batuhan-basoglu/Kargi-Sitesi
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Deployed the page to Github Pages.

Browse source
This commit is contained in:
Batuhan Berk Başoğlu 2024-11-03 21:30:09 -05:00
parent 1d79754e93
commit 2c89899458
Signed by: batuhan-basoglu
SSH key fingerprint: SHA256:kEsnuHX+qbwhxSAXPUQ4ox535wFHu/hIRaa53FzxRpo
62797 changed files with 6551425 additions and 15279 deletions
Download patch file Download diff file Expand all files Collapse all files

3666
node_modules/@firebase/storage/dist/node-esm/index.node.esm.js generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

1
node_modules/@firebase/storage/dist/node-esm/index.node.esm.js.map generated vendored Normal file
View file

File diff suppressed because one or more lines are too long

1
node_modules/@firebase/storage/dist/node-esm/package.json generated vendored Normal file
View file

@ -0,0 +1 @@
{"type":"module"}

47
node_modules/@firebase/storage/dist/node-esm/src/api.browser.d.ts generated vendored Normal file
View file

@ -0,0 +1,47 @@
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { StorageReference } from './public-types';
/**
* Downloads the data at the object's location. Returns an error if the object
* is not found.
*
* To use this functionality, you have to whitelist your app's origin in your
* Cloud Storage bucket. See also
* https://cloud.google.com/storage/docs/configuring-cors
*
* This API is not available in Node.
*
* @public
* @param ref - StorageReference where data should be downloaded.
* @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to
* retrieve.
* @returns A Promise that resolves with a Blob containing the object's bytes
*/
export declare function getBlob(ref: StorageReference, maxDownloadSizeBytes?: number): Promise<Blob>;
/**
* Downloads the data at the object's location. Raises an error event if the
* object is not found.
*
* This API is only available in Node.
*
* @public
* @param ref - StorageReference where data should be downloaded.
* @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to
* retrieve.
* @returns A stream with the object's data as bytes
*/
export declare function getStream(ref: StorageReference, maxDownloadSizeBytes?: number): ReadableStream;

200
node_modules/@firebase/storage/dist/node-esm/src/api.d.ts generated vendored Normal file
View file

@ -0,0 +1,200 @@
/**
* @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.
*/
import { FirebaseApp } from '@firebase/app';
import { StorageReference, FirebaseStorage, UploadResult, ListOptions, ListResult, UploadTask, SettableMetadata, UploadMetadata, FullMetadata } from './public-types';
import { Reference } from './reference';
import { EmulatorMockTokenOptions } from '@firebase/util';
import { StringFormat } from './implementation/string';
export { EmulatorMockTokenOptions } from '@firebase/util';
export { StorageError, StorageErrorCode } from './implementation/error';
/**
* Public types.
*/
export * from './public-types';
export { Location as _Location } from './implementation/location';
export { UploadTask as _UploadTask } from './task';
export type { Reference as _Reference } from './reference';
export type { FirebaseStorageImpl as _FirebaseStorageImpl } from './service';
export { FbsBlob as _FbsBlob } from './implementation/blob';
export { dataFromString as _dataFromString } from './implementation/string';
export { invalidRootOperation as _invalidRootOperation, invalidArgument as _invalidArgument } from './implementation/error';
export { TaskEvent as _TaskEvent, TaskState as _TaskState } from './implementation/taskenums';
export { StringFormat };
/**
* Downloads the data at the object's location. Returns an error if the object
* is not found.
*
* To use this functionality, you have to whitelist your app's origin in your
* Cloud Storage bucket. See also
* https://cloud.google.com/storage/docs/configuring-cors
*
* @public
* @param ref - StorageReference where data should be downloaded.
* @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to
* retrieve.
* @returns A Promise containing the object's bytes
*/
export declare function getBytes(ref: StorageReference, maxDownloadSizeBytes?: number): Promise<ArrayBuffer>;
/**
* Uploads data to this object's location.
* The upload is not resumable.
* @public
* @param ref - {@link StorageReference} where data should be uploaded.
* @param data - The data to upload.
* @param metadata - Metadata for the data to upload.
* @returns A Promise containing an UploadResult
*/
export declare function uploadBytes(ref: StorageReference, data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata): Promise<UploadResult>;
/**
* Uploads a string to this object's location.
* The upload is not resumable.
* @public
* @param ref - {@link StorageReference} where string should be uploaded.
* @param value - The string to upload.
* @param format - The format of the string to upload.
* @param metadata - Metadata for the string to upload.
* @returns A Promise containing an UploadResult
*/
export declare function uploadString(ref: StorageReference, value: string, format?: StringFormat, metadata?: UploadMetadata): Promise<UploadResult>;
/**
* Uploads data to this object's location.
* The upload can be paused and resumed, and exposes progress updates.
* @public
* @param ref - {@link StorageReference} where data should be uploaded.
* @param data - The data to upload.
* @param metadata - Metadata for the data to upload.
* @returns An UploadTask
*/
export declare function uploadBytesResumable(ref: StorageReference, data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata): UploadTask;
/**
* A `Promise` that resolves with the metadata for this object. If this
* object doesn't exist or metadata cannot be retrieved, the promise is
* rejected.
* @public
* @param ref - {@link StorageReference} to get metadata from.
*/
export declare function getMetadata(ref: StorageReference): Promise<FullMetadata>;
/**
* Updates the metadata for this object.
* @public
* @param ref - {@link StorageReference} to update metadata for.
* @param metadata - The new metadata for the object.
* Only values that have been explicitly set will be changed. Explicitly
* setting a value to null will remove the metadata.
* @returns A `Promise` that resolves with the new metadata for this object.
*/
export declare function updateMetadata(ref: StorageReference, metadata: SettableMetadata): Promise<FullMetadata>;
/**
* List items (files) and prefixes (folders) under this storage reference.
*
* List API is only available for Firebase Rules Version 2.
*
* GCS is a key-blob store. Firebase Storage imposes the semantic of '/'
* delimited folder structure.
* Refer to GCS's List API if you want to learn more.
*
* To adhere to Firebase Rules's Semantics, Firebase Storage does not
* support objects whose paths end with "/" or contain two consecutive
* "/"s. Firebase Storage List API will filter these unsupported objects.
* list() may fail if there are too many unsupported objects in the bucket.
* @public
*
* @param ref - {@link StorageReference} to get list from.
* @param options - See {@link ListOptions} for details.
* @returns A `Promise` that resolves with the items and prefixes.
* `prefixes` contains references to sub-folders and `items`
* contains references to objects in this folder. `nextPageToken`
* can be used to get the rest of the results.
*/
export declare function list(ref: StorageReference, options?: ListOptions): Promise<ListResult>;
/**
* List all items (files) and prefixes (folders) under this storage reference.
*
* This is a helper method for calling list() repeatedly until there are
* no more results. The default pagination size is 1000.
*
* Note: The results may not be consistent if objects are changed while this
* operation is running.
*
* Warning: `listAll` may potentially consume too many resources if there are
* too many results.
* @public
* @param ref - {@link StorageReference} to get list from.
*
* @returns A `Promise` that resolves with all the items and prefixes under
* the current storage reference. `prefixes` contains references to
* sub-directories and `items` contains references to objects in this
* folder. `nextPageToken` is never returned.
*/
export declare function listAll(ref: StorageReference): Promise<ListResult>;
/**
* Returns the download URL for the given {@link StorageReference}.
* @public
* @param ref - {@link StorageReference} to get the download URL for.
* @returns A `Promise` that resolves with the download
* URL for this object.
*/
export declare function getDownloadURL(ref: StorageReference): Promise<string>;
/**
* Deletes the object at this location.
* @public
* @param ref - {@link StorageReference} for object to delete.
* @returns A `Promise` that resolves if the deletion succeeds.
*/
export declare function deleteObject(ref: StorageReference): Promise<void>;
/**
* Returns a {@link StorageReference} for the given url.
* @param storage - {@link FirebaseStorage} instance.
* @param url - URL. If empty, returns root reference.
* @public
*/
export declare function ref(storage: FirebaseStorage, url?: string): StorageReference;
/**
* Returns a {@link StorageReference} for the given path in the
* default bucket.
* @param storageOrRef - {@link FirebaseStorage} or {@link StorageReference}.
* @param pathOrUrlStorage - path. If empty, returns root reference (if {@link FirebaseStorage}
* instance provided) or returns same reference (if {@link StorageReference} provided).
* @public
*/
export declare function ref(storageOrRef: FirebaseStorage | StorageReference, path?: string): StorageReference;
/**
* @internal
*/
export declare function _getChild(ref: StorageReference, childPath: string): Reference;
/**
* Gets a {@link FirebaseStorage} instance for the given Firebase app.
* @public
* @param app - Firebase app to get {@link FirebaseStorage} instance for.
* @param bucketUrl - The gs:// url to your Firebase Storage Bucket.
* If not passed, uses the app's default Storage Bucket.
* @returns A {@link FirebaseStorage} instance.
*/
export declare function getStorage(app?: FirebaseApp, bucketUrl?: string): FirebaseStorage;
/**
* Modify this {@link FirebaseStorage} instance to communicate with the Cloud Storage emulator.
*
* @param storage - The {@link FirebaseStorage} instance
* @param host - The emulator host (ex: localhost)
* @param port - The emulator port (ex: 5001)
* @param options - Emulator options. `options.mockUserToken` is the mock auth
* token to use for unit testing Security Rules.
* @public
*/
export declare function connectStorageEmulator(storage: FirebaseStorage, host: string, port: number, options?: {
mockUserToken?: EmulatorMockTokenOptions | string;
}): void;

47
node_modules/@firebase/storage/dist/node-esm/src/api.node.d.ts generated vendored Normal file
View file

@ -0,0 +1,47 @@
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { StorageReference } from './public-types';
/**
* Downloads the data at the object's location. Returns an error if the object
* is not found.
*
* To use this functionality, you have to whitelist your app's origin in your
* Cloud Storage bucket. See also
* https://cloud.google.com/storage/docs/configuring-cors
*
* This API is not available in Node.
*
* @public
* @param ref - StorageReference where data should be downloaded.
* @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to
* retrieve.
* @returns A Promise that resolves with a Blob containing the object's bytes
*/
export declare function getBlob(ref: StorageReference, maxDownloadSizeBytes?: number): Promise<Blob>;
/**
* Downloads the data at the object's location. Raises an error event if the
* object is not found.
*
* This API is only available in Node.
*
* @public
* @param ref - StorageReference where data should be downloaded.
* @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to
* retrieve.
* @returns A stream with the object's data as bytes
*/
export declare function getStream(ref: StorageReference, maxDownloadSizeBytes?: number): ReadableStream;

20
node_modules/@firebase/storage/dist/node-esm/src/constants.d.ts generated vendored Normal file
View file

@ -0,0 +1,20 @@
/**
* @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.
*/
export declare const STORAGE_TYPE = "storage";

22
node_modules/@firebase/storage/dist/node-esm/src/implementation/async.d.ts generated vendored Normal file
View file

@ -0,0 +1,22 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Returns a function that invokes f with its arguments asynchronously as a
* microtask, i.e. as soon as possible after the current script returns back
* into browser code.
*/
export declare function async(f: Function): Function;

43
node_modules/@firebase/storage/dist/node-esm/src/implementation/backoff.d.ts generated vendored Normal file
View file

@ -0,0 +1,43 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Provides a method for running a function with exponential
* backoff.
*/
declare type id = (p1: boolean) => void;
export { id };
/**
* Accepts a callback for an action to perform (`doRequest`),
* and then a callback for when the backoff has completed (`backoffCompleteCb`).
* The callback sent to start requires an argument to call (`onRequestComplete`).
* When `start` calls `doRequest`, it passes a callback for when the request has
* completed, `onRequestComplete`. Based on this, the backoff continues, with
* another call to `doRequest` and the above loop continues until the timeout
* is hit, or a successful response occurs.
* @description
* @param doRequest Callback to perform request
* @param backoffCompleteCb Callback to call when backoff has been completed
*/
export declare function start(doRequest: (onRequestComplete: (success: boolean) => void, canceled: boolean) => void, backoffCompleteCb: (...args: any[]) => unknown, timeout: number): id;
/**
* 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.
*/
export declare function stop(id: id): void;

34
node_modules/@firebase/storage/dist/node-esm/src/implementation/blob.d.ts generated vendored Normal file
View file

@ -0,0 +1,34 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @param opt_elideCopy - If true, doesn't copy mutable input data
* (e.g. Uint8Arrays). Pass true only if you know the objects will not be
* modified after this blob's construction.
*
* @internal
*/
export declare class FbsBlob {
private data_;
private size_;
private type_;
constructor(data: Blob | Uint8Array | ArrayBuffer, elideCopy?: boolean);
size(): number;
type(): string;
slice(startByte: number, endByte: number): FbsBlob | null;
static getBlob(...args: Array<string | FbsBlob>): FbsBlob | null;
uploadData(): Blob | Uint8Array;
}

56
node_modules/@firebase/storage/dist/node-esm/src/implementation/connection.d.ts generated vendored Normal file
View file

@ -0,0 +1,56 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/** Network headers */
export declare type Headers = Record<string, string>;
/** Response type exposed by the networking APIs. */
export declare type ConnectionType = string | ArrayBuffer | Blob | ReadableStream<Uint8Array>;
/**
* A lightweight wrapper around XMLHttpRequest with a
* goog.net.XhrIo-like interface.
*
* You can create a new connection by invoking `newTextConnection()`,
* `newBytesConnection()` or `newStreamConnection()`.
*/
export interface Connection<T extends ConnectionType> {
/**
* Sends a request to the provided URL.
*
* This method never rejects its promise. In case of encountering an error,
* it sets an error code internally which can be accessed by calling
* getErrorCode() by callers.
*/
send(url: string, method: string, body?: ArrayBufferView | Blob | string | null, headers?: Headers): Promise<void>;
getErrorCode(): ErrorCode;
getStatus(): number;
getResponse(): T;
getErrorText(): string;
/**
* Abort the request.
*/
abort(): void;
getResponseHeader(header: string): string | null;
addUploadProgressListener(listener: (p1: ProgressEvent) => void): void;
removeUploadProgressListener(listener: (p1: ProgressEvent) => void): void;
}
/**
* Error codes for requests made by the XhrIo wrapper.
*/
export declare enum ErrorCode {
NO_ERROR = 0,
NETWORK_ERROR = 1,
ABORT = 2
}

48
node_modules/@firebase/storage/dist/node-esm/src/implementation/constants.d.ts generated vendored Normal file
View file

@ -0,0 +1,48 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Constants used in the Firebase Storage library.
*/
/**
* Domain name for firebase storage.
*/
export declare const DEFAULT_HOST = "firebasestorage.googleapis.com";
/**
* The key in Firebase config json for the storage bucket.
*/
export declare const CONFIG_STORAGE_BUCKET_KEY = "storageBucket";
/**
* 2 minutes
*
* The timeout for all operations except upload.
*/
export declare const DEFAULT_MAX_OPERATION_RETRY_TIME: number;
/**
* 10 minutes
*
* The timeout for upload.
*/
export declare const DEFAULT_MAX_UPLOAD_RETRY_TIME: number;
/**
* 1 second
*/
export declare const DEFAULT_MIN_SLEEP_TIME_MILLIS = 1000;
/**
* This is the value of Number.MIN_SAFE_INTEGER, which is not well supported
* enough for us to use it directly.
*/
export declare const MIN_SAFE_INTEGER = -9007199254740991;

126
node_modules/@firebase/storage/dist/node-esm/src/implementation/error.d.ts generated vendored Normal file
View file

@ -0,0 +1,126 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { FirebaseError } from '@firebase/util';
/**
* An error returned by the Firebase Storage SDK.
* @public
*/
export declare class StorageError extends FirebaseError {
private status_;
private readonly _baseMessage;
/**
* Stores custom error data unique to the `StorageError`.
*/
customData: {
serverResponse: string | null;
};
/**
* @param code - A `StorageErrorCode` string to be prefixed with 'storage/' and
* added to the end of the message.
* @param message - Error message.
* @param status_ - Corresponding HTTP Status Code
*/
constructor(code: StorageErrorCode, message: string, status_?: number);
get status(): number;
set status(status: number);
/**
* Compares a `StorageErrorCode` against this error's code, filtering out the prefix.
*/
_codeEquals(code: StorageErrorCode): boolean;
/**
* Optional response message that was added by the server.
*/
get serverResponse(): null | string;
set serverResponse(serverResponse: string | null);
}
export declare const errors: {};
/**
* @public
* Error codes that can be attached to `StorageError` objects.
*/
export declare enum StorageErrorCode {
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",
UNAUTHORIZED_APP = "unauthorized-app",
RETRY_LIMIT_EXCEEDED = "retry-limit-exceeded",
INVALID_CHECKSUM = "invalid-checksum",
CANCELED = "canceled",
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",
UNSUPPORTED_ENVIRONMENT = "unsupported-environment"
}
export declare function prependCode(code: StorageErrorCode): string;
export declare function unknown(): StorageError;
export declare function objectNotFound(path: string): StorageError;
export declare function bucketNotFound(bucket: string): StorageError;
export declare function projectNotFound(project: string): StorageError;
export declare function quotaExceeded(bucket: string): StorageError;
export declare function unauthenticated(): StorageError;
export declare function unauthorizedApp(): StorageError;
export declare function unauthorized(path: string): StorageError;
export declare function retryLimitExceeded(): StorageError;
export declare function invalidChecksum(path: string, checksum: string, calculated: string): StorageError;
export declare function canceled(): StorageError;
export declare function invalidEventName(name: string): StorageError;
export declare function invalidUrl(url: string): StorageError;
export declare function invalidDefaultBucket(bucket: string): StorageError;
export declare function noDefaultBucket(): StorageError;
export declare function cannotSliceBlob(): StorageError;
export declare function serverFileWrongSize(): StorageError;
export declare function noDownloadURL(): StorageError;
export declare function missingPolyFill(polyFill: string): StorageError;
/**
* @internal
*/
export declare function invalidArgument(message: string): StorageError;
export declare function invalidArgumentCount(argMin: number, argMax: number, fnName: string, real: number): StorageError;
export declare function appDeleted(): StorageError;
/**
* @param name - The name of the operation that was invalid.
*
* @internal
*/
export declare function invalidRootOperation(name: string): StorageError;
/**
* @param format - The format that was not valid.
* @param message - A message describing the format violation.
*/
export declare function invalidFormat(format: string, message: string): StorageError;
/**
* @param message - A message describing the internal error.
*/
export declare function unsupportedEnvironment(message: string): StorageError;
/**
* @param message - A message describing the internal error.
*/
export declare function internalError(message: string): StorageError;

29
node_modules/@firebase/storage/dist/node-esm/src/implementation/failrequest.d.ts generated vendored Normal file
View file

@ -0,0 +1,29 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { StorageError } from './error';
import { Request } from './request';
/**
* A request whose promise always fails.
*/
export declare class FailRequest<T> implements Request<T> {
promise_: Promise<T>;
constructor(error: StorageError);
/** @inheritDoc */
getPromise(): Promise<T>;
/** @inheritDoc */
cancel(_appDelete?: boolean): void;
}

17
node_modules/@firebase/storage/dist/node-esm/src/implementation/fs.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
/**
* 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.
*/
export declare function getBlob(...args: Array<string | Blob | ArrayBuffer>): Blob;
/**
* 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.
*/
export declare function sliceBlob(blob: Blob, start: number, end: number): Blob | null;

7
node_modules/@firebase/storage/dist/node-esm/src/implementation/json.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
/**
* Returns the Object resulting from parsing the given JSON, or null if the
* given string does not represent a JSON object.
*/
export declare function jsonObjectOrNull(s: string): {
[name: string]: unknown;
} | null;

19
node_modules/@firebase/storage/dist/node-esm/src/implementation/list.d.ts generated vendored Normal file
View file

@ -0,0 +1,19 @@
/**
* @license
* Copyright 2019 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { ListResult } from '../list';
import { FirebaseStorageImpl } from '../service';
export declare function fromResponseString(service: FirebaseStorageImpl, bucket: string, resourceString: string): ListResult | null;

32
node_modules/@firebase/storage/dist/node-esm/src/implementation/location.d.ts generated vendored Normal file
View file

@ -0,0 +1,32 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Firebase Storage location data.
*
* @internal
*/
export declare class Location {
readonly bucket: string;
private path_;
constructor(bucket: string, path: string);
get path(): string;
get isRoot(): boolean;
fullServerUrl(): string;
bucketOnlyServerUrl(): string;
static makeFromBucketSpec(bucketString: string, host: string): Location;
static makeFromUrl(url: string, host: string): Location;
}

40
node_modules/@firebase/storage/dist/node-esm/src/implementation/metadata.d.ts generated vendored Normal file
View file

@ -0,0 +1,40 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Documentation for the metadata format
*/
import { Metadata } from '../metadata';
import { FirebaseStorageImpl } from '../service';
export declare function noXform_<T>(metadata: Metadata, value: T): T;
declare class Mapping<T> {
server: string;
local: string;
writable: boolean;
xform: (p1: Metadata, p2?: T) => T | undefined;
constructor(server: string, local?: string | null, writable?: boolean, xform?: ((p1: Metadata, p2?: T) => T | undefined) | null);
}
declare type Mappings = Array<Mapping<string> | Mapping<number>>;
export { Mappings };
export declare function xformPath(fullPath: string | undefined): string | undefined;
export declare function getMappings(): Mappings;
export declare function addRef(metadata: Metadata, service: FirebaseStorageImpl): void;
export declare function fromResource(service: FirebaseStorageImpl, resource: {
[name: string]: unknown;
}, mappings: Mappings): Metadata;
export declare function fromResourceString(service: FirebaseStorageImpl, resourceString: string, mappings: Mappings): Metadata | null;
export declare function downloadUrlFromResourceString(metadata: Metadata, resourceString: string, host: string, protocol: string): string | null;
export declare function toResourceString(metadata: Partial<Metadata>, mappings: Mappings): string;

47
node_modules/@firebase/storage/dist/node-esm/src/implementation/observer.d.ts generated vendored Normal file
View file

@ -0,0 +1,47 @@
import { StorageError } from './error';
/**
* Function that is called once for each value in a stream of values.
*/
export declare type NextFn<T> = (value: T) => void;
/**
* A function that is called with a `StorageError`
* if the event stream ends due to an error.
*/
export declare type ErrorFn = (error: StorageError) => void;
/**
* A function that is called if the event stream ends normally.
*/
export declare type CompleteFn = () => void;
/**
* Unsubscribes from a stream.
*/
export declare type Unsubscribe = () => void;
/**
* An observer identical to the `Observer` defined in packages/util except the
* error passed into the ErrorFn is specifically a `StorageError`.
*/
export interface StorageObserver<T> {
/**
* Function that is called once for each value in the event stream.
*/
next?: NextFn<T>;
/**
* A function that is called with a `StorageError`
* if the event stream ends due to an error.
*/
error?: ErrorFn;
/**
* A function that is called if the event stream ends normally.
*/
complete?: CompleteFn;
}
/**
* Subscribes to an event stream.
*/
export declare type Subscribe<T> = (next?: NextFn<T> | StorageObserver<T>, error?: ErrorFn, complete?: CompleteFn) => Unsubscribe;
export declare class Observer<T> implements StorageObserver<T> {
next?: NextFn<T>;
error?: ErrorFn;
complete?: CompleteFn;
constructor(nextOrObserver?: NextFn<T> | StorageObserver<T>, error?: ErrorFn, complete?: CompleteFn);
}

31
node_modules/@firebase/storage/dist/node-esm/src/implementation/path.d.ts generated vendored Normal file
View file

@ -0,0 +1,31 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Contains helper methods for manipulating paths.
*/
/**
* @return Null if the path is already at the root.
*/
export declare function parent(path: string): string | null;
export declare function child(path: string, childPath: string): string;
/**
* Returns the last component of a path.
* '/foo/bar' -> 'bar'
* '/foo/bar/baz/' -> 'baz/'
* '/a' -> 'a'
*/
export declare function lastComponent(path: string): string;

47
node_modules/@firebase/storage/dist/node-esm/src/implementation/request.d.ts generated vendored Normal file
View file

@ -0,0 +1,47 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { RequestInfo } from './requestinfo';
import { Connection, Headers, ConnectionType } from './connection';
export interface Request<T> {
getPromise(): Promise<T>;
/**
* Cancels the request. IMPORTANT: the promise may still be resolved with an
* appropriate value (if the request is finished before you call this method,
* but the promise has not yet been resolved), so don't just assume it will be
* rejected if you call this function.
* @param appDelete - True if the cancelation came from the app being deleted.
*/
cancel(appDelete?: boolean): void;
}
/**
* A collection of information about the result of a network request.
* @param opt_canceled - Defaults to false.
*/
export declare class RequestEndStatus<I extends ConnectionType> {
wasSuccessCode: boolean;
connection: Connection<I> | null;
/**
* True if the request was canceled.
*/
canceled: boolean;
constructor(wasSuccessCode: boolean, connection: Connection<I> | null, canceled?: boolean);
}
export declare function addAuthHeader_(headers: Headers, authToken: string | null): void;
export declare function addVersionHeader_(headers: Headers, firebaseVersion?: string): void;
export declare function addGmpidHeader_(headers: Headers, appId: string | null): void;
export declare function addAppCheckHeader_(headers: Headers, appCheckToken: string | null): void;
export declare function makeRequest<I extends ConnectionType, O>(requestInfo: RequestInfo<I, O>, appId: string | null, authToken: string | null, appCheckToken: string | null, requestFactory: () => Connection<I>, firebaseVersion?: string, retry?: boolean): Request<O>;

73
node_modules/@firebase/storage/dist/node-esm/src/implementation/requestinfo.d.ts generated vendored Normal file
View file

@ -0,0 +1,73 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { StorageError } from './error';
import { Headers, Connection, ConnectionType } from './connection';
/**
* Type for url params stored in RequestInfo.
*/
export interface UrlParams {
[name: string]: string | number;
}
/**
* A function that converts a server response to the API type expected by the
* SDK.
*
* @param I - the type of the backend's network response
* @param O - the output response type used by the rest of the SDK.
*/
export declare type RequestHandler<I extends ConnectionType, O> = (connection: Connection<I>, response: I) => O;
/** A function to handle an error. */
export declare type ErrorHandler = (connection: Connection<ConnectionType>, response: StorageError) => StorageError;
/**
* Contains a fully specified request.
*
* @param I - the type of the backend's network response.
* @param O - the output response type used by the rest of the SDK.
*/
export declare class RequestInfo<I extends ConnectionType, O> {
url: string;
method: string;
/**
* 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: RequestHandler<I, O>;
timeout: number;
urlParams: UrlParams;
headers: Headers;
body: Blob | string | Uint8Array | null;
errorHandler: 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).
*/
progressCallback: ((p1: number, p2: number) => void) | null;
successCodes: number[];
additionalRetryCodes: number[];
constructor(url: string, method: string,
/**
* 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: RequestHandler<I, O>, timeout: number);
}

84
node_modules/@firebase/storage/dist/node-esm/src/implementation/requests.d.ts generated vendored Normal file
View file

@ -0,0 +1,84 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Defines methods for interacting with the network.
*/
import { Metadata } from '../metadata';
import { ListResult } from '../list';
import { FbsBlob } from './blob';
import { StorageError } from './error';
import { Location } from './location';
import { Mappings } from './metadata';
import { RequestInfo } from './requestinfo';
import { Connection, ConnectionType } from './connection';
import { FirebaseStorageImpl } from '../service';
/**
* Throws the UNKNOWN StorageError if cndn is false.
*/
export declare function handlerCheck(cndn: boolean): void;
export declare function metadataHandler(service: FirebaseStorageImpl, mappings: Mappings): (p1: Connection<string>, p2: string) => Metadata;
export declare function listHandler(service: FirebaseStorageImpl, bucket: string): (p1: Connection<string>, p2: string) => ListResult;
export declare function downloadUrlHandler(service: FirebaseStorageImpl, mappings: Mappings): (p1: Connection<string>, p2: string) => string | null;
export declare function sharedErrorHandler(location: Location): (p1: Connection<ConnectionType>, p2: StorageError) => StorageError;
export declare function objectErrorHandler(location: Location): (p1: Connection<ConnectionType>, p2: StorageError) => StorageError;
export declare function getMetadata(service: FirebaseStorageImpl, location: Location, mappings: Mappings): RequestInfo<string, Metadata>;
export declare function list(service: FirebaseStorageImpl, location: Location, delimiter?: string, pageToken?: string | null, maxResults?: number | null): RequestInfo<string, ListResult>;
export declare function getBytes<I extends ConnectionType>(service: FirebaseStorageImpl, location: Location, maxDownloadSizeBytes?: number): RequestInfo<I, I>;
export declare function getDownloadUrl(service: FirebaseStorageImpl, location: Location, mappings: Mappings): RequestInfo<string, string | null>;
export declare function updateMetadata(service: FirebaseStorageImpl, location: Location, metadata: Partial<Metadata>, mappings: Mappings): RequestInfo<string, Metadata>;
export declare function deleteObject(service: FirebaseStorageImpl, location: Location): RequestInfo<string, void>;
export declare function determineContentType_(metadata: Metadata | null, blob: FbsBlob | null): string;
export declare function metadataForUpload_(location: Location, blob: FbsBlob, metadata?: Metadata | null): Metadata;
/**
* Prepare RequestInfo for uploads as Content-Type: multipart.
*/
export declare function multipartUpload(service: FirebaseStorageImpl, location: Location, mappings: Mappings, blob: FbsBlob, metadata?: Metadata | null): RequestInfo<string, Metadata>;
/**
* @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.
*/
export declare class ResumableUploadStatus {
current: number;
total: number;
finalized: boolean;
metadata: Metadata | null;
constructor(current: number, total: number, finalized?: boolean, metadata?: Metadata | null);
}
export declare function checkResumeHeader_(xhr: Connection<string>, allowed?: string[]): string;
export declare function createResumableUpload(service: FirebaseStorageImpl, location: Location, mappings: Mappings, blob: FbsBlob, metadata?: Metadata | null): RequestInfo<string, string>;
/**
* @param url From a call to fbs.requests.createResumableUpload.
*/
export declare function getResumableUploadStatus(service: FirebaseStorageImpl, location: Location, url: string, blob: FbsBlob): RequestInfo<string, ResumableUploadStatus>;
/**
* Any uploads via the resumable upload API must transfer a number of bytes
* that is a multiple of this number.
*/
export declare const RESUMABLE_UPLOAD_CHUNK_SIZE: number;
/**
* @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.
*/
export declare function continueResumableUpload(location: Location, service: FirebaseStorageImpl, url: string, blob: FbsBlob, chunkSize: number, mappings: Mappings, status?: ResumableUploadStatus | null, progressCallback?: ((p1: number, p2: number) => void) | null): RequestInfo<string, ResumableUploadStatus>;

73
node_modules/@firebase/storage/dist/node-esm/src/implementation/string.d.ts generated vendored Normal file
View file

@ -0,0 +1,73 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* An enumeration of the possible string formats for upload.
* @public
*/
export declare type StringFormat = (typeof StringFormat)[keyof typeof StringFormat];
/**
* An enumeration of the possible string formats for upload.
* @public
*/
export declare const StringFormat: {
/**
* Indicates the string should be interpreted "raw", that is, as normal text.
* The string will be interpreted as UTF-16, then uploaded as a UTF-8 byte
* sequence.
* Example: The string 'Hello! \\ud83d\\ude0a' becomes the byte sequence
* 48 65 6c 6c 6f 21 20 f0 9f 98 8a
*/
readonly RAW: "raw";
/**
* Indicates the string should be interpreted as base64-encoded data.
* Padding characters (trailing '='s) are optional.
* Example: The string 'rWmO++E6t7/rlw==' becomes the byte sequence
* ad 69 8e fb e1 3a b7 bf eb 97
*/
readonly BASE64: "base64";
/**
* Indicates the string should be interpreted as base64url-encoded data.
* Padding characters (trailing '='s) are optional.
* Example: The string 'rWmO--E6t7_rlw==' becomes the byte sequence
* ad 69 8e fb e1 3a b7 bf eb 97
*/
readonly BASE64URL: "base64url";
/**
* Indicates the string is a data URL, such as one obtained from
* canvas.toDataURL().
* Example: the string 'data:application/octet-stream;base64,aaaa'
* becomes the byte sequence
* 69 a6 9a
* (the content-type "application/octet-stream" is also applied, but can
* be overridden in the metadata object).
*/
readonly DATA_URL: "data_url";
};
export declare class StringData {
data: Uint8Array;
contentType: string | null;
constructor(data: Uint8Array, contentType?: string | null);
}
/**
* @internal
*/
export declare function dataFromString(format: StringFormat, stringData: string): StringData;
export declare function utf8Bytes_(value: string): Uint8Array;
export declare function percentEncodedBytes_(value: string): Uint8Array;
export declare function base64Bytes_(format: StringFormat, value: string): Uint8Array;
export declare function dataURLBytes_(dataUrl: string): Uint8Array;
export declare function dataURLContentType_(dataUrl: string): string | null;

77
node_modules/@firebase/storage/dist/node-esm/src/implementation/taskenums.d.ts generated vendored Normal file
View file

@ -0,0 +1,77 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Enumerations used for upload tasks.
*/
/**
* An event that is triggered on a task.
* @internal
*/
export declare type TaskEvent = string;
/**
* An event that is triggered on a task.
* @internal
*/
export declare const TaskEvent: {
/**
* For this event,
* <ul>
* <li>The `next` function is triggered on progress updates and when the
* task is paused/resumed with an `UploadTaskSnapshot` as the first
* argument.</li>
* <li>The `error` function is triggered if the upload is canceled or fails
* for another reason.</li>
* <li>The `complete` function is triggered if the upload completes
* successfully.</li>
* </ul>
*/
STATE_CHANGED: string;
};
/**
* Internal enum for task state.
*/
export declare const enum InternalTaskState {
RUNNING = "running",
PAUSING = "pausing",
PAUSED = "paused",
SUCCESS = "success",
CANCELING = "canceling",
CANCELED = "canceled",
ERROR = "error"
}
/**
* Represents the current state of a running upload.
* @internal
*/
export declare type TaskState = (typeof TaskState)[keyof typeof TaskState];
/**
* Represents the current state of a running upload.
* @internal
*/
export declare const TaskState: {
/** The task is currently transferring data. */
readonly RUNNING: "running";
/** The task was paused by the user. */
readonly PAUSED: "paused";
/** The task completed successfully. */
readonly SUCCESS: "success";
/** The task was canceled. */
readonly CANCELED: "canceled";
/** The task failed with an error. */
readonly ERROR: "error";
};
export declare function taskStateFromInternalTaskState(state: InternalTaskState): TaskState;

23
node_modules/@firebase/storage/dist/node-esm/src/implementation/type.d.ts generated vendored Normal file
View file

@ -0,0 +1,23 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export declare function isJustDef<T>(p: T | null | undefined): p is T | null;
export declare function isFunction(p: unknown): p is Function;
export declare function isNonArrayObject(p: unknown): boolean;
export declare function isString(p: unknown): p is string;
export declare function isNativeBlob(p: unknown): p is Blob;
export declare function isNativeBlobDefined(): boolean;
export declare function validateNumber(argument: string, minValue: number, maxValue: number, value: number): void;

22
node_modules/@firebase/storage/dist/node-esm/src/implementation/url.d.ts generated vendored Normal file
View file

@ -0,0 +1,22 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Functions to create and manipulate URLs for the server API.
*/
import { UrlParams } from './requestinfo';
export declare function makeUrl(urlPart: string, host: string, protocol: string): string;
export declare function makeQueryString(params: UrlParams): string;

23
node_modules/@firebase/storage/dist/node-esm/src/implementation/utils.d.ts generated vendored Normal file
View file

@ -0,0 +1,23 @@
/**
* @license
* Copyright 2022 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Checks the status code to see if the action should be retried.
*
* @param status Current HTTP status code returned by server.
* @param additionalRetryCodes additional retry codes to check against
*/
export declare function isRetryStatusCode(status: number, additionalRetryCodes: number[]): boolean;

7
node_modules/@firebase/storage/dist/node-esm/src/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
/**
* Cloud Storage for Firebase
*
* @packageDocumentation
*/
export * from './api';
export * from './api.browser';

7
node_modules/@firebase/storage/dist/node-esm/src/index.node.d.ts generated vendored Normal file
View file

@ -0,0 +1,7 @@
/**
* Cloud Storage for Firebase
*
* @packageDocumentation
*/
export * from './api';
export * from './api.node';

41
node_modules/@firebase/storage/dist/node-esm/src/list.d.ts generated vendored Normal file
View file

@ -0,0 +1,41 @@
/**
* @license
* Copyright 2019 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { Reference } from './reference';
/**
* Result returned by `list()`.
* @public
*/
export interface ListResult {
/**
* References to prefixes (sub-folders). You can call list() on them to
* get its contents.
*
* Folders are implicit based on '/' in the object paths.
* For example, if a bucket has two objects '/a/b/1' and '/a/b/2', list('/a')
* will return '/a/b' as a prefix.
*/
prefixes: Reference[];
/**
* Objects in this directory.
* You can call getMetadata() and getDownloadUrl() on them.
*/
items: Reference[];
/**
* If set, there might be more results for this list. Use this token to resume the list.
*/
nextPageToken?: string;
}

27
node_modules/@firebase/storage/dist/node-esm/src/metadata.d.ts generated vendored Normal file
View file

@ -0,0 +1,27 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { FullMetadata } from './public-types';
/**
* @fileoverview Documentation for the metadata format.
*/
/**
* The full set of object metadata, including read-only properties.
*/
interface Metadata extends FullMetadata {
[prop: string]: unknown;
}
export { Metadata };

20
node_modules/@firebase/storage/dist/node-esm/src/platform/base64.d.ts generated vendored Normal file
View file

@ -0,0 +1,20 @@
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/** Converts a Base64 encoded string to a binary string. */
export declare function decodeBase64(encoded: string): string;
/** Converts a Uint8Array to a string. */
export declare function decodeUint8Array(data: Uint8Array): string;

19
node_modules/@firebase/storage/dist/node-esm/src/platform/browser/base64.d.ts generated vendored Normal file
View file

@ -0,0 +1,19 @@
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/** Converts a Base64 encoded string to a binary string. */
export declare function decodeBase64(encoded: string): string;
export declare function decodeUint8Array(data: Uint8Array): string;

55
node_modules/@firebase/storage/dist/node-esm/src/platform/browser/connection.d.ts generated vendored Normal file
View file

@ -0,0 +1,55 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { Connection, ConnectionType, ErrorCode, Headers } from '../../implementation/connection';
/**
* Network layer for browsers. We use this instead of goog.net.XhrIo because
* goog.net.XhrIo is hyuuuuge and doesn't work in React Native on Android.
*/
declare abstract class XhrConnection<T extends ConnectionType> implements Connection<T> {
protected xhr_: XMLHttpRequest;
private errorCode_;
private sendPromise_;
protected sent_: boolean;
constructor();
abstract initXhr(): void;
send(url: string, method: string, body?: ArrayBufferView | Blob | string, headers?: Headers): Promise<void>;
getErrorCode(): ErrorCode;
getStatus(): number;
getResponse(): T;
getErrorText(): string;
/** Aborts the request. */
abort(): void;
getResponseHeader(header: string): string | null;
addUploadProgressListener(listener: (p1: ProgressEvent) => void): void;
removeUploadProgressListener(listener: (p1: ProgressEvent) => void): void;
}
export declare class XhrTextConnection extends XhrConnection<string> {
initXhr(): void;
}
export declare function newTextConnection(): Connection<string>;
export declare class XhrBytesConnection extends XhrConnection<ArrayBuffer> {
private data_?;
initXhr(): void;
}
export declare function newBytesConnection(): Connection<ArrayBuffer>;
export declare class XhrBlobConnection extends XhrConnection<Blob> {
initXhr(): void;
}
export declare function newBlobConnection(): Connection<Blob>;
export declare function newStreamConnection(): Connection<ReadableStream>;
export declare function injectTestConnection(factory: (() => Connection<string>) | null): void;
export {};

22
node_modules/@firebase/storage/dist/node-esm/src/platform/connection.d.ts generated vendored Normal file
View file

@ -0,0 +1,22 @@
/**
* @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.
*/
import { Connection } from '../implementation/connection';
export declare function injectTestConnection(factory: (() => Connection<string>) | null): void;
export declare function newTextConnection(): Connection<string>;
export declare function newBytesConnection(): Connection<ArrayBuffer>;
export declare function newBlobConnection(): Connection<Blob>;
export declare function newStreamConnection(): Connection<ReadableStream<Uint8Array>>;

19
node_modules/@firebase/storage/dist/node-esm/src/platform/node/base64.d.ts generated vendored Normal file
View file

@ -0,0 +1,19 @@
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/** Converts a Base64 encoded string to a binary string. */
export declare function decodeBase64(encoded: string): string;
export declare function decodeUint8Array(data: Uint8Array): string;

59
node_modules/@firebase/storage/dist/node-esm/src/platform/node/connection.d.ts generated vendored Normal file
View file

@ -0,0 +1,59 @@
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/// <reference types="node" />
import { Connection, ConnectionType, ErrorCode } from '../../implementation/connection';
/**
* Network layer that works in Node.
*
* This network implementation should not be used in browsers as it does not
* support progress updates.
*/
declare abstract class FetchConnection<T extends ConnectionType> implements Connection<T> {
protected errorCode_: ErrorCode;
protected statusCode_: number | undefined;
protected body_: ArrayBuffer | undefined;
protected errorText_: string;
protected headers_: Headers | undefined;
protected sent_: boolean;
constructor();
send(url: string, method: string, body?: NodeJS.ArrayBufferView | Blob | string, headers?: Record<string, string>): Promise<void>;
getErrorCode(): ErrorCode;
getStatus(): number;
abstract getResponse(): T;
getErrorText(): string;
abort(): void;
getResponseHeader(header: string): string | null;
addUploadProgressListener(listener: (p1: ProgressEvent) => void): void;
removeUploadProgressListener(listener: (p1: ProgressEvent) => void): void;
}
export declare class FetchTextConnection extends FetchConnection<string> {
getResponse(): string;
}
export declare function newTextConnection(): Connection<string>;
export declare class FetchBytesConnection extends FetchConnection<ArrayBuffer> {
getResponse(): ArrayBuffer;
}
export declare function newBytesConnection(): Connection<ArrayBuffer>;
export declare class FetchStreamConnection extends FetchConnection<ReadableStream<Uint8Array>> {
private stream_;
send(url: string, method: string, body?: NodeJS.ArrayBufferView | Blob | string, headers?: Record<string, string>): Promise<void>;
getResponse(): ReadableStream;
}
export declare function newStreamConnection(): Connection<ReadableStream<Uint8Array>>;
export declare function newBlobConnection(): Connection<Blob>;
export declare function injectTestConnection(factory: (() => Connection<string>) | null): void;
export {};

424
node_modules/@firebase/storage/dist/node-esm/src/public-types.d.ts generated vendored Normal file
View file

@ -0,0 +1,424 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { FirebaseApp, _FirebaseService } from '@firebase/app';
import { CompleteFn, NextFn, Subscribe, Unsubscribe } from '@firebase/util';
import { StorageError } from './implementation/error';
/**
* A Firebase Storage instance.
* @public
*/
export interface FirebaseStorage extends _FirebaseService {
/**
* The {@link @firebase/app#FirebaseApp} associated with this `FirebaseStorage` instance.
*/
readonly app: FirebaseApp;
/**
* The maximum time to retry uploads in milliseconds.
*/
maxUploadRetryTime: number;
/**
* The maximum time to retry operations other than uploads or downloads in
* milliseconds.
*/
maxOperationRetryTime: number;
}
/**
* Represents a reference to a Google Cloud Storage object. Developers can
* upload, download, and delete objects, as well as get/set object metadata.
* @public
*/
export interface StorageReference {
/**
* Returns a gs:// URL for this object in the form
* `gs://<bucket>/<path>/<to>/<object>`
* @returns The gs:// URL.
*/
toString(): string;
/**
* A reference to the root of this object's bucket.
*/
root: StorageReference;
/**
* The name of the bucket containing this reference's object.
*/
bucket: string;
/**
* The full path of this object.
*/
fullPath: string;
/**
* The short name of this object, which is the last component of the full path.
* For example, if fullPath is 'full/path/image.png', name is 'image.png'.
*/
name: string;
/**
* The {@link FirebaseStorage} instance associated with this reference.
*/
storage: FirebaseStorage;
/**
* A reference pointing to the parent location of this reference, or null if
* this reference is the root.
*/
parent: StorageReference | null;
}
/**
* The options `list()` accepts.
* @public
*/
export interface ListOptions {
/**
* If set, limits the total number of `prefixes` and `items` to return.
* The default and maximum maxResults is 1000.
*/
maxResults?: number | null;
/**
* The `nextPageToken` from a previous call to `list()`. If provided,
* listing is resumed from the previous position.
*/
pageToken?: string | null;
}
/**
* Result returned by list().
* @public
*/
export interface ListResult {
/**
* References to prefixes (sub-folders). You can call list() on them to
* get its contents.
*
* Folders are implicit based on '/' in the object paths.
* For example, if a bucket has two objects '/a/b/1' and '/a/b/2', list('/a')
* will return '/a/b' as a prefix.
*/
prefixes: StorageReference[];
/**
* Objects in this directory.
* You can call getMetadata() and getDownloadUrl() on them.
*/
items: StorageReference[];
/**
* If set, there might be more results for this list. Use this token to resume the list.
*/
nextPageToken?: string;
}
/**
* Object metadata that can be set at any time.
* @public
*/
export interface SettableMetadata {
/**
* Served as the 'Cache-Control' header on object download.
*/
cacheControl?: string | undefined;
/**
* Served as the 'Content-Disposition' header on object download.
*/
contentDisposition?: string | undefined;
/**
* Served as the 'Content-Encoding' header on object download.
*/
contentEncoding?: string | undefined;
/**
* Served as the 'Content-Language' header on object download.
*/
contentLanguage?: string | undefined;
/**
* Served as the 'Content-Type' header on object download.
*/
contentType?: string | undefined;
/**
* Additional user-defined custom metadata.
*/
customMetadata?: {
[key: string]: string;
} | undefined;
}
/**
* Object metadata that can be set at upload.
* @public
*/
export interface UploadMetadata extends SettableMetadata {
/**
* A Base64-encoded MD5 hash of the object being uploaded.
*/
md5Hash?: string | undefined;
}
/**
* The full set of object metadata, including read-only properties.
* @public
*/
export interface FullMetadata extends UploadMetadata {
/**
* The bucket this object is contained in.
*/
bucket: string;
/**
* The full path of this object.
*/
fullPath: string;
/**
* The object's generation.
* {@link https://cloud.google.com/storage/docs/metadata#generation-number}
*/
generation: string;
/**
* The object's metageneration.
* {@link https://cloud.google.com/storage/docs/metadata#generation-number}
*/
metageneration: string;
/**
* The short name of this object, which is the last component of the full path.
* For example, if fullPath is 'full/path/image.png', name is 'image.png'.
*/
name: string;
/**
* The size of this object, in bytes.
*/
size: number;
/**
* A date string representing when this object was created.
*/
timeCreated: string;
/**
* A date string representing when this object was last updated.
*/
updated: string;
/**
* Tokens to allow access to the download URL.
*/
downloadTokens: string[] | undefined;
/**
* `StorageReference` associated with this upload.
*/
ref?: StorageReference | undefined;
}
/**
* An event that is triggered on a task.
* @public
*/
export declare type TaskEvent = 'state_changed';
/**
* Represents the current state of a running upload.
* @public
*/
export declare type TaskState = 'running' | 'paused' | 'success' | 'canceled' | 'error';
/**
* A stream observer for Firebase Storage.
* @public
*/
export interface StorageObserver<T> {
next?: NextFn<T> | null;
error?: (error: StorageError) => void | null;
complete?: CompleteFn | null;
}
/**
* Represents the process of uploading an object. Allows you to monitor and
* manage the upload.
* @public
*/
export interface UploadTask {
/**
* Cancels a running task. Has no effect on a complete or failed task.
* @returns True if the cancel had an effect.
*/
cancel(): boolean;
/**
* Equivalent to calling `then(null, onRejected)`.
*/
catch(onRejected: (error: StorageError) => unknown): Promise<unknown>;
/**
* Listens for events on this task.
*
* Events have three callback functions (referred to as `next`, `error`, and
* `complete`).
*
* If only the event is passed, a function that can be used to register the
* callbacks is returned. Otherwise, the callbacks are passed after the event.
*
* Callbacks can be passed either as three separate arguments <em>or</em> as the
* `next`, `error`, and `complete` properties of an object. Any of the three
* callbacks is optional, as long as at least one is specified. In addition,
* when you add your callbacks, you get a function back. You can call this
* function to unregister the associated callbacks.
*
* @example **Pass callbacks separately or in an object.**
* ```javascript
* var next = function(snapshot) {};
* var error = function(error) {};
* var complete = function() {};
*
* // The first example.
* uploadTask.on(
* firebase.storage.TaskEvent.STATE_CHANGED,
* next,
* error,
* complete);
*
* // This is equivalent to the first example.
* uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED, {
* 'next': next,
* 'error': error,
* 'complete': complete
* });
*
* // This is equivalent to the first example.
* var subscribe = uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED);
* subscribe(next, error, complete);
*
* // This is equivalent to the first example.
* var subscribe = uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED);
* subscribe({
* 'next': next,
* 'error': error,
* 'complete': complete
* });
* ```
*
* @example **Any callback is optional.**
* ```javascript
* // Just listening for completion, this is legal.
* uploadTask.on(
* firebase.storage.TaskEvent.STATE_CHANGED,
* null,
* null,
* function() {
* console.log('upload complete!');
* });
*
* // Just listening for progress/state changes, this is legal.
* uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED, function(snapshot) {
* var percent = snapshot.bytesTransferred / snapshot.totalBytes * 100;
* console.log(percent + "% done");
* });
*
* // This is also legal.
* uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED, {
* 'complete': function() {
* console.log('upload complete!');
* }
* });
* ```
*
* @example **Use the returned function to remove callbacks.**
* ```javascript
* var unsubscribe = uploadTask.on(
* firebase.storage.TaskEvent.STATE_CHANGED,
* function(snapshot) {
* var percent = snapshot.bytesTransferred / snapshot.totalBytes * 100;
* console.log(percent + "% done");
* // Stop after receiving one update.
* unsubscribe();
* });
*
* // This code is equivalent to the above.
* var handle = uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED);
* unsubscribe = handle(function(snapshot) {
* var percent = snapshot.bytesTransferred / snapshot.totalBytes * 100;
* console.log(percent + "% done");
* // Stop after receiving one update.
* unsubscribe();
* });
* ```
*
* @param event - The type of event to listen for.
* @param nextOrObserver -
* The `next` function, which gets called for each item in
* the event stream, or an observer object with some or all of these three
* properties (`next`, `error`, `complete`).
* @param error - A function that gets called with a `StorageError`
* if the event stream ends due to an error.
* @param completed - A function that gets called if the
* event stream ends normally.
* @returns
* If only the event argument is passed, returns a function you can use to
* add callbacks (see the examples above). If more than just the event
* argument is passed, returns a function you can call to unregister the
* callbacks.
*/
on(event: TaskEvent, nextOrObserver?: StorageObserver<UploadTaskSnapshot> | null | ((snapshot: UploadTaskSnapshot) => unknown), error?: ((a: StorageError) => unknown) | null, complete?: Unsubscribe | null): Unsubscribe | Subscribe<UploadTaskSnapshot>;
/**
* Pauses a currently running task. Has no effect on a paused or failed task.
* @returns True if the operation took effect, false if ignored.
*/
pause(): boolean;
/**
* Resumes a paused task. Has no effect on a currently running or failed task.
* @returns True if the operation took effect, false if ignored.
*/
resume(): boolean;
/**
* A snapshot of the current task state.
*/
snapshot: UploadTaskSnapshot;
/**
* 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?: ((snapshot: UploadTaskSnapshot) => unknown) | null, onRejected?: ((error: StorageError) => unknown) | null): Promise<unknown>;
}
/**
* Holds data about the current state of the upload task.
* @public
*/
export interface UploadTaskSnapshot {
/**
* The number of bytes that have been successfully uploaded so far.
*/
bytesTransferred: number;
/**
* Before the upload completes, contains the metadata sent to the server.
* After the upload completes, contains the metadata sent back from the server.
*/
metadata: FullMetadata;
/**
* The reference that spawned this snapshot's upload task.
*/
ref: StorageReference;
/**
* The current state of the task.
*/
state: TaskState;
/**
* The task of which this is a snapshot.
*/
task: UploadTask;
/**
* The total number of bytes to be uploaded.
*/
totalBytes: number;
}
/**
* Result returned from a non-resumable upload.
* @public
*/
export interface UploadResult {
/**
* Contains the metadata sent back from the server.
*/
readonly metadata: FullMetadata;
/**
* The reference that spawned this upload.
*/
readonly ref: StorageReference;
}
declare module '@firebase/component' {
interface NameServiceMapping {
'storage': FirebaseStorage;
}
}

208
node_modules/@firebase/storage/dist/node-esm/src/reference.d.ts generated vendored Normal file
View file

@ -0,0 +1,208 @@
/**
* @license
* Copyright 2019 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { Location } from './implementation/location';
import { ListOptions, UploadResult } from './public-types';
import { StringFormat } from './implementation/string';
import { Metadata } from './metadata';
import { FirebaseStorageImpl } from './service';
import { ListResult } from './list';
import { UploadTask } from './task';
/**
* Provides methods to interact with a bucket in the Firebase Storage service.
* @internal
* @param _location - An fbs.location, or the URL at
* which to base this object, in one of the following forms:
* gs://<bucket>/<object-path>
* http[s]://firebasestorage.googleapis.com/
* <api-version>/b/<bucket>/o/<object-path>
* Any query or fragment strings will be ignored in the http[s]
* format. If no value is passed, the storage object will use a URL based on
* the project ID of the base firebase.App instance.
*/
export declare class Reference {
private _service;
_location: Location;
constructor(_service: FirebaseStorageImpl, location: string | Location);
/**
* Returns the URL for the bucket and path this object references,
* in the form gs://<bucket>/<object-path>
* @override
*/
toString(): string;
protected _newRef(service: FirebaseStorageImpl, location: Location): Reference;
/**
* A reference to the root of this object's bucket.
*/
get root(): Reference;
/**
* The name of the bucket containing this reference's object.
*/
get bucket(): string;
/**
* The full path of this object.
*/
get fullPath(): string;
/**
* The short name of this object, which is the last component of the full path.
* For example, if fullPath is 'full/path/image.png', name is 'image.png'.
*/
get name(): string;
/**
* The `StorageService` instance this `StorageReference` is associated with.
*/
get storage(): FirebaseStorageImpl;
/**
* A `StorageReference` pointing to the parent location of this `StorageReference`, or null if
* this reference is the root.
*/
get parent(): Reference | null;
/**
* Utility function to throw an error in methods that do not accept a root reference.
*/
_throwIfRoot(name: string): void;
}
/**
* Download the bytes at the object's location.
* @returns A Promise containing the downloaded bytes.
*/
export declare function getBytesInternal(ref: Reference, maxDownloadSizeBytes?: number): Promise<ArrayBuffer>;
/**
* Download the bytes at the object's location.
* @returns A Promise containing the downloaded blob.
*/
export declare function getBlobInternal(ref: Reference, maxDownloadSizeBytes?: number): Promise<Blob>;
/** Stream the bytes at the object's location. */
export declare function getStreamInternal(ref: Reference, maxDownloadSizeBytes?: number): ReadableStream;
/**
* Uploads data to this object's location.
* The upload is not resumable.
*
* @param ref - StorageReference where data should be uploaded.
* @param data - The data to upload.
* @param metadata - Metadata for the newly uploaded data.
* @returns A Promise containing an UploadResult
*/
export declare function uploadBytes(ref: Reference, data: Blob | Uint8Array | ArrayBuffer, metadata?: Metadata): Promise<UploadResult>;
/**
* Uploads data to this object's location.
* The upload can be paused and resumed, and exposes progress updates.
* @public
* @param ref - StorageReference where data should be uploaded.
* @param data - The data to upload.
* @param metadata - Metadata for the newly uploaded data.
* @returns An UploadTask
*/
export declare function uploadBytesResumable(ref: Reference, data: Blob | Uint8Array | ArrayBuffer, metadata?: Metadata): UploadTask;
/**
* Uploads a string to this object's location.
* The upload is not resumable.
* @public
* @param ref - StorageReference where string should be uploaded.
* @param value - The string to upload.
* @param format - The format of the string to upload.
* @param metadata - Metadata for the newly uploaded string.
* @returns A Promise containing an UploadResult
*/
export declare function uploadString(ref: Reference, value: string, format?: StringFormat, metadata?: Metadata): Promise<UploadResult>;
/**
* List all items (files) and prefixes (folders) under this storage reference.
*
* This is a helper method for calling list() repeatedly until there are
* no more results. The default pagination size is 1000.
*
* Note: The results may not be consistent if objects are changed while this
* operation is running.
*
* Warning: listAll may potentially consume too many resources if there are
* too many results.
* @public
* @param ref - StorageReference to get list from.
*
* @returns A Promise that resolves with all the items and prefixes under
* the current storage reference. `prefixes` contains references to
* sub-directories and `items` contains references to objects in this
* folder. `nextPageToken` is never returned.
*/
export declare function listAll(ref: Reference): Promise<ListResult>;
/**
* List items (files) and prefixes (folders) under this storage reference.
*
* List API is only available for Firebase Rules Version 2.
*
* GCS is a key-blob store. Firebase Storage imposes the semantic of '/'
* delimited folder structure.
* Refer to GCS's List API if you want to learn more.
*
* To adhere to Firebase Rules's Semantics, Firebase Storage does not
* support objects whose paths end with "/" or contain two consecutive
* "/"s. Firebase Storage List API will filter these unsupported objects.
* list() may fail if there are too many unsupported objects in the bucket.
* @public
*
* @param ref - StorageReference to get list from.
* @param options - See ListOptions for details.
* @returns A Promise that resolves with the items and prefixes.
* `prefixes` contains references to sub-folders and `items`
* contains references to objects in this folder. `nextPageToken`
* can be used to get the rest of the results.
*/
export declare function list(ref: Reference, options?: ListOptions | null): Promise<ListResult>;
/**
* A `Promise` that resolves with the metadata for this object. If this
* object doesn't exist or metadata cannot be retrieved, the promise is
* rejected.
* @public
* @param ref - StorageReference to get metadata from.
*/
export declare function getMetadata(ref: Reference): Promise<Metadata>;
/**
* Updates the metadata for this object.
* @public
* @param ref - StorageReference to update metadata for.
* @param metadata - The new metadata for the object.
* Only values that have been explicitly set will be changed. Explicitly
* setting a value to null will remove the metadata.
* @returns A `Promise` that resolves
* with the new metadata for this object.
* See `firebaseStorage.Reference.prototype.getMetadata`
*/
export declare function updateMetadata(ref: Reference, metadata: Partial<Metadata>): Promise<Metadata>;
/**
* Returns the download URL for the given Reference.
* @public
* @returns A `Promise` that resolves with the download
* URL for this object.
*/
export declare function getDownloadURL(ref: Reference): Promise<string>;
/**
* Deletes the object at this location.
* @public
* @param ref - StorageReference for object to delete.
* @returns A `Promise` that resolves if the deletion succeeds.
*/
export declare function deleteObject(ref: Reference): Promise<void>;
/**
* Returns reference for object obtained by appending `childPath` to `ref`.
*
* @param ref - StorageReference to get child of.
* @param childPath - Child path from provided ref.
* @returns A reference to the object obtained by
* appending childPath, removing any duplicate, beginning, or trailing
* slashes.
*
*/
export declare function _getChild(ref: Reference, childPath: string): Reference;

130
node_modules/@firebase/storage/dist/node-esm/src/service.d.ts generated vendored Normal file
View file

@ -0,0 +1,130 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { Location } from './implementation/location';
import { Request } from './implementation/request';
import { RequestInfo } from './implementation/requestinfo';
import { Reference } from './reference';
import { Provider } from '@firebase/component';
import { FirebaseAuthInternalName } from '@firebase/auth-interop-types';
import { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';
import { FirebaseApp } from '@firebase/app';
import { FirebaseStorage } from './public-types';
import { EmulatorMockTokenOptions } from '@firebase/util';
import { Connection, ConnectionType } from './implementation/connection';
export declare function isUrl(path?: string): boolean;
/**
* Returns a storage Reference for the given url.
* @param storage - `Storage` instance.
* @param url - URL. If empty, returns root reference.
* @public
*/
export declare function ref(storage: FirebaseStorageImpl, url?: string): Reference;
/**
* Returns a storage Reference for the given path in the
* default bucket.
* @param storageOrRef - `Storage` service or storage `Reference`.
* @param pathOrUrlStorage - path. If empty, returns root reference (if Storage
* instance provided) or returns same reference (if Reference provided).
* @public
*/
export declare function ref(storageOrRef: FirebaseStorageImpl | Reference, path?: string): Reference;
export declare function connectStorageEmulator(storage: FirebaseStorageImpl, host: string, port: number, options?: {
mockUserToken?: EmulatorMockTokenOptions | string;
}): void;
/**
* A service that provides Firebase Storage Reference instances.
* @param opt_url - gs:// url to a custom Storage Bucket
*
* @internal
*/
export declare class FirebaseStorageImpl implements FirebaseStorage {
/**
* FirebaseApp associated with this StorageService instance.
*/
readonly app: FirebaseApp;
readonly _authProvider: Provider<FirebaseAuthInternalName>;
/**
* @internal
*/
readonly _appCheckProvider: Provider<AppCheckInternalComponentName>;
/**
* @internal
*/
readonly _url?: string | undefined;
readonly _firebaseVersion?: string | undefined;
_bucket: Location | null;
/**
* This string can be in the formats:
* - host
* - host:port
*/
private _host;
_protocol: string;
protected readonly _appId: string | null;
private readonly _requests;
private _deleted;
private _maxOperationRetryTime;
private _maxUploadRetryTime;
_overrideAuthToken?: string;
constructor(
/**
* FirebaseApp associated with this StorageService instance.
*/
app: FirebaseApp, _authProvider: Provider<FirebaseAuthInternalName>,
/**
* @internal
*/
_appCheckProvider: Provider<AppCheckInternalComponentName>,
/**
* @internal
*/
_url?: string | undefined, _firebaseVersion?: string | undefined);
/**
* The host string for this service, in the form of `host` or
* `host:port`.
*/
get host(): string;
set host(host: string);
/**
* The maximum time to retry uploads in milliseconds.
*/
get maxUploadRetryTime(): number;
set maxUploadRetryTime(time: number);
/**
* The maximum time to retry operations other than uploads or downloads in
* milliseconds.
*/
get maxOperationRetryTime(): number;
set maxOperationRetryTime(time: number);
_getAuthToken(): Promise<string | null>;
_getAppCheckToken(): Promise<string | null>;
/**
* Stop running requests and prevent more from being created.
*/
_delete(): Promise<void>;
/**
* Returns a new firebaseStorage.Reference object referencing this StorageService
* at the given Location.
*/
_makeStorageReference(loc: Location): Reference;
/**
* @param requestInfo - HTTP RequestInfo object
* @param authToken - Firebase auth token
*/
_makeRequest<I extends ConnectionType, O>(requestInfo: RequestInfo<I, O>, requestFactory: () => Connection<I>, authToken: string | null, appCheckToken: string | null, retry?: boolean): Request<O>;
makeRequestWithTokens<I extends ConnectionType, O>(requestInfo: RequestInfo<I, O>, requestFactory: () => Connection<I>): Promise<O>;
}

148
node_modules/@firebase/storage/dist/node-esm/src/task.d.ts generated vendored Normal file
View file

@ -0,0 +1,148 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Defines types for interacting with blob transfer tasks.
*/
import { FbsBlob } from './implementation/blob';
import { StorageError } from './implementation/error';
import { InternalTaskState, TaskEvent } from './implementation/taskenums';
import { Metadata } from './metadata';
import { Subscribe, Unsubscribe } from './implementation/observer';
import { UploadTaskSnapshot, StorageObserver } from './public-types';
import { Reference } from './reference';
import { CompleteFn } from '@firebase/util';
/**
* Represents a blob being uploaded. Can be used to pause/resume/cancel the
* upload and manage callbacks for various events.
* @internal
*/
export declare class UploadTask {
private _ref;
/**
* The data to be uploaded.
*/
_blob: FbsBlob;
/**
* Metadata related to the upload.
*/
_metadata: Metadata | null;
private _mappings;
/**
* Number of bytes transferred so far.
*/
_transferred: number;
private _needToFetchStatus;
private _needToFetchMetadata;
private _observers;
private _resumable;
/**
* Upload state.
*/
_state: InternalTaskState;
private _error?;
private _uploadUrl?;
private _request?;
private _chunkMultiplier;
private _errorHandler;
private _metadataErrorHandler;
private _resolve?;
private _reject?;
private pendingTimeout?;
private _promise;
private sleepTime;
private maxSleepTime;
isExponentialBackoffExpired(): boolean;
/**
* @param ref - The firebaseStorage.Reference object this task came
* from, untyped to avoid cyclic dependencies.
* @param blob - The blob to upload.
*/
constructor(ref: Reference, blob: FbsBlob, metadata?: Metadata | null);
private _makeProgressCallback;
private _shouldDoResumable;
private _start;
private _resolveToken;
private _createResumable;
private _fetchStatus;
private _continueUpload;
private _increaseMultiplier;
private _fetchMetadata;
private _oneShotUpload;
private _updateProgress;
private _transition;
private completeTransitions_;
/**
* A snapshot of the current task state.
*/
get snapshot(): UploadTaskSnapshot;
/**
* Adds a callback for an event.
* @param type - The type of event to listen for.
* @param nextOrObserver -
* The `next` function, which gets called for each item in
* the event stream, or an observer object with some or all of these three
* properties (`next`, `error`, `complete`).
* @param error - A function that gets called with a `StorageError`
* if the event stream ends due to an error.
* @param completed - A function that gets called if the
* event stream ends normally.
* @returns
* If only the event argument is passed, returns a function you can use to
* add callbacks (see the examples above). If more than just the event
* argument is passed, returns a function you can call to unregister the
* callbacks.
*/
on(type: TaskEvent, nextOrObserver?: StorageObserver<UploadTaskSnapshot> | null | ((snapshot: UploadTaskSnapshot) => unknown), error?: ((a: StorageError) => unknown) | null, completed?: CompleteFn | null): Unsubscribe | Subscribe<UploadTaskSnapshot>;
/**
* 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<U>(onFulfilled?: ((value: UploadTaskSnapshot) => U | Promise<U>) | null, onRejected?: ((error: StorageError) => U | Promise<U>) | null): Promise<U>;
/**
* Equivalent to calling `then(null, onRejected)`.
*/
catch<T>(onRejected: (p1: StorageError) => T | Promise<T>): Promise<T>;
/**
* Adds the given observer.
*/
private _addObserver;
/**
* Removes the given observer.
*/
private _removeObserver;
private _notifyObservers;
private _finishPromise;
private _notifyObserver;
/**
* Resumes a paused task. Has no effect on a currently running or failed task.
* @returns True if the operation took effect, false if ignored.
*/
resume(): boolean;
/**
* Pauses a currently running task. Has no effect on a paused or failed task.
* @returns True if the operation took effect, false if ignored.
*/
pause(): boolean;
/**
* Cancels a currently running or paused task. Has no effect on a complete or
* failed task.
* @returns True if the operation took effect, false if ignored.
*/
cancel(): boolean;
}

17
node_modules/@firebase/storage/dist/node-esm/test/browser/blob.test.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export {};

17
node_modules/@firebase/storage/dist/node-esm/test/browser/connection.test.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export {};

17
node_modules/@firebase/storage/dist/node-esm/test/browser/string.browser.test.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
/**
* @license
* Copyright 2022 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export {};

24
node_modules/@firebase/storage/dist/node-esm/test/integration/integration.test.d.ts generated vendored Normal file
View file

@ -0,0 +1,24 @@
/**
* @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.
*/
import { FirebaseApp } from '@firebase/app';
import * as types from '../../src/public-types';
export declare const PROJECT_ID: any;
export declare const STORAGE_BUCKET: any;
export declare const API_KEY: any;
export declare const AUTH_DOMAIN: any;
export declare function createApp(): Promise<FirebaseApp>;
export declare function createStorage(app: FirebaseApp): types.FirebaseStorage;

17
node_modules/@firebase/storage/dist/node-esm/test/node/connection.test.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export {};

17
node_modules/@firebase/storage/dist/node-esm/test/node/stream.test.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
/**
* @license
* Copyright 2021 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export {};

47
node_modules/@firebase/storage/dist/node-esm/test/unit/connection.d.ts generated vendored Normal file
View file

@ -0,0 +1,47 @@
/**
* @license
* Copyright 2017 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { ErrorCode, Headers, Connection } from '../../src/implementation/connection';
export declare type SendHook = (connection: TestingConnection, url: string, method: string, body?: ArrayBufferView | Blob | string | null, headers?: Headers) => void;
export declare enum State {
START = 0,
SENT = 1,
DONE = 2
}
export declare class TestingConnection implements Connection<string> {
private state;
private sendPromise;
private resolve;
private sendHook;
private status;
private responseText;
private headers;
private errorCode;
constructor(sendHook: SendHook | null);
send(url: string, method: string, body?: ArrayBufferView | Blob | string | null, headers?: Headers): Promise<void>;
simulateResponse(status: number, body: string, headers: {
[key: string]: string;
}): void;
getErrorCode(): ErrorCode;
getStatus(): number;
getResponse(): string;
getErrorText(): string;
abort(): void;
getResponseHeader(header: string): string | null;
addUploadProgressListener(): void;
removeUploadProgressListener(): void;
}
export declare function newTestConnection(sendHook?: SendHook | null): Connection<string>;

4
node_modules/@firebase/storage/dist/node-esm/test/unit/index.test.d.ts generated vendored Normal file
View file

@ -0,0 +1,4 @@
export declare const PROJECT_ID: any;
export declare const STORAGE_BUCKET: any;
export declare const API_KEY: any;
export declare const AUTH_DOMAIN: any;

1
node_modules/@firebase/storage/dist/node-esm/test/unit/location.test.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export {};

1
node_modules/@firebase/storage/dist/node-esm/test/unit/reference.test.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export {};

1
node_modules/@firebase/storage/dist/node-esm/test/unit/request.test.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export {};

1
node_modules/@firebase/storage/dist/node-esm/test/unit/requests.test.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export {};

1
node_modules/@firebase/storage/dist/node-esm/test/unit/service.test.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export {};

1
node_modules/@firebase/storage/dist/node-esm/test/unit/string.test.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export {};

1
node_modules/@firebase/storage/dist/node-esm/test/unit/task.test.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export {};

60
node_modules/@firebase/storage/dist/node-esm/test/unit/testshared.d.ts generated vendored Normal file
View file

@ -0,0 +1,60 @@
import { FirebaseApp } from '@firebase/app-types';
import { StorageError } from '../../src/implementation/error';
import { Headers, Connection, ConnectionType } from '../../src/implementation/connection';
import { FirebaseAuthInternalName } from '@firebase/auth-interop-types';
import { Provider } from '@firebase/component';
import { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';
import { FirebaseStorageImpl } from '../../src/service';
import { Metadata } from '../../src/metadata';
export declare const authToken = "totally-legit-auth-token";
export declare const appCheckToken = "totally-shady-token";
export declare const bucket = "mybucket";
export declare const fakeApp: FirebaseApp;
export declare const fakeAuthProvider: Provider<"auth-internal">;
export declare const emptyAuthProvider: Provider<"auth-internal">;
export declare const fakeAppCheckTokenProvider: Provider<"app-check-internal">;
export declare function makeFakeApp(bucketArg?: string): FirebaseApp;
export declare function makeFakeAuthProvider(token: {
accessToken: string;
}): Provider<FirebaseAuthInternalName>;
export declare function makeFakeAppCheckProvider(tokenResult: {
token: string;
}): Provider<AppCheckInternalComponentName>;
/**
* Returns something that looks like an fbs.XhrIo with the given headers
* and status.
*/
export declare function fakeXhrIo<I extends ConnectionType = string>(headers: Headers, status?: number): Connection<I>;
/**
* Binds ignoring types. Used to test calls involving improper arguments.
*/
export declare function bind(f: Function, ctx: any, ...args: any[]): () => void;
export declare function assertThrows(f: () => void, code: string): StorageError;
export declare function assertUint8ArrayEquals(arr1: Uint8Array, arr2: Uint8Array): void;
export declare function assertObjectIncludes(included: {
[name: string]: any;
}, obj: {
[name: string]: any;
}): void;
interface Response {
status: number;
body: string;
headers: Headers;
}
export declare type RequestHandler = (url: string, method: string, body?: ArrayBufferView | Blob | string | null, headers?: Headers) => Response;
export declare function storageServiceWithHandler(handler: RequestHandler, shouldResponseCb?: () => boolean): FirebaseStorageImpl;
export declare function fakeServerHandler(fakeMetadata?: Partial<Metadata>): RequestHandler;
/**
* Responds with a 503 for finalize.
* @param fakeMetadata metadata to respond with for finalize
* @returns a handler for requests
*/
export declare function fake503ForFinalizeServerHandler(fakeMetadata?: Partial<Metadata>): RequestHandler;
/**
* Responds with a 503 for upload.
* @param fakeMetadata metadata to respond with for query
* @returns a handler for requests
*/
export declare function fake503ForUploadServerHandler(fakeMetadata?: Partial<Metadata>, cb?: () => void): RequestHandler;
export declare function fakeOneShot503ServerHandler(fakeMetadata?: Partial<Metadata>): RequestHandler;
export {};

17
node_modules/@firebase/storage/dist/node-esm/test/unit/utils.test.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
/**
* @license
* Copyright 2022 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export {};