@react-native-firebase/storage 24.1.1 → 25.0.1

package/lib/{StorageReference.js → StorageReference.ts}

@@ -29,15 +29,28 @@ import {
   pathParent,
   ReferenceBase,
   toFilePath,
+  isModularCall,
 } from '@react-native-firebase/app/dist/module/common';
 import StorageDownloadTask from './StorageDownloadTask';
 import StorageListResult, { provideStorageReferenceClass } from './StorageListResult';
 import { StringFormat } from './StorageStatics';
 import StorageUploadTask from './StorageUploadTask';
 import { validateMetadata } from './utils';
-
-export default class StorageReference extends ReferenceBase {
-  constructor(storage, path) {
+import type {
+  StorageReference,
+  SettableMetadata,
+  UploadMetadata,
+  ListOptions,
+  FullMetadata,
+  Task,
+  FirebaseStorage,
+} from './types/storage';
+import type { ListResultInternal, StorageInternal } from './types/internal';
+
+export default class Reference extends ReferenceBase implements StorageReference {
+  _storage: StorageInternal;
+
+  constructor(storage: StorageInternal, path: string) {
     super(path);
     this._storage = storage;
   }
@@ -45,145 +58,162 @@ export default class StorageReference extends ReferenceBase {
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#bucket
    */
-  get bucket() {
-    return this._storage._customUrlOrRegion.replace('gs://', '');
+  get bucket(): string {
+    return this._storage._customUrlOrRegion!.replace('gs://', '');
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#fullPath
    */
-  get fullPath() {
+  get fullPath(): string {
     return this.path;
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#name
    */
-  get name() {
+  get name(): string {
     return pathLastComponent(this.path);
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#parent
    */
-  get parent() {
+  get parent(): StorageReference | null {
     const parentPath = pathParent(this.path);
     if (parentPath === null) {
       return parentPath;
     }
-    return new StorageReference(this._storage, parentPath);
+    return new Reference(this._storage, parentPath);
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#root
    */
-  get root() {
-    return new StorageReference(this._storage, '/');
+  get root(): StorageReference {
+    return new Reference(this._storage, '/');
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#storage
    */
-  get storage() {
+  get storage(): FirebaseStorage {
     return this._storage;
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#child
    */
-  child(path) {
+  child(path: string): StorageReference {
     const childPath = pathChild(this.path, path);
-    return new StorageReference(this._storage, childPath);
+    return new Reference(this._storage, childPath);
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#delete
    */
-  delete() {
+  delete(): Promise<void> {
     return this._storage.native.delete(this.toString());
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#getDownloadURL
    */
-  getDownloadURL() {
+  getDownloadURL(): Promise<string> {
     return this._storage.native.getDownloadURL(this.toString());
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#getMetadata
    */
-  getMetadata() {
+  getMetadata(): Promise<FullMetadata> {
     return this._storage.native.getMetadata(this.toString());
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#list
    */
-  list(options) {
+  list(options?: ListOptions): Promise<StorageListResult> {
     if (!isUndefined(options) && !isObject(options)) {
       throw new Error(
         "firebase.storage.StorageReference.list(*) 'options' expected an object value.",
       );
     }
 
-    const listOptions = {
+    const listOptions: { maxResults: number; pageToken?: string } = {
       maxResults: 1000,
     };
 
+    const isModular = isModularCall(arguments);
+
     if (options) {
       if (hasOwnProperty(options, 'maxResults')) {
-        if (!isNumber(options.maxResults) || !isInteger(options.maxResults)) {
-          throw new Error(
-            "firebase.storage.StorageReference.list(*) 'options.maxResults' expected a number value.",
-          );
-        }
-
-        if (options.maxResults < 1 || options.maxResults > 1000) {
-          throw new Error(
-            "firebase.storage.StorageReference.list(*) 'options.maxResults' expected a number value between 1-1000.",
-          );
+        const maxResults = options.maxResults;
+        // Modular typings allow `null` for omission - ignore safely.
+        if (isModular && (maxResults === null || isUndefined(maxResults))) {
+          // no-op (keep default)
+        } else {
+          if (!isNumber(maxResults) || !isInteger(maxResults)) {
+            throw new Error(
+              "firebase.storage.StorageReference.list(*) 'options.maxResults' expected a number value.",
+            );
+          }
+
+          if (maxResults < 1 || maxResults > 1000) {
+            throw new Error(
+              "firebase.storage.StorageReference.list(*) 'options.maxResults' expected a number value between 1-1000.",
+            );
+          }
+
+          listOptions.maxResults = maxResults;
         }
-
-        listOptions.maxResults = options.maxResults;
       }
 
-      if (options.pageToken) {
-        if (!isString(options.pageToken)) {
-          throw new Error(
-            "firebase.storage.StorageReference.list(*) 'options.pageToken' expected a string value.",
-          );
+      if (hasOwnProperty(options, 'pageToken')) {
+        const pageToken = options.pageToken;
+        // Modular typings allow `null` for omission - ignore safely.
+        if (isModular && (pageToken === null || isUndefined(pageToken))) {
+          // no-op
+        } else if (!isUndefined(pageToken) && pageToken !== null) {
+          if (!isString(pageToken)) {
+            throw new Error(
+              "firebase.storage.StorageReference.list(*) 'options.pageToken' expected a string value.",
+            );
+          }
+
+          listOptions.pageToken = pageToken;
         }
-
-        listOptions.pageToken = options.pageToken;
       }
     }
 
     return this._storage.native
       .list(this.toString(), listOptions)
-      .then(data => new StorageListResult(this._storage, data));
+      .then((data: ListResultInternal) => new StorageListResult(this._storage, data));
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#listAll
    */
-  listAll() {
+  listAll(): Promise<StorageListResult> {
     return this._storage.native
       .listAll(this.toString())
-      .then(data => new StorageListResult(this._storage, data));
+      .then((data: ListResultInternal) => new StorageListResult(this._storage, data));
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#put
    */
-  put(data, metadata) {
-    if (!isUndefined(metadata)) {
-      validateMetadata(metadata, false);
-    }
+  put(data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata): Task {
+    const validatedMetadata = isUndefined(metadata) ? metadata : validateMetadata(metadata, false);
 
     return new StorageUploadTask(this, task =>
       Base64.fromData(data).then(({ string, format }) => {
-        const { _string, _format, _metadata } = this._updateString(string, format, metadata, false);
+        const { _string, _format, _metadata } = this._updateString(
+          string as string,
+          format,
+          validatedMetadata,
+          false,
+        );
         return this._storage.native.putString(
           this.toString(),
           _string,
@@ -198,7 +228,11 @@ export default class StorageReference extends ReferenceBase {
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#putString
    */
-  putString(string, format = StringFormat.RAW, metadata) {
+  putString(
+    string: string,
+    format: (typeof StringFormat)[keyof typeof StringFormat] = StringFormat.RAW,
+    metadata?: UploadMetadata,
+  ): Task {
     const { _string, _format, _metadata } = this._updateString(string, format, metadata, false);
 
     return new StorageUploadTask(this, task =>
@@ -209,7 +243,7 @@ export default class StorageReference extends ReferenceBase {
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#fullPath
    */
-  toString() {
+  toString(): string {
     if (this.path.length <= 1) {
       return `${this._storage._customUrlOrRegion}`;
     }
@@ -220,9 +254,9 @@ export default class StorageReference extends ReferenceBase {
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference#updateMetadata
    */
-  updateMetadata(metadata) {
-    validateMetadata(metadata);
-    return this._storage.native.updateMetadata(this.toString(), metadata);
+  updateMetadata(metadata: SettableMetadata): Promise<FullMetadata> {
+    const validatedMetadata = validateMetadata(metadata);
+    return this._storage.native.updateMetadata(this.toString(), validatedMetadata);
   }
 
   /* ----------------------------------------
@@ -232,7 +266,7 @@ export default class StorageReference extends ReferenceBase {
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference
    */
-  writeToFile(filePath) {
+  writeToFile(filePath: string): Task {
     if (!isString(filePath)) {
       throw new Error(
         "firebase.storage.StorageReference.writeToFile(*) 'filePath' expects a string value.",
@@ -247,10 +281,8 @@ export default class StorageReference extends ReferenceBase {
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Reference
    */
-  putFile(filePath, metadata) {
-    if (!isUndefined(metadata)) {
-      validateMetadata(metadata, false);
-    }
+  putFile(filePath: string, metadata?: UploadMetadata): Task {
+    const validatedMetadata = isUndefined(metadata) ? metadata : validateMetadata(metadata, false);
 
     if (!isString(filePath)) {
       throw new Error(
@@ -259,11 +291,21 @@ export default class StorageReference extends ReferenceBase {
     }
 
     return new StorageUploadTask(this, task =>
-      this._storage.native.putFile(this.toString(), toFilePath(filePath), metadata, task._id),
+      this._storage.native.putFile(
+        this.toString(),
+        toFilePath(filePath),
+        validatedMetadata,
+        task._id,
+      ),
     );
   }
 
-  _updateString(string, format, metadata, update = false) {
+  _updateString(
+    string: string,
+    format: (typeof StringFormat)[keyof typeof StringFormat],
+    metadata: UploadMetadata | undefined,
+    update = false,
+  ): { _string: string; _format: string; _metadata: UploadMetadata | undefined } {
     if (!isString(string)) {
       throw new Error(
         "firebase.storage.StorageReference.putString(*, _, _) 'string' expects a string value.",
@@ -279,7 +321,7 @@ export default class StorageReference extends ReferenceBase {
     }
 
     if (!isUndefined(metadata)) {
-      validateMetadata(metadata, update);
+      metadata = validateMetadata(metadata, update) as UploadMetadata;
     }
 
     let _string = string;
@@ -301,7 +343,7 @@ export default class StorageReference extends ReferenceBase {
         if (isUndefined(metadata)) {
           _metadata = {};
         }
-        _metadata.contentType = mediaType;
+        _metadata!.contentType = mediaType;
         _string = base64String;
         _format = StringFormat.BASE64;
       }
@@ -310,4 +352,4 @@ export default class StorageReference extends ReferenceBase {
   }
 }
 
-provideStorageReferenceClass(StorageReference);
+provideStorageReferenceClass(Reference);

package/lib/StorageStatics.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ *
+ */
+
+// Runtime constants live in `types/storage.ts` (alongside their derived-union types).
+export { StringFormat, TaskEvent, TaskState } from './types/storage';

package/lib/StorageTask.ts

@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 { isFunction, isNull, isObject } from '@react-native-firebase/app/dist/module/common';
+import type { EmitterSubscription } from 'react-native';
+import { TaskEvent } from './StorageStatics';
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
+import type {
+  FullMetadata,
+  StorageObserver,
+  StorageReference,
+  Subscribe,
+  Task,
+  TaskSnapshot,
+  Unsubscribe,
+} from './types/storage';
+import type { StorageReferenceInternal, StorageInternal } from './types/internal';
+
+let TASK_ID = 0;
+
+type TaskEventType = (typeof TaskEvent)[keyof typeof TaskEvent];
+
+function createEmptyMetadata(ref: StorageReference): FullMetadata {
+  return {
+    bucket: ref.bucket,
+    fullPath: ref.fullPath,
+    generation: '',
+    metageneration: '',
+    name: ref.name,
+    size: 0,
+    timeCreated: '',
+    updated: '',
+    downloadTokens: undefined,
+    ref,
+  };
+}
+
+function wrapErrorEventListener(
+  listenerFn: ((error: ReactNativeFirebase.NativeFirebaseError) => void) | null | undefined,
+  unsubscribe: (() => void) | null | undefined,
+): (snapshot: TaskSnapshot) => void {
+  return (snapshot: TaskSnapshot) => {
+    if (unsubscribe) {
+      setTimeout(() => unsubscribe(), 0);
+    } // 1 frame = 16ms, pushing to next frame
+    if (isFunction(listenerFn)) {
+      const errorEvent = snapshot as TaskSnapshot & {
+        error?: ReactNativeFirebase.NativeFirebaseError;
+      };
+      if (errorEvent.error) {
+        listenerFn(errorEvent.error);
+      }
+    }
+  };
+}
+
+function wrapSnapshotEventListener(
+  task: StorageTask,
+  listenerFn: ((snapshot: TaskSnapshot) => unknown) | null | undefined,
+  unsubscribe: (() => void) | null | undefined,
+): ((snapshot: TaskSnapshot) => void) | null {
+  if (!isFunction(listenerFn)) {
+    return null;
+  }
+  return (snapshot: TaskSnapshot) => {
+    if (unsubscribe) {
+      setTimeout(() => unsubscribe(), 0);
+    } // 1 frame = 16ms, pushing to next frame
+    if (isFunction(listenerFn)) {
+      const taskSnapshot = Object.assign({}, snapshot);
+      taskSnapshot.task = task as Task;
+      taskSnapshot.ref = task._ref;
+
+      if (!taskSnapshot.metadata) {
+        taskSnapshot.metadata = createEmptyMetadata(task._ref);
+      } else {
+        if (!taskSnapshot.metadata.generation) taskSnapshot.metadata.generation = '';
+        if (!taskSnapshot.metadata.bucket) taskSnapshot.metadata.bucket = task._ref.bucket;
+        if (!taskSnapshot.metadata.metageneration) taskSnapshot.metadata.metageneration = '';
+        if (!taskSnapshot.metadata.fullPath) taskSnapshot.metadata.fullPath = task._ref.fullPath;
+        if (!taskSnapshot.metadata.name) taskSnapshot.metadata.name = task._ref.name;
+        if (!taskSnapshot.metadata.ref) taskSnapshot.metadata.ref = task._ref;
+      }
+
+      Object.freeze(taskSnapshot);
+      task._snapshot = taskSnapshot;
+
+      listenerFn(taskSnapshot);
+    }
+  };
+}
+
+function addTaskEventListener(
+  task: StorageTask,
+  eventName: string,
+  listener: (snapshot: TaskSnapshot) => void,
+): EmitterSubscription {
+  let _eventName = eventName;
+  if (_eventName !== TaskEvent.STATE_CHANGED) {
+    _eventName = `${task._type}_${eventName}`;
+  }
+
+  return task._storage.emitter.addListener(
+    task._storage.eventNameForApp(task._id, _eventName),
+    listener,
+  );
+}
+
+function subscribeToEvents(
+  task: StorageTask,
+  nextOrObserver?: ((snapshot: TaskSnapshot) => unknown) | StorageObserver<TaskSnapshot> | null,
+  error?: ((error: ReactNativeFirebase.NativeFirebaseError) => unknown) | null,
+  complete?: (() => unknown) | null,
+): () => void {
+  let _error: ((snapshot: TaskSnapshot) => void) | undefined;
+  let _errorSubscription: EmitterSubscription | undefined;
+
+  let _next: ((snapshot: TaskSnapshot) => void) | null | undefined;
+  let _nextSubscription: EmitterSubscription | undefined;
+
+  let _complete: ((snapshot: TaskSnapshot) => void) | null | undefined;
+  let _completeSubscription: EmitterSubscription | undefined;
+
+  const unsubscribe = () => {
+    if (_nextSubscription) {
+      _nextSubscription.remove();
+    }
+    if (_errorSubscription) {
+      _errorSubscription.remove();
+    }
+    if (_completeSubscription) {
+      _completeSubscription.remove();
+    }
+  };
+
+  if (isFunction(nextOrObserver)) {
+    _error = wrapErrorEventListener(error, unsubscribe);
+    _next = wrapSnapshotEventListener(task, nextOrObserver, null);
+    _complete = wrapSnapshotEventListener(task, complete, unsubscribe);
+  } else if (isObject(nextOrObserver)) {
+    const observer = nextOrObserver as StorageObserver<TaskSnapshot>;
+    _error = wrapErrorEventListener(observer.error, unsubscribe);
+    _next = wrapSnapshotEventListener(task, observer.next, null);
+    _complete = wrapSnapshotEventListener(task, observer.complete, unsubscribe);
+  } else if (isNull(nextOrObserver)) {
+    _error = wrapErrorEventListener(error, unsubscribe);
+    _complete = wrapSnapshotEventListener(task, complete, unsubscribe);
+  } else {
+    throw new Error(
+      "firebase.storage.StorageTask.on(*, _) 'nextOrObserver' must be a Function, an Object or Null.",
+    );
+  }
+
+  if (_next) {
+    _nextSubscription = addTaskEventListener(task, TaskEvent.STATE_CHANGED, _next);
+  }
+
+  if (_error) {
+    _errorSubscription = addTaskEventListener(task, 'failure', _error);
+  }
+
+  if (_complete) {
+    _completeSubscription = addTaskEventListener(task, 'success', _complete);
+  }
+
+  return unsubscribe;
+}
+
+export default class StorageTask {
+  _type: string;
+  _id: number;
+  _promise: Promise<TaskSnapshot> | null;
+  _ref: StorageReference;
+  _beginTask: (task: StorageTask) => Promise<TaskSnapshot>;
+  _storage: StorageInternal;
+  _snapshot: TaskSnapshot;
+
+  constructor(
+    type: string,
+    storageRef: StorageReference,
+    beginTaskFn: (task: StorageTask) => Promise<TaskSnapshot>,
+  ) {
+    this._type = type;
+    this._id = TASK_ID++;
+    this._promise = null;
+    this._ref = storageRef;
+    this._beginTask = beginTaskFn;
+    this._storage = (storageRef as StorageReferenceInternal)._storage;
+    this._snapshot = {
+      bytesTransferred: 0,
+      totalBytes: 0,
+      state: 'running',
+      metadata: createEmptyMetadata(storageRef),
+      task: this as Task,
+      ref: storageRef,
+    };
+  }
+
+  /**
+   * @url https://firebase.google.com/docs/reference/js/firebase.storage.UploadTask#then
+   */
+  get then(): (
+    onFulfilled?: ((snapshot: TaskSnapshot) => TaskSnapshot) | null,
+    onRejected?: ((error: ReactNativeFirebase.NativeFirebaseError) => any) | null,
+  ) => Promise<TaskSnapshot> {
+    if (!this._promise) {
+      this._promise = this._beginTask(this);
+    }
+
+    const promise = this._promise;
+    return (
+      onFulfilled?: ((snapshot: TaskSnapshot) => any) | null,
+      onRejected?: ((error: ReactNativeFirebase.NativeFirebaseError) => any) | null,
+    ) => {
+      return new Promise((resolve, reject) => {
+        promise
+          .then((response: any) => {
+            this._snapshot = {
+              ...response,
+              ref: this._ref,
+              task: this as Task,
+              state: response?.state ?? this._snapshot.state,
+              metadata: response?.metadata ? response.metadata : createEmptyMetadata(this._ref),
+            } as TaskSnapshot;
+            if (onFulfilled) {
+              resolve(onFulfilled(this._snapshot!));
+            } else {
+              resolve(response);
+            }
+          })
+          .catch((error: ReactNativeFirebase.NativeFirebaseError) => {
+            if (onRejected) {
+              resolve(onRejected(error));
+            } else {
+              reject(error);
+            }
+          });
+      });
+    };
+  }
+
+  /**
+   * @url https://firebase.google.com/docs/reference/js/firebase.storage.UploadTask#catch
+   */
+  get catch(): (
+    onRejected: (error: ReactNativeFirebase.NativeFirebaseError) => any,
+  ) => Promise<any> {
+    if (!this._promise) {
+      this._promise = this._beginTask(this);
+    }
+    return this._promise!.catch.bind(this._promise);
+  }
+
+  get snapshot(): TaskSnapshot {
+    return this._snapshot;
+  }
+
+  // // NOT on Web SDK
+  // /**
+  //  * @url https://firebase.google.com/docs/reference/js/firebase.storage.UploadTask#finally
+  //  */
+  // get finally() {
+  //   if (!this._promise) this._promise = this._beginTask(this);
+  //   return this._promise.finally.bind(this._promise);
+  // }
+
+  /**
+   * @url https://firebase.google.com/docs/reference/js/firebase.storage.UploadTask#on
+   */
+  on(event: TaskEventType): Subscribe<TaskSnapshot>;
+  on(
+    event: TaskEventType,
+    nextOrObserver?: StorageObserver<TaskSnapshot> | null | ((snapshot: TaskSnapshot) => unknown),
+    error?: ((error: ReactNativeFirebase.NativeFirebaseError) => unknown) | null,
+    complete?: (() => unknown) | null,
+  ): Unsubscribe;
+  on(
+    event: TaskEventType,
+    nextOrObserver?: StorageObserver<TaskSnapshot> | null | ((snapshot: TaskSnapshot) => unknown),
+    error?: ((error: ReactNativeFirebase.NativeFirebaseError) => unknown) | null,
+    complete?: (() => unknown) | null,
+  ): Unsubscribe | Subscribe<TaskSnapshot> {
+    if (event !== TaskEvent.STATE_CHANGED) {
+      throw new Error(
+        `firebase.storage.StorageTask.on event argument must be a string with a value of '${TaskEvent.STATE_CHANGED}'`,
+      );
+    }
+
+    if (!this._promise) {
+      this._promise = this._beginTask(this);
+    }
+
+    // if only event provided return the subscriber function
+    if (!nextOrObserver && !error && !complete) {
+      return ((...args: Parameters<Subscribe<TaskSnapshot>>) =>
+        subscribeToEvents(this, ...args)) as Subscribe<TaskSnapshot>;
+    }
+
+    return subscribeToEvents(this, nextOrObserver, error, complete);
+  }
+
+  /**
+   * @url https://firebase.google.com/docs/reference/js/firebase.storage.UploadTask#pause
+   */
+  pause(): Promise<boolean> {
+    return this._storage.native.setTaskStatus(this._id, 0);
+  }
+
+  /**
+   * @url https://firebase.google.com/docs/reference/js/firebase.storage.UploadTask#pause
+   */
+  resume(): Promise<boolean> {
+    return this._storage.native.setTaskStatus(this._id, 1);
+  }
+
+  /**
+   * @url https://firebase.google.com/docs/reference/js/firebase.storage.UploadTask#cancel
+   */
+  cancel(): Promise<boolean> {
+    return this._storage.native.setTaskStatus(this._id, 2);
+  }
+}