@serwist/google-analytics 8.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Google LLC, 2019 ShadowWalker w@weiw.io https://weiw.io, 2023 Serwist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-google-analytics

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { GoogleAnalyticsInitializeOptions } from "./initialize.js";
+import { initialize } from "./initialize.js";
+export { initialize };
+export type { GoogleAnalyticsInitializeOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAE,UAAU,EAAE,CAAC;AACtB,YAAY,EAAE,gCAAgC,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,166 @@
+import { BackgroundSyncPlugin } from '@serwist/background-sync';
+import { privateCacheNames, logger, getFriendlyURL } from '@serwist/core/internal';
+import { Router, Route } from '@serwist/routing';
+import { NetworkOnly, NetworkFirst } from '@serwist/strategies';
+
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ const QUEUE_NAME = "serwist-google-analytics";
+const MAX_RETENTION_TIME = 60 * 48; // Two days in minutes
+const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
+const GTM_HOST = "www.googletagmanager.com";
+const ANALYTICS_JS_PATH = "/analytics.js";
+const GTAG_JS_PATH = "/gtag/js";
+const GTM_JS_PATH = "/gtm.js";
+// This RegExp matches all known Measurement Protocol single-hit collect
+// endpoints. Most of the time the default path (/collect) is used, but
+// occasionally an experimental endpoint is used when testing new features,
+// (e.g. /r/collect or /j/collect)
+const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;
+
+/**
+ * Creates the requestWillDequeue callback to be used with the background
+ * sync plugin. The callback takes the failed request and adds the
+ * `qt` param based on the current time, as well as applies any other
+ * user-defined hit modifications.
+ *
+ * @param config
+ * @returns The requestWillDequeue callback function.
+ * @private
+ */ const createOnSyncCallback = (config)=>{
+    return async ({ queue })=>{
+        let entry;
+        while(entry = await queue.shiftRequest()){
+            const { request, timestamp } = entry;
+            const url = new URL(request.url);
+            try {
+                // Measurement protocol requests can set their payload parameters in
+                // either the URL query string (for GET requests) or the POST body.
+                const params = request.method === "POST" ? new URLSearchParams(await request.clone().text()) : url.searchParams;
+                // Calculate the qt param, accounting for the fact that an existing
+                // qt param may be present and should be updated rather than replaced.
+                const originalHitTime = timestamp - (Number(params.get("qt")) || 0);
+                const queueTime = Date.now() - originalHitTime;
+                // Set the qt param prior to applying hitFilter or parameterOverrides.
+                params.set("qt", String(queueTime));
+                // Apply `parameterOverrides`, if set.
+                if (config.parameterOverrides) {
+                    for (const param of Object.keys(config.parameterOverrides)){
+                        const value = config.parameterOverrides[param];
+                        params.set(param, value);
+                    }
+                }
+                // Apply `hitFilter`, if set.
+                if (typeof config.hitFilter === "function") {
+                    config.hitFilter.call(null, params);
+                }
+                // Retry the fetch. Ignore URL search params from the URL as they're
+                // now in the post body.
+                await fetch(new Request(url.origin + url.pathname, {
+                    body: params.toString(),
+                    method: "POST",
+                    mode: "cors",
+                    credentials: "omit",
+                    headers: {
+                        "Content-Type": "text/plain"
+                    }
+                }));
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(url.href)}' ` + `has been replayed`);
+                }
+            } catch (err) {
+                await queue.unshiftRequest(entry);
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(url.href)}' ` + `failed to replay, putting it back in the queue.`);
+                }
+                throw err;
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log(`All Google Analytics request successfully replayed; ` + `the queue is now empty!`);
+        }
+    };
+};
+/**
+ * Creates GET and POST routes to catch failed Measurement Protocol hits.
+ *
+ * @param bgSyncPlugin
+ * @returns The created routes.
+ * @private
+ */ const createCollectRoutes = (bgSyncPlugin)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
+    const handler = new NetworkOnly({
+        plugins: [
+            bgSyncPlugin
+        ]
+    });
+    return [
+        new Route(match, handler, "GET"),
+        new Route(match, handler, "POST")
+    ];
+};
+/**
+ * Creates a route with a network first strategy for the analytics.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createAnalyticsJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+/**
+ * Creates a route with a network first strategy for the gtag.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createGtagJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+/**
+ * Creates a route with a network first strategy for the gtm.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createGtmJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+/**
+ * @param options
+ */ const initialize = (options = {})=>{
+    const cacheName = privateCacheNames.getGoogleAnalyticsName(options.cacheName);
+    const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
+        maxRetentionTime: MAX_RETENTION_TIME,
+        onSync: createOnSyncCallback(options)
+    });
+    const routes = [
+        createGtmJsRoute(cacheName),
+        createAnalyticsJsRoute(cacheName),
+        createGtagJsRoute(cacheName),
+        ...createCollectRoutes(bgSyncPlugin)
+    ];
+    const router = new Router();
+    for (const route of routes){
+        router.registerRoute(route);
+    }
+    router.addFetchListener();
+};
+
+export { initialize };

package/dist/index.old.cjs

@@ -0,0 +1,168 @@
+'use strict';
+
+var backgroundSync = require('@serwist/background-sync');
+var internal = require('@serwist/core/internal');
+var routing = require('@serwist/routing');
+var strategies = require('@serwist/strategies');
+
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ const QUEUE_NAME = "serwist-google-analytics";
+const MAX_RETENTION_TIME = 60 * 48; // Two days in minutes
+const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
+const GTM_HOST = "www.googletagmanager.com";
+const ANALYTICS_JS_PATH = "/analytics.js";
+const GTAG_JS_PATH = "/gtag/js";
+const GTM_JS_PATH = "/gtm.js";
+// This RegExp matches all known Measurement Protocol single-hit collect
+// endpoints. Most of the time the default path (/collect) is used, but
+// occasionally an experimental endpoint is used when testing new features,
+// (e.g. /r/collect or /j/collect)
+const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;
+
+/**
+ * Creates the requestWillDequeue callback to be used with the background
+ * sync plugin. The callback takes the failed request and adds the
+ * `qt` param based on the current time, as well as applies any other
+ * user-defined hit modifications.
+ *
+ * @param config
+ * @returns The requestWillDequeue callback function.
+ * @private
+ */ const createOnSyncCallback = (config)=>{
+    return async ({ queue })=>{
+        let entry;
+        while(entry = await queue.shiftRequest()){
+            const { request, timestamp } = entry;
+            const url = new URL(request.url);
+            try {
+                // Measurement protocol requests can set their payload parameters in
+                // either the URL query string (for GET requests) or the POST body.
+                const params = request.method === "POST" ? new URLSearchParams(await request.clone().text()) : url.searchParams;
+                // Calculate the qt param, accounting for the fact that an existing
+                // qt param may be present and should be updated rather than replaced.
+                const originalHitTime = timestamp - (Number(params.get("qt")) || 0);
+                const queueTime = Date.now() - originalHitTime;
+                // Set the qt param prior to applying hitFilter or parameterOverrides.
+                params.set("qt", String(queueTime));
+                // Apply `parameterOverrides`, if set.
+                if (config.parameterOverrides) {
+                    for (const param of Object.keys(config.parameterOverrides)){
+                        const value = config.parameterOverrides[param];
+                        params.set(param, value);
+                    }
+                }
+                // Apply `hitFilter`, if set.
+                if (typeof config.hitFilter === "function") {
+                    config.hitFilter.call(null, params);
+                }
+                // Retry the fetch. Ignore URL search params from the URL as they're
+                // now in the post body.
+                await fetch(new Request(url.origin + url.pathname, {
+                    body: params.toString(),
+                    method: "POST",
+                    mode: "cors",
+                    credentials: "omit",
+                    headers: {
+                        "Content-Type": "text/plain"
+                    }
+                }));
+                if (process.env.NODE_ENV !== "production") {
+                    internal.logger.log(`Request for '${internal.getFriendlyURL(url.href)}' ` + `has been replayed`);
+                }
+            } catch (err) {
+                await queue.unshiftRequest(entry);
+                if (process.env.NODE_ENV !== "production") {
+                    internal.logger.log(`Request for '${internal.getFriendlyURL(url.href)}' ` + `failed to replay, putting it back in the queue.`);
+                }
+                throw err;
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            internal.logger.log(`All Google Analytics request successfully replayed; ` + `the queue is now empty!`);
+        }
+    };
+};
+/**
+ * Creates GET and POST routes to catch failed Measurement Protocol hits.
+ *
+ * @param bgSyncPlugin
+ * @returns The created routes.
+ * @private
+ */ const createCollectRoutes = (bgSyncPlugin)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
+    const handler = new strategies.NetworkOnly({
+        plugins: [
+            bgSyncPlugin
+        ]
+    });
+    return [
+        new routing.Route(match, handler, "GET"),
+        new routing.Route(match, handler, "POST")
+    ];
+};
+/**
+ * Creates a route with a network first strategy for the analytics.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createAnalyticsJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
+    const handler = new strategies.NetworkFirst({
+        cacheName
+    });
+    return new routing.Route(match, handler, "GET");
+};
+/**
+ * Creates a route with a network first strategy for the gtag.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createGtagJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
+    const handler = new strategies.NetworkFirst({
+        cacheName
+    });
+    return new routing.Route(match, handler, "GET");
+};
+/**
+ * Creates a route with a network first strategy for the gtm.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createGtmJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
+    const handler = new strategies.NetworkFirst({
+        cacheName
+    });
+    return new routing.Route(match, handler, "GET");
+};
+/**
+ * @param options
+ */ const initialize = (options = {})=>{
+    const cacheName = internal.privateCacheNames.getGoogleAnalyticsName(options.cacheName);
+    const bgSyncPlugin = new backgroundSync.BackgroundSyncPlugin(QUEUE_NAME, {
+        maxRetentionTime: MAX_RETENTION_TIME,
+        onSync: createOnSyncCallback(options)
+    });
+    const routes = [
+        createGtmJsRoute(cacheName),
+        createAnalyticsJsRoute(cacheName),
+        createGtagJsRoute(cacheName),
+        ...createCollectRoutes(bgSyncPlugin)
+    ];
+    const router = new routing.Router();
+    for (const route of routes){
+        router.registerRoute(route);
+    }
+    router.addFetchListener();
+};
+
+exports.initialize = initialize;

package/dist/initialize.d.ts

@@ -0,0 +1,27 @@
+export interface GoogleAnalyticsInitializeOptions {
+    /**
+     * The cache name to store and retrieve analytics.js. Defaults to the cache names provided by `@serwist/core`.
+     */
+    cacheName?: string;
+    /**
+     * [Measurement Protocol parameters](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters),
+     * expressed as key/value pairs, to be added to replayed Google Analytics
+     * requests. This can be used to, e.g., set a custom dimension indicating
+     * that the request was replayed.
+     */
+    parameterOverrides?: {
+        [paramName: string]: string;
+    };
+    /**
+     * A function that allows you to modify the hit parameters prior to replaying
+     * the hit. The function is invoked with the original hit's URLSearchParams
+     * object as its only argument.
+     */
+    hitFilter?: (params: URLSearchParams) => void;
+}
+/**
+ * @param options
+ */
+declare const initialize: (options?: GoogleAnalyticsInitializeOptions) => void;
+export { initialize };
+//# sourceMappingURL=initialize.d.ts.map

package/dist/initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../src/initialize.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,gCAAgC;IAC/C;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE;QAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACrD;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/C;AAyID;;GAEG;AACH,QAAA,MAAM,UAAU,aAAa,gCAAgC,KAAQ,IAgBpE,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/initialize.js

@@ -0,0 +1,166 @@
+import { BackgroundSyncPlugin } from '@serwist/background-sync';
+import { privateCacheNames, logger, getFriendlyURL } from '@serwist/core/internal';
+import { Router, Route } from '@serwist/routing';
+import { NetworkOnly, NetworkFirst } from '@serwist/strategies';
+
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ const QUEUE_NAME = "serwist-google-analytics";
+const MAX_RETENTION_TIME = 60 * 48; // Two days in minutes
+const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
+const GTM_HOST = "www.googletagmanager.com";
+const ANALYTICS_JS_PATH = "/analytics.js";
+const GTAG_JS_PATH = "/gtag/js";
+const GTM_JS_PATH = "/gtm.js";
+// This RegExp matches all known Measurement Protocol single-hit collect
+// endpoints. Most of the time the default path (/collect) is used, but
+// occasionally an experimental endpoint is used when testing new features,
+// (e.g. /r/collect or /j/collect)
+const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;
+
+/**
+ * Creates the requestWillDequeue callback to be used with the background
+ * sync plugin. The callback takes the failed request and adds the
+ * `qt` param based on the current time, as well as applies any other
+ * user-defined hit modifications.
+ *
+ * @param config
+ * @returns The requestWillDequeue callback function.
+ * @private
+ */ const createOnSyncCallback = (config)=>{
+    return async ({ queue })=>{
+        let entry;
+        while(entry = await queue.shiftRequest()){
+            const { request, timestamp } = entry;
+            const url = new URL(request.url);
+            try {
+                // Measurement protocol requests can set their payload parameters in
+                // either the URL query string (for GET requests) or the POST body.
+                const params = request.method === "POST" ? new URLSearchParams(await request.clone().text()) : url.searchParams;
+                // Calculate the qt param, accounting for the fact that an existing
+                // qt param may be present and should be updated rather than replaced.
+                const originalHitTime = timestamp - (Number(params.get("qt")) || 0);
+                const queueTime = Date.now() - originalHitTime;
+                // Set the qt param prior to applying hitFilter or parameterOverrides.
+                params.set("qt", String(queueTime));
+                // Apply `parameterOverrides`, if set.
+                if (config.parameterOverrides) {
+                    for (const param of Object.keys(config.parameterOverrides)){
+                        const value = config.parameterOverrides[param];
+                        params.set(param, value);
+                    }
+                }
+                // Apply `hitFilter`, if set.
+                if (typeof config.hitFilter === "function") {
+                    config.hitFilter.call(null, params);
+                }
+                // Retry the fetch. Ignore URL search params from the URL as they're
+                // now in the post body.
+                await fetch(new Request(url.origin + url.pathname, {
+                    body: params.toString(),
+                    method: "POST",
+                    mode: "cors",
+                    credentials: "omit",
+                    headers: {
+                        "Content-Type": "text/plain"
+                    }
+                }));
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(url.href)}' ` + `has been replayed`);
+                }
+            } catch (err) {
+                await queue.unshiftRequest(entry);
+                if (process.env.NODE_ENV !== "production") {
+                    logger.log(`Request for '${getFriendlyURL(url.href)}' ` + `failed to replay, putting it back in the queue.`);
+                }
+                throw err;
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            logger.log(`All Google Analytics request successfully replayed; ` + `the queue is now empty!`);
+        }
+    };
+};
+/**
+ * Creates GET and POST routes to catch failed Measurement Protocol hits.
+ *
+ * @param bgSyncPlugin
+ * @returns The created routes.
+ * @private
+ */ const createCollectRoutes = (bgSyncPlugin)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
+    const handler = new NetworkOnly({
+        plugins: [
+            bgSyncPlugin
+        ]
+    });
+    return [
+        new Route(match, handler, "GET"),
+        new Route(match, handler, "POST")
+    ];
+};
+/**
+ * Creates a route with a network first strategy for the analytics.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createAnalyticsJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+/**
+ * Creates a route with a network first strategy for the gtag.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createGtagJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+/**
+ * Creates a route with a network first strategy for the gtm.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createGtmJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
+    const handler = new NetworkFirst({
+        cacheName
+    });
+    return new Route(match, handler, "GET");
+};
+/**
+ * @param options
+ */ const initialize = (options = {})=>{
+    const cacheName = privateCacheNames.getGoogleAnalyticsName(options.cacheName);
+    const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
+        maxRetentionTime: MAX_RETENTION_TIME,
+        onSync: createOnSyncCallback(options)
+    });
+    const routes = [
+        createGtmJsRoute(cacheName),
+        createAnalyticsJsRoute(cacheName),
+        createGtagJsRoute(cacheName),
+        ...createCollectRoutes(bgSyncPlugin)
+    ];
+    const router = new Router();
+    for (const route of routes){
+        router.registerRoute(route);
+    }
+    router.addFetchListener();
+};
+
+export { initialize };

package/dist/initialize.old.cjs

@@ -0,0 +1,168 @@
+'use strict';
+
+var backgroundSync = require('@serwist/background-sync');
+var internal = require('@serwist/core/internal');
+var routing = require('@serwist/routing');
+var strategies = require('@serwist/strategies');
+
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/ const QUEUE_NAME = "serwist-google-analytics";
+const MAX_RETENTION_TIME = 60 * 48; // Two days in minutes
+const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
+const GTM_HOST = "www.googletagmanager.com";
+const ANALYTICS_JS_PATH = "/analytics.js";
+const GTAG_JS_PATH = "/gtag/js";
+const GTM_JS_PATH = "/gtm.js";
+// This RegExp matches all known Measurement Protocol single-hit collect
+// endpoints. Most of the time the default path (/collect) is used, but
+// occasionally an experimental endpoint is used when testing new features,
+// (e.g. /r/collect or /j/collect)
+const COLLECT_PATHS_REGEX = /^\/(\w+\/)?collect/;
+
+/**
+ * Creates the requestWillDequeue callback to be used with the background
+ * sync plugin. The callback takes the failed request and adds the
+ * `qt` param based on the current time, as well as applies any other
+ * user-defined hit modifications.
+ *
+ * @param config
+ * @returns The requestWillDequeue callback function.
+ * @private
+ */ const createOnSyncCallback = (config)=>{
+    return async ({ queue })=>{
+        let entry;
+        while(entry = await queue.shiftRequest()){
+            const { request, timestamp } = entry;
+            const url = new URL(request.url);
+            try {
+                // Measurement protocol requests can set their payload parameters in
+                // either the URL query string (for GET requests) or the POST body.
+                const params = request.method === "POST" ? new URLSearchParams(await request.clone().text()) : url.searchParams;
+                // Calculate the qt param, accounting for the fact that an existing
+                // qt param may be present and should be updated rather than replaced.
+                const originalHitTime = timestamp - (Number(params.get("qt")) || 0);
+                const queueTime = Date.now() - originalHitTime;
+                // Set the qt param prior to applying hitFilter or parameterOverrides.
+                params.set("qt", String(queueTime));
+                // Apply `parameterOverrides`, if set.
+                if (config.parameterOverrides) {
+                    for (const param of Object.keys(config.parameterOverrides)){
+                        const value = config.parameterOverrides[param];
+                        params.set(param, value);
+                    }
+                }
+                // Apply `hitFilter`, if set.
+                if (typeof config.hitFilter === "function") {
+                    config.hitFilter.call(null, params);
+                }
+                // Retry the fetch. Ignore URL search params from the URL as they're
+                // now in the post body.
+                await fetch(new Request(url.origin + url.pathname, {
+                    body: params.toString(),
+                    method: "POST",
+                    mode: "cors",
+                    credentials: "omit",
+                    headers: {
+                        "Content-Type": "text/plain"
+                    }
+                }));
+                if (process.env.NODE_ENV !== "production") {
+                    internal.logger.log(`Request for '${internal.getFriendlyURL(url.href)}' ` + `has been replayed`);
+                }
+            } catch (err) {
+                await queue.unshiftRequest(entry);
+                if (process.env.NODE_ENV !== "production") {
+                    internal.logger.log(`Request for '${internal.getFriendlyURL(url.href)}' ` + `failed to replay, putting it back in the queue.`);
+                }
+                throw err;
+            }
+        }
+        if (process.env.NODE_ENV !== "production") {
+            internal.logger.log(`All Google Analytics request successfully replayed; ` + `the queue is now empty!`);
+        }
+    };
+};
+/**
+ * Creates GET and POST routes to catch failed Measurement Protocol hits.
+ *
+ * @param bgSyncPlugin
+ * @returns The created routes.
+ * @private
+ */ const createCollectRoutes = (bgSyncPlugin)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
+    const handler = new strategies.NetworkOnly({
+        plugins: [
+            bgSyncPlugin
+        ]
+    });
+    return [
+        new routing.Route(match, handler, "GET"),
+        new routing.Route(match, handler, "POST")
+    ];
+};
+/**
+ * Creates a route with a network first strategy for the analytics.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createAnalyticsJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
+    const handler = new strategies.NetworkFirst({
+        cacheName
+    });
+    return new routing.Route(match, handler, "GET");
+};
+/**
+ * Creates a route with a network first strategy for the gtag.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createGtagJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
+    const handler = new strategies.NetworkFirst({
+        cacheName
+    });
+    return new routing.Route(match, handler, "GET");
+};
+/**
+ * Creates a route with a network first strategy for the gtm.js script.
+ *
+ * @param cacheName
+ * @returns The created route.
+ * @private
+ */ const createGtmJsRoute = (cacheName)=>{
+    const match = ({ url })=>url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
+    const handler = new strategies.NetworkFirst({
+        cacheName
+    });
+    return new routing.Route(match, handler, "GET");
+};
+/**
+ * @param options
+ */ const initialize = (options = {})=>{
+    const cacheName = internal.privateCacheNames.getGoogleAnalyticsName(options.cacheName);
+    const bgSyncPlugin = new backgroundSync.BackgroundSyncPlugin(QUEUE_NAME, {
+        maxRetentionTime: MAX_RETENTION_TIME,
+        onSync: createOnSyncCallback(options)
+    });
+    const routes = [
+        createGtmJsRoute(cacheName),
+        createAnalyticsJsRoute(cacheName),
+        createGtagJsRoute(cacheName),
+        ...createCollectRoutes(bgSyncPlugin)
+    ];
+    const router = new routing.Router();
+    for (const route of routes){
+        router.registerRoute(route);
+    }
+    router.addFetchListener();
+};
+
+exports.initialize = initialize;

package/dist/utils/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const QUEUE_NAME = "serwist-google-analytics";
+export declare const MAX_RETENTION_TIME: number;
+export declare const GOOGLE_ANALYTICS_HOST = "www.google-analytics.com";
+export declare const GTM_HOST = "www.googletagmanager.com";
+export declare const ANALYTICS_JS_PATH = "/analytics.js";
+export declare const GTAG_JS_PATH = "/gtag/js";
+export declare const GTM_JS_PATH = "/gtm.js";
+export declare const COLLECT_DEFAULT_PATH = "/collect";
+export declare const COLLECT_PATHS_REGEX: RegExp;
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,UAAU,6BAA6B,CAAC;AACrD,eAAO,MAAM,kBAAkB,QAAU,CAAC;AAC1C,eAAO,MAAM,qBAAqB,6BAA6B,CAAC;AAChE,eAAO,MAAM,QAAQ,6BAA6B,CAAC;AACnD,eAAO,MAAM,iBAAiB,kBAAkB,CAAC;AACjD,eAAO,MAAM,YAAY,aAAa,CAAC;AACvC,eAAO,MAAM,WAAW,YAAY,CAAC;AACrC,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAM/C,eAAO,MAAM,mBAAmB,QAAuB,CAAC"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@serwist/google-analytics",
+  "version": "8.0.0",
+  "type": "module",
+  "description": "Queues failed requests and uses the Background Sync API to replay them when the network is available",
+  "files": [
+    "dist",
+    "!dist/**/dts"
+  ],
+  "keywords": [
+    "serwist",
+    "serwistjs",
+    "service worker",
+    "sw",
+    "offline",
+    "google",
+    "analytics"
+  ],
+  "author": "Google's Web DevRel Team, Serwist's Team",
+  "license": "MIT",
+  "repository": "serwist/serwist",
+  "bugs": "https://github.com/serwist/serwist/issues",
+  "homepage": "https://ducanh-next-pwa.vercel.app",
+  "module": "./dist/index.js",
+  "main": "./dist/index.old.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.old.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./initialize": {
+      "import": "./dist/initialize.js",
+      "require": "./dist/initialize.old.cjs",
+      "types": "./dist/initialize.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@serwist/background-sync": "8.0.0",
+    "@serwist/core": "8.0.0",
+    "@serwist/routing": "8.0.0",
+    "@serwist/strategies": "8.0.0"
+  },
+  "devDependencies": {
+    "rollup": "3.28.1",
+    "@serwist/constants": "8.0.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",
+    "lint": "eslint src --ext ts,tsx,js,jsx,cjs,mjs",
+    "typecheck": "tsc"
+  }
+}