From 8eff962cab608341a6f2fedc640a0e32d96f26e2 Mon Sep 17 00:00:00 2001 From: altaf-creator Date: Sun, 9 Nov 2025 11:15:19 +0800 Subject: pain --- .../@firebase/storage/dist/index.node.cjs.js | 3710 ++++++++++++++++++++ 1 file changed, 3710 insertions(+) create mode 100644 frontend-old/node_modules/@firebase/storage/dist/index.node.cjs.js (limited to 'frontend-old/node_modules/@firebase/storage/dist/index.node.cjs.js') diff --git a/frontend-old/node_modules/@firebase/storage/dist/index.node.cjs.js b/frontend-old/node_modules/@firebase/storage/dist/index.node.cjs.js new file mode 100644 index 0000000..26f308c --- /dev/null +++ b/frontend-old/node_modules/@firebase/storage/dist/index.node.cjs.js @@ -0,0 +1,3710 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +var app = require('@firebase/app'); +var util = require('@firebase/util'); +var component = require('@firebase/component'); + +/** + * @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. + */ +/** + * @fileoverview Constants used in the Firebase Storage library. + */ +/** + * Domain name for firebase storage. + */ +const DEFAULT_HOST = 'firebasestorage.googleapis.com'; +/** + * The key in Firebase config json for the storage bucket. + */ +const CONFIG_STORAGE_BUCKET_KEY = 'storageBucket'; +/** + * 2 minutes + * + * The timeout for all operations except upload. + */ +const DEFAULT_MAX_OPERATION_RETRY_TIME = 2 * 60 * 1000; +/** + * 10 minutes + * + * The timeout for upload. + */ +const DEFAULT_MAX_UPLOAD_RETRY_TIME = 10 * 60 * 1000; +/** + * 1 second + */ +const DEFAULT_MIN_SLEEP_TIME_MILLIS = 1000; + +/** + * @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. + */ +/** + * An error returned by the Firebase Storage SDK. + * @public + */ +class StorageError extends util.FirebaseError { + /** + * @param code - A `StorageErrorCode` string to be prefixed with 'storage/' and + * added to the end of the message. + * @param message - Error message. + * @param status_ - Corresponding HTTP Status Code + */ + constructor(code, message, status_ = 0) { + super(prependCode(code), `Firebase Storage: ${message} (${prependCode(code)})`); + this.status_ = status_; + /** + * Stores custom error data unique to the `StorageError`. + */ + this.customData = { serverResponse: null }; + this._baseMessage = this.message; + // Without this, `instanceof StorageError`, in tests for example, + // returns false. + Object.setPrototypeOf(this, StorageError.prototype); + } + get status() { + return this.status_; + } + set status(status) { + this.status_ = status; + } + /** + * Compares a `StorageErrorCode` against this error's code, filtering out the prefix. + */ + _codeEquals(code) { + return prependCode(code) === this.code; + } + /** + * Optional response message that was added by the server. + */ + get serverResponse() { + return this.customData.serverResponse; + } + set serverResponse(serverResponse) { + this.customData.serverResponse = serverResponse; + if (this.customData.serverResponse) { + this.message = `${this._baseMessage}\n${this.customData.serverResponse}`; + } + else { + this.message = this._baseMessage; + } + } +} +/** + * @public + * Error codes that can be attached to `StorageError` objects. + */ +exports.StorageErrorCode = void 0; +(function (StorageErrorCode) { + // Shared between all platforms + StorageErrorCode["UNKNOWN"] = "unknown"; + StorageErrorCode["OBJECT_NOT_FOUND"] = "object-not-found"; + StorageErrorCode["BUCKET_NOT_FOUND"] = "bucket-not-found"; + StorageErrorCode["PROJECT_NOT_FOUND"] = "project-not-found"; + StorageErrorCode["QUOTA_EXCEEDED"] = "quota-exceeded"; + StorageErrorCode["UNAUTHENTICATED"] = "unauthenticated"; + StorageErrorCode["UNAUTHORIZED"] = "unauthorized"; + StorageErrorCode["UNAUTHORIZED_APP"] = "unauthorized-app"; + StorageErrorCode["RETRY_LIMIT_EXCEEDED"] = "retry-limit-exceeded"; + StorageErrorCode["INVALID_CHECKSUM"] = "invalid-checksum"; + StorageErrorCode["CANCELED"] = "canceled"; + // JS specific + StorageErrorCode["INVALID_EVENT_NAME"] = "invalid-event-name"; + StorageErrorCode["INVALID_URL"] = "invalid-url"; + StorageErrorCode["INVALID_DEFAULT_BUCKET"] = "invalid-default-bucket"; + StorageErrorCode["NO_DEFAULT_BUCKET"] = "no-default-bucket"; + StorageErrorCode["CANNOT_SLICE_BLOB"] = "cannot-slice-blob"; + StorageErrorCode["SERVER_FILE_WRONG_SIZE"] = "server-file-wrong-size"; + StorageErrorCode["NO_DOWNLOAD_URL"] = "no-download-url"; + StorageErrorCode["INVALID_ARGUMENT"] = "invalid-argument"; + StorageErrorCode["INVALID_ARGUMENT_COUNT"] = "invalid-argument-count"; + StorageErrorCode["APP_DELETED"] = "app-deleted"; + StorageErrorCode["INVALID_ROOT_OPERATION"] = "invalid-root-operation"; + StorageErrorCode["INVALID_FORMAT"] = "invalid-format"; + StorageErrorCode["INTERNAL_ERROR"] = "internal-error"; + StorageErrorCode["UNSUPPORTED_ENVIRONMENT"] = "unsupported-environment"; +})(exports.StorageErrorCode || (exports.StorageErrorCode = {})); +function prependCode(code) { + return 'storage/' + code; +} +function unknown() { + const message = 'An unknown error occurred, please check the error payload for ' + + 'server response.'; + return new StorageError(exports.StorageErrorCode.UNKNOWN, message); +} +function objectNotFound(path) { + return new StorageError(exports.StorageErrorCode.OBJECT_NOT_FOUND, "Object '" + path + "' does not exist."); +} +function quotaExceeded(bucket) { + return new StorageError(exports.StorageErrorCode.QUOTA_EXCEEDED, "Quota for bucket '" + + bucket + + "' exceeded, please view quota on " + + 'https://firebase.google.com/pricing/.'); +} +function unauthenticated() { + const message = 'User is not authenticated, please authenticate using Firebase ' + + 'Authentication and try again.'; + return new StorageError(exports.StorageErrorCode.UNAUTHENTICATED, message); +} +function unauthorizedApp() { + return new StorageError(exports.StorageErrorCode.UNAUTHORIZED_APP, 'This app does not have permission to access Firebase Storage on this project.'); +} +function unauthorized(path) { + return new StorageError(exports.StorageErrorCode.UNAUTHORIZED, "User does not have permission to access '" + path + "'."); +} +function retryLimitExceeded() { + return new StorageError(exports.StorageErrorCode.RETRY_LIMIT_EXCEEDED, 'Max retry time for operation exceeded, please try again.'); +} +function canceled() { + return new StorageError(exports.StorageErrorCode.CANCELED, 'User canceled the upload/download.'); +} +function invalidUrl(url) { + return new StorageError(exports.StorageErrorCode.INVALID_URL, "Invalid URL '" + url + "'."); +} +function invalidDefaultBucket(bucket) { + return new StorageError(exports.StorageErrorCode.INVALID_DEFAULT_BUCKET, "Invalid default bucket '" + bucket + "'."); +} +function noDefaultBucket() { + return new StorageError(exports.StorageErrorCode.NO_DEFAULT_BUCKET, 'No default bucket ' + + "found. Did you set the '" + + CONFIG_STORAGE_BUCKET_KEY + + "' property when initializing the app?"); +} +function cannotSliceBlob() { + return new StorageError(exports.StorageErrorCode.CANNOT_SLICE_BLOB, 'Cannot slice blob for upload. Please retry the upload.'); +} +function serverFileWrongSize() { + return new StorageError(exports.StorageErrorCode.SERVER_FILE_WRONG_SIZE, 'Server recorded incorrect upload file size, please retry the upload.'); +} +function noDownloadURL() { + return new StorageError(exports.StorageErrorCode.NO_DOWNLOAD_URL, 'The given file does not have any download URLs.'); +} +/** + * @internal + */ +function invalidArgument(message) { + return new StorageError(exports.StorageErrorCode.INVALID_ARGUMENT, message); +} +function appDeleted() { + return new StorageError(exports.StorageErrorCode.APP_DELETED, 'The Firebase app was deleted.'); +} +/** + * @param name - The name of the operation that was invalid. + * + * @internal + */ +function invalidRootOperation(name) { + return new StorageError(exports.StorageErrorCode.INVALID_ROOT_OPERATION, "The operation '" + + name + + "' cannot be performed on a root reference, create a non-root " + + "reference using child, such as .child('file.png')."); +} +/** + * @param format - The format that was not valid. + * @param message - A message describing the format violation. + */ +function invalidFormat(format, message) { + return new StorageError(exports.StorageErrorCode.INVALID_FORMAT, "String does not match format '" + format + "': " + message); +} +/** + * @param message - A message describing the internal error. + */ +function internalError(message) { + throw new StorageError(exports.StorageErrorCode.INTERNAL_ERROR, 'Internal error: ' + message); +} + +/** + * @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. + */ +/** + * Firebase Storage location data. + * + * @internal + */ +class Location { + constructor(bucket, path) { + this.bucket = bucket; + this.path_ = path; + } + get path() { + return this.path_; + } + get isRoot() { + return this.path.length === 0; + } + fullServerUrl() { + const encode = encodeURIComponent; + return '/b/' + encode(this.bucket) + '/o/' + encode(this.path); + } + bucketOnlyServerUrl() { + const encode = encodeURIComponent; + return '/b/' + encode(this.bucket) + '/o'; + } + static makeFromBucketSpec(bucketString, host) { + let bucketLocation; + try { + bucketLocation = Location.makeFromUrl(bucketString, host); + } + catch (e) { + // Not valid URL, use as-is. This lets you put bare bucket names in + // config. + return new Location(bucketString, ''); + } + if (bucketLocation.path === '') { + return bucketLocation; + } + else { + throw invalidDefaultBucket(bucketString); + } + } + static makeFromUrl(url, host) { + let location = null; + const bucketDomain = '([A-Za-z0-9.\\-_]+)'; + function gsModify(loc) { + if (loc.path.charAt(loc.path.length - 1) === '/') { + loc.path_ = loc.path_.slice(0, -1); + } + } + const gsPath = '(/(.*))?$'; + const gsRegex = new RegExp('^gs://' + bucketDomain + gsPath, 'i'); + const gsIndices = { bucket: 1, path: 3 }; + function httpModify(loc) { + loc.path_ = decodeURIComponent(loc.path); + } + const version = 'v[A-Za-z0-9_]+'; + const firebaseStorageHost = host.replace(/[.]/g, '\\.'); + const firebaseStoragePath = '(/([^?#]*).*)?$'; + const firebaseStorageRegExp = new RegExp(`^https?://${firebaseStorageHost}/${version}/b/${bucketDomain}/o${firebaseStoragePath}`, 'i'); + const firebaseStorageIndices = { bucket: 1, path: 3 }; + const cloudStorageHost = host === DEFAULT_HOST + ? '(?:storage.googleapis.com|storage.cloud.google.com)' + : host; + const cloudStoragePath = '([^?#]*)'; + const cloudStorageRegExp = new RegExp(`^https?://${cloudStorageHost}/${bucketDomain}/${cloudStoragePath}`, 'i'); + const cloudStorageIndices = { bucket: 1, path: 2 }; + const groups = [ + { regex: gsRegex, indices: gsIndices, postModify: gsModify }, + { + regex: firebaseStorageRegExp, + indices: firebaseStorageIndices, + postModify: httpModify + }, + { + regex: cloudStorageRegExp, + indices: cloudStorageIndices, + postModify: httpModify + } + ]; + for (let i = 0; i < groups.length; i++) { + const group = groups[i]; + const captures = group.regex.exec(url); + if (captures) { + const bucketValue = captures[group.indices.bucket]; + let pathValue = captures[group.indices.path]; + if (!pathValue) { + pathValue = ''; + } + location = new Location(bucketValue, pathValue); + group.postModify(location); + break; + } + } + if (location == null) { + throw invalidUrl(url); + } + return location; + } +} + +/** + * A request whose promise always fails. + */ +class FailRequest { + constructor(error) { + this.promise_ = Promise.reject(error); + } + /** @inheritDoc */ + getPromise() { + return this.promise_; + } + /** @inheritDoc */ + cancel(_appDelete = false) { } +} + +/** + * @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. + */ +/** + * Accepts a callback for an action to perform (`doRequest`), + * and then a callback for when the backoff has completed (`backoffCompleteCb`). + * The callback sent to start requires an argument to call (`onRequestComplete`). + * When `start` calls `doRequest`, it passes a callback for when the request has + * completed, `onRequestComplete`. Based on this, the backoff continues, with + * another call to `doRequest` and the above loop continues until the timeout + * is hit, or a successful response occurs. + * @description + * @param doRequest Callback to perform request + * @param backoffCompleteCb Callback to call when backoff has been completed + */ +function start(doRequest, +// eslint-disable-next-line @typescript-eslint/no-explicit-any +backoffCompleteCb, timeout) { + // TODO(andysoto): make this code cleaner (probably refactor into an actual + // type instead of a bunch of functions with state shared in the closure) + let waitSeconds = 1; + // Would type this as "number" but that doesn't work for Node so ¯\_(ツ)_/¯ + // TODO: find a way to exclude Node type definition for storage because storage only works in browser + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let retryTimeoutId = null; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let globalTimeoutId = null; + let hitTimeout = false; + let cancelState = 0; + function canceled() { + return cancelState === 2; + } + let triggeredCallback = false; + function triggerCallback(...args) { + if (!triggeredCallback) { + triggeredCallback = true; + backoffCompleteCb.apply(null, args); + } + } + function callWithDelay(millis) { + retryTimeoutId = setTimeout(() => { + retryTimeoutId = null; + doRequest(responseHandler, canceled()); + }, millis); + } + function clearGlobalTimeout() { + if (globalTimeoutId) { + clearTimeout(globalTimeoutId); + } + } + function responseHandler(success, ...args) { + if (triggeredCallback) { + clearGlobalTimeout(); + return; + } + if (success) { + clearGlobalTimeout(); + triggerCallback.call(null, success, ...args); + return; + } + const mustStop = canceled() || hitTimeout; + if (mustStop) { + clearGlobalTimeout(); + triggerCallback.call(null, success, ...args); + return; + } + if (waitSeconds < 64) { + /* TODO(andysoto): don't back off so quickly if we know we're offline. */ + waitSeconds *= 2; + } + let waitMillis; + if (cancelState === 1) { + cancelState = 2; + waitMillis = 0; + } + else { + waitMillis = (waitSeconds + Math.random()) * 1000; + } + callWithDelay(waitMillis); + } + let stopped = false; + function stop(wasTimeout) { + if (stopped) { + return; + } + stopped = true; + clearGlobalTimeout(); + if (triggeredCallback) { + return; + } + if (retryTimeoutId !== null) { + if (!wasTimeout) { + cancelState = 2; + } + clearTimeout(retryTimeoutId); + callWithDelay(0); + } + else { + if (!wasTimeout) { + cancelState = 1; + } + } + } + callWithDelay(0); + globalTimeoutId = setTimeout(() => { + hitTimeout = true; + stop(true); + }, timeout); + return stop; +} +/** + * Stops the retry loop from repeating. + * If the function is currently "in between" retries, it is invoked immediately + * with the second parameter as "true". Otherwise, it will be invoked once more + * after the current invocation finishes iff the current invocation would have + * triggered another retry. + */ +function stop(id) { + id(false); +} + +/** + * @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. + */ +function isJustDef(p) { + return p !== void 0; +} +// eslint-disable-next-line @typescript-eslint/ban-types +function isFunction(p) { + return typeof p === 'function'; +} +function isNonArrayObject(p) { + return typeof p === 'object' && !Array.isArray(p); +} +function isString(p) { + return typeof p === 'string' || p instanceof String; +} +function isNativeBlob(p) { + return isNativeBlobDefined() && p instanceof Blob; +} +function isNativeBlobDefined() { + return typeof Blob !== 'undefined'; +} +function validateNumber(argument, minValue, maxValue, value) { + if (value < minValue) { + throw invalidArgument(`Invalid value for '${argument}'. Expected ${minValue} or greater.`); + } + if (value > maxValue) { + throw invalidArgument(`Invalid value for '${argument}'. Expected ${maxValue} or less.`); + } +} + +/** + * @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. + */ +function makeUrl(urlPart, host, protocol) { + let origin = host; + if (protocol == null) { + origin = `https://${host}`; + } + return `${protocol}://${origin}/v0${urlPart}`; +} +function makeQueryString(params) { + const encode = encodeURIComponent; + let queryPart = '?'; + for (const key in params) { + if (params.hasOwnProperty(key)) { + const nextPart = encode(key) + '=' + encode(params[key]); + queryPart = queryPart + nextPart + '&'; + } + } + // Chop off the extra '&' or '?' on the end + queryPart = queryPart.slice(0, -1); + return queryPart; +} + +/** + * Error codes for requests made by 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 2022 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. + */ +/** + * Checks the status code to see if the action should be retried. + * + * @param status Current HTTP status code returned by server. + * @param additionalRetryCodes additional retry codes to check against + */ +function isRetryStatusCode(status, additionalRetryCodes) { + // The codes for which to retry came from this page: + // https://cloud.google.com/storage/docs/exponential-backoff + const isFiveHundredCode = status >= 500 && status < 600; + const extraRetryCodes = [ + // Request Timeout: web server didn't receive full request in time. + 408, + // Too Many Requests: you're getting rate-limited, basically. + 429 + ]; + const isExtraRetryCode = extraRetryCodes.indexOf(status) !== -1; + const isAdditionalRetryCode = additionalRetryCodes.indexOf(status) !== -1; + return isFiveHundredCode || isExtraRetryCode || isAdditionalRetryCode; +} + +/** + * @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. + */ +/** + * Handles network logic for all Storage Requests, including error reporting and + * retries with backoff. + * + * @param I - the type of the backend's network response. + * @param - O the output type used by the rest of the SDK. The conversion + * happens in the specified `callback_`. + */ +class NetworkRequest { + constructor(url_, method_, headers_, body_, successCodes_, additionalRetryCodes_, callback_, errorCallback_, timeout_, progressCallback_, connectionFactory_, retry = true, isUsingEmulator = false) { + 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.connectionFactory_ = connectionFactory_; + this.retry = retry; + this.isUsingEmulator = isUsingEmulator; + this.pendingConnection_ = null; + this.backoffId_ = null; + this.canceled_ = false; + this.appDelete_ = false; + this.promise_ = new Promise((resolve, reject) => { + this.resolve_ = resolve; + this.reject_ = reject; + this.start_(); + }); + } + /** + * Actually starts the retry loop. + */ + start_() { + const doTheRequest = (backoffCallback, canceled) => { + if (canceled) { + backoffCallback(false, new RequestEndStatus(false, null, true)); + return; + } + const connection = this.connectionFactory_(); + this.pendingConnection_ = connection; + const progressListener = progressEvent => { + const loaded = progressEvent.loaded; + const total = progressEvent.lengthComputable ? progressEvent.total : -1; + if (this.progressCallback_ !== null) { + this.progressCallback_(loaded, total); + } + }; + 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(this.url_, this.method_, this.isUsingEmulator, this.body_, this.headers_) + .then(() => { + if (this.progressCallback_ !== null) { + connection.removeUploadProgressListener(progressListener); + } + this.pendingConnection_ = null; + const hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR; + const status = connection.getStatus(); + if (!hitServer || + (isRetryStatusCode(status, this.additionalRetryCodes_) && + this.retry)) { + const wasCanceled = connection.getErrorCode() === ErrorCode.ABORT; + backoffCallback(false, new RequestEndStatus(false, null, wasCanceled)); + return; + } + 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. + */ + const backoffDone = (requestWentThrough, status) => { + const resolve = this.resolve_; + const reject = this.reject_; + const connection = status.connection; + if (status.wasSuccessCode) { + try { + const result = this.callback_(connection, connection.getResponse()); + if (isJustDef(result)) { + resolve(result); + } + else { + resolve(); + } + } + catch (e) { + reject(e); + } + } + else { + if (connection !== null) { + const err = unknown(); + err.serverResponse = connection.getErrorText(); + if (this.errorCallback_) { + reject(this.errorCallback_(connection, err)); + } + else { + reject(err); + } + } + else { + if (status.canceled) { + const err = this.appDelete_ ? appDeleted() : canceled(); + reject(err); + } + else { + const err = retryLimitExceeded(); + reject(err); + } + } + } + }; + if (this.canceled_) { + backoffDone(false, new RequestEndStatus(false, null, true)); + } + else { + this.backoffId_ = start(doTheRequest, backoffDone, this.timeout_); + } + } + /** @inheritDoc */ + getPromise() { + return this.promise_; + } + /** @inheritDoc */ + cancel(appDelete) { + this.canceled_ = true; + this.appDelete_ = appDelete || false; + if (this.backoffId_ !== null) { + stop(this.backoffId_); + } + if (this.pendingConnection_ !== null) { + this.pendingConnection_.abort(); + } + } +} +/** + * A collection of information about the result of a network request. + * @param opt_canceled - Defaults to false. + */ +class RequestEndStatus { + constructor(wasSuccessCode, connection, canceled) { + this.wasSuccessCode = wasSuccessCode; + this.connection = connection; + this.canceled = !!canceled; + } +} +function addAuthHeader_(headers, authToken) { + if (authToken !== null && authToken.length > 0) { + headers['Authorization'] = 'Firebase ' + authToken; + } +} +function addVersionHeader_(headers, firebaseVersion) { + headers['X-Firebase-Storage-Version'] = + 'webjs/' + (firebaseVersion ?? 'AppManager'); +} +function addGmpidHeader_(headers, appId) { + if (appId) { + headers['X-Firebase-GMPID'] = appId; + } +} +function addAppCheckHeader_(headers, appCheckToken) { + if (appCheckToken !== null) { + headers['X-Firebase-AppCheck'] = appCheckToken; + } +} +function makeRequest(requestInfo, appId, authToken, appCheckToken, requestFactory, firebaseVersion, retry = true, isUsingEmulator = false) { + const queryPart = makeQueryString(requestInfo.urlParams); + const url = requestInfo.url + queryPart; + const headers = Object.assign({}, requestInfo.headers); + addGmpidHeader_(headers, appId); + addAuthHeader_(headers, authToken); + addVersionHeader_(headers, firebaseVersion); + addAppCheckHeader_(headers, appCheckToken); + return new NetworkRequest(url, requestInfo.method, headers, requestInfo.body, requestInfo.successCodes, requestInfo.additionalRetryCodes, requestInfo.handler, requestInfo.errorHandler, requestInfo.timeout, requestInfo.progressCallback, requestFactory, retry, isUsingEmulator); +} + +/** + * @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. + */ +function getBlobBuilder() { + if (typeof BlobBuilder !== 'undefined') { + return BlobBuilder; + } + else if (typeof WebKitBlobBuilder !== 'undefined') { + return WebKitBlobBuilder; + } + else { + return undefined; + } +} +/** + * Concatenates one or more values together and converts them to a Blob. + * + * @param args The values that will make up the resulting blob. + * @return The blob. + */ +function getBlob$1(...args) { + const BlobBuilder = getBlobBuilder(); + if (BlobBuilder !== undefined) { + const bb = new BlobBuilder(); + for (let i = 0; i < args.length; i++) { + bb.append(args[i]); + } + return bb.getBlob(); + } + else { + if (isNativeBlobDefined()) { + return new Blob(args); + } + else { + throw new StorageError(exports.StorageErrorCode.UNSUPPORTED_ENVIRONMENT, "This browser doesn't seem to support creating Blobs"); + } + } +} +/** + * Slices the blob. The returned blob contains data from the start byte + * (inclusive) till the end byte (exclusive). Negative indices cannot be used. + * + * @param blob The blob to be sliced. + * @param start Index of the starting byte. + * @param end Index of the ending byte. + * @return The blob slice or null if not supported. + */ +function sliceBlob(blob, start, end) { + if (blob.webkitSlice) { + return blob.webkitSlice(start, end); + } + else if (blob.mozSlice) { + return blob.mozSlice(start, end); + } + else if (blob.slice) { + return blob.slice(start, end); + } + return null; +} + +/** + * @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. + */ +/** Converts a Base64 encoded string to a binary string. */ +function decodeBase64(encoded) { + // Node actually doesn't validate base64 strings. + // A quick sanity check that is not a fool-proof validation + if (/[^-A-Za-z0-9+/=]/.test(encoded)) { + throw invalidFormat('base64', 'Invalid character found'); + } + return Buffer.from(encoded, 'base64').toString('binary'); +} + +/** + * @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. + */ +/** + * An enumeration of the possible string formats for upload. + * @public + */ +const StringFormat = { + /** + * Indicates the string should be interpreted "raw", that is, as normal text. + * The string will be interpreted as UTF-16, then uploaded as a UTF-8 byte + * sequence. + * Example: The string 'Hello! \\ud83d\\ude0a' becomes the byte sequence + * 48 65 6c 6c 6f 21 20 f0 9f 98 8a + */ + RAW: 'raw', + /** + * Indicates the string should be interpreted as base64-encoded data. + * Padding characters (trailing '='s) are optional. + * Example: The string 'rWmO++E6t7/rlw==' becomes the byte sequence + * ad 69 8e fb e1 3a b7 bf eb 97 + */ + BASE64: 'base64', + /** + * Indicates the string should be interpreted as base64url-encoded data. + * Padding characters (trailing '='s) are optional. + * Example: The string 'rWmO--E6t7_rlw==' becomes the byte sequence + * ad 69 8e fb e1 3a b7 bf eb 97 + */ + BASE64URL: 'base64url', + /** + * Indicates the string is a data URL, such as one obtained from + * canvas.toDataURL(). + * Example: the string 'data:application/octet-stream;base64,aaaa' + * becomes the byte sequence + * 69 a6 9a + * (the content-type "application/octet-stream" is also applied, but can + * be overridden in the metadata object). + */ + DATA_URL: 'data_url' +}; +class StringData { + constructor(data, contentType) { + this.data = data; + this.contentType = contentType || null; + } +} +/** + * @internal + */ +function dataFromString(format, stringData) { + switch (format) { + case StringFormat.RAW: + return new StringData(utf8Bytes_(stringData)); + case StringFormat.BASE64: + case StringFormat.BASE64URL: + return new StringData(base64Bytes_(format, stringData)); + case StringFormat.DATA_URL: + return new StringData(dataURLBytes_(stringData), dataURLContentType_(stringData)); + // do nothing + } + // assert(false); + throw unknown(); +} +function utf8Bytes_(value) { + const b = []; + for (let i = 0; i < value.length; i++) { + let c = value.charCodeAt(i); + if (c <= 127) { + b.push(c); + } + else { + if (c <= 2047) { + b.push(192 | (c >> 6), 128 | (c & 63)); + } + else { + if ((c & 64512) === 55296) { + // The start of a surrogate pair. + const valid = i < value.length - 1 && (value.charCodeAt(i + 1) & 64512) === 56320; + if (!valid) { + // The second surrogate wasn't there. + b.push(239, 191, 189); + } + else { + const hi = c; + const lo = value.charCodeAt(++i); + c = 65536 | ((hi & 1023) << 10) | (lo & 1023); + b.push(240 | (c >> 18), 128 | ((c >> 12) & 63), 128 | ((c >> 6) & 63), 128 | (c & 63)); + } + } + else { + if ((c & 64512) === 56320) { + // Invalid low surrogate. + b.push(239, 191, 189); + } + else { + b.push(224 | (c >> 12), 128 | ((c >> 6) & 63), 128 | (c & 63)); + } + } + } + } + } + return new Uint8Array(b); +} +function percentEncodedBytes_(value) { + let decoded; + try { + decoded = decodeURIComponent(value); + } + catch (e) { + throw invalidFormat(StringFormat.DATA_URL, 'Malformed data URL.'); + } + return utf8Bytes_(decoded); +} +function base64Bytes_(format, value) { + switch (format) { + case StringFormat.BASE64: { + const hasMinus = value.indexOf('-') !== -1; + const hasUnder = value.indexOf('_') !== -1; + if (hasMinus || hasUnder) { + const invalidChar = hasMinus ? '-' : '_'; + throw invalidFormat(format, "Invalid character '" + + invalidChar + + "' found: is it base64url encoded?"); + } + break; + } + case StringFormat.BASE64URL: { + const hasPlus = value.indexOf('+') !== -1; + const hasSlash = value.indexOf('/') !== -1; + if (hasPlus || hasSlash) { + const invalidChar = hasPlus ? '+' : '/'; + throw invalidFormat(format, "Invalid character '" + invalidChar + "' found: is it base64 encoded?"); + } + value = value.replace(/-/g, '+').replace(/_/g, '/'); + break; + } + // do nothing + } + let bytes; + try { + bytes = decodeBase64(value); + } + catch (e) { + if (e.message.includes('polyfill')) { + throw e; + } + throw invalidFormat(format, 'Invalid character found'); + } + const array = new Uint8Array(bytes.length); + for (let i = 0; i < bytes.length; i++) { + array[i] = bytes.charCodeAt(i); + } + return array; +} +class DataURLParts { + constructor(dataURL) { + this.base64 = false; + this.contentType = null; + const matches = dataURL.match(/^data:([^,]+)?,/); + if (matches === null) { + throw invalidFormat(StringFormat.DATA_URL, "Must be formatted 'data:[][;base64],"); + } + const middle = matches[1] || null; + if (middle != null) { + this.base64 = endsWith(middle, ';base64'); + this.contentType = this.base64 + ? middle.substring(0, middle.length - ';base64'.length) + : middle; + } + this.rest = dataURL.substring(dataURL.indexOf(',') + 1); + } +} +function dataURLBytes_(dataUrl) { + const parts = new DataURLParts(dataUrl); + if (parts.base64) { + return base64Bytes_(StringFormat.BASE64, parts.rest); + } + else { + return percentEncodedBytes_(parts.rest); + } +} +function dataURLContentType_(dataUrl) { + const parts = new DataURLParts(dataUrl); + return parts.contentType; +} +function endsWith(s, end) { + const longEnough = s.length >= end.length; + if (!longEnough) { + return false; + } + return s.substring(s.length - end.length) === end; +} + +/** + * @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. + */ +/** + * @param opt_elideCopy - If true, doesn't copy mutable input data + * (e.g. Uint8Arrays). Pass true only if you know the objects will not be + * modified after this blob's construction. + * + * @internal + */ +class FbsBlob { + constructor(data, elideCopy) { + let size = 0; + let blobType = ''; + if (isNativeBlob(data)) { + this.data_ = data; + size = data.size; + blobType = data.type; + } + else if (data instanceof ArrayBuffer) { + if (elideCopy) { + this.data_ = new Uint8Array(data); + } + else { + this.data_ = new Uint8Array(data.byteLength); + this.data_.set(new Uint8Array(data)); + } + size = this.data_.length; + } + else if (data instanceof Uint8Array) { + if (elideCopy) { + this.data_ = data; + } + else { + this.data_ = new Uint8Array(data.length); + this.data_.set(data); + } + size = data.length; + } + this.size_ = size; + this.type_ = blobType; + } + size() { + return this.size_; + } + type() { + return this.type_; + } + slice(startByte, endByte) { + if (isNativeBlob(this.data_)) { + const realBlob = this.data_; + const sliced = sliceBlob(realBlob, startByte, endByte); + if (sliced === null) { + return null; + } + return new FbsBlob(sliced); + } + else { + const slice = new Uint8Array(this.data_.buffer, startByte, endByte - startByte); + return new FbsBlob(slice, true); + } + } + static getBlob(...args) { + if (isNativeBlobDefined()) { + const blobby = args.map((val) => { + if (val instanceof FbsBlob) { + return val.data_; + } + else { + return val; + } + }); + return new FbsBlob(getBlob$1.apply(null, blobby)); + } + else { + const uint8Arrays = args.map((val) => { + if (isString(val)) { + return dataFromString(StringFormat.RAW, val).data; + } + else { + // Blobs don't exist, so this has to be a Uint8Array. + return val.data_; + } + }); + let finalLength = 0; + uint8Arrays.forEach((array) => { + finalLength += array.byteLength; + }); + const merged = new Uint8Array(finalLength); + let index = 0; + uint8Arrays.forEach((array) => { + for (let i = 0; i < array.length; i++) { + merged[index++] = array[i]; + } + }); + return new FbsBlob(merged, true); + } + } + uploadData() { + return this.data_; + } +} + +/** + * @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. + */ +/** + * Returns the Object resulting from parsing the given JSON, or null if the + * given string does not represent a JSON object. + */ +function jsonObjectOrNull(s) { + let obj; + try { + obj = JSON.parse(s); + } + catch (e) { + return null; + } + if (isNonArrayObject(obj)) { + return obj; + } + else { + return null; + } +} + +/** + * @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. + */ +/** + * @fileoverview Contains helper methods for manipulating paths. + */ +/** + * @return Null if the path is already at the root. + */ +function parent(path) { + if (path.length === 0) { + return null; + } + const index = path.lastIndexOf('/'); + if (index === -1) { + return ''; + } + const newPath = path.slice(0, index); + return newPath; +} +function child(path, childPath) { + const canonicalChildPath = childPath + .split('/') + .filter(component => component.length > 0) + .join('/'); + if (path.length === 0) { + return canonicalChildPath; + } + else { + return path + '/' + canonicalChildPath; + } +} +/** + * Returns the last component of a path. + * '/foo/bar' -> 'bar' + * '/foo/bar/baz/' -> 'baz/' + * '/a' -> 'a' + */ +function lastComponent(path) { + const index = path.lastIndexOf('/', path.length - 2); + if (index === -1) { + return path; + } + else { + return path.slice(index + 1); + } +} + +/** + * @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. + */ +function noXform_(metadata, value) { + return value; +} +class Mapping { + constructor(server, local, writable, xform) { + this.server = server; + this.local = local || server; + this.writable = !!writable; + this.xform = xform || noXform_; + } +} +let mappings_ = null; +function xformPath(fullPath) { + if (!isString(fullPath) || fullPath.length < 2) { + return fullPath; + } + else { + return lastComponent(fullPath); + } +} +function getMappings() { + if (mappings_) { + return mappings_; + } + const mappings = []; + mappings.push(new Mapping('bucket')); + mappings.push(new Mapping('generation')); + mappings.push(new Mapping('metageneration')); + mappings.push(new Mapping('name', 'fullPath', true)); + function mappingsXformPath(_metadata, fullPath) { + return xformPath(fullPath); + } + const nameMapping = new Mapping('name'); + nameMapping.xform = mappingsXformPath; + mappings.push(nameMapping); + /** + * Coerces the second param to a number, if it is defined. + */ + function xformSize(_metadata, size) { + if (size !== undefined) { + return Number(size); + } + else { + return size; + } + } + const sizeMapping = new Mapping('size'); + sizeMapping.xform = xformSize; + mappings.push(sizeMapping); + mappings.push(new Mapping('timeCreated')); + mappings.push(new Mapping('updated')); + mappings.push(new Mapping('md5Hash', null, true)); + mappings.push(new Mapping('cacheControl', null, true)); + mappings.push(new Mapping('contentDisposition', null, true)); + mappings.push(new Mapping('contentEncoding', null, true)); + mappings.push(new Mapping('contentLanguage', null, true)); + mappings.push(new Mapping('contentType', null, true)); + mappings.push(new Mapping('metadata', 'customMetadata', true)); + mappings_ = mappings; + return mappings_; +} +function addRef(metadata, service) { + function generateRef() { + const bucket = metadata['bucket']; + const path = metadata['fullPath']; + const loc = new Location(bucket, path); + return service._makeStorageReference(loc); + } + Object.defineProperty(metadata, 'ref', { get: generateRef }); +} +function fromResource(service, resource, mappings) { + const metadata = {}; + metadata['type'] = 'file'; + const len = mappings.length; + for (let i = 0; i < len; i++) { + const mapping = mappings[i]; + metadata[mapping.local] = mapping.xform(metadata, resource[mapping.server]); + } + addRef(metadata, service); + return metadata; +} +function fromResourceString(service, resourceString, mappings) { + const obj = jsonObjectOrNull(resourceString); + if (obj === null) { + return null; + } + const resource = obj; + return fromResource(service, resource, mappings); +} +function downloadUrlFromResourceString(metadata, resourceString, host, protocol) { + const obj = jsonObjectOrNull(resourceString); + if (obj === null) { + return null; + } + if (!isString(obj['downloadTokens'])) { + // This can happen if objects are uploaded through GCS and retrieved + // through list, so we don't want to throw an Error. + return null; + } + const tokens = obj['downloadTokens']; + if (tokens.length === 0) { + return null; + } + const encode = encodeURIComponent; + const tokensList = tokens.split(','); + const urls = tokensList.map((token) => { + const bucket = metadata['bucket']; + const path = metadata['fullPath']; + const urlPart = '/b/' + encode(bucket) + '/o/' + encode(path); + const base = makeUrl(urlPart, host, protocol); + const queryString = makeQueryString({ + alt: 'media', + token + }); + return base + queryString; + }); + return urls[0]; +} +function toResourceString(metadata, mappings) { + const resource = {}; + const len = mappings.length; + for (let i = 0; i < len; i++) { + const mapping = mappings[i]; + if (mapping.writable) { + resource[mapping.server] = metadata[mapping.local]; + } + } + return JSON.stringify(resource); +} + +/** + * @license + * Copyright 2019 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. + */ +const PREFIXES_KEY = 'prefixes'; +const ITEMS_KEY = 'items'; +function fromBackendResponse(service, bucket, resource) { + const listResult = { + prefixes: [], + items: [], + nextPageToken: resource['nextPageToken'] + }; + if (resource[PREFIXES_KEY]) { + for (const path of resource[PREFIXES_KEY]) { + const pathWithoutTrailingSlash = path.replace(/\/$/, ''); + const reference = service._makeStorageReference(new Location(bucket, pathWithoutTrailingSlash)); + listResult.prefixes.push(reference); + } + } + if (resource[ITEMS_KEY]) { + for (const item of resource[ITEMS_KEY]) { + const reference = service._makeStorageReference(new Location(bucket, item['name'])); + listResult.items.push(reference); + } + } + return listResult; +} +function fromResponseString(service, bucket, resourceString) { + const obj = jsonObjectOrNull(resourceString); + if (obj === null) { + return null; + } + const resource = obj; + return fromBackendResponse(service, bucket, resource); +} + +/** + * Contains a fully specified request. + * + * @param I - the type of the backend's network response. + * @param O - the output response type used by the rest of the SDK. + */ +class RequestInfo { + constructor(url, method, + /** + * Returns the value with which to resolve the request's promise. Only called + * if the request is successful. Throw from this function to reject the + * returned Request's promise with the thrown error. + * Note: The XhrIo passed to this function may be reused after this callback + * returns. Do not keep a reference to it in any way. + */ + handler, timeout) { + this.url = url; + this.method = method; + this.handler = handler; + this.timeout = timeout; + this.urlParams = {}; + this.headers = {}; + this.body = null; + this.errorHandler = null; + /** + * Called with the current number of bytes uploaded and total size (-1 if not + * computable) of the request body (i.e. used to report upload progress). + */ + this.progressCallback = null; + this.successCodes = [200]; + this.additionalRetryCodes = []; + } +} + +/** + * @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. + */ +/** + * Throws the UNKNOWN StorageError if cndn is false. + */ +function handlerCheck(cndn) { + if (!cndn) { + throw unknown(); + } +} +function metadataHandler(service, mappings) { + function handler(xhr, text) { + const metadata = fromResourceString(service, text, mappings); + handlerCheck(metadata !== null); + return metadata; + } + return handler; +} +function listHandler(service, bucket) { + function handler(xhr, text) { + const listResult = fromResponseString(service, bucket, text); + handlerCheck(listResult !== null); + return listResult; + } + return handler; +} +function downloadUrlHandler(service, mappings) { + function handler(xhr, text) { + const metadata = fromResourceString(service, text, mappings); + handlerCheck(metadata !== null); + return downloadUrlFromResourceString(metadata, text, service.host, service._protocol); + } + return handler; +} +function sharedErrorHandler(location) { + function errorHandler(xhr, err) { + let newErr; + if (xhr.getStatus() === 401) { + if ( + // This exact message string is the only consistent part of the + // server's error response that identifies it as an App Check error. + xhr.getErrorText().includes('Firebase App Check token is invalid')) { + newErr = unauthorizedApp(); + } + else { + newErr = unauthenticated(); + } + } + else { + if (xhr.getStatus() === 402) { + newErr = quotaExceeded(location.bucket); + } + else { + if (xhr.getStatus() === 403) { + newErr = unauthorized(location.path); + } + else { + newErr = err; + } + } + } + newErr.status = xhr.getStatus(); + newErr.serverResponse = err.serverResponse; + return newErr; + } + return errorHandler; +} +function objectErrorHandler(location) { + const shared = sharedErrorHandler(location); + function errorHandler(xhr, err) { + let newErr = shared(xhr, err); + if (xhr.getStatus() === 404) { + newErr = objectNotFound(location.path); + } + newErr.serverResponse = err.serverResponse; + return newErr; + } + return errorHandler; +} +function getMetadata$2(service, location, mappings) { + const urlPart = location.fullServerUrl(); + const url = makeUrl(urlPart, service.host, service._protocol); + const method = 'GET'; + const timeout = service.maxOperationRetryTime; + const requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout); + requestInfo.errorHandler = objectErrorHandler(location); + return requestInfo; +} +function list$2(service, location, delimiter, pageToken, maxResults) { + const urlParams = {}; + if (location.isRoot) { + urlParams['prefix'] = ''; + } + else { + urlParams['prefix'] = location.path + '/'; + } + if (delimiter && delimiter.length > 0) { + urlParams['delimiter'] = delimiter; + } + if (pageToken) { + urlParams['pageToken'] = pageToken; + } + if (maxResults) { + urlParams['maxResults'] = maxResults; + } + const urlPart = location.bucketOnlyServerUrl(); + const url = makeUrl(urlPart, service.host, service._protocol); + const method = 'GET'; + const timeout = service.maxOperationRetryTime; + const requestInfo = new RequestInfo(url, method, listHandler(service, location.bucket), timeout); + requestInfo.urlParams = urlParams; + requestInfo.errorHandler = sharedErrorHandler(location); + return requestInfo; +} +function getBytes$1(service, location, maxDownloadSizeBytes) { + const urlPart = location.fullServerUrl(); + const url = makeUrl(urlPart, service.host, service._protocol) + '?alt=media'; + const method = 'GET'; + const timeout = service.maxOperationRetryTime; + const requestInfo = new RequestInfo(url, method, (_, data) => data, timeout); + requestInfo.errorHandler = objectErrorHandler(location); + if (maxDownloadSizeBytes !== undefined) { + requestInfo.headers['Range'] = `bytes=0-${maxDownloadSizeBytes}`; + requestInfo.successCodes = [200 /* OK */, 206 /* Partial Content */]; + } + return requestInfo; +} +function getDownloadUrl(service, location, mappings) { + const urlPart = location.fullServerUrl(); + const url = makeUrl(urlPart, service.host, service._protocol); + const method = 'GET'; + const timeout = service.maxOperationRetryTime; + const requestInfo = new RequestInfo(url, method, downloadUrlHandler(service, mappings), timeout); + requestInfo.errorHandler = objectErrorHandler(location); + return requestInfo; +} +function updateMetadata$2(service, location, metadata, mappings) { + const urlPart = location.fullServerUrl(); + const url = makeUrl(urlPart, service.host, service._protocol); + const method = 'PATCH'; + const body = toResourceString(metadata, mappings); + const headers = { 'Content-Type': 'application/json; charset=utf-8' }; + const timeout = service.maxOperationRetryTime; + const requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout); + requestInfo.headers = headers; + requestInfo.body = body; + requestInfo.errorHandler = objectErrorHandler(location); + return requestInfo; +} +function deleteObject$2(service, location) { + const urlPart = location.fullServerUrl(); + const url = makeUrl(urlPart, service.host, service._protocol); + const method = 'DELETE'; + const timeout = service.maxOperationRetryTime; + function handler(_xhr, _text) { } + const requestInfo = new RequestInfo(url, method, handler, timeout); + requestInfo.successCodes = [200, 204]; + requestInfo.errorHandler = objectErrorHandler(location); + return requestInfo; +} +function determineContentType_(metadata, blob) { + return ((metadata && metadata['contentType']) || + (blob && blob.type()) || + 'application/octet-stream'); +} +function metadataForUpload_(location, blob, metadata) { + const metadataClone = Object.assign({}, metadata); + metadataClone['fullPath'] = location.path; + metadataClone['size'] = blob.size(); + if (!metadataClone['contentType']) { + metadataClone['contentType'] = determineContentType_(null, blob); + } + return metadataClone; +} +/** + * Prepare RequestInfo for uploads as Content-Type: multipart. + */ +function multipartUpload(service, location, mappings, blob, metadata) { + const urlPart = location.bucketOnlyServerUrl(); + const headers = { + 'X-Goog-Upload-Protocol': 'multipart' + }; + function genBoundary() { + let str = ''; + for (let i = 0; i < 2; i++) { + str = str + Math.random().toString().slice(2); + } + return str; + } + const boundary = genBoundary(); + headers['Content-Type'] = 'multipart/related; boundary=' + boundary; + const metadata_ = metadataForUpload_(location, blob, metadata); + const metadataString = toResourceString(metadata_, mappings); + const preBlobPart = '--' + + boundary + + '\r\n' + + 'Content-Type: application/json; charset=utf-8\r\n\r\n' + + metadataString + + '\r\n--' + + boundary + + '\r\n' + + 'Content-Type: ' + + metadata_['contentType'] + + '\r\n\r\n'; + const postBlobPart = '\r\n--' + boundary + '--'; + const body = FbsBlob.getBlob(preBlobPart, blob, postBlobPart); + if (body === null) { + throw cannotSliceBlob(); + } + const urlParams = { name: metadata_['fullPath'] }; + const url = makeUrl(urlPart, service.host, service._protocol); + const method = 'POST'; + const timeout = service.maxUploadRetryTime; + const requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout); + requestInfo.urlParams = urlParams; + requestInfo.headers = headers; + requestInfo.body = body.uploadData(); + requestInfo.errorHandler = sharedErrorHandler(location); + return requestInfo; +} +/** + * @param current The number of bytes that have been uploaded so far. + * @param total The total number of bytes in the upload. + * @param opt_finalized True if the server has finished the upload. + * @param opt_metadata The upload metadata, should + * only be passed if opt_finalized is true. + */ +class ResumableUploadStatus { + constructor(current, total, finalized, metadata) { + this.current = current; + this.total = total; + this.finalized = !!finalized; + this.metadata = metadata || null; + } +} +function checkResumeHeader_(xhr, allowed) { + let status = null; + try { + status = xhr.getResponseHeader('X-Goog-Upload-Status'); + } + catch (e) { + handlerCheck(false); + } + const allowedStatus = allowed || ['active']; + handlerCheck(!!status && allowedStatus.indexOf(status) !== -1); + return status; +} +function createResumableUpload(service, location, mappings, blob, metadata) { + const urlPart = location.bucketOnlyServerUrl(); + const metadataForUpload = metadataForUpload_(location, blob, metadata); + const urlParams = { name: metadataForUpload['fullPath'] }; + const url = makeUrl(urlPart, service.host, service._protocol); + const method = 'POST'; + const headers = { + 'X-Goog-Upload-Protocol': 'resumable', + 'X-Goog-Upload-Command': 'start', + 'X-Goog-Upload-Header-Content-Length': `${blob.size()}`, + 'X-Goog-Upload-Header-Content-Type': metadataForUpload['contentType'], + 'Content-Type': 'application/json; charset=utf-8' + }; + const body = toResourceString(metadataForUpload, mappings); + const timeout = service.maxUploadRetryTime; + function handler(xhr) { + checkResumeHeader_(xhr); + let url; + try { + url = xhr.getResponseHeader('X-Goog-Upload-URL'); + } + catch (e) { + handlerCheck(false); + } + handlerCheck(isString(url)); + return url; + } + const requestInfo = new RequestInfo(url, method, handler, timeout); + requestInfo.urlParams = urlParams; + requestInfo.headers = headers; + requestInfo.body = body; + requestInfo.errorHandler = sharedErrorHandler(location); + return requestInfo; +} +/** + * @param url From a call to fbs.requests.createResumableUpload. + */ +function getResumableUploadStatus(service, location, url, blob) { + const headers = { 'X-Goog-Upload-Command': 'query' }; + function handler(xhr) { + const status = checkResumeHeader_(xhr, ['active', 'final']); + let sizeString = null; + try { + sizeString = xhr.getResponseHeader('X-Goog-Upload-Size-Received'); + } + catch (e) { + handlerCheck(false); + } + if (!sizeString) { + // null or empty string + handlerCheck(false); + } + const size = Number(sizeString); + handlerCheck(!isNaN(size)); + return new ResumableUploadStatus(size, blob.size(), status === 'final'); + } + const method = 'POST'; + const timeout = service.maxUploadRetryTime; + const requestInfo = new RequestInfo(url, method, handler, timeout); + requestInfo.headers = headers; + requestInfo.errorHandler = sharedErrorHandler(location); + return requestInfo; +} +/** + * Any uploads via the resumable upload API must transfer a number of bytes + * that is a multiple of this number. + */ +const RESUMABLE_UPLOAD_CHUNK_SIZE = 256 * 1024; +/** + * @param url From a call to fbs.requests.createResumableUpload. + * @param chunkSize Number of bytes to upload. + * @param status The previous status. + * If not passed or null, we start from the beginning. + * @throws fbs.Error If the upload is already complete, the passed in status + * has a final size inconsistent with the blob, or the blob cannot be sliced + * for upload. + */ +function continueResumableUpload(location, service, url, blob, chunkSize, mappings, status, progressCallback) { + // TODO(andysoto): standardize on internal asserts + // assert(!(opt_status && opt_status.finalized)); + const status_ = new ResumableUploadStatus(0, 0); + if (status) { + status_.current = status.current; + status_.total = status.total; + } + else { + status_.current = 0; + status_.total = blob.size(); + } + if (blob.size() !== status_.total) { + throw serverFileWrongSize(); + } + const bytesLeft = status_.total - status_.current; + let bytesToUpload = bytesLeft; + if (chunkSize > 0) { + bytesToUpload = Math.min(bytesToUpload, chunkSize); + } + const startByte = status_.current; + const endByte = startByte + bytesToUpload; + let uploadCommand = ''; + if (bytesToUpload === 0) { + uploadCommand = 'finalize'; + } + else if (bytesLeft === bytesToUpload) { + uploadCommand = 'upload, finalize'; + } + else { + uploadCommand = 'upload'; + } + const headers = { + 'X-Goog-Upload-Command': uploadCommand, + 'X-Goog-Upload-Offset': `${status_.current}` + }; + const body = blob.slice(startByte, endByte); + if (body === null) { + throw cannotSliceBlob(); + } + function handler(xhr, text) { + // TODO(andysoto): Verify the MD5 of each uploaded range: + // the 'x-range-md5' header comes back with status code 308 responses. + // We'll only be able to bail out though, because you can't re-upload a + // range that you previously uploaded. + const uploadStatus = checkResumeHeader_(xhr, ['active', 'final']); + const newCurrent = status_.current + bytesToUpload; + const size = blob.size(); + let metadata; + if (uploadStatus === 'final') { + metadata = metadataHandler(service, mappings)(xhr, text); + } + else { + metadata = null; + } + return new ResumableUploadStatus(newCurrent, size, uploadStatus === 'final', metadata); + } + const method = 'POST'; + const timeout = service.maxUploadRetryTime; + const requestInfo = new RequestInfo(url, method, handler, timeout); + requestInfo.headers = headers; + requestInfo.body = body.uploadData(); + requestInfo.progressCallback = progressCallback || null; + requestInfo.errorHandler = sharedErrorHandler(location); + return requestInfo; +} + +/** + * @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. + */ +/** + * An event that is triggered on a task. + * @internal + */ +const TaskEvent = { + /** + * For this event, + *
    + *
  • The `next` function is triggered on progress updates and when the + * task is paused/resumed with an `UploadTaskSnapshot` as the first + * argument.
  • + *
  • The `error` function is triggered if the upload is canceled or fails + * for another reason.
  • + *
  • The `complete` function is triggered if the upload completes + * successfully.
  • + *
+ */ + STATE_CHANGED: 'state_changed' +}; +// type keys = keyof TaskState +/** + * Represents the current state of a running upload. + * @internal + */ +const TaskState = { + /** The task is currently transferring data. */ + RUNNING: 'running', + /** The task was paused by the user. */ + PAUSED: 'paused', + /** The task completed successfully. */ + SUCCESS: 'success', + /** The task was canceled. */ + CANCELED: 'canceled', + /** The task failed with an error. */ + ERROR: 'error' +}; +function taskStateFromInternalTaskState(state) { + switch (state) { + case "running" /* InternalTaskState.RUNNING */: + case "pausing" /* InternalTaskState.PAUSING */: + case "canceling" /* InternalTaskState.CANCELING */: + return TaskState.RUNNING; + case "paused" /* InternalTaskState.PAUSED */: + return TaskState.PAUSED; + case "success" /* InternalTaskState.SUCCESS */: + return TaskState.SUCCESS; + case "canceled" /* InternalTaskState.CANCELED */: + return TaskState.CANCELED; + case "error" /* InternalTaskState.ERROR */: + return TaskState.ERROR; + default: + // TODO(andysoto): assert(false); + return TaskState.ERROR; + } +} + +/** + * @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. + */ +class Observer { + constructor(nextOrObserver, error, complete) { + const asFunctions = isFunction(nextOrObserver) || error != null || complete != null; + if (asFunctions) { + this.next = nextOrObserver; + this.error = error ?? undefined; + this.complete = complete ?? undefined; + } + else { + const observer = nextOrObserver; + this.next = observer.next; + this.error = observer.error; + this.complete = observer.complete; + } + } +} + +/** + * @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. + */ +/** + * Returns a function that invokes f with its arguments asynchronously as a + * microtask, i.e. as soon as possible after the current script returns back + * into browser code. + */ +// eslint-disable-next-line @typescript-eslint/ban-types +function async(f) { + return (...argsToForward) => { + // eslint-disable-next-line @typescript-eslint/no-floating-promises + Promise.resolve().then(() => f(...argsToForward)); + }; +} + +/** + * @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. + */ +/** An override for the text-based Connection. Used in tests. */ +let textFactoryOverride = null; +/** + * 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.errorText_ = ''; + this.sent_ = false; + this.errorCode_ = ErrorCode.NO_ERROR; + } + async send(url, method, isUsingEmulator, body, headers) { + if (this.sent_) { + throw internalError('cannot .send() more than once'); + } + this.sent_ = true; + try { + const response = await newFetch(url, method, isUsingEmulator, headers, body); + this.headers_ = response.headers; + this.statusCode_ = response.status; + this.errorCode_ = ErrorCode.NO_ERROR; + this.body_ = await response.arrayBuffer(); + } + catch (e) { + this.errorText_ = e?.message; + // emulate XHR which sets status to 0 when encountering a network error + this.statusCode_ = 0; + this.errorCode_ = ErrorCode.NETWORK_ERROR; + } + } + 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_; + } + getErrorText() { + return this.errorText_; + } + abort() { + // Not supported + } + getResponseHeader(header) { + if (!this.headers_) { + throw internalError('cannot .getResponseHeader() before receiving response'); + } + return this.headers_.get(header); + } + addUploadProgressListener(listener) { + // Not supported + } + removeUploadProgressListener(listener) { + // Not supported + } +} +class FetchTextConnection extends FetchConnection { + getResponse() { + if (!this.body_) { + throw internalError('cannot .getResponse() before receiving response'); + } + return Buffer.from(this.body_).toString('utf-8'); + } +} +function newTextConnection() { + return textFactoryOverride + ? textFactoryOverride() + : new FetchTextConnection(); +} +class FetchBytesConnection extends FetchConnection { + getResponse() { + if (!this.body_) { + throw internalError('cannot .getResponse() before sending'); + } + return this.body_; + } +} +function newBytesConnection() { + return new FetchBytesConnection(); +} +class FetchStreamConnection extends FetchConnection { + constructor() { + super(...arguments); + this.stream_ = null; + } + async send(url, method, isUsingEmulator, body, headers) { + if (this.sent_) { + throw internalError('cannot .send() more than once'); + } + this.sent_ = true; + try { + const response = await newFetch(url, method, isUsingEmulator, headers, body); + this.headers_ = response.headers; + this.statusCode_ = response.status; + this.errorCode_ = ErrorCode.NO_ERROR; + this.stream_ = response.body; + } + catch (e) { + this.errorText_ = e?.message; + // emulate XHR which sets status to 0 when encountering a network error + this.statusCode_ = 0; + this.errorCode_ = ErrorCode.NETWORK_ERROR; + } + } + getResponse() { + if (!this.stream_) { + throw internalError('cannot .getResponse() before sending'); + } + return this.stream_; + } +} +function newFetch(url, method, isUsingEmulator, headers, body) { + const fetchArgs = { + method, + headers: headers || {}, + body: body + }; + if (util.isCloudWorkstation(url) && isUsingEmulator) { + fetchArgs.credentials = 'include'; + } + return fetch(url, fetchArgs); +} +function newStreamConnection() { + return new FetchStreamConnection(); +} + +/** + * @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. + */ +/** + * Represents a blob being uploaded. Can be used to pause/resume/cancel the + * upload and manage callbacks for various events. + * @internal + */ +class UploadTask { + isExponentialBackoffExpired() { + return this.sleepTime > this.maxSleepTime; + } + /** + * @param ref - The firebaseStorage.Reference object this task came + * from, untyped to avoid cyclic dependencies. + * @param blob - The blob to upload. + */ + constructor(ref, blob, metadata = null) { + /** + * Number of bytes transferred so far. + */ + this._transferred = 0; + this._needToFetchStatus = false; + this._needToFetchMetadata = false; + this._observers = []; + this._error = undefined; + this._uploadUrl = undefined; + this._request = undefined; + this._chunkMultiplier = 1; + this._resolve = undefined; + this._reject = undefined; + this._ref = ref; + this._blob = blob; + this._metadata = metadata; + this._mappings = getMappings(); + this._resumable = this._shouldDoResumable(this._blob); + this._state = "running" /* InternalTaskState.RUNNING */; + this._errorHandler = error => { + this._request = undefined; + this._chunkMultiplier = 1; + if (error._codeEquals(exports.StorageErrorCode.CANCELED)) { + this._needToFetchStatus = true; + this.completeTransitions_(); + } + else { + const backoffExpired = this.isExponentialBackoffExpired(); + if (isRetryStatusCode(error.status, [])) { + if (backoffExpired) { + error = retryLimitExceeded(); + } + else { + this.sleepTime = Math.max(this.sleepTime * 2, DEFAULT_MIN_SLEEP_TIME_MILLIS); + this._needToFetchStatus = true; + this.completeTransitions_(); + return; + } + } + this._error = error; + this._transition("error" /* InternalTaskState.ERROR */); + } + }; + this._metadataErrorHandler = error => { + this._request = undefined; + if (error._codeEquals(exports.StorageErrorCode.CANCELED)) { + this.completeTransitions_(); + } + else { + this._error = error; + this._transition("error" /* InternalTaskState.ERROR */); + } + }; + this.sleepTime = 0; + this.maxSleepTime = this._ref.storage.maxUploadRetryTime; + this._promise = new Promise((resolve, reject) => { + this._resolve = resolve; + this._reject = reject; + this._start(); + }); + // Prevent uncaught rejections on the internal promise from bubbling out + // to the top level with a dummy handler. + this._promise.then(null, () => { }); + } + _makeProgressCallback() { + const sizeBefore = this._transferred; + return loaded => this._updateProgress(sizeBefore + loaded); + } + _shouldDoResumable(blob) { + return blob.size() > 256 * 1024; + } + _start() { + if (this._state !== "running" /* InternalTaskState.RUNNING */) { + // This can happen if someone pauses us in a resume callback, for example. + return; + } + if (this._request !== undefined) { + return; + } + if (this._resumable) { + if (this._uploadUrl === undefined) { + this._createResumable(); + } + else { + if (this._needToFetchStatus) { + this._fetchStatus(); + } + else { + if (this._needToFetchMetadata) { + // Happens if we miss the metadata on upload completion. + this._fetchMetadata(); + } + else { + this.pendingTimeout = setTimeout(() => { + this.pendingTimeout = undefined; + this._continueUpload(); + }, this.sleepTime); + } + } + } + } + else { + this._oneShotUpload(); + } + } + _resolveToken(callback) { + // eslint-disable-next-line @typescript-eslint/no-floating-promises + Promise.all([ + this._ref.storage._getAuthToken(), + this._ref.storage._getAppCheckToken() + ]).then(([authToken, appCheckToken]) => { + switch (this._state) { + case "running" /* InternalTaskState.RUNNING */: + callback(authToken, appCheckToken); + break; + case "canceling" /* InternalTaskState.CANCELING */: + this._transition("canceled" /* InternalTaskState.CANCELED */); + break; + case "pausing" /* InternalTaskState.PAUSING */: + this._transition("paused" /* InternalTaskState.PAUSED */); + break; + } + }); + } + // TODO(andysoto): assert false + _createResumable() { + this._resolveToken((authToken, appCheckToken) => { + const requestInfo = createResumableUpload(this._ref.storage, this._ref._location, this._mappings, this._blob, this._metadata); + const createRequest = this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken); + this._request = createRequest; + createRequest.getPromise().then((url) => { + this._request = undefined; + this._uploadUrl = url; + this._needToFetchStatus = false; + this.completeTransitions_(); + }, this._errorHandler); + }); + } + _fetchStatus() { + // TODO(andysoto): assert(this.uploadUrl_ !== null); + const url = this._uploadUrl; + this._resolveToken((authToken, appCheckToken) => { + const requestInfo = getResumableUploadStatus(this._ref.storage, this._ref._location, url, this._blob); + const statusRequest = this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken); + this._request = statusRequest; + statusRequest.getPromise().then(status => { + status = status; + this._request = undefined; + this._updateProgress(status.current); + this._needToFetchStatus = false; + if (status.finalized) { + this._needToFetchMetadata = true; + } + this.completeTransitions_(); + }, this._errorHandler); + }); + } + _continueUpload() { + const chunkSize = RESUMABLE_UPLOAD_CHUNK_SIZE * this._chunkMultiplier; + const status = new ResumableUploadStatus(this._transferred, this._blob.size()); + // TODO(andysoto): assert(this.uploadUrl_ !== null); + const url = this._uploadUrl; + this._resolveToken((authToken, appCheckToken) => { + let requestInfo; + try { + requestInfo = continueResumableUpload(this._ref._location, this._ref.storage, url, this._blob, chunkSize, this._mappings, status, this._makeProgressCallback()); + } + catch (e) { + this._error = e; + this._transition("error" /* InternalTaskState.ERROR */); + return; + } + const uploadRequest = this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken, + /*retry=*/ false // Upload requests should not be retried as each retry should be preceded by another query request. Which is handled in this file. + ); + this._request = uploadRequest; + uploadRequest.getPromise().then((newStatus) => { + this._increaseMultiplier(); + this._request = undefined; + this._updateProgress(newStatus.current); + if (newStatus.finalized) { + this._metadata = newStatus.metadata; + this._transition("success" /* InternalTaskState.SUCCESS */); + } + else { + this.completeTransitions_(); + } + }, this._errorHandler); + }); + } + _increaseMultiplier() { + const currentSize = RESUMABLE_UPLOAD_CHUNK_SIZE * this._chunkMultiplier; + // Max chunk size is 32M. + if (currentSize * 2 < 32 * 1024 * 1024) { + this._chunkMultiplier *= 2; + } + } + _fetchMetadata() { + this._resolveToken((authToken, appCheckToken) => { + const requestInfo = getMetadata$2(this._ref.storage, this._ref._location, this._mappings); + const metadataRequest = this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken); + this._request = metadataRequest; + metadataRequest.getPromise().then(metadata => { + this._request = undefined; + this._metadata = metadata; + this._transition("success" /* InternalTaskState.SUCCESS */); + }, this._metadataErrorHandler); + }); + } + _oneShotUpload() { + this._resolveToken((authToken, appCheckToken) => { + const requestInfo = multipartUpload(this._ref.storage, this._ref._location, this._mappings, this._blob, this._metadata); + const multipartRequest = this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken); + this._request = multipartRequest; + multipartRequest.getPromise().then(metadata => { + this._request = undefined; + this._metadata = metadata; + this._updateProgress(this._blob.size()); + this._transition("success" /* InternalTaskState.SUCCESS */); + }, this._errorHandler); + }); + } + _updateProgress(transferred) { + const old = this._transferred; + this._transferred = transferred; + // A progress update can make the "transferred" value smaller (e.g. a + // partial upload not completed by server, after which the "transferred" + // value may reset to the value at the beginning of the request). + if (this._transferred !== old) { + this._notifyObservers(); + } + } + _transition(state) { + if (this._state === state) { + return; + } + switch (state) { + case "canceling" /* InternalTaskState.CANCELING */: + case "pausing" /* InternalTaskState.PAUSING */: + // TODO(andysoto): + // assert(this.state_ === InternalTaskState.RUNNING || + // this.state_ === InternalTaskState.PAUSING); + this._state = state; + if (this._request !== undefined) { + this._request.cancel(); + } + else if (this.pendingTimeout) { + clearTimeout(this.pendingTimeout); + this.pendingTimeout = undefined; + this.completeTransitions_(); + } + break; + case "running" /* InternalTaskState.RUNNING */: + // TODO(andysoto): + // assert(this.state_ === InternalTaskState.PAUSED || + // this.state_ === InternalTaskState.PAUSING); + const wasPaused = this._state === "paused" /* InternalTaskState.PAUSED */; + this._state = state; + if (wasPaused) { + this._notifyObservers(); + this._start(); + } + break; + case "paused" /* InternalTaskState.PAUSED */: + // TODO(andysoto): + // assert(this.state_ === InternalTaskState.PAUSING); + this._state = state; + this._notifyObservers(); + break; + case "canceled" /* InternalTaskState.CANCELED */: + // TODO(andysoto): + // assert(this.state_ === InternalTaskState.PAUSED || + // this.state_ === InternalTaskState.CANCELING); + this._error = canceled(); + this._state = state; + this._notifyObservers(); + break; + case "error" /* InternalTaskState.ERROR */: + // TODO(andysoto): + // assert(this.state_ === InternalTaskState.RUNNING || + // this.state_ === InternalTaskState.PAUSING || + // this.state_ === InternalTaskState.CANCELING); + this._state = state; + this._notifyObservers(); + break; + case "success" /* InternalTaskState.SUCCESS */: + // TODO(andysoto): + // assert(this.state_ === InternalTaskState.RUNNING || + // this.state_ === InternalTaskState.PAUSING || + // this.state_ === InternalTaskState.CANCELING); + this._state = state; + this._notifyObservers(); + break; + } + } + completeTransitions_() { + switch (this._state) { + case "pausing" /* InternalTaskState.PAUSING */: + this._transition("paused" /* InternalTaskState.PAUSED */); + break; + case "canceling" /* InternalTaskState.CANCELING */: + this._transition("canceled" /* InternalTaskState.CANCELED */); + break; + case "running" /* InternalTaskState.RUNNING */: + this._start(); + break; + } + } + /** + * A snapshot of the current task state. + */ + get snapshot() { + const externalState = taskStateFromInternalTaskState(this._state); + return { + bytesTransferred: this._transferred, + totalBytes: this._blob.size(), + state: externalState, + metadata: this._metadata, + task: this, + ref: this._ref + }; + } + /** + * Adds a callback for an event. + * @param type - The type of event to listen for. + * @param nextOrObserver - + * The `next` function, which gets called for each item in + * the event stream, or an observer object with some or all of these three + * properties (`next`, `error`, `complete`). + * @param error - A function that gets called with a `StorageError` + * if the event stream ends due to an error. + * @param completed - A function that gets called if the + * event stream ends normally. + * @returns + * If only the event argument is passed, returns a function you can use to + * add callbacks (see the examples above). If more than just the event + * argument is passed, returns a function you can call to unregister the + * callbacks. + */ + on(type, nextOrObserver, error, completed) { + // Note: `type` isn't being used. Its type is also incorrect. TaskEvent should not be a string. + const observer = new Observer(nextOrObserver || undefined, error || undefined, completed || undefined); + this._addObserver(observer); + return () => { + this._removeObserver(observer); + }; + } + /** + * This object behaves like a Promise, and resolves with its snapshot data + * when the upload completes. + * @param onFulfilled - The fulfillment callback. Promise chaining works as normal. + * @param onRejected - The rejection callback. + */ + then(onFulfilled, onRejected) { + // These casts are needed so that TypeScript can infer the types of the + // resulting Promise. + return this._promise.then(onFulfilled, onRejected); + } + /** + * Equivalent to calling `then(null, onRejected)`. + */ + catch(onRejected) { + return this.then(null, onRejected); + } + /** + * Adds the given observer. + */ + _addObserver(observer) { + this._observers.push(observer); + this._notifyObserver(observer); + } + /** + * Removes the given observer. + */ + _removeObserver(observer) { + const i = this._observers.indexOf(observer); + if (i !== -1) { + this._observers.splice(i, 1); + } + } + _notifyObservers() { + this._finishPromise(); + const observers = this._observers.slice(); + observers.forEach(observer => { + this._notifyObserver(observer); + }); + } + _finishPromise() { + if (this._resolve !== undefined) { + let triggered = true; + switch (taskStateFromInternalTaskState(this._state)) { + case TaskState.SUCCESS: + async(this._resolve.bind(null, this.snapshot))(); + break; + case TaskState.CANCELED: + case TaskState.ERROR: + const toCall = this._reject; + async(toCall.bind(null, this._error))(); + break; + default: + triggered = false; + break; + } + if (triggered) { + this._resolve = undefined; + this._reject = undefined; + } + } + } + _notifyObserver(observer) { + const externalState = taskStateFromInternalTaskState(this._state); + switch (externalState) { + case TaskState.RUNNING: + case TaskState.PAUSED: + if (observer.next) { + async(observer.next.bind(observer, this.snapshot))(); + } + break; + case TaskState.SUCCESS: + if (observer.complete) { + async(observer.complete.bind(observer))(); + } + break; + case TaskState.CANCELED: + case TaskState.ERROR: + if (observer.error) { + async(observer.error.bind(observer, this._error))(); + } + break; + default: + // TODO(andysoto): assert(false); + if (observer.error) { + async(observer.error.bind(observer, this._error))(); + } + } + } + /** + * Resumes a paused task. Has no effect on a currently running or failed task. + * @returns True if the operation took effect, false if ignored. + */ + resume() { + const valid = this._state === "paused" /* InternalTaskState.PAUSED */ || + this._state === "pausing" /* InternalTaskState.PAUSING */; + if (valid) { + this._transition("running" /* InternalTaskState.RUNNING */); + } + return valid; + } + /** + * Pauses a currently running task. Has no effect on a paused or failed task. + * @returns True if the operation took effect, false if ignored. + */ + pause() { + const valid = this._state === "running" /* InternalTaskState.RUNNING */; + if (valid) { + this._transition("pausing" /* InternalTaskState.PAUSING */); + } + return valid; + } + /** + * Cancels a currently running or paused task. Has no effect on a complete or + * failed task. + * @returns True if the operation took effect, false if ignored. + */ + cancel() { + const valid = this._state === "running" /* InternalTaskState.RUNNING */ || + this._state === "pausing" /* InternalTaskState.PAUSING */; + if (valid) { + this._transition("canceling" /* InternalTaskState.CANCELING */); + } + return valid; + } +} + +/** + * @license + * Copyright 2019 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. + */ +/** + * Provides methods to interact with a bucket in the Firebase Storage service. + * @internal + * @param _location - An fbs.location, or the URL at + * which to base this object, in one of the following forms: + * gs:/// + * http[s]://firebasestorage.googleapis.com/ + * /b//o/ + * Any query or fragment strings will be ignored in the http[s] + * format. If no value is passed, the storage object will use a URL based on + * the project ID of the base firebase.App instance. + */ +class Reference { + constructor(_service, location) { + this._service = _service; + if (location instanceof Location) { + this._location = location; + } + else { + this._location = Location.makeFromUrl(location, _service.host); + } + } + /** + * Returns the URL for the bucket and path this object references, + * in the form gs:/// + * @override + */ + toString() { + return 'gs://' + this._location.bucket + '/' + this._location.path; + } + _newRef(service, location) { + return new Reference(service, location); + } + /** + * A reference to the root of this object's bucket. + */ + get root() { + const location = new Location(this._location.bucket, ''); + return this._newRef(this._service, location); + } + /** + * The name of the bucket containing this reference's object. + */ + get bucket() { + return this._location.bucket; + } + /** + * The full path of this object. + */ + get fullPath() { + return this._location.path; + } + /** + * The short name of this object, which is the last component of the full path. + * For example, if fullPath is 'full/path/image.png', name is 'image.png'. + */ + get name() { + return lastComponent(this._location.path); + } + /** + * The `StorageService` instance this `StorageReference` is associated with. + */ + get storage() { + return this._service; + } + /** + * A `StorageReference` pointing to the parent location of this `StorageReference`, or null if + * this reference is the root. + */ + get parent() { + const newPath = parent(this._location.path); + if (newPath === null) { + return null; + } + const location = new Location(this._location.bucket, newPath); + return new Reference(this._service, location); + } + /** + * Utility function to throw an error in methods that do not accept a root reference. + */ + _throwIfRoot(name) { + if (this._location.path === '') { + throw invalidRootOperation(name); + } + } +} +/** + * Download the bytes at the object's location. + * @returns A Promise containing the downloaded bytes. + */ +function getBytesInternal(ref, maxDownloadSizeBytes) { + ref._throwIfRoot('getBytes'); + const requestInfo = getBytes$1(ref.storage, ref._location, maxDownloadSizeBytes); + return ref.storage + .makeRequestWithTokens(requestInfo, newBytesConnection) + .then(bytes => maxDownloadSizeBytes !== undefined + ? // GCS may not honor the Range header for small files + bytes.slice(0, maxDownloadSizeBytes) + : bytes); +} +/** Stream the bytes at the object's location. */ +function getStreamInternal(ref, maxDownloadSizeBytes) { + ref._throwIfRoot('getStream'); + const requestInfo = getBytes$1(ref.storage, ref._location, maxDownloadSizeBytes); + // Transforms the stream so that only `maxDownloadSizeBytes` bytes are piped to the result + const newMaxSizeTransform = (n) => { + let missingBytes = n; + return { + transform(chunk, controller) { + // GCS may not honor the Range header for small files + if (chunk.length < missingBytes) { + controller.enqueue(chunk); + missingBytes -= chunk.length; + } + else { + controller.enqueue(chunk.slice(0, missingBytes)); + controller.terminate(); + } + } + }; + }; + const result = maxDownloadSizeBytes !== undefined + ? new TransformStream(newMaxSizeTransform(maxDownloadSizeBytes)) + : new TransformStream(); // The default transformer forwards all chunks to its readable side + ref.storage + .makeRequestWithTokens(requestInfo, newStreamConnection) + .then(readableStream => readableStream.pipeThrough(result)) + .catch(err => result.writable.abort(err)); + return result.readable; +} +/** + * Uploads data to this object's location. + * The upload is not resumable. + * + * @param ref - StorageReference where data should be uploaded. + * @param data - The data to upload. + * @param metadata - Metadata for the newly uploaded data. + * @returns A Promise containing an UploadResult + */ +function uploadBytes$1(ref, data, metadata) { + ref._throwIfRoot('uploadBytes'); + const requestInfo = multipartUpload(ref.storage, ref._location, getMappings(), new FbsBlob(data, true), metadata); + return ref.storage + .makeRequestWithTokens(requestInfo, newTextConnection) + .then(finalMetadata => { + return { + metadata: finalMetadata, + ref + }; + }); +} +/** + * Uploads data to this object's location. + * The upload can be paused and resumed, and exposes progress updates. + * @public + * @param ref - StorageReference where data should be uploaded. + * @param data - The data to upload. + * @param metadata - Metadata for the newly uploaded data. + * @returns An UploadTask + */ +function uploadBytesResumable$1(ref, data, metadata) { + ref._throwIfRoot('uploadBytesResumable'); + return new UploadTask(ref, new FbsBlob(data), metadata); +} +/** + * Uploads a string to this object's location. + * The upload is not resumable. + * @public + * @param ref - StorageReference where string should be uploaded. + * @param value - The string to upload. + * @param format - The format of the string to upload. + * @param metadata - Metadata for the newly uploaded string. + * @returns A Promise containing an UploadResult + */ +function uploadString$1(ref, value, format = StringFormat.RAW, metadata) { + ref._throwIfRoot('uploadString'); + const data = dataFromString(format, value); + const metadataClone = { ...metadata }; + if (metadataClone['contentType'] == null && data.contentType != null) { + metadataClone['contentType'] = data.contentType; + } + return uploadBytes$1(ref, data.data, metadataClone); +} +/** + * List all items (files) and prefixes (folders) under this storage reference. + * + * This is a helper method for calling list() repeatedly until there are + * no more results. The default pagination size is 1000. + * + * Note: The results may not be consistent if objects are changed while this + * operation is running. + * + * Warning: listAll may potentially consume too many resources if there are + * too many results. + * @public + * @param ref - StorageReference to get list from. + * + * @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. + */ +function listAll$1(ref) { + const accumulator = { + prefixes: [], + items: [] + }; + return listAllHelper(ref, accumulator).then(() => accumulator); +} +/** + * Separated from listAll because async functions can't use "arguments". + * @param ref + * @param accumulator + * @param pageToken + */ +async function listAllHelper(ref, accumulator, pageToken) { + const opt = { + // maxResults is 1000 by default. + pageToken + }; + const nextPage = await list$1(ref, opt); + accumulator.prefixes.push(...nextPage.prefixes); + accumulator.items.push(...nextPage.items); + if (nextPage.nextPageToken != null) { + await listAllHelper(ref, accumulator, nextPage.nextPageToken); + } +} +/** + * List items (files) and prefixes (folders) under this storage 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. + * + * 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. + * @public + * + * @param ref - StorageReference to get list from. + * @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. + */ +function list$1(ref, options) { + if (options != null) { + if (typeof options.maxResults === 'number') { + validateNumber('options.maxResults', + /* minValue= */ 1, + /* maxValue= */ 1000, options.maxResults); + } + } + const op = options || {}; + const requestInfo = list$2(ref.storage, ref._location, + /*delimiter= */ '/', op.pageToken, op.maxResults); + return ref.storage.makeRequestWithTokens(requestInfo, newTextConnection); +} +/** + * A `Promise` that resolves with the metadata for this object. If this + * object doesn't exist or metadata cannot be retrieved, the promise is + * rejected. + * @public + * @param ref - StorageReference to get metadata from. + */ +function getMetadata$1(ref) { + ref._throwIfRoot('getMetadata'); + const requestInfo = getMetadata$2(ref.storage, ref._location, getMappings()); + return ref.storage.makeRequestWithTokens(requestInfo, newTextConnection); +} +/** + * Updates the metadata for this object. + * @public + * @param ref - StorageReference to update metadata for. + * @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. + * @returns A `Promise` that resolves + * with the new metadata for this object. + * See `firebaseStorage.Reference.prototype.getMetadata` + */ +function updateMetadata$1(ref, metadata) { + ref._throwIfRoot('updateMetadata'); + const requestInfo = updateMetadata$2(ref.storage, ref._location, metadata, getMappings()); + return ref.storage.makeRequestWithTokens(requestInfo, newTextConnection); +} +/** + * Returns the download URL for the given Reference. + * @public + * @returns A `Promise` that resolves with the download + * URL for this object. + */ +function getDownloadURL$1(ref) { + ref._throwIfRoot('getDownloadURL'); + const requestInfo = getDownloadUrl(ref.storage, ref._location, getMappings()); + return ref.storage + .makeRequestWithTokens(requestInfo, newTextConnection) + .then(url => { + if (url === null) { + throw noDownloadURL(); + } + return url; + }); +} +/** + * Deletes the object at this location. + * @public + * @param ref - StorageReference for object to delete. + * @returns A `Promise` that resolves if the deletion succeeds. + */ +function deleteObject$1(ref) { + ref._throwIfRoot('deleteObject'); + const requestInfo = deleteObject$2(ref.storage, ref._location); + return ref.storage.makeRequestWithTokens(requestInfo, newTextConnection); +} +/** + * Returns reference for object obtained by appending `childPath` to `ref`. + * + * @param ref - StorageReference to get child of. + * @param childPath - Child path from provided ref. + * @returns A reference to the object obtained by + * appending childPath, removing any duplicate, beginning, or trailing + * slashes. + * + */ +function _getChild$1(ref, childPath) { + const newPath = child(ref._location.path, childPath); + const location = new Location(ref._location.bucket, newPath); + return new Reference(ref.storage, location); +} + +/** + * @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. + */ +function isUrl(path) { + return /^[A-Za-z]+:\/\//.test(path); +} +/** + * Returns a firebaseStorage.Reference for the given url. + */ +function refFromURL(service, url) { + return new Reference(service, url); +} +/** + * Returns a firebaseStorage.Reference for the given path in the default + * bucket. + */ +function refFromPath(ref, path) { + if (ref instanceof FirebaseStorageImpl) { + const service = ref; + if (service._bucket == null) { + throw noDefaultBucket(); + } + const reference = new Reference(service, service._bucket); + if (path != null) { + return refFromPath(reference, path); + } + else { + return reference; + } + } + else { + // ref is a Reference + if (path !== undefined) { + return _getChild$1(ref, path); + } + else { + return ref; + } + } +} +function ref$1(serviceOrRef, pathOrUrl) { + if (pathOrUrl && isUrl(pathOrUrl)) { + if (serviceOrRef instanceof FirebaseStorageImpl) { + return refFromURL(serviceOrRef, pathOrUrl); + } + else { + throw invalidArgument('To use ref(service, url), the first argument must be a Storage instance.'); + } + } + else { + return refFromPath(serviceOrRef, pathOrUrl); + } +} +function extractBucket(host, config) { + const bucketString = config?.[CONFIG_STORAGE_BUCKET_KEY]; + if (bucketString == null) { + return null; + } + return Location.makeFromBucketSpec(bucketString, host); +} +function connectStorageEmulator$1(storage, host, port, options = {}) { + storage.host = `${host}:${port}`; + const useSsl = util.isCloudWorkstation(host); + // Workaround to get cookies in Firebase Studio + if (useSsl) { + void util.pingServer(`https://${storage.host}/b`); + util.updateEmulatorBanner('Storage', true); + } + storage._isUsingEmulator = true; + storage._protocol = useSsl ? 'https' : 'http'; + const { mockUserToken } = options; + if (mockUserToken) { + storage._overrideAuthToken = + typeof mockUserToken === 'string' + ? mockUserToken + : util.createMockUserToken(mockUserToken, storage.app.options.projectId); + } +} +/** + * A service that provides Firebase Storage Reference instances. + * @param opt_url - gs:// url to a custom Storage Bucket + * + * @internal + */ +class FirebaseStorageImpl { + constructor( + /** + * FirebaseApp associated with this StorageService instance. + */ + app, _authProvider, + /** + * @internal + */ + _appCheckProvider, + /** + * @internal + */ + _url, _firebaseVersion, _isUsingEmulator = false) { + this.app = app; + this._authProvider = _authProvider; + this._appCheckProvider = _appCheckProvider; + this._url = _url; + this._firebaseVersion = _firebaseVersion; + this._isUsingEmulator = _isUsingEmulator; + this._bucket = null; + /** + * This string can be in the formats: + * - host + * - host:port + */ + this._host = DEFAULT_HOST; + this._protocol = 'https'; + this._appId = null; + this._deleted = false; + this._maxOperationRetryTime = DEFAULT_MAX_OPERATION_RETRY_TIME; + this._maxUploadRetryTime = DEFAULT_MAX_UPLOAD_RETRY_TIME; + this._requests = new Set(); + if (_url != null) { + this._bucket = Location.makeFromBucketSpec(_url, this._host); + } + else { + this._bucket = extractBucket(this._host, this.app.options); + } + } + /** + * The host string for this service, in the form of `host` or + * `host:port`. + */ + get host() { + return this._host; + } + set host(host) { + this._host = host; + if (this._url != null) { + this._bucket = Location.makeFromBucketSpec(this._url, host); + } + else { + this._bucket = extractBucket(host, this.app.options); + } + } + /** + * The maximum time to retry uploads in milliseconds. + */ + get maxUploadRetryTime() { + return this._maxUploadRetryTime; + } + set maxUploadRetryTime(time) { + validateNumber('time', + /* minValue=*/ 0, + /* maxValue= */ Number.POSITIVE_INFINITY, time); + this._maxUploadRetryTime = time; + } + /** + * The maximum time to retry operations other than uploads or downloads in + * milliseconds. + */ + get maxOperationRetryTime() { + return this._maxOperationRetryTime; + } + set maxOperationRetryTime(time) { + validateNumber('time', + /* minValue=*/ 0, + /* maxValue= */ Number.POSITIVE_INFINITY, time); + this._maxOperationRetryTime = time; + } + async _getAuthToken() { + if (this._overrideAuthToken) { + return this._overrideAuthToken; + } + const auth = this._authProvider.getImmediate({ optional: true }); + if (auth) { + const tokenData = await auth.getToken(); + if (tokenData !== null) { + return tokenData.accessToken; + } + } + return null; + } + async _getAppCheckToken() { + if (app._isFirebaseServerApp(this.app) && this.app.settings.appCheckToken) { + return this.app.settings.appCheckToken; + } + const appCheck = this._appCheckProvider.getImmediate({ optional: true }); + if (appCheck) { + const result = await appCheck.getToken(); + // TODO: What do we want to do if there is an error getting the token? + // Context: appCheck.getToken() will never throw even if an error happened. In the error case, a dummy token will be + // returned along with an error field describing the error. In general, we shouldn't care about the error condition and just use + // the token (actual or dummy) to send requests. + return result.token; + } + return null; + } + /** + * Stop running requests and prevent more from being created. + */ + _delete() { + if (!this._deleted) { + this._deleted = true; + this._requests.forEach(request => request.cancel()); + this._requests.clear(); + } + return Promise.resolve(); + } + /** + * Returns a new firebaseStorage.Reference object referencing this StorageService + * at the given Location. + */ + _makeStorageReference(loc) { + return new Reference(this, loc); + } + /** + * @param requestInfo - HTTP RequestInfo object + * @param authToken - Firebase auth token + */ + _makeRequest(requestInfo, requestFactory, authToken, appCheckToken, retry = true) { + if (!this._deleted) { + const request = makeRequest(requestInfo, this._appId, authToken, appCheckToken, requestFactory, this._firebaseVersion, retry, this._isUsingEmulator); + this._requests.add(request); + // Request removes itself from set when complete. + request.getPromise().then(() => this._requests.delete(request), () => this._requests.delete(request)); + return request; + } + else { + return new FailRequest(appDeleted()); + } + } + async makeRequestWithTokens(requestInfo, requestFactory) { + const [authToken, appCheckToken] = await Promise.all([ + this._getAuthToken(), + this._getAppCheckToken() + ]); + return this._makeRequest(requestInfo, requestFactory, authToken, appCheckToken).getPromise(); + } +} + +const name = "@firebase/storage"; +const version = "0.14.0"; + +/** + * @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. + */ +/** + * Type constant for Firebase Storage. + */ +const STORAGE_TYPE = 'storage'; + +/** + * @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. + */ +/** + * Downloads the data at the object's location. Returns an error if the object + * is not found. + * + * To use this functionality, you have to whitelist your app's origin in your + * Cloud Storage bucket. See also + * https://cloud.google.com/storage/docs/configuring-cors + * + * @public + * @param ref - StorageReference where data should be downloaded. + * @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to + * retrieve. + * @returns A Promise containing the object's bytes + */ +function getBytes(ref, maxDownloadSizeBytes) { + ref = util.getModularInstance(ref); + return getBytesInternal(ref, maxDownloadSizeBytes); +} +/** + * Uploads data to this object's location. + * The upload is not resumable. + * @public + * @param ref - {@link StorageReference} where data should be uploaded. + * @param data - The data to upload. + * @param metadata - Metadata for the data to upload. + * @returns A Promise containing an UploadResult + */ +function uploadBytes(ref, data, metadata) { + ref = util.getModularInstance(ref); + return uploadBytes$1(ref, data, metadata); +} +/** + * Uploads a string to this object's location. + * The upload is not resumable. + * @public + * @param ref - {@link StorageReference} where string should be uploaded. + * @param value - The string to upload. + * @param format - The format of the string to upload. + * @param metadata - Metadata for the string to upload. + * @returns A Promise containing an UploadResult + */ +function uploadString(ref, value, format, metadata) { + ref = util.getModularInstance(ref); + return uploadString$1(ref, value, format, metadata); +} +/** + * Uploads data to this object's location. + * The upload can be paused and resumed, and exposes progress updates. + * @public + * @param ref - {@link StorageReference} where data should be uploaded. + * @param data - The data to upload. + * @param metadata - Metadata for the data to upload. + * @returns An UploadTask + */ +function uploadBytesResumable(ref, data, metadata) { + ref = util.getModularInstance(ref); + return uploadBytesResumable$1(ref, data, metadata); +} +/** + * A `Promise` that resolves with the metadata for this object. If this + * object doesn't exist or metadata cannot be retrieved, the promise is + * rejected. + * @public + * @param ref - {@link StorageReference} to get metadata from. + */ +function getMetadata(ref) { + ref = util.getModularInstance(ref); + return getMetadata$1(ref); +} +/** + * Updates the metadata for this object. + * @public + * @param ref - {@link StorageReference} to update metadata for. + * @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. + * @returns A `Promise` that resolves with the new metadata for this object. + */ +function updateMetadata(ref, metadata) { + ref = util.getModularInstance(ref); + return updateMetadata$1(ref, metadata); +} +/** + * List items (files) and prefixes (folders) under this storage 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. + * + * 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. + * @public + * + * @param ref - {@link StorageReference} to get list from. + * @param options - See {@link 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. + */ +function list(ref, options) { + ref = util.getModularInstance(ref); + return list$1(ref, options); +} +/** + * List all items (files) and prefixes (folders) under this storage reference. + * + * This is a helper method for calling list() repeatedly until there are + * no more results. The default pagination size is 1000. + * + * Note: The results may not be consistent if objects are changed while this + * operation is running. + * + * Warning: `listAll` may potentially consume too many resources if there are + * too many results. + * @public + * @param ref - {@link StorageReference} to get list from. + * + * @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. + */ +function listAll(ref) { + ref = util.getModularInstance(ref); + return listAll$1(ref); +} +/** + * Returns the download URL for the given {@link StorageReference}. + * @public + * @param ref - {@link StorageReference} to get the download URL for. + * @returns A `Promise` that resolves with the download + * URL for this object. + */ +function getDownloadURL(ref) { + ref = util.getModularInstance(ref); + return getDownloadURL$1(ref); +} +/** + * Deletes the object at this location. + * @public + * @param ref - {@link StorageReference} for object to delete. + * @returns A `Promise` that resolves if the deletion succeeds. + */ +function deleteObject(ref) { + ref = util.getModularInstance(ref); + return deleteObject$1(ref); +} +function ref(serviceOrRef, pathOrUrl) { + serviceOrRef = util.getModularInstance(serviceOrRef); + return ref$1(serviceOrRef, pathOrUrl); +} +/** + * @internal + */ +function _getChild(ref, childPath) { + return _getChild$1(ref, childPath); +} +/** + * Gets a {@link FirebaseStorage} instance for the given Firebase app. + * @public + * @param app - Firebase app to get {@link FirebaseStorage} instance for. + * @param bucketUrl - The gs:// url to your Firebase Storage Bucket. + * If not passed, uses the app's default Storage Bucket. + * @returns A {@link FirebaseStorage} instance. + */ +function getStorage(app$1 = app.getApp(), bucketUrl) { + app$1 = util.getModularInstance(app$1); + const storageProvider = app._getProvider(app$1, STORAGE_TYPE); + const storageInstance = storageProvider.getImmediate({ + identifier: bucketUrl + }); + const emulator = util.getDefaultEmulatorHostnameAndPort('storage'); + if (emulator) { + connectStorageEmulator(storageInstance, ...emulator); + } + return storageInstance; +} +/** + * Modify this {@link FirebaseStorage} instance to communicate with the Cloud Storage emulator. + * + * @param storage - The {@link FirebaseStorage} instance + * @param host - The emulator host (ex: localhost) + * @param port - The emulator port (ex: 5001) + * @param options - Emulator options. `options.mockUserToken` is the mock auth + * token to use for unit testing Security Rules. + * @public + */ +function connectStorageEmulator(storage, host, port, options = {}) { + connectStorageEmulator$1(storage, host, port, options); +} + +/** + * @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. + */ +/** + * Downloads the data at the object's location. Returns an error if the object + * is not found. + * + * To use this functionality, you have to whitelist your app's origin in your + * Cloud Storage bucket. See also + * https://cloud.google.com/storage/docs/configuring-cors + * + * This API is not available in Node. + * + * @public + * @param ref - StorageReference where data should be downloaded. + * @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to + * retrieve. + * @returns A Promise that resolves with a Blob containing the object's bytes + */ +// eslint-disable-next-line @typescript-eslint/no-unused-vars +function getBlob(ref, maxDownloadSizeBytes) { + throw new Error('getBlob() is only available in Browser-like environments'); +} +/** + * Downloads the data at the object's location. Raises an error event if the + * object is not found. + * + * This API is only available in Node. + * + * @public + * @param ref - StorageReference where data should be downloaded. + * @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to + * retrieve. + * @returns A stream with the object's data as bytes + */ +function getStream(ref, maxDownloadSizeBytes) { + ref = util.getModularInstance(ref); + return getStreamInternal(ref, maxDownloadSizeBytes); +} + +/** + * Cloud Storage for Firebase + * + * @packageDocumentation + */ +function factory(container, { instanceIdentifier: url }) { + const app$1 = container.getProvider('app').getImmediate(); + const authProvider = container.getProvider('auth-internal'); + const appCheckProvider = container.getProvider('app-check-internal'); + return new FirebaseStorageImpl(app$1, authProvider, appCheckProvider, url, app.SDK_VERSION); +} +function registerStorage() { + app._registerComponent(new component.Component(STORAGE_TYPE, factory, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true)); + app.registerVersion(name, version); +} +registerStorage(); + +exports.StorageError = StorageError; +exports.StringFormat = StringFormat; +exports._FbsBlob = FbsBlob; +exports._Location = Location; +exports._TaskEvent = TaskEvent; +exports._TaskState = TaskState; +exports._UploadTask = UploadTask; +exports._dataFromString = dataFromString; +exports._getChild = _getChild; +exports._invalidArgument = invalidArgument; +exports._invalidRootOperation = invalidRootOperation; +exports.connectStorageEmulator = connectStorageEmulator; +exports.deleteObject = deleteObject; +exports.getBlob = getBlob; +exports.getBytes = getBytes; +exports.getDownloadURL = getDownloadURL; +exports.getMetadata = getMetadata; +exports.getStorage = getStorage; +exports.getStream = getStream; +exports.list = list; +exports.listAll = listAll; +exports.ref = ref; +exports.updateMetadata = updateMetadata; +exports.uploadBytes = uploadBytes; +exports.uploadBytesResumable = uploadBytesResumable; +exports.uploadString = uploadString; +//# sourceMappingURL=index.node.cjs.js.map -- cgit v1.2.3