serwist 9.0.0-preview.24 → 9.0.0-preview.26

package/src/legacy/Router.ts

@@ -6,16 +6,16 @@
   https://opensource.org/licenses/MIT.
 */
 
+import type { Route } from "../Route.js";
+import type { HTTPMethod } from "../constants.js";
+import { defaultMethod } from "../constants.js";
 import type { RouteHandler, RouteHandlerCallbackOptions, RouteHandlerObject, RouteMatchCallback, RouteMatchCallbackOptions } from "../types.js";
-import { assert } from "../utils/assert.js";
 import { SerwistError } from "../utils/SerwistError.js";
+import { assert } from "../utils/assert.js";
 import { getFriendlyURL } from "../utils/getFriendlyURL.js";
 import { logger } from "../utils/logger.js";
-import type { Route } from "../Route.js";
-import type { HTTPMethod } from "../constants.js";
-import { defaultMethod } from "../constants.js";
-import { parseRoute } from "../parseRoute.js";
 import { normalizeHandler } from "../utils/normalizeHandler.js";
+import { parseRoute } from "../utils/parseRoute.js";
 
 declare const self: ServiceWorkerGlobalScope;
 

package/src/legacy/fallbacks.ts

@@ -1,12 +1,12 @@
-import { PrecacheFallbackPlugin } from "./PrecacheFallbackPlugin.js";
-import { Strategy } from "../strategies/Strategy.js";
+import { Strategy } from "../lib/strategies/Strategy.js";
 import type { PrecacheRouteOptions, RuntimeCaching } from "../types.js";
 import type { PrecacheController } from "./PrecacheController.js";
+import { PrecacheFallbackPlugin } from "./PrecacheFallbackPlugin.js";
+import type { PrecacheFallbackEntry } from "./PrecacheFallbackPlugin.js";
 import { PrecacheRoute } from "./PrecacheRoute.js";
 import type { Router } from "./Router.js";
 import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
 import { getSingletonRouter } from "./singletonRouter.js";
-import type { PrecacheFallbackEntry } from "./PrecacheFallbackPlugin.js";
 
 export interface FallbackEntry extends PrecacheFallbackEntry {
   /**

package/src/legacy/handlePrecaching.ts

@@ -1,6 +1,6 @@
 import { NavigationRoute } from "../NavigationRoute.js";
-import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "../cleanupOutdatedCaches.js";
 import type { PrecacheEntry, PrecacheRouteOptions } from "../types.js";
+import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "../utils/cleanupOutdatedCaches.js";
 import type { PrecacheController } from "./PrecacheController.js";
 import { PrecacheRoute } from "./PrecacheRoute.js";
 import type { Router } from "./Router.js";

package/src/legacy/initializeGoogleAnalytics.ts

@@ -0,0 +1,218 @@
+/*
+  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.
+*/
+
+import { Route } from "../Route.js";
+import { BackgroundSyncPlugin } from "../lib/backgroundSync/BackgroundSyncPlugin.js";
+import type { BackgroundSyncQueue, BackgroundSyncQueueEntry } from "../lib/backgroundSync/BackgroundSyncQueue.js";
+import { NetworkFirst } from "../lib/strategies/NetworkFirst.js";
+import { NetworkOnly } from "../lib/strategies/NetworkOnly.js";
+import type { RouteMatchCallbackOptions } from "../types.js";
+import { cacheNames as privateCacheNames } from "../utils/cacheNames.js";
+import { getFriendlyURL } from "../utils/getFriendlyURL.js";
+import { logger } from "../utils/logger.js";
+import { Router } from "./Router.js";
+import {
+  ANALYTICS_JS_PATH,
+  COLLECT_PATHS_REGEX,
+  GOOGLE_ANALYTICS_HOST,
+  GTAG_JS_PATH,
+  GTM_HOST,
+  GTM_JS_PATH,
+  MAX_RETENTION_TIME,
+  QUEUE_NAME,
+} from "./constants.js";
+import { getSingletonRouter } from "./singletonRouter.js";
+
+/**
+ * @deprecated
+ */
+export interface GoogleAnalyticsInitializeOptions {
+  /**
+   * An optional `Router` instance. If not provided, the singleton `Router`
+   * will be used.
+   */
+  router?: Router;
+  /**
+   * The cache name to store and retrieve analytics.js. Defaults to Serwist's default cache names.
+   */
+  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;
+}
+
+/**
+ * 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: Pick<GoogleAnalyticsInitializeOptions, "parameterOverrides" | "hitFilter">) => {
+  return async ({ queue }: { queue: BackgroundSyncQueue }) => {
+    let entry: BackgroundSyncQueueEntry | undefined = undefined;
+    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: BackgroundSyncPlugin) => {
+  const match = ({ url }: RouteMatchCallbackOptions) => 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: string) => {
+  const match = ({ url }: RouteMatchCallbackOptions) => 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: string) => {
+  const match = ({ url }: RouteMatchCallbackOptions) => 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: string) => {
+  const match = ({ url }: RouteMatchCallbackOptions) => url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
+
+  const handler = new NetworkFirst({ cacheName });
+
+  return new Route(match, handler, "GET");
+};
+
+/**
+ * Initialize Serwist's offline Google Analytics v3 support.
+ *
+ * @param options
+ * @deprecated Use `serwist.initializeGoogleAnalytics` instead.
+ */
+export const initializeGoogleAnalytics = ({ router = getSingletonRouter(), cacheName, ...options }: GoogleAnalyticsInitializeOptions = {}): void => {
+  const resolvedCacheName = privateCacheNames.getGoogleAnalyticsName(cacheName);
+
+  const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
+    maxRetentionTime: MAX_RETENTION_TIME,
+    onSync: createOnSyncCallback(options),
+  });
+
+  const routes = [
+    createGtmJsRoute(resolvedCacheName),
+    createAnalyticsJsRoute(resolvedCacheName),
+    createGtagJsRoute(resolvedCacheName),
+    ...createCollectRoutes(bgSyncPlugin),
+  ];
+
+  for (const route of routes) {
+    router.registerRoute(route);
+  }
+};

package/src/legacy/installSerwist.ts

@@ -1,11 +1,88 @@
-import { Serwist, type SerwistOptions } from "../Serwist.js";
+import { disableDevLogs as disableDevLogsImpl } from "../disableDevLogs.js";
+import { enableNavigationPreload } from "../navigationPreload.js";
+import { setCacheNameDetails } from "../setCacheNameDetails.js";
+import type { RuntimeCaching } from "../types.js";
+import { clientsClaim as clientsClaimImpl } from "../utils/clientsClaim.js";
+import type { PrecacheController } from "./PrecacheController.js";
+import type { Router } from "./Router.js";
+import type { FallbacksOptions } from "./fallbacks.js";
+import { fallbacks as fallbacksImpl } from "./fallbacks.js";
+import { type HandlePrecachingOptions, handlePrecaching } from "./handlePrecaching.js";
+import { initializeGoogleAnalytics } from "./initializeGoogleAnalytics.js";
+import type { GoogleAnalyticsInitializeOptions } from "./initializeGoogleAnalytics.js";
+import { registerRuntimeCaching } from "./registerRuntimeCaching.js";
+import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
+import { getSingletonRouter } from "./singletonRouter.js";
+
+declare const self: ServiceWorkerGlobalScope;
 
 /**
  * Options for `installSerwist`.
  *
  * @deprecated
  */
-export type InstallSerwistOptions = SerwistOptions;
+export interface InstallSerwistOptions extends Omit<HandlePrecachingOptions, "precacheController" | "router"> {
+  /**
+   * An optional `PrecacheController` instance. If not provided, the singleton
+   * `PrecacheController` will be used.
+   */
+  precacheController?: PrecacheController;
+  /**
+   * An optional `Router` instance. If not provided, the singleton `Router`
+   * will be used.
+   */
+  router?: Router;
+  /**
+   * Forces the waiting service worker to become the active one.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/skipWaiting
+   */
+  skipWaiting?: boolean;
+  /**
+   * Imports external scripts. They are executed in the order they
+   * are passed.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/importScripts
+   */
+  importScripts?: string[];
+  /**
+   * Enables navigation preloading if it is supported.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/navigationPreload
+   */
+  navigationPreload?: boolean;
+  /**
+   * Modifies the prefix of the default cache names used by Serwist packages.
+   */
+  cacheId?: string | undefined;
+  /**
+   * Claims any currently available clients once the service worker
+   * becomes active. This is normally used in conjunction with `skipWaiting()`.
+   *
+   * @default false
+   */
+  clientsClaim?: boolean;
+  /**
+   * A list of caching strategies.
+   */
+  runtimeCaching?: RuntimeCaching[];
+  /**
+   * Your configuration for `@serwist/google-analytics`. This plugin is
+   * only initialized when this option is not `undefined` or `false`.
+   */
+  offlineAnalyticsConfig?: GoogleAnalyticsInitializeOptions | boolean;
+  /**
+   * Disables Serwist's logging in development mode.
+   *
+   * @default false
+   */
+  disableDevLogs?: boolean;
+  /**
+   * Precaches routes so that they can be used as a fallback when
+   * a Strategy fails to generate a response.
+   */
+  fallbacks?: Pick<FallbacksOptions, "entries">;
+}
 
 /**
  * Abstracts away the core APIs of Serwist.
@@ -13,7 +90,81 @@ export type InstallSerwistOptions = SerwistOptions;
  * @param options - `installSerwist` options.
  * @deprecated
  */
-export const installSerwist = (options: InstallSerwistOptions): void => {
-  const serwist = new Serwist(options);
-  serwist.addEventListeners();
+export const installSerwist = ({
+  precacheController = getSingletonPrecacheController(),
+  router = getSingletonRouter(),
+  precacheEntries,
+  precacheOptions,
+  cleanupOutdatedCaches,
+  navigateFallback,
+  navigateFallbackAllowlist,
+  navigateFallbackDenylist,
+  skipWaiting,
+  importScripts,
+  navigationPreload = false,
+  cacheId,
+  clientsClaim = false,
+  runtimeCaching,
+  offlineAnalyticsConfig,
+  disableDevLogs = false,
+  fallbacks,
+}: InstallSerwistOptions): void => {
+  if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
+
+  if (navigationPreload) enableNavigationPreload();
+
+  if (cacheId !== undefined) {
+    setCacheNameDetails({
+      prefix: cacheId,
+    });
+  }
+
+  if (skipWaiting) {
+    self.skipWaiting();
+  } else {
+    self.addEventListener("message", (event) => {
+      if (event.data && event.data.type === "SKIP_WAITING") {
+        self.skipWaiting();
+      }
+    });
+  }
+
+  if (clientsClaim) clientsClaimImpl();
+
+  handlePrecaching({
+    precacheController,
+    router,
+    precacheEntries,
+    precacheOptions,
+    cleanupOutdatedCaches,
+    navigateFallback,
+    navigateFallbackAllowlist,
+    navigateFallbackDenylist,
+  });
+
+  if (runtimeCaching !== undefined) {
+    if (fallbacks !== undefined) {
+      runtimeCaching = fallbacksImpl({
+        precacheController,
+        router,
+        runtimeCaching,
+        entries: fallbacks.entries,
+        precacheOptions,
+      });
+    }
+    registerRuntimeCaching(...runtimeCaching);
+  }
+
+  if (offlineAnalyticsConfig !== undefined) {
+    if (typeof offlineAnalyticsConfig === "boolean") {
+      offlineAnalyticsConfig && initializeGoogleAnalytics({ router });
+    } else {
+      initializeGoogleAnalytics({
+        ...offlineAnalyticsConfig,
+        router,
+      });
+    }
+  }
+
+  if (disableDevLogs) disableDevLogsImpl();
 };

package/src/legacy/registerRoute.ts

@@ -6,9 +6,9 @@
   https://opensource.org/licenses/MIT.
 */
 
-import type { RouteHandler, RouteMatchCallback } from "../types.js";
 import type { Route } from "../Route.js";
 import type { HTTPMethod } from "../constants.js";
+import type { RouteHandler, RouteMatchCallback } from "../types.js";
 import { getSingletonRouter } from "./singletonRouter.js";
 
 /**

package/src/{plugins → lib}/backgroundSync/BackgroundSyncPlugin.ts

@@ -7,25 +7,25 @@
 */
 
 import type { FetchDidFailCallbackParam, SerwistPlugin } from "../../types.js";
-import type { QueueOptions } from "./Queue.js";
-import { Queue } from "./Queue.js";
+import type { BackgroundSyncQueueOptions } from "./BackgroundSyncQueue.js";
+import { BackgroundSyncQueue } from "./BackgroundSyncQueue.js";
 
 /**
  * A class implementing the `fetchDidFail` lifecycle callback. This makes it
  * easier to add failed requests to a background sync Queue.
  */
 export class BackgroundSyncPlugin implements SerwistPlugin {
-  private readonly _queue: Queue;
+  private readonly _queue: BackgroundSyncQueue;
 
   /**
    * @param name See the `serwist/plugins.BackgroundSyncQueue`
    * documentation for parameter details.
    * @param options See the `serwist/plugins.BackgroundSyncQueue`
    * documentation for parameter details.
-   * @see https://serwist.pages.dev/docs/background-sync/queue
+   * @see https://serwist.pages.dev/docs/core/background-sync-queue
    */
-  constructor(name: string, options?: QueueOptions) {
-    this._queue = new Queue(name, options);
+  constructor(name: string, options?: BackgroundSyncQueueOptions) {
+    this._queue = new BackgroundSyncQueue(name, options);
   }
 
   /**

package/src/{plugins/backgroundSync/Queue.ts → lib/backgroundSync/BackgroundSyncQueue.ts}

@@ -1,3 +1,4 @@
+import { SerwistError } from "../../utils/SerwistError.js";
 /*
   Copyright 2018 Google LLC
 
@@ -6,23 +7,43 @@
   https://opensource.org/licenses/MIT.
 */
 import { assert } from "../../utils/assert.js";
-import { SerwistError } from "../../utils/SerwistError.js";
 import { getFriendlyURL } from "../../utils/getFriendlyURL.js";
 import { logger } from "../../utils/logger.js";
-import type { QueueStoreEntry, UnidentifiedQueueStoreEntry } from "./QueueDb.js";
-import { QueueStore } from "./QueueStore.js";
+import type { BackgroundSyncQueueStoreEntry, UnidentifiedQueueStoreEntry } from "./BackgroundSyncQueueDb.js";
+import { BackgroundSyncQueueStore } from "./BackgroundSyncQueueStore.js";
 import { StorableRequest } from "./StorableRequest.js";
 
+// See https://github.com/GoogleChrome/workbox/issues/2946
+interface SyncManager {
+  getTags(): Promise<string[]>;
+  register(tag: string): Promise<void>;
+}
+
+declare global {
+  interface ServiceWorkerRegistration {
+    readonly sync: SyncManager;
+  }
+
+  interface SyncEvent extends ExtendableEvent {
+    readonly lastChance: boolean;
+    readonly tag: string;
+  }
+
+  interface ServiceWorkerGlobalScopeEventMap {
+    sync: SyncEvent;
+  }
+}
+
 // Give TypeScript the correct global.
-declare let self: ServiceWorkerGlobalScope;
+declare const self: ServiceWorkerGlobalScope;
 
 interface OnSyncCallbackOptions {
-  queue: Queue;
+  queue: BackgroundSyncQueue;
 }
 
 type OnSyncCallback = (options: OnSyncCallbackOptions) => void | Promise<void>;
 
-export interface QueueOptions {
+export interface BackgroundSyncQueueOptions {
   /**
    * If `true`, instead of attempting to use background sync events, always attempt
    * to replay queued request at service worker startup. Most folks will not need
@@ -50,7 +71,7 @@ export interface QueueOptions {
   onSync?: OnSyncCallback;
 }
 
-export interface QueueEntry {
+export interface BackgroundSyncQueueEntry {
   /**
    * The request to store in the queue.
    */
@@ -85,8 +106,8 @@ const queueNames = new Set<string>();
  * @returns
  * @private
  */
-const convertEntry = (queueStoreEntry: UnidentifiedQueueStoreEntry): QueueEntry => {
-  const queueEntry: QueueEntry = {
+const convertEntry = (queueStoreEntry: UnidentifiedQueueStoreEntry): BackgroundSyncQueueEntry => {
+  const queueEntry: BackgroundSyncQueueEntry = {
     request: new StorableRequest(queueStoreEntry.requestData).toRequest(),
     timestamp: queueStoreEntry.timestamp,
   };
@@ -101,11 +122,11 @@ const convertEntry = (queueStoreEntry: UnidentifiedQueueStoreEntry): QueueEntry
  * later. All parts of the storing and replaying process are observable via
  * callbacks.
  */
-export class Queue {
+export class BackgroundSyncQueue {
   private readonly _name: string;
   private readonly _onSync: OnSyncCallback;
   private readonly _maxRetentionTime: number;
-  private readonly _queueStore: QueueStore;
+  private readonly _queueStore: BackgroundSyncQueueStore;
   private readonly _forceSyncFallback: boolean;
   private _syncInProgress = false;
   private _requestsAddedDuringSync = false;
@@ -119,7 +140,7 @@ export class Queue {
    * a duplicate name is detected.
    * @param options
    */
-  constructor(name: string, { forceSyncFallback, onSync, maxRetentionTime }: QueueOptions = {}) {
+  constructor(name: string, { forceSyncFallback, onSync, maxRetentionTime }: BackgroundSyncQueueOptions = {}) {
     // Ensure the store name is not already being used
     if (queueNames.has(name)) {
       throw new SerwistError("duplicate-queue-name", { name });
@@ -130,7 +151,7 @@ export class Queue {
     this._onSync = onSync || this.replayRequests;
     this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME;
     this._forceSyncFallback = Boolean(forceSyncFallback);
-    this._queueStore = new QueueStore(this._name);
+    this._queueStore = new BackgroundSyncQueueStore(this._name);
 
     this._addSyncListener();
   }
@@ -148,16 +169,16 @@ export class Queue {
    *
    * @param entry
    */
-  async pushRequest(entry: QueueEntry): Promise<void> {
+  async pushRequest(entry: BackgroundSyncQueueEntry): Promise<void> {
     if (process.env.NODE_ENV !== "production") {
       assert!.isType(entry, "object", {
-        moduleName: "serwist/plugins",
+        moduleName: "serwist",
         className: "BackgroundSyncQueue",
         funcName: "pushRequest",
         paramName: "entry",
       });
       assert!.isInstance(entry.request, Request, {
-        moduleName: "serwist/plugins",
+        moduleName: "serwist",
         className: "BackgroundSyncQueue",
         funcName: "pushRequest",
         paramName: "entry.request",
@@ -173,16 +194,16 @@ export class Queue {
    *
    * @param entry
    */
-  async unshiftRequest(entry: QueueEntry): Promise<void> {
+  async unshiftRequest(entry: BackgroundSyncQueueEntry): Promise<void> {
     if (process.env.NODE_ENV !== "production") {
       assert!.isType(entry, "object", {
-        moduleName: "serwist/plugins",
+        moduleName: "serwist",
         className: "BackgroundSyncQueue",
         funcName: "unshiftRequest",
         paramName: "entry",
       });
       assert!.isInstance(entry.request, Request, {
-        moduleName: "serwist/plugins",
+        moduleName: "serwist",
         className: "BackgroundSyncQueue",
         funcName: "unshiftRequest",
         paramName: "entry.request",
@@ -198,7 +219,7 @@ export class Queue {
    *
    * @returns
    */
-  async popRequest(): Promise<QueueEntry | undefined> {
+  async popRequest(): Promise<BackgroundSyncQueueEntry | undefined> {
     return this._removeRequest("pop");
   }
 
@@ -208,7 +229,7 @@ export class Queue {
    *
    * @returns
    */
-  async shiftRequest(): Promise<QueueEntry | undefined> {
+  async shiftRequest(): Promise<BackgroundSyncQueueEntry | undefined> {
     return this._removeRequest("shift");
   }
 
@@ -218,7 +239,7 @@ export class Queue {
    *
    * @returns
    */
-  async getAll(): Promise<QueueEntry[]> {
+  async getAll(): Promise<BackgroundSyncQueueEntry[]> {
     const allEntries = await this._queueStore.getAll();
     const now = Date.now();
 
@@ -254,7 +275,7 @@ export class Queue {
    * @param operation
    * @private
    */
-  async _addRequest({ request, metadata, timestamp = Date.now() }: QueueEntry, operation: "push" | "unshift"): Promise<void> {
+  async _addRequest({ request, metadata, timestamp = Date.now() }: BackgroundSyncQueueEntry, operation: "push" | "unshift"): Promise<void> {
     const storableRequest = await StorableRequest.fromRequest(request.clone());
     const entry: UnidentifiedQueueStoreEntry = {
       requestData: storableRequest.toObject(),
@@ -297,9 +318,9 @@ export class Queue {
    * @returns
    * @private
    */
-  async _removeRequest(operation: "pop" | "shift"): Promise<QueueEntry | undefined> {
+  async _removeRequest(operation: "pop" | "shift"): Promise<BackgroundSyncQueueEntry | undefined> {
     const now = Date.now();
-    let entry: QueueStoreEntry | undefined;
+    let entry: BackgroundSyncQueueStoreEntry | undefined;
     switch (operation) {
       case "pop":
         entry = await this._queueStore.popEntry();
@@ -329,7 +350,7 @@ export class Queue {
    * the queue (which registers a retry for the next sync event).
    */
   async replayRequests(): Promise<void> {
-    let entry: QueueEntry | undefined = undefined;
+    let entry: BackgroundSyncQueueEntry | undefined = undefined;
     while ((entry = await this.shiftRequest())) {
       try {
         await fetch(entry.request.clone());