@adobe/alloy 2.28.0 → 2.28.1-beta.1

package/libEs6/components/RulesEngine/utils/getExpirationDate.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 default retentionPeriod => {
+  const expirationDate = new Date();
+  expirationDate.setDate(expirationDate.getDate() - retentionPeriod);
+  return expirationDate;
+};

package/libEs6/components/RulesEngine/utils/getPropositionData.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 getActivityId = proposition => proposition?.scopeDetails?.activity?.id;
+export const getDecisionProvider = proposition => proposition?.scopeDetails?.decisionProvider;

package/libEs6/components/RulesEngine/utils/hasExperienceData.js

@@ -0,0 +1,17 @@
+/*
+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 default xdm => {
+  const {
+    _experience
+  } = xdm || {};
+  return !!_experience && typeof _experience === "object";
+};

package/libEs6/components/RulesEngine/utils/index.js

@@ -0,0 +1,18 @@
+/*
+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 { default as generateEventHash } from "./generateEventHash.js";
+export { default as getExpirationDate } from "./getExpirationDate.js";
+export { default as createEventPruner } from "./createEventPruner.js";
+export { default as hasExperienceData } from "./hasExperienceData.js";
+export { getActivityId, getDecisionProvider } from "./getPropositionData.js";
+export { createRestoreStorage, createSaveStorage, createInMemoryStorage, clearLocalStorage } from "./storage.js";

package/libEs6/components/RulesEngine/utils/storage.js

@@ -0,0 +1,40 @@
+/*
+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 createRestoreStorage = (storage, storageKey) => {
+  return defaultValue => {
+    try {
+      const stored = storage.getItem(storageKey);
+      const s = JSON.parse(stored);
+      return [s, stored.length];
+      // eslint-disable-next-line no-empty
+    } catch {}
+    return [defaultValue, 0];
+  };
+};
+export const createSaveStorage = (storage, storageKey) => value => {
+  storage.setItem(storageKey, JSON.stringify(value));
+};
+export const createInMemoryStorage = () => {
+  const inMemoryStorage = {};
+  return {
+    getItem: key => {
+      return key in inMemoryStorage ? inMemoryStorage[key] : null;
+    },
+    setItem: (key, value) => {
+      inMemoryStorage[key] = value;
+    }
+  };
+};
+export const clearLocalStorage = storage => {
+  storage.clear();
+};

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/index.js";
+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/StreamingMedia/createMediaEventManager.js

@@ -0,0 +1,125 @@
+/*
+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 MediaEvents from "./constants/eventTypes.js";
+import createMediaRequest from "./createMediaRequest.js";
+import { toInteger } from "../../utils/index.js";
+import { createDataCollectionRequestPayload } from "../../utils/request/index.js";
+export default ({
+  config,
+  eventManager,
+  consent,
+  sendEdgeNetworkRequest,
+  setTimestamp
+}) => {
+  return {
+    createMediaEvent({
+      options
+    }) {
+      const event = eventManager.createEvent();
+      const {
+        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,
+        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: sessionDetails.playerName || playerName,
+            channel: sessionDetails.channel || channel,
+            appVersion: sessionDetails.appVersion || appVersion
+          }
+        }
+      });
+      return event;
+    },
+    augmentMediaEvent({
+      event,
+      playerId,
+      getPlayerDetails,
+      sessionID
+    }) {
+      if (!playerId || !getPlayerDetails) {
+        return event;
+      }
+      const {
+        playhead,
+        qoeDataDetails
+      } = getPlayerDetails({
+        playerId
+      });
+      event.mergeXdm({
+        mediaCollection: {
+          playhead: toInteger(playhead),
+          qoeDataDetails,
+          sessionID
+        }
+      });
+      return event;
+    },
+    trackMediaSession({
+      event,
+      mediaOptions,
+      edgeConfigOverrides
+    }) {
+      const sendEventOptions = {
+        mediaOptions,
+        edgeConfigOverrides
+      };
+      return eventManager.sendEvent(event, sendEventOptions);
+    },
+    trackMediaEvent({
+      event,
+      action
+    }) {
+      const mediaRequestPayload = createDataCollectionRequestPayload();
+      const request = createMediaRequest({
+        mediaRequestPayload,
+        action
+      });
+      mediaRequestPayload.addEvent(event);
+      event.finalize();
+      return consent.awaitConsent().then(() => {
+        return sendEdgeNetworkRequest({
+          request
+        }).then(() => {
+          return {};
+        });
+      });
+    }
+  };
+};

package/libEs6/components/StreamingMedia/createMediaRequest.js

@@ -0,0 +1,28 @@
+/*
+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 { createRequest } from "../../utils/request/index.js";
+export default ({
+  mediaRequestPayload,
+  action
+}) => {
+  return createRequest({
+    payload: mediaRequestPayload,
+    edgeSubPath: "/va",
+    getAction() {
+      return action;
+    },
+    getUseSendBeacon() {
+      return false;
+    }
+  });
+};

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.js";
+import MediaEvents from "./constants/eventTypes.js";
+import { isNonEmptyArray } from "../../utils/index.js";
+import PlaybackState from "./constants/playbackState.js";
+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/StreamingMedia/createMediaSessionCacheManager.js

@@ -0,0 +1,59 @@
+/*
+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 PlaybackState from "./constants/playbackState.js";
+export default () => {
+  let mediaSessionCache;
+  const getSession = playerId => {
+    return mediaSessionCache[playerId] || {};
+  };
+  const savePing = ({
+    playerId,
+    pingId,
+    playbackState
+  }) => {
+    if (!mediaSessionCache[playerId]) {
+      return;
+    }
+    if (mediaSessionCache[playerId].pingId) {
+      clearTimeout(mediaSessionCache[playerId].pingId);
+    }
+    mediaSessionCache[playerId].pingId = pingId;
+    mediaSessionCache[playerId].playbackState = playbackState;
+  };
+  const stopPing = ({
+    playerId
+  }) => {
+    const sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
+      return;
+    }
+    clearTimeout(sessionDetails.pingId);
+    sessionDetails.pingId = null;
+    sessionDetails.playbackState = PlaybackState.COMPLETED;
+  };
+  const storeSession = ({
+    playerId,
+    sessionDetails
+  }) => {
+    if (mediaSessionCache === undefined) {
+      mediaSessionCache = {};
+    }
+    mediaSessionCache[playerId] = sessionDetails;
+  };
+  return {
+    getSession,
+    storeSession,
+    stopPing,
+    savePing
+  };
+};

package/libEs6/components/StreamingMedia/createStreamingMediaComponent.js

@@ -0,0 +1,69 @@
+/*
+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 } from "../../utils/index.js";
+import validateSessionOptions from "./validateMediaSessionOptions.js";
+import validateMediaEventOptions from "./validateMediaEventOptions.js";
+export default ({
+  config,
+  trackMediaEvent,
+  trackMediaSession,
+  mediaResponseHandler
+}) => {
+  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: {
+      createMediaSession: {
+        optionsValidator: options => validateSessionOptions({
+          options
+        }),
+        run: trackMediaSession
+      },
+      sendMediaEvent: {
+        optionsValidator: options => validateMediaEventOptions({
+          options
+        }),
+        run: options => {
+          if (!config.streamingMedia) {
+            return Promise.reject(new Error("Streaming media is not configured."));
+          }
+          return trackMediaEvent(options);
+        }
+      }
+    }
+  };
+};

package/libEs6/components/StreamingMedia/createTrackMediaEvent.js

@@ -0,0 +1,93 @@
+/*
+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 MediaEvents from "./constants/eventTypes.js";
+const getContentState = (eventType, sessionContentState) => {
+  if (eventType === MediaEvents.AD_START || eventType === MediaEvents.Ad_BREAK_START || eventType === MediaEvents.AD_SKIP || eventType === MediaEvents.AD_COMPLETE) {
+    return "ad";
+  }
+  if (eventType === MediaEvents.AD_BREAK_COMPLETE || eventType === MediaEvents.CHAPTER_COMPLETE || eventType === MediaEvents.CHAPTER_START || eventType === MediaEvents.CHAPTER_SKIP || eventType === MediaEvents.SESSION_START) {
+    return "main";
+  }
+  if (eventType === MediaEvents.SESSION_END || eventType === MediaEvents.SESSION_COMPLETE) {
+    return "completed";
+  }
+  return sessionContentState;
+};
+export default ({
+  mediaEventManager,
+  mediaSessionCacheManager,
+  config
+}) => {
+  const sendMediaEvent = options => {
+    const event = mediaEventManager.createMediaEvent({
+      options
+    });
+    const {
+      playerId,
+      xdm
+    } = options;
+    const {
+      eventType
+    } = xdm;
+    const action = eventType.split(".")[1];
+    const {
+      getPlayerDetails,
+      sessionPromise,
+      playbackState
+    } = mediaSessionCacheManager.getSession(playerId);
+    return sessionPromise.then(result => {
+      if (!result.sessionId) {
+        return Promise.reject(new Error(`Failed to trigger media event: ${eventType}. Session ID is not available for playerId: ${playerId}.`));
+      }
+      mediaEventManager.augmentMediaEvent({
+        event,
+        eventType,
+        playerId,
+        getPlayerDetails,
+        sessionID: result.sessionId
+      });
+      return mediaEventManager.trackMediaEvent({
+        event,
+        action
+      }).then(() => {
+        if (playerId) {
+          if (eventType === MediaEvents.SESSION_COMPLETE || eventType === MediaEvents.SESSION_END) {
+            mediaSessionCacheManager.stopPing({
+              playerId
+            });
+          } else {
+            const sessionPlaybackState = getContentState(eventType, playbackState);
+            if (sessionPlaybackState === "completed") {
+              return;
+            }
+            const interval = sessionPlaybackState === "ad" ? config.streamingMedia.adPingInterval : config.streamingMedia.mainPingInterval;
+            const pingId = setTimeout(() => {
+              const pingOptions = {
+                playerId,
+                xdm: {
+                  eventType: MediaEvents.PING
+                }
+              };
+              sendMediaEvent(pingOptions);
+            }, interval * 1000);
+            mediaSessionCacheManager.savePing({
+              playerId,
+              pingId,
+              playbackState: sessionPlaybackState
+            });
+          }
+        }
+      });
+    });
+  };
+  return options => sendMediaEvent(options);
+};

package/libEs6/components/StreamingMedia/createTrackMediaSession.js

@@ -0,0 +1,53 @@
+/*
+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 PlaybackState from "./constants/playbackState.js";
+export default ({
+  config,
+  mediaEventManager,
+  mediaSessionCacheManager,
+  legacy = false
+}) => {
+  return options => {
+    if (!config.streamingMedia) {
+      return Promise.reject(new Error("Streaming media is not configured."));
+    }
+    const {
+      playerId,
+      getPlayerDetails,
+      edgeConfigOverrides
+    } = options;
+    const event = mediaEventManager.createMediaSession(options);
+    mediaEventManager.augmentMediaEvent({
+      event,
+      playerId,
+      getPlayerDetails
+    });
+    const sessionPromise = mediaEventManager.trackMediaSession({
+      event,
+      mediaOptions: {
+        playerId,
+        getPlayerDetails,
+        legacy
+      },
+      edgeConfigOverrides
+    });
+    mediaSessionCacheManager.storeSession({
+      playerId,
+      sessionDetails: {
+        sessionPromise,
+        getPlayerDetails,
+        playbackState: PlaybackState.MAIN
+      }
+    });
+    return sessionPromise;
+  };
+};