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

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

@@ -1,11 +1,10 @@
 "use strict";
 
 exports.default = void 0;
-var _mediaEvents = require("./mediaConstants/mediaEvents");
-var _createMediaRequestPayload = require("./createMediaRequestPayload");
+var _eventTypes = require("./constants/eventTypes");
 var _createMediaRequest = require("./createMediaRequest");
-var _injectTimestamp = require("../Context/injectTimestamp");
 var _utils = require("../../utils");
+var _request = require("../../utils/request");
 /*
 Copyright 2023 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -17,40 +16,46 @@ 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 */
-var _default = function _default(_ref) {
+var _default = exports.default = function _default(_ref) {
   var config = _ref.config,
     eventManager = _ref.eventManager,
     consent = _ref.consent,
-    sendEdgeNetworkRequest = _ref.sendEdgeNetworkRequest;
+    sendEdgeNetworkRequest = _ref.sendEdgeNetworkRequest,
+    setTimestamp = _ref.setTimestamp;
   return {
     createMediaEvent: function createMediaEvent(_ref2) {
       var options = _ref2.options;
-      var _options$xdm = options.xdm,
-        xdm = _options$xdm === void 0 ? {} : _options$xdm;
-      var event = {
-        xdm: xdm
-      };
-      var timestamp = (0, _injectTimestamp.default)(function () {
-        return new Date();
-      });
-      timestamp(event.xdm);
+      var event = eventManager.createEvent();
+      var xdm = options.xdm;
+      setTimestamp(xdm);
+      event.setUserXdm(xdm);
+      if (xdm.eventType === _eventTypes.default.AD_START) {
+        var advertisingDetails = options.xdm.mediaCollection.advertisingDetails;
+        event.mergeXdm({
+          mediaCollection: {
+            advertisingDetails: {
+              playerName: advertisingDetails.playerName || config.streamingMedia.playerName
+            }
+          }
+        });
+      }
       return event;
     },
     createMediaSession: function createMediaSession(options) {
-      var _config$mediaCollecti = config.mediaCollection,
-        playerName = _config$mediaCollecti.playerName,
-        channel = _config$mediaCollecti.channel,
-        version = _config$mediaCollecti.version;
+      var _config$streamingMedi = config.streamingMedia,
+        playerName = _config$streamingMedi.playerName,
+        channel = _config$streamingMedi.channel,
+        appVersion = _config$streamingMedi.appVersion;
       var event = eventManager.createEvent();
+      var sessionDetails = options.xdm.mediaCollection.sessionDetails;
       event.setUserXdm(options.xdm);
       event.mergeXdm({
-        eventType: _mediaEvents.default.SESSION_START,
+        eventType: _eventTypes.default.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,53 +64,42 @@ var _default = function _default(_ref) {
     augmentMediaEvent: function augmentMediaEvent(_ref3) {
       var event = _ref3.event,
         playerId = _ref3.playerId,
-        onBeforeMediaEvent = _ref3.onBeforeMediaEvent,
+        getPlayerDetails = _ref3.getPlayerDetails,
         sessionID = _ref3.sessionID;
-      if (!playerId || !onBeforeMediaEvent) {
+      if (!playerId || !getPlayerDetails) {
         return event;
       }
-      var _onBeforeMediaEvent = onBeforeMediaEvent({
+      var _getPlayerDetails = getPlayerDetails({
           playerId: playerId
         }),
-        playhead = _onBeforeMediaEvent.playhead,
-        qoeDataDetails = _onBeforeMediaEvent.qoeDataDetails;
-      if (event.mergeXdm) {
-        event.mergeXdm({
-          mediaCollection: {
-            playhead: (0, _utils.toInteger)(playhead),
-            qoeDataDetails: qoeDataDetails
-          }
-        });
-        return event;
-      }
-      return (0, _utils.deepAssign)(event, {
-        xdm: {
-          mediaCollection: {
-            playhead: (0, _utils.toInteger)(playhead),
-            qoeDataDetails: qoeDataDetails,
-            sessionID: sessionID
-          }
+        playhead = _getPlayerDetails.playhead,
+        qoeDataDetails = _getPlayerDetails.qoeDataDetails;
+      event.mergeXdm({
+        mediaCollection: {
+          playhead: (0, _utils.toInteger)(playhead),
+          qoeDataDetails: qoeDataDetails,
+          sessionID: sessionID
         }
       });
+      return event;
     },
     trackMediaSession: function trackMediaSession(_ref4) {
       var event = _ref4.event,
-        playerId = _ref4.playerId,
-        onBeforeMediaEvent = _ref4.onBeforeMediaEvent;
+        mediaOptions = _ref4.mediaOptions;
       return eventManager.sendEvent(event, {
-        playerId: playerId,
-        onBeforeMediaEvent: onBeforeMediaEvent
+        mediaOptions: mediaOptions
       });
     },
     trackMediaEvent: function trackMediaEvent(_ref5) {
-      var event = _ref5.event;
-      var action = event.xdm.eventType.split(".")[1];
-      var mediaRequestPayload = (0, _createMediaRequestPayload.default)();
+      var event = _ref5.event,
+        action = _ref5.action;
+      var mediaRequestPayload = (0, _request.createDataCollectionRequestPayload)();
       var request = (0, _createMediaRequest.default)({
         mediaRequestPayload: mediaRequestPayload,
         action: action
       });
       mediaRequestPayload.addEvent(event);
+      event.finalize();
       return consent.awaitConsent().then(function () {
         return sendEdgeNetworkRequest({
           request: request
@@ -115,5 +109,4 @@ var _default = function _default(_ref) {
       });
     }
   };
-};
-exports.default = _default;
+};

package/libEs5/components/{MediaCollection → StreamingMedia}/createMediaRequest.js

@@ -13,7 +13,7 @@ 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.
 */
-var _default = function _default(_ref) {
+var _default = exports.default = function _default(_ref) {
   var mediaRequestPayload = _ref.mediaRequestPayload,
     action = _ref.action;
   return (0, _request.createRequest)({
@@ -26,5 +26,4 @@ var _default = function _default(_ref) {
       return false;
     }
   });
-};
-exports.default = _default;
+};

package/libEs5/components/StreamingMedia/createMediaResponseHandler.js

@@ -0,0 +1,57 @@
+"use strict";
+
+exports.default = void 0;
+var _isBlankString = require("../../utils/isBlankString");
+var _eventTypes = require("./constants/eventTypes");
+var _utils = require("../../utils");
+var _playbackState = require("./constants/playbackState");
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var mediaSessionCacheManager = _ref.mediaSessionCacheManager,
+    config = _ref.config,
+    trackMediaEvent = _ref.trackMediaEvent;
+  return function (_ref2) {
+    var response = _ref2.response,
+      playerId = _ref2.playerId,
+      getPlayerDetails = _ref2.getPlayerDetails;
+    var mediaPayload = response.getPayloadsByType("media-analytics:new-session");
+    if ((0, _utils.isNonEmptyArray)(mediaPayload)) {
+      var sessionId = mediaPayload[0].sessionId;
+      if ((0, _isBlankString.default)(sessionId)) {
+        return {};
+      }
+      if (!playerId || !getPlayerDetails) {
+        return {
+          sessionId: sessionId
+        };
+      }
+      var pingId = setTimeout(function () {
+        trackMediaEvent({
+          playerId: playerId,
+          xdm: {
+            eventType: _eventTypes.default.PING
+          }
+        });
+      }, config.streamingMedia.mainPingInterval * 1000);
+      mediaSessionCacheManager.savePing({
+        playerId: playerId,
+        pingId: pingId,
+        playbackState: _playbackState.default.MAIN
+      });
+      return {
+        sessionId: sessionId
+      };
+    }
+    return {};
+  };
+};

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

@@ -1,6 +1,7 @@
 "use strict";
 
 exports.default = void 0;
+var _playbackState = require("./constants/playbackState");
 /*
 Copyright 2023 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -12,40 +13,37 @@ 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.
 */
-var _default = function _default() {
+var _default = exports.default = function _default() {
   var mediaSessionCache;
   var getSession = function getSession(playerId) {
     return mediaSessionCache[playerId] || {};
   };
-  var saveHeartbeat = function saveHeartbeat(_ref) {
+  var savePing = function savePing(_ref) {
     var playerId = _ref.playerId,
-      heartbeatId = _ref.heartbeatId;
-    var mediaSession = mediaSessionCache[playerId];
-    if (!mediaSession) {
+      pingId = _ref.pingId,
+      playbackState = _ref.playbackState;
+    if (!mediaSessionCache[playerId]) {
       return;
     }
-    mediaSession.heartbeatId = heartbeatId;
-  };
-  var stopHeartbeat = function stopHeartbeat(_ref2) {
-    var playerId = _ref2.playerId;
-    var 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;
   };
-  var updateLastTriggeredEventTS = function updateLastTriggeredEventTS(_ref3) {
-    var playerId = _ref3.playerId;
-    var player = mediaSessionCache[playerId];
-    if (!player) {
+  var stopPing = function stopPing(_ref2) {
+    var playerId = _ref2.playerId;
+    var sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
       return;
     }
-    player.latestTriggeredEvent = Date.now();
+    clearTimeout(sessionDetails.pingId);
+    sessionDetails.pingId = null;
+    sessionDetails.playbackState = _playbackState.default.COMPLETED;
   };
-  var storeSession = function storeSession(_ref4) {
-    var playerId = _ref4.playerId,
-      sessionDetails = _ref4.sessionDetails;
+  var storeSession = function storeSession(_ref3) {
+    var playerId = _ref3.playerId,
+      sessionDetails = _ref3.sessionDetails;
     if (mediaSessionCache === undefined) {
       mediaSessionCache = {};
     }
@@ -53,10 +51,8 @@ var _default = function _default() {
   };
   return {
     getSession: getSession,
-    stopHeartbeat: stopHeartbeat,
-    updateLastTriggeredEventTS: updateLastTriggeredEventTS,
     storeSession: storeSession,
-    saveHeartbeat: saveHeartbeat
+    stopPing: stopPing,
+    savePing: savePing
   };
-};
-exports.default = _default;
+};

package/libEs5/components/StreamingMedia/createStreamingMediaComponent.js

@@ -0,0 +1,72 @@
+"use strict";
+
+exports.default = void 0;
+var _utils = require("../../utils");
+var _validateMediaSessionOptions = require("./validateMediaSessionOptions");
+var _validateMediaEventOptions = require("./validateMediaEventOptions");
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var config = _ref.config,
+    trackMediaEvent = _ref.trackMediaEvent,
+    trackMediaSession = _ref.trackMediaSession,
+    mediaResponseHandler = _ref.mediaResponseHandler;
+  return {
+    lifecycle: {
+      onBeforeEvent: function onBeforeEvent(_ref2) {
+        var mediaOptions = _ref2.mediaOptions,
+          _ref2$onResponse = _ref2.onResponse,
+          onResponse = _ref2$onResponse === void 0 ? _utils.noop : _ref2$onResponse;
+        if (!mediaOptions) {
+          return;
+        }
+        var legacy = mediaOptions.legacy,
+          playerId = mediaOptions.playerId,
+          getPlayerDetails = mediaOptions.getPlayerDetails;
+        if (legacy) {
+          return;
+        }
+        onResponse(function (_ref3) {
+          var response = _ref3.response;
+          return mediaResponseHandler({
+            playerId: playerId,
+            getPlayerDetails: getPlayerDetails,
+            response: response
+          });
+        });
+      }
+    },
+    commands: {
+      createMediaSession: {
+        optionsValidator: function optionsValidator(options) {
+          return (0, _validateMediaSessionOptions.default)({
+            options: options
+          });
+        },
+        run: trackMediaSession
+      },
+      sendMediaEvent: {
+        optionsValidator: function optionsValidator(options) {
+          return (0, _validateMediaEventOptions.default)({
+            options: options
+          });
+        },
+        run: function run(options) {
+          if (!config.streamingMedia) {
+            return Promise.reject(new Error("Streaming media is not configured."));
+          }
+          return trackMediaEvent(options);
+        }
+      }
+    }
+  };
+};

package/libEs5/components/StreamingMedia/createTrackMediaEvent.js

@@ -0,0 +1,90 @@
+"use strict";
+
+exports.default = void 0;
+var _eventTypes = require("./constants/eventTypes");
+/*
+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.
+*/
+
+var getContentState = function getContentState(eventType, sessionContentState) {
+  if (eventType === _eventTypes.default.AD_START || eventType === _eventTypes.default.Ad_BREAK_START || eventType === _eventTypes.default.AD_SKIP || eventType === _eventTypes.default.AD_COMPLETE) {
+    return "ad";
+  }
+  if (eventType === _eventTypes.default.AD_BREAK_COMPLETE || eventType === _eventTypes.default.CHAPTER_COMPLETE || eventType === _eventTypes.default.CHAPTER_START || eventType === _eventTypes.default.CHAPTER_SKIP || eventType === _eventTypes.default.SESSION_START) {
+    return "main";
+  }
+  if (eventType === _eventTypes.default.SESSION_END || eventType === _eventTypes.default.SESSION_COMPLETE) {
+    return "completed";
+  }
+  return sessionContentState;
+};
+var _default = exports.default = function _default(_ref) {
+  var mediaEventManager = _ref.mediaEventManager,
+    mediaSessionCacheManager = _ref.mediaSessionCacheManager,
+    config = _ref.config;
+  var sendMediaEvent = function sendMediaEvent(options) {
+    var event = mediaEventManager.createMediaEvent({
+      options: options
+    });
+    var playerId = options.playerId,
+      xdm = options.xdm;
+    var eventType = xdm.eventType;
+    var action = eventType.split(".")[1];
+    var _mediaSessionCacheMan = mediaSessionCacheManager.getSession(playerId),
+      getPlayerDetails = _mediaSessionCacheMan.getPlayerDetails,
+      sessionPromise = _mediaSessionCacheMan.sessionPromise,
+      playbackState = _mediaSessionCacheMan.playbackState;
+    return sessionPromise.then(function (result) {
+      mediaEventManager.augmentMediaEvent({
+        event: event,
+        eventType: eventType,
+        playerId: playerId,
+        getPlayerDetails: getPlayerDetails,
+        sessionID: result.sessionId
+      });
+      return mediaEventManager.trackMediaEvent({
+        event: event,
+        action: action
+      }).then(function () {
+        if (playerId) {
+          if (eventType === _eventTypes.default.SESSION_COMPLETE || eventType === _eventTypes.default.SESSION_END) {
+            mediaSessionCacheManager.stopPing({
+              playerId: playerId
+            });
+          } else {
+            var sessionPlaybackState = getContentState(eventType, playbackState);
+            if (sessionPlaybackState === "completed") {
+              return;
+            }
+            var interval = sessionPlaybackState === "ad" ? config.streamingMedia.adPingInterval : config.streamingMedia.mainPingInterval;
+            var pingId = setTimeout(function () {
+              var pingOptions = {
+                playerId: playerId,
+                xdm: {
+                  eventType: _eventTypes.default.PING
+                }
+              };
+              sendMediaEvent(pingOptions);
+            }, interval * 1000);
+            mediaSessionCacheManager.savePing({
+              playerId: playerId,
+              pingId: pingId,
+              playbackState: sessionPlaybackState
+            });
+          }
+        }
+      });
+    });
+  };
+  return function (options) {
+    return sendMediaEvent(options);
+  };
+};

package/libEs5/components/StreamingMedia/createTrackMediaSession.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.default = void 0;
+var _playbackState = require("./constants/playbackState");
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var config = _ref.config,
+    mediaEventManager = _ref.mediaEventManager,
+    mediaSessionCacheManager = _ref.mediaSessionCacheManager,
+    _ref$legacy = _ref.legacy,
+    legacy = _ref$legacy === void 0 ? false : _ref$legacy;
+  return function (options) {
+    if (!config.streamingMedia) {
+      return Promise.reject(new Error("Streaming media is not configured."));
+    }
+    var playerId = options.playerId,
+      getPlayerDetails = options.getPlayerDetails;
+    var event = mediaEventManager.createMediaSession(options);
+    mediaEventManager.augmentMediaEvent({
+      event: event,
+      playerId: playerId,
+      getPlayerDetails: getPlayerDetails
+    });
+    var sessionPromise = mediaEventManager.trackMediaSession({
+      event: event,
+      mediaOptions: {
+        playerId: playerId,
+        getPlayerDetails: getPlayerDetails,
+        legacy: legacy
+      }
+    });
+    mediaSessionCacheManager.storeSession({
+      playerId: playerId,
+      sessionDetails: {
+        sessionPromise: sessionPromise,
+        getPlayerDetails: getPlayerDetails,
+        playbackState: _playbackState.default.MAIN
+      }
+    });
+    return sessionPromise;
+  };
+};

package/libEs5/components/StreamingMedia/index.js

@@ -0,0 +1,69 @@
+"use strict";
+
+exports.default = void 0;
+var _createMediaSessionCacheManager = require("./createMediaSessionCacheManager");
+var _createMediaEventManager = require("./createMediaEventManager");
+var _createTrackMediaEvent = require("./createTrackMediaEvent");
+var _configValidators = require("./configValidators");
+var _createStreamingMediaComponent = require("./createStreamingMediaComponent");
+var _createTrackMediaSession = require("./createTrackMediaSession");
+var _createMediaResponseHandler = require("./createMediaResponseHandler");
+var _injectTimestamp = require("../Context/injectTimestamp");
+/*
+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 createStreamingMedia = function createStreamingMedia(_ref) {
+  var config = _ref.config,
+    logger = _ref.logger,
+    eventManager = _ref.eventManager,
+    sendEdgeNetworkRequest = _ref.sendEdgeNetworkRequest,
+    consent = _ref.consent;
+  var mediaSessionCacheManager = (0, _createMediaSessionCacheManager.default)({
+    config: config
+  });
+  var mediaEventManager = (0, _createMediaEventManager.default)({
+    config: config,
+    eventManager: eventManager,
+    logger: logger,
+    consent: consent,
+    sendEdgeNetworkRequest: sendEdgeNetworkRequest,
+    setTimestamp: (0, _injectTimestamp.default)(function () {
+      return new Date();
+    })
+  });
+  var trackMediaEvent = (0, _createTrackMediaEvent.default)({
+    mediaSessionCacheManager: mediaSessionCacheManager,
+    mediaEventManager: mediaEventManager,
+    config: config
+  });
+  var trackMediaSession = (0, _createTrackMediaSession.default)({
+    config: config,
+    mediaEventManager: mediaEventManager,
+    mediaSessionCacheManager: mediaSessionCacheManager
+  });
+  var mediaResponseHandler = (0, _createMediaResponseHandler.default)({
+    mediaSessionCacheManager: mediaSessionCacheManager,
+    config: config,
+    trackMediaEvent: trackMediaEvent
+  });
+  return (0, _createStreamingMediaComponent.default)({
+    config: config,
+    trackMediaEvent: trackMediaEvent,
+    mediaEventManager: mediaEventManager,
+    mediaResponseHandler: mediaResponseHandler,
+    trackMediaSession: trackMediaSession
+  });
+};
+createStreamingMedia.namespace = "Streaming media";
+createStreamingMedia.configValidators = _configValidators.default;
+var _default = exports.default = createStreamingMedia;

package/libEs5/components/StreamingMedia/validateMediaEventOptions.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.default = void 0;
+var _validation = require("../../utils/validation");
+var _eventTypes = require("./constants/eventTypes");
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /*
+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 = exports.default = function _default(_ref) {
+  var options = _ref.options;
+  var validator = (0, _validation.anyOf)([(0, _validation.objectOf)({
+    playerId: (0, _validation.string)().required(),
+    xdm: (0, _validation.objectOf)({
+      eventType: _validation.enumOf.apply(void 0, _toConsumableArray(Object.values(_eventTypes.default))).required(),
+      mediaCollection: (0, _validation.objectOf)((0, _validation.anything)())
+    }).required()
+  }).required(), (0, _validation.objectOf)({
+    xdm: (0, _validation.objectOf)({
+      eventType: _validation.enumOf.apply(void 0, _toConsumableArray(Object.values(_eventTypes.default))).required(),
+      mediaCollection: (0, _validation.objectOf)({
+        playhead: (0, _validation.number)().integer().required(),
+        sessionID: (0, _validation.string)().required()
+      }).required()
+    }).required()
+  }).required()], "Error validating the sendMediaEvent command options.");
+  return validator(options);
+};

package/libEs5/components/{MediaCollection → StreamingMedia}/validateMediaSessionOptions.js

@@ -13,11 +13,11 @@ 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.
 */
-var _default = function _default(_ref) {
+var _default = exports.default = function _default(_ref) {
   var options = _ref.options;
   var sessionValidator = (0, _validation.anyOf)([(0, _validation.objectOf)({
     playerId: (0, _validation.string)().required(),
-    onBeforeMediaEvent: (0, _validation.callback)().required(),
+    getPlayerDetails: (0, _validation.callback)().required(),
     xdm: (0, _validation.objectOf)({
       mediaCollection: (0, _validation.objectOf)({
         sessionDetails: (0, _validation.objectOf)((0, _validation.anything)()).required()
@@ -32,5 +32,4 @@ var _default = function _default(_ref) {
     })
   }).required()], "Error validating the createMediaSession command options.");
   return sessionValidator(options);
-};
-exports.default = _default;
+};

package/libEs5/constants/apiVersion.js

@@ -12,5 +12,4 @@ 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.
 */
-var _default = "v1";
-exports.default = _default;
+var _default = exports.default = "v1";