@firebase/analytics 0.7.10 → 0.7.11-canary.13550089f

package/dist/esm/index.esm2017.js

@@ -234,6 +234,10 @@ measurementIdToAppId) {
                 // If CONFIG, second arg must be measurementId.
                 await gtagOnConfig(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId, idOrNameOrParams, gtagParams);
             }
+            else if (command === "consent" /* CONSENT */) {
+                // If CONFIG, second arg must be measurementId.
+                gtagCore("consent" /* CONSENT */, 'update', gtagParams);
+            }
             else {
                 // If SET, second arg must be params.
                 gtagCore("set" /* SET */, idOrNameOrParams);
@@ -456,6 +460,7 @@ retryData = defaultRetryData, timeoutMillis) {
  */
 async function attemptFetchDynamicConfigWithRetry(appFields, { throttleEndTimeMillis, backoffCount }, signal, retryData = defaultRetryData // for testing
 ) {
+    var _a, _b;
     const { appId, measurementId } = appFields;
     // Starts with a (potentially zero) timeout to support resumption from stored state.
     // Ensures the throttle end time is honored if the last attempt timed out.
@@ -467,7 +472,7 @@ async function attemptFetchDynamicConfigWithRetry(appFields, { throttleEndTimeMi
         if (measurementId) {
             logger.warn(`Timed out fetching this Firebase app's measurement ID from the server.` +
                 ` Falling back to the measurement ID ${measurementId}` +
-                ` provided in the "measurementId" field in the local Firebase config. [${e.message}]`);
+                ` provided in the "measurementId" field in the local Firebase config. [${(_a = e) === null || _a === void 0 ? void 0 : _a.message}]`);
             return { appId, measurementId };
         }
         throw e;
@@ -479,19 +484,20 @@ async function attemptFetchDynamicConfigWithRetry(appFields, { throttleEndTimeMi
         return response;
     }
     catch (e) {
-        if (!isRetriableError(e)) {
+        const error = e;
+        if (!isRetriableError(error)) {
             retryData.deleteThrottleMetadata(appId);
             if (measurementId) {
                 logger.warn(`Failed to fetch this Firebase app's measurement ID from the server.` +
                     ` Falling back to the measurement ID ${measurementId}` +
-                    ` provided in the "measurementId" field in the local Firebase config. [${e.message}]`);
+                    ` provided in the "measurementId" field in the local Firebase config. [${error === null || error === void 0 ? void 0 : error.message}]`);
                 return { appId, measurementId };
             }
             else {
                 throw e;
             }
         }
-        const backoffMillis = Number(e.customData.httpStatus) === 503
+        const backoffMillis = Number((_b = error === null || error === void 0 ? void 0 : error.customData) === null || _b === void 0 ? void 0 : _b.httpStatus) === 503
             ? calculateBackoffMillis(backoffCount, retryData.intervalMillis, LONG_RETRY_FACTOR)
             : calculateBackoffMillis(backoffCount, retryData.intervalMillis);
         // Increments backoff state.
@@ -566,6 +572,141 @@ class AnalyticsAbortSignal {
     }
 }
 
+/**
+ * @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.
+ */
+/**
+ * Event parameters to set on 'gtag' during initialization.
+ */
+let defaultEventParametersForInit;
+/**
+ * Logs an analytics event through the Firebase SDK.
+ *
+ * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
+ * @param eventName Google Analytics event name, choose from standard list or use a custom string.
+ * @param eventParams Analytics event parameters.
+ */
+async function logEvent$1(gtagFunction, initializationPromise, eventName, eventParams, options) {
+    if (options && options.global) {
+        gtagFunction("event" /* EVENT */, eventName, eventParams);
+        return;
+    }
+    else {
+        const measurementId = await initializationPromise;
+        const params = Object.assign(Object.assign({}, eventParams), { 'send_to': measurementId });
+        gtagFunction("event" /* EVENT */, eventName, params);
+    }
+}
+/**
+ * Set screen_name parameter for this Google Analytics ID.
+ *
+ * @deprecated Use {@link logEvent} with `eventName` as 'screen_view' and add relevant `eventParams`.
+ * See {@link https://firebase.google.com/docs/analytics/screenviews | Track Screenviews}.
+ *
+ * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
+ * @param screenName Screen name string to set.
+ */
+async function setCurrentScreen$1(gtagFunction, initializationPromise, screenName, options) {
+    if (options && options.global) {
+        gtagFunction("set" /* SET */, { 'screen_name': screenName });
+        return Promise.resolve();
+    }
+    else {
+        const measurementId = await initializationPromise;
+        gtagFunction("config" /* CONFIG */, measurementId, {
+            update: true,
+            'screen_name': screenName
+        });
+    }
+}
+/**
+ * Set user_id parameter for this Google Analytics ID.
+ *
+ * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
+ * @param id User ID string to set
+ */
+async function setUserId$1(gtagFunction, initializationPromise, id, options) {
+    if (options && options.global) {
+        gtagFunction("set" /* SET */, { 'user_id': id });
+        return Promise.resolve();
+    }
+    else {
+        const measurementId = await initializationPromise;
+        gtagFunction("config" /* CONFIG */, measurementId, {
+            update: true,
+            'user_id': id
+        });
+    }
+}
+/**
+ * Set all other user properties other than user_id and screen_name.
+ *
+ * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
+ * @param properties Map of user properties to set
+ */
+async function setUserProperties$1(gtagFunction, initializationPromise, properties, options) {
+    if (options && options.global) {
+        const flatProperties = {};
+        for (const key of Object.keys(properties)) {
+            // use dot notation for merge behavior in gtag.js
+            flatProperties[`user_properties.${key}`] = properties[key];
+        }
+        gtagFunction("set" /* SET */, flatProperties);
+        return Promise.resolve();
+    }
+    else {
+        const measurementId = await initializationPromise;
+        gtagFunction("config" /* CONFIG */, measurementId, {
+            update: true,
+            'user_properties': properties
+        });
+    }
+}
+/**
+ * Set whether collection is enabled for this ID.
+ *
+ * @param enabled If true, collection is enabled for this ID.
+ */
+async function setAnalyticsCollectionEnabled$1(initializationPromise, enabled) {
+    const measurementId = await initializationPromise;
+    window[`ga-disable-${measurementId}`] = !enabled;
+}
+/**
+ * Consent parameters to default to during 'gtag' initialization.
+ */
+let defaultConsentSettingsForInit;
+/**
+ * Sets the variable {@link defaultConsentSettingsForInit} for use in the initialization of
+ * analytics.
+ *
+ * @param consentSettings Maps the applicable end user consent state for gtag.js.
+ */
+function _setConsentDefaultForInit(consentSettings) {
+    defaultConsentSettingsForInit = consentSettings;
+}
+/**
+ * Sets the variable `defaultEventParametersForInit` for use in the initialization of
+ * analytics.
+ *
+ * @param customParams Any custom params the user may pass to gtag.js.
+ */
+function _setDefaultEventParametersForInit(customParams) {
+    defaultEventParametersForInit = customParams;
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -583,6 +724,7 @@ class AnalyticsAbortSignal {
  * limitations under the License.
  */
 async function validateIndexedDB() {
+    var _a;
     if (!isIndexedDBAvailable()) {
         logger.warn(ERROR_FACTORY.create("indexeddb-unavailable" /* INDEXEDDB_UNAVAILABLE */, {
             errorInfo: 'IndexedDB is not available in this environment.'
@@ -595,7 +737,7 @@ async function validateIndexedDB() {
         }
         catch (e) {
             logger.warn(ERROR_FACTORY.create("indexeddb-unavailable" /* INDEXEDDB_UNAVAILABLE */, {
-                errorInfo: e
+                errorInfo: (_a = e) === null || _a === void 0 ? void 0 : _a.toString()
             }).message);
             return false;
         }
@@ -650,6 +792,11 @@ async function _initializeAnalytics(app, dynamicConfigPromisesList, measurementI
     if (!findGtagScriptOnPage()) {
         insertScriptTag(dataLayerName, dynamicConfig.measurementId);
     }
+    // Detects if there are consent settings that need to be configured.
+    if (defaultConsentSettingsForInit) {
+        gtagCore("consent" /* CONSENT */, 'default', defaultConsentSettingsForInit);
+        _setConsentDefaultForInit(undefined);
+    }
     // This command initializes gtag.js and only needs to be called once for the entire web app,
     // but since it is idempotent, we can call it multiple times.
     // We keep it together with other initialization logic for better code structure.
@@ -669,6 +816,11 @@ async function _initializeAnalytics(app, dynamicConfigPromisesList, measurementI
     // Note: This will trigger a page_view event unless 'send_page_view' is set to false in
     // `configProperties`.
     gtagCore("config" /* CONFIG */, dynamicConfig.measurementId, configProperties);
+    // Detects if there is data that will be set on every event logged from the SDK.
+    if (defaultEventParametersForInit) {
+        gtagCore("set" /* SET */, defaultEventParametersForInit);
+        _setDefaultEventParametersForInit(undefined);
+    }
     return dynamicConfig.measurementId;
 }
 
@@ -829,115 +981,6 @@ function factory(app, installations, options) {
     return analyticsInstance;
 }
 
-/**
- * @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.
- */
-/**
- * Logs an analytics event through the Firebase SDK.
- *
- * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
- * @param eventName Google Analytics event name, choose from standard list or use a custom string.
- * @param eventParams Analytics event parameters.
- */
-async function logEvent$1(gtagFunction, initializationPromise, eventName, eventParams, options) {
-    if (options && options.global) {
-        gtagFunction("event" /* EVENT */, eventName, eventParams);
-        return;
-    }
-    else {
-        const measurementId = await initializationPromise;
-        const params = Object.assign(Object.assign({}, eventParams), { 'send_to': measurementId });
-        gtagFunction("event" /* EVENT */, eventName, params);
-    }
-}
-/**
- * Set screen_name parameter for this Google Analytics ID.
- *
- * @deprecated Use {@link logEvent} with `eventName` as 'screen_view' and add relevant `eventParams`.
- * See {@link https://firebase.google.com/docs/analytics/screenviews | Track Screenviews}.
- *
- * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
- * @param screenName Screen name string to set.
- */
-async function setCurrentScreen$1(gtagFunction, initializationPromise, screenName, options) {
-    if (options && options.global) {
-        gtagFunction("set" /* SET */, { 'screen_name': screenName });
-        return Promise.resolve();
-    }
-    else {
-        const measurementId = await initializationPromise;
-        gtagFunction("config" /* CONFIG */, measurementId, {
-            update: true,
-            'screen_name': screenName
-        });
-    }
-}
-/**
- * Set user_id parameter for this Google Analytics ID.
- *
- * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
- * @param id User ID string to set
- */
-async function setUserId$1(gtagFunction, initializationPromise, id, options) {
-    if (options && options.global) {
-        gtagFunction("set" /* SET */, { 'user_id': id });
-        return Promise.resolve();
-    }
-    else {
-        const measurementId = await initializationPromise;
-        gtagFunction("config" /* CONFIG */, measurementId, {
-            update: true,
-            'user_id': id
-        });
-    }
-}
-/**
- * Set all other user properties other than user_id and screen_name.
- *
- * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
- * @param properties Map of user properties to set
- */
-async function setUserProperties$1(gtagFunction, initializationPromise, properties, options) {
-    if (options && options.global) {
-        const flatProperties = {};
-        for (const key of Object.keys(properties)) {
-            // use dot notation for merge behavior in gtag.js
-            flatProperties[`user_properties.${key}`] = properties[key];
-        }
-        gtagFunction("set" /* SET */, flatProperties);
-        return Promise.resolve();
-    }
-    else {
-        const measurementId = await initializationPromise;
-        gtagFunction("config" /* CONFIG */, measurementId, {
-            update: true,
-            'user_properties': properties
-        });
-    }
-}
-/**
- * Set whether collection is enabled for this ID.
- *
- * @param enabled If true, collection is enabled for this ID.
- */
-async function setAnalyticsCollectionEnabled$1(initializationPromise, enabled) {
-    const measurementId = await initializationPromise;
-    window[`ga-disable-${measurementId}`] = !enabled;
-}
-
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * Returns an {@link Analytics} instance for the given app.
@@ -1055,6 +1098,22 @@ function setAnalyticsCollectionEnabled(analyticsInstance, enabled) {
     analyticsInstance = getModularInstance(analyticsInstance);
     setAnalyticsCollectionEnabled$1(initializationPromisesMap[analyticsInstance.app.options.appId], enabled).catch(e => logger.error(e));
 }
+/**
+ * Adds data that will be set on every event logged from the SDK, including automatic ones.
+ * With gtag's "set" command, the values passed persist on the current page and are passed with
+ * all subsequent events.
+ * @public
+ * @param customParams - Any custom params the user may pass to gtag.js.
+ */
+function setDefaultEventParameters(customParams) {
+    // Check if reference to existing gtag function on window object exists
+    if (wrappedGtagFunction) {
+        wrappedGtagFunction("set" /* SET */, customParams);
+    }
+    else {
+        _setDefaultEventParametersForInit(customParams);
+    }
+}
 /**
  * Sends a Google Analytics event with given `eventParams`. This method
  * automatically associates this logged event with this Firebase web
@@ -1069,10 +1128,28 @@ function setAnalyticsCollectionEnabled(analyticsInstance, enabled) {
 function logEvent(analyticsInstance, eventName, eventParams, options) {
     analyticsInstance = getModularInstance(analyticsInstance);
     logEvent$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], eventName, eventParams, options).catch(e => logger.error(e));
+}
+/**
+ * Sets the applicable end user consent state for this web app across all gtag references once
+ * Firebase Analytics is initialized.
+ *
+ * Use the {@link ConsentSettings} to specify individual consent type values. By default consent
+ * types are set to "granted".
+ * @public
+ * @param consentSettings - Maps the applicable end user consent state for gtag.js.
+ */
+function setConsent(consentSettings) {
+    // Check if reference to existing gtag function on window object exists
+    if (wrappedGtagFunction) {
+        wrappedGtagFunction("consent" /* CONSENT */, 'update', consentSettings);
+    }
+    else {
+        _setConsentDefaultForInit(consentSettings);
+    }
 }
 
 const name = "@firebase/analytics";
-const version = "0.7.10";
+const version = "0.7.11-canary.13550089f";
 
 /**
  * Firebase Analytics
@@ -1108,5 +1185,5 @@ function registerAnalytics() {
 }
 registerAnalytics();
 
-export { getAnalytics, initializeAnalytics, isSupported, logEvent, setAnalyticsCollectionEnabled, setCurrentScreen, setUserId, setUserProperties, settings };
+export { getAnalytics, initializeAnalytics, isSupported, logEvent, setAnalyticsCollectionEnabled, setConsent, setCurrentScreen, setDefaultEventParameters, setUserId, setUserProperties, settings };
 //# sourceMappingURL=index.esm2017.js.map