@adobe/alloy 2.20.0-beta.2 → 2.20.0-beta.6

package/libEs5/components/Privacy/validateSetConsentOptions.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/validation/index.js");
+var _index2 = require("../../utils/index.js");
+/*
+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 = (0, _index.objectOf)({
+  consent: (0, _index.arrayOf)((0, _index.anything)()).required().nonEmpty(),
+  identityMap: _index2.validateIdentityMap,
+  edgeConfigOverrides: _index2.validateConfigOverride
+}).noUnknownFields().required();

package/libEs5/components/StreamingMedia/configValidators.js

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

package/libEs5/components/StreamingMedia/constants/eventTypes.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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 = {
+  PAUSE: "media.pauseStart",
+  PLAY: "media.play",
+  BUFFER_START: "media.bufferStart",
+  AD_START: "media.adStart",
+  Ad_BREAK_START: "media.adBreakStart",
+  SESSION_END: "media.sessionEnd",
+  SESSION_START: "media.sessionStart",
+  SESSION_COMPLETE: "media.sessionComplete",
+  PING: "media.ping",
+  AD_BREAK_COMPLETE: "media.adBreakComplete",
+  AD_COMPLETE: "media.adComplete",
+  AD_SKIP: "media.adSkip",
+  BITRATE_CHANGE: "media.bitrateChange",
+  CHAPTER_COMPLETE: "media.chapterComplete",
+  CHAPTER_SKIP: "media.chapterSkip",
+  CHAPTER_START: "media.chapterStart",
+  ERROR: "media.error",
+  STATES_UPDATE: "media.statesUpdate"
+};

package/libEs5/components/StreamingMedia/constants/playbackState.js

@@ -0,0 +1,19 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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 = {
+  MAIN: "main",
+  AD: "ad",
+  COMPLETED: "completed"
+};

package/libEs5/components/StreamingMedia/createMediaEventManager.js

@@ -0,0 +1,112 @@
+"use strict";
+
+exports.default = void 0;
+var _eventTypes = require("./constants/eventTypes.js");
+var _createMediaRequest = require("./createMediaRequest.js");
+var _index = require("../../utils/index.js");
+var _index2 = require("../../utils/request/index.js");
+/*
+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 config = _ref.config,
+    eventManager = _ref.eventManager,
+    consent = _ref.consent,
+    sendEdgeNetworkRequest = _ref.sendEdgeNetworkRequest,
+    setTimestamp = _ref.setTimestamp;
+  return {
+    createMediaEvent: function createMediaEvent(_ref2) {
+      var options = _ref2.options;
+      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$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: _eventTypes.default.SESSION_START,
+        mediaCollection: {
+          sessionDetails: {
+            playerName: sessionDetails.playerName || playerName,
+            channel: sessionDetails.channel || channel,
+            appVersion: sessionDetails.appVersion || appVersion
+          }
+        }
+      });
+      return event;
+    },
+    augmentMediaEvent: function augmentMediaEvent(_ref3) {
+      var event = _ref3.event,
+        playerId = _ref3.playerId,
+        getPlayerDetails = _ref3.getPlayerDetails,
+        sessionID = _ref3.sessionID;
+      if (!playerId || !getPlayerDetails) {
+        return event;
+      }
+      var _getPlayerDetails = getPlayerDetails({
+          playerId: playerId
+        }),
+        playhead = _getPlayerDetails.playhead,
+        qoeDataDetails = _getPlayerDetails.qoeDataDetails;
+      event.mergeXdm({
+        mediaCollection: {
+          playhead: (0, _index.toInteger)(playhead),
+          qoeDataDetails: qoeDataDetails,
+          sessionID: sessionID
+        }
+      });
+      return event;
+    },
+    trackMediaSession: function trackMediaSession(_ref4) {
+      var event = _ref4.event,
+        mediaOptions = _ref4.mediaOptions;
+      return eventManager.sendEvent(event, {
+        mediaOptions: mediaOptions
+      });
+    },
+    trackMediaEvent: function trackMediaEvent(_ref5) {
+      var event = _ref5.event,
+        action = _ref5.action;
+      var mediaRequestPayload = (0, _index2.createDataCollectionRequestPayload)();
+      var request = (0, _createMediaRequest.default)({
+        mediaRequestPayload: mediaRequestPayload,
+        action: action
+      });
+      mediaRequestPayload.addEvent(event);
+      event.finalize();
+      return consent.awaitConsent().then(function () {
+        return sendEdgeNetworkRequest({
+          request: request
+        }).then(function () {
+          return {};
+        });
+      });
+    }
+  };
+};

package/libEs5/components/StreamingMedia/createMediaRequest.js

@@ -0,0 +1,29 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/request/index.js");
+/*
+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 mediaRequestPayload = _ref.mediaRequestPayload,
+    action = _ref.action;
+  return (0, _index.createRequest)({
+    payload: mediaRequestPayload,
+    edgeSubPath: "/va",
+    getAction: function getAction() {
+      return action;
+    },
+    getUseSendBeacon: function getUseSendBeacon() {
+      return false;
+    }
+  });
+};

package/libEs5/components/StreamingMedia/createMediaResponseHandler.js

@@ -0,0 +1,57 @@
+"use strict";
+
+exports.default = void 0;
+var _isBlankString = require("../../utils/isBlankString.js");
+var _eventTypes = require("./constants/eventTypes.js");
+var _index = require("../../utils/index.js");
+var _playbackState = require("./constants/playbackState.js");
+/*
+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, _index.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/StreamingMedia/createMediaSessionCacheManager.js

@@ -0,0 +1,58 @@
+"use strict";
+
+exports.default = void 0;
+var _playbackState = require("./constants/playbackState.js");
+/*
+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() {
+  var mediaSessionCache;
+  var getSession = function getSession(playerId) {
+    return mediaSessionCache[playerId] || {};
+  };
+  var savePing = function savePing(_ref) {
+    var playerId = _ref.playerId,
+      pingId = _ref.pingId,
+      playbackState = _ref.playbackState;
+    if (!mediaSessionCache[playerId]) {
+      return;
+    }
+    if (mediaSessionCache[playerId].pingId) {
+      clearTimeout(mediaSessionCache[playerId].pingId);
+    }
+    mediaSessionCache[playerId].pingId = pingId;
+    mediaSessionCache[playerId].playbackState = playbackState;
+  };
+  var stopPing = function stopPing(_ref2) {
+    var playerId = _ref2.playerId;
+    var sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
+      return;
+    }
+    clearTimeout(sessionDetails.pingId);
+    sessionDetails.pingId = null;
+    sessionDetails.playbackState = _playbackState.default.COMPLETED;
+  };
+  var storeSession = function storeSession(_ref3) {
+    var playerId = _ref3.playerId,
+      sessionDetails = _ref3.sessionDetails;
+    if (mediaSessionCache === undefined) {
+      mediaSessionCache = {};
+    }
+    mediaSessionCache[playerId] = sessionDetails;
+  };
+  return {
+    getSession: getSession,
+    storeSession: storeSession,
+    stopPing: stopPing,
+    savePing: savePing
+  };
+};

package/libEs5/components/StreamingMedia/createStreamingMediaComponent.js

@@ -0,0 +1,72 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/index.js");
+var _validateMediaSessionOptions = require("./validateMediaSessionOptions.js");
+var _validateMediaEventOptions = require("./validateMediaEventOptions.js");
+/*
+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 ? _index.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.js");
+/*
+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.js");
+/*
+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.js");
+var _createMediaEventManager = require("./createMediaEventManager.js");
+var _createTrackMediaEvent = require("./createTrackMediaEvent.js");
+var _configValidators = require("./configValidators.js");
+var _createStreamingMediaComponent = require("./createStreamingMediaComponent.js");
+var _createTrackMediaSession = require("./createTrackMediaSession.js");
+var _createMediaResponseHandler = require("./createMediaResponseHandler.js");
+var _injectTimestamp = require("../Context/injectTimestamp.js");
+/*
+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;