Initial Commit

node_modules/@firebase/functions/dist/index.esm2017.js

@@ -0,0 +1,548 @@
+import firebase from '@firebase/app';
+import { Component } from '@firebase/component';
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Standard error codes for different ways a request can fail, as defined by:
+ * https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
+ *
+ * This map is used primarily to convert from a backend error code string to
+ * a client SDK error code string, and make sure it's in the supported set.
+ */
+const errorCodeMap = {
+    OK: 'ok',
+    CANCELLED: 'cancelled',
+    UNKNOWN: 'unknown',
+    INVALID_ARGUMENT: 'invalid-argument',
+    DEADLINE_EXCEEDED: 'deadline-exceeded',
+    NOT_FOUND: 'not-found',
+    ALREADY_EXISTS: 'already-exists',
+    PERMISSION_DENIED: 'permission-denied',
+    UNAUTHENTICATED: 'unauthenticated',
+    RESOURCE_EXHAUSTED: 'resource-exhausted',
+    FAILED_PRECONDITION: 'failed-precondition',
+    ABORTED: 'aborted',
+    OUT_OF_RANGE: 'out-of-range',
+    UNIMPLEMENTED: 'unimplemented',
+    INTERNAL: 'internal',
+    UNAVAILABLE: 'unavailable',
+    DATA_LOSS: 'data-loss'
+};
+/**
+ * An explicit error that can be thrown from a handler to send an error to the
+ * client that called the function.
+ */
+class HttpsErrorImpl extends Error {
+    constructor(code, message, details) {
+        super(message);
+        // This is a workaround for a bug in TypeScript when extending Error:
+        // tslint:disable-next-line
+        // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        Object.setPrototypeOf(this, HttpsErrorImpl.prototype);
+        this.code = code;
+        this.details = details;
+    }
+}
+/**
+ * Takes an HTTP status code and returns the corresponding ErrorCode.
+ * This is the standard HTTP status code -> error mapping defined in:
+ * https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
+ *
+ * @param status An HTTP status code.
+ * @return The corresponding ErrorCode, or ErrorCode.UNKNOWN if none.
+ */
+function codeForHTTPStatus(status) {
+    // Make sure any successful status is OK.
+    if (status >= 200 && status < 300) {
+        return 'ok';
+    }
+    switch (status) {
+        case 0:
+            // This can happen if the server returns 500.
+            return 'internal';
+        case 400:
+            return 'invalid-argument';
+        case 401:
+            return 'unauthenticated';
+        case 403:
+            return 'permission-denied';
+        case 404:
+            return 'not-found';
+        case 409:
+            return 'aborted';
+        case 429:
+            return 'resource-exhausted';
+        case 499:
+            return 'cancelled';
+        case 500:
+            return 'internal';
+        case 501:
+            return 'unimplemented';
+        case 503:
+            return 'unavailable';
+        case 504:
+            return 'deadline-exceeded';
+    }
+    return 'unknown';
+}
+/**
+ * Takes an HTTP response and returns the corresponding Error, if any.
+ */
+function _errorForResponse(status, bodyJSON, serializer) {
+    let code = codeForHTTPStatus(status);
+    // Start with reasonable defaults from the status code.
+    let description = code;
+    let details = undefined;
+    // Then look through the body for explicit details.
+    try {
+        const errorJSON = bodyJSON && bodyJSON.error;
+        if (errorJSON) {
+            const status = errorJSON.status;
+            if (typeof status === 'string') {
+                if (!errorCodeMap[status]) {
+                    // They must've included an unknown error code in the body.
+                    return new HttpsErrorImpl('internal', 'internal');
+                }
+                code = errorCodeMap[status];
+                // TODO(klimt): Add better default descriptions for error enums.
+                // The default description needs to be updated for the new code.
+                description = status;
+            }
+            const message = errorJSON.message;
+            if (typeof message === 'string') {
+                description = message;
+            }
+            details = errorJSON.details;
+            if (details !== undefined) {
+                details = serializer.decode(details);
+            }
+        }
+    }
+    catch (e) {
+        // If we couldn't parse explicit error data, that's fine.
+    }
+    if (code === 'ok') {
+        // Technically, there's an edge case where a developer could explicitly
+        // return an error code of OK, and we will treat it as success, but that
+        // seems reasonable.
+        return null;
+    }
+    return new HttpsErrorImpl(code, description, details);
+}
+
+/**
+ * Helper class to get metadata that should be included with a function call.
+ */
+class ContextProvider {
+    constructor(authProvider, messagingProvider) {
+        this.auth = null;
+        this.messaging = null;
+        this.auth = authProvider.getImmediate({ optional: true });
+        this.messaging = messagingProvider.getImmediate({
+            optional: true
+        });
+        if (!this.auth) {
+            authProvider.get().then(auth => (this.auth = auth), () => {
+                /* get() never rejects */
+            });
+        }
+        if (!this.messaging) {
+            messagingProvider.get().then(messaging => (this.messaging = messaging), () => {
+                /* get() never rejects */
+            });
+        }
+    }
+    async getAuthToken() {
+        if (!this.auth) {
+            return undefined;
+        }
+        try {
+            const token = await this.auth.getToken();
+            if (!token) {
+                return undefined;
+            }
+            return token.accessToken;
+        }
+        catch (e) {
+            // If there's any error when trying to get the auth token, leave it off.
+            return undefined;
+        }
+    }
+    async getInstanceIdToken() {
+        if (!this.messaging ||
+            !('Notification' in self) ||
+            Notification.permission !== 'granted') {
+            return undefined;
+        }
+        try {
+            return this.messaging.getToken();
+        }
+        catch (e) {
+            // We don't warn on this, because it usually means messaging isn't set up.
+            // console.warn('Failed to retrieve instance id token.', e);
+            // If there's any error when trying to get the token, leave it off.
+            return undefined;
+        }
+    }
+    async getContext() {
+        const authToken = await this.getAuthToken();
+        const instanceIdToken = await this.getInstanceIdToken();
+        return { authToken, instanceIdToken };
+    }
+}
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const LONG_TYPE = 'type.googleapis.com/google.protobuf.Int64Value';
+const UNSIGNED_LONG_TYPE = 'type.googleapis.com/google.protobuf.UInt64Value';
+function mapValues(
+// { [k: string]: unknown } is no longer a wildcard assignment target after typescript 3.5
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+o, f) {
+    const result = {};
+    for (const key in o) {
+        if (o.hasOwnProperty(key)) {
+            result[key] = f(o[key]);
+        }
+    }
+    return result;
+}
+class Serializer {
+    // Takes data and encodes it in a JSON-friendly way, such that types such as
+    // Date are preserved.
+    encode(data) {
+        if (data == null) {
+            return null;
+        }
+        if (data instanceof Number) {
+            data = data.valueOf();
+        }
+        if (typeof data === 'number' && isFinite(data)) {
+            // Any number in JS is safe to put directly in JSON and parse as a double
+            // without any loss of precision.
+            return data;
+        }
+        if (data === true || data === false) {
+            return data;
+        }
+        if (Object.prototype.toString.call(data) === '[object String]') {
+            return data;
+        }
+        if (Array.isArray(data)) {
+            return data.map(x => this.encode(x));
+        }
+        if (typeof data === 'function' || typeof data === 'object') {
+            return mapValues(data, x => this.encode(x));
+        }
+        // If we got this far, the data is not encodable.
+        throw new Error('Data cannot be encoded in JSON: ' + data);
+    }
+    // Takes data that's been encoded in a JSON-friendly form and returns a form
+    // with richer datatypes, such as Dates, etc.
+    decode(json) {
+        if (json == null) {
+            return json;
+        }
+        if (json['@type']) {
+            switch (json['@type']) {
+                case LONG_TYPE:
+                // Fall through and handle this the same as unsigned.
+                case UNSIGNED_LONG_TYPE: {
+                    // Technically, this could work return a valid number for malformed
+                    // data if there was a number followed by garbage. But it's just not
+                    // worth all the extra code to detect that case.
+                    const value = Number(json['value']);
+                    if (isNaN(value)) {
+                        throw new Error('Data cannot be decoded from JSON: ' + json);
+                    }
+                    return value;
+                }
+                default: {
+                    throw new Error('Data cannot be decoded from JSON: ' + json);
+                }
+            }
+        }
+        if (Array.isArray(json)) {
+            return json.map(x => this.decode(x));
+        }
+        if (typeof json === 'function' || typeof json === 'object') {
+            return mapValues(json, x => this.decode(x));
+        }
+        // Anything else is safe to return.
+        return json;
+    }
+}
+
+/**
+ * @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 Promise that will be rejected after the given duration.
+ * The error will be of type HttpsErrorImpl.
+ *
+ * @param millis Number of milliseconds to wait before rejecting.
+ */
+function failAfter(millis) {
+    return new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new HttpsErrorImpl('deadline-exceeded', 'deadline-exceeded'));
+        }, millis);
+    });
+}
+/**
+ * The main class for the Firebase Functions SDK.
+ */
+class Service {
+    /**
+     * Creates a new Functions service for the given app and (optional) region.
+     * @param app_ The FirebaseApp to use.
+     * @param region_ The region to call functions in.
+     */
+    constructor(app_, authProvider, messagingProvider, region_ = 'us-central1') {
+        this.app_ = app_;
+        this.region_ = region_;
+        this.serializer = new Serializer();
+        this.emulatorOrigin = null;
+        this.INTERNAL = {
+            delete: () => {
+                return this.deleteService();
+            }
+        };
+        this.contextProvider = new ContextProvider(authProvider, messagingProvider);
+        // Cancels all ongoing requests when resolved.
+        this.cancelAllRequests = new Promise(resolve => {
+            this.deleteService = () => {
+                return resolve();
+            };
+        });
+    }
+    get app() {
+        return this.app_;
+    }
+    /**
+     * Returns the URL for a callable with the given name.
+     * @param name The name of the callable.
+     */
+    _url(name) {
+        const projectId = this.app_.options.projectId;
+        const region = this.region_;
+        if (this.emulatorOrigin !== null) {
+            const origin = this.emulatorOrigin;
+            return `${origin}/${projectId}/${region}/${name}`;
+        }
+        return `https://${region}-${projectId}.cloudfunctions.net/${name}`;
+    }
+    /**
+     * Changes this instance to point to a Cloud Functions emulator running
+     * locally. See https://firebase.google.com/docs/functions/local-emulator
+     *
+     * @param origin The origin of the local emulator, such as
+     * "http://localhost:5005".
+     */
+    useFunctionsEmulator(origin) {
+        this.emulatorOrigin = origin;
+    }
+    /**
+     * Returns a reference to the callable https trigger with the given name.
+     * @param name The name of the trigger.
+     */
+    httpsCallable(name, options) {
+        return data => {
+            return this.call(name, data, options || {});
+        };
+    }
+    /**
+     * Does an HTTP POST and returns the completed response.
+     * @param url The url to post to.
+     * @param body The JSON body of the post.
+     * @param headers The HTTP headers to include in the request.
+     * @return A Promise that will succeed when the request finishes.
+     */
+    async postJSON(url, body, headers) {
+        headers.append('Content-Type', 'application/json');
+        let response;
+        try {
+            response = await fetch(url, {
+                method: 'POST',
+                body: JSON.stringify(body),
+                headers
+            });
+        }
+        catch (e) {
+            // This could be an unhandled error on the backend, or it could be a
+            // network error. There's no way to know, since an unhandled error on the
+            // backend will fail to set the proper CORS header, and thus will be
+            // treated as a network error by fetch.
+            return {
+                status: 0,
+                json: null
+            };
+        }
+        let json = null;
+        try {
+            json = await response.json();
+        }
+        catch (e) {
+            // If we fail to parse JSON, it will fail the same as an empty body.
+        }
+        return {
+            status: response.status,
+            json
+        };
+    }
+    /**
+     * Calls a callable function asynchronously and returns the result.
+     * @param name The name of the callable trigger.
+     * @param data The data to pass as params to the function.s
+     */
+    async call(name, data, options) {
+        const url = this._url(name);
+        // Encode any special types, such as dates, in the input data.
+        data = this.serializer.encode(data);
+        const body = { data };
+        // Add a header for the authToken.
+        const headers = new Headers();
+        const context = await this.contextProvider.getContext();
+        if (context.authToken) {
+            headers.append('Authorization', 'Bearer ' + context.authToken);
+        }
+        if (context.instanceIdToken) {
+            headers.append('Firebase-Instance-ID-Token', context.instanceIdToken);
+        }
+        // Default timeout to 70s, but let the options override it.
+        const timeout = options.timeout || 70000;
+        const response = await Promise.race([
+            this.postJSON(url, body, headers),
+            failAfter(timeout),
+            this.cancelAllRequests
+        ]);
+        // If service was deleted, interrupted response throws an error.
+        if (!response) {
+            throw new HttpsErrorImpl('cancelled', 'Firebase Functions instance was deleted.');
+        }
+        // Check for an error status, regardless of http status.
+        const error = _errorForResponse(response.status, response.json, this.serializer);
+        if (error) {
+            throw error;
+        }
+        if (!response.json) {
+            throw new HttpsErrorImpl('internal', 'Response is not valid JSON object.');
+        }
+        let responseData = response.json.data;
+        // TODO(klimt): For right now, allow "result" instead of "data", for
+        // backwards compatibility.
+        if (typeof responseData === 'undefined') {
+            responseData = response.json.result;
+        }
+        if (typeof responseData === 'undefined') {
+            // Consider the response malformed.
+            throw new HttpsErrorImpl('internal', 'Response is missing data field.');
+        }
+        // Decode any special types, such as dates, in the returned data.
+        const decodedData = this.serializer.decode(responseData);
+        return { data: decodedData };
+    }
+}
+
+/**
+ * @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.
+ */
+/**
+ * Type constant for Firebase Functions.
+ */
+const FUNCTIONS_TYPE = 'functions';
+function factory(container, region) {
+    // Dependencies
+    const app = container.getProvider('app').getImmediate();
+    const authProvider = container.getProvider('auth-internal');
+    const messagingProvider = container.getProvider('messaging');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new Service(app, authProvider, messagingProvider, region);
+}
+function registerFunctions(instance) {
+    const namespaceExports = {
+        // no-inline
+        Functions: Service
+    };
+    instance.INTERNAL.registerComponent(new Component(FUNCTIONS_TYPE, factory, "PUBLIC" /* PUBLIC */)
+        .setServiceProps(namespaceExports)
+        .setMultipleInstances(true));
+}
+
+const name = "@firebase/functions";
+const version = "0.4.44";
+
+/**
+ * @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.
+ */
+registerFunctions(firebase);
+firebase.registerVersion(name, version);
+//# sourceMappingURL=index.esm2017.js.map