Saving work in progress

Author: hsubox76

packages/storage-types/index.d.ts

@@ -107,7 +107,7 @@ export interface UploadTask {
   on(
     event: TaskEvent,
     nextOrObserver?:
-      | Partial<StorageObserver<UploadTaskSnapshot>>
+      | StorageObserver<UploadTaskSnapshot>
       | null
       | ((a: UploadTaskSnapshot) => unknown),
     error?: ((a: FirebaseStorageError) => any) | null,

packages/storage/compat/index.ts

@@ -43,13 +43,18 @@ function factory(
   url?: string
 ): types.FirebaseStorage {
   // Dependencies
+  // TODO: This should eventually be 'app-compat'
   const app = container.getProvider('app').getImmediate();
   const authProvider = container.getProvider('auth-internal');
 
-  return new StorageServiceCompat(
+  // TODO: get StorageService instance from component framework instead
+  // of creating a new one.
+  const storageServiceCompat: StorageServiceCompat = new StorageServiceCompat(
+    app,
     new StorageService(app, authProvider, new XhrIoPool(), url),
-    ref => new ReferenceCompat(ref)
+    ref => new ReferenceCompat(ref, storageServiceCompat)
   );
+  return storageServiceCompat;
 }
 
 export function registerStorage(instance: _FirebaseNamespace): void {

packages/storage/compat/list.ts

@@ -22,11 +22,11 @@ import { Reference } from '../src/reference';
 
 export class ListResultCompat implements types.ListResult {
   constructor(
-    private readonly delegate: ListResult,
-    private converter: (ref: Reference) => ReferenceCompat
+    private readonly _delegate: ListResult,
+    private _referenceConverter: (ref: Reference) => ReferenceCompat
   ) {}
 
-  prefixes = this.delegate.prefixes.map(v => this.converter(v));
-  items = this.delegate.items.map(v => this.converter(v));
-  nextPageToken = this.delegate.nextPageToken;
+  prefixes = this._delegate.prefixes.map(v => this._referenceConverter(v));
+  items = this._delegate.items.map(v => this._referenceConverter(v));
+  nextPageToken = this._delegate.nextPageToken || null;
 }

packages/storage/compat/reference.ts

@@ -29,102 +29,86 @@ import {
   deleteObject
 } from '../src/reference';
 import * as types from '@firebase/storage-types';
-import {
-  validate,
-  stringSpec,
-  listOptionSpec,
-  metadataSpec,
-  uploadDataSpec
-} from '../src/implementation/args';
 import { Metadata } from '../src/metadata';
-import { StringFormat, formatValidator } from '../src/implementation/string';
+import { StringFormat } from '../src/implementation/string';
 import { ListOptions } from '../src/list';
 import { UploadTaskCompat } from './task';
 import { ListResultCompat } from './list';
 import { StorageServiceCompat } from './service';
 import { invalidRootOperation } from '../src/implementation/error';
 
 export class ReferenceCompat implements types.Reference {
-  constructor(private readonly delegate: Reference) {}
+  constructor(
+    private readonly _delegate: Reference,
+    public storage: StorageServiceCompat
+  ) {}
 
-  storage = new StorageServiceCompat(
-    this.delegate.storage,
-    ref => new ReferenceCompat(ref)
-  ) as types.FirebaseStorage;
-  name = this.delegate.name;
-  bucket = this.delegate.bucket;
-  fullPath = this.delegate.fullPath;
+  name = this._delegate.name;
+  bucket = this._delegate.bucket;
+  fullPath = this._delegate.fullPath;
 
   toString(): string {
-    validate('toString', [], arguments);
-    return this.delegate.toString();
+    return this._delegate.toString();
   }
 
   /**
-   * @return A reference to the object obtained by
+   * @returns A reference to the object obtained by
    * appending childPath, removing any duplicate, beginning, or trailing
    * slashes.
    */
   child(childPath: string): types.Reference {
-    validate('child', [stringSpec()], arguments);
-    const reference = getChild(this.delegate, childPath);
-    return new ReferenceCompat(reference);
+    const reference = getChild(this._delegate, childPath);
+    return new ReferenceCompat(reference, this.storage);
   }
 
   get root(): types.Reference {
-    return new ReferenceCompat(this.delegate.root) as types.Reference;
+    return new ReferenceCompat(this._delegate.root, this.storage);
   }
 
   /**
-   * @return A reference to the parent of the
+   * @returns A reference to the parent of the
    * current object, or null if the current object is the root.
    */
   get parent(): types.Reference | null {
-    const reference = getParent(this.delegate);
+    const reference = getParent(this._delegate);
     if (reference == null) {
       return null;
     }
-    return new ReferenceCompat(reference);
+    return new ReferenceCompat(reference, this.storage);
   }
 
   /**
    * Uploads a blob to this object's location.
-   * @param data The blob to upload.
-   * @return An UploadTask that lets you control and
+   * @param data - The blob to upload.
+   * @returns An UploadTask that lets you control and
    * observe the upload.
    */
   put(
     data: Blob | Uint8Array | ArrayBuffer,
     metadata?: Metadata
   ): types.UploadTask {
-    validate('put', [uploadDataSpec(), metadataSpec(true)], arguments);
     this._throwIfRoot('put');
     return new UploadTaskCompat(
-      uploadBytes(this.delegate, data, metadata),
+      uploadBytes(this._delegate, data, metadata),
       this
     );
   }
 
   /**
    * Uploads a string to this object's location.
-   * @param value The string to upload.
-   * @param format The format of the string to upload.
-   * @return An UploadTask that lets you control and
+   * @param value - The string to upload.
+   * @param format - The format of the string to upload.
+   * @returns An UploadTask that lets you control and
    * observe the upload.
    */
   putString(
     value: string,
     format: StringFormat = StringFormat.RAW,
     metadata?: Metadata
   ): types.UploadTask {
-    validate(
-      'putString',
-      [stringSpec(), stringSpec(formatValidator, true), metadataSpec(true)],
-      arguments
-    );
     this._throwIfRoot('putString');
     return new UploadTaskCompat(
-      uploadString(this.delegate, value, format, metadata),
+      uploadString(this._delegate, value, format, metadata),
       this
     );
   }
@@ -141,15 +125,15 @@ export class ReferenceCompat implements types.Reference {
    * Warning: listAll may potentially consume too many resources if there are
    * too many results.
    *
-   * @return A Promise that resolves with all the items and prefixes under
+   * @returns A Promise that resolves with all the items and prefixes under
    *  the current storage reference. `prefixes` contains references to
    *  sub-directories and `items` contains references to objects in this
    *  folder. `nextPageToken` is never returned.
    */
   listAll(): Promise<types.ListResult> {
-    validate('listAll', [], arguments);
-    return listAll(this.delegate).then(
-      r => new ListResultCompat(r, ref => new ReferenceCompat(ref))
+    return listAll(this._delegate).then(
+      r =>
+        new ListResultCompat(r, ref => new ReferenceCompat(ref, this.storage))
     );
   }
 
@@ -159,24 +143,23 @@ export class ReferenceCompat implements types.Reference {
    * List API is only available for Firebase Rules Version 2.
    *
    * GCS is a key-blob store. Firebase Storage imposes the semantic of '/'
-   * delimited folder structure.
-   * Refer to GCS's List API if you want to learn more.
+   * delimited folder structure. Refer to GCS's List API if you want to learn more.
    *
    * To adhere to Firebase Rules's Semantics, Firebase Storage does not
    * support objects whose paths end with "/" or contain two consecutive
    * "/"s. Firebase Storage List API will filter these unsupported objects.
    * list() may fail if there are too many unsupported objects in the bucket.
    *
-   * @param options See ListOptions for details.
-   * @return A Promise that resolves with the items and prefixes.
+   * @param options - See ListOptions for details.
+   * @returns A Promise that resolves with the items and prefixes.
    * `prefixes` contains references to sub-folders and `items`
    * contains references to objects in this folder. `nextPageToken`
    * can be used to get the rest of the results.
    */
   list(options?: ListOptions | null): Promise<types.ListResult> {
-    validate('list', [listOptionSpec(true)], arguments);
-    return list(this.delegate, options).then(
-      r => new ListResultCompat(r, ref => new ReferenceCompat(ref))
+    return list(this._delegate, options).then(
+      r =>
+        new ListResultCompat(r, ref => new ReferenceCompat(ref, this.storage))
     );
   }
 
@@ -186,45 +169,41 @@ export class ReferenceCompat implements types.Reference {
    * rejected.
    */
   getMetadata(): Promise<Metadata> {
-    validate('getMetadata', [], arguments);
-    return getMetadata(this.delegate);
+    return getMetadata(this._delegate);
   }
 
   /**
    * Updates the metadata for this object.
-   * @param metadata The new metadata for the object.
+   * @param metadata - The new metadata for the object.
    * Only values that have been explicitly set will be changed. Explicitly
    * setting a value to null will remove the metadata.
-   * @return A promise that resolves
+   * @returns A promise that resolves
    * with the new metadata for this object.
    * @see firebaseStorage.Reference.prototype.getMetadata
    */
   updateMetadata(metadata: Metadata): Promise<Metadata> {
-    validate('updateMetadata', [metadataSpec()], arguments);
-    return updateMetadata(this.delegate, metadata);
+    return updateMetadata(this._delegate, metadata);
   }
 
   /**
-   * @return A promise that resolves with the download
+   * @returns A promise that resolves with the download
    * URL for this object.
    */
   getDownloadURL(): Promise<string> {
-    validate('getDownloadURL', [], arguments);
-    return getDownloadURL(this.delegate);
+    return getDownloadURL(this._delegate);
   }
 
   /**
    * Deletes the object at this location.
-   * @return A promise that resolves if the deletion succeeds.
+   * @returns A promise that resolves if the deletion succeeds.
    */
   delete(): Promise<void> {
-    validate('delete', [], arguments);
     this._throwIfRoot('delete');
-    return deleteObject(this.delegate);
+    return deleteObject(this._delegate);
   }
 
   private _throwIfRoot(name: string): void {
-    if (this.delegate.location.path === '') {
+    if (this._delegate.location.path === '') {
       throw invalidRootOperation(name);
     }
   }