rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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,7 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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
@@ -21,30 +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;
                 }
             }
+            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: data, publicEvent: { start: start, data: data } };
+                const newScheduledEvent = { start,
+                    id,
+                    data: actualData,
+                    publicEvent: { start,
+                        data: actualData } };
                 scheduledEvents.push(newScheduledEvent);
             }
             else {
-                var newScheduledEvent = { start: start, end: end, id: id, data: data, publicEvent: { start: start, end: end, data: data } };
+                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.d.ts

@@ -14,17 +14,39 @@
  * limitations under the License.
  */
 import Manifest from "../../../../manifest";
-import { CancellationSignal } from "../../../../utils/task_canceller";
+import EventEmitter from "../../../../utils/event_emitter";
 import { IPlaybackObservation, IReadOnlyPlaybackObserver } from "../../../api";
 import { IPublicNonFiniteStreamEvent, IPublicStreamEvent } from "./types";
+interface IStreamEventsEmitterEvent {
+    event: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
+    eventSkip: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
+}
 /**
  * Get events from manifest and emit each time an event has to be emitted
- * @param {Object} manifest
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} playbackObserver
- * @param {Function} onEvent
- * @param {Function} onEventSkip
- * @param {Object} cancelSignal
- * @returns {Object}
  */
-export default function streamEventsEmitter(manifest: Manifest, mediaElement: HTMLMediaElement, playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>, onEvent: (evt: IPublicStreamEvent | IPublicNonFiniteStreamEvent) => void, onEventSkip: (evt: IPublicStreamEvent | IPublicNonFiniteStreamEvent) => void, cancelSignal: CancellationSignal): void;
+export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitterEvent> {
+    private _manifest;
+    private _mediaElement;
+    private _playbackObserver;
+    private _scheduledEventsRef;
+    private _eventsBeingPlayed;
+    private _canceller;
+    /**
+     * @param {Object} manifest
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
+    constructor(manifest: Manifest, mediaElement: HTMLMediaElement, playbackObserver: IReadOnlyPlaybackObserver<IPlaybackObservation>);
+    start(): void;
+    stop(): void;
+    /**
+     * Examine playback situation from playback observations to emit stream events and
+     * prepare set onExit callbacks if needed.
+     * @param {Array.<Object>} scheduledEvents
+     * @param {Object} oldObservation
+     * @param {Object} newObservation
+     * @param {Object} stopSignal
+     */
+    private _emitStreamEvents;
+}
+export {};

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,63 +14,87 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../../config";
-import createSharedReference 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
- * @param {Object} manifest
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} playbackObserver
- * @param {Function} onEvent
- * @param {Function} onEventSkip
- * @param {Object} cancelSignal
- * @returns {Object}
  */
-export default function streamEventsEmitter(manifest, mediaElement, playbackObserver, onEvent, onEventSkip, cancelSignal) {
-    var eventsBeingPlayed = new WeakMap();
-    var scheduledEventsRef = createSharedReference(refreshScheduledEventsList([], manifest), cancelSignal);
-    manifest.addEventListener("manifestUpdate", function () {
-        var prev = scheduledEventsRef.getValue();
-        scheduledEventsRef.setValue(refreshScheduledEventsList(prev, manifest));
-    }, cancelSignal);
-    var isPollingEvents = false;
-    var cancelCurrentPolling = new TaskCanceller();
-    cancelCurrentPolling.linkToSignal(cancelSignal);
-    scheduledEventsRef.onUpdate(function (_a) {
-        var scheduledEventsLength = _a.length;
-        if (scheduledEventsLength === 0) {
-            if (isPollingEvents) {
-                cancelCurrentPolling.cancel();
-                cancelCurrentPolling = new TaskCanceller();
-                cancelCurrentPolling.linkToSignal(cancelSignal);
-                isPollingEvents = false;
-            }
-            return;
-        }
-        else if (isPollingEvents) {
+class StreamEventsEmitter extends event_emitter_1.default {
+    /**
+     * @param {Object} manifest
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
+    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();
+    }
+    start() {
+        if (this._canceller !== null) {
             return;
         }
-        isPollingEvents = true;
-        var oldObservation = constructObservation();
-        var STREAM_EVENT_EMITTER_POLL_INTERVAL = config.getCurrent().STREAM_EVENT_EMITTER_POLL_INTERVAL;
-        var intervalId = setInterval(checkStreamEvents, STREAM_EVENT_EMITTER_POLL_INTERVAL);
-        playbackObserver.listen(checkStreamEvents, { includeLastObservation: false,
-            clearSignal: cancelCurrentPolling.signal });
-        cancelCurrentPolling.signal.register(function () {
-            clearInterval(intervalId);
-        });
-        function checkStreamEvents() {
-            var newObservation = constructObservation();
-            emitStreamEvents(scheduledEventsRef.getValue(), oldObservation, newObservation, cancelCurrentPolling.signal);
-            oldObservation = newObservation;
-        }
-        function constructObservation() {
-            var isSeeking = playbackObserver.getReference().getValue().seeking;
-            return { currentTime: mediaElement.currentTime, isSeeking: isSeeking };
+        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", () => {
+            const prev = this._scheduledEventsRef.getValue();
+            this._scheduledEventsRef.setValue((0, refresh_scheduled_events_list_1.default)(prev, this._manifest));
+        }, this._canceller.signal);
+        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 task_canceller_1.default();
+                    cancelCurrentPolling.linkToSignal(cancelSignal);
+                    isPollingEvents = false;
+                }
+                return;
+            }
+            else if (isPollingEvents) {
+                return;
+            }
+            isPollingEvents = true;
+            let oldObservation = constructObservation();
+            const checkStreamEvents = () => {
+                const newObservation = constructObservation();
+                this._emitStreamEvents(this._scheduledEventsRef.getValue(), oldObservation, newObservation, cancelCurrentPolling.signal);
+                oldObservation = newObservation;
+            };
+            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(() => {
+                clearInterval(intervalId);
+            });
+            function constructObservation() {
+                const isSeeking = playbackObserver.getReference().getValue().seeking;
+                return { currentTime: mediaElement.currentTime,
+                    isSeeking };
+            }
+        }, { emitCurrentValue: true, clearSignal: cancelSignal });
+    }
+    stop() {
+        if (this._canceller !== null) {
+            this._canceller.cancel();
+            this._canceller = null;
         }
-    }, { emitCurrentValue: true, clearSignal: cancelSignal });
+    }
     /**
      * Examine playback situation from playback observations to emit stream events and
      * prepare set onExit callbacks if needed.
@@ -78,56 +103,55 @@ export default function streamEventsEmitter(manifest, mediaElement, playbackObse
      * @param {Object} newObservation
      * @param {Object} stopSignal
      */
-    function emitStreamEvents(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 = 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);
                     }
-                    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 });
-                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") {
-                    onEvent(event_2.value);
+            for (const event of eventsToSend) {
+                if (event.type === "stream-event") {
+                    this.trigger("event", event.value);
                 }
                 else {
-                    onEventSkip(event_2.value);
+                    this.trigger("eventSkip", event.value);
                 }
                 if (stopSignal.isCancelled()) {
                     return;
@@ -135,10 +159,9 @@ export default function streamEventsEmitter(manifest, mediaElement, playbackObse
             }
         }
         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;
@@ -147,6 +170,7 @@ export default function streamEventsEmitter(manifest, mediaElement, playbackObse
         }
     }
 }
+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;