@adobe/alloy 2.20.0-alpha.1 → 2.20.0-beta.0

package/libEs6/components/LegacyMediaAnalytics/createGetInstance.js

@@ -0,0 +1,240 @@
+/*
+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.
+*/
+import { EVENT, MEDIA_EVENTS_INTERNAL } from "./constants/constants";
+import { includes, isEmptyObject, isNonEmptyArray, isNumber } from "../../utils";
+import { adsToXdmKeys, mediaToXdmKeys } from "./constants/mediaKeysToXdmConverter";
+export default (({
+  logger,
+  trackMediaSession,
+  trackMediaEvent,
+  uuid
+}) => {
+  let trackerState = {
+    qoe: null,
+    lastPlayhead: 0,
+    playerId: uuid()
+  };
+  const getEventType = ({
+    eventType
+  }) => {
+    if (eventType === EVENT.BufferComplete || eventType === EVENT.SeekComplete) {
+      return MEDIA_EVENTS_INTERNAL.Play;
+    }
+    if (eventType === EVENT.StateStart || eventType === EVENT.StateEnd) {
+      return MEDIA_EVENTS_INTERNAL.StateUpdate;
+    }
+    if (eventType === EVENT.SeekStart) {
+      return MEDIA_EVENTS_INTERNAL.Pause;
+    }
+    return eventType;
+  };
+  const createXdmObject = ({
+    eventType,
+    mediaDetails = {},
+    contextData = []
+  }) => {
+    const action = getEventType({
+      eventType
+    });
+    if (eventType === EVENT.StateStart) {
+      const xdm = {
+        eventType: `media.${action}`,
+        mediaCollection: {
+          statesStart: [mediaDetails]
+        }
+      };
+      return xdm;
+    }
+    if (eventType === EVENT.StateEnd) {
+      const xdm = {
+        eventType: `media.${action}`,
+        mediaCollection: {
+          statesEnd: [mediaDetails]
+        }
+      };
+      return xdm;
+    }
+    const xdm = {
+      eventType: `media.${action}`,
+      mediaCollection: {
+        ...mediaDetails
+      }
+    };
+    const customMetadata = [];
+    Object.keys(contextData).forEach(key => {
+      if (mediaToXdmKeys[key]) {
+        xdm.mediaCollection.sessionDetails[mediaToXdmKeys[key]] = contextData[key];
+      } else if (adsToXdmKeys[key]) {
+        xdm.mediaCollection.advertisingDetails[adsToXdmKeys[key]] = contextData[key];
+      } else {
+        customMetadata.push({
+          name: key,
+          value: contextData[key]
+        });
+      }
+    });
+    if (isNonEmptyArray(customMetadata)) {
+      xdm.mediaCollection.customMetadata = customMetadata;
+    }
+    return xdm;
+  };
+  return {
+    trackSessionStart: (mediaObject, contextData = {}) => {
+      if (isEmptyObject(mediaObject)) {
+        logger.warn("Invalid media object");
+        return {};
+      }
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed. Restarting a new session.");
+        trackerState = {
+          qoe: null,
+          lastPlayhead: 0,
+          playerId: uuid()
+        };
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.SessionStart,
+        mediaDetails: mediaObject,
+        contextData
+      });
+      return trackMediaSession({
+        playerId: trackerState.playerId,
+        getPlayerDetails: () => {
+          return {
+            playhead: trackerState.lastPlayhead,
+            qoeDataDetails: trackerState.qoe
+          };
+        },
+        xdm
+      });
+    },
+    trackPlay: () => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.Play
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackPause: () => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.Pause
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackSessionEnd: () => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.SessionEnd
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackComplete: () => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.SessionComplete
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackError: errorId => {
+      logger.warn(`trackError(${errorId})`);
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const errorDetails = {
+        name: errorId,
+        source: "player"
+      };
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.Error,
+        mediaDetails: {
+          errorDetails
+        }
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackEvent: (eventType, info, context) => {
+      if (isEmptyObject(info)) {
+        logger.warn("Invalid media object.");
+        return {};
+      }
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      if (!includes(Object.values(EVENT), eventType)) {
+        logger.warn("Invalid event type");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType,
+        mediaDetails: info,
+        contextData: context
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    updatePlayhead: time => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return;
+      }
+      if (isNumber(time)) {
+        trackerState.lastPlayhead = parseInt(time, 10);
+      }
+    },
+    updateQoEObject: qoeObject => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return;
+      }
+      if (!qoeObject) {
+        return;
+      }
+      trackerState.qoe = qoeObject;
+    },
+    destroy: () => {
+      logger.warn("Destroy called, destroying the tracker.");
+      trackerState = null;
+    }
+  };
+});

package/libEs6/components/LegacyMediaAnalytics/createLegacyMediaComponent.js

@@ -0,0 +1,85 @@
+/*
+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.
+*/
+
+import { noop, uuid } from "../../utils";
+import { AD_METADATA_KEYS as AdMetadataKeys, AUDIO_METADATA_KEYS as AudioMetadataKeys, EVENT as Event, MEDIA_OBJECT_KEYS as MediaObjectKey, MEDIA_TYPE as MediaType, PLAYER_STATE as PlayerState, STREAM_TYPE as StreamType, VIDEO_METADATA_KEYS as VideoMetadataKeys } from "./constants/constants";
+export default (({
+  trackMediaEvent,
+  trackMediaSession,
+  mediaResponseHandler,
+  logger,
+  createMediaHelper,
+  createGetInstance,
+  config
+}) => {
+  return {
+    lifecycle: {
+      onBeforeEvent({
+        mediaOptions,
+        onResponse = noop
+      }) {
+        if (!mediaOptions) {
+          return;
+        }
+        const {
+          legacy,
+          playerId,
+          getPlayerDetails
+        } = mediaOptions;
+        if (!legacy) {
+          return;
+        }
+        onResponse(({
+          response
+        }) => {
+          return mediaResponseHandler({
+            playerId,
+            getPlayerDetails,
+            response
+          });
+        });
+      }
+    },
+    commands: {
+      getMediaAnalyticsTracker: {
+        run: () => {
+          if (!config.streamingMedia) {
+            return Promise.reject(new Error("Streaming media is not configured."));
+          }
+          logger.info("Streaming media is configured in legacy mode.");
+          const mediaAnalyticsHelper = createMediaHelper({
+            logger
+          });
+          return Promise.resolve({
+            getInstance: () => {
+              return createGetInstance({
+                logger,
+                trackMediaEvent,
+                trackMediaSession,
+                uuid
+              });
+            },
+            Event,
+            MediaType,
+            PlayerState,
+            StreamType,
+            MediaObjectKey,
+            VideoMetadataKeys,
+            AudioMetadataKeys,
+            AdMetadataKeys,
+            ...mediaAnalyticsHelper
+          });
+        }
+      }
+    }
+  };
+});

package/libEs6/components/LegacyMediaAnalytics/createMediaHelper.js

@@ -131,15 +131,12 @@ export default (({
     }
   };
   const createStateObject = stateName => {
-    const STATE_NAME_REGEX = "^[a-zA-Z0-9_]{1,64}$";
+    const STATE_NAME_REGEX = new RegExp("^[a-zA-Z0-9_]{1,64}$");
     const validator = string().matches(STATE_NAME_REGEX, "This is not a valid state name.");
     try {
       const result = validator(stateName);
-      const stateDetails = {
-        name: result
-      };
       return {
-        stateDetails
+        name: result
       };
     } catch (error) {
       logger.warn(`An error occurred while creating the State Object.`, error);
@@ -161,14 +158,11 @@ export default (({
     });
     try {
       const result = validator(qoeObject);
-      const qoeDetails = {
+      return {
         bitrate: result.bitrate,
         droppedFrames: result.droppedFrames,
-        fps: result.fps,
-        startupTime: result.startupTime
-      };
-      return {
-        qoeDetails
+        framesPerSecond: result.fps,
+        timeToStart: result.startupTime
       };
     } catch (error) {
       logger.warn(`An error occurred while creating the QOE Object.`, error);

package/libEs6/components/LegacyMediaAnalytics/index.js

@@ -1,5 +1,5 @@
 /*
-Copyright 2023 Adobe. All rights reserved.
+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
@@ -11,8 +11,15 @@ governing permissions and limitations under the License.
 */
 /* eslint-disable import/no-restricted-paths */
 
-import { createMediaAnalyticsTracker } from "./createMediaAnalyticsTracker";
-import createMediaEventManager from "../MediaCollection/createMediaEventManager";
+import createMediaEventManager from "../StreamingMedia/createMediaEventManager";
+import createMediaSessionCacheManager from "../StreamingMedia/createMediaSessionCacheManager";
+import createTrackMediaEvent from "../StreamingMedia/createTrackMediaEvent";
+import createTrackMediaSession from "../StreamingMedia/createTrackMediaSession";
+import createMediaResponseHandler from "../StreamingMedia/createMediaResponseHandler";
+import createLegacyMediaComponent from "./createLegacyMediaComponent";
+import createMediaHelper from "./createMediaHelper";
+import createGetInstance from "./createGetInstance";
+import injectTimestamp from "../Context/injectTimestamp";
 const createLegacyMediaAnalytics = ({
   eventManager,
   sendEdgeNetworkRequest,
@@ -20,26 +27,41 @@ const createLegacyMediaAnalytics = ({
   logger,
   consent
 }) => {
+  const mediaSessionCacheManager = createMediaSessionCacheManager({
+    config
+  });
   const mediaEventManager = createMediaEventManager({
     sendEdgeNetworkRequest,
     config,
-    logger,
     consent,
-    eventManager
+    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
   });
-  return {
-    commands: {
-      getMediaAnalyticsTracker: {
-        run: () => {
-          return createMediaAnalyticsTracker({
-            config,
-            logger,
-            mediaEventManager
-          });
-        }
-      }
-    }
-  };
 };
 createLegacyMediaAnalytics.namespace = "Legacy Media Analytics";
 export default createLegacyMediaAnalytics;

package/libEs6/components/LibraryInfo/index.js

@@ -27,10 +27,12 @@ const prepareLibraryInfo = ({
     }
     resultConfig[key] = value.toString();
   });
+  const components = componentRegistry.getComponentNames();
   return {
     version: libraryVersion,
     configs: resultConfig,
-    commands: allCommands
+    commands: allCommands,
+    components
   };
 };
 const createLibraryInfo = ({

package/libEs6/components/Personalization/createComponent.js

@@ -29,10 +29,14 @@ export default (({
   setTargetMigration,
   mergeDecisionsMeta,
   renderedPropositions,
-  onDecisionHandler
+  onDecisionHandler,
+  handleConsentFlicker
 }) => {
   return {
     lifecycle: {
+      onComponentsRegistered() {
+        handleConsentFlicker();
+      },
       onDecision: onDecisionHandler,
       onBeforeRequest({
         request

package/libEs6/components/Personalization/createFetchDataHandler.js

@@ -18,7 +18,8 @@ export default (({
   mergeQuery,
   processPropositions,
   createProposition,
-  notificationHandler
+  notificationHandler,
+  consent
 }) => {
   return ({
     cacheUpdate,
@@ -26,13 +27,22 @@ export default (({
     event,
     onResponse
   }) => {
-    if (personalizationDetails.isRenderDecisions()) {
-      hideContainers(prehidingStyle);
-    } else {
-      showContainers();
+    const {
+      state,
+      wasSet
+    } = consent.current();
+    if (!(state === "out" && wasSet)) {
+      if (personalizationDetails.isRenderDecisions()) {
+        hideContainers(prehidingStyle);
+      } else {
+        showContainers();
+      }
     }
     mergeQuery(event, personalizationDetails.createQueryDetails());
-    const handleNotifications = notificationHandler(personalizationDetails.isSendDisplayEvent(), personalizationDetails.getViewName());
+
+    // This needs to be called before the response so that future sendEvent calls
+    // can know to wait until this request is complete for pending display notifications.
+    const handleNotifications = notificationHandler(personalizationDetails.isRenderDecisions(), personalizationDetails.isSendDisplayEvent(), personalizationDetails.getViewName());
     onResponse(({
       response
     }) => {

package/libEs6/components/Personalization/createHandleConsentFlicker.js

@@ -0,0 +1,26 @@
+/*
+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.
+*/
+import { OUT } from "../../constants/consentStatus";
+export default (({
+  showContainers,
+  consent
+}) => () => {
+  const {
+    state,
+    wasSet
+  } = consent.current();
+  if (state === OUT && wasSet) {
+    showContainers();
+  } else {
+    consent.awaitConsent().catch(showContainers);
+  }
+});

package/libEs6/components/Personalization/createNotificationHandler.js

@@ -11,8 +11,12 @@ governing permissions and limitations under the License.
 */
 import { defer } from "../../utils";
 export default ((collect, renderedPropositions) => {
-  return (sendDisplayEvent, viewName) => {
-    if (!sendDisplayEvent) {
+  return (isRenderDecisions, isSendDisplayEvent, viewName) => {
+    if (!isRenderDecisions) {
+      // If we aren't rendering anything, then we don't need to sendDisplayEvents.
+      return () => undefined;
+    }
+    if (!isSendDisplayEvent) {
       const renderedPropositionsDeferred = defer();
       renderedPropositions.concat(renderedPropositionsDeferred.promise);
       return renderedPropositionsDeferred.resolve;

package/libEs6/components/Personalization/createOnDecisionHandler.js

@@ -33,7 +33,7 @@ export default (({
       render,
       returnedPropositions
     } = processPropositions(propositionsToExecute);
-    const handleNotifications = notificationHandler(sendDisplayEvent, viewName);
+    const handleNotifications = notificationHandler(renderDecisions, sendDisplayEvent, viewName);
     render().then(handleNotifications);
     return Promise.resolve({
       propositions: returnedPropositions

package/libEs6/components/Personalization/handlers/createProcessRedirect.js

@@ -33,7 +33,6 @@ export default (({
       // there is a redirect.
     });
   };
-
   return {
     render,
     setRenderAttempted: true,

package/libEs6/components/Personalization/index.js

@@ -43,10 +43,12 @@ import createProcessInAppMessage from "./handlers/createProcessInAppMessage";
 import initInAppMessageActionsModules from "./in-app-message-actions/initInAppMessageActionsModules";
 import createRedirect from "./dom-actions/createRedirect";
 import createNotificationHandler from "./createNotificationHandler";
+import createHandleConsentFlicker from "./createHandleConsentFlicker";
 const createPersonalization = ({
   config,
   logger,
-  eventManager
+  eventManager,
+  consent
 }) => {
   const {
     targetMigrationEnabled,
@@ -108,7 +110,8 @@ const createPersonalization = ({
     mergeQuery,
     processPropositions,
     createProposition,
-    notificationHandler
+    notificationHandler,
+    consent
   });
   const onClickHandler = createOnClickHandler({
     mergeDecisionsMeta,
@@ -134,6 +137,10 @@ const createPersonalization = ({
     createProposition,
     notificationHandler
   });
+  const handleConsentFlicker = createHandleConsentFlicker({
+    showContainers,
+    consent
+  });
   return createComponent({
     getPageLocation,
     logger,
@@ -148,7 +155,8 @@ const createPersonalization = ({
     setTargetMigration,
     mergeDecisionsMeta,
     renderedPropositions,
-    onDecisionHandler
+    onDecisionHandler,
+    handleConsentFlicker
   });
 };
 createPersonalization.namespace = "Personalization";

package/libEs6/components/StreamingMedia/configValidators.js

@@ -0,0 +1,22 @@
+/*
+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.
+*/
+
+import { number, objectOf, string } from "../../utils/validation";
+export default objectOf({
+  streamingMedia: objectOf({
+    channel: string().nonEmpty().required(),
+    playerName: string().nonEmpty().required(),
+    appVersion: string(),
+    mainPingInterval: number().minimum(10).maximum(50).default(10),
+    adPingInterval: number().minimum(1).maximum(10).default(10)
+  }).noUnknownFields()
+});

package/libEs6/components/StreamingMedia/constants/eventTypes.js

@@ -0,0 +1,31 @@
+/*
+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 {
+  PAUSE: "media.pauseStart",
+  PLAY: "media.play",
+  BUFFER_START: "media.bufferStart",
+  AD_START: "media.adStart",
+  Ad_BREAK_START: "media.adBreakStart",
+  SESSION_END: "media.sessionEnd",
+  SESSION_START: "media.sessionStart",
+  SESSION_COMPLETE: "media.sessionComplete",
+  PING: "media.ping",
+  AD_BREAK_COMPLETE: "media.adBreakComplete",
+  AD_COMPLETE: "media.adComplete",
+  AD_SKIP: "media.adSkip",
+  BITRATE_CHANGE: "media.bitrateChange",
+  CHAPTER_COMPLETE: "media.chapterComplete",
+  CHAPTER_SKIP: "media.chapterSkip",
+  CHAPTER_START: "media.chapterStart",
+  ERROR: "media.error",
+  STATES_UPDATE: "media.statesUpdate"
+};