rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/refresh_scheduled_events_list.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,18 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import areSameStreamEvents from "./are_same_stream_events";
+Object.defineProperty(exports, "__esModule", { value: true });
+const are_same_stream_events_1 = require("./are_same_stream_events");
 /**
  * Refresh local scheduled events list
  * @param {Array.<Object>} oldScheduledEvents
@@ -32,35 +23,42 @@ import areSameStreamEvents from "./are_same_stream_events";
  * @returns {Array.<Object>}
  */
 function refreshScheduledEventsList(oldScheduledEvents, manifest) {
-    var scheduledEvents = [];
-    var periods = manifest.periods;
-    for (var i = 0; i < periods.length; i++) {
-        var period = periods[i];
-        var streamEvents = period.streamEvents;
-        streamEvents.forEach(function (_a) {
-            var start = _a.start, end = _a.end, id = _a.id, data = _a.data;
-            for (var j = 0; j < oldScheduledEvents.length; j++) {
-                var currentScheduledEvent = oldScheduledEvents[j];
-                if (areSameStreamEvents(currentScheduledEvent, { id: id, start: start, end: end })) {
+    const scheduledEvents = [];
+    const { periods } = manifest;
+    for (let i = 0; i < periods.length; i++) {
+        const period = periods[i];
+        const { streamEvents } = period;
+        streamEvents.forEach(({ start, end, id, data }) => {
+            for (let j = 0; j < oldScheduledEvents.length; j++) {
+                const currentScheduledEvent = oldScheduledEvents[j];
+                if ((0, are_same_stream_events_1.default)(currentScheduledEvent, { id, start, end })) {
                     scheduledEvents.push(currentScheduledEvent);
                     return;
                 }
             }
-            var element = data.value.element;
-            var actualData = { type: data.type,
-                value: __assign(__assign({}, data.value), { element: element }) };
+            const element = data.value.element;
+            const actualData = { type: data.type,
+                value: Object.assign(Object.assign({}, data.value), { element }) };
             if (end === undefined) {
-                var newScheduledEvent = { start: start, id: id, data: actualData,
-                    publicEvent: { start: start, data: actualData } };
+                const newScheduledEvent = { start,
+                    id,
+                    data: actualData,
+                    publicEvent: { start,
+                        data: actualData } };
                 scheduledEvents.push(newScheduledEvent);
             }
             else {
-                var newScheduledEvent = { start: start, end: end, id: id, data: actualData,
-                    publicEvent: { start: start, end: end, data: actualData } };
+                const newScheduledEvent = { start,
+                    end,
+                    id,
+                    data: actualData,
+                    publicEvent: { start,
+                        end,
+                        data: actualData } };
                 scheduledEvents.push(newScheduledEvent);
             }
         });
     }
     return scheduledEvents;
 }
-export default refreshScheduledEventsList;
+exports.default = refreshScheduledEventsList;

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/stream_events_emitter.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,70 +14,52 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import config from "../../../../config";
-import EventEmitter from "../../../../utils/event_emitter";
-import SharedReference from "../../../../utils/reference";
-import TaskCanceller from "../../../../utils/task_canceller";
-import refreshScheduledEventsList from "./refresh_scheduled_events_list";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../../config");
+const event_emitter_1 = require("../../../../utils/event_emitter");
+const reference_1 = require("../../../../utils/reference");
+const task_canceller_1 = require("../../../../utils/task_canceller");
+const refresh_scheduled_events_list_1 = require("./refresh_scheduled_events_list");
 /**
  * Get events from manifest and emit each time an event has to be emitted
  */
-var StreamEventsEmitter = /** @class */ (function (_super) {
-    __extends(StreamEventsEmitter, _super);
+class StreamEventsEmitter extends event_emitter_1.default {
     /**
      * @param {Object} manifest
      * @param {HTMLMediaElement} mediaElement
      * @param {Object} playbackObserver
      */
-    function StreamEventsEmitter(manifest, mediaElement, playbackObserver) {
-        var _this = _super.call(this) || this;
-        _this._manifest = manifest;
-        _this._mediaElement = mediaElement;
-        _this._playbackObserver = playbackObserver;
-        _this._canceller = null;
-        _this._scheduledEventsRef = new SharedReference([]);
-        _this._eventsBeingPlayed =
+    constructor(manifest, mediaElement, playbackObserver) {
+        super();
+        this._manifest = manifest;
+        this._mediaElement = mediaElement;
+        this._playbackObserver = playbackObserver;
+        this._canceller = null;
+        this._scheduledEventsRef = new reference_1.default([]);
+        this._eventsBeingPlayed =
             new WeakMap();
-        return _this;
     }
-    StreamEventsEmitter.prototype.start = function () {
-        var _this = this;
+    start() {
         if (this._canceller !== null) {
             return;
         }
-        this._canceller = new TaskCanceller();
-        var cancelSignal = this._canceller.signal;
-        var playbackObserver = this._playbackObserver;
-        var mediaElement = this._mediaElement;
-        var isPollingEvents = false;
-        var cancelCurrentPolling = new TaskCanceller();
+        this._canceller = new task_canceller_1.default();
+        const cancelSignal = this._canceller.signal;
+        const playbackObserver = this._playbackObserver;
+        const mediaElement = this._mediaElement;
+        let isPollingEvents = false;
+        let cancelCurrentPolling = new task_canceller_1.default();
         cancelCurrentPolling.linkToSignal(cancelSignal);
-        this._manifest.addEventListener("manifestUpdate", function () {
-            var prev = _this._scheduledEventsRef.getValue();
-            _this._scheduledEventsRef.setValue(refreshScheduledEventsList(prev, _this._manifest));
+        this._manifest.addEventListener("manifestUpdate", () => {
+            const prev = this._scheduledEventsRef.getValue();
+            this._scheduledEventsRef.setValue((0, refresh_scheduled_events_list_1.default)(prev, this._manifest));
         }, this._canceller.signal);
-        this._scheduledEventsRef.setValue(refreshScheduledEventsList([], this._manifest));
-        this._scheduledEventsRef.onUpdate(function (_a) {
-            var scheduledEventsLength = _a.length;
+        this._scheduledEventsRef.setValue((0, refresh_scheduled_events_list_1.default)([], this._manifest));
+        this._scheduledEventsRef.onUpdate(({ length: scheduledEventsLength }) => {
             if (scheduledEventsLength === 0) {
                 if (isPollingEvents) {
                     cancelCurrentPolling.cancel();
-                    cancelCurrentPolling = new TaskCanceller();
+                    cancelCurrentPolling = new task_canceller_1.default();
                     cancelCurrentPolling.linkToSignal(cancelSignal);
                     isPollingEvents = false;
                 }
@@ -86,31 +69,32 @@ var StreamEventsEmitter = /** @class */ (function (_super) {
                 return;
             }
             isPollingEvents = true;
-            var oldObservation = constructObservation();
-            var checkStreamEvents = function () {
-                var newObservation = constructObservation();
-                _this._emitStreamEvents(_this._scheduledEventsRef.getValue(), oldObservation, newObservation, cancelCurrentPolling.signal);
+            let oldObservation = constructObservation();
+            const checkStreamEvents = () => {
+                const newObservation = constructObservation();
+                this._emitStreamEvents(this._scheduledEventsRef.getValue(), oldObservation, newObservation, cancelCurrentPolling.signal);
                 oldObservation = newObservation;
             };
-            var STREAM_EVENT_EMITTER_POLL_INTERVAL = config.getCurrent().STREAM_EVENT_EMITTER_POLL_INTERVAL;
-            var intervalId = setInterval(checkStreamEvents, STREAM_EVENT_EMITTER_POLL_INTERVAL);
+            const { STREAM_EVENT_EMITTER_POLL_INTERVAL } = config_1.default.getCurrent();
+            const intervalId = setInterval(checkStreamEvents, STREAM_EVENT_EMITTER_POLL_INTERVAL);
             playbackObserver.listen(checkStreamEvents, { includeLastObservation: false,
                 clearSignal: cancelCurrentPolling.signal });
-            cancelCurrentPolling.signal.register(function () {
+            cancelCurrentPolling.signal.register(() => {
                 clearInterval(intervalId);
             });
             function constructObservation() {
-                var isSeeking = playbackObserver.getReference().getValue().seeking;
-                return { currentTime: mediaElement.currentTime, isSeeking: isSeeking };
+                const isSeeking = playbackObserver.getReference().getValue().seeking;
+                return { currentTime: mediaElement.currentTime,
+                    isSeeking };
             }
         }, { emitCurrentValue: true, clearSignal: cancelSignal });
-    };
-    StreamEventsEmitter.prototype.stop = function () {
+    }
+    stop() {
         if (this._canceller !== null) {
             this._canceller.cancel();
             this._canceller = null;
         }
-    };
+    }
     /**
      * Examine playback situation from playback observations to emit stream events and
      * prepare set onExit callbacks if needed.
@@ -119,56 +103,55 @@ var StreamEventsEmitter = /** @class */ (function (_super) {
      * @param {Object} newObservation
      * @param {Object} stopSignal
      */
-    StreamEventsEmitter.prototype._emitStreamEvents = function (scheduledEvents, oldObservation, newObservation, stopSignal) {
-        var previousTime = oldObservation.currentTime;
-        var isSeeking = newObservation.isSeeking, currentTime = newObservation.currentTime;
-        var eventsToSend = [];
-        var eventsToExit = [];
-        for (var i = 0; i < scheduledEvents.length; i++) {
-            var event_1 = scheduledEvents[i];
-            var start = event_1.start;
-            var end = isFiniteStreamEvent(event_1) ? event_1.end :
+    _emitStreamEvents(scheduledEvents, oldObservation, newObservation, stopSignal) {
+        const { currentTime: previousTime } = oldObservation;
+        const { isSeeking, currentTime } = newObservation;
+        const eventsToSend = [];
+        const eventsToExit = [];
+        for (let i = 0; i < scheduledEvents.length; i++) {
+            const event = scheduledEvents[i];
+            const start = event.start;
+            const end = isFiniteStreamEvent(event) ? event.end :
                 undefined;
-            var isBeingPlayed = this._eventsBeingPlayed.has(event_1);
+            const isBeingPlayed = this._eventsBeingPlayed.has(event);
             if (isBeingPlayed) {
                 if (start > currentTime ||
                     (end !== undefined && currentTime >= end)) {
-                    if (isFiniteStreamEvent(event_1)) {
-                        eventsToExit.push(event_1.publicEvent);
+                    if (isFiniteStreamEvent(event)) {
+                        eventsToExit.push(event.publicEvent);
                     }
-                    this._eventsBeingPlayed.delete(event_1);
+                    this._eventsBeingPlayed.delete(event);
                 }
             }
             else if (start <= currentTime &&
                 end !== undefined &&
                 currentTime < end) {
                 eventsToSend.push({ type: "stream-event",
-                    value: event_1.publicEvent });
-                this._eventsBeingPlayed.set(event_1, true);
+                    value: event.publicEvent });
+                this._eventsBeingPlayed.set(event, true);
             }
             else if (previousTime < start &&
                 currentTime >= (end !== null && end !== void 0 ? end : start)) {
                 if (isSeeking) {
                     eventsToSend.push({ type: "stream-event-skip",
-                        value: event_1.publicEvent });
+                        value: event.publicEvent });
                 }
                 else {
                     eventsToSend.push({ type: "stream-event",
-                        value: event_1.publicEvent });
-                    if (isFiniteStreamEvent(event_1)) {
-                        eventsToExit.push(event_1.publicEvent);
+                        value: event.publicEvent });
+                    if (isFiniteStreamEvent(event)) {
+                        eventsToExit.push(event.publicEvent);
                     }
                 }
             }
         }
         if (eventsToSend.length > 0) {
-            for (var _i = 0, eventsToSend_1 = eventsToSend; _i < eventsToSend_1.length; _i++) {
-                var event_2 = eventsToSend_1[_i];
-                if (event_2.type === "stream-event") {
-                    this.trigger("event", event_2.value);
+            for (const event of eventsToSend) {
+                if (event.type === "stream-event") {
+                    this.trigger("event", event.value);
                 }
                 else {
-                    this.trigger("eventSkip", event_2.value);
+                    this.trigger("eventSkip", event.value);
                 }
                 if (stopSignal.isCancelled()) {
                     return;
@@ -176,20 +159,18 @@ var StreamEventsEmitter = /** @class */ (function (_super) {
             }
         }
         if (eventsToExit.length > 0) {
-            for (var _a = 0, eventsToExit_1 = eventsToExit; _a < eventsToExit_1.length; _a++) {
-                var event_3 = eventsToExit_1[_a];
-                if (typeof event_3.onExit === "function") {
-                    event_3.onExit();
+            for (const event of eventsToExit) {
+                if (typeof event.onExit === "function") {
+                    event.onExit();
                 }
                 if (stopSignal.isCancelled()) {
                     return;
                 }
             }
         }
-    };
-    return StreamEventsEmitter;
-}(EventEmitter));
-export default StreamEventsEmitter;
+    }
+}
+exports.default = StreamEventsEmitter;
 /**
  * Tells if a stream event has a duration
  * @param {Object} evt

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/types.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,4 +14,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/_esm5.processed/core/init/utils/throw_on_media_error.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,46 +14,48 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MediaError } from "../../../errors";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../../errors");
+const is_null_or_undefined_1 = require("../../../utils/is_null_or_undefined");
 /**
  * @param {HTMLMediaElement} mediaElement
  * @param {Function} onError
  * @param {Object} cancelSignal
  */
-export default function listenToMediaError(mediaElement, onError, cancelSignal) {
+function listenToMediaError(mediaElement, onError, cancelSignal) {
     if (cancelSignal.isCancelled()) {
         return;
     }
     mediaElement.addEventListener("error", onMediaError);
-    cancelSignal.register(function () {
+    cancelSignal.register(() => {
         mediaElement.removeEventListener("error", onMediaError);
     });
     function onMediaError() {
-        var mediaError = mediaElement.error;
-        var errorCode;
-        var errorMessage;
-        if (!isNullOrUndefined(mediaError)) {
+        const mediaError = mediaElement.error;
+        let errorCode;
+        let errorMessage;
+        if (!(0, is_null_or_undefined_1.default)(mediaError)) {
             errorCode = mediaError.code;
             errorMessage = mediaError.message;
         }
         switch (errorCode) {
             case 1:
                 errorMessage = errorMessage !== null && errorMessage !== void 0 ? errorMessage : "The fetching of the associated resource was aborted by the user's request.";
-                return onError(new MediaError("MEDIA_ERR_ABORTED", errorMessage));
+                return onError(new errors_1.MediaError("MEDIA_ERR_ABORTED", errorMessage));
             case 2:
                 errorMessage = errorMessage !== null && errorMessage !== void 0 ? errorMessage : "A network error occurred which prevented the media from being " +
                     "successfully fetched";
-                return onError(new MediaError("MEDIA_ERR_NETWORK", errorMessage));
+                return onError(new errors_1.MediaError("MEDIA_ERR_NETWORK", errorMessage));
             case 3:
                 errorMessage = errorMessage !== null && errorMessage !== void 0 ? errorMessage : "An error occurred while trying to decode the media resource";
-                return onError(new MediaError("MEDIA_ERR_DECODE", errorMessage));
+                return onError(new errors_1.MediaError("MEDIA_ERR_DECODE", errorMessage));
             case 4:
                 errorMessage = errorMessage !== null && errorMessage !== void 0 ? errorMessage : "The media resource has been found to be unsuitable.";
-                return onError(new MediaError("MEDIA_ERR_SRC_NOT_SUPPORTED", errorMessage));
+                return onError(new errors_1.MediaError("MEDIA_ERR_SRC_NOT_SUPPORTED", errorMessage));
             default:
                 errorMessage = errorMessage !== null && errorMessage !== void 0 ? errorMessage : "The HTMLMediaElement errored due to an unknown reason.";
-                return onError(new MediaError("MEDIA_ERR_UNKNOWN", errorMessage));
+                return onError(new errors_1.MediaError("MEDIA_ERR_UNKNOWN", errorMessage));
         }
     }
 }
+exports.default = listenToMediaError;