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

package/src/components/Context/injectEnvironment.js

@@ -0,0 +1,38 @@
+/*
+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.
+*/
+
+import { toInteger } from "@adobe/alloy-core/utils";
+
+export default (window) => {
+  return (event) => {
+    const {
+      document: { documentElement: { clientWidth, clientHeight } = {} },
+    } = window;
+
+    const environment = {
+      type: "browser",
+    };
+
+    const viewportWidth = toInteger(clientWidth);
+    if (viewportWidth >= 0) {
+      environment.browserDetails = { viewportWidth };
+    }
+
+    const viewportHeight = toInteger(clientHeight);
+    if (viewportHeight >= 0) {
+      environment.browserDetails = environment.browserDetails || {};
+      environment.browserDetails.viewportHeight = viewportHeight;
+    }
+
+    event.mergeXdm({ environment });
+  };
+};

package/src/components/Context/injectHighEntropyUserAgentHints.js

@@ -0,0 +1,55 @@
+/*
+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 { noop } from "@adobe/alloy-core/utils";
+import highEntropyUserAgentHints from "@adobe/alloy-core/constants/highEntropyUserAgentClientHints.js";
+
+const browserSupportsUserAgentClientHints = (navigator) => {
+  return "userAgentData" in navigator;
+};
+
+export default (navigator) => {
+  if (!browserSupportsUserAgentClientHints(navigator)) {
+    return noop;
+  }
+  return (event, logger) => {
+    try {
+      // eslint-disable-next-line compat/compat -- Feature detection performed above
+      return navigator.userAgentData
+        .getHighEntropyValues(highEntropyUserAgentHints.map((hint) => hint[0]))
+        .then((hints) => {
+          const userAgentClientHints = {};
+          highEntropyUserAgentHints.forEach(([hintName, hintType]) => {
+            if (
+              Object.prototype.hasOwnProperty.call(hints, hintName) &&
+              /* eslint-disable-next-line valid-typeof */
+              typeof hints[hintName] === hintType
+            ) {
+              userAgentClientHints[hintName] = hints[hintName];
+            }
+          });
+          event.mergeXdm({
+            environment: {
+              browserDetails: {
+                userAgentClientHints,
+              },
+            },
+          });
+        });
+    } catch (error) {
+      logger.warn(
+        `Unable to collect user-agent client hints. ${error.message}`,
+      );
+      return noop;
+    }
+  };
+};

package/src/components/Context/injectOneTimeAnalyticsReferrer.js

@@ -0,0 +1,61 @@
+/*
+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.
+*/
+
+// Because these events are originated by the SDK rather than user actions, don't change the referrer
+const IGNORED_EVENT_TYPES = new Set([
+  "decisioning.propositionFetch",
+  "decisioning.propositionDisplay",
+  "decisioning.propositionInteract",
+]);
+
+export default (window) => {
+  let lastReferrerSent = null;
+
+  return (event) => {
+    const content = event.getContent();
+    const eventType = content.xdm?.eventType;
+
+    if (IGNORED_EVENT_TYPES.has(eventType)) {
+      return;
+    }
+
+    // Allow customers to explicitly set the referrer (for SPA view changes)
+    // Otherwise, use document.referrer
+    // eslint-disable-next-line no-underscore-dangle
+    const explicitReferrer = content.data?.__adobe?.analytics?.referrer;
+    const currentReferrer =
+      explicitReferrer !== undefined
+        ? explicitReferrer
+        : window.document.referrer;
+
+    if (currentReferrer === lastReferrerSent) {
+      event.mergeData({
+        __adobe: {
+          analytics: {
+            referrer: "",
+          },
+        },
+      });
+      return;
+    }
+
+    event.mergeData({
+      __adobe: {
+        analytics: {
+          referrer: currentReferrer,
+        },
+      },
+    });
+
+    lastReferrerSent = currentReferrer;
+  };
+};

package/src/components/Context/injectPlaceContext.js

@@ -0,0 +1,38 @@
+/*
+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.
+*/
+import { toISOStringLocal, toInteger } from "@adobe/alloy-core/utils";
+
+export default (dateProvider) => {
+  return (event) => {
+    const date = dateProvider();
+
+    const placeContext = {};
+
+    const localTimezoneOffset = toInteger(date.getTimezoneOffset());
+    if (localTimezoneOffset !== undefined) {
+      placeContext.localTimezoneOffset = localTimezoneOffset;
+    }
+    // make sure the timezone offset only uses two digits
+    if (
+      localTimezoneOffset === undefined ||
+      Math.abs(localTimezoneOffset) < 6000
+    ) {
+      placeContext.localTime = toISOStringLocal(date);
+    }
+    const ianaTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (ianaTimezone) {
+      placeContext.ianaTimezone = ianaTimezone;
+    }
+
+    event.mergeXdm({ placeContext });
+  };
+};

package/src/components/Context/injectWeb.js

@@ -0,0 +1,26 @@
+/*
+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 (window) => {
+  return (event) => {
+    event.mergeXdm({
+      web: {
+        webPageDetails: {
+          URL: window.location.href || window.location,
+        },
+        webReferrer: {
+          URL: window.document.referrer,
+        },
+      },
+    });
+  };
+};

package/src/components/Personalization/constants/loggerMessage.js

@@ -0,0 +1,14 @@
+/*
+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 const AUTHORING_ENABLED = "Rendering is disabled for authoring mode.";
+export const REDIRECT_EXECUTION_ERROR =
+  "An error occurred while executing the redirect offer.";

package/src/components/Personalization/constants/scopeType.js

@@ -0,0 +1,15 @@
+/*
+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.
+*/
+
+export const VIEW_SCOPE_TYPE = "view";
+export const PAGE_SCOPE_TYPE = "page";
+export const PROPOSITION_SCOPE_TYPE = "proposition";

package/src/components/Personalization/constants/surface.js

@@ -0,0 +1,16 @@
+/*
+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.
+*/
+
+export const WEB = "web";
+export const WEBAPP = "webapp";
+export const SURFACE_TYPE_DELIMITER = "://";
+export const FRAGMENT_DELIMITER = "#";

package/src/components/Personalization/createApplyPropositions.js

@@ -0,0 +1,136 @@
+/*
+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 { defer, isEmptyObject, isNonEmptyArray } from "@adobe/alloy-core/utils";
+import {
+  DEFAULT_CONTENT_ITEM,
+  DOM_ACTION,
+  HTML_CONTENT_ITEM,
+  JSON_CONTENT_ITEM,
+  MESSAGE_IN_APP,
+} from "@adobe/alloy-core/constants/schema.js";
+import PAGE_WIDE_SCOPE from "@adobe/alloy-core/constants/pageWideScope.js";
+import { DOM_ACTION_COLLECT_INTERACTIONS } from "./dom-actions/initDomActionsModules.js";
+
+const isInteractionTrackingItem = (schema, actionType) =>
+  schema === JSON_CONTENT_ITEM &&
+  actionType === DOM_ACTION_COLLECT_INTERACTIONS;
+
+const SUPPORTED_SCHEMAS = {
+  [DOM_ACTION]: () => true,
+  [HTML_CONTENT_ITEM]: () => true,
+  [JSON_CONTENT_ITEM]: isInteractionTrackingItem,
+  [MESSAGE_IN_APP]: () => true,
+  [DEFAULT_CONTENT_ITEM]: () => true,
+};
+
+const filterItemsPredicate = (schema, actionType) =>
+  typeof SUPPORTED_SCHEMAS[schema] === "function" &&
+  SUPPORTED_SCHEMAS[schema](schema, actionType);
+
+export default ({
+  processPropositions,
+  createProposition,
+  renderedPropositions,
+  viewCache,
+}) => {
+  const updatePropositionItems = ({ items, metadataForScope = {} }) => {
+    const { actionType, selector } = metadataForScope;
+
+    return items
+      .filter((item) => filterItemsPredicate(item.schema, actionType))
+      .map((item) => {
+        const { schema } = item;
+
+        if (
+          schema !== HTML_CONTENT_ITEM &&
+          !isInteractionTrackingItem(schema, actionType)
+        ) {
+          return { ...item };
+        }
+        if (!isEmptyObject(metadataForScope)) {
+          return {
+            ...item,
+            schema: isInteractionTrackingItem(schema, actionType)
+              ? DOM_ACTION
+              : schema,
+            data: {
+              ...item.data,
+              selector,
+              type: actionType,
+            },
+          };
+        }
+        return undefined;
+      })
+      .filter((item) => item);
+  };
+
+  const filterPropositionsPredicate = (proposition) => {
+    return !(
+      proposition.scope === PAGE_WIDE_SCOPE && proposition.renderAttempted
+    );
+  };
+
+  const preparePropositions = ({ propositions, metadata }) => {
+    return propositions
+      .filter(filterPropositionsPredicate)
+      .map((proposition) => {
+        if (isNonEmptyArray(proposition.items)) {
+          const { id, scope, scopeDetails } = proposition;
+          return {
+            id,
+            scope,
+            scopeDetails,
+            items: updatePropositionItems({
+              items: proposition.items,
+              metadataForScope: metadata[proposition.scope],
+            }),
+          };
+        }
+        return proposition;
+      })
+      .filter((proposition) => isNonEmptyArray(proposition.items));
+  };
+
+  return ({ propositions = [], metadata = {}, viewName }) => {
+    // We need to immediately call concat so that subsequent sendEvent
+    // calls will wait for applyPropositions to complete before executing.
+    const renderedPropositionsDeferred = defer();
+    renderedPropositions.concat(renderedPropositionsDeferred.promise);
+
+    const propositionsToExecute = preparePropositions({
+      propositions,
+      metadata,
+    }).map((proposition) => createProposition(proposition));
+
+    return Promise.resolve()
+      .then(() => {
+        if (viewName) {
+          return viewCache.getView(viewName);
+        }
+        return [];
+      })
+      .then((additionalPropositions) => {
+        const { render, returnedPropositions } = processPropositions([
+          ...propositionsToExecute,
+          ...additionalPropositions,
+        ]);
+
+        render().then(renderedPropositionsDeferred.resolve);
+
+        return {
+          propositions: returnedPropositions,
+        };
+      });
+  };
+};

package/src/components/Personalization/createClickStorage.js

@@ -0,0 +1,56 @@
+/*
+Copyright 2020 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.
+*/
+
+const metasToArray = (metas) => {
+  return Object.keys(metas).map((key) => {
+    return {
+      id: key,
+      ...metas[key],
+    };
+  });
+};
+
+export default () => {
+  const clickStorage = {};
+
+  const storeClickMeta = ({
+    selector,
+    meta: { id, scope, scopeDetails, trackingLabel, scopeType },
+  }) => {
+    if (!clickStorage[selector]) {
+      clickStorage[selector] = {};
+    }
+    clickStorage[selector][id] = {
+      scope,
+      scopeDetails,
+      trackingLabel,
+      scopeType,
+    };
+  };
+
+  const getClickSelectors = () => {
+    return Object.keys(clickStorage);
+  };
+
+  const getClickMetas = (selector) => {
+    const metas = clickStorage[selector];
+    if (!metas) {
+      return {};
+    }
+    return metasToArray(clickStorage[selector]);
+  };
+  return {
+    storeClickMeta,
+    getClickSelectors,
+    getClickMetas,
+  };
+};

package/src/components/Personalization/createComponent.js

@@ -0,0 +1,133 @@
+/*
+Copyright 2020 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 { noop, isNonEmptyArray } from "@adobe/alloy-core/utils";
+import createPersonalizationDetails from "./createPersonalizationDetails.js";
+import { AUTHORING_ENABLED } from "./constants/loggerMessage.js";
+import { PropositionEventType } from "@adobe/alloy-core/constants/propositionEventType.js";
+import validateApplyPropositionsOptions from "./validateApplyPropositionsOptions.js";
+
+export default ({
+  getPageLocation,
+  logger,
+  fetchDataHandler,
+  viewChangeHandler,
+  onClickHandler,
+  isAuthoringModeEnabled,
+  mergeQuery,
+  viewCache,
+  showContainers,
+  applyPropositions,
+  setTargetMigration,
+  mergeDecisionsMeta,
+  renderedPropositions,
+  onDecisionHandler,
+  handleConsentFlicker,
+}) => {
+  return {
+    lifecycle: {
+      onComponentsRegistered() {
+        handleConsentFlicker();
+      },
+      onDecision: onDecisionHandler,
+      onBeforeRequest({ request }) {
+        setTargetMigration(request);
+        return Promise.resolve();
+      },
+      onBeforeEvent({
+        event,
+        renderDecisions,
+        decisionScopes = [],
+        personalization = {},
+        onResponse = noop,
+        onRequestFailure = noop,
+      }) {
+        // Include propositions on all responses, overridden with data as needed
+        onResponse(() => ({ propositions: [] }));
+        onRequestFailure(() => showContainers());
+
+        if (isAuthoringModeEnabled()) {
+          logger.warn(AUTHORING_ENABLED);
+
+          // If we are in authoring mode we disable personalization
+          mergeQuery(event, { enabled: false });
+          return Promise.resolve();
+        }
+
+        const personalizationDetails = createPersonalizationDetails({
+          getPageLocation,
+          renderDecisions,
+          decisionScopes,
+          personalization,
+          event,
+          isCacheInitialized: viewCache.isInitialized(),
+          logger,
+        });
+
+        const decisionsMetaPromises = [];
+        if (personalizationDetails.shouldIncludeRenderedPropositions()) {
+          decisionsMetaPromises.push(renderedPropositions.clear());
+        }
+
+        if (personalizationDetails.shouldFetchData()) {
+          const cacheUpdate = viewCache.createCacheUpdate(
+            personalizationDetails.getViewName(),
+          );
+          onRequestFailure(() => cacheUpdate.cancel());
+
+          const identityMap = event.getUserIdentityMap();
+
+          fetchDataHandler({
+            cacheUpdate,
+            personalizationDetails,
+            event,
+            onResponse,
+            identityMap,
+          });
+        } else if (personalizationDetails.shouldUseCachedData()) {
+          decisionsMetaPromises.push(
+            viewChangeHandler({
+              personalizationDetails,
+              event,
+              onResponse,
+              onRequestFailure,
+            }),
+          );
+        }
+
+        // This promise.all waits for both the pending display notifications to be resolved
+        // (i.e. the top of page call to finish rendering) and the view change handler to
+        // finish rendering anything for this view.
+        return Promise.all(decisionsMetaPromises).then((decisionsMetas) => {
+          // We only want to call mergeDecisionsMeta once, but we can get the propositions
+          // from two places: the pending display notifications and the view change handler.
+          const decisionsMeta = decisionsMetas.flatMap((dms) => dms);
+          if (isNonEmptyArray(decisionsMeta)) {
+            mergeDecisionsMeta(event, decisionsMeta, [
+              PropositionEventType.DISPLAY,
+            ]);
+          }
+        });
+      },
+      onClick({ event, clickedElement }) {
+        onClickHandler({ event, clickedElement });
+      },
+    },
+    commands: {
+      applyPropositions: {
+        optionsValidator: (options) =>
+          validateApplyPropositionsOptions({ logger, options }),
+        run: applyPropositions,
+      },
+    },
+  };
+};