@adobe/alloy 2.19.2 → 2.20.0-alpha.1

package/libEs5/components/Identity/index.js

@@ -86,8 +86,7 @@ var createIdentity = function createIdentity(_ref) {
   });
   var awaitIdentityCookie = (0, _injectAwaitIdentityCookie.default)({
     doesIdentityCookieExist: doesIdentityCookieExist,
-    orgId: orgId,
-    logger: logger
+    orgId: orgId
   });
   var ensureSingleIdentity = (0, _injectEnsureSingleIdentity.default)({
     doesIdentityCookieExist: doesIdentityCookieExist,

package/libEs5/components/Identity/injectAddQueryStringIdentityToPayload.js

@@ -37,10 +37,6 @@ var _default = function _default(_ref) {
     if (queryStringValue === undefined) {
       return;
     }
-    if (Array.isArray(queryStringValue)) {
-      logger.warn("Found multiple adobe_mc query string paramters, only using the last one.");
-      queryStringValue = queryStringValue[queryStringValue.length - 1];
-    }
     var properties = queryStringValue.split("|").reduce(function (memo, keyValue) {
       var _keyValue$split = keyValue.split("="),
         _keyValue$split2 = _slicedToArray(_keyValue$split, 2),

package/libEs5/components/Identity/injectAwaitIdentityCookie.js

@@ -14,8 +14,7 @@ governing permissions and limitations under the License.
 */
 var _default = function _default(_ref) {
   var doesIdentityCookieExist = _ref.doesIdentityCookieExist,
-    orgId = _ref.orgId,
-    logger = _ref.logger;
+    orgId = _ref.orgId;
   /**
    * Returns a promise that will be resolved once an identity cookie exists.
    * If an identity cookie doesn't already exist, it should always exist after
@@ -31,11 +30,16 @@ var _default = function _default(_ref) {
         } else {
           // This logic assumes that the code setting the cookie is working as expected and that
           // the cookie was missing from the response.
-          logger.warn("Identity cookie not found. This could be caused by any of the following issues:\n" + ("\t* The org ID " + orgId + " configured in Alloy doesn't match the org ID specified in the edge configuration.\n") + "\t* Experience edge was not able to set the identity cookie due to domain or cookie restrictions.\n" + "\t* The request was canceled by the browser and not fully processed.");
+          var noIdentityCookieError = new Error("An identity was not set properly. Please verify that the org ID " + orgId + " configured in Alloy matches the org ID specified in the edge configuration.");
 
-          // Rejecting the promise will tell queued events to still go out
-          // one at a time.
-          reject(new Error("Identity cookie not found."));
+          // Rejecting the promise will reject commands that were queued
+          // by the Identity component while waiting on the response to
+          // the initial request.
+          reject(noIdentityCookieError);
+
+          // Throwing an error will reject the event command that initiated
+          // the request.
+          throw noIdentityCookieError;
         }
       });
       onRequestFailure(function () {
@@ -44,7 +48,7 @@ var _default = function _default(_ref) {
         } else {
           // The error from the request failure will be logged separately. Rejecting this here
           // will tell ensureSingleIdentity to send the next request without identity
-          reject(new Error("Identity cookie not found."));
+          reject(new Error("No identity was set on response."));
         }
       });
     });

package/libEs5/components/Identity/injectEnsureSingleIdentity.js

@@ -55,8 +55,9 @@ var _default = function _default(_ref) {
     if (obtainedIdentityPromise) {
       // We don't have an identity cookie, but at least one request has
       // been sent to get it. Konductor may set the identity cookie in the
-      // response. We will hold up this request until the previous request
-      // returns and awaitIdentityCookie confirms the identity was set.
+      // response. We will hold up this request until the last request
+      // requiring identity returns and awaitIdentityCookie confirms the
+      // identity was set.
       logger.info("Delaying request while retrieving ECID from server.");
       var previousObtainedIdentityPromise = obtainedIdentityPromise;
 
@@ -91,10 +92,6 @@ var _default = function _default(_ref) {
       onResponse: onResponse,
       onRequestFailure: onRequestFailure
     });
-    // This prevents an un-caught promise in the console when the identity isn't set.
-    obtainedIdentityPromise.catch(function () {
-      return undefined;
-    });
     return allowRequestToGoWithoutIdentity(request);
   };
 };

package/libEs5/components/LegacyMediaAnalytics/createMediaAnalyticsTracker.js

@@ -0,0 +1,272 @@
+"use strict";
+
+exports.createMediaAnalyticsTracker = void 0;
+var _defer = require("../../utils/defer");
+var _constants = require("./media/constants");
+var _utils = require("../../utils");
+var _mediaKeysToXdmConverter = require("./media/mediaKeysToXdmConverter");
+var _createMediaHelper = require("./createMediaHelper");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /*
+                                                                                                                                                                                                                  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.
+                                                                                                                                                                                                                  */
+var convertSessionDetailsMetadataToXDM = function convertSessionDetailsMetadataToXDM(contextData) {
+  var customMetadata = [];
+  var sessionDetails = {};
+  Object.keys(contextData).forEach(function (key) {
+    if (_mediaKeysToXdmConverter.mediaToXdmKeys[key]) {
+      sessionDetails[_mediaKeysToXdmConverter.mediaToXdmKeys[key]] = contextData[key];
+    } else {
+      customMetadata.push({
+        name: key,
+        value: contextData[key]
+      });
+    }
+  });
+  return {
+    sessionDetails: sessionDetails,
+    customMetadata: customMetadata
+  };
+};
+var createMediaDetailsObject = function createMediaDetailsObject(_ref) {
+  var eventType = _ref.eventType,
+    info = _ref.info,
+    context = _ref.context;
+  var mediaDetails = info;
+  var customMetadata = [];
+  if (context && !(0, _utils.isEmptyObject)(context)) {
+    if (eventType === _constants.MEDIA_EVENTS.AdStart) {
+      Object.keys(context).forEach(function (key) {
+        if (_mediaKeysToXdmConverter.adsToXdmKeys[key]) {
+          mediaDetails.advertisingDetails[_mediaKeysToXdmConverter.mediaToXdmKeys[key]] = context[key];
+        } else {
+          customMetadata.push({
+            name: key,
+            value: context[key]
+          });
+        }
+      });
+    } else {
+      Object.keys(context).forEach(function (key) {
+        customMetadata.push({
+          name: key,
+          value: context[key]
+        });
+      });
+    }
+    mediaDetails.customMetadata = customMetadata;
+  }
+  return mediaDetails;
+};
+var createHeartbeat = function createHeartbeat(_ref2) {
+  var mainPingInterval = _ref2.mainPingInterval,
+    playerState = _ref2.playerState,
+    trackEvent = _ref2.trackEvent;
+  // eslint-disable-next-line consistent-return
+  return function () {
+    var currentTime = Date.now();
+    if (Math.abs(currentTime - playerState.latestTriggeredEvent) / 1000 > mainPingInterval) {
+      return trackEvent({
+        eventType: "ping"
+      });
+    }
+  };
+};
+var createGetInstance = function createGetInstance(_ref3) {
+  var config = _ref3.config,
+    logger = _ref3.logger,
+    mediaEventManager = _ref3.mediaEventManager;
+  var mainPingInterval = config.mediaCollection.mainPingInterval;
+  var trackerState = {
+    qoe: null,
+    lastPlayhead: 0,
+    latestTriggeredEvent: null
+  };
+  var ticker;
+  var deferSession = (0, _defer.default)();
+  var updateLastTimeEventTriggered = function updateLastTimeEventTriggered() {
+    trackerState.latestTriggeredEvent = Date.now();
+  };
+  var getEventType = function getEventType(_ref4) {
+    var eventType = _ref4.eventType;
+    if (eventType === _constants.MEDIA_EVENTS.BufferComplete) {
+      return _constants.MEDIA_EVENTS.Play;
+    }
+    return eventType;
+  };
+  var _trackEvent = function trackEvent(_ref5) {
+    var eventType = _ref5.eventType,
+      mediaDetails = _ref5.mediaDetails;
+    return deferSession.promise.then(function (sessionID) {
+      var action = getEventType({
+        eventType: eventType
+      });
+      var xdm = {
+        eventType: "media." + action,
+        mediaCollection: {
+          sessionID: sessionID,
+          playhead: trackerState.lastPlayhead
+        }
+      };
+      (0, _utils.deepAssign)(xdm.mediaCollection, mediaDetails);
+      var event = mediaEventManager.createMediaEvent({
+        options: {
+          xdm: xdm
+        }
+      });
+      return mediaEventManager.trackMediaEvent({
+        event: event,
+        action: action
+      }).then(function () {
+        updateLastTimeEventTriggered();
+      });
+    }).catch(function (error) {
+      logger.warn("An error occurred while sending " + eventType + " Media Event.", error);
+    });
+  };
+  var heartbeatEngine = createHeartbeat({
+    mainPingInterval: mainPingInterval,
+    deferSession: deferSession,
+    playerState: trackerState,
+    trackEvent: _trackEvent
+  });
+  return {
+    trackSessionStart: function trackSessionStart(mediaObject) {
+      var contextData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if ((0, _utils.isEmptyObject)(mediaObject)) {
+        deferSession.reject("invalid media object");
+        return {};
+      }
+      var mediaCollection = {
+        playhead: 0
+      };
+      var _convertSessionDetail = convertSessionDetailsMetadataToXDM(contextData),
+        sessionDetails = _convertSessionDetail.sessionDetails,
+        customMetadata = _convertSessionDetail.customMetadata;
+      (0, _utils.deepAssign)(mediaCollection, mediaObject, {
+        sessionDetails: sessionDetails
+      }, {
+        customMetadata: customMetadata
+      });
+      var event = mediaEventManager.createMediaSession({
+        xdm: {
+          mediaCollection: mediaCollection
+        }
+      });
+      return mediaEventManager.trackMediaSession({
+        event: event
+      }).then(function (result) {
+        updateLastTimeEventTriggered();
+        deferSession.resolve(result.sessionId);
+        ticker = setInterval(function () {
+          heartbeatEngine();
+        }, 1000);
+      });
+    },
+    trackPlay: function trackPlay() {
+      return _trackEvent({
+        eventType: _constants.MEDIA_EVENTS.Play
+      });
+    },
+    trackPause: function trackPause() {
+      return _trackEvent({
+        eventType: _constants.MEDIA_EVENTS.Pause
+      });
+    },
+    trackSessionEnd: function trackSessionEnd() {
+      clearInterval(ticker);
+      return _trackEvent({
+        eventType: _constants.MEDIA_EVENTS.SessionEnd
+      }).then(function () {
+        deferSession = null;
+      });
+    },
+    trackComplete: function trackComplete() {
+      clearInterval(ticker);
+      return _trackEvent({
+        eventType: _constants.MEDIA_EVENTS.SessionComplete
+      });
+    },
+    trackError: function trackError(errorId) {
+      logger.info("trackError(" + errorId + ")");
+      var errorDetails = {
+        name: errorId,
+        source: "player"
+      };
+      var mediaDetails = {
+        errorDetails: errorDetails
+      };
+      return _trackEvent({
+        eventType: _constants.MEDIA_EVENTS.SessionEnd,
+        mediaDetails: mediaDetails
+      });
+    },
+    trackEvent: function trackEvent(eventType, info, context) {
+      if ((0, _utils.isEmptyObject)(info)) {
+        logger.info("invalid media object");
+        return {};
+      }
+      var mediaDetails = createMediaDetailsObject({
+        eventType: eventType,
+        info: info,
+        context: context
+      });
+      return _trackEvent({
+        eventType: eventType,
+        mediaDetails: mediaDetails
+      });
+    },
+    updatePlayhead: function updatePlayhead(time) {
+      if ((0, _utils.isNumber)(time)) {
+        trackerState.lastPlayhead = parseInt(time, 10);
+      }
+    },
+    updateQoEObject: function updateQoEObject(qoeObject) {
+      if (!qoeObject) {
+        return;
+      }
+      trackerState.qoe = qoeObject;
+    },
+    destroy: function destroy() {
+      logger.info("Destroy called, destroying the tracker");
+      clearInterval(ticker);
+      deferSession = null;
+    }
+  };
+};
+var createMediaAnalyticsTracker = function createMediaAnalyticsTracker(_ref6) {
+  var config = _ref6.config,
+    logger = _ref6.logger,
+    mediaEventManager = _ref6.mediaEventManager;
+  logger.info("Media Analytics Component was configured");
+  var mediaAnalyticsHelper = (0, _createMediaHelper.default)({
+    logger: logger
+  });
+  return _objectSpread({
+    getInstance: function getInstance() {
+      return createGetInstance({
+        config: config,
+        logger: logger,
+        mediaEventManager: mediaEventManager
+      });
+    },
+    Event: _constants.EVENT,
+    MediaType: _constants.MEDIA_TYPE,
+    PlayerState: _constants.PLAYER_STATE,
+    StreamType: _constants.STREAM_TYPE,
+    MediaObjectKey: _constants.MEDIA_OBJECT_KEYS,
+    VideoMetadataKeys: _constants.VIDEO_METADATA_KEYS,
+    AudioMetadataKeys: _constants.AUDIO_METADATA_KEYS,
+    AdMetadataKeys: _constants.AD_METADATA_KEYS
+  }, mediaAnalyticsHelper);
+};
+exports.createMediaAnalyticsTracker = createMediaAnalyticsTracker;

package/libEs5/components/LegacyMediaAnalytics/createMediaHelper.js

@@ -0,0 +1,188 @@
+"use strict";
+
+exports.default = void 0;
+var _validation = require("../../utils/validation");
+/*
+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.
+*/
+var _default = function _default(_ref) {
+  var logger = _ref.logger;
+  var createMediaObject = function createMediaObject(friendlyName, name, length, contentType, streamType) {
+    var mediaObject = {
+      friendlyName: friendlyName,
+      name: name,
+      length: length,
+      streamType: streamType,
+      contentType: contentType
+    };
+    var validate = (0, _validation.objectOf)({
+      friendlyName: (0, _validation.string)().nonEmpty(),
+      name: (0, _validation.string)().nonEmpty(),
+      length: (0, _validation.number)().required(),
+      streamType: (0, _validation.string)().nonEmpty(),
+      contentType: (0, _validation.string)().nonEmpty()
+    });
+    try {
+      var result = validate(mediaObject);
+      var sessionDetails = {
+        name: result.name,
+        friendlyName: result.friendlyName,
+        length: result.length,
+        streamType: result.streamType,
+        contentType: result.contentType
+      };
+      return {
+        sessionDetails: sessionDetails
+      };
+    } catch (error) {
+      logger.warn("An error occurred while creating the Media Object.", error);
+      return {};
+    }
+  };
+  var createAdBreakObject = function createAdBreakObject(name, position, startTime) {
+    var adBreakObject = {
+      friendlyName: name,
+      offset: position,
+      index: startTime
+    };
+    var validator = (0, _validation.objectOf)({
+      friendlyName: (0, _validation.string)().nonEmpty(),
+      offset: (0, _validation.number)(),
+      index: (0, _validation.number)()
+    });
+    try {
+      var result = validator(adBreakObject);
+      var advertisingPodDetails = {
+        friendlyName: result.friendlyName,
+        offset: result.offset,
+        index: result.index
+      };
+      return {
+        advertisingPodDetails: advertisingPodDetails
+      };
+    } catch (error) {
+      logger.warn("An error occurred while creating the Ad Break Object.", error);
+      return {};
+    }
+  };
+  var createAdObject = function createAdObject(name, id, position, length) {
+    var adObject = {
+      friendlyName: name,
+      name: id,
+      podPosition: position,
+      length: length
+    };
+    var validator = (0, _validation.objectOf)({
+      friendlyName: (0, _validation.string)().nonEmpty(),
+      name: (0, _validation.string)().nonEmpty(),
+      podPosition: (0, _validation.number)(),
+      length: (0, _validation.number)()
+    });
+    try {
+      var result = validator(adObject);
+      var advertisingDetails = {
+        friendlyName: result.friendlyName,
+        name: result.name,
+        podPosition: result.podPosition,
+        length: result.length
+      };
+      return {
+        advertisingDetails: advertisingDetails
+      };
+    } catch (error) {
+      logger.warn("An error occurred while creating the Advertising Object.", error);
+      return {};
+    }
+  };
+  var createChapterObject = function createChapterObject(name, position, length, startTime) {
+    var chapterDetailsObject = {
+      friendlyName: name,
+      offset: position,
+      length: length,
+      index: startTime
+    };
+    var validator = (0, _validation.objectOf)({
+      friendlyName: (0, _validation.string)().nonEmpty(),
+      offset: (0, _validation.number)(),
+      length: (0, _validation.number)(),
+      index: (0, _validation.number)()
+    });
+    try {
+      var result = validator(chapterDetailsObject);
+      var chapterDetails = {
+        friendlyName: result.friendlyName,
+        offset: result.offset,
+        index: result.index,
+        length: result.length
+      };
+      return {
+        chapterDetails: chapterDetails
+      };
+    } catch (error) {
+      logger.warn("An error occurred while creating the Chapter Object.", error);
+      return {};
+    }
+  };
+  var createStateObject = function createStateObject(stateName) {
+    var STATE_NAME_REGEX = "^[a-zA-Z0-9_]{1,64}$";
+    var validator = (0, _validation.string)().matches(STATE_NAME_REGEX, "This is not a valid state name.");
+    try {
+      var result = validator(stateName);
+      var stateDetails = {
+        name: result
+      };
+      return {
+        stateDetails: stateDetails
+      };
+    } catch (error) {
+      logger.warn("An error occurred while creating the State Object.", error);
+      return {};
+    }
+  };
+  var createQoEObject = function createQoEObject(bitrate, droppedFrames, fps, startupTime) {
+    var qoeObject = {
+      bitrate: bitrate,
+      droppedFrames: droppedFrames,
+      fps: fps,
+      startupTime: startupTime
+    };
+    var validator = (0, _validation.objectOf)({
+      bitrate: (0, _validation.number)(),
+      droppedFrames: (0, _validation.number)(),
+      fps: (0, _validation.number)(),
+      startupTime: (0, _validation.number)()
+    });
+    try {
+      var result = validator(qoeObject);
+      var qoeDetails = {
+        bitrate: result.bitrate,
+        droppedFrames: result.droppedFrames,
+        fps: result.fps,
+        startupTime: result.startupTime
+      };
+      return {
+        qoeDetails: qoeDetails
+      };
+    } catch (error) {
+      logger.warn("An error occurred while creating the QOE Object.", error);
+      return {};
+    }
+  };
+  return {
+    createMediaObject: createMediaObject,
+    createAdBreakObject: createAdBreakObject,
+    createAdObject: createAdObject,
+    createChapterObject: createChapterObject,
+    createStateObject: createStateObject,
+    createQoEObject: createQoEObject
+  };
+};
+exports.default = _default;

package/libEs5/components/LegacyMediaAnalytics/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+exports.default = void 0;
+var _createMediaAnalyticsTracker = require("./createMediaAnalyticsTracker");
+var _createMediaEventManager = require("../MediaCollection/createMediaEventManager");
+/*
+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 */
+
+var createLegacyMediaAnalytics = function createLegacyMediaAnalytics(_ref) {
+  var eventManager = _ref.eventManager,
+    sendEdgeNetworkRequest = _ref.sendEdgeNetworkRequest,
+    config = _ref.config,
+    logger = _ref.logger,
+    consent = _ref.consent;
+  var mediaEventManager = (0, _createMediaEventManager.default)({
+    sendEdgeNetworkRequest: sendEdgeNetworkRequest,
+    config: config,
+    logger: logger,
+    consent: consent,
+    eventManager: eventManager
+  });
+  return {
+    commands: {
+      getMediaAnalyticsTracker: {
+        run: function run() {
+          return (0, _createMediaAnalyticsTracker.createMediaAnalyticsTracker)({
+            config: config,
+            logger: logger,
+            mediaEventManager: mediaEventManager
+          });
+        }
+      }
+    }
+  };
+};
+createLegacyMediaAnalytics.namespace = "Legacy Media Analytics";
+var _default = createLegacyMediaAnalytics;
+exports.default = _default;