@firebase/storage 0.8.3 → 0.8.4-canary.1048c4f2d

package/dist/index.cjs.js

@@ -4,39 +4,13 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var app = require('@firebase/app');
 var util = require('@firebase/util');
-var nodeFetch = require('node-fetch');
 var component = require('@firebase/component');
+var nodeFetch = require('node-fetch');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var nodeFetch__default = /*#__PURE__*/_interopDefaultLegacy(nodeFetch);
 
-/**
- * @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.
- */
-/**
- * Error codes for requests made by the the XhrIo wrapper.
- */
-var ErrorCode;
-(function (ErrorCode) {
-    ErrorCode[ErrorCode["NO_ERROR"] = 0] = "NO_ERROR";
-    ErrorCode[ErrorCode["NETWORK_ERROR"] = 1] = "NETWORK_ERROR";
-    ErrorCode[ErrorCode["ABORT"] = 2] = "ABORT";
-})(ErrorCode || (ErrorCode = {}));
-
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -209,120 +183,6 @@ function internalError(message) {
     throw new StorageError("internal-error" /* INTERNAL_ERROR */, 'Internal error: ' + message);
 }
 
-/**
- * @license
- * Copyright 2021 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.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const fetch = nodeFetch__default['default'];
-/**
- * Network layer that works in Node.
- *
- * This network implementation should not be used in browsers as it does not
- * support progress updates.
- */
-class FetchConnection {
-    constructor() {
-        this.sent_ = false;
-        this.errorCode_ = ErrorCode.NO_ERROR;
-    }
-    send(url, method, body, headers) {
-        if (this.sent_) {
-            throw internalError('cannot .send() more than once');
-        }
-        this.sent_ = true;
-        return fetch(url, {
-            method,
-            headers: headers || {},
-            body
-        })
-            .then(resp => {
-            this.headers_ = resp.headers;
-            this.statusCode_ = resp.status;
-            return resp.text();
-        })
-            .then(body => {
-            this.body_ = body;
-        });
-    }
-    getErrorCode() {
-        if (this.errorCode_ === undefined) {
-            throw internalError('cannot .getErrorCode() before receiving response');
-        }
-        return this.errorCode_;
-    }
-    getStatus() {
-        if (this.statusCode_ === undefined) {
-            throw internalError('cannot .getStatus() before receiving response');
-        }
-        return this.statusCode_;
-    }
-    getResponseText() {
-        if (this.body_ === undefined) {
-            throw internalError('cannot .getResponseText() before receiving response');
-        }
-        return this.body_;
-    }
-    abort() {
-        // Not supported
-    }
-    getResponseHeader(header) {
-        if (!this.headers_) {
-            throw internalError('cannot .getResponseText() before receiving response');
-        }
-        return this.headers_.get(header);
-    }
-    addUploadProgressListener(listener) {
-        // Not supported
-    }
-    /**
-     * @override
-     */
-    removeUploadProgressListener(listener) {
-        // Not supported
-    }
-}
-function newConnection() {
-    return new FetchConnection();
-}
-
-/**
- * @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.
- */
-/**
- * Factory-like class for creating XhrIo instances.
- */
-class ConnectionPool {
-    createConnection() {
-        return newConnection();
-    }
-}
-
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -652,6 +512,32 @@ function makeQueryString(params) {
     return queryPart;
 }
 
+/**
+ * @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.
+ */
+/**
+ * Error codes for requests made by the the XhrIo wrapper.
+ */
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["NO_ERROR"] = 0] = "NO_ERROR";
+    ErrorCode[ErrorCode["NETWORK_ERROR"] = 1] = "NETWORK_ERROR";
+    ErrorCode[ErrorCode["ABORT"] = 2] = "ABORT";
+})(ErrorCode || (ErrorCode = {}));
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -669,22 +555,22 @@ function makeQueryString(params) {
  * limitations under the License.
  */
 class NetworkRequest {
-    constructor(url, method, headers, body, successCodes, additionalRetryCodes, callback, errorCallback, timeout, progressCallback, pool) {
+    constructor(url_, method_, headers_, body_, successCodes_, additionalRetryCodes_, callback_, errorCallback_, timeout_, progressCallback_, pool_) {
+        this.url_ = url_;
+        this.method_ = method_;
+        this.headers_ = headers_;
+        this.body_ = body_;
+        this.successCodes_ = successCodes_;
+        this.additionalRetryCodes_ = additionalRetryCodes_;
+        this.callback_ = callback_;
+        this.errorCallback_ = errorCallback_;
+        this.timeout_ = timeout_;
+        this.progressCallback_ = progressCallback_;
+        this.pool_ = pool_;
         this.pendingConnection_ = null;
         this.backoffId_ = null;
         this.canceled_ = false;
         this.appDelete_ = false;
-        this.url_ = url;
-        this.method_ = method;
-        this.headers_ = headers;
-        this.body_ = body;
-        this.successCodes_ = successCodes.slice();
-        this.additionalRetryCodes_ = additionalRetryCodes.slice();
-        this.callback_ = callback;
-        this.errorCallback_ = errorCallback;
-        this.progressCallback_ = progressCallback;
-        this.timeout_ = timeout;
-        this.pool_ = pool;
         this.promise_ = new Promise((resolve, reject) => {
             this.resolve_ = resolve;
             this.reject_ = reject;
@@ -695,54 +581,56 @@ class NetworkRequest {
      * Actually starts the retry loop.
      */
     start_() {
-        const self = this;
-        function doTheRequest(backoffCallback, canceled) {
+        const doTheRequest = (backoffCallback, canceled) => {
             if (canceled) {
                 backoffCallback(false, new RequestEndStatus(false, null, true));
                 return;
             }
-            const connection = self.pool_.createConnection();
-            self.pendingConnection_ = connection;
-            function progressListener(progressEvent) {
+            const connection = this.pool_.createConnection();
+            this.pendingConnection_ = connection;
+            const progressListener = progressEvent => {
                 const loaded = progressEvent.loaded;
-                const total = progressEvent.lengthComputable ? progressEvent.total : -1;
-                if (self.progressCallback_ !== null) {
-                    self.progressCallback_(loaded, total);
+                const total = progressEvent.lengthComputable
+                    ? progressEvent.total
+                    : -1;
+                if (this.progressCallback_ !== null) {
+                    this.progressCallback_(loaded, total);
                 }
-            }
-            if (self.progressCallback_ !== null) {
+            };
+            if (this.progressCallback_ !== null) {
                 connection.addUploadProgressListener(progressListener);
             }
+            // connection.send() never rejects, so we don't need to have a error handler or use catch on the returned promise.
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
             connection
-                .send(self.url_, self.method_, self.body_, self.headers_)
+                .send(this.url_, this.method_, this.body_, this.headers_)
                 .then(() => {
-                if (self.progressCallback_ !== null) {
+                if (this.progressCallback_ !== null) {
                     connection.removeUploadProgressListener(progressListener);
                 }
-                self.pendingConnection_ = null;
+                this.pendingConnection_ = null;
                 const hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR;
                 const status = connection.getStatus();
-                if (!hitServer || self.isRetryStatusCode_(status)) {
+                if (!hitServer || this.isRetryStatusCode_(status)) {
                     const wasCanceled = connection.getErrorCode() === ErrorCode.ABORT;
                     backoffCallback(false, new RequestEndStatus(false, null, wasCanceled));
                     return;
                 }
-                const successCode = self.successCodes_.indexOf(status) !== -1;
+                const successCode = this.successCodes_.indexOf(status) !== -1;
                 backoffCallback(true, new RequestEndStatus(successCode, connection));
             });
-        }
+        };
         /**
          * @param requestWentThrough - True if the request eventually went
          *     through, false if it hit the retry limit or was canceled.
          */
-        function backoffDone(requestWentThrough, status) {
-            const resolve = self.resolve_;
-            const reject = self.reject_;
+        const backoffDone = (requestWentThrough, status) => {
+            const resolve = this.resolve_;
+            const reject = this.reject_;
             const connection = status.connection;
             if (status.wasSuccessCode) {
                 try {
-                    const result = self.callback_(connection, connection.getResponseText());
+                    const result = this.callback_(connection, connection.getResponseText());
                     if (isJustDef(result)) {
                         resolve(result);
                     }
@@ -758,8 +646,8 @@ class NetworkRequest {
                 if (connection !== null) {
                     const err = unknown();
                     err.serverResponse = connection.getResponseText();
-                    if (self.errorCallback_) {
-                        reject(self.errorCallback_(connection, err));
+                    if (this.errorCallback_) {
+                        reject(this.errorCallback_(connection, err));
                     }
                     else {
                         reject(err);
@@ -767,7 +655,7 @@ class NetworkRequest {
                 }
                 else {
                     if (status.canceled) {
-                        const err = self.appDelete_ ? appDeleted() : canceled();
+                        const err = this.appDelete_ ? appDeleted() : canceled();
                         reject(err);
                     }
                     else {
@@ -776,7 +664,7 @@ class NetworkRequest {
                     }
                 }
             }
-        }
+        };
         if (this.canceled_) {
             backoffDone(false, new RequestEndStatus(false, null, true));
         }
@@ -3141,7 +3029,7 @@ class FirebaseStorageImpl {
 }
 
 const name = "@firebase/storage";
-const version = "0.8.3";
+const version = "0.8.4-canary.1048c4f2d";
 
 /**
  * @license
@@ -3164,6 +3052,122 @@ const version = "0.8.3";
  */
 const STORAGE_TYPE = 'storage';
 
+/**
+ * @license
+ * Copyright 2021 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.
+ */
+/**
+ * Network layer that works in Node.
+ *
+ * This network implementation should not be used in browsers as it does not
+ * support progress updates.
+ */
+class FetchConnection {
+    constructor() {
+        this.sent_ = false;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.fetch_ = nodeFetch__default["default"];
+        this.errorCode_ = ErrorCode.NO_ERROR;
+    }
+    send(url, method, body, headers) {
+        if (this.sent_) {
+            throw internalError('cannot .send() more than once');
+        }
+        this.sent_ = true;
+        return this.fetch_(url, {
+            method,
+            headers: headers || {},
+            body
+        }).then(resp => {
+            this.headers_ = resp.headers;
+            this.statusCode_ = resp.status;
+            return resp.text().then(body => {
+                this.body_ = body;
+            });
+        }, (_err) => {
+            this.errorCode_ = ErrorCode.NETWORK_ERROR;
+            // emulate XHR which sets status to 0 when encountering a network error
+            this.statusCode_ = 0;
+        });
+    }
+    getErrorCode() {
+        if (this.errorCode_ === undefined) {
+            throw internalError('cannot .getErrorCode() before receiving response');
+        }
+        return this.errorCode_;
+    }
+    getStatus() {
+        if (this.statusCode_ === undefined) {
+            throw internalError('cannot .getStatus() before receiving response');
+        }
+        return this.statusCode_;
+    }
+    getResponseText() {
+        if (this.body_ === undefined) {
+            throw internalError('cannot .getResponseText() before receiving response');
+        }
+        return this.body_;
+    }
+    abort() {
+        // Not supported
+    }
+    getResponseHeader(header) {
+        if (!this.headers_) {
+            throw internalError('cannot .getResponseText() before receiving response');
+        }
+        return this.headers_.get(header);
+    }
+    addUploadProgressListener(listener) {
+        // Not supported
+    }
+    /**
+     * @override
+     */
+    removeUploadProgressListener(listener) {
+        // Not supported
+    }
+}
+function newConnection() {
+    return new FetchConnection();
+}
+
+/**
+ * @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.
+ */
+/**
+ * Factory-like class for creating XhrIo instances.
+ */
+class ConnectionPool {
+    createConnection() {
+        return newConnection();
+    }
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC