import firebase from '@firebase/app'; import { Component } from '@firebase/component'; /** * @license * Copyright 2017 Google Inc. * * 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 Inc. * * 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 noDefaultBucket() { return new FirebaseStorageError(Code.NO_DEFAULT_BUCKET, 'No default bucket ' + "found. Did you set the '" + CONFIG_STORAGE_BUCKET_KEY + "' property when initializing the app?"); } 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 Inc. * * 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:[][;base64],"); } const middle = matches[1] || null; if (middle != null) { this.base64 = endsWith(middle, ';base64'); this.contentType = this.base64 ? middle.substring(0, middle.length - ';base64'.length) : middle; } this.rest = dataURL.substring(dataURL.indexOf(',') + 1); } } function dataURLBytes_(dataUrl) { const parts = new DataURLParts(dataUrl); if (parts.base64) { return base64Bytes_(StringFormat.BASE64, parts.rest); } else { return percentEncodedBytes_(parts.rest); } } function dataURLContentType_(dataUrl) { const parts = new DataURLParts(dataUrl); return parts.contentType; } function endsWith(s, end) { const longEnough = s.length >= end.length; if (!longEnough) { return false; } return s.substring(s.length - end.length) === end; } /** * @license * Copyright 2017 Google Inc. * * 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 Inc. * * 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 Inc. * * 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 Inc. * * 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 Inc. * * 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 Inc. * * 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 Inc. * * 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 Inc. * * 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 path = '(/([^?#]*).*)?$'; 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 hostRegex = DEFAULT_HOST.replace(/[.]/g, '\\.'); const httpRegex = new RegExp(`^https?://${hostRegex}/${version}/b/${bucketDomain}/o${path}`, 'i'); const httpIndices = { bucket: 1, path: 3 }; const groups = [ { regex: gsRegex, indices: gsIndices, postModify: gsModify }, { regex: httpRegex, indices: httpIndices, 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 Inc. * * 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 Inc. * * 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 Inc. * * 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 Inc. * * 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 Inc. * * 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, resource) { const listResult = { prefixes: [], items: [], nextPageToken: resource['nextPageToken'] }; const bucket = authWrapper.bucket(); if (bucket === null) { throw noDefaultBucket(); } 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, resourceString) { const obj = jsonObjectOrNull(resourceString); if (obj === null) { return null; } const resource = obj; return fromBackendResponse(authWrapper, 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 Inc. * * 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) { function handler(xhr, text) { const listResult = fromResponseString(authWrapper, 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), 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 Inc. * * 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 Inc. * * 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 Inc. * * 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 Inc. * * 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 Inc. * * 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:/// * http[s]://firebasestorage.googleapis.com/ * /b//o/ * Any query or fragment strings will be ignored in the http[s] * format. If no value is passed, the storage object will use a URL based on * the project ID of the base firebase.App instance. */ class Reference { constructor(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:/// * @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) { this.bucket_ = 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.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, 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 Inc. * * 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 Inc. * * 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; } /** * @template T */ function makeRequest(requestInfo, authToken, pool) { const queryPart = makeQueryString(requestInfo.urlParams); const url = requestInfo.url + queryPart; const headers = Object.assign({}, requestInfo.headers); 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 Inc. * * 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.25"; /** * @license * Copyright 2017 Google Inc. * * 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