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

package/libEs5/components/Privacy/validateSetConsentOptions.js

@@ -14,9 +14,8 @@ 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 = (0, _validation.objectOf)({
+var _default = exports.default = (0, _validation.objectOf)({
   consent: (0, _validation.arrayOf)((0, _validation.anything)()).required().nonEmpty(),
   identityMap: _utils.validateIdentityMap,
   edgeConfigOverrides: _utils.validateConfigOverride
-}).noUnknownFields().required();
-exports.default = _default;
+}).noUnknownFields().required();

package/libEs5/components/StreamingMedia/configValidators.js

@@ -0,0 +1,24 @@
+"use strict";
+
+exports.default = void 0;
+var _validation = require("../../utils/validation");
+/*
+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 = (0, _validation.objectOf)({
+  streamingMedia: (0, _validation.objectOf)({
+    channel: (0, _validation.string)().nonEmpty().required(),
+    playerName: (0, _validation.string)().nonEmpty().required(),
+    appVersion: (0, _validation.string)(),
+    mainPingInterval: (0, _validation.number)().minimum(10).maximum(50).default(10),
+    adPingInterval: (0, _validation.number)().minimum(1).maximum(10).default(10)
+  }).noUnknownFields()
+});

package/libEs5/components/{MediaCollection → StreamingMedia}/constants/eventTypes.js

@@ -12,14 +12,23 @@ 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 = {
+var _default = exports.default = {
   PAUSE: "media.pauseStart",
   PLAY: "media.play",
-  BUFFERING: "media.buffering",
+  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"
-};
-exports.default = _default;
+  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/utils/debounce.js → libEs5/components/StreamingMedia/constants/playbackState.js}

@@ -1,5 +1,8 @@
+"use strict";
+
+exports.default = void 0;
 /*
-Copyright 2023 Adobe. All rights reserved.
+Copyright 2024 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License. You may obtain a copy
 of the License at http://www.apache.org/licenses/LICENSE-2.0
@@ -9,14 +12,8 @@ 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.
 */
-export default ((fn, delay = 150) => {
-  let timer;
-  return (...args) => {
-    if (timer) {
-      clearTimeout(timer);
-    }
-    timer = setTimeout(() => {
-      fn(...args);
-    }, delay);
-  };
-});
+var _default = exports.default = {
+  MAIN: "main",
+  AD: "ad",
+  COMPLETED: "completed"
+};

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

@@ -3,7 +3,6 @@
 exports.default = void 0;
 var _eventTypes = require("./constants/eventTypes");
 var _createMediaRequest = require("./createMediaRequest");
-var _injectTimestamp = require("../Context/injectTimestamp");
 var _utils = require("../../utils");
 var _request = require("../../utils/request");
 /*
@@ -17,29 +16,36 @@ 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 event = eventManager.createEvent();
       var xdm = options.xdm;
-      var timestamp = (0, _injectTimestamp.default)(function () {
-        return new Date();
-      });
-      timestamp(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);
@@ -49,7 +55,7 @@ var _default = function _default(_ref) {
           sessionDetails: {
             playerName: sessionDetails.playerName || playerName,
             channel: sessionDetails.channel || channel,
-            appVersion: sessionDetails.appVersion || version
+            appVersion: sessionDetails.appVersion || appVersion
           }
         }
       });
@@ -58,16 +64,16 @@ 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;
+        playhead = _getPlayerDetails.playhead,
+        qoeDataDetails = _getPlayerDetails.qoeDataDetails;
       event.mergeXdm({
         mediaCollection: {
           playhead: (0, _utils.toInteger)(playhead),
@@ -79,11 +85,9 @@ var _default = function _default(_ref) {
     },
     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) {
@@ -105,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 sessionDetails = mediaSessionCache[playerId];
-    if (!sessionDetails) {
+      pingId = _ref.pingId,
+      playbackState = _ref.playbackState;
+    if (!mediaSessionCache[playerId]) {
       return;
     }
-    sessionDetails.heartbeatId = heartbeatId;
-  };
-  var stopHeartbeat = function stopHeartbeat(_ref2) {
-    var playerId = _ref2.playerId;
-    var sessionDetails = mediaSessionCache[playerId];
-    if (!sessionDetails) {
-      return;
+    if (mediaSessionCache[playerId].pingId) {
+      clearTimeout(mediaSessionCache[playerId].pingId);
     }
-    clearInterval(sessionDetails.heartbeatId);
-    sessionDetails.heartbeatId = null;
+    mediaSessionCache[playerId].pingId = pingId;
+    mediaSessionCache[playerId].playbackState = playbackState;
   };
-  var updateLastTriggeredEventTS = function updateLastTriggeredEventTS(_ref3) {
-    var playerId = _ref3.playerId;
+  var stopPing = function stopPing(_ref2) {
+    var playerId = _ref2.playerId;
     var sessionDetails = mediaSessionCache[playerId];
     if (!sessionDetails) {
       return;
     }
-    sessionDetails.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;