3434 lines
113 KiB
JavaScript
3434 lines
113 KiB
JavaScript
import firebase from '@firebase/app';
|
|
import { Component } from '@firebase/component';
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* @fileoverview Constants used in the Firebase Storage library.
|
|
*/
|
|
/**
|
|
* Domain name for firebase storage.
|
|
*/
|
|
const DEFAULT_HOST = 'firebasestorage.googleapis.com';
|
|
/**
|
|
* The key in Firebase config json for the storage bucket.
|
|
*/
|
|
const CONFIG_STORAGE_BUCKET_KEY = 'storageBucket';
|
|
/**
|
|
* 2 minutes
|
|
*
|
|
* The timeout for all operations except upload.
|
|
*/
|
|
const DEFAULT_MAX_OPERATION_RETRY_TIME = 2 * 60 * 1000;
|
|
/**
|
|
* 10 minutes
|
|
*
|
|
* The timeout for upload.
|
|
*/
|
|
const DEFAULT_MAX_UPLOAD_RETRY_TIME = 10 * 60 * 1000;
|
|
/**
|
|
* This is the value of Number.MIN_SAFE_INTEGER, which is not well supported
|
|
* enough for us to use it directly.
|
|
*/
|
|
const MIN_SAFE_INTEGER = -9007199254740991;
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
class FirebaseStorageError {
|
|
constructor(code, message) {
|
|
this.code_ = prependCode(code);
|
|
this.message_ = 'Firebase Storage: ' + message;
|
|
this.serverResponse_ = null;
|
|
this.name_ = 'FirebaseError';
|
|
}
|
|
codeProp() {
|
|
return this.code;
|
|
}
|
|
codeEquals(code) {
|
|
return prependCode(code) === this.codeProp();
|
|
}
|
|
serverResponseProp() {
|
|
return this.serverResponse_;
|
|
}
|
|
setServerResponseProp(serverResponse) {
|
|
this.serverResponse_ = serverResponse;
|
|
}
|
|
get name() {
|
|
return this.name_;
|
|
}
|
|
get code() {
|
|
return this.code_;
|
|
}
|
|
get message() {
|
|
return this.message_;
|
|
}
|
|
get serverResponse() {
|
|
return this.serverResponse_;
|
|
}
|
|
}
|
|
const Code = {
|
|
// Shared between all platforms
|
|
UNKNOWN: 'unknown',
|
|
OBJECT_NOT_FOUND: 'object-not-found',
|
|
BUCKET_NOT_FOUND: 'bucket-not-found',
|
|
PROJECT_NOT_FOUND: 'project-not-found',
|
|
QUOTA_EXCEEDED: 'quota-exceeded',
|
|
UNAUTHENTICATED: 'unauthenticated',
|
|
UNAUTHORIZED: 'unauthorized',
|
|
RETRY_LIMIT_EXCEEDED: 'retry-limit-exceeded',
|
|
INVALID_CHECKSUM: 'invalid-checksum',
|
|
CANCELED: 'canceled',
|
|
// JS specific
|
|
INVALID_EVENT_NAME: 'invalid-event-name',
|
|
INVALID_URL: 'invalid-url',
|
|
INVALID_DEFAULT_BUCKET: 'invalid-default-bucket',
|
|
NO_DEFAULT_BUCKET: 'no-default-bucket',
|
|
CANNOT_SLICE_BLOB: 'cannot-slice-blob',
|
|
SERVER_FILE_WRONG_SIZE: 'server-file-wrong-size',
|
|
NO_DOWNLOAD_URL: 'no-download-url',
|
|
INVALID_ARGUMENT: 'invalid-argument',
|
|
INVALID_ARGUMENT_COUNT: 'invalid-argument-count',
|
|
APP_DELETED: 'app-deleted',
|
|
INVALID_ROOT_OPERATION: 'invalid-root-operation',
|
|
INVALID_FORMAT: 'invalid-format',
|
|
INTERNAL_ERROR: 'internal-error'
|
|
};
|
|
function prependCode(code) {
|
|
return 'storage/' + code;
|
|
}
|
|
function unknown() {
|
|
const message = 'An unknown error occurred, please check the error payload for ' +
|
|
'server response.';
|
|
return new FirebaseStorageError(Code.UNKNOWN, message);
|
|
}
|
|
function objectNotFound(path) {
|
|
return new FirebaseStorageError(Code.OBJECT_NOT_FOUND, "Object '" + path + "' does not exist.");
|
|
}
|
|
function quotaExceeded(bucket) {
|
|
return new FirebaseStorageError(Code.QUOTA_EXCEEDED, "Quota for bucket '" +
|
|
bucket +
|
|
"' exceeded, please view quota on " +
|
|
'https://firebase.google.com/pricing/.');
|
|
}
|
|
function unauthenticated() {
|
|
const message = 'User is not authenticated, please authenticate using Firebase ' +
|
|
'Authentication and try again.';
|
|
return new FirebaseStorageError(Code.UNAUTHENTICATED, message);
|
|
}
|
|
function unauthorized(path) {
|
|
return new FirebaseStorageError(Code.UNAUTHORIZED, "User does not have permission to access '" + path + "'.");
|
|
}
|
|
function retryLimitExceeded() {
|
|
return new FirebaseStorageError(Code.RETRY_LIMIT_EXCEEDED, 'Max retry time for operation exceeded, please try again.');
|
|
}
|
|
function canceled() {
|
|
return new FirebaseStorageError(Code.CANCELED, 'User canceled the upload/download.');
|
|
}
|
|
function invalidUrl(url) {
|
|
return new FirebaseStorageError(Code.INVALID_URL, "Invalid URL '" + url + "'.");
|
|
}
|
|
function invalidDefaultBucket(bucket) {
|
|
return new FirebaseStorageError(Code.INVALID_DEFAULT_BUCKET, "Invalid default bucket '" + bucket + "'.");
|
|
}
|
|
function cannotSliceBlob() {
|
|
return new FirebaseStorageError(Code.CANNOT_SLICE_BLOB, 'Cannot slice blob for upload. Please retry the upload.');
|
|
}
|
|
function serverFileWrongSize() {
|
|
return new FirebaseStorageError(Code.SERVER_FILE_WRONG_SIZE, 'Server recorded incorrect upload file size, please retry the upload.');
|
|
}
|
|
function noDownloadURL() {
|
|
return new FirebaseStorageError(Code.NO_DOWNLOAD_URL, 'The given file does not have any download URLs.');
|
|
}
|
|
function invalidArgument(index, fnName, message) {
|
|
return new FirebaseStorageError(Code.INVALID_ARGUMENT, 'Invalid argument in `' + fnName + '` at index ' + index + ': ' + message);
|
|
}
|
|
function invalidArgumentCount(argMin, argMax, fnName, real) {
|
|
let countPart;
|
|
let plural;
|
|
if (argMin === argMax) {
|
|
countPart = argMin;
|
|
plural = argMin === 1 ? 'argument' : 'arguments';
|
|
}
|
|
else {
|
|
countPart = 'between ' + argMin + ' and ' + argMax;
|
|
plural = 'arguments';
|
|
}
|
|
return new FirebaseStorageError(Code.INVALID_ARGUMENT_COUNT, 'Invalid argument count in `' +
|
|
fnName +
|
|
'`: Expected ' +
|
|
countPart +
|
|
' ' +
|
|
plural +
|
|
', received ' +
|
|
real +
|
|
'.');
|
|
}
|
|
function appDeleted() {
|
|
return new FirebaseStorageError(Code.APP_DELETED, 'The Firebase app was deleted.');
|
|
}
|
|
/**
|
|
* @param name The name of the operation that was invalid.
|
|
*/
|
|
function invalidRootOperation(name) {
|
|
return new FirebaseStorageError(Code.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 FirebaseStorageError(Code.INVALID_FORMAT, "String does not match format '" + format + "': " + message);
|
|
}
|
|
/**
|
|
* @param message A message describing the internal error.
|
|
*/
|
|
function internalError(message) {
|
|
throw new FirebaseStorageError(Code.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.
|
|
*/
|
|
const StringFormat = {
|
|
RAW: 'raw',
|
|
BASE64: 'base64',
|
|
BASE64URL: 'base64url',
|
|
DATA_URL: 'data_url'
|
|
};
|
|
function formatValidator(stringFormat) {
|
|
switch (stringFormat) {
|
|
case StringFormat.RAW:
|
|
case StringFormat.BASE64:
|
|
case StringFormat.BASE64URL:
|
|
case StringFormat.DATA_URL:
|
|
return;
|
|
default:
|
|
throw 'Expected one of the event types: [' +
|
|
StringFormat.RAW +
|
|
', ' +
|
|
StringFormat.BASE64 +
|
|
', ' +
|
|
StringFormat.BASE64URL +
|
|
', ' +
|
|
StringFormat.DATA_URL +
|
|
'].';
|
|
}
|
|
}
|
|
/**
|
|
* @struct
|
|
*/
|
|
class StringData {
|
|
constructor(data, contentType) {
|
|
this.data = data;
|
|
this.contentType = contentType || null;
|
|
}
|
|
}
|
|
function dataFromString(format, stringData) {
|
|
switch (format) {
|
|
case StringFormat.RAW:
|
|
return new StringData(utf8Bytes_(stringData));
|
|
case StringFormat.BASE64:
|
|
case StringFormat.BASE64URL:
|
|
return new StringData(base64Bytes_(format, stringData));
|
|
case StringFormat.DATA_URL:
|
|
return new StringData(dataURLBytes_(stringData), dataURLContentType_(stringData));
|
|
// do nothing
|
|
}
|
|
// assert(false);
|
|
throw unknown();
|
|
}
|
|
function utf8Bytes_(value) {
|
|
const b = [];
|
|
for (let i = 0; i < value.length; i++) {
|
|
let c = value.charCodeAt(i);
|
|
if (c <= 127) {
|
|
b.push(c);
|
|
}
|
|
else {
|
|
if (c <= 2047) {
|
|
b.push(192 | (c >> 6), 128 | (c & 63));
|
|
}
|
|
else {
|
|
if ((c & 64512) === 55296) {
|
|
// The start of a surrogate pair.
|
|
const valid = i < value.length - 1 && (value.charCodeAt(i + 1) & 64512) === 56320;
|
|
if (!valid) {
|
|
// The second surrogate wasn't there.
|
|
b.push(239, 191, 189);
|
|
}
|
|
else {
|
|
const hi = c;
|
|
const lo = value.charCodeAt(++i);
|
|
c = 65536 | ((hi & 1023) << 10) | (lo & 1023);
|
|
b.push(240 | (c >> 18), 128 | ((c >> 12) & 63), 128 | ((c >> 6) & 63), 128 | (c & 63));
|
|
}
|
|
}
|
|
else {
|
|
if ((c & 64512) === 56320) {
|
|
// Invalid low surrogate.
|
|
b.push(239, 191, 189);
|
|
}
|
|
else {
|
|
b.push(224 | (c >> 12), 128 | ((c >> 6) & 63), 128 | (c & 63));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return new Uint8Array(b);
|
|
}
|
|
function percentEncodedBytes_(value) {
|
|
let decoded;
|
|
try {
|
|
decoded = decodeURIComponent(value);
|
|
}
|
|
catch (e) {
|
|
throw invalidFormat(StringFormat.DATA_URL, 'Malformed data URL.');
|
|
}
|
|
return utf8Bytes_(decoded);
|
|
}
|
|
function base64Bytes_(format, value) {
|
|
switch (format) {
|
|
case StringFormat.BASE64: {
|
|
const hasMinus = value.indexOf('-') !== -1;
|
|
const hasUnder = value.indexOf('_') !== -1;
|
|
if (hasMinus || hasUnder) {
|
|
const invalidChar = hasMinus ? '-' : '_';
|
|
throw invalidFormat(format, "Invalid character '" +
|
|
invalidChar +
|
|
"' found: is it base64url encoded?");
|
|
}
|
|
break;
|
|
}
|
|
case StringFormat.BASE64URL: {
|
|
const hasPlus = value.indexOf('+') !== -1;
|
|
const hasSlash = value.indexOf('/') !== -1;
|
|
if (hasPlus || hasSlash) {
|
|
const invalidChar = hasPlus ? '+' : '/';
|
|
throw invalidFormat(format, "Invalid character '" + invalidChar + "' found: is it base64 encoded?");
|
|
}
|
|
value = value.replace(/-/g, '+').replace(/_/g, '/');
|
|
break;
|
|
}
|
|
// do nothing
|
|
}
|
|
let bytes;
|
|
try {
|
|
bytes = atob(value);
|
|
}
|
|
catch (e) {
|
|
throw invalidFormat(format, 'Invalid character found');
|
|
}
|
|
const array = new Uint8Array(bytes.length);
|
|
for (let i = 0; i < bytes.length; i++) {
|
|
array[i] = bytes.charCodeAt(i);
|
|
}
|
|
return array;
|
|
}
|
|
/**
|
|
* @struct
|
|
*/
|
|
class DataURLParts {
|
|
constructor(dataURL) {
|
|
this.base64 = false;
|
|
this.contentType = null;
|
|
const matches = dataURL.match(/^data:([^,]+)?,/);
|
|
if (matches === null) {
|
|
throw invalidFormat(StringFormat.DATA_URL, "Must be formatted 'data:[<mediatype>][;base64],<data>");
|
|
}
|
|
const middle = matches[1] || null;
|
|
if (middle != null) {
|
|
this.base64 = endsWith(middle, ';base64');
|
|
this.contentType = this.base64
|
|
? middle.substring(0, middle.length - ';base64'.length)
|
|
: middle;
|
|
}
|
|
this.rest = dataURL.substring(dataURL.indexOf(',') + 1);
|
|
}
|
|
}
|
|
function dataURLBytes_(dataUrl) {
|
|
const parts = new DataURLParts(dataUrl);
|
|
if (parts.base64) {
|
|
return base64Bytes_(StringFormat.BASE64, parts.rest);
|
|
}
|
|
else {
|
|
return percentEncodedBytes_(parts.rest);
|
|
}
|
|
}
|
|
function dataURLContentType_(dataUrl) {
|
|
const parts = new DataURLParts(dataUrl);
|
|
return parts.contentType;
|
|
}
|
|
function endsWith(s, end) {
|
|
const longEnough = s.length >= end.length;
|
|
if (!longEnough) {
|
|
return false;
|
|
}
|
|
return s.substring(s.length - end.length) === end;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
const TaskEvent = {
|
|
/** Triggered whenever the task changes or progress is updated. */
|
|
STATE_CHANGED: 'state_changed'
|
|
};
|
|
const InternalTaskState = {
|
|
RUNNING: 'running',
|
|
PAUSING: 'pausing',
|
|
PAUSED: 'paused',
|
|
SUCCESS: 'success',
|
|
CANCELING: 'canceling',
|
|
CANCELED: 'canceled',
|
|
ERROR: 'error'
|
|
};
|
|
const TaskState = {
|
|
/** The task is currently transferring data. */
|
|
RUNNING: 'running',
|
|
/** The task was paused by the user. */
|
|
PAUSED: 'paused',
|
|
/** The task completed successfully. */
|
|
SUCCESS: 'success',
|
|
/** The task was canceled. */
|
|
CANCELED: 'canceled',
|
|
/** The task failed with an error. */
|
|
ERROR: 'error'
|
|
};
|
|
function taskStateFromInternalTaskState(state) {
|
|
switch (state) {
|
|
case InternalTaskState.RUNNING:
|
|
case InternalTaskState.PAUSING:
|
|
case InternalTaskState.CANCELING:
|
|
return TaskState.RUNNING;
|
|
case InternalTaskState.PAUSED:
|
|
return TaskState.PAUSED;
|
|
case InternalTaskState.SUCCESS:
|
|
return TaskState.SUCCESS;
|
|
case InternalTaskState.CANCELED:
|
|
return TaskState.CANCELED;
|
|
case 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.
|
|
*/
|
|
/**
|
|
* @return False if the object is undefined or null, true otherwise.
|
|
*/
|
|
function isDef(p) {
|
|
return p != null;
|
|
}
|
|
function isJustDef(p) {
|
|
return p !== void 0;
|
|
}
|
|
function isFunction(p) {
|
|
return typeof p === 'function';
|
|
}
|
|
function isObject(p) {
|
|
return typeof p === 'object';
|
|
}
|
|
function isNonNullObject(p) {
|
|
return isObject(p) && p !== null;
|
|
}
|
|
function isNonArrayObject(p) {
|
|
return isObject(p) && !Array.isArray(p);
|
|
}
|
|
function isString(p) {
|
|
return typeof p === 'string' || p instanceof String;
|
|
}
|
|
function isInteger(p) {
|
|
return isNumber(p) && Number.isInteger(p);
|
|
}
|
|
function isNumber(p) {
|
|
return typeof p === 'number' || p instanceof Number;
|
|
}
|
|
function isNativeBlob(p) {
|
|
return isNativeBlobDefined() && p instanceof Blob;
|
|
}
|
|
function isNativeBlobDefined() {
|
|
return typeof Blob !== 'undefined';
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
/**
|
|
* @enum{number}
|
|
*/
|
|
var ErrorCode;
|
|
(function (ErrorCode) {
|
|
ErrorCode[ErrorCode["NO_ERROR"] = 0] = "NO_ERROR";
|
|
ErrorCode[ErrorCode["NETWORK_ERROR"] = 1] = "NETWORK_ERROR";
|
|
ErrorCode[ErrorCode["ABORT"] = 2] = "ABORT";
|
|
})(ErrorCode || (ErrorCode = {}));
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* 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.
|
|
*/
|
|
/**
|
|
* We use this instead of goog.net.XhrIo because goog.net.XhrIo is hyuuuuge and
|
|
* doesn't work in React Native on Android.
|
|
*/
|
|
class NetworkXhrIo {
|
|
constructor() {
|
|
this.sent_ = false;
|
|
this.xhr_ = new XMLHttpRequest();
|
|
this.errorCode_ = ErrorCode.NO_ERROR;
|
|
this.sendPromise_ = new Promise(resolve => {
|
|
this.xhr_.addEventListener('abort', () => {
|
|
this.errorCode_ = ErrorCode.ABORT;
|
|
resolve(this);
|
|
});
|
|
this.xhr_.addEventListener('error', () => {
|
|
this.errorCode_ = ErrorCode.NETWORK_ERROR;
|
|
resolve(this);
|
|
});
|
|
this.xhr_.addEventListener('load', () => {
|
|
resolve(this);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* @override
|
|
*/
|
|
send(url, method, body, headers) {
|
|
if (this.sent_) {
|
|
throw internalError('cannot .send() more than once');
|
|
}
|
|
this.sent_ = true;
|
|
this.xhr_.open(method, url, true);
|
|
if (isDef(headers)) {
|
|
for (const key in headers) {
|
|
if (headers.hasOwnProperty(key)) {
|
|
this.xhr_.setRequestHeader(key, headers[key].toString());
|
|
}
|
|
}
|
|
}
|
|
if (isDef(body)) {
|
|
this.xhr_.send(body);
|
|
}
|
|
else {
|
|
this.xhr_.send();
|
|
}
|
|
return this.sendPromise_;
|
|
}
|
|
/**
|
|
* @override
|
|
*/
|
|
getErrorCode() {
|
|
if (!this.sent_) {
|
|
throw internalError('cannot .getErrorCode() before sending');
|
|
}
|
|
return this.errorCode_;
|
|
}
|
|
/**
|
|
* @override
|
|
*/
|
|
getStatus() {
|
|
if (!this.sent_) {
|
|
throw internalError('cannot .getStatus() before sending');
|
|
}
|
|
try {
|
|
return this.xhr_.status;
|
|
}
|
|
catch (e) {
|
|
return -1;
|
|
}
|
|
}
|
|
/**
|
|
* @override
|
|
*/
|
|
getResponseText() {
|
|
if (!this.sent_) {
|
|
throw internalError('cannot .getResponseText() before sending');
|
|
}
|
|
return this.xhr_.responseText;
|
|
}
|
|
/**
|
|
* Aborts the request.
|
|
* @override
|
|
*/
|
|
abort() {
|
|
this.xhr_.abort();
|
|
}
|
|
/**
|
|
* @override
|
|
*/
|
|
getResponseHeader(header) {
|
|
return this.xhr_.getResponseHeader(header);
|
|
}
|
|
/**
|
|
* @override
|
|
*/
|
|
addUploadProgressListener(listener) {
|
|
if (isDef(this.xhr_.upload)) {
|
|
this.xhr_.upload.addEventListener('progress', listener);
|
|
}
|
|
}
|
|
/**
|
|
* @override
|
|
*/
|
|
removeUploadProgressListener(listener) {
|
|
if (isDef(this.xhr_.upload)) {
|
|
this.xhr_.upload.removeEventListener('progress', listener);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* Factory-like class for creating XhrIo instances.
|
|
*/
|
|
class XhrIoPool {
|
|
createXhrIo() {
|
|
return new NetworkXhrIo();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @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(...args) {
|
|
const BlobBuilder = getBlobBuilder();
|
|
if (BlobBuilder !== undefined) {
|
|
const bb = new BlobBuilder();
|
|
for (let i = 0; i < args.length; i++) {
|
|
bb.append(args[i]);
|
|
}
|
|
return bb.getBlob();
|
|
}
|
|
else {
|
|
if (isNativeBlobDefined()) {
|
|
return new Blob(args);
|
|
}
|
|
else {
|
|
throw Error("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 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.
|
|
*/
|
|
class FbsBlob {
|
|
constructor(data, elideCopy) {
|
|
let size = 0;
|
|
let blobType = '';
|
|
if (isNativeBlob(data)) {
|
|
this.data_ = data;
|
|
size = data.size;
|
|
blobType = data.type;
|
|
}
|
|
else if (data instanceof ArrayBuffer) {
|
|
if (elideCopy) {
|
|
this.data_ = new Uint8Array(data);
|
|
}
|
|
else {
|
|
this.data_ = new Uint8Array(data.byteLength);
|
|
this.data_.set(new Uint8Array(data));
|
|
}
|
|
size = this.data_.length;
|
|
}
|
|
else if (data instanceof Uint8Array) {
|
|
if (elideCopy) {
|
|
this.data_ = data;
|
|
}
|
|
else {
|
|
this.data_ = new Uint8Array(data.length);
|
|
this.data_.set(data);
|
|
}
|
|
size = data.length;
|
|
}
|
|
this.size_ = size;
|
|
this.type_ = blobType;
|
|
}
|
|
size() {
|
|
return this.size_;
|
|
}
|
|
type() {
|
|
return this.type_;
|
|
}
|
|
slice(startByte, endByte) {
|
|
if (isNativeBlob(this.data_)) {
|
|
const realBlob = this.data_;
|
|
const sliced = sliceBlob(realBlob, startByte, endByte);
|
|
if (sliced === null) {
|
|
return null;
|
|
}
|
|
return new FbsBlob(sliced);
|
|
}
|
|
else {
|
|
const slice = new Uint8Array(this.data_.buffer, startByte, endByte - startByte);
|
|
return new FbsBlob(slice, true);
|
|
}
|
|
}
|
|
static getBlob(...args) {
|
|
if (isNativeBlobDefined()) {
|
|
const blobby = args.map((val) => {
|
|
if (val instanceof FbsBlob) {
|
|
return val.data_;
|
|
}
|
|
else {
|
|
return val;
|
|
}
|
|
});
|
|
return new FbsBlob(getBlob.apply(null, blobby));
|
|
}
|
|
else {
|
|
const uint8Arrays = args.map((val) => {
|
|
if (isString(val)) {
|
|
return dataFromString(StringFormat.RAW, val).data;
|
|
}
|
|
else {
|
|
// Blobs don't exist, so this has to be a Uint8Array.
|
|
return val.data_;
|
|
}
|
|
});
|
|
let finalLength = 0;
|
|
uint8Arrays.forEach((array) => {
|
|
finalLength += array.byteLength;
|
|
});
|
|
const merged = new Uint8Array(finalLength);
|
|
let index = 0;
|
|
uint8Arrays.forEach((array) => {
|
|
for (let i = 0; i < array.length; i++) {
|
|
merged[index++] = array[i];
|
|
}
|
|
});
|
|
return new FbsBlob(merged, true);
|
|
}
|
|
}
|
|
uploadData() {
|
|
return this.data_;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* @struct
|
|
*/
|
|
class Location {
|
|
constructor(bucket, path) {
|
|
this.bucket = bucket;
|
|
this.path_ = path;
|
|
}
|
|
get path() {
|
|
return this.path_;
|
|
}
|
|
get isRoot() {
|
|
return this.path.length === 0;
|
|
}
|
|
fullServerUrl() {
|
|
const encode = encodeURIComponent;
|
|
return '/b/' + encode(this.bucket) + '/o/' + encode(this.path);
|
|
}
|
|
bucketOnlyServerUrl() {
|
|
const encode = encodeURIComponent;
|
|
return '/b/' + encode(this.bucket) + '/o';
|
|
}
|
|
static makeFromBucketSpec(bucketString) {
|
|
let bucketLocation;
|
|
try {
|
|
bucketLocation = Location.makeFromUrl(bucketString);
|
|
}
|
|
catch (e) {
|
|
// Not valid URL, use as-is. This lets you put bare bucket names in
|
|
// config.
|
|
return new Location(bucketString, '');
|
|
}
|
|
if (bucketLocation.path === '') {
|
|
return bucketLocation;
|
|
}
|
|
else {
|
|
throw invalidDefaultBucket(bucketString);
|
|
}
|
|
}
|
|
static makeFromUrl(url) {
|
|
let location = null;
|
|
const bucketDomain = '([A-Za-z0-9.\\-_]+)';
|
|
function gsModify(loc) {
|
|
if (loc.path.charAt(loc.path.length - 1) === '/') {
|
|
loc.path_ = loc.path_.slice(0, -1);
|
|
}
|
|
}
|
|
const gsPath = '(/(.*))?$';
|
|
const gsRegex = new RegExp('^gs://' + bucketDomain + gsPath, 'i');
|
|
const gsIndices = { bucket: 1, path: 3 };
|
|
function httpModify(loc) {
|
|
loc.path_ = decodeURIComponent(loc.path);
|
|
}
|
|
const version = 'v[A-Za-z0-9_]+';
|
|
const firebaseStorageHost = DEFAULT_HOST.replace(/[.]/g, '\\.');
|
|
const firebaseStoragePath = '(/([^?#]*).*)?$';
|
|
const firebaseStorageRegExp = new RegExp(`^https?://${firebaseStorageHost}/${version}/b/${bucketDomain}/o${firebaseStoragePath}`, 'i');
|
|
const firebaseStorageIndices = { bucket: 1, path: 3 };
|
|
const cloudStorageHost = '(?:storage.googleapis.com|storage.cloud.google.com)';
|
|
const cloudStoragePath = '([^?#]*)';
|
|
const cloudStorageRegExp = new RegExp(`^https?://${cloudStorageHost}/${bucketDomain}/${cloudStoragePath}`, 'i');
|
|
const cloudStorageIndices = { bucket: 1, path: 2 };
|
|
const groups = [
|
|
{ regex: gsRegex, indices: gsIndices, postModify: gsModify },
|
|
{
|
|
regex: firebaseStorageRegExp,
|
|
indices: firebaseStorageIndices,
|
|
postModify: httpModify
|
|
},
|
|
{
|
|
regex: cloudStorageRegExp,
|
|
indices: cloudStorageIndices,
|
|
postModify: httpModify
|
|
}
|
|
];
|
|
for (let i = 0; i < groups.length; i++) {
|
|
const group = groups[i];
|
|
const captures = group.regex.exec(url);
|
|
if (captures) {
|
|
const bucketValue = captures[group.indices.bucket];
|
|
let pathValue = captures[group.indices.path];
|
|
if (!pathValue) {
|
|
pathValue = '';
|
|
}
|
|
location = new Location(bucketValue, pathValue);
|
|
group.postModify(location);
|
|
break;
|
|
}
|
|
}
|
|
if (location == null) {
|
|
throw invalidUrl(url);
|
|
}
|
|
return location;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* Returns the Object resulting from parsing the given JSON, or null if the
|
|
* given string does not represent a JSON object.
|
|
*/
|
|
function jsonObjectOrNull(s) {
|
|
let obj;
|
|
try {
|
|
obj = JSON.parse(s);
|
|
}
|
|
catch (e) {
|
|
return null;
|
|
}
|
|
if (isNonArrayObject(obj)) {
|
|
return obj;
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* @fileoverview Contains helper methods for manipulating paths.
|
|
*/
|
|
/**
|
|
* @return Null if the path is already at the root.
|
|
*/
|
|
function parent(path) {
|
|
if (path.length === 0) {
|
|
return null;
|
|
}
|
|
const index = path.lastIndexOf('/');
|
|
if (index === -1) {
|
|
return '';
|
|
}
|
|
const newPath = path.slice(0, index);
|
|
return newPath;
|
|
}
|
|
function child(path, childPath) {
|
|
const canonicalChildPath = childPath
|
|
.split('/')
|
|
.filter(component => component.length > 0)
|
|
.join('/');
|
|
if (path.length === 0) {
|
|
return canonicalChildPath;
|
|
}
|
|
else {
|
|
return path + '/' + canonicalChildPath;
|
|
}
|
|
}
|
|
/**
|
|
* Returns the last component of a path.
|
|
* '/foo/bar' -> 'bar'
|
|
* '/foo/bar/baz/' -> 'baz/'
|
|
* '/a' -> 'a'
|
|
*/
|
|
function lastComponent(path) {
|
|
const index = path.lastIndexOf('/', path.length - 2);
|
|
if (index === -1) {
|
|
return path;
|
|
}
|
|
else {
|
|
return path.slice(index + 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function makeUrl(urlPart) {
|
|
return `https://${DEFAULT_HOST}/v0${urlPart}`;
|
|
}
|
|
function makeQueryString(params) {
|
|
const encode = encodeURIComponent;
|
|
let queryPart = '?';
|
|
for (const key in params) {
|
|
if (params.hasOwnProperty(key)) {
|
|
// @ts-ignore TODO: remove once typescript is upgraded to 3.5.x
|
|
const nextPart = encode(key) + '=' + encode(params[key]);
|
|
queryPart = queryPart + nextPart + '&';
|
|
}
|
|
}
|
|
// Chop off the extra '&' or '?' on the end
|
|
queryPart = queryPart.slice(0, -1);
|
|
return queryPart;
|
|
}
|
|
|
|
/**
|
|
* @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;
|
|
}
|
|
/**
|
|
* @struct
|
|
*/
|
|
class Mapping {
|
|
constructor(server, local, writable, xform) {
|
|
this.server = server;
|
|
this.local = local || server;
|
|
this.writable = !!writable;
|
|
this.xform = xform || noXform_;
|
|
}
|
|
}
|
|
let mappings_ = null;
|
|
function xformPath(fullPath) {
|
|
if (!isString(fullPath) || fullPath.length < 2) {
|
|
return fullPath;
|
|
}
|
|
else {
|
|
return lastComponent(fullPath);
|
|
}
|
|
}
|
|
function getMappings() {
|
|
if (mappings_) {
|
|
return mappings_;
|
|
}
|
|
const mappings = [];
|
|
mappings.push(new Mapping('bucket'));
|
|
mappings.push(new Mapping('generation'));
|
|
mappings.push(new Mapping('metageneration'));
|
|
mappings.push(new Mapping('name', 'fullPath', true));
|
|
function mappingsXformPath(_metadata, fullPath) {
|
|
return xformPath(fullPath);
|
|
}
|
|
const nameMapping = new Mapping('name');
|
|
nameMapping.xform = mappingsXformPath;
|
|
mappings.push(nameMapping);
|
|
/**
|
|
* Coerces the second param to a number, if it is defined.
|
|
*/
|
|
function xformSize(_metadata, size) {
|
|
if (isDef(size)) {
|
|
return Number(size);
|
|
}
|
|
else {
|
|
return size;
|
|
}
|
|
}
|
|
const sizeMapping = new Mapping('size');
|
|
sizeMapping.xform = xformSize;
|
|
mappings.push(sizeMapping);
|
|
mappings.push(new Mapping('timeCreated'));
|
|
mappings.push(new Mapping('updated'));
|
|
mappings.push(new Mapping('md5Hash', null, true));
|
|
mappings.push(new Mapping('cacheControl', null, true));
|
|
mappings.push(new Mapping('contentDisposition', null, true));
|
|
mappings.push(new Mapping('contentEncoding', null, true));
|
|
mappings.push(new Mapping('contentLanguage', null, true));
|
|
mappings.push(new Mapping('contentType', null, true));
|
|
mappings.push(new Mapping('metadata', 'customMetadata', true));
|
|
mappings_ = mappings;
|
|
return mappings_;
|
|
}
|
|
function addRef(metadata, authWrapper) {
|
|
function generateRef() {
|
|
const bucket = metadata['bucket'];
|
|
const path = metadata['fullPath'];
|
|
const loc = new Location(bucket, path);
|
|
return authWrapper.makeStorageReference(loc);
|
|
}
|
|
Object.defineProperty(metadata, 'ref', { get: generateRef });
|
|
}
|
|
function fromResource(authWrapper, resource, mappings) {
|
|
const metadata = {};
|
|
metadata['type'] = 'file';
|
|
const len = mappings.length;
|
|
for (let i = 0; i < len; i++) {
|
|
const mapping = mappings[i];
|
|
metadata[mapping.local] = mapping.xform(metadata, resource[mapping.server]);
|
|
}
|
|
addRef(metadata, authWrapper);
|
|
return metadata;
|
|
}
|
|
function fromResourceString(authWrapper, resourceString, mappings) {
|
|
const obj = jsonObjectOrNull(resourceString);
|
|
if (obj === null) {
|
|
return null;
|
|
}
|
|
const resource = obj;
|
|
return fromResource(authWrapper, resource, mappings);
|
|
}
|
|
function downloadUrlFromResourceString(metadata, resourceString) {
|
|
const obj = jsonObjectOrNull(resourceString);
|
|
if (obj === null) {
|
|
return null;
|
|
}
|
|
if (!isString(obj['downloadTokens'])) {
|
|
// This can happen if objects are uploaded through GCS and retrieved
|
|
// through list, so we don't want to throw an Error.
|
|
return null;
|
|
}
|
|
const tokens = obj['downloadTokens'];
|
|
if (tokens.length === 0) {
|
|
return null;
|
|
}
|
|
const encode = encodeURIComponent;
|
|
const tokensList = tokens.split(',');
|
|
const urls = tokensList.map((token) => {
|
|
const bucket = metadata['bucket'];
|
|
const path = metadata['fullPath'];
|
|
const urlPart = '/b/' + encode(bucket) + '/o/' + encode(path);
|
|
const base = makeUrl(urlPart);
|
|
const queryString = makeQueryString({
|
|
alt: 'media',
|
|
token
|
|
});
|
|
return base + queryString;
|
|
});
|
|
return urls[0];
|
|
}
|
|
function toResourceString(metadata, mappings) {
|
|
const resource = {};
|
|
const len = mappings.length;
|
|
for (let i = 0; i < len; i++) {
|
|
const mapping = mappings[i];
|
|
if (mapping.writable) {
|
|
resource[mapping.server] = metadata[mapping.local];
|
|
}
|
|
}
|
|
return JSON.stringify(resource);
|
|
}
|
|
function metadataValidator(p) {
|
|
if (!isObject(p) || !p) {
|
|
throw 'Expected Metadata object.';
|
|
}
|
|
for (const key in p) {
|
|
if (p.hasOwnProperty(key)) {
|
|
const val = p[key];
|
|
if (key === 'customMetadata') {
|
|
if (!isObject(val)) {
|
|
throw 'Expected object for \'customMetadata\' mapping.';
|
|
}
|
|
}
|
|
else {
|
|
if (isNonNullObject(val)) {
|
|
throw "Mapping for '" + key + "' cannot be an object.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
const MAX_RESULTS_KEY = 'maxResults';
|
|
const MAX_MAX_RESULTS = 1000;
|
|
const PAGE_TOKEN_KEY = 'pageToken';
|
|
const PREFIXES_KEY = 'prefixes';
|
|
const ITEMS_KEY = 'items';
|
|
function fromBackendResponse(authWrapper, bucket, resource) {
|
|
const listResult = {
|
|
prefixes: [],
|
|
items: [],
|
|
nextPageToken: resource['nextPageToken']
|
|
};
|
|
if (resource[PREFIXES_KEY]) {
|
|
for (const path of resource[PREFIXES_KEY]) {
|
|
const pathWithoutTrailingSlash = path.replace(/\/$/, '');
|
|
const reference = authWrapper.makeStorageReference(new Location(bucket, pathWithoutTrailingSlash));
|
|
listResult.prefixes.push(reference);
|
|
}
|
|
}
|
|
if (resource[ITEMS_KEY]) {
|
|
for (const item of resource[ITEMS_KEY]) {
|
|
const reference = authWrapper.makeStorageReference(new Location(bucket, item['name']));
|
|
listResult.items.push(reference);
|
|
}
|
|
}
|
|
return listResult;
|
|
}
|
|
function fromResponseString(authWrapper, bucket, resourceString) {
|
|
const obj = jsonObjectOrNull(resourceString);
|
|
if (obj === null) {
|
|
return null;
|
|
}
|
|
const resource = obj;
|
|
return fromBackendResponse(authWrapper, bucket, resource);
|
|
}
|
|
function listOptionsValidator(p) {
|
|
if (!isObject(p) || !p) {
|
|
throw 'Expected ListOptions object.';
|
|
}
|
|
for (const key in p) {
|
|
if (key === MAX_RESULTS_KEY) {
|
|
if (!isInteger(p[MAX_RESULTS_KEY]) ||
|
|
p[MAX_RESULTS_KEY] <= 0) {
|
|
throw 'Expected maxResults to be a positive number.';
|
|
}
|
|
if (p[MAX_RESULTS_KEY] > 1000) {
|
|
throw `Expected maxResults to be less than or equal to ${MAX_MAX_RESULTS}.`;
|
|
}
|
|
}
|
|
else if (key === PAGE_TOKEN_KEY) {
|
|
if (p[PAGE_TOKEN_KEY] && !isString(p[PAGE_TOKEN_KEY])) {
|
|
throw 'Expected pageToken to be string.';
|
|
}
|
|
}
|
|
else {
|
|
throw 'Unknown option: ' + key;
|
|
}
|
|
}
|
|
}
|
|
|
|
class RequestInfo {
|
|
constructor(url, method,
|
|
/**
|
|
* Returns the value with which to resolve the request's promise. Only called
|
|
* if the request is successful. Throw from this function to reject the
|
|
* returned Request's promise with the thrown error.
|
|
* Note: The XhrIo passed to this function may be reused after this callback
|
|
* returns. Do not keep a reference to it in any way.
|
|
*/
|
|
handler, timeout) {
|
|
this.url = url;
|
|
this.method = method;
|
|
this.handler = handler;
|
|
this.timeout = timeout;
|
|
this.urlParams = {};
|
|
this.headers = {};
|
|
this.body = null;
|
|
this.errorHandler = null;
|
|
/**
|
|
* Called with the current number of bytes uploaded and total size (-1 if not
|
|
* computable) of the request body (i.e. used to report upload progress).
|
|
*/
|
|
this.progressCallback = null;
|
|
this.successCodes = [200];
|
|
this.additionalRetryCodes = [];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* Throws the UNKNOWN FirebaseStorageError if cndn is false.
|
|
*/
|
|
function handlerCheck(cndn) {
|
|
if (!cndn) {
|
|
throw unknown();
|
|
}
|
|
}
|
|
function metadataHandler(authWrapper, mappings) {
|
|
function handler(xhr, text) {
|
|
const metadata = fromResourceString(authWrapper, text, mappings);
|
|
handlerCheck(metadata !== null);
|
|
return metadata;
|
|
}
|
|
return handler;
|
|
}
|
|
function listHandler(authWrapper, bucket) {
|
|
function handler(xhr, text) {
|
|
const listResult = fromResponseString(authWrapper, bucket, text);
|
|
handlerCheck(listResult !== null);
|
|
return listResult;
|
|
}
|
|
return handler;
|
|
}
|
|
function downloadUrlHandler(authWrapper, mappings) {
|
|
function handler(xhr, text) {
|
|
const metadata = fromResourceString(authWrapper, text, mappings);
|
|
handlerCheck(metadata !== null);
|
|
return downloadUrlFromResourceString(metadata, text);
|
|
}
|
|
return handler;
|
|
}
|
|
function sharedErrorHandler(location) {
|
|
function errorHandler(xhr, err) {
|
|
let newErr;
|
|
if (xhr.getStatus() === 401) {
|
|
newErr = unauthenticated();
|
|
}
|
|
else {
|
|
if (xhr.getStatus() === 402) {
|
|
newErr = quotaExceeded(location.bucket);
|
|
}
|
|
else {
|
|
if (xhr.getStatus() === 403) {
|
|
newErr = unauthorized(location.path);
|
|
}
|
|
else {
|
|
newErr = err;
|
|
}
|
|
}
|
|
}
|
|
newErr.setServerResponseProp(err.serverResponseProp());
|
|
return newErr;
|
|
}
|
|
return errorHandler;
|
|
}
|
|
function objectErrorHandler(location) {
|
|
const shared = sharedErrorHandler(location);
|
|
function errorHandler(xhr, err) {
|
|
let newErr = shared(xhr, err);
|
|
if (xhr.getStatus() === 404) {
|
|
newErr = objectNotFound(location.path);
|
|
}
|
|
newErr.setServerResponseProp(err.serverResponseProp());
|
|
return newErr;
|
|
}
|
|
return errorHandler;
|
|
}
|
|
function getMetadata(authWrapper, location, mappings) {
|
|
const urlPart = location.fullServerUrl();
|
|
const url = makeUrl(urlPart);
|
|
const method = 'GET';
|
|
const timeout = authWrapper.maxOperationRetryTime();
|
|
const requestInfo = new RequestInfo(url, method, metadataHandler(authWrapper, mappings), timeout);
|
|
requestInfo.errorHandler = objectErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
function list(authWrapper, location, delimiter, pageToken, maxResults) {
|
|
const urlParams = {};
|
|
if (location.isRoot) {
|
|
urlParams['prefix'] = '';
|
|
}
|
|
else {
|
|
urlParams['prefix'] = location.path + '/';
|
|
}
|
|
if (delimiter && delimiter.length > 0) {
|
|
urlParams['delimiter'] = delimiter;
|
|
}
|
|
if (pageToken) {
|
|
urlParams['pageToken'] = pageToken;
|
|
}
|
|
if (maxResults) {
|
|
urlParams['maxResults'] = maxResults;
|
|
}
|
|
const urlPart = location.bucketOnlyServerUrl();
|
|
const url = makeUrl(urlPart);
|
|
const method = 'GET';
|
|
const timeout = authWrapper.maxOperationRetryTime();
|
|
const requestInfo = new RequestInfo(url, method, listHandler(authWrapper, location.bucket), timeout);
|
|
requestInfo.urlParams = urlParams;
|
|
requestInfo.errorHandler = sharedErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
function getDownloadUrl(authWrapper, location, mappings) {
|
|
const urlPart = location.fullServerUrl();
|
|
const url = makeUrl(urlPart);
|
|
const method = 'GET';
|
|
const timeout = authWrapper.maxOperationRetryTime();
|
|
const requestInfo = new RequestInfo(url, method, downloadUrlHandler(authWrapper, mappings), timeout);
|
|
requestInfo.errorHandler = objectErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
function updateMetadata(authWrapper, location, metadata, mappings) {
|
|
const urlPart = location.fullServerUrl();
|
|
const url = makeUrl(urlPart);
|
|
const method = 'PATCH';
|
|
const body = toResourceString(metadata, mappings);
|
|
const headers = { 'Content-Type': 'application/json; charset=utf-8' };
|
|
const timeout = authWrapper.maxOperationRetryTime();
|
|
const requestInfo = new RequestInfo(url, method, metadataHandler(authWrapper, mappings), timeout);
|
|
requestInfo.headers = headers;
|
|
requestInfo.body = body;
|
|
requestInfo.errorHandler = objectErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
function deleteObject(authWrapper, location) {
|
|
const urlPart = location.fullServerUrl();
|
|
const url = makeUrl(urlPart);
|
|
const method = 'DELETE';
|
|
const timeout = authWrapper.maxOperationRetryTime();
|
|
function handler(_xhr, _text) { }
|
|
const requestInfo = new RequestInfo(url, method, handler, timeout);
|
|
requestInfo.successCodes = [200, 204];
|
|
requestInfo.errorHandler = objectErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
function determineContentType_(metadata, blob) {
|
|
return ((metadata && metadata['contentType']) ||
|
|
(blob && blob.type()) ||
|
|
'application/octet-stream');
|
|
}
|
|
function metadataForUpload_(location, blob, metadata) {
|
|
const metadataClone = Object.assign({}, metadata);
|
|
metadataClone['fullPath'] = location.path;
|
|
metadataClone['size'] = blob.size();
|
|
if (!metadataClone['contentType']) {
|
|
metadataClone['contentType'] = determineContentType_(null, blob);
|
|
}
|
|
return metadataClone;
|
|
}
|
|
function multipartUpload(authWrapper, location, mappings, blob, metadata) {
|
|
const urlPart = location.bucketOnlyServerUrl();
|
|
const headers = {
|
|
'X-Goog-Upload-Protocol': 'multipart'
|
|
};
|
|
function genBoundary() {
|
|
let str = '';
|
|
for (let i = 0; i < 2; i++) {
|
|
str =
|
|
str +
|
|
Math.random()
|
|
.toString()
|
|
.slice(2);
|
|
}
|
|
return str;
|
|
}
|
|
const boundary = genBoundary();
|
|
headers['Content-Type'] = 'multipart/related; boundary=' + boundary;
|
|
const metadata_ = metadataForUpload_(location, blob, metadata);
|
|
const metadataString = toResourceString(metadata_, mappings);
|
|
const preBlobPart = '--' +
|
|
boundary +
|
|
'\r\n' +
|
|
'Content-Type: application/json; charset=utf-8\r\n\r\n' +
|
|
metadataString +
|
|
'\r\n--' +
|
|
boundary +
|
|
'\r\n' +
|
|
'Content-Type: ' +
|
|
metadata_['contentType'] +
|
|
'\r\n\r\n';
|
|
const postBlobPart = '\r\n--' + boundary + '--';
|
|
const body = FbsBlob.getBlob(preBlobPart, blob, postBlobPart);
|
|
if (body === null) {
|
|
throw cannotSliceBlob();
|
|
}
|
|
const urlParams = { name: metadata_['fullPath'] };
|
|
const url = makeUrl(urlPart);
|
|
const method = 'POST';
|
|
const timeout = authWrapper.maxUploadRetryTime();
|
|
const requestInfo = new RequestInfo(url, method, metadataHandler(authWrapper, 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.
|
|
* @struct
|
|
*/
|
|
class ResumableUploadStatus {
|
|
constructor(current, total, finalized, metadata) {
|
|
this.current = current;
|
|
this.total = total;
|
|
this.finalized = !!finalized;
|
|
this.metadata = metadata || null;
|
|
}
|
|
}
|
|
function checkResumeHeader_(xhr, allowed) {
|
|
let status = null;
|
|
try {
|
|
status = xhr.getResponseHeader('X-Goog-Upload-Status');
|
|
}
|
|
catch (e) {
|
|
handlerCheck(false);
|
|
}
|
|
const allowedStatus = allowed || ['active'];
|
|
handlerCheck(!!status && allowedStatus.indexOf(status) !== -1);
|
|
return status;
|
|
}
|
|
function createResumableUpload(authWrapper, location, mappings, blob, metadata) {
|
|
const urlPart = location.bucketOnlyServerUrl();
|
|
const metadataForUpload = metadataForUpload_(location, blob, metadata);
|
|
const urlParams = { name: metadataForUpload['fullPath'] };
|
|
const url = makeUrl(urlPart);
|
|
const method = 'POST';
|
|
const headers = {
|
|
'X-Goog-Upload-Protocol': 'resumable',
|
|
'X-Goog-Upload-Command': 'start',
|
|
'X-Goog-Upload-Header-Content-Length': blob.size(),
|
|
'X-Goog-Upload-Header-Content-Type': metadataForUpload['contentType'],
|
|
'Content-Type': 'application/json; charset=utf-8'
|
|
};
|
|
const body = toResourceString(metadataForUpload, mappings);
|
|
const timeout = authWrapper.maxUploadRetryTime();
|
|
function handler(xhr) {
|
|
checkResumeHeader_(xhr);
|
|
let url;
|
|
try {
|
|
url = xhr.getResponseHeader('X-Goog-Upload-URL');
|
|
}
|
|
catch (e) {
|
|
handlerCheck(false);
|
|
}
|
|
handlerCheck(isString(url));
|
|
return url;
|
|
}
|
|
const requestInfo = new RequestInfo(url, method, handler, timeout);
|
|
requestInfo.urlParams = urlParams;
|
|
requestInfo.headers = headers;
|
|
requestInfo.body = body;
|
|
requestInfo.errorHandler = sharedErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
/**
|
|
* @param url From a call to fbs.requests.createResumableUpload.
|
|
*/
|
|
function getResumableUploadStatus(authWrapper, location, url, blob) {
|
|
const headers = { 'X-Goog-Upload-Command': 'query' };
|
|
function handler(xhr) {
|
|
const status = checkResumeHeader_(xhr, ['active', 'final']);
|
|
let sizeString = null;
|
|
try {
|
|
sizeString = xhr.getResponseHeader('X-Goog-Upload-Size-Received');
|
|
}
|
|
catch (e) {
|
|
handlerCheck(false);
|
|
}
|
|
if (!sizeString) {
|
|
// null or empty string
|
|
handlerCheck(false);
|
|
}
|
|
const size = Number(sizeString);
|
|
handlerCheck(!isNaN(size));
|
|
return new ResumableUploadStatus(size, blob.size(), status === 'final');
|
|
}
|
|
const method = 'POST';
|
|
const timeout = authWrapper.maxUploadRetryTime();
|
|
const requestInfo = new RequestInfo(url, method, handler, timeout);
|
|
requestInfo.headers = headers;
|
|
requestInfo.errorHandler = sharedErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
/**
|
|
* Any uploads via the resumable upload API must transfer a number of bytes
|
|
* that is a multiple of this number.
|
|
*/
|
|
const resumableUploadChunkSize = 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, authWrapper, url, blob, chunkSize, mappings, status, progressCallback) {
|
|
// TODO(andysoto): standardize on internal asserts
|
|
// assert(!(opt_status && opt_status.finalized));
|
|
const status_ = new ResumableUploadStatus(0, 0);
|
|
if (status) {
|
|
status_.current = status.current;
|
|
status_.total = status.total;
|
|
}
|
|
else {
|
|
status_.current = 0;
|
|
status_.total = blob.size();
|
|
}
|
|
if (blob.size() !== status_.total) {
|
|
throw serverFileWrongSize();
|
|
}
|
|
const bytesLeft = status_.total - status_.current;
|
|
let bytesToUpload = bytesLeft;
|
|
if (chunkSize > 0) {
|
|
bytesToUpload = Math.min(bytesToUpload, chunkSize);
|
|
}
|
|
const startByte = status_.current;
|
|
const endByte = startByte + bytesToUpload;
|
|
const uploadCommand = bytesToUpload === bytesLeft ? 'upload, finalize' : 'upload';
|
|
const headers = {
|
|
'X-Goog-Upload-Command': uploadCommand,
|
|
'X-Goog-Upload-Offset': status_.current
|
|
};
|
|
const body = blob.slice(startByte, endByte);
|
|
if (body === null) {
|
|
throw cannotSliceBlob();
|
|
}
|
|
function handler(xhr, text) {
|
|
// TODO(andysoto): Verify the MD5 of each uploaded range:
|
|
// the 'x-range-md5' header comes back with status code 308 responses.
|
|
// We'll only be able to bail out though, because you can't re-upload a
|
|
// range that you previously uploaded.
|
|
const uploadStatus = checkResumeHeader_(xhr, ['active', 'final']);
|
|
const newCurrent = status_.current + bytesToUpload;
|
|
const size = blob.size();
|
|
let metadata;
|
|
if (uploadStatus === 'final') {
|
|
metadata = metadataHandler(authWrapper, mappings)(xhr, text);
|
|
}
|
|
else {
|
|
metadata = null;
|
|
}
|
|
return new ResumableUploadStatus(newCurrent, size, uploadStatus === 'final', metadata);
|
|
}
|
|
const method = 'POST';
|
|
const timeout = authWrapper.maxUploadRetryTime();
|
|
const requestInfo = new RequestInfo(url, method, handler, timeout);
|
|
requestInfo.headers = headers;
|
|
requestInfo.body = body.uploadData();
|
|
requestInfo.progressCallback = progressCallback || null;
|
|
requestInfo.errorHandler = sharedErrorHandler(location);
|
|
return requestInfo;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* @struct
|
|
*/
|
|
class Observer {
|
|
constructor(nextOrObserver, error, complete) {
|
|
const asFunctions = isFunction(nextOrObserver) ||
|
|
isDef(error) ||
|
|
isDef(complete);
|
|
if (asFunctions) {
|
|
this.next = nextOrObserver;
|
|
this.error = error || null;
|
|
this.complete = complete || null;
|
|
}
|
|
else {
|
|
const observer = nextOrObserver;
|
|
this.next = observer.next || null;
|
|
this.error = observer.error || null;
|
|
this.complete = observer.complete || null;
|
|
}
|
|
}
|
|
}
|
|
|
|
class UploadTaskSnapshot {
|
|
constructor(bytesTransferred, totalBytes, state, metadata, task, ref) {
|
|
this.bytesTransferred = bytesTransferred;
|
|
this.totalBytes = totalBytes;
|
|
this.state = state;
|
|
this.metadata = metadata;
|
|
this.task = task;
|
|
this.ref = ref;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @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 name Name of the function.
|
|
* @param specs Argument specs.
|
|
* @param passed The actual arguments passed to the function.
|
|
* @throws {fbs.Error} If the arguments are invalid.
|
|
*/
|
|
function validate(name, specs, passed) {
|
|
let minArgs = specs.length;
|
|
const maxArgs = specs.length;
|
|
for (let i = 0; i < specs.length; i++) {
|
|
if (specs[i].optional) {
|
|
minArgs = i;
|
|
break;
|
|
}
|
|
}
|
|
const validLength = minArgs <= passed.length && passed.length <= maxArgs;
|
|
if (!validLength) {
|
|
throw invalidArgumentCount(minArgs, maxArgs, name, passed.length);
|
|
}
|
|
for (let i = 0; i < passed.length; i++) {
|
|
try {
|
|
specs[i].validator(passed[i]);
|
|
}
|
|
catch (e) {
|
|
if (e instanceof Error) {
|
|
throw invalidArgument(i, name, e.message);
|
|
}
|
|
else {
|
|
throw invalidArgument(i, name, e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @struct
|
|
*/
|
|
class ArgSpec {
|
|
constructor(validator, optional) {
|
|
const self = this;
|
|
this.validator = function (p) {
|
|
if (self.optional && !isJustDef(p)) {
|
|
return;
|
|
}
|
|
validator(p);
|
|
};
|
|
this.optional = !!optional;
|
|
}
|
|
}
|
|
function and_(v1, v2) {
|
|
return function (p) {
|
|
v1(p);
|
|
v2(p);
|
|
};
|
|
}
|
|
function stringSpec(validator, optional) {
|
|
function stringValidator(p) {
|
|
if (!isString(p)) {
|
|
throw 'Expected string.';
|
|
}
|
|
}
|
|
let chainedValidator;
|
|
if (validator) {
|
|
chainedValidator = and_(stringValidator, validator);
|
|
}
|
|
else {
|
|
chainedValidator = stringValidator;
|
|
}
|
|
return new ArgSpec(chainedValidator, optional);
|
|
}
|
|
function uploadDataSpec() {
|
|
function validator(p) {
|
|
const valid = p instanceof Uint8Array ||
|
|
p instanceof ArrayBuffer ||
|
|
(isNativeBlobDefined() && p instanceof Blob);
|
|
if (!valid) {
|
|
throw 'Expected Blob or File.';
|
|
}
|
|
}
|
|
return new ArgSpec(validator);
|
|
}
|
|
function metadataSpec(optional) {
|
|
return new ArgSpec(metadataValidator, optional);
|
|
}
|
|
function listOptionSpec(optional) {
|
|
return new ArgSpec(listOptionsValidator, optional);
|
|
}
|
|
function nonNegativeNumberSpec() {
|
|
function validator(p) {
|
|
const valid = isNumber(p) && p >= 0;
|
|
if (!valid) {
|
|
throw 'Expected a number 0 or greater.';
|
|
}
|
|
}
|
|
return new ArgSpec(validator);
|
|
}
|
|
function looseObjectSpec(validator, optional) {
|
|
function isLooseObjectValidator(p) {
|
|
const isLooseObject = p === null || (isDef(p) && p instanceof Object);
|
|
if (!isLooseObject) {
|
|
throw 'Expected an Object.';
|
|
}
|
|
if (validator !== undefined && validator !== null) {
|
|
validator(p);
|
|
}
|
|
}
|
|
return new ArgSpec(isLooseObjectValidator, optional);
|
|
}
|
|
function nullFunctionSpec(optional) {
|
|
function validator(p) {
|
|
const valid = p === null || isFunction(p);
|
|
if (!valid) {
|
|
throw 'Expected a Function.';
|
|
}
|
|
}
|
|
return new ArgSpec(validator, optional);
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
function async(f) {
|
|
return (...argsToForward) => {
|
|
// eslint-disable-next-line @typescript-eslint/no-floating-promises
|
|
Promise.resolve().then(() => f(...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.
|
|
*/
|
|
/**
|
|
* Represents a blob being uploaded. Can be used to pause/resume/cancel the
|
|
* upload and manage callbacks for various events.
|
|
*/
|
|
class UploadTask {
|
|
/**
|
|
* @param ref The firebaseStorage.Reference object this task came
|
|
* from, untyped to avoid cyclic dependencies.
|
|
* @param blob The blob to upload.
|
|
*/
|
|
constructor(ref, authWrapper, location, mappings, blob, metadata = null) {
|
|
this.transferred_ = 0;
|
|
this.needToFetchStatus_ = false;
|
|
this.needToFetchMetadata_ = false;
|
|
this.observers_ = [];
|
|
this.error_ = null;
|
|
this.uploadUrl_ = null;
|
|
this.request_ = null;
|
|
this.chunkMultiplier_ = 1;
|
|
this.resolve_ = null;
|
|
this.reject_ = null;
|
|
this.ref_ = ref;
|
|
this.authWrapper_ = authWrapper;
|
|
this.location_ = location;
|
|
this.blob_ = blob;
|
|
this.metadata_ = metadata;
|
|
this.mappings_ = mappings;
|
|
this.resumable_ = this.shouldDoResumable_(this.blob_);
|
|
this.state_ = InternalTaskState.RUNNING;
|
|
this.errorHandler_ = error => {
|
|
this.request_ = null;
|
|
this.chunkMultiplier_ = 1;
|
|
if (error.codeEquals(Code.CANCELED)) {
|
|
this.needToFetchStatus_ = true;
|
|
this.completeTransitions_();
|
|
}
|
|
else {
|
|
this.error_ = error;
|
|
this.transition_(InternalTaskState.ERROR);
|
|
}
|
|
};
|
|
this.metadataErrorHandler_ = error => {
|
|
this.request_ = null;
|
|
if (error.codeEquals(Code.CANCELED)) {
|
|
this.completeTransitions_();
|
|
}
|
|
else {
|
|
this.error_ = error;
|
|
this.transition_(InternalTaskState.ERROR);
|
|
}
|
|
};
|
|
this.promise_ = new Promise((resolve, reject) => {
|
|
this.resolve_ = resolve;
|
|
this.reject_ = reject;
|
|
this.start_();
|
|
});
|
|
// Prevent uncaught rejections on the internal promise from bubbling out
|
|
// to the top level with a dummy handler.
|
|
this.promise_.then(null, () => { });
|
|
}
|
|
makeProgressCallback_() {
|
|
const sizeBefore = this.transferred_;
|
|
return loaded => this.updateProgress_(sizeBefore + loaded);
|
|
}
|
|
shouldDoResumable_(blob) {
|
|
return blob.size() > 256 * 1024;
|
|
}
|
|
start_() {
|
|
if (this.state_ !== InternalTaskState.RUNNING) {
|
|
// This can happen if someone pauses us in a resume callback, for example.
|
|
return;
|
|
}
|
|
if (this.request_ !== null) {
|
|
return;
|
|
}
|
|
if (this.resumable_) {
|
|
if (this.uploadUrl_ === null) {
|
|
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.continueUpload_();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
this.oneShotUpload_();
|
|
}
|
|
}
|
|
resolveToken_(callback) {
|
|
// eslint-disable-next-line @typescript-eslint/no-floating-promises
|
|
this.authWrapper_.getAuthToken().then(authToken => {
|
|
switch (this.state_) {
|
|
case InternalTaskState.RUNNING:
|
|
callback(authToken);
|
|
break;
|
|
case InternalTaskState.CANCELING:
|
|
this.transition_(InternalTaskState.CANCELED);
|
|
break;
|
|
case InternalTaskState.PAUSING:
|
|
this.transition_(InternalTaskState.PAUSED);
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
// TODO(andysoto): assert false
|
|
createResumable_() {
|
|
this.resolveToken_(authToken => {
|
|
const requestInfo = createResumableUpload(this.authWrapper_, this.location_, this.mappings_, this.blob_, this.metadata_);
|
|
const createRequest = this.authWrapper_.makeRequest(requestInfo, authToken);
|
|
this.request_ = createRequest;
|
|
createRequest.getPromise().then((url) => {
|
|
this.request_ = null;
|
|
this.uploadUrl_ = url;
|
|
this.needToFetchStatus_ = false;
|
|
this.completeTransitions_();
|
|
}, this.errorHandler_);
|
|
});
|
|
}
|
|
fetchStatus_() {
|
|
// TODO(andysoto): assert(this.uploadUrl_ !== null);
|
|
const url = this.uploadUrl_;
|
|
this.resolveToken_(authToken => {
|
|
const requestInfo = getResumableUploadStatus(this.authWrapper_, this.location_, url, this.blob_);
|
|
const statusRequest = this.authWrapper_.makeRequest(requestInfo, authToken);
|
|
this.request_ = statusRequest;
|
|
statusRequest.getPromise().then(status => {
|
|
status = status;
|
|
this.request_ = null;
|
|
this.updateProgress_(status.current);
|
|
this.needToFetchStatus_ = false;
|
|
if (status.finalized) {
|
|
this.needToFetchMetadata_ = true;
|
|
}
|
|
this.completeTransitions_();
|
|
}, this.errorHandler_);
|
|
});
|
|
}
|
|
continueUpload_() {
|
|
const chunkSize = resumableUploadChunkSize * this.chunkMultiplier_;
|
|
const status = new ResumableUploadStatus(this.transferred_, this.blob_.size());
|
|
// TODO(andysoto): assert(this.uploadUrl_ !== null);
|
|
const url = this.uploadUrl_;
|
|
this.resolveToken_(authToken => {
|
|
let requestInfo;
|
|
try {
|
|
requestInfo = continueResumableUpload(this.location_, this.authWrapper_, url, this.blob_, chunkSize, this.mappings_, status, this.makeProgressCallback_());
|
|
}
|
|
catch (e) {
|
|
this.error_ = e;
|
|
this.transition_(InternalTaskState.ERROR);
|
|
return;
|
|
}
|
|
const uploadRequest = this.authWrapper_.makeRequest(requestInfo, authToken);
|
|
this.request_ = uploadRequest;
|
|
uploadRequest
|
|
.getPromise()
|
|
.then((newStatus) => {
|
|
this.increaseMultiplier_();
|
|
this.request_ = null;
|
|
this.updateProgress_(newStatus.current);
|
|
if (newStatus.finalized) {
|
|
this.metadata_ = newStatus.metadata;
|
|
this.transition_(InternalTaskState.SUCCESS);
|
|
}
|
|
else {
|
|
this.completeTransitions_();
|
|
}
|
|
}, this.errorHandler_);
|
|
});
|
|
}
|
|
increaseMultiplier_() {
|
|
const currentSize = resumableUploadChunkSize * this.chunkMultiplier_;
|
|
// Max chunk size is 32M.
|
|
if (currentSize < 32 * 1024 * 1024) {
|
|
this.chunkMultiplier_ *= 2;
|
|
}
|
|
}
|
|
fetchMetadata_() {
|
|
this.resolveToken_(authToken => {
|
|
const requestInfo = getMetadata(this.authWrapper_, this.location_, this.mappings_);
|
|
const metadataRequest = this.authWrapper_.makeRequest(requestInfo, authToken);
|
|
this.request_ = metadataRequest;
|
|
metadataRequest.getPromise().then(metadata => {
|
|
this.request_ = null;
|
|
this.metadata_ = metadata;
|
|
this.transition_(InternalTaskState.SUCCESS);
|
|
}, this.metadataErrorHandler_);
|
|
});
|
|
}
|
|
oneShotUpload_() {
|
|
this.resolveToken_(authToken => {
|
|
const requestInfo = multipartUpload(this.authWrapper_, this.location_, this.mappings_, this.blob_, this.metadata_);
|
|
const multipartRequest = this.authWrapper_.makeRequest(requestInfo, authToken);
|
|
this.request_ = multipartRequest;
|
|
multipartRequest.getPromise().then(metadata => {
|
|
this.request_ = null;
|
|
this.metadata_ = metadata;
|
|
this.updateProgress_(this.blob_.size());
|
|
this.transition_(InternalTaskState.SUCCESS);
|
|
}, this.errorHandler_);
|
|
});
|
|
}
|
|
updateProgress_(transferred) {
|
|
const old = this.transferred_;
|
|
this.transferred_ = transferred;
|
|
// A progress update can make the "transferred" value smaller (e.g. a
|
|
// partial upload not completed by server, after which the "transferred"
|
|
// value may reset to the value at the beginning of the request).
|
|
if (this.transferred_ !== old) {
|
|
this.notifyObservers_();
|
|
}
|
|
}
|
|
transition_(state) {
|
|
if (this.state_ === state) {
|
|
return;
|
|
}
|
|
switch (state) {
|
|
case InternalTaskState.CANCELING:
|
|
// TODO(andysoto):
|
|
// assert(this.state_ === InternalTaskState.RUNNING ||
|
|
// this.state_ === InternalTaskState.PAUSING);
|
|
this.state_ = state;
|
|
if (this.request_ !== null) {
|
|
this.request_.cancel();
|
|
}
|
|
break;
|
|
case InternalTaskState.PAUSING:
|
|
// TODO(andysoto):
|
|
// assert(this.state_ === InternalTaskState.RUNNING);
|
|
this.state_ = state;
|
|
if (this.request_ !== null) {
|
|
this.request_.cancel();
|
|
}
|
|
break;
|
|
case InternalTaskState.RUNNING:
|
|
// TODO(andysoto):
|
|
// assert(this.state_ === InternalTaskState.PAUSED ||
|
|
// this.state_ === InternalTaskState.PAUSING);
|
|
const wasPaused = this.state_ === InternalTaskState.PAUSED;
|
|
this.state_ = state;
|
|
if (wasPaused) {
|
|
this.notifyObservers_();
|
|
this.start_();
|
|
}
|
|
break;
|
|
case InternalTaskState.PAUSED:
|
|
// TODO(andysoto):
|
|
// assert(this.state_ === InternalTaskState.PAUSING);
|
|
this.state_ = state;
|
|
this.notifyObservers_();
|
|
break;
|
|
case InternalTaskState.CANCELED:
|
|
// TODO(andysoto):
|
|
// assert(this.state_ === InternalTaskState.PAUSED ||
|
|
// this.state_ === InternalTaskState.CANCELING);
|
|
this.error_ = canceled();
|
|
this.state_ = state;
|
|
this.notifyObservers_();
|
|
break;
|
|
case InternalTaskState.ERROR:
|
|
// TODO(andysoto):
|
|
// assert(this.state_ === InternalTaskState.RUNNING ||
|
|
// this.state_ === InternalTaskState.PAUSING ||
|
|
// this.state_ === InternalTaskState.CANCELING);
|
|
this.state_ = state;
|
|
this.notifyObservers_();
|
|
break;
|
|
case InternalTaskState.SUCCESS:
|
|
// TODO(andysoto):
|
|
// assert(this.state_ === InternalTaskState.RUNNING ||
|
|
// this.state_ === InternalTaskState.PAUSING ||
|
|
// this.state_ === InternalTaskState.CANCELING);
|
|
this.state_ = state;
|
|
this.notifyObservers_();
|
|
break;
|
|
}
|
|
}
|
|
completeTransitions_() {
|
|
switch (this.state_) {
|
|
case InternalTaskState.PAUSING:
|
|
this.transition_(InternalTaskState.PAUSED);
|
|
break;
|
|
case InternalTaskState.CANCELING:
|
|
this.transition_(InternalTaskState.CANCELED);
|
|
break;
|
|
case InternalTaskState.RUNNING:
|
|
this.start_();
|
|
break;
|
|
}
|
|
}
|
|
get snapshot() {
|
|
const externalState = taskStateFromInternalTaskState(this.state_);
|
|
return new UploadTaskSnapshot(this.transferred_, this.blob_.size(), externalState, this.metadata_, this, this.ref_);
|
|
}
|
|
/**
|
|
* Adds a callback for an event.
|
|
* @param type The type of event to listen for.
|
|
*/
|
|
on(type, nextOrObserver, error, completed) {
|
|
function typeValidator() {
|
|
if (type !== TaskEvent.STATE_CHANGED) {
|
|
throw `Expected one of the event types: [${TaskEvent.STATE_CHANGED}].`;
|
|
}
|
|
}
|
|
const nextOrObserverMessage = 'Expected a function or an Object with one of ' +
|
|
'`next`, `error`, `complete` properties.';
|
|
const nextValidator = nullFunctionSpec(true).validator;
|
|
const observerValidator = looseObjectSpec(null, true).validator;
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
function nextOrObserverValidator(p) {
|
|
try {
|
|
nextValidator(p);
|
|
return;
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
observerValidator(p);
|
|
const anyDefined = isJustDef(p['next']) ||
|
|
isJustDef(p['error']) ||
|
|
isJustDef(p['complete']);
|
|
if (!anyDefined) {
|
|
throw '';
|
|
}
|
|
return;
|
|
}
|
|
catch (e) {
|
|
throw nextOrObserverMessage;
|
|
}
|
|
}
|
|
const specs = [
|
|
stringSpec(typeValidator),
|
|
looseObjectSpec(nextOrObserverValidator, true),
|
|
nullFunctionSpec(true),
|
|
nullFunctionSpec(true)
|
|
];
|
|
validate('on', specs, arguments);
|
|
const self = this;
|
|
function makeBinder(specs) {
|
|
function binder(nextOrObserver, error, complete) {
|
|
if (specs !== null) {
|
|
validate('on', specs, arguments);
|
|
}
|
|
const observer = new Observer(nextOrObserver, error, completed);
|
|
self.addObserver_(observer);
|
|
return () => {
|
|
self.removeObserver_(observer);
|
|
};
|
|
}
|
|
return binder;
|
|
}
|
|
function binderNextOrObserverValidator(p) {
|
|
if (p === null) {
|
|
throw nextOrObserverMessage;
|
|
}
|
|
nextOrObserverValidator(p);
|
|
}
|
|
const binderSpecs = [
|
|
looseObjectSpec(binderNextOrObserverValidator),
|
|
nullFunctionSpec(true),
|
|
nullFunctionSpec(true)
|
|
];
|
|
const typeOnly = !(isJustDef(nextOrObserver) ||
|
|
isJustDef(error) ||
|
|
isJustDef(completed));
|
|
if (typeOnly) {
|
|
return makeBinder(binderSpecs);
|
|
}
|
|
else {
|
|
return makeBinder(null)(nextOrObserver, error, completed);
|
|
}
|
|
}
|
|
/**
|
|
* This object behaves like a Promise, and resolves with its snapshot data
|
|
* when the upload completes.
|
|
* @param onFulfilled The fulfillment callback. Promise chaining works as normal.
|
|
* @param onRejected The rejection callback.
|
|
*/
|
|
then(onFulfilled, onRejected) {
|
|
// These casts are needed so that TypeScript can infer the types of the
|
|
// resulting Promise.
|
|
return this.promise_.then(onFulfilled, onRejected);
|
|
}
|
|
/**
|
|
* Equivalent to calling `then(null, onRejected)`.
|
|
*/
|
|
catch(onRejected) {
|
|
return this.then(null, onRejected);
|
|
}
|
|
/**
|
|
* Adds the given observer.
|
|
*/
|
|
addObserver_(observer) {
|
|
this.observers_.push(observer);
|
|
this.notifyObserver_(observer);
|
|
}
|
|
/**
|
|
* Removes the given observer.
|
|
*/
|
|
removeObserver_(observer) {
|
|
const i = this.observers_.indexOf(observer);
|
|
if (i !== -1) {
|
|
this.observers_.splice(i, 1);
|
|
}
|
|
}
|
|
notifyObservers_() {
|
|
this.finishPromise_();
|
|
const observers = this.observers_.slice();
|
|
observers.forEach(observer => {
|
|
this.notifyObserver_(observer);
|
|
});
|
|
}
|
|
finishPromise_() {
|
|
if (this.resolve_ !== null) {
|
|
let triggered = true;
|
|
switch (taskStateFromInternalTaskState(this.state_)) {
|
|
case TaskState.SUCCESS:
|
|
async(this.resolve_.bind(null, this.snapshot))();
|
|
break;
|
|
case TaskState.CANCELED:
|
|
case TaskState.ERROR:
|
|
const toCall = this.reject_;
|
|
async(toCall.bind(null, this.error_))();
|
|
break;
|
|
default:
|
|
triggered = false;
|
|
break;
|
|
}
|
|
if (triggered) {
|
|
this.resolve_ = null;
|
|
this.reject_ = null;
|
|
}
|
|
}
|
|
}
|
|
notifyObserver_(observer) {
|
|
const externalState = taskStateFromInternalTaskState(this.state_);
|
|
switch (externalState) {
|
|
case TaskState.RUNNING:
|
|
case TaskState.PAUSED:
|
|
if (observer.next) {
|
|
async(observer.next.bind(observer, this.snapshot))();
|
|
}
|
|
break;
|
|
case TaskState.SUCCESS:
|
|
if (observer.complete) {
|
|
async(observer.complete.bind(observer))();
|
|
}
|
|
break;
|
|
case TaskState.CANCELED:
|
|
case TaskState.ERROR:
|
|
if (observer.error) {
|
|
async(observer.error.bind(observer, this.error_))();
|
|
}
|
|
break;
|
|
default:
|
|
// TODO(andysoto): assert(false);
|
|
if (observer.error) {
|
|
async(observer.error.bind(observer, this.error_))();
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Resumes a paused task. Has no effect on a currently running or failed task.
|
|
* @return True if the operation took effect, false if ignored.
|
|
*/
|
|
resume() {
|
|
validate('resume', [], arguments);
|
|
const valid = this.state_ === InternalTaskState.PAUSED ||
|
|
this.state_ === InternalTaskState.PAUSING;
|
|
if (valid) {
|
|
this.transition_(InternalTaskState.RUNNING);
|
|
}
|
|
return valid;
|
|
}
|
|
/**
|
|
* Pauses a currently running task. Has no effect on a paused or failed task.
|
|
* @return True if the operation took effect, false if ignored.
|
|
*/
|
|
pause() {
|
|
validate('pause', [], arguments);
|
|
const valid = this.state_ === InternalTaskState.RUNNING;
|
|
if (valid) {
|
|
this.transition_(InternalTaskState.PAUSING);
|
|
}
|
|
return valid;
|
|
}
|
|
/**
|
|
* Cancels a currently running or paused task. Has no effect on a complete or
|
|
* failed task.
|
|
* @return True if the operation took effect, false if ignored.
|
|
*/
|
|
cancel() {
|
|
validate('cancel', [], arguments);
|
|
const valid = this.state_ === InternalTaskState.RUNNING ||
|
|
this.state_ === InternalTaskState.PAUSING;
|
|
if (valid) {
|
|
this.transition_(InternalTaskState.CANCELING);
|
|
}
|
|
return valid;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* Provides methods to interact with a bucket in the Firebase Storage service.
|
|
* @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.
|
|
*/
|
|
class Reference {
|
|
constructor(authWrapper, location) {
|
|
this.authWrapper = authWrapper;
|
|
if (location instanceof Location) {
|
|
this.location = location;
|
|
}
|
|
else {
|
|
this.location = Location.makeFromUrl(location);
|
|
}
|
|
}
|
|
/**
|
|
* @return The URL for the bucket and path this object references,
|
|
* in the form gs://<bucket>/<object-path>
|
|
* @override
|
|
*/
|
|
toString() {
|
|
validate('toString', [], arguments);
|
|
return 'gs://' + this.location.bucket + '/' + this.location.path;
|
|
}
|
|
newRef(authWrapper, location) {
|
|
return new Reference(authWrapper, location);
|
|
}
|
|
mappings() {
|
|
return getMappings();
|
|
}
|
|
/**
|
|
* @return A reference to the object obtained by
|
|
* appending childPath, removing any duplicate, beginning, or trailing
|
|
* slashes.
|
|
*/
|
|
child(childPath) {
|
|
validate('child', [stringSpec()], arguments);
|
|
const newPath = child(this.location.path, childPath);
|
|
const location = new Location(this.location.bucket, newPath);
|
|
return this.newRef(this.authWrapper, location);
|
|
}
|
|
/**
|
|
* @return A reference to the parent of the
|
|
* current object, or null if the current object is the root.
|
|
*/
|
|
get parent() {
|
|
const newPath = parent(this.location.path);
|
|
if (newPath === null) {
|
|
return null;
|
|
}
|
|
const location = new Location(this.location.bucket, newPath);
|
|
return this.newRef(this.authWrapper, location);
|
|
}
|
|
/**
|
|
* @return An reference to the root of this
|
|
* object's bucket.
|
|
*/
|
|
get root() {
|
|
const location = new Location(this.location.bucket, '');
|
|
return this.newRef(this.authWrapper, location);
|
|
}
|
|
get bucket() {
|
|
return this.location.bucket;
|
|
}
|
|
get fullPath() {
|
|
return this.location.path;
|
|
}
|
|
get name() {
|
|
return lastComponent(this.location.path);
|
|
}
|
|
get storage() {
|
|
return this.authWrapper.service();
|
|
}
|
|
/**
|
|
* Uploads a blob to this object's location.
|
|
* @param data The blob to upload.
|
|
* @return An UploadTask that lets you control and
|
|
* observe the upload.
|
|
*/
|
|
put(data, metadata = null) {
|
|
validate('put', [uploadDataSpec(), metadataSpec(true)], arguments);
|
|
this.throwIfRoot_('put');
|
|
return new UploadTask(this, this.authWrapper, this.location, this.mappings(), new FbsBlob(data), metadata);
|
|
}
|
|
/**
|
|
* Uploads a string to this object's location.
|
|
* @param value The string to upload.
|
|
* @param format The format of the string to upload.
|
|
* @return An UploadTask that lets you control and
|
|
* observe the upload.
|
|
*/
|
|
putString(value, format = StringFormat.RAW, metadata) {
|
|
validate('putString', [stringSpec(), stringSpec(formatValidator, true), metadataSpec(true)], arguments);
|
|
this.throwIfRoot_('putString');
|
|
const data = dataFromString(format, value);
|
|
const metadataClone = Object.assign({}, metadata);
|
|
if (!isDef(metadataClone['contentType']) &&
|
|
isDef(data.contentType)) {
|
|
metadataClone['contentType'] = data.contentType;
|
|
}
|
|
return new UploadTask(this, this.authWrapper, this.location, this.mappings(), new FbsBlob(data.data, true), metadataClone);
|
|
}
|
|
/**
|
|
* Deletes the object at this location.
|
|
* @return A promise that resolves if the deletion succeeds.
|
|
*/
|
|
delete() {
|
|
validate('delete', [], arguments);
|
|
this.throwIfRoot_('delete');
|
|
return this.authWrapper.getAuthToken().then(authToken => {
|
|
const requestInfo = deleteObject(this.authWrapper, this.location);
|
|
return this.authWrapper.makeRequest(requestInfo, authToken).getPromise();
|
|
});
|
|
}
|
|
/**
|
|
* 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.
|
|
*
|
|
* @return 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.
|
|
*/
|
|
listAll() {
|
|
validate('listAll', [], arguments);
|
|
const accumulator = {
|
|
prefixes: [],
|
|
items: []
|
|
};
|
|
return this.listAllHelper(accumulator).then(() => accumulator);
|
|
}
|
|
async listAllHelper(accumulator, pageToken) {
|
|
const opt = {
|
|
// maxResults is 1000 by default.
|
|
pageToken
|
|
};
|
|
const nextPage = await this.list(opt);
|
|
accumulator.prefixes.push(...nextPage.prefixes);
|
|
accumulator.items.push(...nextPage.items);
|
|
if (nextPage.nextPageToken != null) {
|
|
await this.listAllHelper(accumulator, nextPage.nextPageToken);
|
|
}
|
|
}
|
|
/**
|
|
* List items (files) and prefixes (folders) under this storage reference.
|
|
*
|
|
* List API is only available for Firebase Rules Version 2.
|
|
*
|
|
* GCS is a key-blob store. Firebase Storage imposes the semantic of '/'
|
|
* delimited folder structure.
|
|
* Refer to GCS's List API if you want to learn more.
|
|
*
|
|
* To adhere to Firebase Rules's Semantics, Firebase Storage does not
|
|
* support objects whose paths end with "/" or contain two consecutive
|
|
* "/"s. Firebase Storage List API will filter these unsupported objects.
|
|
* list() may fail if there are too many unsupported objects in the bucket.
|
|
*
|
|
* @param options See ListOptions for details.
|
|
* @return 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.
|
|
*/
|
|
list(options) {
|
|
validate('list', [listOptionSpec(true)], arguments);
|
|
const self = this;
|
|
return this.authWrapper.getAuthToken().then(authToken => {
|
|
const op = options || {};
|
|
const requestInfo = list(self.authWrapper, self.location,
|
|
/*delimiter= */ '/', op.pageToken, op.maxResults);
|
|
return self.authWrapper.makeRequest(requestInfo, authToken).getPromise();
|
|
});
|
|
}
|
|
/**
|
|
* 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.
|
|
*/
|
|
getMetadata() {
|
|
validate('getMetadata', [], arguments);
|
|
this.throwIfRoot_('getMetadata');
|
|
return this.authWrapper.getAuthToken().then(authToken => {
|
|
const requestInfo = getMetadata(this.authWrapper, this.location, this.mappings());
|
|
return this.authWrapper.makeRequest(requestInfo, authToken).getPromise();
|
|
});
|
|
}
|
|
/**
|
|
* Updates the metadata for this object.
|
|
* @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.
|
|
* @return A promise that resolves
|
|
* with the new metadata for this object.
|
|
* @see firebaseStorage.Reference.prototype.getMetadata
|
|
*/
|
|
updateMetadata(metadata) {
|
|
validate('updateMetadata', [metadataSpec()], arguments);
|
|
this.throwIfRoot_('updateMetadata');
|
|
return this.authWrapper.getAuthToken().then(authToken => {
|
|
const requestInfo = updateMetadata(this.authWrapper, this.location, metadata, this.mappings());
|
|
return this.authWrapper.makeRequest(requestInfo, authToken).getPromise();
|
|
});
|
|
}
|
|
/**
|
|
* @return A promise that resolves with the download
|
|
* URL for this object.
|
|
*/
|
|
getDownloadURL() {
|
|
validate('getDownloadURL', [], arguments);
|
|
this.throwIfRoot_('getDownloadURL');
|
|
return this.authWrapper.getAuthToken().then(authToken => {
|
|
const requestInfo = getDownloadUrl(this.authWrapper, this.location, this.mappings());
|
|
return this.authWrapper
|
|
.makeRequest(requestInfo, authToken)
|
|
.getPromise()
|
|
.then(url => {
|
|
if (url === null) {
|
|
throw noDownloadURL();
|
|
}
|
|
return url;
|
|
});
|
|
});
|
|
}
|
|
throwIfRoot_(name) {
|
|
if (this.location.path === '') {
|
|
throw invalidRootOperation(name);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A request whose promise always fails.
|
|
* @struct
|
|
* @template T
|
|
*/
|
|
class FailRequest {
|
|
constructor(error) {
|
|
this.promise_ = Promise.reject(error);
|
|
}
|
|
/** @inheritDoc */
|
|
getPromise() {
|
|
return this.promise_;
|
|
}
|
|
/** @inheritDoc */
|
|
cancel(_appDelete = false) { }
|
|
}
|
|
|
|
class RequestMap {
|
|
constructor() {
|
|
this.map = new Map();
|
|
this.id = MIN_SAFE_INTEGER;
|
|
}
|
|
/**
|
|
* Registers the given request with this map.
|
|
* The request is unregistered when it completes.
|
|
*
|
|
* @param request The request to register.
|
|
*/
|
|
addRequest(request) {
|
|
const id = this.id;
|
|
this.id++;
|
|
this.map.set(id, request);
|
|
request.getPromise().then(() => this.map.delete(id), () => this.map.delete(id));
|
|
}
|
|
/**
|
|
* Cancels all registered requests.
|
|
*/
|
|
clear() {
|
|
this.map.forEach(v => {
|
|
v && v.cancel(true);
|
|
});
|
|
this.map.clear();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param app If null, getAuthToken always resolves with null.
|
|
* @param service The storage service associated with this auth wrapper.
|
|
* Untyped to avoid circular type dependencies.
|
|
* @struct
|
|
*/
|
|
class AuthWrapper {
|
|
constructor(app, authProvider, maker, requestMaker, service, pool) {
|
|
var _a;
|
|
this.bucket_ = null;
|
|
this.appId_ = null;
|
|
this.deleted_ = false;
|
|
this.app_ = app;
|
|
if (this.app_ !== null) {
|
|
const options = this.app_.options;
|
|
if (isDef(options)) {
|
|
this.bucket_ = AuthWrapper.extractBucket_(options);
|
|
this.appId_ = (_a = options.appId) !== null && _a !== void 0 ? _a : null;
|
|
}
|
|
}
|
|
this.authProvider_ = authProvider;
|
|
this.storageRefMaker_ = maker;
|
|
this.requestMaker_ = requestMaker;
|
|
this.pool_ = pool;
|
|
this.service_ = service;
|
|
this.maxOperationRetryTime_ = DEFAULT_MAX_OPERATION_RETRY_TIME;
|
|
this.maxUploadRetryTime_ = DEFAULT_MAX_UPLOAD_RETRY_TIME;
|
|
this.requestMap_ = new RequestMap();
|
|
}
|
|
static extractBucket_(config) {
|
|
const bucketString = config[CONFIG_STORAGE_BUCKET_KEY] || null;
|
|
if (bucketString == null) {
|
|
return null;
|
|
}
|
|
const loc = Location.makeFromBucketSpec(bucketString);
|
|
return loc.bucket;
|
|
}
|
|
getAuthToken() {
|
|
const auth = this.authProvider_.getImmediate({ optional: true });
|
|
if (auth) {
|
|
return auth.getToken().then((response) => {
|
|
if (response !== null) {
|
|
return response.accessToken;
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}, () => null);
|
|
}
|
|
else {
|
|
return Promise.resolve(null);
|
|
}
|
|
}
|
|
bucket() {
|
|
if (this.deleted_) {
|
|
throw appDeleted();
|
|
}
|
|
else {
|
|
return this.bucket_;
|
|
}
|
|
}
|
|
/**
|
|
* The service associated with this auth wrapper. Untyped to avoid circular
|
|
* type dependencies.
|
|
*/
|
|
service() {
|
|
return this.service_;
|
|
}
|
|
/**
|
|
* Returns a new firebaseStorage.Reference object referencing this AuthWrapper
|
|
* at the given Location.
|
|
* @param loc The Location.
|
|
* @return Actually a firebaseStorage.Reference, typing not allowed
|
|
* because of circular dependency problems.
|
|
*/
|
|
makeStorageReference(loc) {
|
|
return this.storageRefMaker_(this, loc);
|
|
}
|
|
makeRequest(requestInfo, authToken) {
|
|
if (!this.deleted_) {
|
|
const request = this.requestMaker_(requestInfo, this.appId_, authToken, this.pool_);
|
|
this.requestMap_.addRequest(request);
|
|
return request;
|
|
}
|
|
else {
|
|
return new FailRequest(appDeleted());
|
|
}
|
|
}
|
|
/**
|
|
* Stop running requests and prevent more from being created.
|
|
*/
|
|
deleteApp() {
|
|
this.deleted_ = true;
|
|
this.app_ = null;
|
|
this.requestMap_.clear();
|
|
}
|
|
maxUploadRetryTime() {
|
|
return this.maxUploadRetryTime_;
|
|
}
|
|
setMaxUploadRetryTime(time) {
|
|
this.maxUploadRetryTime_ = time;
|
|
}
|
|
maxOperationRetryTime() {
|
|
return this.maxOperationRetryTime_;
|
|
}
|
|
setMaxOperationRetryTime(time) {
|
|
this.maxOperationRetryTime_ = time;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @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 f May be invoked
|
|
* before the function returns.
|
|
* @param callback Get all the arguments passed to the function
|
|
* passed to f, including the initial boolean.
|
|
*/
|
|
function start(f, callback, timeout) {
|
|
// TODO(andysoto): make this code cleaner (probably refactor into an actual
|
|
// type instead of a bunch of functions with state shared in the closure)
|
|
let waitSeconds = 1;
|
|
// Would type this as "number" but that doesn't work for Node so ¯\_(ツ)_/¯
|
|
// TODO: find a way to exclude Node type definition for storage because storage only works in browser
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
let timeoutId = null;
|
|
let hitTimeout = false;
|
|
let cancelState = 0;
|
|
function canceled() {
|
|
return cancelState === 2;
|
|
}
|
|
let triggeredCallback = false;
|
|
// TODO: This disable can be removed and the 'ignoreRestArgs' option added to
|
|
// the no-explicit-any rule when ESlint releases it.
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
function triggerCallback(...args) {
|
|
if (!triggeredCallback) {
|
|
triggeredCallback = true;
|
|
callback.apply(null, args);
|
|
}
|
|
}
|
|
function callWithDelay(millis) {
|
|
timeoutId = setTimeout(() => {
|
|
timeoutId = null;
|
|
f(handler, canceled());
|
|
}, millis);
|
|
}
|
|
// TODO: This disable can be removed and the 'ignoreRestArgs' option added to
|
|
// the no-explicit-any rule when ESlint releases it.
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
function handler(success, ...args) {
|
|
if (triggeredCallback) {
|
|
return;
|
|
}
|
|
if (success) {
|
|
triggerCallback.call(null, success, ...args);
|
|
return;
|
|
}
|
|
const mustStop = canceled() || hitTimeout;
|
|
if (mustStop) {
|
|
triggerCallback.call(null, success, ...args);
|
|
return;
|
|
}
|
|
if (waitSeconds < 64) {
|
|
/* TODO(andysoto): don't back off so quickly if we know we're offline. */
|
|
waitSeconds *= 2;
|
|
}
|
|
let waitMillis;
|
|
if (cancelState === 1) {
|
|
cancelState = 2;
|
|
waitMillis = 0;
|
|
}
|
|
else {
|
|
waitMillis = (waitSeconds + Math.random()) * 1000;
|
|
}
|
|
callWithDelay(waitMillis);
|
|
}
|
|
let stopped = false;
|
|
function stop(wasTimeout) {
|
|
if (stopped) {
|
|
return;
|
|
}
|
|
stopped = true;
|
|
if (triggeredCallback) {
|
|
return;
|
|
}
|
|
if (timeoutId !== null) {
|
|
if (!wasTimeout) {
|
|
cancelState = 2;
|
|
}
|
|
clearTimeout(timeoutId);
|
|
callWithDelay(0);
|
|
}
|
|
else {
|
|
if (!wasTimeout) {
|
|
cancelState = 1;
|
|
}
|
|
}
|
|
}
|
|
callWithDelay(0);
|
|
setTimeout(() => {
|
|
hitTimeout = true;
|
|
stop(true);
|
|
}, timeout);
|
|
return stop;
|
|
}
|
|
/**
|
|
* Stops the retry loop from repeating.
|
|
* If the function is currently "in between" retries, it is invoked immediately
|
|
* with the second parameter as "true". Otherwise, it will be invoked once more
|
|
* after the current invocation finishes iff the current invocation would have
|
|
* triggered another retry.
|
|
*/
|
|
function stop(id) {
|
|
id(false);
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* @struct
|
|
* @template T
|
|
*/
|
|
class NetworkRequest {
|
|
constructor(url, method, headers, body, successCodes, additionalRetryCodes, callback, errorCallback, timeout, progressCallback, pool) {
|
|
this.pendingXhr_ = null;
|
|
this.backoffId_ = null;
|
|
this.resolve_ = null;
|
|
this.reject_ = null;
|
|
this.canceled_ = false;
|
|
this.appDelete_ = false;
|
|
this.url_ = url;
|
|
this.method_ = method;
|
|
this.headers_ = headers;
|
|
this.body_ = body;
|
|
this.successCodes_ = successCodes.slice();
|
|
this.additionalRetryCodes_ = additionalRetryCodes.slice();
|
|
this.callback_ = callback;
|
|
this.errorCallback_ = errorCallback;
|
|
this.progressCallback_ = progressCallback;
|
|
this.timeout_ = timeout;
|
|
this.pool_ = pool;
|
|
this.promise_ = new Promise((resolve, reject) => {
|
|
this.resolve_ = resolve;
|
|
this.reject_ = reject;
|
|
this.start_();
|
|
});
|
|
}
|
|
/**
|
|
* Actually starts the retry loop.
|
|
*/
|
|
start_() {
|
|
const self = this;
|
|
function doTheRequest(backoffCallback, canceled) {
|
|
if (canceled) {
|
|
backoffCallback(false, new RequestEndStatus(false, null, true));
|
|
return;
|
|
}
|
|
const xhr = self.pool_.createXhrIo();
|
|
self.pendingXhr_ = xhr;
|
|
function progressListener(progressEvent) {
|
|
const loaded = progressEvent.loaded;
|
|
const total = progressEvent.lengthComputable ? progressEvent.total : -1;
|
|
if (self.progressCallback_ !== null) {
|
|
self.progressCallback_(loaded, total);
|
|
}
|
|
}
|
|
if (self.progressCallback_ !== null) {
|
|
xhr.addUploadProgressListener(progressListener);
|
|
}
|
|
// eslint-disable-next-line @typescript-eslint/no-floating-promises
|
|
xhr
|
|
.send(self.url_, self.method_, self.body_, self.headers_)
|
|
.then((xhr) => {
|
|
if (self.progressCallback_ !== null) {
|
|
xhr.removeUploadProgressListener(progressListener);
|
|
}
|
|
self.pendingXhr_ = null;
|
|
xhr = xhr;
|
|
const hitServer = xhr.getErrorCode() === ErrorCode.NO_ERROR;
|
|
const status = xhr.getStatus();
|
|
if (!hitServer || self.isRetryStatusCode_(status)) {
|
|
const wasCanceled = xhr.getErrorCode() === ErrorCode.ABORT;
|
|
backoffCallback(false, new RequestEndStatus(false, null, wasCanceled));
|
|
return;
|
|
}
|
|
const successCode = self.successCodes_.indexOf(status) !== -1;
|
|
backoffCallback(true, new RequestEndStatus(successCode, xhr));
|
|
});
|
|
}
|
|
/**
|
|
* @param requestWentThrough True if the request eventually went
|
|
* through, false if it hit the retry limit or was canceled.
|
|
*/
|
|
function backoffDone(requestWentThrough, status) {
|
|
const resolve = self.resolve_;
|
|
const reject = self.reject_;
|
|
const xhr = status.xhr;
|
|
if (status.wasSuccessCode) {
|
|
try {
|
|
const result = self.callback_(xhr, xhr.getResponseText());
|
|
if (isJustDef(result)) {
|
|
resolve(result);
|
|
}
|
|
else {
|
|
resolve();
|
|
}
|
|
}
|
|
catch (e) {
|
|
reject(e);
|
|
}
|
|
}
|
|
else {
|
|
if (xhr !== null) {
|
|
const err = unknown();
|
|
err.setServerResponseProp(xhr.getResponseText());
|
|
if (self.errorCallback_) {
|
|
reject(self.errorCallback_(xhr, err));
|
|
}
|
|
else {
|
|
reject(err);
|
|
}
|
|
}
|
|
else {
|
|
if (status.canceled) {
|
|
const err = self.appDelete_ ? appDeleted() : canceled();
|
|
reject(err);
|
|
}
|
|
else {
|
|
const err = retryLimitExceeded();
|
|
reject(err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (this.canceled_) {
|
|
backoffDone(false, new RequestEndStatus(false, null, true));
|
|
}
|
|
else {
|
|
this.backoffId_ = start(doTheRequest, backoffDone, this.timeout_);
|
|
}
|
|
}
|
|
/** @inheritDoc */
|
|
getPromise() {
|
|
return this.promise_;
|
|
}
|
|
/** @inheritDoc */
|
|
cancel(appDelete) {
|
|
this.canceled_ = true;
|
|
this.appDelete_ = appDelete || false;
|
|
if (this.backoffId_ !== null) {
|
|
stop(this.backoffId_);
|
|
}
|
|
if (this.pendingXhr_ !== null) {
|
|
this.pendingXhr_.abort();
|
|
}
|
|
}
|
|
isRetryStatusCode_(status) {
|
|
// The codes for which to retry came from this page:
|
|
// https://cloud.google.com/storage/docs/exponential-backoff
|
|
const isFiveHundredCode = status >= 500 && status < 600;
|
|
const extraRetryCodes = [
|
|
// Request Timeout: web server didn't receive full request in time.
|
|
408,
|
|
// Too Many Requests: you're getting rate-limited, basically.
|
|
429
|
|
];
|
|
const isExtraRetryCode = extraRetryCodes.indexOf(status) !== -1;
|
|
const isRequestSpecificRetryCode = this.additionalRetryCodes_.indexOf(status) !== -1;
|
|
return isFiveHundredCode || isExtraRetryCode || isRequestSpecificRetryCode;
|
|
}
|
|
}
|
|
/**
|
|
* A collection of information about the result of a network request.
|
|
* @param opt_canceled Defaults to false.
|
|
* @struct
|
|
*/
|
|
class RequestEndStatus {
|
|
constructor(wasSuccessCode, xhr, canceled) {
|
|
this.wasSuccessCode = wasSuccessCode;
|
|
this.xhr = xhr;
|
|
this.canceled = !!canceled;
|
|
}
|
|
}
|
|
function addAuthHeader_(headers, authToken) {
|
|
if (authToken !== null && authToken.length > 0) {
|
|
headers['Authorization'] = 'Firebase ' + authToken;
|
|
}
|
|
}
|
|
function addVersionHeader_(headers) {
|
|
const version = typeof firebase !== 'undefined' ? firebase.SDK_VERSION : 'AppManager';
|
|
headers['X-Firebase-Storage-Version'] = 'webjs/' + version;
|
|
}
|
|
function addGmpidHeader_(headers, appId) {
|
|
if (appId) {
|
|
headers['X-Firebase-GMPID'] = appId;
|
|
}
|
|
}
|
|
/**
|
|
* @template T
|
|
*/
|
|
function makeRequest(requestInfo, appId, authToken, pool) {
|
|
const queryPart = makeQueryString(requestInfo.urlParams);
|
|
const url = requestInfo.url + queryPart;
|
|
const headers = Object.assign({}, requestInfo.headers);
|
|
addGmpidHeader_(headers, appId);
|
|
addAuthHeader_(headers, authToken);
|
|
addVersionHeader_(headers);
|
|
return new NetworkRequest(url, requestInfo.method, headers, requestInfo.body, requestInfo.successCodes, requestInfo.additionalRetryCodes, requestInfo.handler, requestInfo.errorHandler, requestInfo.timeout, requestInfo.progressCallback, pool);
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
/**
|
|
* A service that provides firebaseStorage.Reference instances.
|
|
* @param opt_url gs:// url to a custom Storage Bucket
|
|
*
|
|
* @struct
|
|
*/
|
|
class Service {
|
|
constructor(app, authProvider, pool, url) {
|
|
this.bucket_ = null;
|
|
function maker(authWrapper, loc) {
|
|
return new Reference(authWrapper, loc);
|
|
}
|
|
this.authWrapper_ = new AuthWrapper(app, authProvider, maker, makeRequest, this, pool);
|
|
this.app_ = app;
|
|
if (url != null) {
|
|
this.bucket_ = Location.makeFromBucketSpec(url);
|
|
}
|
|
else {
|
|
const authWrapperBucket = this.authWrapper_.bucket();
|
|
if (authWrapperBucket != null) {
|
|
this.bucket_ = new Location(authWrapperBucket, '');
|
|
}
|
|
}
|
|
this.internals_ = new ServiceInternals(this);
|
|
}
|
|
/**
|
|
* Returns a firebaseStorage.Reference for the given path in the default
|
|
* bucket.
|
|
*/
|
|
ref(path) {
|
|
function validator(path) {
|
|
if (typeof path !== 'string') {
|
|
throw 'Path is not a string.';
|
|
}
|
|
if (/^[A-Za-z]+:\/\//.test(path)) {
|
|
throw 'Expected child path but got a URL, use refFromURL instead.';
|
|
}
|
|
}
|
|
validate('ref', [stringSpec(validator, true)], arguments);
|
|
if (this.bucket_ == null) {
|
|
throw new Error('No Storage Bucket defined in Firebase Options.');
|
|
}
|
|
const ref = new Reference(this.authWrapper_, this.bucket_);
|
|
if (path != null) {
|
|
return ref.child(path);
|
|
}
|
|
else {
|
|
return ref;
|
|
}
|
|
}
|
|
/**
|
|
* Returns a firebaseStorage.Reference object for the given absolute URL,
|
|
* which must be a gs:// or http[s]:// URL.
|
|
*/
|
|
refFromURL(url) {
|
|
function validator(p) {
|
|
if (typeof p !== 'string') {
|
|
throw 'Path is not a string.';
|
|
}
|
|
if (!/^[A-Za-z]+:\/\//.test(p)) {
|
|
throw 'Expected full URL but got a child path, use ref instead.';
|
|
}
|
|
try {
|
|
Location.makeFromUrl(p);
|
|
}
|
|
catch (e) {
|
|
throw 'Expected valid full URL but got an invalid one.';
|
|
}
|
|
}
|
|
validate('refFromURL', [stringSpec(validator, false)], arguments);
|
|
return new Reference(this.authWrapper_, url);
|
|
}
|
|
get maxUploadRetryTime() {
|
|
return this.authWrapper_.maxUploadRetryTime();
|
|
}
|
|
setMaxUploadRetryTime(time) {
|
|
validate('setMaxUploadRetryTime', [nonNegativeNumberSpec()], arguments);
|
|
this.authWrapper_.setMaxUploadRetryTime(time);
|
|
}
|
|
setMaxOperationRetryTime(time) {
|
|
validate('setMaxOperationRetryTime', [nonNegativeNumberSpec()], arguments);
|
|
this.authWrapper_.setMaxOperationRetryTime(time);
|
|
}
|
|
get app() {
|
|
return this.app_;
|
|
}
|
|
get INTERNAL() {
|
|
return this.internals_;
|
|
}
|
|
}
|
|
/**
|
|
* @struct
|
|
*/
|
|
class ServiceInternals {
|
|
constructor(service) {
|
|
this.service_ = service;
|
|
}
|
|
/**
|
|
* Called when the associated app is deleted.
|
|
* @see {!fbs.AuthWrapper.prototype.deleteApp}
|
|
*/
|
|
delete() {
|
|
this.service_.authWrapper_.deleteApp();
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
|
|
const name = "@firebase/storage";
|
|
const version = "0.3.34";
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
/**
|
|
* Type constant for Firebase Storage.
|
|
*/
|
|
const STORAGE_TYPE = 'storage';
|
|
function factory(container, url) {
|
|
// Dependencies
|
|
const app = container.getProvider('app').getImmediate();
|
|
const authProvider = container.getProvider('auth-internal');
|
|
return new Service(app, authProvider, new XhrIoPool(), url);
|
|
}
|
|
function registerStorage(instance) {
|
|
const namespaceExports = {
|
|
// no-inline
|
|
TaskState,
|
|
TaskEvent,
|
|
StringFormat,
|
|
Storage: Service,
|
|
Reference
|
|
};
|
|
instance.INTERNAL.registerComponent(new Component(STORAGE_TYPE, factory, "PUBLIC" /* PUBLIC */)
|
|
.setServiceProps(namespaceExports)
|
|
.setMultipleInstances(true));
|
|
instance.registerVersion(name, version);
|
|
}
|
|
registerStorage(firebase);
|
|
|
|
export { registerStorage };
|
|
//# sourceMappingURL=index.esm2017.js.map
|