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

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/{MediaCollection/createUpdateMediaSessionState.js → Personalization/createHandleConsentFlicker.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
@@ -9,28 +9,18 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-
-import MediaEvents from "./mediaConstants/mediaEvents";
+import { OUT } from "../../constants/consentStatus";
 export default (({
-  mediaSessionCacheManager
-}) => {
-  return ({
-    playerId,
-    xdm
-  }) => {
-    if (!playerId) {
-      return;
-    }
-    const {
-      eventType
-    } = xdm;
-    if (eventType === MediaEvents.SESSION_COMPLETE || eventType === MediaEvents.SESSION_END) {
-      mediaSessionCacheManager.stopHeartbeat({
-        playerId
-      });
-    }
-    mediaSessionCacheManager.updateLastTriggeredEventTS({
-      playerId
-    });
-  };
+  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"
+};

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

@@ -0,0 +1,16 @@
+/*
+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 default {
+  MAIN: "main",
+  AD: "ad",
+  COMPLETED: "completed"
+};

package/libEs6/components/{MediaCollection → StreamingMedia}/createMediaEventManager.js

@@ -9,48 +9,59 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 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 MediaEvents from "./mediaConstants/mediaEvents";
-import createMediaRequestPayload from "./createMediaRequestPayload";
+import MediaEvents from "./constants/eventTypes";
 import createMediaRequest from "./createMediaRequest";
-import injectTimestamp from "../Context/injectTimestamp";
-import { deepAssign, toInteger } from "../../utils";
+import { toInteger } from "../../utils";
+import { createDataCollectionRequestPayload } from "../../utils/request";
 export default (({
   config,
   eventManager,
   consent,
-  sendEdgeNetworkRequest
+  sendEdgeNetworkRequest,
+  setTimestamp
 }) => {
   return {
     createMediaEvent({
       options
     }) {
+      const event = eventManager.createEvent();
       const {
-        xdm = {}
-      } = options;
-      const event = {
         xdm
-      };
-      const timestamp = injectTimestamp(() => new Date());
-      timestamp(event.xdm);
+      } = options;
+      setTimestamp(xdm);
+      event.setUserXdm(xdm);
+      if (xdm.eventType === MediaEvents.AD_START) {
+        const {
+          advertisingDetails
+        } = options.xdm.mediaCollection;
+        event.mergeXdm({
+          mediaCollection: {
+            advertisingDetails: {
+              playerName: advertisingDetails.playerName || config.streamingMedia.playerName
+            }
+          }
+        });
+      }
       return event;
     },
     createMediaSession(options) {
       const {
         playerName,
         channel,
-        version
-      } = config.mediaCollection;
+        appVersion
+      } = config.streamingMedia;
       const event = eventManager.createEvent();
+      const {
+        sessionDetails
+      } = options.xdm.mediaCollection;
       event.setUserXdm(options.xdm);
       event.mergeXdm({
         eventType: MediaEvents.SESSION_START,
         mediaCollection: {
           sessionDetails: {
-            playerName: options.xdm.mediaCollection.sessionDetails.playerName || playerName,
-            channel: options.xdm.mediaCollection.sessionDetails.channel || channel,
-            appVersion: options.xdm.mediaCollection.sessionDetails.appVersion || version
+            playerName: sessionDetails.playerName || playerName,
+            channel: sessionDetails.channel || channel,
+            appVersion: sessionDetails.appVersion || appVersion
           }
         }
       });
@@ -59,57 +70,46 @@ export default (({
     augmentMediaEvent({
       event,
       playerId,
-      onBeforeMediaEvent,
+      getPlayerDetails,
       sessionID
     }) {
-      if (!playerId || !onBeforeMediaEvent) {
+      if (!playerId || !getPlayerDetails) {
         return event;
       }
       const {
         playhead,
         qoeDataDetails
-      } = onBeforeMediaEvent({
+      } = getPlayerDetails({
         playerId
       });
-      if (event.mergeXdm) {
-        event.mergeXdm({
-          mediaCollection: {
-            playhead: toInteger(playhead),
-            qoeDataDetails
-          }
-        });
-        return event;
-      }
-      return deepAssign(event, {
-        xdm: {
-          mediaCollection: {
-            playhead: toInteger(playhead),
-            qoeDataDetails,
-            sessionID
-          }
+      event.mergeXdm({
+        mediaCollection: {
+          playhead: toInteger(playhead),
+          qoeDataDetails,
+          sessionID
         }
       });
+      return event;
     },
     trackMediaSession({
       event,
-      playerId,
-      onBeforeMediaEvent
+      mediaOptions
     }) {
       return eventManager.sendEvent(event, {
-        playerId,
-        onBeforeMediaEvent
+        mediaOptions
       });
     },
     trackMediaEvent({
-      event
+      event,
+      action
     }) {
-      const action = event.xdm.eventType.split(".")[1];
-      const mediaRequestPayload = createMediaRequestPayload();
+      const mediaRequestPayload = createDataCollectionRequestPayload();
       const request = createMediaRequest({
         mediaRequestPayload,
         action
       });
       mediaRequestPayload.addEvent(event);
+      event.finalize();
       return consent.awaitConsent().then(() => {
         return sendEdgeNetworkRequest({
           request

package/libEs6/components/StreamingMedia/createMediaResponseHandler.js

@@ -0,0 +1,58 @@
+/*
+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 isBlankString from "../../utils/isBlankString";
+import MediaEvents from "./constants/eventTypes";
+import { isNonEmptyArray } from "../../utils";
+import PlaybackState from "./constants/playbackState";
+export default (({
+  mediaSessionCacheManager,
+  config,
+  trackMediaEvent
+}) => {
+  return ({
+    response,
+    playerId,
+    getPlayerDetails
+  }) => {
+    const mediaPayload = response.getPayloadsByType("media-analytics:new-session");
+    if (isNonEmptyArray(mediaPayload)) {
+      const {
+        sessionId
+      } = mediaPayload[0];
+      if (isBlankString(sessionId)) {
+        return {};
+      }
+      if (!playerId || !getPlayerDetails) {
+        return {
+          sessionId
+        };
+      }
+      const pingId = setTimeout(() => {
+        trackMediaEvent({
+          playerId,
+          xdm: {
+            eventType: MediaEvents.PING
+          }
+        });
+      }, config.streamingMedia.mainPingInterval * 1000);
+      mediaSessionCacheManager.savePing({
+        playerId,
+        pingId,
+        playbackState: PlaybackState.MAIN
+      });
+      return {
+        sessionId
+      };
+    }
+    return {};
+  };
+});

package/libEs6/components/{MediaCollection → StreamingMedia}/createMediaSessionCacheManager.js

@@ -10,39 +10,36 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
+import PlaybackState from "./constants/playbackState";
 export default (() => {
   let mediaSessionCache;
   const getSession = playerId => {
     return mediaSessionCache[playerId] || {};
   };
-  const saveHeartbeat = ({
+  const savePing = ({
     playerId,
-    heartbeatId
+    pingId,
+    playbackState
   }) => {
-    const mediaSession = mediaSessionCache[playerId];
-    if (!mediaSession) {
+    if (!mediaSessionCache[playerId]) {
       return;
     }
-    mediaSession.heartbeatId = heartbeatId;
-  };
-  const stopHeartbeat = ({
-    playerId
-  }) => {
-    const mediaSession = mediaSessionCache[playerId];
-    if (!mediaSession) {
-      return;
+    if (mediaSessionCache[playerId].pingId) {
+      clearTimeout(mediaSessionCache[playerId].pingId);
     }
-    clearInterval(mediaSession.heartbeatId);
-    mediaSession.heartbeatId = null;
+    mediaSessionCache[playerId].pingId = pingId;
+    mediaSessionCache[playerId].playbackState = playbackState;
   };
-  const updateLastTriggeredEventTS = ({
+  const stopPing = ({
     playerId
   }) => {
-    const player = mediaSessionCache[playerId];
-    if (!player) {
+    const sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
       return;
     }
-    player.latestTriggeredEvent = Date.now();
+    clearTimeout(sessionDetails.pingId);
+    sessionDetails.pingId = null;
+    sessionDetails.playbackState = PlaybackState.COMPLETED;
   };
   const storeSession = ({
     playerId,
@@ -55,9 +52,8 @@ export default (() => {
   };
   return {
     getSession,
-    stopHeartbeat,
-    updateLastTriggeredEventTS,
     storeSession,
-    saveHeartbeat
+    stopPing,
+    savePing
   };
 });