From 8eff962cab608341a6f2fedc640a0e32d96f26e2 Mon Sep 17 00:00:00 2001 From: altaf-creator Date: Sun, 9 Nov 2025 11:15:19 +0800 Subject: pain --- .../@firebase/messaging/dist/index.cjs.js | 1278 ++++++++++++++++++++ 1 file changed, 1278 insertions(+) create mode 100644 frontend-old/node_modules/@firebase/messaging/dist/index.cjs.js (limited to 'frontend-old/node_modules/@firebase/messaging/dist/index.cjs.js') diff --git a/frontend-old/node_modules/@firebase/messaging/dist/index.cjs.js b/frontend-old/node_modules/@firebase/messaging/dist/index.cjs.js new file mode 100644 index 0000000..0e0b22c --- /dev/null +++ b/frontend-old/node_modules/@firebase/messaging/dist/index.cjs.js @@ -0,0 +1,1278 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +require('@firebase/installations'); +var component = require('@firebase/component'); +var idb = require('idb'); +var util = require('@firebase/util'); +var app = require('@firebase/app'); + +/** + * @license + * Copyright 2019 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +const DEFAULT_SW_PATH = '/firebase-messaging-sw.js'; +const DEFAULT_SW_SCOPE = '/firebase-cloud-messaging-push-scope'; +const DEFAULT_VAPID_KEY = 'BDOU99-h67HcA6JeFXHbSNMu7e2yNNu3RzoMj8TM4W88jITfq7ZmPvIM1Iv-4_l2LxQcYwhqby2xGpWwzjfAnG4'; +const ENDPOINT = 'https://fcmregistrations.googleapis.com/v1'; +const CONSOLE_CAMPAIGN_ID = 'google.c.a.c_id'; +const CONSOLE_CAMPAIGN_NAME = 'google.c.a.c_l'; +const CONSOLE_CAMPAIGN_TIME = 'google.c.a.ts'; +/** Set to '1' if Analytics is enabled for the campaign */ +const CONSOLE_CAMPAIGN_ANALYTICS_ENABLED = 'google.c.a.e'; +const DEFAULT_REGISTRATION_TIMEOUT = 10000; +var MessageType$1; +(function (MessageType) { + MessageType[MessageType["DATA_MESSAGE"] = 1] = "DATA_MESSAGE"; + MessageType[MessageType["DISPLAY_NOTIFICATION"] = 3] = "DISPLAY_NOTIFICATION"; +})(MessageType$1 || (MessageType$1 = {})); + +/** + * @license + * Copyright 2018 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. + */ +var MessageType; +(function (MessageType) { + MessageType["PUSH_RECEIVED"] = "push-received"; + MessageType["NOTIFICATION_CLICKED"] = "notification-clicked"; +})(MessageType || (MessageType = {})); + +/** + * @license + * Copyright 2017 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +function arrayToBase64(array) { + const uint8Array = new Uint8Array(array); + const base64String = btoa(String.fromCharCode(...uint8Array)); + return base64String.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_'); +} +function base64ToArray(base64String) { + const padding = '='.repeat((4 - (base64String.length % 4)) % 4); + const base64 = (base64String + padding) + .replace(/\-/g, '+') + .replace(/_/g, '/'); + const rawData = atob(base64); + const outputArray = new Uint8Array(rawData.length); + for (let i = 0; i < rawData.length; ++i) { + outputArray[i] = rawData.charCodeAt(i); + } + return outputArray; +} + +/** + * @license + * Copyright 2019 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +const OLD_DB_NAME = 'fcm_token_details_db'; +/** + * The last DB version of 'fcm_token_details_db' was 4. This is one higher, so that the upgrade + * callback is called for all versions of the old DB. + */ +const OLD_DB_VERSION = 5; +const OLD_OBJECT_STORE_NAME = 'fcm_token_object_Store'; +async function migrateOldDatabase(senderId) { + if ('databases' in indexedDB) { + // indexedDb.databases() is an IndexedDB v3 API and does not exist in all browsers. TODO: Remove + // typecast when it lands in TS types. + const databases = await indexedDB.databases(); + const dbNames = databases.map(db => db.name); + if (!dbNames.includes(OLD_DB_NAME)) { + // old DB didn't exist, no need to open. + return null; + } + } + let tokenDetails = null; + const db = await idb.openDB(OLD_DB_NAME, OLD_DB_VERSION, { + upgrade: async (db, oldVersion, newVersion, upgradeTransaction) => { + if (oldVersion < 2) { + // Database too old, skip migration. + return; + } + if (!db.objectStoreNames.contains(OLD_OBJECT_STORE_NAME)) { + // Database did not exist. Nothing to do. + return; + } + const objectStore = upgradeTransaction.objectStore(OLD_OBJECT_STORE_NAME); + const value = await objectStore.index('fcmSenderId').get(senderId); + await objectStore.clear(); + if (!value) { + // No entry in the database, nothing to migrate. + return; + } + if (oldVersion === 2) { + const oldDetails = value; + if (!oldDetails.auth || !oldDetails.p256dh || !oldDetails.endpoint) { + return; + } + tokenDetails = { + token: oldDetails.fcmToken, + createTime: oldDetails.createTime ?? Date.now(), + subscriptionOptions: { + auth: oldDetails.auth, + p256dh: oldDetails.p256dh, + endpoint: oldDetails.endpoint, + swScope: oldDetails.swScope, + vapidKey: typeof oldDetails.vapidKey === 'string' + ? oldDetails.vapidKey + : arrayToBase64(oldDetails.vapidKey) + } + }; + } + else if (oldVersion === 3) { + const oldDetails = value; + tokenDetails = { + token: oldDetails.fcmToken, + createTime: oldDetails.createTime, + subscriptionOptions: { + auth: arrayToBase64(oldDetails.auth), + p256dh: arrayToBase64(oldDetails.p256dh), + endpoint: oldDetails.endpoint, + swScope: oldDetails.swScope, + vapidKey: arrayToBase64(oldDetails.vapidKey) + } + }; + } + else if (oldVersion === 4) { + const oldDetails = value; + tokenDetails = { + token: oldDetails.fcmToken, + createTime: oldDetails.createTime, + subscriptionOptions: { + auth: arrayToBase64(oldDetails.auth), + p256dh: arrayToBase64(oldDetails.p256dh), + endpoint: oldDetails.endpoint, + swScope: oldDetails.swScope, + vapidKey: arrayToBase64(oldDetails.vapidKey) + } + }; + } + } + }); + db.close(); + // Delete all old databases. + await idb.deleteDB(OLD_DB_NAME); + await idb.deleteDB('fcm_vapid_details_db'); + await idb.deleteDB('undefined'); + return checkTokenDetails(tokenDetails) ? tokenDetails : null; +} +function checkTokenDetails(tokenDetails) { + if (!tokenDetails || !tokenDetails.subscriptionOptions) { + return false; + } + const { subscriptionOptions } = tokenDetails; + return (typeof tokenDetails.createTime === 'number' && + tokenDetails.createTime > 0 && + typeof tokenDetails.token === 'string' && + tokenDetails.token.length > 0 && + typeof subscriptionOptions.auth === 'string' && + subscriptionOptions.auth.length > 0 && + typeof subscriptionOptions.p256dh === 'string' && + subscriptionOptions.p256dh.length > 0 && + typeof subscriptionOptions.endpoint === 'string' && + subscriptionOptions.endpoint.length > 0 && + typeof subscriptionOptions.swScope === 'string' && + subscriptionOptions.swScope.length > 0 && + typeof subscriptionOptions.vapidKey === 'string' && + subscriptionOptions.vapidKey.length > 0); +} + +/** + * @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. + */ +// Exported for tests. +const DATABASE_NAME = 'firebase-messaging-database'; +const DATABASE_VERSION = 1; +const OBJECT_STORE_NAME = 'firebase-messaging-store'; +let dbPromise = null; +function getDbPromise() { + if (!dbPromise) { + dbPromise = idb.openDB(DATABASE_NAME, DATABASE_VERSION, { + upgrade: (upgradeDb, oldVersion) => { + // We don't use 'break' in this switch statement, the fall-through behavior is what we want, + // because if there are multiple versions between the old version and the current version, we + // want ALL the migrations that correspond to those versions to run, not only the last one. + // eslint-disable-next-line default-case + switch (oldVersion) { + case 0: + upgradeDb.createObjectStore(OBJECT_STORE_NAME); + } + } + }); + } + return dbPromise; +} +/** Gets record(s) from the objectStore that match the given key. */ +async function dbGet(firebaseDependencies) { + const key = getKey(firebaseDependencies); + const db = await getDbPromise(); + const tokenDetails = (await db + .transaction(OBJECT_STORE_NAME) + .objectStore(OBJECT_STORE_NAME) + .get(key)); + if (tokenDetails) { + return tokenDetails; + } + else { + // Check if there is a tokenDetails object in the old DB. + const oldTokenDetails = await migrateOldDatabase(firebaseDependencies.appConfig.senderId); + if (oldTokenDetails) { + await dbSet(firebaseDependencies, oldTokenDetails); + return oldTokenDetails; + } + } +} +/** Assigns or overwrites the record for the given key with the given value. */ +async function dbSet(firebaseDependencies, tokenDetails) { + const key = getKey(firebaseDependencies); + const db = await getDbPromise(); + const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite'); + await tx.objectStore(OBJECT_STORE_NAME).put(tokenDetails, key); + await tx.done; + return tokenDetails; +} +/** Removes record(s) from the objectStore that match the given key. */ +async function dbRemove(firebaseDependencies) { + const key = getKey(firebaseDependencies); + const db = await getDbPromise(); + const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite'); + await tx.objectStore(OBJECT_STORE_NAME).delete(key); + await tx.done; +} +function getKey({ appConfig }) { + return appConfig.appId; +} + +/** + * @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 ERROR_MAP = { + ["missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */]: 'Missing App configuration value: "{$valueName}"', + ["only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */]: 'This method is available in a Window context.', + ["only-available-in-sw" /* ErrorCode.AVAILABLE_IN_SW */]: 'This method is available in a service worker context.', + ["permission-default" /* ErrorCode.PERMISSION_DEFAULT */]: 'The notification permission was not granted and dismissed instead.', + ["permission-blocked" /* ErrorCode.PERMISSION_BLOCKED */]: 'The notification permission was not granted and blocked instead.', + ["unsupported-browser" /* ErrorCode.UNSUPPORTED_BROWSER */]: "This browser doesn't support the API's required to use the Firebase SDK.", + ["indexed-db-unsupported" /* ErrorCode.INDEXED_DB_UNSUPPORTED */]: "This browser doesn't support indexedDb.open() (ex. Safari iFrame, Firefox Private Browsing, etc)", + ["failed-service-worker-registration" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */]: 'We are unable to register the default service worker. {$browserErrorMessage}', + ["token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */]: 'A problem occurred while subscribing the user to FCM: {$errorInfo}', + ["token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */]: 'FCM returned no token when subscribing the user to push.', + ["token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */]: 'A problem occurred while unsubscribing the ' + + 'user from FCM: {$errorInfo}', + ["token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */]: 'A problem occurred while updating the user from FCM: {$errorInfo}', + ["token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */]: 'FCM returned no token when updating the user to push.', + ["use-sw-after-get-token" /* ErrorCode.USE_SW_AFTER_GET_TOKEN */]: 'The useServiceWorker() method may only be called once and must be ' + + 'called before calling getToken() to ensure your service worker is used.', + ["invalid-sw-registration" /* ErrorCode.INVALID_SW_REGISTRATION */]: 'The input to useServiceWorker() must be a ServiceWorkerRegistration.', + ["invalid-bg-handler" /* ErrorCode.INVALID_BG_HANDLER */]: 'The input to setBackgroundMessageHandler() must be a function.', + ["invalid-vapid-key" /* ErrorCode.INVALID_VAPID_KEY */]: 'The public VAPID key must be a string.', + ["use-vapid-key-after-get-token" /* ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN */]: 'The usePublicVapidKey() method may only be called once and must be ' + + 'called before calling getToken() to ensure your VAPID key is used.' +}; +const ERROR_FACTORY = new util.ErrorFactory('messaging', 'Messaging', ERROR_MAP); + +/** + * @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. + */ +async function requestGetToken(firebaseDependencies, subscriptionOptions) { + const headers = await getHeaders(firebaseDependencies); + const body = getBody(subscriptionOptions); + const subscribeOptions = { + method: 'POST', + headers, + body: JSON.stringify(body) + }; + let responseData; + try { + const response = await fetch(getEndpoint(firebaseDependencies.appConfig), subscribeOptions); + responseData = await response.json(); + } + catch (err) { + throw ERROR_FACTORY.create("token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, { + errorInfo: err?.toString() + }); + } + if (responseData.error) { + const message = responseData.error.message; + throw ERROR_FACTORY.create("token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, { + errorInfo: message + }); + } + if (!responseData.token) { + throw ERROR_FACTORY.create("token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */); + } + return responseData.token; +} +async function requestUpdateToken(firebaseDependencies, tokenDetails) { + const headers = await getHeaders(firebaseDependencies); + const body = getBody(tokenDetails.subscriptionOptions); + const updateOptions = { + method: 'PATCH', + headers, + body: JSON.stringify(body) + }; + let responseData; + try { + const response = await fetch(`${getEndpoint(firebaseDependencies.appConfig)}/${tokenDetails.token}`, updateOptions); + responseData = await response.json(); + } + catch (err) { + throw ERROR_FACTORY.create("token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */, { + errorInfo: err?.toString() + }); + } + if (responseData.error) { + const message = responseData.error.message; + throw ERROR_FACTORY.create("token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */, { + errorInfo: message + }); + } + if (!responseData.token) { + throw ERROR_FACTORY.create("token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */); + } + return responseData.token; +} +async function requestDeleteToken(firebaseDependencies, token) { + const headers = await getHeaders(firebaseDependencies); + const unsubscribeOptions = { + method: 'DELETE', + headers + }; + try { + const response = await fetch(`${getEndpoint(firebaseDependencies.appConfig)}/${token}`, unsubscribeOptions); + const responseData = await response.json(); + if (responseData.error) { + const message = responseData.error.message; + throw ERROR_FACTORY.create("token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, { + errorInfo: message + }); + } + } + catch (err) { + throw ERROR_FACTORY.create("token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, { + errorInfo: err?.toString() + }); + } +} +function getEndpoint({ projectId }) { + return `${ENDPOINT}/projects/${projectId}/registrations`; +} +async function getHeaders({ appConfig, installations }) { + const authToken = await installations.getToken(); + return new Headers({ + 'Content-Type': 'application/json', + Accept: 'application/json', + 'x-goog-api-key': appConfig.apiKey, + 'x-goog-firebase-installations-auth': `FIS ${authToken}` + }); +} +function getBody({ p256dh, auth, endpoint, vapidKey }) { + const body = { + web: { + endpoint, + auth, + p256dh + } + }; + if (vapidKey !== DEFAULT_VAPID_KEY) { + body.web.applicationPubKey = vapidKey; + } + return body; +} + +/** + * @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. + */ +// UpdateRegistration will be called once every week. +const TOKEN_EXPIRATION_MS = 7 * 24 * 60 * 60 * 1000; // 7 days +async function getTokenInternal(messaging) { + const pushSubscription = await getPushSubscription(messaging.swRegistration, messaging.vapidKey); + const subscriptionOptions = { + vapidKey: messaging.vapidKey, + swScope: messaging.swRegistration.scope, + endpoint: pushSubscription.endpoint, + auth: arrayToBase64(pushSubscription.getKey('auth')), + p256dh: arrayToBase64(pushSubscription.getKey('p256dh')) + }; + const tokenDetails = await dbGet(messaging.firebaseDependencies); + if (!tokenDetails) { + // No token, get a new one. + return getNewToken(messaging.firebaseDependencies, subscriptionOptions); + } + else if (!isTokenValid(tokenDetails.subscriptionOptions, subscriptionOptions)) { + // Invalid token, get a new one. + try { + await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token); + } + catch (e) { + // Suppress errors because of #2364 + console.warn(e); + } + return getNewToken(messaging.firebaseDependencies, subscriptionOptions); + } + else if (Date.now() >= tokenDetails.createTime + TOKEN_EXPIRATION_MS) { + // Weekly token refresh + return updateToken(messaging, { + token: tokenDetails.token, + createTime: Date.now(), + subscriptionOptions + }); + } + else { + // Valid token, nothing to do. + return tokenDetails.token; + } +} +/** + * This method deletes the token from the database, unsubscribes the token from FCM, and unregisters + * the push subscription if it exists. + */ +async function deleteTokenInternal(messaging) { + const tokenDetails = await dbGet(messaging.firebaseDependencies); + if (tokenDetails) { + await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token); + await dbRemove(messaging.firebaseDependencies); + } + // Unsubscribe from the push subscription. + const pushSubscription = await messaging.swRegistration.pushManager.getSubscription(); + if (pushSubscription) { + return pushSubscription.unsubscribe(); + } + // If there's no SW, consider it a success. + return true; +} +async function updateToken(messaging, tokenDetails) { + try { + const updatedToken = await requestUpdateToken(messaging.firebaseDependencies, tokenDetails); + const updatedTokenDetails = { + ...tokenDetails, + token: updatedToken, + createTime: Date.now() + }; + await dbSet(messaging.firebaseDependencies, updatedTokenDetails); + return updatedToken; + } + catch (e) { + throw e; + } +} +async function getNewToken(firebaseDependencies, subscriptionOptions) { + const token = await requestGetToken(firebaseDependencies, subscriptionOptions); + const tokenDetails = { + token, + createTime: Date.now(), + subscriptionOptions + }; + await dbSet(firebaseDependencies, tokenDetails); + return tokenDetails.token; +} +/** + * Gets a PushSubscription for the current user. + */ +async function getPushSubscription(swRegistration, vapidKey) { + const subscription = await swRegistration.pushManager.getSubscription(); + if (subscription) { + return subscription; + } + return swRegistration.pushManager.subscribe({ + userVisibleOnly: true, + // Chrome <= 75 doesn't support base64-encoded VAPID key. For backward compatibility, VAPID key + // submitted to pushManager#subscribe must be of type Uint8Array. + applicationServerKey: base64ToArray(vapidKey) + }); +} +/** + * Checks if the saved tokenDetails object matches the configuration provided. + */ +function isTokenValid(dbOptions, currentOptions) { + const isVapidKeyEqual = currentOptions.vapidKey === dbOptions.vapidKey; + const isEndpointEqual = currentOptions.endpoint === dbOptions.endpoint; + const isAuthEqual = currentOptions.auth === dbOptions.auth; + const isP256dhEqual = currentOptions.p256dh === dbOptions.p256dh; + return isVapidKeyEqual && isEndpointEqual && isAuthEqual && isP256dhEqual; +} + +/** + * @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. + */ +function externalizePayload(internalPayload) { + const payload = { + from: internalPayload.from, + // eslint-disable-next-line camelcase + collapseKey: internalPayload.collapse_key, + // eslint-disable-next-line camelcase + messageId: internalPayload.fcmMessageId + }; + propagateNotificationPayload(payload, internalPayload); + propagateDataPayload(payload, internalPayload); + propagateFcmOptions(payload, internalPayload); + return payload; +} +function propagateNotificationPayload(payload, messagePayloadInternal) { + if (!messagePayloadInternal.notification) { + return; + } + payload.notification = {}; + const title = messagePayloadInternal.notification.title; + if (!!title) { + payload.notification.title = title; + } + const body = messagePayloadInternal.notification.body; + if (!!body) { + payload.notification.body = body; + } + const image = messagePayloadInternal.notification.image; + if (!!image) { + payload.notification.image = image; + } + const icon = messagePayloadInternal.notification.icon; + if (!!icon) { + payload.notification.icon = icon; + } +} +function propagateDataPayload(payload, messagePayloadInternal) { + if (!messagePayloadInternal.data) { + return; + } + payload.data = messagePayloadInternal.data; +} +function propagateFcmOptions(payload, messagePayloadInternal) { + // fcmOptions.link value is written into notification.click_action. see more in b/232072111 + if (!messagePayloadInternal.fcmOptions && + !messagePayloadInternal.notification?.click_action) { + return; + } + payload.fcmOptions = {}; + const link = messagePayloadInternal.fcmOptions?.link ?? + messagePayloadInternal.notification?.click_action; + if (!!link) { + payload.fcmOptions.link = link; + } + // eslint-disable-next-line camelcase + const analyticsLabel = messagePayloadInternal.fcmOptions?.analytics_label; + if (!!analyticsLabel) { + payload.fcmOptions.analyticsLabel = analyticsLabel; + } +} + +/** + * @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. + */ +function isConsoleMessage(data) { + // This message has a campaign ID, meaning it was sent using the Firebase Console. + return typeof data === 'object' && !!data && CONSOLE_CAMPAIGN_ID in data; +} + +/** + * @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. + */ +_mergeStrings('AzSCbw63g1R0nCw85jG8', 'Iaya3yLKwmgvh7cF0q4'); +function _mergeStrings(s1, s2) { + const resultArray = []; + for (let i = 0; i < s1.length; i++) { + resultArray.push(s1.charAt(i)); + if (i < s2.length) { + resultArray.push(s2.charAt(i)); + } + } + return resultArray.join(''); +} + +/** + * @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. + */ +function extractAppConfig(app) { + if (!app || !app.options) { + throw getMissingValueError('App Configuration Object'); + } + if (!app.name) { + throw getMissingValueError('App Name'); + } + // Required app config keys + const configKeys = [ + 'projectId', + 'apiKey', + 'appId', + 'messagingSenderId' + ]; + const { options } = app; + for (const keyName of configKeys) { + if (!options[keyName]) { + throw getMissingValueError(keyName); + } + } + return { + appName: app.name, + projectId: options.projectId, + apiKey: options.apiKey, + appId: options.appId, + senderId: options.messagingSenderId + }; +} +function getMissingValueError(valueName) { + return ERROR_FACTORY.create("missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */, { + valueName + }); +} + +/** + * @license + * Copyright 2020 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +class MessagingService { + constructor(app, installations, analyticsProvider) { + // logging is only done with end user consent. Default to false. + this.deliveryMetricsExportedToBigQueryEnabled = false; + this.onBackgroundMessageHandler = null; + this.onMessageHandler = null; + this.logEvents = []; + this.isLogServiceStarted = false; + const appConfig = extractAppConfig(app); + this.firebaseDependencies = { + app, + appConfig, + installations, + analyticsProvider + }; + } + _delete() { + return Promise.resolve(); + } +} + +/** + * @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. + */ +async function registerDefaultSw(messaging) { + try { + messaging.swRegistration = await navigator.serviceWorker.register(DEFAULT_SW_PATH, { + scope: DEFAULT_SW_SCOPE + }); + // The timing when browser updates sw when sw has an update is unreliable from experiment. It + // leads to version conflict when the SDK upgrades to a newer version in the main page, but sw + // is stuck with the old version. For example, + // https://github.com/firebase/firebase-js-sdk/issues/2590 The following line reliably updates + // sw if there was an update. + messaging.swRegistration.update().catch(() => { + /* it is non blocking and we don't care if it failed */ + }); + await waitForRegistrationActive(messaging.swRegistration); + } + catch (e) { + throw ERROR_FACTORY.create("failed-service-worker-registration" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */, { + browserErrorMessage: e?.message + }); + } +} +/** + * Waits for registration to become active. MDN documentation claims that + * a service worker registration should be ready to use after awaiting + * navigator.serviceWorker.register() but that doesn't seem to be the case in + * practice, causing the SDK to throw errors when calling + * swRegistration.pushManager.subscribe() too soon after register(). The only + * solution seems to be waiting for the service worker registration `state` + * to become "active". + */ +async function waitForRegistrationActive(registration) { + return new Promise((resolve, reject) => { + const rejectTimeout = setTimeout(() => reject(new Error(`Service worker not registered after ${DEFAULT_REGISTRATION_TIMEOUT} ms`)), DEFAULT_REGISTRATION_TIMEOUT); + const incomingSw = registration.installing || registration.waiting; + if (registration.active) { + clearTimeout(rejectTimeout); + resolve(); + } + else if (incomingSw) { + incomingSw.onstatechange = ev => { + if (ev.target?.state === 'activated') { + incomingSw.onstatechange = null; + clearTimeout(rejectTimeout); + resolve(); + } + }; + } + else { + clearTimeout(rejectTimeout); + reject(new Error('No incoming service worker found.')); + } + }); +} + +/** + * @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. + */ +async function updateSwReg(messaging, swRegistration) { + if (!swRegistration && !messaging.swRegistration) { + await registerDefaultSw(messaging); + } + if (!swRegistration && !!messaging.swRegistration) { + return; + } + if (!(swRegistration instanceof ServiceWorkerRegistration)) { + throw ERROR_FACTORY.create("invalid-sw-registration" /* ErrorCode.INVALID_SW_REGISTRATION */); + } + messaging.swRegistration = swRegistration; +} + +/** + * @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. + */ +async function updateVapidKey(messaging, vapidKey) { + if (!!vapidKey) { + messaging.vapidKey = vapidKey; + } + else if (!messaging.vapidKey) { + messaging.vapidKey = DEFAULT_VAPID_KEY; + } +} + +/** + * @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. + */ +async function getToken$1(messaging, options) { + if (!navigator) { + throw ERROR_FACTORY.create("only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */); + } + if (Notification.permission === 'default') { + await Notification.requestPermission(); + } + if (Notification.permission !== 'granted') { + throw ERROR_FACTORY.create("permission-blocked" /* ErrorCode.PERMISSION_BLOCKED */); + } + await updateVapidKey(messaging, options?.vapidKey); + await updateSwReg(messaging, options?.serviceWorkerRegistration); + return getTokenInternal(messaging); +} + +/** + * @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. + */ +async function logToScion(messaging, messageType, data) { + const eventType = getEventType(messageType); + const analytics = await messaging.firebaseDependencies.analyticsProvider.get(); + analytics.logEvent(eventType, { + /* eslint-disable camelcase */ + message_id: data[CONSOLE_CAMPAIGN_ID], + message_name: data[CONSOLE_CAMPAIGN_NAME], + message_time: data[CONSOLE_CAMPAIGN_TIME], + message_device_time: Math.floor(Date.now() / 1000) + /* eslint-enable camelcase */ + }); +} +function getEventType(messageType) { + switch (messageType) { + case MessageType.NOTIFICATION_CLICKED: + return 'notification_open'; + case MessageType.PUSH_RECEIVED: + return 'notification_foreground'; + default: + throw new Error(); + } +} + +/** + * @license + * Copyright 2017 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +async function messageEventListener(messaging, event) { + const internalPayload = event.data; + if (!internalPayload.isFirebaseMessaging) { + return; + } + if (messaging.onMessageHandler && + internalPayload.messageType === MessageType.PUSH_RECEIVED) { + if (typeof messaging.onMessageHandler === 'function') { + messaging.onMessageHandler(externalizePayload(internalPayload)); + } + else { + messaging.onMessageHandler.next(externalizePayload(internalPayload)); + } + } + // Log to Scion if applicable + const dataPayload = internalPayload.data; + if (isConsoleMessage(dataPayload) && + dataPayload[CONSOLE_CAMPAIGN_ANALYTICS_ENABLED] === '1') { + await logToScion(messaging, internalPayload.messageType, dataPayload); + } +} + +const name = "@firebase/messaging"; +const version = "0.12.23"; + +/** + * @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. + */ +const WindowMessagingFactory = (container) => { + const messaging = new MessagingService(container.getProvider('app').getImmediate(), container.getProvider('installations-internal').getImmediate(), container.getProvider('analytics-internal')); + navigator.serviceWorker.addEventListener('message', e => messageEventListener(messaging, e)); + return messaging; +}; +const WindowMessagingInternalFactory = (container) => { + const messaging = container + .getProvider('messaging') + .getImmediate(); + const messagingInternal = { + getToken: (options) => getToken$1(messaging, options) + }; + return messagingInternal; +}; +function registerMessagingInWindow() { + app._registerComponent(new component.Component('messaging', WindowMessagingFactory, "PUBLIC" /* ComponentType.PUBLIC */)); + app._registerComponent(new component.Component('messaging-internal', WindowMessagingInternalFactory, "PRIVATE" /* ComponentType.PRIVATE */)); + app.registerVersion(name, version); + // BUILD_TARGET will be replaced by values like esm, cjs, etc during the compilation + app.registerVersion(name, version, 'cjs2020'); +} + +/** + * @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. + */ +/** + * Checks if all required APIs exist in the browser. + * @returns a Promise that resolves to a boolean. + * + * @public + */ +async function isWindowSupported() { + try { + // This throws if open() is unsupported, so adding it to the conditional + // statement below can cause an uncaught error. + await util.validateIndexedDBOpenable(); + } + catch (e) { + return false; + } + // firebase-js-sdk/issues/2393 reveals that idb#open in Safari iframe and Firefox private browsing + // might be prohibited to run. In these contexts, an error would be thrown during the messaging + // instantiating phase, informing the developers to import/call isSupported for special handling. + return (typeof window !== 'undefined' && + util.isIndexedDBAvailable() && + util.areCookiesEnabled() && + 'serviceWorker' in navigator && + 'PushManager' in window && + 'Notification' in window && + 'fetch' in window && + ServiceWorkerRegistration.prototype.hasOwnProperty('showNotification') && + PushSubscription.prototype.hasOwnProperty('getKey')); +} + +/** + * @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. + */ +async function deleteToken$1(messaging) { + if (!navigator) { + throw ERROR_FACTORY.create("only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */); + } + if (!messaging.swRegistration) { + await registerDefaultSw(messaging); + } + return deleteTokenInternal(messaging); +} + +/** + * @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. + */ +function onMessage$1(messaging, nextOrObserver) { + if (!navigator) { + throw ERROR_FACTORY.create("only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */); + } + messaging.onMessageHandler = nextOrObserver; + return () => { + messaging.onMessageHandler = null; + }; +} + +/** + * @license + * Copyright 2017 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * Retrieves a Firebase Cloud Messaging instance. + * + * @returns The Firebase Cloud Messaging instance associated with the provided firebase app. + * + * @public + */ +function getMessagingInWindow(app$1 = app.getApp()) { + // Conscious decision to make this async check non-blocking during the messaging instance + // initialization phase for performance consideration. An error would be thrown latter for + // developer's information. Developers can then choose to import and call `isSupported` for + // special handling. + isWindowSupported().then(isSupported => { + // If `isWindowSupported()` resolved, but returned false. + if (!isSupported) { + throw ERROR_FACTORY.create("unsupported-browser" /* ErrorCode.UNSUPPORTED_BROWSER */); + } + }, _ => { + // If `isWindowSupported()` rejected. + throw ERROR_FACTORY.create("indexed-db-unsupported" /* ErrorCode.INDEXED_DB_UNSUPPORTED */); + }); + return app._getProvider(util.getModularInstance(app$1), 'messaging').getImmediate(); +} +/** + * Subscribes the {@link Messaging} instance to push notifications. Returns a Firebase Cloud + * Messaging registration token that can be used to send push messages to that {@link Messaging} + * instance. + * + * If notification permission isn't already granted, this method asks the user for permission. The + * returned promise rejects if the user does not allow the app to show notifications. + * + * @param messaging - The {@link Messaging} instance. + * @param options - Provides an optional vapid key and an optional service worker registration. + * + * @returns The promise resolves with an FCM registration token. + * + * @public + */ +async function getToken(messaging, options) { + messaging = util.getModularInstance(messaging); + return getToken$1(messaging, options); +} +/** + * Deletes the registration token associated with this {@link Messaging} instance and unsubscribes + * the {@link Messaging} instance from the push subscription. + * + * @param messaging - The {@link Messaging} instance. + * + * @returns The promise resolves when the token has been successfully deleted. + * + * @public + */ +function deleteToken(messaging) { + messaging = util.getModularInstance(messaging); + return deleteToken$1(messaging); +} +/** + * When a push message is received and the user is currently on a page for your origin, the + * message is passed to the page and an `onMessage()` event is dispatched with the payload of + * the push message. + * + * + * @param messaging - The {@link Messaging} instance. + * @param nextOrObserver - This function, or observer object with `next` defined, + * is called when a message is received and the user is currently viewing your page. + * @returns To stop listening for messages execute this returned function. + * + * @public + */ +function onMessage(messaging, nextOrObserver) { + messaging = util.getModularInstance(messaging); + return onMessage$1(messaging, nextOrObserver); +} + +/** + * The Firebase Cloud Messaging Web SDK. + * This SDK does not work in a Node.js environment. + * + * @packageDocumentation + */ +registerMessagingInWindow(); + +exports.deleteToken = deleteToken; +exports.getMessaging = getMessagingInWindow; +exports.getToken = getToken; +exports.isSupported = isWindowSupported; +exports.onMessage = onMessage; +//# sourceMappingURL=index.cjs.js.map -- cgit v1.2.3