In the middle of messing with Typescript

Author: hsubox76

packages/storage-types/index.d.ts

@@ -16,7 +16,6 @@
  */
 
 import { FirebaseApp, FirebaseNamespace } from '@firebase/app-types';
-import { Observer, Unsubscribe } from '@firebase/util';
 
 export interface FullMetadata extends UploadMetadata {
   bucket: string;
@@ -85,15 +84,25 @@ export interface UploadMetadata extends SettableMetadata {
   md5Hash?: string | null;
 }
 
+export type NextFn<T> = (value: T) => void;
+export type ErrorFn = (error: Error | FirebaseStorageError) => void;
+export type CompleteFn = () => void;
+export type Unsubscribe = () => void;
+export interface StorageObserver<T> {
+  next?: NextFn<T> | null;
+  error?: ErrorFn | null;
+  complete?: CompleteFn | null;
+}
+
 export interface UploadTask {
   cancel(): boolean;
   catch(onRejected: (a: Error) => any): Promise<any>;
   on(
     event: TaskEvent,
     nextOrObserver?:
-      | Partial<Observer<UploadTaskSnapshot>>
+      | Partial<StorageObserver<UploadTaskSnapshot>>
       | null
-      | ((a: UploadTaskSnapshot) => any),
+      | ((a: UploadTaskSnapshot) => unknown),
     error?: ((a: Error) => any) | null,
     complete?: Unsubscribe | null
   ): Function;

packages/storage/compat/reference.ts

@@ -28,6 +28,7 @@ import {
   updateMetadata,
   deleteObject
 } from '../src/reference';
+import * as types from '@firebase/storage-types';
 import {
   validate,
   stringSpec,
@@ -36,12 +37,12 @@ import {
   uploadDataSpec
 } from '../src/implementation/args';
 import { Metadata } from '../src/metadata';
-import { UploadTask } from '../src/task';
 import { StringFormat, formatValidator } from '../src/implementation/string';
 import { ListResult, ListOptions } from '../src/list';
+import { UploadTaskCompat } from './task';
 
-export class ReferenceCompat extends Reference {
-  static fromReference(ref: Reference): ReferenceCompat {
+export class ReferenceCompat extends Reference implements types.Reference {
+  static fromReference(ref: Reference): types.Reference {
     return new ReferenceCompat(ref.service, ref.location);
   }
   toString(): string {
@@ -53,7 +54,7 @@ export class ReferenceCompat extends Reference {
    *     appending childPath, removing any duplicate, beginning, or trailing
    *     slashes.
    */
-  child(childPath: string): ReferenceCompat {
+  child(childPath: string): types.Reference {
     validate('child', [stringSpec()], arguments);
     const reference = getChild(this, childPath);
     return ReferenceCompat.fromReference(reference);
@@ -63,7 +64,7 @@ export class ReferenceCompat extends Reference {
    * @return A reference to the parent of the
    *     current object, or null if the current object is the root.
    */
-  get parent(): ReferenceCompat | null {
+  get parent(): types.Reference | null {
     validate('parent', [], arguments);
     const reference = getParent(this);
     if (reference == null) {
@@ -80,11 +81,11 @@ export class ReferenceCompat extends Reference {
    */
   put(
     data: Blob | Uint8Array | ArrayBuffer,
-    metadata: Metadata | null = null
-  ): UploadTask {
+    metadata?: Metadata
+  ): UploadTaskCompat {
     validate('put', [uploadDataSpec(), metadataSpec(true)], arguments);
     this.throwIfRoot_('put');
-    return uploadBytes(this, data, metadata);
+    return uploadBytes(this, data, metadata) as UploadTaskCompat;
   }
   /**
    * Uploads a string to this object's location.
@@ -97,7 +98,7 @@ export class ReferenceCompat extends Reference {
     value: string,
     format: StringFormat = StringFormat.RAW,
     metadata?: Metadata
-  ): UploadTask {
+  ): UploadTaskCompat {
     validate(
       'putString',
       [stringSpec(), stringSpec(formatValidator, true), metadataSpec(true)],

packages/storage/compat/task.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { UploadTask } from '../src/task';
+import { UploadTaskSnapshotCompat } from './tasksnapshot';
+import { UploadTaskSnapshot } from '../src/tasksnapshot';
+import {
+  taskStateFromInternalTaskState,
+  TaskEvent
+} from '../src/implementation/taskenums';
+import { ReferenceCompat } from './reference';
+import { FbsBlob } from '../src/implementation/blob';
+import { Metadata } from '../src/metadata';
+import { ErrorFn, CompleteFn, Unsubscribe, Subscribe } from '@firebase/util';
+import * as types from '@firebase/storage-types';
+import { StorageObserver } from '../src/implementation/observer';
+
+export class UploadTaskCompat extends UploadTask<UploadTaskSnapshotCompat>
+  implements types.UploadTask {
+  constructor(
+    private refCompat_: ReferenceCompat,
+    blob: FbsBlob,
+    metadata: Metadata | null = null
+  ) {
+    super(refCompat_, blob, metadata);
+  }
+  get snapshot(): UploadTaskSnapshotCompat {
+    const externalState = taskStateFromInternalTaskState(this.state_);
+    return new UploadTaskSnapshotCompat(
+      this.transferred_,
+      this.blob_.size(),
+      externalState,
+      this.metadata_,
+      this,
+      this.refCompat_
+    );
+  }
+  on(
+    type: TaskEvent,
+    nextOrObserver?:
+      | Partial<StorageObserver<UploadTaskSnapshotCompat>>
+      | null
+      | ((a: UploadTaskSnapshotCompat) => unknown),
+    error?: ErrorFn | null,
+    completed?: CompleteFn | null
+  ): Unsubscribe | Subscribe<UploadTaskSnapshotCompat> {
+    const castNextOrObserver = nextOrObserver as
+      | Partial<StorageObserver<UploadTaskSnapshot>>
+      | null
+      | ((a: UploadTaskSnapshot) => unknown);
+    return super.on(type, castNextOrObserver, error, completed) as
+      | Unsubscribe
+      | Subscribe<types.UploadTaskSnapshot>;
+  }
+}

packages/storage/compat/tasksnapshot.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { TaskState } from '../src/implementation/taskenums';
+import { Metadata } from '../src/metadata';
+import { ReferenceCompat } from './reference';
+import { UploadTaskCompat } from './task';
+
+export class UploadTaskSnapshotCompat {
+  constructor(
+    readonly bytesTransferred: number,
+    readonly totalBytes: number,
+    readonly state: TaskState,
+    readonly metadata: Metadata | null,
+    readonly task: UploadTaskCompat,
+    readonly ref: ReferenceCompat
+  ) {}
+}

packages/storage/src/reference.ts

@@ -36,9 +36,9 @@ import {
 import * as type from './implementation/type';
 import { Metadata } from './metadata';
 import { StorageService } from './service';
-import { UploadTask } from './task';
 import { ListOptions, ListResult } from './list';
 import { uploadDataSpec, listOptionSpec } from './implementation/args';
+import { UploadTask } from './task';
 
 /**
  * Provides methods to interact with a bucket in the Firebase Storage service.

packages/storage/src/task.ts

@@ -55,26 +55,26 @@ import { Reference } from './reference';
  * Represents a blob being uploaded. Can be used to pause/resume/cancel the
  * upload and manage callbacks for various events.
  */
-export class UploadTask {
+export class UploadTask<T extends UploadTaskSnapshot> {
   private ref_: Reference;
-  private blob_: FbsBlob;
-  private metadata_: Metadata | null;
+  blob_: FbsBlob;
+  metadata_: Metadata | null;
   private mappings_: fbsMetadata.Mappings;
-  private transferred_: number = 0;
+  transferred_: number = 0;
   private needToFetchStatus_: boolean = false;
   private needToFetchMetadata_: boolean = false;
-  private observers_: Array<Observer<UploadTaskSnapshot>> = [];
+  private observers_: Array<StorageObserver<T>> = [];
   private resumable_: boolean;
-  private state_: InternalTaskState;
+  state_: InternalTaskState;
   private error_: Error | null = null;
   private uploadUrl_: string | null = null;
   private request_: Request<unknown> | null = null;
   private chunkMultiplier_: number = 1;
   private errorHandler_: (p1: FirebaseStorageError) => void;
   private metadataErrorHandler_: (p1: FirebaseStorageError) => void;
-  private resolve_: ((p1: UploadTaskSnapshot) => void) | null = null;
+  private resolve_: ((p1: T) => void) | null = null;
   private reject_: ((p1: Error) => void) | null = null;
-  private promise_: Promise<UploadTaskSnapshot>;
+  private promise_: Promise<T>;
 
   /**
    * @param ref The firebaseStorage.Reference object this task came
@@ -425,7 +425,7 @@ export class UploadTask {
     }
   }
 
-  get snapshot(): UploadTaskSnapshot {
+  get snapshot(): T {
     const externalState = taskStateFromInternalTaskState(this.state_);
     return new UploadTaskSnapshot(
       this.transferred_,
@@ -434,7 +434,7 @@ export class UploadTask {
       this.metadata_,
       this,
       this.ref_
-    );
+    ) as T;
   }
 
   /**
@@ -443,13 +443,10 @@ export class UploadTask {
    */
   on(
     type: TaskEvent,
-    nextOrObserver?:
-      | NextFn<UploadTaskSnapshot>
-      | StorageObserver<UploadTaskSnapshot>
-      | null,
+    nextOrObserver?: Partial<StorageObserver<T>> | null | ((a: T) => unknown),
     error?: ErrorFn | null,
     completed?: CompleteFn | null
-  ): Unsubscribe | Subscribe<UploadTaskSnapshot> {
+  ): Unsubscribe | Subscribe<T> {
     function typeValidator(): void {
       if (type !== TaskEvent.STATE_CHANGED) {
         throw `Expected one of the event types: [${TaskEvent.STATE_CHANGED}].`;
@@ -490,14 +487,9 @@ export class UploadTask {
     validate('on', specs, arguments);
     const self = this;
 
-    function makeBinder(
-      specs: ArgSpec[] | null
-    ): Subscribe<UploadTaskSnapshot> {
+    function makeBinder(specs: ArgSpec[] | null): Subscribe<T> {
       function binder(
-        nextOrObserver?:
-          | NextFn<UploadTaskSnapshot>
-          | StorageObserver<UploadTaskSnapshot>
-          | null,
+        nextOrObserver?: NextFn<T> | StorageObserver<T> | null,
         error?: ErrorFn | null,
         complete?: CompleteFn | null
       ): () => void {
@@ -544,7 +536,7 @@ export class UploadTask {
    */
   then<U>(
     onFulfilled?: ((value: UploadTaskSnapshot) => U | Promise<U>) | null,
-    onRejected?: ((error: Error) => U | Promise<U>) | null
+    onRejected?: ((error: FirebaseStorageError) => U | Promise<U>) | null
   ): Promise<U> {
     // These casts are needed so that TypeScript can infer the types of the
     // resulting Promise.
@@ -557,22 +549,24 @@ export class UploadTask {
   /**
    * Equivalent to calling `then(null, onRejected)`.
    */
-  catch<T>(onRejected: (p1: Error) => T | Promise<T>): Promise<T> {
+  catch<T>(
+    onRejected: (p1: FirebaseStorageError) => T | Promise<T>
+  ): Promise<T> {
     return this.then(null, onRejected);
   }
 
   /**
    * Adds the given observer.
    */
-  private addObserver_(observer: Observer<UploadTaskSnapshot>): void {
+  private addObserver_(observer: Observer<T>): void {
     this.observers_.push(observer);
     this.notifyObserver_(observer);
   }
 
   /**
    * Removes the given observer.
    */
-  private removeObserver_(observer: Observer<UploadTaskSnapshot>): void {
+  private removeObserver_(observer: Observer<T>): void {
     const i = this.observers_.indexOf(observer);
     if (i !== -1) {
       this.observers_.splice(i, 1);
@@ -610,7 +604,7 @@ export class UploadTask {
     }
   }
 
-  private notifyObserver_(observer: Observer<UploadTaskSnapshot>): void {
+  private notifyObserver_(observer: Observer<T>): void {
     const externalState = taskStateFromInternalTaskState(this.state_);
     switch (externalState) {
       case TaskState.RUNNING: