@adobe/alloy 2.20.0-beta.2 → 2.20.0-beta.6

package/libEs6/components/LegacyMediaAnalytics/index.js

@@ -0,0 +1,67 @@
+/*
+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.
+*/
+/* eslint-disable import/no-restricted-paths */
+
+import createMediaEventManager from "../StreamingMedia/createMediaEventManager.js";
+import createMediaSessionCacheManager from "../StreamingMedia/createMediaSessionCacheManager.js";
+import createTrackMediaEvent from "../StreamingMedia/createTrackMediaEvent.js";
+import createTrackMediaSession from "../StreamingMedia/createTrackMediaSession.js";
+import createMediaResponseHandler from "../StreamingMedia/createMediaResponseHandler.js";
+import createLegacyMediaComponent from "./createLegacyMediaComponent.js";
+import createMediaHelper from "./createMediaHelper.js";
+import createGetInstance from "./createGetInstance.js";
+import injectTimestamp from "../Context/injectTimestamp.js";
+const createLegacyMediaAnalytics = ({
+  eventManager,
+  sendEdgeNetworkRequest,
+  config,
+  logger,
+  consent
+}) => {
+  const mediaSessionCacheManager = createMediaSessionCacheManager({
+    config
+  });
+  const mediaEventManager = createMediaEventManager({
+    sendEdgeNetworkRequest,
+    config,
+    consent,
+    eventManager,
+    setTimestamp: injectTimestamp(() => new Date())
+  });
+  const trackMediaEvent = createTrackMediaEvent({
+    mediaSessionCacheManager,
+    mediaEventManager,
+    config
+  });
+  const trackMediaSession = createTrackMediaSession({
+    config,
+    mediaEventManager,
+    mediaSessionCacheManager,
+    legacy: true
+  });
+  const mediaResponseHandler = createMediaResponseHandler({
+    mediaSessionCacheManager,
+    config,
+    trackMediaEvent
+  });
+  return createLegacyMediaComponent({
+    mediaResponseHandler,
+    trackMediaSession,
+    trackMediaEvent,
+    createMediaHelper,
+    createGetInstance,
+    logger,
+    config
+  });
+};
+createLegacyMediaAnalytics.namespace = "Legacy Media Analytics";
+export default createLegacyMediaAnalytics;

package/libEs6/components/LibraryInfo/index.js

@@ -0,0 +1,59 @@
+/*
+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 libraryVersion from "../../constants/libraryVersion.js";
+import { CONFIGURE, SET_DEBUG } from "../../constants/coreCommands.js";
+const prepareLibraryInfo = ({
+  config,
+  componentRegistry
+}) => {
+  const allCommands = [...componentRegistry.getCommandNames(), CONFIGURE, SET_DEBUG].sort();
+  const resultConfig = {
+    ...config
+  };
+  Object.keys(config).forEach(key => {
+    const value = config[key];
+    if (typeof value !== "function") {
+      return;
+    }
+    resultConfig[key] = value.toString();
+  });
+  const components = componentRegistry.getComponentNames();
+  return {
+    version: libraryVersion,
+    configs: resultConfig,
+    commands: allCommands,
+    components
+  };
+};
+const createLibraryInfo = ({
+  config,
+  componentRegistry
+}) => {
+  const libraryInfo = prepareLibraryInfo({
+    config,
+    componentRegistry
+  });
+  return {
+    commands: {
+      getLibraryInfo: {
+        run: () => {
+          return {
+            libraryInfo
+          };
+        }
+      }
+    }
+  };
+};
+createLibraryInfo.namespace = "LibraryInfo";
+export default createLibraryInfo;

package/libEs6/components/MachineLearning/index.js

@@ -0,0 +1,23 @@
+/*
+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.
+*/
+
+import processResponse from "./processResponse.js";
+const createMachineLearning = () => {
+  return {
+    lifecycle: {
+      onResponse: processResponse
+    },
+    commands: {}
+  };
+};
+createMachineLearning.namespace = "MachineLearning";
+export default createMachineLearning;

package/libEs6/components/MachineLearning/processResponse.js

@@ -0,0 +1,18 @@
+/*
+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 (({
+  response
+}) => {
+  return {
+    inferences: response.getPayloadsByType("rtml:inferences")
+  };
+});

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

@@ -0,0 +1,13 @@
+/*
+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/libEs6/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/libEs6/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/libEs6/components/Personalization/createActionsProvider.js

@@ -0,0 +1,70 @@
+/*
+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 createPreprocessors from "./createPreprocessors.js";
+import { assign } from "../../utils/index.js";
+export default (({
+  modules,
+  preprocessors = createPreprocessors(),
+  logger
+}) => {
+  const logActionError = (action, error) => {
+    if (logger.enabled) {
+      const details = JSON.stringify(action);
+      const {
+        message,
+        stack
+      } = error;
+      const errorMessage = `Failed to execute action ${details}. ${message} ${stack ? `\n ${stack}` : ""}`;
+      logger.warn(errorMessage);
+    }
+  };
+  const logActionCompleted = action => {
+    if (logger.enabled) {
+      const details = JSON.stringify(action);
+      logger.info(`Action ${details} executed.`);
+    }
+  };
+  const getExecuteAction = (schema, type) => {
+    if (!modules[schema] || !modules[schema][type]) {
+      return () => Promise.reject(new Error(`Action "${type}" not found for schema "${schema}"`));
+    }
+    return modules[schema][type];
+  };
+  const applyPreprocessors = action => {
+    const {
+      schema
+    } = action;
+    const preprocessorsList = preprocessors[schema];
+    if (!schema || !(preprocessorsList instanceof Array) || preprocessorsList.length === 0) {
+      return action;
+    }
+    return preprocessorsList.reduce((processed, fn) => assign(processed, fn(processed)), action);
+  };
+  const executeAction = action => {
+    const processedAction = applyPreprocessors(action);
+    const {
+      type,
+      schema
+    } = processedAction;
+    const execute = getExecuteAction(schema, type);
+    return execute(processedAction).then(result => {
+      logActionCompleted(processedAction);
+      return result;
+    }).catch(error => {
+      logActionError(processedAction, error);
+      throw error;
+    });
+  };
+  return {
+    executeAction
+  };
+});

package/libEs6/components/Personalization/createApplyPropositions.js

@@ -0,0 +1,103 @@
+/*
+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 { isNonEmptyArray, isObject, defer } from "../../utils/index.js";
+import { DOM_ACTION, HTML_CONTENT_ITEM, MESSAGE_IN_APP } from "../../constants/schema.js";
+import PAGE_WIDE_SCOPE from "../../constants/pageWideScope.js";
+const SUPPORTED_SCHEMAS = [DOM_ACTION, HTML_CONTENT_ITEM, MESSAGE_IN_APP];
+export default (({
+  processPropositions,
+  createProposition,
+  renderedPropositions,
+  viewCache
+}) => {
+  const filterItemsPredicate = item => SUPPORTED_SCHEMAS.indexOf(item.schema) > -1;
+  const updatePropositionItems = ({
+    items,
+    metadataForScope
+  }) => {
+    return items.filter(filterItemsPredicate).map(item => {
+      if (item.schema !== HTML_CONTENT_ITEM) {
+        return {
+          ...item
+        };
+      }
+      if (isObject(metadataForScope)) {
+        return {
+          ...item,
+          data: {
+            ...item.data,
+            selector: metadataForScope.selector,
+            type: metadataForScope.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/libEs6/components/Personalization/createClickStorage.js

@@ -0,0 +1,58 @@
+/*
+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 storeClickMetrics = ({
+    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 getClickMetasBySelector = selector => {
+    const metas = clickStorage[selector];
+    if (!metas) {
+      return {};
+    }
+    return metasToArray(clickStorage[selector]);
+  };
+  return {
+    storeClickMetrics,
+    getClickSelectors,
+    getClickMetasBySelector
+  };
+});

package/libEs6/components/Personalization/createCollect.js

@@ -0,0 +1,48 @@
+/*
+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 { DISPLAY } from "../../constants/eventType.js";
+import { getPropositionEventType } from "../../constants/propositionEventType.js";
+import { isNonEmptyArray } from "../../utils/index.js";
+export default (({
+  eventManager,
+  mergeDecisionsMeta
+}) => {
+  // Called when a decision is auto-rendered for the __view__ scope or a SPA view(display and empty display notification)
+  return ({
+    decisionsMeta = [],
+    propositionAction,
+    documentMayUnload = false,
+    eventType = DISPLAY,
+    propositionEventTypes = [getPropositionEventType(eventType)],
+    viewName
+  }) => {
+    const event = eventManager.createEvent();
+    const data = {
+      eventType
+    };
+    if (viewName) {
+      data.web = {
+        webPageDetails: {
+          viewName
+        }
+      };
+    }
+    if (isNonEmptyArray(decisionsMeta)) {
+      mergeDecisionsMeta(event, decisionsMeta, propositionEventTypes, propositionAction);
+    }
+    event.mergeXdm(data);
+    if (documentMayUnload) {
+      event.documentMayUnload();
+    }
+    return eventManager.sendEvent(event);
+  };
+});

package/libEs6/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, flatMap, isNonEmptyArray } from "../../utils/index.js";
+import createPersonalizationDetails from "./createPersonalizationDetails.js";
+import { AUTHORING_ENABLED } from "./constants/loggerMessage.js";
+import { PropositionEventType } from "../../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());
+          fetchDataHandler({
+            cacheUpdate,
+            personalizationDetails,
+            event,
+            onResponse
+          });
+        } else if (personalizationDetails.shouldUseCachedData()) {
+          // eslint-disable-next-line consistent-return
+          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 = flatMap(decisionsMetas, 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
+      }
+    }
+  };
+});