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

package/libEs5/utils/validation/index.js

@@ -10,6 +10,7 @@ var _createDeprecatedValidator = require("./createDeprecatedValidator");
 var _createLiteralValidator = require("./createLiteralValidator");
 var _createMapOfValuesValidator = require("./createMapOfValuesValidator");
 var _createMinimumValidator = require("./createMinimumValidator");
+var _createMaximumValidator = require("./createMaximumValidator");
 var _createNoUnknownFieldsValidator = require("./createNoUnknownFieldsValidator");
 var _createNonEmptyValidator = require("./createNonEmptyValidator");
 var _createObjectOfValidator = require("./createObjectOfValidator");
@@ -116,6 +117,9 @@ var minimumInteger = function minimumInteger(minValue) {
 var minimumNumber = function minimumNumber(minValue) {
   return (0, _utils.nullSafeChain)(this, (0, _createMinimumValidator.default)("a number", minValue));
 };
+var maximumNumber = function maximumNumber(maxValue) {
+  return (0, _utils.nullSafeChain)(this, (0, _createMaximumValidator.default)("a number", maxValue));
+};
 var integer = function integer() {
   return (0, _utils.nullSafeChain)(this, _integerValidator.default, {
     minimum: minimumInteger
@@ -167,6 +171,7 @@ var literal = function literal(literalValue) {
 var number = function number() {
   return (0, _utils.nullSafeChain)(this, _numberValidator.default, {
     minimum: minimumNumber,
+    maximum: maximumNumber,
     integer: integer,
     unique: unique
   });

package/libEs6/components/LegacyMediaAnalytics/createMediaAnalyticsTracker.js

@@ -0,0 +1,276 @@
+/*
+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 defer from "../../utils/defer";
+import { AdMetadataKeys, AudioMetadataKeys, mediaEvent as Event, MediaObjectKey, MediaType, PlayerState, StreamType, VideoMetadataKeys } from "./media/constants";
+import { deepAssign, isEmptyObject, isNumber } from "../../utils";
+import { adsToXdmKeys, mediaToXdmKeys } from "./media/mediaKeysToXdmConverter";
+import { createMediaObject, createAdBreakObject, createAdObject, createChapterObject, createStateObject, createQoEObject } from "./createMediaHelper";
+const convertSessionDetailsMetadataToXDM = contextData => {
+  const customMetadata = [];
+  const sessionDetails = {};
+  Object.keys(contextData).forEach(key => {
+    if (mediaToXdmKeys[key]) {
+      sessionDetails[mediaToXdmKeys[key]] = contextData[key];
+    } else {
+      customMetadata.push({
+        name: key,
+        value: contextData[key]
+      });
+    }
+  });
+  return {
+    sessionDetails,
+    customMetadata
+  };
+};
+const createMediaDetailsObject = ({
+  eventType,
+  info,
+  context
+}) => {
+  const mediaDetails = info;
+  const customMetadata = [];
+  if (context && !isEmptyObject(context)) {
+    if (eventType === Event.AdStart) {
+      Object.keys(context).forEach(key => {
+        if (adsToXdmKeys[key]) {
+          mediaDetails.advertisingDetails[mediaToXdmKeys[key]] = context[key];
+        } else {
+          customMetadata.push({
+            name: key,
+            value: context[key]
+          });
+        }
+      });
+    } else {
+      Object.keys(context).forEach(key => {
+        customMetadata.push({
+          name: key,
+          value: context[key]
+        });
+      });
+    }
+    mediaDetails.customMetadata = customMetadata;
+  }
+  return mediaDetails;
+};
+const createHeartbeat = ({
+  mainPingInterval,
+  playerState,
+  trackEvent
+}) => {
+  // eslint-disable-next-line consistent-return
+  return () => {
+    const currentTime = Date.now();
+    if (Math.abs(currentTime - playerState.latestTriggeredEvent) / 1000 > mainPingInterval) {
+      return trackEvent({
+        eventType: "ping"
+      });
+    }
+  };
+};
+const createGetInstance = ({
+  config,
+  logger,
+  mediaEventManager
+}) => {
+  const {
+    mainPingInterval
+  } = config.mediaCollection;
+  const trackerState = {
+    qoe: null,
+    lastPlayhead: 0,
+    latestTriggeredEvent: null
+  };
+  let ticker;
+  let deferSession = defer();
+  const updateLastTimeEventTriggered = () => {
+    trackerState.latestTriggeredEvent = Date.now();
+  };
+  const getEventType = ({
+    eventType
+  }) => {
+    if (eventType === Event.BufferComplete) {
+      return `media.${Event.Play}`;
+    }
+    return `media.${eventType}`;
+  };
+  const trackEvent = ({
+    eventType,
+    mediaDetails
+  }) => {
+    return deferSession.promise.then(sessionID => {
+      const xdm = {
+        eventType: getEventType({
+          eventType
+        }),
+        mediaCollection: {
+          sessionID,
+          playhead: trackerState.lastPlayhead
+        }
+      };
+      deepAssign(xdm.mediaCollection, mediaDetails);
+      const event = mediaEventManager.createMediaEvent({
+        options: {
+          xdm
+        }
+      });
+      return mediaEventManager.trackMediaEvent({
+        event
+      }).then(() => {
+        updateLastTimeEventTriggered();
+      });
+    }).catch(error => {
+      logger.info(error);
+    });
+  };
+  const heartbeatEngine = createHeartbeat({
+    mainPingInterval,
+    deferSession,
+    playerState: trackerState,
+    trackEvent
+  });
+  return {
+    trackSessionStart: (mediaObject, contextData = {}) => {
+      if (isEmptyObject(mediaObject)) {
+        deferSession.reject("invalid media object");
+        return {};
+      }
+      const mediaCollection = {
+        playhead: 0
+      };
+      const {
+        sessionDetails,
+        customMetadata
+      } = convertSessionDetailsMetadataToXDM(contextData);
+      deepAssign(mediaCollection, mediaObject, {
+        sessionDetails
+      }, {
+        customMetadata
+      });
+      const event = mediaEventManager.createMediaSession({
+        xdm: {
+          mediaCollection
+        }
+      });
+      return mediaEventManager.trackMediaSession({
+        event
+      }).then(result => {
+        updateLastTimeEventTriggered();
+        deferSession.resolve(result.sessionId);
+        ticker = setInterval(() => {
+          heartbeatEngine();
+        }, 1000);
+      });
+    },
+    trackPlay: () => {
+      return trackEvent({
+        eventType: Event.Play
+      });
+    },
+    trackPause: () => {
+      return trackEvent({
+        eventType: Event.Pause
+      });
+    },
+    trackSessionEnd: () => {
+      clearInterval(ticker);
+      return trackEvent({
+        eventType: Event.SessionEnd
+      }).then(() => {
+        deferSession = null;
+      });
+    },
+    trackComplete: () => {
+      clearInterval(ticker);
+      return trackEvent({
+        eventType: Event.SessionComplete
+      });
+    },
+    trackError: errorId => {
+      logger.info(`trackError(${errorId})`);
+      const errorDetails = {
+        name: errorId,
+        source: "player"
+      };
+      const mediaDetails = {
+        errorDetails
+      };
+      return trackEvent({
+        eventType: Event.SessionEnd,
+        mediaDetails
+      });
+    },
+    trackEvent: (eventType, info, context) => {
+      if (isEmptyObject(info)) {
+        logger.info("invalid media object");
+        return {};
+      }
+      const mediaDetails = createMediaDetailsObject({
+        eventType,
+        info,
+        context
+      });
+      return trackEvent({
+        eventType,
+        mediaDetails
+      });
+    },
+    updatePlayhead: time => {
+      if (isNumber(time)) {
+        trackerState.lastPlayhead = parseInt(time, 10);
+      }
+    },
+    updateQoEObject: qoeObject => {
+      if (!qoeObject) {
+        return;
+      }
+      trackerState.qoe = qoeObject;
+    },
+    destroy: () => {
+      logger.info("Destroy called, destroying the tracker");
+      clearInterval(ticker);
+      deferSession = null;
+    }
+  };
+};
+export const createMediaAnalyticsTracker = ({
+  config,
+  logger,
+  mediaEventManager
+}) => {
+  logger.info("Media Analytics Component was configured");
+  return {
+    getInstance: () => {
+      return createGetInstance({
+        config,
+        logger,
+        mediaEventManager
+      });
+    },
+    Event,
+    MediaType,
+    PlayerState,
+    StreamType,
+    MediaObjectKey,
+    VideoMetadataKeys,
+    AudioMetadataKeys,
+    AdMetadataKeys,
+    createMediaObject,
+    createAdBreakObject,
+    createAdObject,
+    createChapterObject,
+    createStateObject,
+    createQoEObject
+  };
+};

package/libEs6/components/LegacyMediaAnalytics/createMediaHelper.js

@@ -0,0 +1,173 @@
+/*
+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 { number, objectOf, string } from "../../utils/validation";
+export const createMediaObject = (friendlyName, name, length, contentType, streamType) => {
+  const mediaObject = {
+    friendlyName,
+    name,
+    length,
+    streamType,
+    contentType
+  };
+  const validate = objectOf({
+    friendlyName: string().nonEmpty(),
+    name: string().nonEmpty(),
+    length: number().required(),
+    streamType: string().nonEmpty(),
+    contentType: string().nonEmpty()
+  });
+  try {
+    const result = validate(mediaObject);
+    const sessionDetails = {
+      name: result.name,
+      friendlyName: result.friendlyName,
+      length: result.length,
+      streamType: result.streamType,
+      contentType: result.contentType
+    };
+    return {
+      sessionDetails
+    };
+  } catch (error) {
+    return {};
+  }
+};
+export const createAdBreakObject = (name, position, startTime) => {
+  const adBreakObject = {
+    friendlyName: name,
+    offset: position,
+    index: startTime
+  };
+  const validator = objectOf({
+    friendlyName: string().nonEmpty(),
+    offset: number(),
+    index: number()
+  });
+  try {
+    const result = validator(adBreakObject);
+    const advertisingPodDetails = {
+      friendlyName: result.friendlyName,
+      offset: result.offset,
+      index: result.index
+    };
+    return {
+      advertisingPodDetails
+    };
+  } catch (error) {
+    return {};
+  }
+};
+export const createAdObject = (name, id, position, length) => {
+  const adObject = {
+    friendlyName: name,
+    name: id,
+    podPosition: position,
+    length
+  };
+  const validator = objectOf({
+    friendlyName: string().nonEmpty(),
+    name: string().nonEmpty(),
+    podPosition: number(),
+    length: number()
+  });
+  try {
+    const result = validator(adObject);
+    const advertisingDetails = {
+      friendlyName: result.friendlyName,
+      name: result.name,
+      podPosition: result.podPosition,
+      length: result.length
+    };
+    return {
+      advertisingDetails
+    };
+  } catch (error) {
+    return {};
+  }
+};
+export const createChapterObject = (name, position, length, startTime) => {
+  const chapterDetailsObject = {
+    friendlyName: name,
+    offset: position,
+    length,
+    index: startTime
+  };
+  const validator = objectOf({
+    friendlyName: string().nonEmpty(),
+    offset: number(),
+    length: number(),
+    index: number()
+  });
+  try {
+    const result = validator(chapterDetailsObject);
+    const chapterDetails = {
+      friendlyName: result.friendlyName,
+      offset: result.offset,
+      index: result.index,
+      length: result.length
+    };
+    return {
+      chapterDetails
+    };
+  } catch (error) {
+    return {};
+  }
+};
+export const createStateObject = stateName => {
+  const STATE_NAME_REGEX = new RegExp("^[a-zA-Z0-9_\\.]{1,64}$");
+  const state = {
+    state: stateName
+  };
+  const validator = objectOf({
+    state: string().regexp(STATE_NAME_REGEX)
+  });
+  try {
+    const result = validator(state);
+    const stateDetails = {
+      name: result.name
+    };
+    return {
+      stateDetails
+    };
+  } catch (error) {
+    return {};
+  }
+};
+export const createQoEObject = (bitrate, droppedFrames, fps, startupTime) => {
+  const qoeObject = {
+    bitrate,
+    droppedFrames,
+    fps,
+    startupTime
+  };
+  const validator = objectOf({
+    bitrate: number(),
+    droppedFrames: number(),
+    fps: number(),
+    startupTime: number()
+  });
+  try {
+    const result = validator(qoeObject);
+    const qoeDetails = {
+      bitrate: result.bitrate,
+      droppedFrames: result.droppedFrames,
+      fps: result.fps,
+      startupTime: result.startupTime
+    };
+    return {
+      qoeDetails
+    };
+  } catch (error) {
+    return {};
+  }
+};

package/libEs6/components/LegacyMediaAnalytics/index.js

@@ -0,0 +1,45 @@
+/*
+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.
+*/
+/* eslint-disable import/no-restricted-paths */
+
+import { createMediaAnalyticsTracker } from "./createMediaAnalyticsTracker";
+import createMediaEventManager from "../MediaCollection/createMediaEventManager";
+const createLegacyMediaAnalytics = ({
+  eventManager,
+  sendEdgeNetworkRequest,
+  config,
+  logger,
+  consent
+}) => {
+  const mediaEventManager = createMediaEventManager({
+    sendEdgeNetworkRequest,
+    config,
+    logger,
+    consent,
+    eventManager
+  });
+  return {
+    commands: {
+      getMediaAnalyticsTracker: {
+        run: () => {
+          return createMediaAnalyticsTracker({
+            config,
+            logger,
+            mediaEventManager
+          });
+        }
+      }
+    }
+  };
+};
+createLegacyMediaAnalytics.namespace = "Legacy Media Analytics";
+export default createLegacyMediaAnalytics;

package/libEs6/components/LegacyMediaAnalytics/media/constants.js

@@ -0,0 +1,140 @@
+/*
+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 MediaType = {
+  Video: "video",
+  Audio: "audio"
+};
+export const StreamType = {
+  VOD: "vod",
+  Live: "live",
+  Linear: "linear",
+  Podcast: "podcast",
+  Audiobook: "audiobook",
+  AOD: "aod"
+};
+export const PlayerState = {
+  FullScreen: "fullScreen",
+  ClosedCaption: "closedCaptioning",
+  Mute: "mute",
+  PictureInPicture: "pictureInPicture",
+  InFocus: "inFocus"
+};
+export const Event = {
+  /**
+   * Constant defining event type for AdBreak start
+   */
+  AdBreakStart: "adBreakStart",
+  /**
+   * Constant defining event type for AdBreak complete
+   */
+  AdBreakComplete: "adBreakComplete",
+  /**
+   * Constant defining event type for Ad start
+   */
+  AdStart: "adStart",
+  /**
+   * Constant defining event type for Ad complete
+   */
+  AdComplete: "adComplete",
+  /**
+   * Constant defining event type for Ad skip
+   */
+  AdSkip: "adSkip",
+  /**
+   * Constant defining event type for Chapter start
+   */
+  ChapterStart: "chapterStart",
+  /**
+   * Constant defining event type for Chapter complete
+   */
+  ChapterComplete: "chapterComplete",
+  /**
+   * Constant defining event type for Chapter skip
+   */
+  ChapterSkip: "chapterSkip",
+  /**
+   * Constant defining event type for Seek start
+   */
+  SeekStart: "seekStart",
+  /**
+   * Constant defining event type for Seek complete
+   */
+  SeekComplete: "seekComplete",
+  /**
+   * Constant defining event type for Buffer start
+   */
+  BufferStart: "bufferStart",
+  /**
+   * Constant defining event type for Buffer complete
+   */
+  BufferComplete: "bufferComplete",
+  /**
+   * Constant defining event type for change in Bitrate
+   */
+  BitrateChange: "bitrateChange",
+  /**
+   * Constant defining event type for Custom State Start
+   */
+  StateStart: "stateStart",
+  /**
+   * Constant defining event type for Custom State End
+   */
+  StateEnd: "stateEnd"
+};
+export const mediaEvent = {
+  SessionStart: "sessionStart",
+  SessionEnd: "sessionEnd",
+  SessionComplete: "sessionComplete",
+  Play: "play",
+  Pause: "pauseStart",
+  ...Event
+};
+export const MediaObjectKey = {
+  MediaResumed: "media.resumed",
+  GranularAdTracking: "media.granularadtracking"
+};
+export const VideoMetadataKeys = {
+  Show: "a.media.show",
+  Season: "a.media.season",
+  Episode: "a.media.episode",
+  AssetId: "a.media.asset",
+  Genre: "a.media.genre",
+  FirstAirDate: "a.media.airDate",
+  FirstDigitalDate: "a.media.digitalDate",
+  Rating: "a.media.rating",
+  Originator: "a.media.originator",
+  Network: "a.media.network",
+  ShowType: "a.media.type",
+  AdLoad: "a.media.adLoad",
+  MVPD: "a.media.pass.mvpd",
+  Authorized: "a.media.pass.auth",
+  DayPart: "a.media.dayPart",
+  Feed: "a.media.feed",
+  StreamFormat: "a.media.format"
+};
+export const AudioMetadataKeys = {
+  Artist: "a.media.artist",
+  Album: "a.media.album",
+  Label: "a.media.label",
+  Author: "a.media.author",
+  Station: "a.media.station",
+  Publisher: "a.media.publisher"
+};
+export const AdMetadataKeys = {
+  Advertiser: "a.media.ad.advertiser",
+  CampaignId: "a.media.ad.campaign",
+  CreativeId: "a.media.ad.creative",
+  PlacementId: "a.media.ad.placement",
+  SiteId: "a.media.ad.site",
+  CreativeUrl: "a.media.ad.creativeURL"
+};

package/libEs6/components/LegacyMediaAnalytics/media/mediaKeysToXdmConverter.js

@@ -0,0 +1,46 @@
+/*
+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 mediaToXdmKeys = {
+  "a.media.show": "show",
+  "a.media.season": "season",
+  "a.media.episode": "episode",
+  "a.media.asset": "assetID",
+  "a.media.genre": "genre",
+  "a.media.airDate": "firstAirDate",
+  "a.media.digitalDate": "firstDigitalDate",
+  "a.media.rating": "rating",
+  "a.media.originator": "originator",
+  "a.media.network": "network",
+  "a.media.type": "showType",
+  "a.media.adLoad": "adLoad",
+  "a.media.pass.mvpd": "mvpd",
+  "a.media.pass.auth": "authorized",
+  "a.media.dayPart": "dayPart",
+  "a.media.feed": "feed",
+  "a.media.format": "streamFormat",
+  "a.media.artist": "artist",
+  "a.media.album": "album",
+  "a.media.label": "label",
+  "a.media.author": "author",
+  "a.media.station": "station",
+  "a.media.publisher": "publisher",
+  "media.resumed": "hasResume"
+};
+export const adsToXdmKeys = {
+  "a.media.ad.advertiser": "advertiser",
+  "a.media.ad.campaign": "campaignID",
+  "a.media.ad.creative": "creativeID",
+  "a.media.ad.placement": "placementID",
+  "a.media.ad.site": "siteID",
+  "a.media.ad.creativeURL": "creativeURL"
+};