3856 lines
141 KiB
JavaScript
3856 lines
141 KiB
JavaScript
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
var app = require('@firebase/app');
|
|
var tslib = require('tslib');
|
|
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.
|
|
*/
|
|
var DEFAULT_HOST = 'firebasestorage.googleapis.com';
|
|
/**
|
|
* The key in Firebase config json for the storage bucket.
|
|
*/
|
|
var CONFIG_STORAGE_BUCKET_KEY = 'storageBucket';
|
|
/**
|
|
* 2 minutes
|
|
*
|
|
* The timeout for all operations except upload.
|
|
*/
|
|
var DEFAULT_MAX_OPERATION_RETRY_TIME = 2 * 60 * 1000;
|
|
/**
|
|
* 10 minutes
|
|
*
|
|
* The timeout for upload.
|
|
*/
|
|
var DEFAULT_MAX_UPLOAD_RETRY_TIME = 10 * 60 * 1000;
|
|
/**
|
|
* 1 second
|
|
*/
|
|
var 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
|
|
*/
|
|
var StorageError = /** @class */ (function (_super) {
|
|
tslib.__extends(StorageError, _super);
|
|
/**
|
|
* @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
|
|
*/
|
|
function StorageError(code, message, status_) {
|
|
if (status_ === void 0) { status_ = 0; }
|
|
var _this = _super.call(this, prependCode(code), "Firebase Storage: ".concat(message, " (").concat(prependCode(code), ")")) || this;
|
|
_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);
|
|
return _this;
|
|
}
|
|
Object.defineProperty(StorageError.prototype, "status", {
|
|
get: function () {
|
|
return this.status_;
|
|
},
|
|
set: function (status) {
|
|
this.status_ = status;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* Compares a `StorageErrorCode` against this error's code, filtering out the prefix.
|
|
*/
|
|
StorageError.prototype._codeEquals = function (code) {
|
|
return prependCode(code) === this.code;
|
|
};
|
|
Object.defineProperty(StorageError.prototype, "serverResponse", {
|
|
/**
|
|
* Optional response message that was added by the server.
|
|
*/
|
|
get: function () {
|
|
return this.customData.serverResponse;
|
|
},
|
|
set: function (serverResponse) {
|
|
this.customData.serverResponse = serverResponse;
|
|
if (this.customData.serverResponse) {
|
|
this.message = "".concat(this._baseMessage, "\n").concat(this.customData.serverResponse);
|
|
}
|
|
else {
|
|
this.message = this._baseMessage;
|
|
}
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
return StorageError;
|
|
}(util.FirebaseError));
|
|
/**
|
|
* @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() {
|
|
var 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() {
|
|
var 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.');
|
|
}
|
|
function missingPolyFill(polyFill) {
|
|
return new StorageError(exports.StorageErrorCode.UNSUPPORTED_ENVIRONMENT, "".concat(polyFill, " is missing. Make sure to install the required polyfills. See https://firebase.google.com/docs/web/environments-js-sdk#polyfills for more information."));
|
|
}
|
|
/**
|
|
* @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
|
|
*/
|
|
var Location = /** @class */ (function () {
|
|
function Location(bucket, path) {
|
|
this.bucket = bucket;
|
|
this.path_ = path;
|
|
}
|
|
Object.defineProperty(Location.prototype, "path", {
|
|
get: function () {
|
|
return this.path_;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Location.prototype, "isRoot", {
|
|
get: function () {
|
|
return this.path.length === 0;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Location.prototype.fullServerUrl = function () {
|
|
var encode = encodeURIComponent;
|
|
return '/b/' + encode(this.bucket) + '/o/' + encode(this.path);
|
|
};
|
|
Location.prototype.bucketOnlyServerUrl = function () {
|
|
var encode = encodeURIComponent;
|
|
return '/b/' + encode(this.bucket) + '/o';
|
|
};
|
|
Location.makeFromBucketSpec = function (bucketString, host) {
|
|
var 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);
|
|
}
|
|
};
|
|
Location.makeFromUrl = function (url, host) {
|
|
var location = null;
|
|
var bucketDomain = '([A-Za-z0-9.\\-_]+)';
|
|
function gsModify(loc) {
|
|
if (loc.path.charAt(loc.path.length - 1) === '/') {
|
|
loc.path_ = loc.path_.slice(0, -1);
|
|
}
|
|
}
|
|
var gsPath = '(/(.*))?$';
|
|
var gsRegex = new RegExp('^gs://' + bucketDomain + gsPath, 'i');
|
|
var gsIndices = { bucket: 1, path: 3 };
|
|
function httpModify(loc) {
|
|
loc.path_ = decodeURIComponent(loc.path);
|
|
}
|
|
var version = 'v[A-Za-z0-9_]+';
|
|
var firebaseStorageHost = host.replace(/[.]/g, '\\.');
|
|
var firebaseStoragePath = '(/([^?#]*).*)?$';
|
|
var firebaseStorageRegExp = new RegExp("^https?://".concat(firebaseStorageHost, "/").concat(version, "/b/").concat(bucketDomain, "/o").concat(firebaseStoragePath), 'i');
|
|
var firebaseStorageIndices = { bucket: 1, path: 3 };
|
|
var cloudStorageHost = host === DEFAULT_HOST
|
|
? '(?:storage.googleapis.com|storage.cloud.google.com)'
|
|
: host;
|
|
var cloudStoragePath = '([^?#]*)';
|
|
var cloudStorageRegExp = new RegExp("^https?://".concat(cloudStorageHost, "/").concat(bucketDomain, "/").concat(cloudStoragePath), 'i');
|
|
var cloudStorageIndices = { bucket: 1, path: 2 };
|
|
var groups = [
|
|
{ regex: gsRegex, indices: gsIndices, postModify: gsModify },
|
|
{
|
|
regex: firebaseStorageRegExp,
|
|
indices: firebaseStorageIndices,
|
|
postModify: httpModify
|
|
},
|
|
{
|
|
regex: cloudStorageRegExp,
|
|
indices: cloudStorageIndices,
|
|
postModify: httpModify
|
|
}
|
|
];
|
|
for (var i = 0; i < groups.length; i++) {
|
|
var group = groups[i];
|
|
var captures = group.regex.exec(url);
|
|
if (captures) {
|
|
var bucketValue = captures[group.indices.bucket];
|
|
var 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;
|
|
};
|
|
return Location;
|
|
}());
|
|
|
|
/**
|
|
* A request whose promise always fails.
|
|
*/
|
|
var FailRequest = /** @class */ (function () {
|
|
function FailRequest(error) {
|
|
this.promise_ = Promise.reject(error);
|
|
}
|
|
/** @inheritDoc */
|
|
FailRequest.prototype.getPromise = function () {
|
|
return this.promise_;
|
|
};
|
|
/** @inheritDoc */
|
|
FailRequest.prototype.cancel = function (_appDelete) {
|
|
};
|
|
return FailRequest;
|
|
}());
|
|
|
|
/**
|
|
* @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)
|
|
var 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
|
|
var retryTimeoutId = null;
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
var globalTimeoutId = null;
|
|
var hitTimeout = false;
|
|
var cancelState = 0;
|
|
function canceled() {
|
|
return cancelState === 2;
|
|
}
|
|
var triggeredCallback = false;
|
|
function triggerCallback() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
if (!triggeredCallback) {
|
|
triggeredCallback = true;
|
|
backoffCompleteCb.apply(null, args);
|
|
}
|
|
}
|
|
function callWithDelay(millis) {
|
|
retryTimeoutId = setTimeout(function () {
|
|
retryTimeoutId = null;
|
|
doRequest(responseHandler, canceled());
|
|
}, millis);
|
|
}
|
|
function clearGlobalTimeout() {
|
|
if (globalTimeoutId) {
|
|
clearTimeout(globalTimeoutId);
|
|
}
|
|
}
|
|
function responseHandler(success) {
|
|
var args = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
args[_i - 1] = arguments[_i];
|
|
}
|
|
if (triggeredCallback) {
|
|
clearGlobalTimeout();
|
|
return;
|
|
}
|
|
if (success) {
|
|
clearGlobalTimeout();
|
|
triggerCallback.call.apply(triggerCallback, tslib.__spreadArray([null, success], args, false));
|
|
return;
|
|
}
|
|
var mustStop = canceled() || hitTimeout;
|
|
if (mustStop) {
|
|
clearGlobalTimeout();
|
|
triggerCallback.call.apply(triggerCallback, tslib.__spreadArray([null, success], args, false));
|
|
return;
|
|
}
|
|
if (waitSeconds < 64) {
|
|
/* TODO(andysoto): don't back off so quickly if we know we're offline. */
|
|
waitSeconds *= 2;
|
|
}
|
|
var waitMillis;
|
|
if (cancelState === 1) {
|
|
cancelState = 2;
|
|
waitMillis = 0;
|
|
}
|
|
else {
|
|
waitMillis = (waitSeconds + Math.random()) * 1000;
|
|
}
|
|
callWithDelay(waitMillis);
|
|
}
|
|
var 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(function () {
|
|
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 '".concat(argument, "'. Expected ").concat(minValue, " or greater."));
|
|
}
|
|
if (value > maxValue) {
|
|
throw invalidArgument("Invalid value for '".concat(argument, "'. Expected ").concat(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) {
|
|
var origin = host;
|
|
if (protocol == null) {
|
|
origin = "https://".concat(host);
|
|
}
|
|
return "".concat(protocol, "://").concat(origin, "/v0").concat(urlPart);
|
|
}
|
|
function makeQueryString(params) {
|
|
var encode = encodeURIComponent;
|
|
var queryPart = '?';
|
|
for (var key in params) {
|
|
if (params.hasOwnProperty(key)) {
|
|
var nextPart = encode(key) + '=' + encode(params[key]);
|
|
queryPart = queryPart + nextPart + '&';
|
|
}
|
|
}
|
|
// Chop off the extra '&' or '?' on the end
|
|
queryPart = queryPart.slice(0, -1);
|
|
return queryPart;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* Error codes for requests made by the the XhrIo wrapper.
|
|
*/
|
|
var ErrorCode;
|
|
(function (ErrorCode) {
|
|
ErrorCode[ErrorCode["NO_ERROR"] = 0] = "NO_ERROR";
|
|
ErrorCode[ErrorCode["NETWORK_ERROR"] = 1] = "NETWORK_ERROR";
|
|
ErrorCode[ErrorCode["ABORT"] = 2] = "ABORT";
|
|
})(ErrorCode || (ErrorCode = {}));
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 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
|
|
var isFiveHundredCode = status >= 500 && status < 600;
|
|
var extraRetryCodes = [
|
|
// Request Timeout: web server didn't receive full request in time.
|
|
408,
|
|
// Too Many Requests: you're getting rate-limited, basically.
|
|
429
|
|
];
|
|
var isExtraRetryCode = extraRetryCodes.indexOf(status) !== -1;
|
|
var 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_`.
|
|
*/
|
|
var NetworkRequest = /** @class */ (function () {
|
|
function NetworkRequest(url_, method_, headers_, body_, successCodes_, additionalRetryCodes_, callback_, errorCallback_, timeout_, progressCallback_, connectionFactory_, retry) {
|
|
if (retry === void 0) { retry = true; }
|
|
var _this = this;
|
|
this.url_ = url_;
|
|
this.method_ = method_;
|
|
this.headers_ = headers_;
|
|
this.body_ = body_;
|
|
this.successCodes_ = successCodes_;
|
|
this.additionalRetryCodes_ = additionalRetryCodes_;
|
|
this.callback_ = callback_;
|
|
this.errorCallback_ = errorCallback_;
|
|
this.timeout_ = timeout_;
|
|
this.progressCallback_ = progressCallback_;
|
|
this.connectionFactory_ = connectionFactory_;
|
|
this.retry = retry;
|
|
this.pendingConnection_ = null;
|
|
this.backoffId_ = null;
|
|
this.canceled_ = false;
|
|
this.appDelete_ = false;
|
|
this.promise_ = new Promise(function (resolve, reject) {
|
|
_this.resolve_ = resolve;
|
|
_this.reject_ = reject;
|
|
_this.start_();
|
|
});
|
|
}
|
|
/**
|
|
* Actually starts the retry loop.
|
|
*/
|
|
NetworkRequest.prototype.start_ = function () {
|
|
var _this = this;
|
|
var doTheRequest = function (backoffCallback, canceled) {
|
|
if (canceled) {
|
|
backoffCallback(false, new RequestEndStatus(false, null, true));
|
|
return;
|
|
}
|
|
var connection = _this.connectionFactory_();
|
|
_this.pendingConnection_ = connection;
|
|
var progressListener = function (progressEvent) {
|
|
var loaded = progressEvent.loaded;
|
|
var 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.body_, _this.headers_)
|
|
.then(function () {
|
|
if (_this.progressCallback_ !== null) {
|
|
connection.removeUploadProgressListener(progressListener);
|
|
}
|
|
_this.pendingConnection_ = null;
|
|
var hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR;
|
|
var status = connection.getStatus();
|
|
if (!hitServer ||
|
|
(isRetryStatusCode(status, _this.additionalRetryCodes_) &&
|
|
_this.retry)) {
|
|
var wasCanceled = connection.getErrorCode() === ErrorCode.ABORT;
|
|
backoffCallback(false, new RequestEndStatus(false, null, wasCanceled));
|
|
return;
|
|
}
|
|
var successCode = _this.successCodes_.indexOf(status) !== -1;
|
|
backoffCallback(true, new RequestEndStatus(successCode, connection));
|
|
});
|
|
};
|
|
/**
|
|
* @param requestWentThrough - True if the request eventually went
|
|
* through, false if it hit the retry limit or was canceled.
|
|
*/
|
|
var backoffDone = function (requestWentThrough, status) {
|
|
var resolve = _this.resolve_;
|
|
var reject = _this.reject_;
|
|
var connection = status.connection;
|
|
if (status.wasSuccessCode) {
|
|
try {
|
|
var result = _this.callback_(connection, connection.getResponse());
|
|
if (isJustDef(result)) {
|
|
resolve(result);
|
|
}
|
|
else {
|
|
resolve();
|
|
}
|
|
}
|
|
catch (e) {
|
|
reject(e);
|
|
}
|
|
}
|
|
else {
|
|
if (connection !== null) {
|
|
var err = unknown();
|
|
err.serverResponse = connection.getErrorText();
|
|
if (_this.errorCallback_) {
|
|
reject(_this.errorCallback_(connection, err));
|
|
}
|
|
else {
|
|
reject(err);
|
|
}
|
|
}
|
|
else {
|
|
if (status.canceled) {
|
|
var err = _this.appDelete_ ? appDeleted() : canceled();
|
|
reject(err);
|
|
}
|
|
else {
|
|
var err = retryLimitExceeded();
|
|
reject(err);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
if (this.canceled_) {
|
|
backoffDone(false, new RequestEndStatus(false, null, true));
|
|
}
|
|
else {
|
|
this.backoffId_ = start(doTheRequest, backoffDone, this.timeout_);
|
|
}
|
|
};
|
|
/** @inheritDoc */
|
|
NetworkRequest.prototype.getPromise = function () {
|
|
return this.promise_;
|
|
};
|
|
/** @inheritDoc */
|
|
NetworkRequest.prototype.cancel = function (appDelete) {
|
|
this.canceled_ = true;
|
|
this.appDelete_ = appDelete || false;
|
|
if (this.backoffId_ !== null) {
|
|
stop(this.backoffId_);
|
|
}
|
|
if (this.pendingConnection_ !== null) {
|
|
this.pendingConnection_.abort();
|
|
}
|
|
};
|
|
return NetworkRequest;
|
|
}());
|
|
/**
|
|
* A collection of information about the result of a network request.
|
|
* @param opt_canceled - Defaults to false.
|
|
*/
|
|
var RequestEndStatus = /** @class */ (function () {
|
|
function RequestEndStatus(wasSuccessCode, connection, canceled) {
|
|
this.wasSuccessCode = wasSuccessCode;
|
|
this.connection = connection;
|
|
this.canceled = !!canceled;
|
|
}
|
|
return RequestEndStatus;
|
|
}());
|
|
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 !== null && firebaseVersion !== void 0 ? 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) {
|
|
if (retry === void 0) { retry = true; }
|
|
var queryPart = makeQueryString(requestInfo.urlParams);
|
|
var url = requestInfo.url + queryPart;
|
|
var 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);
|
|
}
|
|
|
|
/**
|
|
* @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() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var BlobBuilder = getBlobBuilder();
|
|
if (BlobBuilder !== undefined) {
|
|
var bb = new BlobBuilder();
|
|
for (var 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) {
|
|
if (typeof atob === 'undefined') {
|
|
throw missingPolyFill('base-64');
|
|
}
|
|
return atob(encoded);
|
|
}
|
|
|
|
/**
|
|
* @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
|
|
*/
|
|
var 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'
|
|
};
|
|
var StringData = /** @class */ (function () {
|
|
function StringData(data, contentType) {
|
|
this.data = data;
|
|
this.contentType = contentType || null;
|
|
}
|
|
return StringData;
|
|
}());
|
|
/**
|
|
* @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) {
|
|
var b = [];
|
|
for (var i = 0; i < value.length; i++) {
|
|
var 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.
|
|
var 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 {
|
|
var hi = c;
|
|
var 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) {
|
|
var 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: {
|
|
var hasMinus = value.indexOf('-') !== -1;
|
|
var hasUnder = value.indexOf('_') !== -1;
|
|
if (hasMinus || hasUnder) {
|
|
var invalidChar = hasMinus ? '-' : '_';
|
|
throw invalidFormat(format, "Invalid character '" +
|
|
invalidChar +
|
|
"' found: is it base64url encoded?");
|
|
}
|
|
break;
|
|
}
|
|
case StringFormat.BASE64URL: {
|
|
var hasPlus = value.indexOf('+') !== -1;
|
|
var hasSlash = value.indexOf('/') !== -1;
|
|
if (hasPlus || hasSlash) {
|
|
var invalidChar = hasPlus ? '+' : '/';
|
|
throw invalidFormat(format, "Invalid character '" + invalidChar + "' found: is it base64 encoded?");
|
|
}
|
|
value = value.replace(/-/g, '+').replace(/_/g, '/');
|
|
break;
|
|
}
|
|
// do nothing
|
|
}
|
|
var bytes;
|
|
try {
|
|
bytes = decodeBase64(value);
|
|
}
|
|
catch (e) {
|
|
if (e.message.includes('polyfill')) {
|
|
throw e;
|
|
}
|
|
throw invalidFormat(format, 'Invalid character found');
|
|
}
|
|
var array = new Uint8Array(bytes.length);
|
|
for (var i = 0; i < bytes.length; i++) {
|
|
array[i] = bytes.charCodeAt(i);
|
|
}
|
|
return array;
|
|
}
|
|
var DataURLParts = /** @class */ (function () {
|
|
function DataURLParts(dataURL) {
|
|
this.base64 = false;
|
|
this.contentType = null;
|
|
var matches = dataURL.match(/^data:([^,]+)?,/);
|
|
if (matches === null) {
|
|
throw invalidFormat(StringFormat.DATA_URL, "Must be formatted 'data:[<mediatype>][;base64],<data>");
|
|
}
|
|
var 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);
|
|
}
|
|
return DataURLParts;
|
|
}());
|
|
function dataURLBytes_(dataUrl) {
|
|
var parts = new DataURLParts(dataUrl);
|
|
if (parts.base64) {
|
|
return base64Bytes_(StringFormat.BASE64, parts.rest);
|
|
}
|
|
else {
|
|
return percentEncodedBytes_(parts.rest);
|
|
}
|
|
}
|
|
function dataURLContentType_(dataUrl) {
|
|
var parts = new DataURLParts(dataUrl);
|
|
return parts.contentType;
|
|
}
|
|
function endsWith(s, end) {
|
|
var 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
|
|
*/
|
|
var FbsBlob = /** @class */ (function () {
|
|
function FbsBlob(data, elideCopy) {
|
|
var size = 0;
|
|
var 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;
|
|
}
|
|
FbsBlob.prototype.size = function () {
|
|
return this.size_;
|
|
};
|
|
FbsBlob.prototype.type = function () {
|
|
return this.type_;
|
|
};
|
|
FbsBlob.prototype.slice = function (startByte, endByte) {
|
|
if (isNativeBlob(this.data_)) {
|
|
var realBlob = this.data_;
|
|
var sliced = sliceBlob(realBlob, startByte, endByte);
|
|
if (sliced === null) {
|
|
return null;
|
|
}
|
|
return new FbsBlob(sliced);
|
|
}
|
|
else {
|
|
var slice = new Uint8Array(this.data_.buffer, startByte, endByte - startByte);
|
|
return new FbsBlob(slice, true);
|
|
}
|
|
};
|
|
FbsBlob.getBlob = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
if (isNativeBlobDefined()) {
|
|
var blobby = args.map(function (val) {
|
|
if (val instanceof FbsBlob) {
|
|
return val.data_;
|
|
}
|
|
else {
|
|
return val;
|
|
}
|
|
});
|
|
return new FbsBlob(getBlob$1.apply(null, blobby));
|
|
}
|
|
else {
|
|
var uint8Arrays = args.map(function (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_;
|
|
}
|
|
});
|
|
var finalLength_1 = 0;
|
|
uint8Arrays.forEach(function (array) {
|
|
finalLength_1 += array.byteLength;
|
|
});
|
|
var merged_1 = new Uint8Array(finalLength_1);
|
|
var index_1 = 0;
|
|
uint8Arrays.forEach(function (array) {
|
|
for (var i = 0; i < array.length; i++) {
|
|
merged_1[index_1++] = array[i];
|
|
}
|
|
});
|
|
return new FbsBlob(merged_1, true);
|
|
}
|
|
};
|
|
FbsBlob.prototype.uploadData = function () {
|
|
return this.data_;
|
|
};
|
|
return FbsBlob;
|
|
}());
|
|
|
|
/**
|
|
* @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) {
|
|
var 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;
|
|
}
|
|
var index = path.lastIndexOf('/');
|
|
if (index === -1) {
|
|
return '';
|
|
}
|
|
var newPath = path.slice(0, index);
|
|
return newPath;
|
|
}
|
|
function child(path, childPath) {
|
|
var canonicalChildPath = childPath
|
|
.split('/')
|
|
.filter(function (component) { return 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) {
|
|
var 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;
|
|
}
|
|
var Mapping = /** @class */ (function () {
|
|
function Mapping(server, local, writable, xform) {
|
|
this.server = server;
|
|
this.local = local || server;
|
|
this.writable = !!writable;
|
|
this.xform = xform || noXform_;
|
|
}
|
|
return Mapping;
|
|
}());
|
|
var mappings_ = null;
|
|
function xformPath(fullPath) {
|
|
if (!isString(fullPath) || fullPath.length < 2) {
|
|
return fullPath;
|
|
}
|
|
else {
|
|
return lastComponent(fullPath);
|
|
}
|
|
}
|
|
function getMappings() {
|
|
if (mappings_) {
|
|
return mappings_;
|
|
}
|
|
var 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);
|
|
}
|
|
var 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;
|
|
}
|
|
}
|
|
var 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() {
|
|
var bucket = metadata['bucket'];
|
|
var path = metadata['fullPath'];
|
|
var loc = new Location(bucket, path);
|
|
return service._makeStorageReference(loc);
|
|
}
|
|
Object.defineProperty(metadata, 'ref', { get: generateRef });
|
|
}
|
|
function fromResource(service, resource, mappings) {
|
|
var metadata = {};
|
|
metadata['type'] = 'file';
|
|
var len = mappings.length;
|
|
for (var i = 0; i < len; i++) {
|
|
var mapping = mappings[i];
|
|
metadata[mapping.local] = mapping.xform(metadata, resource[mapping.server]);
|
|
}
|
|
addRef(metadata, service);
|
|
return metadata;
|
|
}
|
|
function fromResourceString(service, resourceString, mappings) {
|
|
var obj = jsonObjectOrNull(resourceString);
|
|
if (obj === null) {
|
|
return null;
|
|
}
|
|
var resource = obj;
|
|
return fromResource(service, resource, mappings);
|
|
}
|
|
function downloadUrlFromResourceString(metadata, resourceString, host, protocol) {
|
|
var 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;
|
|
}
|
|
var tokens = obj['downloadTokens'];
|
|
if (tokens.length === 0) {
|
|
return null;
|
|
}
|
|
var encode = encodeURIComponent;
|
|
var tokensList = tokens.split(',');
|
|
var urls = tokensList.map(function (token) {
|
|
var bucket = metadata['bucket'];
|
|
var path = metadata['fullPath'];
|
|
var urlPart = '/b/' + encode(bucket) + '/o/' + encode(path);
|
|
var base = makeUrl(urlPart, host, protocol);
|
|
var queryString = makeQueryString({
|
|
alt: 'media',
|
|
token: token
|
|
});
|
|
return base + queryString;
|
|
});
|
|
return urls[0];
|
|
}
|
|
function toResourceString(metadata, mappings) {
|
|
var resource = {};
|
|
var len = mappings.length;
|
|
for (var i = 0; i < len; i++) {
|
|
var 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.
|
|
*/
|
|
var PREFIXES_KEY = 'prefixes';
|
|
var ITEMS_KEY = 'items';
|
|
function fromBackendResponse(service, bucket, resource) {
|
|
var listResult = {
|
|
prefixes: [],
|
|
items: [],
|
|
nextPageToken: resource['nextPageToken']
|
|
};
|
|
if (resource[PREFIXES_KEY]) {
|
|
for (var _i = 0, _a = resource[PREFIXES_KEY]; _i < _a.length; _i++) {
|
|
var path = _a[_i];
|
|
var pathWithoutTrailingSlash = path.replace(/\/$/, '');
|
|
var reference = service._makeStorageReference(new Location(bucket, pathWithoutTrailingSlash));
|
|
listResult.prefixes.push(reference);
|
|
}
|
|
}
|
|
if (resource[ITEMS_KEY]) {
|
|
for (var _b = 0, _c = resource[ITEMS_KEY]; _b < _c.length; _b++) {
|
|
var item = _c[_b];
|
|
var reference = service._makeStorageReference(new Location(bucket, item['name']));
|
|
listResult.items.push(reference);
|
|
}
|
|
}
|
|
return listResult;
|
|
}
|
|
function fromResponseString(service, bucket, resourceString) {
|
|
var obj = jsonObjectOrNull(resourceString);
|
|
if (obj === null) {
|
|
return null;
|
|
}
|
|
var 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.
|
|
*/
|
|
var RequestInfo = /** @class */ (function () {
|
|
function RequestInfo(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 = [];
|
|
}
|
|
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.
|
|
*/
|
|
/**
|
|
* Throws the UNKNOWN StorageError if cndn is false.
|
|
*/
|
|
function handlerCheck(cndn) {
|
|
if (!cndn) {
|
|
throw unknown();
|
|
}
|
|
}
|
|
function metadataHandler(service, mappings) {
|
|
function handler(xhr, text) {
|
|
var metadata = fromResourceString(service, text, mappings);
|
|
handlerCheck(metadata !== null);
|
|
return metadata;
|
|
}
|
|
return handler;
|
|
}
|
|
function listHandler(service, bucket) {
|
|
function handler(xhr, text) {
|
|
var listResult = fromResponseString(service, bucket, text);
|
|
handlerCheck(listResult !== null);
|
|
return listResult;
|
|
}
|
|
return handler;
|
|
}
|
|
function downloadUrlHandler(service, mappings) {
|
|
function handler(xhr, text) {
|
|
var 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) {
|
|
var 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) {
|
|
var shared = sharedErrorHandler(location);
|
|
function errorHandler(xhr, err) {
|
|
var 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) {
|
|
var urlPart = location.fullServerUrl();
|
|
var url = makeUrl(urlPart, service.host, service._protocol);
|
|
var method = 'GET';
|
|
var timeout = service.maxOperationRetryTime;
|
|
var requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout);
|
|
requestInfo.errorHandler = objectErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
function list$2(service, location, delimiter, pageToken, maxResults) {
|
|
var 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;
|
|
}
|
|
var urlPart = location.bucketOnlyServerUrl();
|
|
var url = makeUrl(urlPart, service.host, service._protocol);
|
|
var method = 'GET';
|
|
var timeout = service.maxOperationRetryTime;
|
|
var 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) {
|
|
var urlPart = location.fullServerUrl();
|
|
var url = makeUrl(urlPart, service.host, service._protocol) + '?alt=media';
|
|
var method = 'GET';
|
|
var timeout = service.maxOperationRetryTime;
|
|
var requestInfo = new RequestInfo(url, method, function (_, data) { return data; }, timeout);
|
|
requestInfo.errorHandler = objectErrorHandler(location);
|
|
if (maxDownloadSizeBytes !== undefined) {
|
|
requestInfo.headers['Range'] = "bytes=0-".concat(maxDownloadSizeBytes);
|
|
requestInfo.successCodes = [200 /* OK */, 206 /* Partial Content */];
|
|
}
|
|
return requestInfo;
|
|
}
|
|
function getDownloadUrl(service, location, mappings) {
|
|
var urlPart = location.fullServerUrl();
|
|
var url = makeUrl(urlPart, service.host, service._protocol);
|
|
var method = 'GET';
|
|
var timeout = service.maxOperationRetryTime;
|
|
var requestInfo = new RequestInfo(url, method, downloadUrlHandler(service, mappings), timeout);
|
|
requestInfo.errorHandler = objectErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
function updateMetadata$2(service, location, metadata, mappings) {
|
|
var urlPart = location.fullServerUrl();
|
|
var url = makeUrl(urlPart, service.host, service._protocol);
|
|
var method = 'PATCH';
|
|
var body = toResourceString(metadata, mappings);
|
|
var headers = { 'Content-Type': 'application/json; charset=utf-8' };
|
|
var timeout = service.maxOperationRetryTime;
|
|
var 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) {
|
|
var urlPart = location.fullServerUrl();
|
|
var url = makeUrl(urlPart, service.host, service._protocol);
|
|
var method = 'DELETE';
|
|
var timeout = service.maxOperationRetryTime;
|
|
function handler(_xhr, _text) { }
|
|
var 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) {
|
|
var 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) {
|
|
var urlPart = location.bucketOnlyServerUrl();
|
|
var headers = {
|
|
'X-Goog-Upload-Protocol': 'multipart'
|
|
};
|
|
function genBoundary() {
|
|
var str = '';
|
|
for (var i = 0; i < 2; i++) {
|
|
str = str + Math.random().toString().slice(2);
|
|
}
|
|
return str;
|
|
}
|
|
var boundary = genBoundary();
|
|
headers['Content-Type'] = 'multipart/related; boundary=' + boundary;
|
|
var metadata_ = metadataForUpload_(location, blob, metadata);
|
|
var metadataString = toResourceString(metadata_, mappings);
|
|
var 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';
|
|
var postBlobPart = '\r\n--' + boundary + '--';
|
|
var body = FbsBlob.getBlob(preBlobPart, blob, postBlobPart);
|
|
if (body === null) {
|
|
throw cannotSliceBlob();
|
|
}
|
|
var urlParams = { name: metadata_['fullPath'] };
|
|
var url = makeUrl(urlPart, service.host, service._protocol);
|
|
var method = 'POST';
|
|
var timeout = service.maxUploadRetryTime;
|
|
var 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.
|
|
*/
|
|
var ResumableUploadStatus = /** @class */ (function () {
|
|
function ResumableUploadStatus(current, total, finalized, metadata) {
|
|
this.current = current;
|
|
this.total = total;
|
|
this.finalized = !!finalized;
|
|
this.metadata = metadata || null;
|
|
}
|
|
return ResumableUploadStatus;
|
|
}());
|
|
function checkResumeHeader_(xhr, allowed) {
|
|
var status = null;
|
|
try {
|
|
status = xhr.getResponseHeader('X-Goog-Upload-Status');
|
|
}
|
|
catch (e) {
|
|
handlerCheck(false);
|
|
}
|
|
var allowedStatus = allowed || ['active'];
|
|
handlerCheck(!!status && allowedStatus.indexOf(status) !== -1);
|
|
return status;
|
|
}
|
|
function createResumableUpload(service, location, mappings, blob, metadata) {
|
|
var urlPart = location.bucketOnlyServerUrl();
|
|
var metadataForUpload = metadataForUpload_(location, blob, metadata);
|
|
var urlParams = { name: metadataForUpload['fullPath'] };
|
|
var url = makeUrl(urlPart, service.host, service._protocol);
|
|
var method = 'POST';
|
|
var headers = {
|
|
'X-Goog-Upload-Protocol': 'resumable',
|
|
'X-Goog-Upload-Command': 'start',
|
|
'X-Goog-Upload-Header-Content-Length': "".concat(blob.size()),
|
|
'X-Goog-Upload-Header-Content-Type': metadataForUpload['contentType'],
|
|
'Content-Type': 'application/json; charset=utf-8'
|
|
};
|
|
var body = toResourceString(metadataForUpload, mappings);
|
|
var timeout = service.maxUploadRetryTime;
|
|
function handler(xhr) {
|
|
checkResumeHeader_(xhr);
|
|
var url;
|
|
try {
|
|
url = xhr.getResponseHeader('X-Goog-Upload-URL');
|
|
}
|
|
catch (e) {
|
|
handlerCheck(false);
|
|
}
|
|
handlerCheck(isString(url));
|
|
return url;
|
|
}
|
|
var 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) {
|
|
var headers = { 'X-Goog-Upload-Command': 'query' };
|
|
function handler(xhr) {
|
|
var status = checkResumeHeader_(xhr, ['active', 'final']);
|
|
var sizeString = null;
|
|
try {
|
|
sizeString = xhr.getResponseHeader('X-Goog-Upload-Size-Received');
|
|
}
|
|
catch (e) {
|
|
handlerCheck(false);
|
|
}
|
|
if (!sizeString) {
|
|
// null or empty string
|
|
handlerCheck(false);
|
|
}
|
|
var size = Number(sizeString);
|
|
handlerCheck(!isNaN(size));
|
|
return new ResumableUploadStatus(size, blob.size(), status === 'final');
|
|
}
|
|
var method = 'POST';
|
|
var timeout = service.maxUploadRetryTime;
|
|
var 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.
|
|
*/
|
|
var 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));
|
|
var 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();
|
|
}
|
|
var bytesLeft = status_.total - status_.current;
|
|
var bytesToUpload = bytesLeft;
|
|
if (chunkSize > 0) {
|
|
bytesToUpload = Math.min(bytesToUpload, chunkSize);
|
|
}
|
|
var startByte = status_.current;
|
|
var endByte = startByte + bytesToUpload;
|
|
var uploadCommand = '';
|
|
if (bytesToUpload === 0) {
|
|
uploadCommand = 'finalize';
|
|
}
|
|
else if (bytesLeft === bytesToUpload) {
|
|
uploadCommand = 'upload, finalize';
|
|
}
|
|
else {
|
|
uploadCommand = 'upload';
|
|
}
|
|
var headers = {
|
|
'X-Goog-Upload-Command': uploadCommand,
|
|
'X-Goog-Upload-Offset': "".concat(status_.current)
|
|
};
|
|
var 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.
|
|
var uploadStatus = checkResumeHeader_(xhr, ['active', 'final']);
|
|
var newCurrent = status_.current + bytesToUpload;
|
|
var size = blob.size();
|
|
var metadata;
|
|
if (uploadStatus === 'final') {
|
|
metadata = metadataHandler(service, mappings)(xhr, text);
|
|
}
|
|
else {
|
|
metadata = null;
|
|
}
|
|
return new ResumableUploadStatus(newCurrent, size, uploadStatus === 'final', metadata);
|
|
}
|
|
var method = 'POST';
|
|
var timeout = service.maxUploadRetryTime;
|
|
var 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
|
|
*/
|
|
var TaskEvent = {
|
|
/**
|
|
* For this event,
|
|
* <ul>
|
|
* <li>The `next` function is triggered on progress updates and when the
|
|
* task is paused/resumed with an `UploadTaskSnapshot` as the first
|
|
* argument.</li>
|
|
* <li>The `error` function is triggered if the upload is canceled or fails
|
|
* for another reason.</li>
|
|
* <li>The `complete` function is triggered if the upload completes
|
|
* successfully.</li>
|
|
* </ul>
|
|
*/
|
|
STATE_CHANGED: 'state_changed'
|
|
};
|
|
// type keys = keyof TaskState
|
|
/**
|
|
* Represents the current state of a running upload.
|
|
* @internal
|
|
*/
|
|
var 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.
|
|
*/
|
|
var Observer = /** @class */ (function () {
|
|
function Observer(nextOrObserver, error, complete) {
|
|
var asFunctions = isFunction(nextOrObserver) || error != null || complete != null;
|
|
if (asFunctions) {
|
|
this.next = nextOrObserver;
|
|
this.error = error !== null && error !== void 0 ? error : undefined;
|
|
this.complete = complete !== null && complete !== void 0 ? complete : undefined;
|
|
}
|
|
else {
|
|
var observer = nextOrObserver;
|
|
this.next = observer.next;
|
|
this.error = observer.error;
|
|
this.complete = observer.complete;
|
|
}
|
|
}
|
|
return Observer;
|
|
}());
|
|
|
|
/**
|
|
* @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 function () {
|
|
var argsToForward = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
argsToForward[_i] = arguments[_i];
|
|
}
|
|
// eslint-disable-next-line @typescript-eslint/no-floating-promises
|
|
Promise.resolve().then(function () { return f.apply(void 0, argsToForward); });
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @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 override for the text-based Connection. Used in tests. */
|
|
var textFactoryOverride = null;
|
|
/**
|
|
* Network layer for browsers. We use this instead of goog.net.XhrIo because
|
|
* goog.net.XhrIo is hyuuuuge and doesn't work in React Native on Android.
|
|
*/
|
|
var XhrConnection = /** @class */ (function () {
|
|
function XhrConnection() {
|
|
var _this = this;
|
|
this.sent_ = false;
|
|
this.xhr_ = new XMLHttpRequest();
|
|
this.initXhr();
|
|
this.errorCode_ = ErrorCode.NO_ERROR;
|
|
this.sendPromise_ = new Promise(function (resolve) {
|
|
_this.xhr_.addEventListener('abort', function () {
|
|
_this.errorCode_ = ErrorCode.ABORT;
|
|
resolve();
|
|
});
|
|
_this.xhr_.addEventListener('error', function () {
|
|
_this.errorCode_ = ErrorCode.NETWORK_ERROR;
|
|
resolve();
|
|
});
|
|
_this.xhr_.addEventListener('load', function () {
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
XhrConnection.prototype.send = function (url, method, body, headers) {
|
|
if (this.sent_) {
|
|
throw internalError('cannot .send() more than once');
|
|
}
|
|
this.sent_ = true;
|
|
this.xhr_.open(method, url, true);
|
|
if (headers !== undefined) {
|
|
for (var key in headers) {
|
|
if (headers.hasOwnProperty(key)) {
|
|
this.xhr_.setRequestHeader(key, headers[key].toString());
|
|
}
|
|
}
|
|
}
|
|
if (body !== undefined) {
|
|
this.xhr_.send(body);
|
|
}
|
|
else {
|
|
this.xhr_.send();
|
|
}
|
|
return this.sendPromise_;
|
|
};
|
|
XhrConnection.prototype.getErrorCode = function () {
|
|
if (!this.sent_) {
|
|
throw internalError('cannot .getErrorCode() before sending');
|
|
}
|
|
return this.errorCode_;
|
|
};
|
|
XhrConnection.prototype.getStatus = function () {
|
|
if (!this.sent_) {
|
|
throw internalError('cannot .getStatus() before sending');
|
|
}
|
|
try {
|
|
return this.xhr_.status;
|
|
}
|
|
catch (e) {
|
|
return -1;
|
|
}
|
|
};
|
|
XhrConnection.prototype.getResponse = function () {
|
|
if (!this.sent_) {
|
|
throw internalError('cannot .getResponse() before sending');
|
|
}
|
|
return this.xhr_.response;
|
|
};
|
|
XhrConnection.prototype.getErrorText = function () {
|
|
if (!this.sent_) {
|
|
throw internalError('cannot .getErrorText() before sending');
|
|
}
|
|
return this.xhr_.statusText;
|
|
};
|
|
/** Aborts the request. */
|
|
XhrConnection.prototype.abort = function () {
|
|
this.xhr_.abort();
|
|
};
|
|
XhrConnection.prototype.getResponseHeader = function (header) {
|
|
return this.xhr_.getResponseHeader(header);
|
|
};
|
|
XhrConnection.prototype.addUploadProgressListener = function (listener) {
|
|
if (this.xhr_.upload != null) {
|
|
this.xhr_.upload.addEventListener('progress', listener);
|
|
}
|
|
};
|
|
XhrConnection.prototype.removeUploadProgressListener = function (listener) {
|
|
if (this.xhr_.upload != null) {
|
|
this.xhr_.upload.removeEventListener('progress', listener);
|
|
}
|
|
};
|
|
return XhrConnection;
|
|
}());
|
|
var XhrTextConnection = /** @class */ (function (_super) {
|
|
tslib.__extends(XhrTextConnection, _super);
|
|
function XhrTextConnection() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
XhrTextConnection.prototype.initXhr = function () {
|
|
this.xhr_.responseType = 'text';
|
|
};
|
|
return XhrTextConnection;
|
|
}(XhrConnection));
|
|
function newTextConnection() {
|
|
return textFactoryOverride ? textFactoryOverride() : new XhrTextConnection();
|
|
}
|
|
var XhrBytesConnection = /** @class */ (function (_super) {
|
|
tslib.__extends(XhrBytesConnection, _super);
|
|
function XhrBytesConnection() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
XhrBytesConnection.prototype.initXhr = function () {
|
|
this.xhr_.responseType = 'arraybuffer';
|
|
};
|
|
return XhrBytesConnection;
|
|
}(XhrConnection));
|
|
function newBytesConnection() {
|
|
return new XhrBytesConnection();
|
|
}
|
|
var XhrBlobConnection = /** @class */ (function (_super) {
|
|
tslib.__extends(XhrBlobConnection, _super);
|
|
function XhrBlobConnection() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
XhrBlobConnection.prototype.initXhr = function () {
|
|
this.xhr_.responseType = 'blob';
|
|
};
|
|
return XhrBlobConnection;
|
|
}(XhrConnection));
|
|
function newBlobConnection() {
|
|
return new XhrBlobConnection();
|
|
}
|
|
|
|
/**
|
|
* @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
|
|
*/
|
|
var UploadTask = /** @class */ (function () {
|
|
/**
|
|
* @param ref - The firebaseStorage.Reference object this task came
|
|
* from, untyped to avoid cyclic dependencies.
|
|
* @param blob - The blob to upload.
|
|
*/
|
|
function UploadTask(ref, blob, metadata) {
|
|
if (metadata === void 0) { metadata = null; }
|
|
var _this = this;
|
|
/**
|
|
* 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 = function (error) {
|
|
_this._request = undefined;
|
|
_this._chunkMultiplier = 1;
|
|
if (error._codeEquals(exports.StorageErrorCode.CANCELED)) {
|
|
_this._needToFetchStatus = true;
|
|
_this.completeTransitions_();
|
|
}
|
|
else {
|
|
var 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 = function (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(function (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, function () { });
|
|
}
|
|
UploadTask.prototype.isExponentialBackoffExpired = function () {
|
|
return this.sleepTime > this.maxSleepTime;
|
|
};
|
|
UploadTask.prototype._makeProgressCallback = function () {
|
|
var _this = this;
|
|
var sizeBefore = this._transferred;
|
|
return function (loaded) { return _this._updateProgress(sizeBefore + loaded); };
|
|
};
|
|
UploadTask.prototype._shouldDoResumable = function (blob) {
|
|
return blob.size() > 256 * 1024;
|
|
};
|
|
UploadTask.prototype._start = function () {
|
|
var _this = this;
|
|
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(function () {
|
|
_this.pendingTimeout = undefined;
|
|
_this._continueUpload();
|
|
}, this.sleepTime);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
this._oneShotUpload();
|
|
}
|
|
};
|
|
UploadTask.prototype._resolveToken = function (callback) {
|
|
var _this = this;
|
|
// eslint-disable-next-line @typescript-eslint/no-floating-promises
|
|
Promise.all([
|
|
this._ref.storage._getAuthToken(),
|
|
this._ref.storage._getAppCheckToken()
|
|
]).then(function (_a) {
|
|
var authToken = _a[0], appCheckToken = _a[1];
|
|
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
|
|
UploadTask.prototype._createResumable = function () {
|
|
var _this = this;
|
|
this._resolveToken(function (authToken, appCheckToken) {
|
|
var requestInfo = createResumableUpload(_this._ref.storage, _this._ref._location, _this._mappings, _this._blob, _this._metadata);
|
|
var createRequest = _this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken);
|
|
_this._request = createRequest;
|
|
createRequest.getPromise().then(function (url) {
|
|
_this._request = undefined;
|
|
_this._uploadUrl = url;
|
|
_this._needToFetchStatus = false;
|
|
_this.completeTransitions_();
|
|
}, _this._errorHandler);
|
|
});
|
|
};
|
|
UploadTask.prototype._fetchStatus = function () {
|
|
var _this = this;
|
|
// TODO(andysoto): assert(this.uploadUrl_ !== null);
|
|
var url = this._uploadUrl;
|
|
this._resolveToken(function (authToken, appCheckToken) {
|
|
var requestInfo = getResumableUploadStatus(_this._ref.storage, _this._ref._location, url, _this._blob);
|
|
var statusRequest = _this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken);
|
|
_this._request = statusRequest;
|
|
statusRequest.getPromise().then(function (status) {
|
|
status = status;
|
|
_this._request = undefined;
|
|
_this._updateProgress(status.current);
|
|
_this._needToFetchStatus = false;
|
|
if (status.finalized) {
|
|
_this._needToFetchMetadata = true;
|
|
}
|
|
_this.completeTransitions_();
|
|
}, _this._errorHandler);
|
|
});
|
|
};
|
|
UploadTask.prototype._continueUpload = function () {
|
|
var _this = this;
|
|
var chunkSize = RESUMABLE_UPLOAD_CHUNK_SIZE * this._chunkMultiplier;
|
|
var status = new ResumableUploadStatus(this._transferred, this._blob.size());
|
|
// TODO(andysoto): assert(this.uploadUrl_ !== null);
|
|
var url = this._uploadUrl;
|
|
this._resolveToken(function (authToken, appCheckToken) {
|
|
var 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;
|
|
}
|
|
var 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(function (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);
|
|
});
|
|
};
|
|
UploadTask.prototype._increaseMultiplier = function () {
|
|
var currentSize = RESUMABLE_UPLOAD_CHUNK_SIZE * this._chunkMultiplier;
|
|
// Max chunk size is 32M.
|
|
if (currentSize * 2 < 32 * 1024 * 1024) {
|
|
this._chunkMultiplier *= 2;
|
|
}
|
|
};
|
|
UploadTask.prototype._fetchMetadata = function () {
|
|
var _this = this;
|
|
this._resolveToken(function (authToken, appCheckToken) {
|
|
var requestInfo = getMetadata$2(_this._ref.storage, _this._ref._location, _this._mappings);
|
|
var metadataRequest = _this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken);
|
|
_this._request = metadataRequest;
|
|
metadataRequest.getPromise().then(function (metadata) {
|
|
_this._request = undefined;
|
|
_this._metadata = metadata;
|
|
_this._transition("success" /* InternalTaskState.SUCCESS */);
|
|
}, _this._metadataErrorHandler);
|
|
});
|
|
};
|
|
UploadTask.prototype._oneShotUpload = function () {
|
|
var _this = this;
|
|
this._resolveToken(function (authToken, appCheckToken) {
|
|
var requestInfo = multipartUpload(_this._ref.storage, _this._ref._location, _this._mappings, _this._blob, _this._metadata);
|
|
var multipartRequest = _this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken);
|
|
_this._request = multipartRequest;
|
|
multipartRequest.getPromise().then(function (metadata) {
|
|
_this._request = undefined;
|
|
_this._metadata = metadata;
|
|
_this._updateProgress(_this._blob.size());
|
|
_this._transition("success" /* InternalTaskState.SUCCESS */);
|
|
}, _this._errorHandler);
|
|
});
|
|
};
|
|
UploadTask.prototype._updateProgress = function (transferred) {
|
|
var 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();
|
|
}
|
|
};
|
|
UploadTask.prototype._transition = function (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);
|
|
var 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;
|
|
}
|
|
};
|
|
UploadTask.prototype.completeTransitions_ = function () {
|
|
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;
|
|
}
|
|
};
|
|
Object.defineProperty(UploadTask.prototype, "snapshot", {
|
|
/**
|
|
* A snapshot of the current task state.
|
|
*/
|
|
get: function () {
|
|
var externalState = taskStateFromInternalTaskState(this._state);
|
|
return {
|
|
bytesTransferred: this._transferred,
|
|
totalBytes: this._blob.size(),
|
|
state: externalState,
|
|
metadata: this._metadata,
|
|
task: this,
|
|
ref: this._ref
|
|
};
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* 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.
|
|
*/
|
|
UploadTask.prototype.on = function (type, nextOrObserver, error, completed) {
|
|
var _this = this;
|
|
// Note: `type` isn't being used. Its type is also incorrect. TaskEvent should not be a string.
|
|
var observer = new Observer(nextOrObserver || undefined, error || undefined, completed || undefined);
|
|
this._addObserver(observer);
|
|
return function () {
|
|
_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.
|
|
*/
|
|
UploadTask.prototype.then = function (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)`.
|
|
*/
|
|
UploadTask.prototype.catch = function (onRejected) {
|
|
return this.then(null, onRejected);
|
|
};
|
|
/**
|
|
* Adds the given observer.
|
|
*/
|
|
UploadTask.prototype._addObserver = function (observer) {
|
|
this._observers.push(observer);
|
|
this._notifyObserver(observer);
|
|
};
|
|
/**
|
|
* Removes the given observer.
|
|
*/
|
|
UploadTask.prototype._removeObserver = function (observer) {
|
|
var i = this._observers.indexOf(observer);
|
|
if (i !== -1) {
|
|
this._observers.splice(i, 1);
|
|
}
|
|
};
|
|
UploadTask.prototype._notifyObservers = function () {
|
|
var _this = this;
|
|
this._finishPromise();
|
|
var observers = this._observers.slice();
|
|
observers.forEach(function (observer) {
|
|
_this._notifyObserver(observer);
|
|
});
|
|
};
|
|
UploadTask.prototype._finishPromise = function () {
|
|
if (this._resolve !== undefined) {
|
|
var triggered = true;
|
|
switch (taskStateFromInternalTaskState(this._state)) {
|
|
case TaskState.SUCCESS:
|
|
async(this._resolve.bind(null, this.snapshot))();
|
|
break;
|
|
case TaskState.CANCELED:
|
|
case TaskState.ERROR:
|
|
var toCall = this._reject;
|
|
async(toCall.bind(null, this._error))();
|
|
break;
|
|
default:
|
|
triggered = false;
|
|
break;
|
|
}
|
|
if (triggered) {
|
|
this._resolve = undefined;
|
|
this._reject = undefined;
|
|
}
|
|
}
|
|
};
|
|
UploadTask.prototype._notifyObserver = function (observer) {
|
|
var 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.
|
|
*/
|
|
UploadTask.prototype.resume = function () {
|
|
var 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.
|
|
*/
|
|
UploadTask.prototype.pause = function () {
|
|
var 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.
|
|
*/
|
|
UploadTask.prototype.cancel = function () {
|
|
var valid = this._state === "running" /* InternalTaskState.RUNNING */ ||
|
|
this._state === "pausing" /* InternalTaskState.PAUSING */;
|
|
if (valid) {
|
|
this._transition("canceling" /* InternalTaskState.CANCELING */);
|
|
}
|
|
return valid;
|
|
};
|
|
return UploadTask;
|
|
}());
|
|
|
|
/**
|
|
* @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://<bucket>/<object-path>
|
|
* http[s]://firebasestorage.googleapis.com/
|
|
* <api-version>/b/<bucket>/o/<object-path>
|
|
* 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.
|
|
*/
|
|
var Reference = /** @class */ (function () {
|
|
function Reference(_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://<bucket>/<object-path>
|
|
* @override
|
|
*/
|
|
Reference.prototype.toString = function () {
|
|
return 'gs://' + this._location.bucket + '/' + this._location.path;
|
|
};
|
|
Reference.prototype._newRef = function (service, location) {
|
|
return new Reference(service, location);
|
|
};
|
|
Object.defineProperty(Reference.prototype, "root", {
|
|
/**
|
|
* A reference to the root of this object's bucket.
|
|
*/
|
|
get: function () {
|
|
var location = new Location(this._location.bucket, '');
|
|
return this._newRef(this._service, location);
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Reference.prototype, "bucket", {
|
|
/**
|
|
* The name of the bucket containing this reference's object.
|
|
*/
|
|
get: function () {
|
|
return this._location.bucket;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Reference.prototype, "fullPath", {
|
|
/**
|
|
* The full path of this object.
|
|
*/
|
|
get: function () {
|
|
return this._location.path;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Reference.prototype, "name", {
|
|
/**
|
|
* 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: function () {
|
|
return lastComponent(this._location.path);
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Reference.prototype, "storage", {
|
|
/**
|
|
* The `StorageService` instance this `StorageReference` is associated with.
|
|
*/
|
|
get: function () {
|
|
return this._service;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(Reference.prototype, "parent", {
|
|
/**
|
|
* A `StorageReference` pointing to the parent location of this `StorageReference`, or null if
|
|
* this reference is the root.
|
|
*/
|
|
get: function () {
|
|
var newPath = parent(this._location.path);
|
|
if (newPath === null) {
|
|
return null;
|
|
}
|
|
var location = new Location(this._location.bucket, newPath);
|
|
return new Reference(this._service, location);
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* Utility function to throw an error in methods that do not accept a root reference.
|
|
*/
|
|
Reference.prototype._throwIfRoot = function (name) {
|
|
if (this._location.path === '') {
|
|
throw invalidRootOperation(name);
|
|
}
|
|
};
|
|
return Reference;
|
|
}());
|
|
/**
|
|
* Download the bytes at the object's location.
|
|
* @returns A Promise containing the downloaded bytes.
|
|
*/
|
|
function getBytesInternal(ref, maxDownloadSizeBytes) {
|
|
ref._throwIfRoot('getBytes');
|
|
var requestInfo = getBytes$1(ref.storage, ref._location, maxDownloadSizeBytes);
|
|
return ref.storage
|
|
.makeRequestWithTokens(requestInfo, newBytesConnection)
|
|
.then(function (bytes) {
|
|
return maxDownloadSizeBytes !== undefined
|
|
? // GCS may not honor the Range header for small files
|
|
bytes.slice(0, maxDownloadSizeBytes)
|
|
: bytes;
|
|
});
|
|
}
|
|
/**
|
|
* Download the bytes at the object's location.
|
|
* @returns A Promise containing the downloaded blob.
|
|
*/
|
|
function getBlobInternal(ref, maxDownloadSizeBytes) {
|
|
ref._throwIfRoot('getBlob');
|
|
var requestInfo = getBytes$1(ref.storage, ref._location, maxDownloadSizeBytes);
|
|
return ref.storage
|
|
.makeRequestWithTokens(requestInfo, newBlobConnection)
|
|
.then(function (blob) {
|
|
return maxDownloadSizeBytes !== undefined
|
|
? // GCS may not honor the Range header for small files
|
|
blob.slice(0, maxDownloadSizeBytes)
|
|
: blob;
|
|
});
|
|
}
|
|
/**
|
|
* 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');
|
|
var requestInfo = multipartUpload(ref.storage, ref._location, getMappings(), new FbsBlob(data, true), metadata);
|
|
return ref.storage
|
|
.makeRequestWithTokens(requestInfo, newTextConnection)
|
|
.then(function (finalMetadata) {
|
|
return {
|
|
metadata: finalMetadata,
|
|
ref: 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, metadata) {
|
|
if (format === void 0) { format = StringFormat.RAW; }
|
|
ref._throwIfRoot('uploadString');
|
|
var data = dataFromString(format, value);
|
|
var metadataClone = tslib.__assign({}, 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) {
|
|
var accumulator = {
|
|
prefixes: [],
|
|
items: []
|
|
};
|
|
return listAllHelper(ref, accumulator).then(function () { return accumulator; });
|
|
}
|
|
/**
|
|
* Separated from listAll because async functions can't use "arguments".
|
|
* @param ref
|
|
* @param accumulator
|
|
* @param pageToken
|
|
*/
|
|
function listAllHelper(ref, accumulator, pageToken) {
|
|
return tslib.__awaiter(this, void 0, void 0, function () {
|
|
var opt, nextPage;
|
|
var _a, _b;
|
|
return tslib.__generator(this, function (_c) {
|
|
switch (_c.label) {
|
|
case 0:
|
|
opt = {
|
|
// maxResults is 1000 by default.
|
|
pageToken: pageToken
|
|
};
|
|
return [4 /*yield*/, list$1(ref, opt)];
|
|
case 1:
|
|
nextPage = _c.sent();
|
|
(_a = accumulator.prefixes).push.apply(_a, nextPage.prefixes);
|
|
(_b = accumulator.items).push.apply(_b, nextPage.items);
|
|
if (!(nextPage.nextPageToken != null)) return [3 /*break*/, 3];
|
|
return [4 /*yield*/, listAllHelper(ref, accumulator, nextPage.nextPageToken)];
|
|
case 2:
|
|
_c.sent();
|
|
_c.label = 3;
|
|
case 3: return [2 /*return*/];
|
|
}
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* 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);
|
|
}
|
|
}
|
|
var op = options || {};
|
|
var 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 retreived, the promise is
|
|
* rejected.
|
|
* @public
|
|
* @param ref - StorageReference to get metadata from.
|
|
*/
|
|
function getMetadata$1(ref) {
|
|
ref._throwIfRoot('getMetadata');
|
|
var 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');
|
|
var 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');
|
|
var requestInfo = getDownloadUrl(ref.storage, ref._location, getMappings());
|
|
return ref.storage
|
|
.makeRequestWithTokens(requestInfo, newTextConnection)
|
|
.then(function (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');
|
|
var 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) {
|
|
var newPath = child(ref._location.path, childPath);
|
|
var 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) {
|
|
var service = ref;
|
|
if (service._bucket == null) {
|
|
throw noDefaultBucket();
|
|
}
|
|
var 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) {
|
|
var bucketString = config === null || config === void 0 ? void 0 : config[CONFIG_STORAGE_BUCKET_KEY];
|
|
if (bucketString == null) {
|
|
return null;
|
|
}
|
|
return Location.makeFromBucketSpec(bucketString, host);
|
|
}
|
|
function connectStorageEmulator$1(storage, host, port, options) {
|
|
if (options === void 0) { options = {}; }
|
|
storage.host = "".concat(host, ":").concat(port);
|
|
storage._protocol = 'http';
|
|
var mockUserToken = options.mockUserToken;
|
|
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
|
|
*/
|
|
var FirebaseStorageImpl = /** @class */ (function () {
|
|
function FirebaseStorageImpl(
|
|
/**
|
|
* FirebaseApp associated with this StorageService instance.
|
|
*/
|
|
app, _authProvider,
|
|
/**
|
|
* @internal
|
|
*/
|
|
_appCheckProvider,
|
|
/**
|
|
* @internal
|
|
*/
|
|
_url, _firebaseVersion) {
|
|
this.app = app;
|
|
this._authProvider = _authProvider;
|
|
this._appCheckProvider = _appCheckProvider;
|
|
this._url = _url;
|
|
this._firebaseVersion = _firebaseVersion;
|
|
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);
|
|
}
|
|
}
|
|
Object.defineProperty(FirebaseStorageImpl.prototype, "host", {
|
|
/**
|
|
* The host string for this service, in the form of `host` or
|
|
* `host:port`.
|
|
*/
|
|
get: function () {
|
|
return this._host;
|
|
},
|
|
set: function (host) {
|
|
this._host = host;
|
|
if (this._url != null) {
|
|
this._bucket = Location.makeFromBucketSpec(this._url, host);
|
|
}
|
|
else {
|
|
this._bucket = extractBucket(host, this.app.options);
|
|
}
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(FirebaseStorageImpl.prototype, "maxUploadRetryTime", {
|
|
/**
|
|
* The maximum time to retry uploads in milliseconds.
|
|
*/
|
|
get: function () {
|
|
return this._maxUploadRetryTime;
|
|
},
|
|
set: function (time) {
|
|
validateNumber('time',
|
|
/* minValue=*/ 0,
|
|
/* maxValue= */ Number.POSITIVE_INFINITY, time);
|
|
this._maxUploadRetryTime = time;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(FirebaseStorageImpl.prototype, "maxOperationRetryTime", {
|
|
/**
|
|
* The maximum time to retry operations other than uploads or downloads in
|
|
* milliseconds.
|
|
*/
|
|
get: function () {
|
|
return this._maxOperationRetryTime;
|
|
},
|
|
set: function (time) {
|
|
validateNumber('time',
|
|
/* minValue=*/ 0,
|
|
/* maxValue= */ Number.POSITIVE_INFINITY, time);
|
|
this._maxOperationRetryTime = time;
|
|
},
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
FirebaseStorageImpl.prototype._getAuthToken = function () {
|
|
return tslib.__awaiter(this, void 0, void 0, function () {
|
|
var auth, tokenData;
|
|
return tslib.__generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
if (this._overrideAuthToken) {
|
|
return [2 /*return*/, this._overrideAuthToken];
|
|
}
|
|
auth = this._authProvider.getImmediate({ optional: true });
|
|
if (!auth) return [3 /*break*/, 2];
|
|
return [4 /*yield*/, auth.getToken()];
|
|
case 1:
|
|
tokenData = _a.sent();
|
|
if (tokenData !== null) {
|
|
return [2 /*return*/, tokenData.accessToken];
|
|
}
|
|
_a.label = 2;
|
|
case 2: return [2 /*return*/, null];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
FirebaseStorageImpl.prototype._getAppCheckToken = function () {
|
|
return tslib.__awaiter(this, void 0, void 0, function () {
|
|
var appCheck, result;
|
|
return tslib.__generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
appCheck = this._appCheckProvider.getImmediate({ optional: true });
|
|
if (!appCheck) return [3 /*break*/, 2];
|
|
return [4 /*yield*/, appCheck.getToken()];
|
|
case 1:
|
|
result = _a.sent();
|
|
// 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 [2 /*return*/, result.token];
|
|
case 2: return [2 /*return*/, null];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Stop running requests and prevent more from being created.
|
|
*/
|
|
FirebaseStorageImpl.prototype._delete = function () {
|
|
if (!this._deleted) {
|
|
this._deleted = true;
|
|
this._requests.forEach(function (request) { return request.cancel(); });
|
|
this._requests.clear();
|
|
}
|
|
return Promise.resolve();
|
|
};
|
|
/**
|
|
* Returns a new firebaseStorage.Reference object referencing this StorageService
|
|
* at the given Location.
|
|
*/
|
|
FirebaseStorageImpl.prototype._makeStorageReference = function (loc) {
|
|
return new Reference(this, loc);
|
|
};
|
|
/**
|
|
* @param requestInfo - HTTP RequestInfo object
|
|
* @param authToken - Firebase auth token
|
|
*/
|
|
FirebaseStorageImpl.prototype._makeRequest = function (requestInfo, requestFactory, authToken, appCheckToken, retry) {
|
|
var _this = this;
|
|
if (retry === void 0) { retry = true; }
|
|
if (!this._deleted) {
|
|
var request_1 = makeRequest(requestInfo, this._appId, authToken, appCheckToken, requestFactory, this._firebaseVersion, retry);
|
|
this._requests.add(request_1);
|
|
// Request removes itself from set when complete.
|
|
request_1.getPromise().then(function () { return _this._requests.delete(request_1); }, function () { return _this._requests.delete(request_1); });
|
|
return request_1;
|
|
}
|
|
else {
|
|
return new FailRequest(appDeleted());
|
|
}
|
|
};
|
|
FirebaseStorageImpl.prototype.makeRequestWithTokens = function (requestInfo, requestFactory) {
|
|
return tslib.__awaiter(this, void 0, void 0, function () {
|
|
var _a, authToken, appCheckToken;
|
|
return tslib.__generator(this, function (_b) {
|
|
switch (_b.label) {
|
|
case 0: return [4 /*yield*/, Promise.all([
|
|
this._getAuthToken(),
|
|
this._getAppCheckToken()
|
|
])];
|
|
case 1:
|
|
_a = _b.sent(), authToken = _a[0], appCheckToken = _a[1];
|
|
return [2 /*return*/, this._makeRequest(requestInfo, requestFactory, authToken, appCheckToken).getPromise()];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
return FirebaseStorageImpl;
|
|
}());
|
|
|
|
var name = "@firebase/storage";
|
|
var version = "0.12.1";
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
var STORAGE_TYPE = 'storage';
|
|
|
|
/**
|
|
* 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 retreived, 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, bucketUrl) {
|
|
if (app$1 === void 0) { app$1 = app.getApp(); }
|
|
app$1 = util.getModularInstance(app$1);
|
|
var storageProvider = app._getProvider(app$1, STORAGE_TYPE);
|
|
var storageInstance = storageProvider.getImmediate({
|
|
identifier: bucketUrl
|
|
});
|
|
var emulator = util.getDefaultEmulatorHostnameAndPort('storage');
|
|
if (emulator) {
|
|
connectStorageEmulator.apply(void 0, tslib.__spreadArray([storageInstance], emulator, false));
|
|
}
|
|
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) {
|
|
if (options === void 0) { 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
|
|
*/
|
|
function getBlob(ref, maxDownloadSizeBytes) {
|
|
ref = util.getModularInstance(ref);
|
|
return getBlobInternal(ref, maxDownloadSizeBytes);
|
|
}
|
|
/**
|
|
* 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) {
|
|
throw new Error('getStream() is only supported by NodeJS builds');
|
|
}
|
|
|
|
/**
|
|
* Cloud Storage for Firebase
|
|
*
|
|
* @packageDocumentation
|
|
*/
|
|
function factory(container, _a) {
|
|
var url = _a.instanceIdentifier;
|
|
var app$1 = container.getProvider('app').getImmediate();
|
|
var authProvider = container.getProvider('auth-internal');
|
|
var 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));
|
|
//RUNTIME_ENV will be replaced during the compilation to "node" for nodejs and an empty string for browser
|
|
app.registerVersion(name, version, '');
|
|
// BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
|
|
app.registerVersion(name, version, 'cjs5');
|
|
}
|
|
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.browser.cjs.js.map
|