@adobe/alloy 2.32.1-beta.0 → 2.33.0-beta.2

package/src/components/Personalization/index.js

@@ -0,0 +1,223 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import {
+  anyOf,
+  boolean,
+  literal,
+  objectOf,
+  string,
+} from "@adobe/alloy-core/utils/validation";
+import createComponent from "./createComponent.js";
+import { initDomActionsModules } from "./dom-actions/index.js";
+import createCollect from "@adobe/alloy-core/utils/createCollect.js";
+import { createHideContainers, createShowContainers } from "./flicker/index.js";
+import createFetchDataHandler from "./createFetchDataHandler.js";
+import collectClicks from "./dom-actions/clicks/collectClicks.js";
+import isAuthoringModeEnabled from "./utils/isAuthoringModeEnabled.js";
+import {
+  mergeDecisionsMeta,
+  mergeQuery,
+} from "@adobe/alloy-core/utils/event.js";
+import createOnClickHandler from "./createOnClickHandler.js";
+import createViewCacheManager from "./createViewCacheManager.js";
+import createViewChangeHandler from "./createViewChangeHandler.js";
+import createClickStorage from "./createClickStorage.js";
+import createInteractionStorage from "./createInteractionStorage.js";
+import createApplyPropositions from "./createApplyPropositions.js";
+import createGetPageLocation from "./createGetPageLocation.js";
+import createSetTargetMigration from "./createSetTargetMigration.js";
+import remapCustomCodeOffers from "./dom-actions/remapCustomCodeOffers.js";
+import remapHeadOffers from "./dom-actions/remapHeadOffers.js";
+import createPreprocess from "./dom-actions/createPreprocess.js";
+import injectCreateProposition from "./handlers/injectCreateProposition.js";
+import createAsyncArray from "./utils/createAsyncArray.js";
+import * as schema from "@adobe/alloy-core/constants/schema.js";
+import processDefaultContent from "./handlers/processDefaultContent.js";
+import { isPageWideSurface } from "@adobe/alloy-core/utils/surfaceUtils.js";
+import createProcessDomAction from "./handlers/createProcessDomAction.js";
+import createProcessHtmlContent from "./handlers/createProcessHtmlContent.js";
+import createProcessRedirect from "./handlers/createProcessRedirect.js";
+import createProcessPropositions from "./handlers/createProcessPropositions.js";
+import createOnDecisionHandler from "./createOnDecisionHandler.js";
+import createProcessInAppMessage from "./handlers/createProcessInAppMessage.js";
+import initInAppMessageActionsModules from "./in-app-message-actions/initInAppMessageActionsModules.js";
+import createRedirect from "./dom-actions/createRedirect.js";
+import createNotificationHandler from "./createNotificationHandler.js";
+import createHandleConsentFlicker from "./createHandleConsentFlicker.js";
+import collectInteractions from "./dom-actions/clicks/collectInteractions.js";
+import {
+  ALWAYS,
+  NEVER,
+  PROPOSITION_INTERACTION_TYPES,
+} from "@adobe/alloy-core/constants/propositionInteractionType.js";
+import {
+  ADOBE_JOURNEY_OPTIMIZER,
+  ADOBE_TARGET,
+} from "@adobe/alloy-core/constants/decisionProvider.js";
+
+const createPersonalization = ({ config, logger, eventManager, consent }) => {
+  const {
+    targetMigrationEnabled,
+    prehidingStyle,
+    autoCollectPropositionInteractions,
+  } = config;
+  const collect = createCollect({
+    eventManager,
+    mergeDecisionsMeta,
+  });
+
+  const showContainers = createShowContainers(logger);
+  const hideContainers = createHideContainers(logger);
+
+  const { storeInteractionMeta, getInteractionMetas } =
+    createInteractionStorage();
+
+  const { storeClickMeta, getClickSelectors, getClickMetas } =
+    createClickStorage();
+
+  const getPageLocation = createGetPageLocation({ window });
+  const domActionsModules = initDomActionsModules();
+
+  const preprocess = createPreprocess([remapHeadOffers, remapCustomCodeOffers]);
+  const createProposition = injectCreateProposition({
+    preprocess,
+    isPageWideSurface,
+  });
+  const viewCache = createViewCacheManager({ createProposition });
+
+  const executeRedirect = createRedirect(window);
+  const schemaProcessors = {
+    [schema.DEFAULT_CONTENT_ITEM]: processDefaultContent,
+    [schema.DOM_ACTION]: createProcessDomAction({
+      modules: domActionsModules,
+      logger,
+      storeInteractionMeta,
+      storeClickMeta,
+      autoCollectPropositionInteractions,
+    }),
+    [schema.HTML_CONTENT_ITEM]: createProcessHtmlContent({
+      modules: domActionsModules,
+      logger,
+      storeInteractionMeta,
+      autoCollectPropositionInteractions,
+    }),
+    [schema.REDIRECT_ITEM]: createProcessRedirect({
+      logger,
+      executeRedirect,
+      collect,
+    }),
+    [schema.MESSAGE_IN_APP]: createProcessInAppMessage({
+      modules: initInAppMessageActionsModules(collect),
+      logger,
+    }),
+  };
+
+  const processPropositions = createProcessPropositions({
+    schemaProcessors,
+    logger,
+  });
+
+  const renderedPropositions = createAsyncArray();
+  const notificationHandler = createNotificationHandler(
+    collect,
+    renderedPropositions,
+  );
+
+  const fetchDataHandler = createFetchDataHandler({
+    prehidingStyle,
+    showContainers,
+    hideContainers,
+    mergeQuery,
+    processPropositions,
+    createProposition,
+    notificationHandler,
+    consent,
+    logger,
+  });
+
+  const onClickHandler = createOnClickHandler({
+    mergeDecisionsMeta,
+    collectInteractions,
+    collectClicks,
+    getInteractionMetas,
+    getClickMetas,
+    getClickSelectors,
+    autoCollectPropositionInteractions,
+  });
+
+  const viewChangeHandler = createViewChangeHandler({
+    processPropositions,
+    viewCache,
+    logger,
+  });
+  const applyPropositions = createApplyPropositions({
+    processPropositions,
+    createProposition,
+    renderedPropositions,
+    viewCache,
+  });
+  const setTargetMigration = createSetTargetMigration({
+    targetMigrationEnabled,
+  });
+
+  const onDecisionHandler = createOnDecisionHandler({
+    processPropositions,
+    createProposition,
+    notificationHandler,
+  });
+
+  const handleConsentFlicker = createHandleConsentFlicker({
+    showContainers,
+    consent,
+  });
+
+  return createComponent({
+    getPageLocation,
+    logger,
+    fetchDataHandler,
+    viewChangeHandler,
+    onClickHandler,
+    isAuthoringModeEnabled,
+    mergeQuery,
+    viewCache,
+    showContainers,
+    applyPropositions,
+    setTargetMigration,
+    mergeDecisionsMeta,
+    renderedPropositions,
+    onDecisionHandler,
+    handleConsentFlicker,
+  });
+};
+
+createPersonalization.namespace = "Personalization";
+
+const interactionConfigOptions = PROPOSITION_INTERACTION_TYPES.map(
+  (propositionInteractionType) => literal(propositionInteractionType),
+);
+
+createPersonalization.configValidators = objectOf({
+  prehidingStyle: string().nonEmpty(),
+  targetMigrationEnabled: boolean().default(false),
+  autoCollectPropositionInteractions: objectOf({
+    [ADOBE_JOURNEY_OPTIMIZER]: anyOf(interactionConfigOptions).default(ALWAYS),
+    [ADOBE_TARGET]: anyOf(interactionConfigOptions).default(NEVER),
+  })
+    .default({
+      [ADOBE_JOURNEY_OPTIMIZER]: ALWAYS,
+      [ADOBE_TARGET]: NEVER,
+    })
+    .noUnknownFields(),
+});
+
+export default createPersonalization;

package/src/components/Personalization/utils/addRenderAttemptedToDecisions.js

@@ -0,0 +1,15 @@
+/*
+Copyright 2021 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export default ({ decisions, renderAttempted }) => {
+  return decisions.map((decision) => ({ renderAttempted, ...decision }));
+};

package/src/components/Personalization/utils/createAsyncArray.js

@@ -0,0 +1,37 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+export default () => {
+  let latest = Promise.resolve([]);
+  return {
+    concat(promise) {
+      latest = latest.then((existingPropositions) => {
+        return promise
+          .then((newPropositions) => {
+            return existingPropositions.concat(newPropositions);
+          })
+          .catch(() => {
+            return existingPropositions;
+          });
+      });
+    },
+    /**
+     * Clears the saved propositions, waiting until the next propositions are resolved and available.
+     *
+     * @returns {Promise<Array>} A promise that resolves to the latest propositions.
+     */
+    clear() {
+      const oldLatest = latest;
+      latest = Promise.resolve([]);
+      return oldLatest;
+    },
+  };
+};

package/src/components/Personalization/utils/isAuthoringModeEnabled.js

@@ -0,0 +1,15 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export default (doc = document) => {
+  return doc.location.href.indexOf("adobe_authoring_enabled") !== -1;
+};

package/src/components/Personalization/utils/metaUtils.js

@@ -0,0 +1,27 @@
+/*
+Copyright 2024 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+export const cleanMetas = (metas) =>
+  metas.map((meta) => {
+    const { trackingLabel, scopeType, ...rest } = meta;
+    return rest;
+  });
+
+export const dedupeMetas = (metas) =>
+  metas.filter((meta, index) => {
+    const stringifiedMeta = JSON.stringify(meta);
+    return (
+      index ===
+      metas.findIndex(
+        (innerMeta) => JSON.stringify(innerMeta) === stringifiedMeta,
+      )
+    );
+  });

package/src/components/Personalization/utils/surfaceUtils.js

@@ -0,0 +1,120 @@
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import {
+  WEB,
+  WEBAPP,
+  SURFACE_TYPE_DELIMITER,
+  FRAGMENT_DELIMITER,
+} from "../constants/surface.js";
+import { isNil, isNonEmptyString } from "@adobe/alloy-core/utils";
+
+const SURFACE_REGEX = /^(\w+):\/\/([^/#]+)(\/[^#]*)?(#.*)?$/;
+const AUTHORITY_REGEX =
+  /^(?:.*@)?(?:[a-z\d\u00a1-\uffff.-]+|\[[a-f\d:]+])(?::\d+)?$/;
+const PATH_REGEX = /^\/(?:[/\w\u00a1-\uffff-.~]|%[a-fA-F\d]{2})*$/;
+const FRAGMENT_REGEX = /^#(?:[/\w\u00a1-\uffff-.~]|%[a-fA-F\d]{2})+$/;
+
+const normalizePath = (path = "/") => {
+  let end = path.length;
+  while (end > 0 && "/".indexOf(path.charAt(end - 1)) !== -1) {
+    end -= 1;
+  }
+  return path.substring(0, end) || "/";
+};
+
+const getSurfaceType = (surfaceTypeMatch) =>
+  isNonEmptyString(surfaceTypeMatch) ? surfaceTypeMatch.toLowerCase() : "";
+
+const getAuthority = (authorityMatch) =>
+  isNonEmptyString(authorityMatch) ? authorityMatch.toLowerCase() : "";
+
+const getPath = (pathMatch) =>
+  isNonEmptyString(pathMatch) ? normalizePath(pathMatch) : "/";
+
+const parseSurface = (surfaceString) => {
+  const matched = surfaceString.match(SURFACE_REGEX);
+  return matched
+    ? {
+        surfaceType: getSurfaceType(matched[1]),
+        authority: getAuthority(matched[2]),
+        path: getPath(matched[3]),
+        fragment: matched[4],
+      }
+    : null;
+};
+
+const stringifySurface = (surface) =>
+  `${surface.surfaceType}${SURFACE_TYPE_DELIMITER}${
+    surface.authority
+  }${surface.path || ""}${surface.fragment || ""}`;
+
+export const buildPageSurface = (getPageLocation) => {
+  const location = getPageLocation();
+  const host = location.host.toLowerCase();
+  const path = location.pathname;
+  return WEB + SURFACE_TYPE_DELIMITER + host + normalizePath(path);
+};
+
+const expandFragmentSurface = (surface, getPageLocation) =>
+  surface.startsWith(FRAGMENT_DELIMITER)
+    ? buildPageSurface(getPageLocation) + surface
+    : surface;
+
+const validateSurface = (surface, getPageLocation, logger) => {
+  const invalidateSurface = (validationError) => {
+    logger.warn(validationError);
+    return null;
+  };
+
+  if (!isNonEmptyString(surface)) {
+    return invalidateSurface(`Invalid surface: ${surface}`);
+  }
+  const expanded = expandFragmentSurface(surface, getPageLocation);
+  const parsed = parseSurface(expanded);
+  if (parsed === null) {
+    return invalidateSurface(`Invalid surface: ${surface}`);
+  }
+  if (![WEB, WEBAPP].includes(parsed.surfaceType)) {
+    return invalidateSurface(
+      `Unsupported surface type ${parsed.surfaceType} in surface: ${surface}`,
+    );
+  }
+  if (!parsed.authority || !AUTHORITY_REGEX.test(parsed.authority)) {
+    return invalidateSurface(
+      `Invalid authority ${parsed.authority} in surface: ${surface}`,
+    );
+  }
+  if (parsed.path && !PATH_REGEX.test(parsed.path)) {
+    return invalidateSurface(
+      `Invalid path ${parsed.path} in surface: ${surface}`,
+    );
+  }
+  if (parsed.fragment && !FRAGMENT_REGEX.test(parsed.fragment)) {
+    return invalidateSurface(
+      `Invalid fragment ${parsed.fragment} in surface: ${surface}`,
+    );
+  }
+  return parsed;
+};
+
+export const isPageWideSurface = (scope) =>
+  !!scope &&
+  scope.indexOf(WEB + SURFACE_TYPE_DELIMITER) === 0 &&
+  scope.indexOf(FRAGMENT_DELIMITER) === -1;
+
+// eslint-disable-next-line default-param-last
+export const normalizeSurfaces = (surfaces = [], getPageLocation, logger) =>
+  surfaces
+    .map((surface) => validateSurface(surface, getPageLocation, logger))
+    .filter((surface) => !isNil(surface))
+    .map(stringifySurface);

package/src/components/Personalization/validateApplyPropositionsOptions.js

@@ -0,0 +1,56 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import {
+  anything,
+  objectOf,
+  arrayOf,
+  string,
+} from "@adobe/alloy-core/utils/validation";
+
+export const EMPTY_PROPOSITIONS = { propositions: [] };
+
+export default ({ logger, options }) => {
+  const applyPropositionsOptionsValidator = objectOf({
+    propositions: arrayOf(
+      objectOf({
+        id: string().required(),
+        scope: string().required(),
+        scopeDetails: objectOf({
+          decisionProvider: string().required(),
+        }).required(),
+        items: arrayOf(
+          objectOf({
+            id: string().required(),
+            schema: string().required(),
+            data: objectOf(anything()),
+          }),
+        )
+          .nonEmpty()
+          .required(),
+      }).required(),
+    )
+      .nonEmpty()
+      .required(),
+    metadata: objectOf(anything()),
+    viewName: string(),
+  }).required();
+
+  try {
+    return applyPropositionsOptionsValidator(options);
+  } catch (e) {
+    logger.warn(
+      "Invalid options for applyPropositions. No propositions will be applied.",
+      e,
+    );
+    return EMPTY_PROPOSITIONS;
+  }
+};

package/src/components/PushNotifications/helpers/constants.js

@@ -0,0 +1,16 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export const DB_NAME = "alloyPushNotifications";
+export const DB_VERSION = 1;
+export const STORE_NAME = "config";
+export const INDEX_KEY = "alloyConfig";

package/src/components/PushNotifications/helpers/getPushSubscriptionDetails.js

@@ -0,0 +1,122 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { PushSubscription } from '../types.js' */
+
+import { base64ToBytes, bytesToBase64 } from "@adobe/alloy-core/utils";
+
+/**
+ * Gets push subscription details for the current browser.
+ *
+ * @async
+ * @function
+ *
+ * @param {object} options
+ * @param {string} options.vapidPublicKey - The VAPID public key in base64 format used for push notification authentication.
+ * @param {Window} options.window
+ *
+ * @returns {Promise<PushSubscription>} A promise that resolves to an object containing the push subscription details.
+
+ * @throws {Error} Throws an error if service workers are not supported in the browser.
+ * @throws {Error} Throws an error if user didn't approve push notifications for the domain.
+ * @throws {Error} Throws an error if push notifications are not supported in the browser.
+ * @throws {Error} Throws an error if no VAPID public key was provided.
+ *
+ * @example
+ * // Get subscription details with VAPID key
+ * const vapidKey = "BEl62iUYgUivxIkv69yViEuiBIa40HI5hmjHbKPlXO...";
+ * const subscription = await getPushSubscriptionDetails(vapidKey);
+ * console.log(subscription.endpoint); // "https://fcm.googleapis.com/fcm/send/..."
+ */
+const getPushSubscriptionDetails = async ({ vapidPublicKey, window }) => {
+  if (!("serviceWorker" in window.navigator)) {
+    throw new Error("Service workers are not supported in this browser.");
+  }
+
+  if (!("PushManager" in window) || !("Notification" in window)) {
+    throw new Error("Push notifications are not supported in this browser.");
+  }
+
+  /** @type {object} */
+  const notification = window.Notification;
+  if (notification.permission !== "granted") {
+    throw new Error(
+      "The user has not given permission to send push notifications.",
+    );
+  }
+
+  const serviceWorkerRegistration =
+    // eslint-disable-next-line compat/compat -- Service worker support is required for push notifications
+    await window.navigator.serviceWorker.getRegistration();
+
+  if (!serviceWorkerRegistration) {
+    throw new Error("No service worker registration was found.");
+  }
+
+  // Even `applicationServerKey` is not required in the spec, some browsers like Chrome are requiring it.
+  if (!vapidPublicKey) {
+    throw new Error("No VAPID public key was provided.");
+  }
+
+  const subscriptionOptions = {
+    userVisibleOnly: true,
+    applicationServerKey: base64ToBytes(vapidPublicKey),
+  };
+
+  // Push subscription handling strategy:
+  //
+  // 1. We always call subscribe() to either get the current subscription or create a new one.
+  //    - If called with the same VAPID key as an existing subscription, it returns that subscription
+  //    - If called with a different VAPID key when a subscription exists, it throws an error
+  //
+  // 2. Error handling approach:
+  //    - Browser error messages vary and don't clearly indicate VAPID key conflicts
+  //    - When subscribe() fails, we assume it's likely due to a VAPID key mismatch
+  //    - We attempt recovery by unsubscribing the existing subscription and retrying
+  //    - If the retry also fails, we re-throw the original error
+  //
+  // This strategy ensures we can handle both new subscriptions and VAPID key changes
+  // while gracefully falling back to error reporting when recovery isn't possible.
+  try {
+    const subscription =
+      await serviceWorkerRegistration.pushManager.subscribe(
+        subscriptionOptions,
+      );
+
+    return {
+      endpoint: subscription.endpoint,
+      keys: {
+        p256dh: bytesToBase64(new Uint8Array(subscription.getKey("p256dh")), {
+          urlSafe: true,
+        }),
+        auth: bytesToBase64(new Uint8Array(subscription.getKey("auth")), {
+          urlSafe: true,
+        }),
+      },
+    };
+  } catch (e) {
+    const subscription =
+      await serviceWorkerRegistration.pushManager.getSubscription();
+    if (!subscription) {
+      throw e;
+    }
+
+    const unsubscribeResult = await subscription.unsubscribe();
+    if (!unsubscribeResult) {
+      throw e;
+    }
+
+    return getPushSubscriptionDetails({ vapidPublicKey, window });
+  }
+};
+
+export default getPushSubscriptionDetails;

package/src/components/PushNotifications/helpers/readFromIndexedDb.js

@@ -0,0 +1,50 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you 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 REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { ServiceWorkerLogger } from '../types.js' */
+
+import {
+  getFromIndexedDbStore,
+  openIndexedDb,
+} from "@adobe/alloy-core/utils/indexedDb.js";
+import { DB_NAME, DB_VERSION, STORE_NAME, INDEX_KEY } from "./constants.js";
+
+/**
+ * @param {ServiceWorkerLogger} logger
+ * @returns {Promise<Object|undefined>}
+ * @throws {Error}
+ */
+export default async (logger) => {
+  try {
+    const db = await openIndexedDb(
+      DB_NAME,
+      DB_VERSION,
+      (/** @type {IDBDatabase} */ db) => {
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME, { keyPath: "id" });
+        }
+      },
+    );
+
+    const existingConfigData = await getFromIndexedDbStore(
+      db,
+      STORE_NAME,
+      INDEX_KEY,
+    );
+
+    db.close();
+
+    return existingConfigData;
+  } catch (error) {
+    logger.error("Failed to read data from IndexedDB", { error });
+  }
+};