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

package/dist/index.esm5.js

@@ -248,9 +248,6 @@ var XhrConnection = /** @class */ (function () {
             });
         });
     }
-    /**
-     * @override
-     */
     XhrConnection.prototype.send = function (url, method, body, headers) {
         if (this.sent_) {
             throw internalError('cannot .send() more than once');
@@ -272,18 +269,12 @@ var XhrConnection = /** @class */ (function () {
         }
         return this.sendPromise_;
     };
-    /**
-     * @override
-     */
     XhrConnection.prototype.getErrorCode = function () {
         if (!this.sent_) {
             throw internalError('cannot .getErrorCode() before sending');
         }
         return this.errorCode_;
     };
-    /**
-     * @override
-     */
     XhrConnection.prototype.getStatus = function () {
         if (!this.sent_) {
             throw internalError('cannot .getStatus() before sending');
@@ -295,39 +286,24 @@ var XhrConnection = /** @class */ (function () {
             return -1;
         }
     };
-    /**
-     * @override
-     */
     XhrConnection.prototype.getResponseText = function () {
         if (!this.sent_) {
             throw internalError('cannot .getResponseText() before sending');
         }
         return this.xhr_.responseText;
     };
-    /**
-     * Aborts the request.
-     * @override
-     */
+    /** Aborts the request. */
     XhrConnection.prototype.abort = function () {
         this.xhr_.abort();
     };
-    /**
-     * @override
-     */
     XhrConnection.prototype.getResponseHeader = function (header) {
         return this.xhr_.getResponseHeader(header);
     };
-    /**
-     * @override
-     */
     XhrConnection.prototype.addUploadProgressListener = function (listener) {
         if (this.xhr_.upload != null) {
             this.xhr_.upload.addEventListener('progress', listener);
         }
     };
-    /**
-     * @override
-     */
     XhrConnection.prototype.removeUploadProgressListener = function (listener) {
         if (this.xhr_.upload != null) {
             this.xhr_.upload.removeEventListener('progress', listener);
@@ -732,23 +708,23 @@ function makeQueryString(params) {
  * limitations under the License.
  */
 var NetworkRequest = /** @class */ (function () {
-    function NetworkRequest(url, method, headers, body, successCodes, additionalRetryCodes, callback, errorCallback, timeout, progressCallback, pool) {
+    function NetworkRequest(url_, method_, headers_, body_, successCodes_, additionalRetryCodes_, callback_, errorCallback_, timeout_, progressCallback_, pool_) {
         var _this = this;
+        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(function (resolve, reject) {
             _this.resolve_ = resolve;
             _this.reject_ = reject;
@@ -759,54 +735,57 @@ var NetworkRequest = /** @class */ (function () {
      * Actually starts the retry loop.
      */
     NetworkRequest.prototype.start_ = function () {
-        var self = this;
-        function doTheRequest(backoffCallback, canceled) {
+        var _this = this;
+        var doTheRequest = function (backoffCallback, canceled) {
             if (canceled) {
                 backoffCallback(false, new RequestEndStatus(false, null, true));
                 return;
             }
-            var connection = self.pool_.createConnection();
-            self.pendingConnection_ = connection;
-            function progressListener(progressEvent) {
+            var connection = _this.pool_.createConnection();
+            _this.pendingConnection_ = connection;
+            var progressListener = function (progressEvent) {
                 var loaded = progressEvent.loaded;
-                var total = progressEvent.lengthComputable ? progressEvent.total : -1;
-                if (self.progressCallback_ !== null) {
-                    self.progressCallback_(loaded, total);
+                var 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(function () {
-                if (self.progressCallback_ !== null) {
+                if (_this.progressCallback_ !== null) {
                     connection.removeUploadProgressListener(progressListener);
                 }
-                self.pendingConnection_ = null;
+                _this.pendingConnection_ = null;
                 var hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR;
                 var status = connection.getStatus();
-                if (!hitServer || self.isRetryStatusCode_(status)) {
+                if (!hitServer || _this.isRetryStatusCode_(status)) {
                     var wasCanceled = connection.getErrorCode() === ErrorCode.ABORT;
                     backoffCallback(false, new RequestEndStatus(false, null, wasCanceled));
                     return;
                 }
-                var successCode = self.successCodes_.indexOf(status) !== -1;
+                var 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) {
-            var resolve = self.resolve_;
-            var reject = self.reject_;
+        var backoffDone = function (requestWentThrough, status) {
+            var resolve = _this.resolve_;
+            var reject = _this.reject_;
             var connection = status.connection;
             if (status.wasSuccessCode) {
                 try {
-                    var result = self.callback_(connection, connection.getResponseText());
+                    var result = _this.callback_(connection, connection.getResponseText());
                     if (isJustDef(result)) {
                         resolve(result);
                     }
@@ -822,8 +801,8 @@ var NetworkRequest = /** @class */ (function () {
                 if (connection !== null) {
                     var 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);
@@ -831,7 +810,7 @@ var NetworkRequest = /** @class */ (function () {
                 }
                 else {
                     if (status.canceled) {
-                        var err = self.appDelete_ ? appDeleted() : canceled();
+                        var err = _this.appDelete_ ? appDeleted() : canceled();
                         reject(err);
                     }
                     else {
@@ -840,7 +819,7 @@ var NetworkRequest = /** @class */ (function () {
                     }
                 }
             }
-        }
+        };
         if (this.canceled_) {
             backoffDone(false, new RequestEndStatus(false, null, true));
         }
@@ -3368,7 +3347,7 @@ var FirebaseStorageImpl = /** @class */ (function () {
 }());
 
 var name = "@firebase/storage";
-var version = "0.8.3";
+var version = "0.8.4-canary.1048c4f2d";
 
 /**
  * @license
@@ -3597,7 +3576,10 @@ function factory(container, _a) {
 }
 function registerStorage() {
     _registerComponent(new Component(STORAGE_TYPE, factory, "PUBLIC" /* PUBLIC */).setMultipleInstances(true));
-    registerVersion(name, version);
+    //RUNTIME_ENV will be replaced during the compilation to "node" for nodejs and an empty string for browser
+    registerVersion(name, version, '');
+    // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
+    registerVersion(name, version, 'esm5');
 }
 registerStorage();