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

package/dist/_esm5.processed/core/init/directfile_content_initializer.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,36 +14,22 @@
  * 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 __());
-    };
-})();
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * /!\ This file is feature-switchable.
  * It always should be imported through the `features` object.
  */
-import { clearElementSrc } from "../../compat";
-import log from "../../log";
-import assert from "../../utils/assert";
-import SharedReference from "../../utils/reference";
-import TaskCanceller from "../../utils/task_canceller";
-import { ContentInitializer } from "./types";
-import getLoadedReference from "./utils/get_loaded_reference";
-import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
-import initializeContentDecryption from "./utils/initialize_content_decryption";
-import RebufferingController from "./utils/rebuffering_controller";
-import listenToMediaError from "./utils/throw_on_media_error";
+const compat_1 = require("../../compat");
+const log_1 = require("../../log");
+const assert_1 = require("../../utils/assert");
+const reference_1 = require("../../utils/reference");
+const task_canceller_1 = require("../../utils/task_canceller");
+const types_1 = require("./types");
+const get_loaded_reference_1 = require("./utils/get_loaded_reference");
+const initial_seek_and_play_1 = require("./utils/initial_seek_and_play");
+const initialize_content_decryption_1 = require("./utils/initialize_content_decryption");
+const rebuffering_controller_1 = require("./utils/rebuffering_controller");
+const throw_on_media_error_1 = require("./utils/throw_on_media_error");
 /**
  * `ContentIntializer` which will load contents by putting their URL in the
  * `src` attribute of the given HTMLMediaElement.
@@ -53,24 +40,22 @@ import listenToMediaError from "./utils/throw_on_media_error";
  *
  * @class DirectFileContentInitializer
  */
-var DirectFileContentInitializer = /** @class */ (function (_super) {
-    __extends(DirectFileContentInitializer, _super);
+class DirectFileContentInitializer extends types_1.ContentInitializer {
     /**
      * Creates a new `DirectFileContentInitializer` linked to the given settings.
      * @param {Object} settings
      */
-    function DirectFileContentInitializer(settings) {
-        var _this = _super.call(this) || this;
-        _this._settings = settings;
-        _this._initCanceller = new TaskCanceller();
-        return _this;
+    constructor(settings) {
+        super();
+        this._settings = settings;
+        this._initCanceller = new task_canceller_1.default();
     }
     /**
      * "Prepare" content so it can later be played by calling `start`.
      */
-    DirectFileContentInitializer.prototype.prepare = function () {
+    prepare() {
         return; // Directfile contents do not have any preparation
-    };
+    }
     /**
      * Start playback of the content linked to this `DirectFileContentInitializer`
      * on the given `HTMLMediaElement` and its associated `PlaybackObserver`.
@@ -79,123 +64,112 @@ var DirectFileContentInitializer = /** @class */ (function (_super) {
      * @param {Object} playbackObserver - Object regularly emitting playback
      * information.
      */
-    DirectFileContentInitializer.prototype.start = function (mediaElement, playbackObserver) {
-        var _this = this;
-        var cancelSignal = this._initCanceller.signal;
-        var _a = this._settings, keySystems = _a.keySystems, speed = _a.speed, url = _a.url;
-        clearElementSrc(mediaElement);
+    start(mediaElement, playbackObserver) {
+        const cancelSignal = this._initCanceller.signal;
+        const { keySystems, speed, url } = this._settings;
+        (0, compat_1.clearElementSrc)(mediaElement);
         /**
          * Create dummy encryption data emitter, as those are not sent from the
          * RxPlayer for directfile contents.
          */
-        var decryptionRef = new SharedReference(null);
+        const decryptionRef = new reference_1.default(null);
         decryptionRef.finish();
-        var drmInitRef = initializeContentDecryption(mediaElement, keySystems, decryptionRef, { onError: function (err) { return _this._onFatalError(err); },
-            onWarning: function (err) { return _this.trigger("warning", err); } }, cancelSignal);
+        const drmInitRef = (0, initialize_content_decryption_1.default)(mediaElement, keySystems, decryptionRef, { onError: (err) => this._onFatalError(err),
+            onWarning: (err) => this.trigger("warning", err) }, cancelSignal);
         /** Translate errors coming from the media element into RxPlayer errors. */
-        listenToMediaError(mediaElement, function (error) { return _this._onFatalError(error); }, cancelSignal);
+        (0, throw_on_media_error_1.default)(mediaElement, (error) => this._onFatalError(error), cancelSignal);
         /**
          * Class trying to avoid various stalling situations, emitting "stalled"
          * events when it cannot, as well as "unstalled" events when it get out of one.
          */
-        var rebufferingController = new RebufferingController(playbackObserver, null, null, speed);
-        rebufferingController.addEventListener("stalled", function (evt) {
-            return _this.trigger("stalled", evt);
-        });
-        rebufferingController.addEventListener("unstalled", function () {
-            return _this.trigger("unstalled", null);
-        });
-        rebufferingController.addEventListener("warning", function (err) {
-            return _this.trigger("warning", err);
-        });
-        cancelSignal.register(function () {
+        const rebufferingController = new rebuffering_controller_1.default(playbackObserver, null, null, speed);
+        rebufferingController.addEventListener("stalled", (evt) => this.trigger("stalled", evt));
+        rebufferingController.addEventListener("unstalled", () => this.trigger("unstalled", null));
+        rebufferingController.addEventListener("warning", (err) => this.trigger("warning", err));
+        cancelSignal.register(() => {
             rebufferingController.destroy();
         });
         rebufferingController.start();
-        drmInitRef.onUpdate(function (evt, stopListeningToDrmUpdates) {
+        drmInitRef.onUpdate((evt, stopListeningToDrmUpdates) => {
             if (evt.initializationState.type === "uninitialized") {
                 return; // nothing done yet
             }
             stopListeningToDrmUpdates();
             // Start everything! (Just put the URL in the element's src).
-            log.info("Setting URL to HTMLMediaElement", url);
+            log_1.default.info("Setting URL to HTMLMediaElement", url);
             mediaElement.src = url;
-            cancelSignal.register(function () {
-                log.info("Init: Removing directfile src from media element", mediaElement.src);
-                clearElementSrc(mediaElement);
+            cancelSignal.register(() => {
+                log_1.default.info("Init: Removing directfile src from media element", mediaElement.src);
+                (0, compat_1.clearElementSrc)(mediaElement);
             });
             if (evt.initializationState.type === "awaiting-media-link") {
                 evt.initializationState.value.isMediaLinked.setValue(true);
-                drmInitRef.onUpdate(function (newDrmStatus, stopListeningToDrmUpdatesAgain) {
+                drmInitRef.onUpdate((newDrmStatus, stopListeningToDrmUpdatesAgain) => {
                     if (newDrmStatus.initializationState.type === "initialized") {
                         stopListeningToDrmUpdatesAgain();
-                        _this._seekAndPlay(mediaElement, playbackObserver);
+                        this._seekAndPlay(mediaElement, playbackObserver);
                     }
                 }, { emitCurrentValue: true, clearSignal: cancelSignal });
             }
             else {
-                assert(evt.initializationState.type === "initialized");
-                _this._seekAndPlay(mediaElement, playbackObserver);
+                (0, assert_1.default)(evt.initializationState.type === "initialized");
+                this._seekAndPlay(mediaElement, playbackObserver);
             }
         }, { emitCurrentValue: true, clearSignal: cancelSignal });
-    };
+    }
     /**
      * Update URL this `ContentIntializer` depends on.
      * @param {Array.<string>|undefined} _urls
      * @param {boolean} _refreshNow
      */
-    DirectFileContentInitializer.prototype.updateContentUrls = function (_urls, _refreshNow) {
+    updateContentUrls(_urls, _refreshNow) {
         throw new Error("Cannot update content URL of directfile contents");
-    };
+    }
     /**
      * Stop content and free all resources linked to this `ContentIntializer`.
      */
-    DirectFileContentInitializer.prototype.dispose = function () {
+    dispose() {
         this._initCanceller.cancel();
-    };
+    }
     /**
      * Logic performed when a fatal error was triggered.
      * @param {*} err - The fatal error in question.
      */
-    DirectFileContentInitializer.prototype._onFatalError = function (err) {
+    _onFatalError(err) {
         this._initCanceller.cancel();
         this.trigger("error", err);
-    };
+    }
     /**
      * Perform the initial seek (to begin playback at an initially-calculated
      * position based on settings) and auto-play if needed when loaded.
      * @param {HTMLMediaElement} mediaElement
      * @param {Object} playbackObserver
      */
-    DirectFileContentInitializer.prototype._seekAndPlay = function (mediaElement, playbackObserver) {
-        var _this = this;
-        var cancelSignal = this._initCanceller.signal;
-        var _a = this._settings, autoPlay = _a.autoPlay, startAt = _a.startAt;
-        var initialTime = function () {
-            log.debug("Init: Calculating initial time");
-            var initTime = getDirectFileInitialTime(mediaElement, startAt);
-            log.debug("Init: Initial time calculated:", initTime);
+    _seekAndPlay(mediaElement, playbackObserver) {
+        const cancelSignal = this._initCanceller.signal;
+        const { autoPlay, startAt } = this._settings;
+        const initialTime = () => {
+            log_1.default.debug("Init: Calculating initial time");
+            const initTime = getDirectFileInitialTime(mediaElement, startAt);
+            log_1.default.debug("Init: Initial time calculated:", initTime);
             return initTime;
         };
-        performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) { return _this.trigger("warning", err); }, cancelSignal).autoPlayResult
-            .then(function () {
-            return getLoadedReference(playbackObserver, mediaElement, true, cancelSignal)
-                .onUpdate(function (isLoaded, stopListening) {
-                if (isLoaded) {
-                    stopListening();
-                    _this.trigger("loaded", { segmentBuffersStore: null });
-                }
-            }, { emitCurrentValue: true, clearSignal: cancelSignal });
-        })
-            .catch(function (err) {
+        (0, initial_seek_and_play_1.default)(mediaElement, playbackObserver, initialTime, autoPlay, (err) => this.trigger("warning", err), cancelSignal).autoPlayResult
+            .then(() => (0, get_loaded_reference_1.default)(playbackObserver, mediaElement, true, cancelSignal)
+            .onUpdate((isLoaded, stopListening) => {
+            if (isLoaded) {
+                stopListening();
+                this.trigger("loaded", { segmentBuffersStore: null });
+            }
+        }, { emitCurrentValue: true, clearSignal: cancelSignal }))
+            .catch((err) => {
             if (!cancelSignal.isCancelled()) {
-                _this._onFatalError(err);
+                this._onFatalError(err);
             }
         });
-    };
-    return DirectFileContentInitializer;
-}(ContentInitializer));
-export default DirectFileContentInitializer;
+    }
+}
+exports.default = DirectFileContentInitializer;
 /**
  * calculate initial time as a position in seconds.
  * @param {HTMLMediaElement} mediaElement
@@ -215,9 +189,9 @@ function getDirectFileInitialTime(mediaElement, startAt) {
     else if (startAt.fromFirstPosition != null) {
         return startAt.fromFirstPosition;
     }
-    var duration = mediaElement.duration;
+    const duration = mediaElement.duration;
     if (duration == null || !isFinite(duration)) {
-        log.warn("startAt.fromLastPosition set but no known duration, " +
+        log_1.default.warn("startAt.fromLastPosition set but no known duration, " +
             "beginning at 0.");
         return 0;
     }
@@ -225,14 +199,14 @@ function getDirectFileInitialTime(mediaElement, startAt) {
         return Math.max(0, duration + startAt.fromLastPosition);
     }
     else if (startAt.percentage != null) {
-        var percentage = startAt.percentage;
+        const { percentage } = startAt;
         if (percentage >= 100) {
             return duration;
         }
         else if (percentage <= 0) {
             return 0;
         }
-        var ratio = +percentage / 100;
+        const ratio = +percentage / 100;
         return duration * ratio;
     }
     return 0;

package/dist/_esm5.processed/core/init/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,4 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { ContentInitializer, } from "./types";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentInitializer = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "ContentInitializer", { enumerable: true, get: function () { return types_1.ContentInitializer; } });