summaryrefslogtreecommitdiff
path: root/frontend-old/node_modules/@firebase/storage-compat/dist/index.cjs.js
diff options
context:
space:
mode:
Diffstat (limited to 'frontend-old/node_modules/@firebase/storage-compat/dist/index.cjs.js')
-rw-r--r--frontend-old/node_modules/@firebase/storage-compat/dist/index.cjs.js406
1 files changed, 406 insertions, 0 deletions
diff --git a/frontend-old/node_modules/@firebase/storage-compat/dist/index.cjs.js b/frontend-old/node_modules/@firebase/storage-compat/dist/index.cjs.js
new file mode 100644
index 0000000..c89691e
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/storage-compat/dist/index.cjs.js
@@ -0,0 +1,406 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var firebase = require('@firebase/app-compat');
+var storage = require('@firebase/storage');
+var component = require('@firebase/component');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var firebase__default = /*#__PURE__*/_interopDefaultLegacy(firebase);
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class UploadTaskSnapshotCompat {
+ constructor(_delegate, task, ref) {
+ this._delegate = _delegate;
+ this.task = task;
+ this.ref = ref;
+ }
+ get bytesTransferred() {
+ return this._delegate.bytesTransferred;
+ }
+ get metadata() {
+ return this._delegate.metadata;
+ }
+ get state() {
+ return this._delegate.state;
+ }
+ get totalBytes() {
+ return this._delegate.totalBytes;
+ }
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class UploadTaskCompat {
+ constructor(_delegate, _ref) {
+ this._delegate = _delegate;
+ this._ref = _ref;
+ this.cancel = this._delegate.cancel.bind(this._delegate);
+ this.catch = this._delegate.catch.bind(this._delegate);
+ this.pause = this._delegate.pause.bind(this._delegate);
+ this.resume = this._delegate.resume.bind(this._delegate);
+ }
+ get snapshot() {
+ return new UploadTaskSnapshotCompat(this._delegate.snapshot, this, this._ref);
+ }
+ then(onFulfilled, onRejected) {
+ return this._delegate.then(snapshot => {
+ if (onFulfilled) {
+ return onFulfilled(new UploadTaskSnapshotCompat(snapshot, this, this._ref));
+ }
+ }, onRejected);
+ }
+ on(type, nextOrObserver, error, completed) {
+ let wrappedNextOrObserver = undefined;
+ if (!!nextOrObserver) {
+ if (typeof nextOrObserver === 'function') {
+ wrappedNextOrObserver = (taskSnapshot) => nextOrObserver(new UploadTaskSnapshotCompat(taskSnapshot, this, this._ref));
+ }
+ else {
+ wrappedNextOrObserver = {
+ next: !!nextOrObserver.next
+ ? (taskSnapshot) => nextOrObserver.next(new UploadTaskSnapshotCompat(taskSnapshot, this, this._ref))
+ : undefined,
+ complete: nextOrObserver.complete || undefined,
+ error: nextOrObserver.error || undefined
+ };
+ }
+ }
+ return this._delegate.on(type, wrappedNextOrObserver, error || undefined, completed || undefined);
+ }
+}
+
+class ListResultCompat {
+ constructor(_delegate, _service) {
+ this._delegate = _delegate;
+ this._service = _service;
+ }
+ get prefixes() {
+ return this._delegate.prefixes.map(ref => new ReferenceCompat(ref, this._service));
+ }
+ get items() {
+ return this._delegate.items.map(ref => new ReferenceCompat(ref, this._service));
+ }
+ get nextPageToken() {
+ return this._delegate.nextPageToken || null;
+ }
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ReferenceCompat {
+ constructor(_delegate, storage) {
+ this._delegate = _delegate;
+ this.storage = storage;
+ }
+ get name() {
+ return this._delegate.name;
+ }
+ get bucket() {
+ return this._delegate.bucket;
+ }
+ get fullPath() {
+ return this._delegate.fullPath;
+ }
+ toString() {
+ return this._delegate.toString();
+ }
+ /**
+ * @returns A reference to the object obtained by
+ * appending childPath, removing any duplicate, beginning, or trailing
+ * slashes.
+ */
+ child(childPath) {
+ const reference = storage._getChild(this._delegate, childPath);
+ return new ReferenceCompat(reference, this.storage);
+ }
+ get root() {
+ return new ReferenceCompat(this._delegate.root, this.storage);
+ }
+ /**
+ * @returns A reference to the parent of the
+ * current object, or null if the current object is the root.
+ */
+ get parent() {
+ const reference = this._delegate.parent;
+ if (reference == null) {
+ return null;
+ }
+ return new ReferenceCompat(reference, this.storage);
+ }
+ /**
+ * Uploads a blob to this object's location.
+ * @param data - The blob to upload.
+ * @returns An UploadTask that lets you control and
+ * observe the upload.
+ */
+ put(data, metadata) {
+ this._throwIfRoot('put');
+ return new UploadTaskCompat(storage.uploadBytesResumable(this._delegate, data, metadata), this);
+ }
+ /**
+ * Uploads a string to this object's location.
+ * @param value - The string to upload.
+ * @param format - The format of the string to upload.
+ * @returns An UploadTask that lets you control and
+ * observe the upload.
+ */
+ putString(value, format = storage.StringFormat.RAW, metadata) {
+ this._throwIfRoot('putString');
+ const data = storage._dataFromString(format, value);
+ const metadataClone = { ...metadata };
+ if (metadataClone['contentType'] == null && data.contentType != null) {
+ metadataClone['contentType'] = data.contentType;
+ }
+ return new UploadTaskCompat(new storage._UploadTask(this._delegate, new storage._FbsBlob(data.data, true), metadataClone), this);
+ }
+ /**
+ * 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.
+ *
+ * @returns A Promise that resolves with all the items and prefixes under
+ * the current storage reference. `prefixes` contains references to
+ * sub-directories and `items` contains references to objects in this
+ * folder. `nextPageToken` is never returned.
+ */
+ listAll() {
+ return storage.listAll(this._delegate).then(r => new ListResultCompat(r, this.storage));
+ }
+ /**
+ * 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.
+ * @returns A Promise that resolves with the items and prefixes.
+ * `prefixes` contains references to sub-folders and `items`
+ * contains references to objects in this folder. `nextPageToken`
+ * can be used to get the rest of the results.
+ */
+ list(options) {
+ return storage.list(this._delegate, options || undefined).then(r => new ListResultCompat(r, this.storage));
+ }
+ /**
+ * A `Promise` that resolves with the metadata for this object. If this
+ * object doesn't exist or metadata cannot be retrieved, the promise is
+ * rejected.
+ */
+ getMetadata() {
+ return storage.getMetadata(this._delegate);
+ }
+ /**
+ * 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.
+ * @returns A `Promise` that resolves
+ * with the new metadata for this object.
+ * @see firebaseStorage.Reference.prototype.getMetadata
+ */
+ updateMetadata(metadata) {
+ return storage.updateMetadata(this._delegate, metadata);
+ }
+ /**
+ * @returns A `Promise` that resolves with the download
+ * URL for this object.
+ */
+ getDownloadURL() {
+ return storage.getDownloadURL(this._delegate);
+ }
+ /**
+ * Deletes the object at this location.
+ * @returns A `Promise` that resolves if the deletion succeeds.
+ */
+ delete() {
+ this._throwIfRoot('delete');
+ return storage.deleteObject(this._delegate);
+ }
+ _throwIfRoot(name) {
+ if (this._delegate._location.path === '') {
+ throw storage._invalidRootOperation(name);
+ }
+ }
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A service that provides firebaseStorage.Reference instances.
+ * @param opt_url gs:// url to a custom Storage Bucket
+ */
+class StorageServiceCompat {
+ constructor(app, _delegate) {
+ this.app = app;
+ this._delegate = _delegate;
+ }
+ get maxOperationRetryTime() {
+ return this._delegate.maxOperationRetryTime;
+ }
+ get maxUploadRetryTime() {
+ return this._delegate.maxUploadRetryTime;
+ }
+ /**
+ * Returns a firebaseStorage.Reference for the given path in the default
+ * bucket.
+ */
+ ref(path) {
+ if (isUrl(path)) {
+ throw storage._invalidArgument('ref() expected a child path but got a URL, use refFromURL instead.');
+ }
+ return new ReferenceCompat(storage.ref(this._delegate, path), this);
+ }
+ /**
+ * Returns a firebaseStorage.Reference object for the given absolute URL,
+ * which must be a gs:// or http[s]:// URL.
+ */
+ refFromURL(url) {
+ if (!isUrl(url)) {
+ throw storage._invalidArgument('refFromURL() expected a full URL but got a child path, use ref() instead.');
+ }
+ try {
+ storage._Location.makeFromUrl(url, this._delegate.host);
+ }
+ catch (e) {
+ throw storage._invalidArgument('refFromUrl() expected a valid full URL but got an invalid one.');
+ }
+ return new ReferenceCompat(storage.ref(this._delegate, url), this);
+ }
+ setMaxUploadRetryTime(time) {
+ this._delegate.maxUploadRetryTime = time;
+ }
+ setMaxOperationRetryTime(time) {
+ this._delegate.maxOperationRetryTime = time;
+ }
+ useEmulator(host, port, options = {}) {
+ storage.connectStorageEmulator(this._delegate, host, port, options);
+ }
+}
+function isUrl(path) {
+ return /^[A-Za-z]+:\/\//.test(path);
+}
+
+const name = "@firebase/storage-compat";
+const version = "0.4.0";
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Type constant for Firebase Storage.
+ */
+const STORAGE_TYPE = 'storage-compat';
+function factory(container, { instanceIdentifier: url }) {
+ // Dependencies
+ const app = container.getProvider('app-compat').getImmediate();
+ const storageExp = container
+ .getProvider('storage')
+ .getImmediate({ identifier: url });
+ const storageServiceCompat = new StorageServiceCompat(app, storageExp);
+ return storageServiceCompat;
+}
+function registerStorage(instance) {
+ const namespaceExports = {
+ // no-inline
+ TaskState: storage._TaskState,
+ TaskEvent: storage._TaskEvent,
+ StringFormat: storage.StringFormat,
+ Storage: StorageServiceCompat,
+ Reference: ReferenceCompat
+ };
+ instance.INTERNAL.registerComponent(new component.Component(STORAGE_TYPE, factory, "PUBLIC" /* ComponentType.PUBLIC */)
+ .setServiceProps(namespaceExports)
+ .setMultipleInstances(true));
+ instance.registerVersion(name, version);
+}
+registerStorage(firebase__default["default"]);
+
+exports.registerStorage = registerStorage;
+//# sourceMappingURL=index.cjs.js.map