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

package/dist/_esm5.processed/core/segment_buffers/inventory/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/segment_buffers/inventory/utils.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFirstSegmentAfterPeriod = exports.getLastSegmentBeforePeriod = void 0;
 /**
  * Returns the last segment in the `inventory` which is linked to a Period
  * before `period`.
@@ -20,8 +23,8 @@
  * @param {Object} period
  * @returns {Object|null}
  */
-export function getLastSegmentBeforePeriod(inventory, period) {
-    for (var i = 0; i < inventory.length; i++) {
+function getLastSegmentBeforePeriod(inventory, period) {
+    for (let i = 0; i < inventory.length; i++) {
         if (inventory[i].infos.period.start >= period.start) {
             if (i > 0) {
                 return inventory[i - 1];
@@ -32,6 +35,7 @@ export function getLastSegmentBeforePeriod(inventory, period) {
     return inventory.length > 0 ? inventory[inventory.length - 1] :
         null;
 }
+exports.getLastSegmentBeforePeriod = getLastSegmentBeforePeriod;
 /**
  * Returns the first segment in the `inventory` which is linked to a Period
  * after `period`.
@@ -39,11 +43,12 @@ export function getLastSegmentBeforePeriod(inventory, period) {
  * @param {Object} period
  * @returns {Object|null}
  */
-export function getFirstSegmentAfterPeriod(inventory, period) {
-    for (var i = 0; i < inventory.length; i++) {
+function getFirstSegmentAfterPeriod(inventory, period) {
+    for (let i = 0; i < inventory.length; i++) {
         if (inventory[i].infos.period.start > period.start) {
             return inventory[i];
         }
     }
     return null;
 }
+exports.getFirstSegmentAfterPeriod = getFirstSegmentAfterPeriod;

package/dist/_esm5.processed/core/segment_buffers/segment_buffers_store.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,12 +14,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MediaError } from "../../errors";
-import features from "../../features";
-import log from "../../log";
-import createCancellablePromise from "../../utils/create_cancellable_promise";
-import { AudioVideoSegmentBuffer, } from "./implementations";
-var POSSIBLE_BUFFER_TYPES = ["audio",
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../errors");
+const features_1 = require("../../features");
+const log_1 = require("../../log");
+const create_cancellable_promise_1 = require("../../utils/create_cancellable_promise");
+const implementations_1 = require("./implementations");
+const POSSIBLE_BUFFER_TYPES = ["audio",
     "video",
     "text"];
 /**
@@ -42,18 +44,7 @@ var POSSIBLE_BUFFER_TYPES = ["audio",
  *
  * @class SegmentBuffersStore
  */
-var SegmentBuffersStore = /** @class */ (function () {
-    /**
-     * @param {HTMLMediaElement} mediaElement
-     * @param {MediaSource} mediaSource
-     * @constructor
-     */
-    function SegmentBuffersStore(mediaElement, mediaSource) {
-        this._mediaElement = mediaElement;
-        this._mediaSource = mediaSource;
-        this._initializedSegmentBuffers = {};
-        this._onNativeBufferAddedOrDisabled = [];
-    }
+class SegmentBuffersStore {
     /**
      * Returns true if the type is linked to a "native" media buffer (i.e. relying
      * on a SourceBuffer object, native to the browser).
@@ -63,31 +54,42 @@ var SegmentBuffersStore = /** @class */ (function () {
      * @param {string} bufferType
      * @returns {Boolean}
      */
-    SegmentBuffersStore.isNative = function (bufferType) {
+    static isNative(bufferType) {
         return shouldHaveNativeBuffer(bufferType);
-    };
+    }
+    /**
+     * @param {HTMLMediaElement} mediaElement
+     * @param {MediaSource} mediaSource
+     * @constructor
+     */
+    constructor(mediaElement, mediaSource) {
+        this._mediaElement = mediaElement;
+        this._mediaSource = mediaSource;
+        this._initializedSegmentBuffers = {};
+        this._onNativeBufferAddedOrDisabled = [];
+    }
     /**
      * Get all currently available buffer types.
      * /!\ This list can evolve at runtime depending on feature switching.
      * @returns {Array.<string>}
      */
-    SegmentBuffersStore.prototype.getBufferTypes = function () {
-        var bufferTypes = this.getNativeBufferTypes();
-        if (features.nativeTextTracksBuffer != null ||
-            features.htmlTextTracksBuffer != null) {
+    getBufferTypes() {
+        const bufferTypes = this.getNativeBufferTypes();
+        if (features_1.default.nativeTextTracksBuffer != null ||
+            features_1.default.htmlTextTracksBuffer != null) {
             bufferTypes.push("text");
         }
         return bufferTypes;
-    };
+    }
     /**
      * Get all "native" buffer types that should be created before beginning to
      * push contents.
      * @returns {Array.<string>}
      */
-    SegmentBuffersStore.prototype.getNativeBufferTypes = function () {
+    getNativeBufferTypes() {
         return this._mediaElement.nodeName === "AUDIO" ? ["audio"] :
             ["video", "audio"];
-    };
+    }
     /**
      * Returns the current "status" of the SegmentBuffer linked to the buffer
      * type given.
@@ -110,13 +112,13 @@ var SegmentBuffersStore = /** @class */ (function () {
      * @param {string} bufferType
      * @returns {Object|null}
      */
-    SegmentBuffersStore.prototype.getStatus = function (bufferType) {
-        var initializedBuffer = this._initializedSegmentBuffers[bufferType];
+    getStatus(bufferType) {
+        const initializedBuffer = this._initializedSegmentBuffers[bufferType];
         return initializedBuffer === undefined ? { type: "uninitialized" } :
             initializedBuffer === null ? { type: "disabled" } :
                 { type: "initialized",
                     value: initializedBuffer };
-    };
+    }
     /**
      * Native media buffers (audio and video) needed for playing the current
      * content need to all be created (by creating SegmentBuffers linked to them)
@@ -133,30 +135,29 @@ var SegmentBuffersStore = /** @class */ (function () {
      * @param {Object} cancelWaitSignal
      * @return {Promise}
      */
-    SegmentBuffersStore.prototype.waitForUsableBuffers = function (cancelWaitSignal) {
-        var _this = this;
+    waitForUsableBuffers(cancelWaitSignal) {
         if (this._areNativeBuffersUsable()) {
             return Promise.resolve();
         }
-        return createCancellablePromise(cancelWaitSignal, function (res) {
+        return (0, create_cancellable_promise_1.default)(cancelWaitSignal, (res) => {
             /* eslint-disable-next-line prefer-const */
-            var onAddedOrDisabled;
-            var removeCallback = function () {
-                var indexOf = _this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);
+            let onAddedOrDisabled;
+            const removeCallback = () => {
+                const indexOf = this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);
                 if (indexOf >= 0) {
-                    _this._onNativeBufferAddedOrDisabled.splice(indexOf, 1);
+                    this._onNativeBufferAddedOrDisabled.splice(indexOf, 1);
                 }
             };
-            onAddedOrDisabled = function () {
-                if (_this._areNativeBuffersUsable()) {
+            onAddedOrDisabled = () => {
+                if (this._areNativeBuffersUsable()) {
                     removeCallback();
                     res();
                 }
             };
-            _this._onNativeBufferAddedOrDisabled.push(onAddedOrDisabled);
+            this._onNativeBufferAddedOrDisabled.push(onAddedOrDisabled);
             return removeCallback;
         });
-    };
+    }
     /**
      * Explicitely disable the SegmentBuffer for a given buffer type.
      * A call to this function is needed at least for unused native buffer types
@@ -164,10 +165,10 @@ var SegmentBuffersStore = /** @class */ (function () {
      * `waitForUsableBuffers` when conditions are met.
      * @param {string}
      */
-    SegmentBuffersStore.prototype.disableSegmentBuffer = function (bufferType) {
-        var currentValue = this._initializedSegmentBuffers[bufferType];
+    disableSegmentBuffer(bufferType) {
+        const currentValue = this._initializedSegmentBuffers[bufferType];
         if (currentValue === null) {
-            log.warn("SBS: The ".concat(bufferType, " SegmentBuffer was already disabled."));
+            log_1.default.warn(`SBS: The ${bufferType} SegmentBuffer was already disabled.`);
             return;
         }
         if (currentValue !== undefined) {
@@ -175,9 +176,9 @@ var SegmentBuffersStore = /** @class */ (function () {
         }
         this._initializedSegmentBuffers[bufferType] = null;
         if (SegmentBuffersStore.isNative(bufferType)) {
-            this._onNativeBufferAddedOrDisabled.forEach(function (cb) { return cb(); });
+            this._onNativeBufferAddedOrDisabled.forEach(cb => cb());
         }
-    };
+    }
     /**
      * Creates a new SegmentBuffer associated to a type.
      * Reuse an already created one if a SegmentBuffer for the given type
@@ -191,103 +192,95 @@ var SegmentBuffersStore = /** @class */ (function () {
      * @param {Object|undefined} options
      * @returns {Object}
      */
-    SegmentBuffersStore.prototype.createSegmentBuffer = function (bufferType, codec, options) {
-        if (options === void 0) { options = {}; }
-        var memorizedSegmentBuffer = this._initializedSegmentBuffers[bufferType];
+    createSegmentBuffer(bufferType, codec, options = {}) {
+        const memorizedSegmentBuffer = this._initializedSegmentBuffers[bufferType];
         if (shouldHaveNativeBuffer(bufferType)) {
             if (memorizedSegmentBuffer != null) {
-                if (memorizedSegmentBuffer instanceof AudioVideoSegmentBuffer &&
+                if (memorizedSegmentBuffer instanceof implementations_1.AudioVideoSegmentBuffer &&
                     memorizedSegmentBuffer.codec !== codec) {
-                    log.warn("SB: Reusing native SegmentBuffer with codec", memorizedSegmentBuffer.codec, "for codec", codec);
+                    log_1.default.warn("SB: Reusing native SegmentBuffer with codec", memorizedSegmentBuffer.codec, "for codec", codec);
                 }
                 else {
-                    log.info("SB: Reusing native SegmentBuffer with codec", codec);
+                    log_1.default.info("SB: Reusing native SegmentBuffer with codec", codec);
                 }
                 return memorizedSegmentBuffer;
             }
-            log.info("SB: Adding native SegmentBuffer with codec", codec);
-            var nativeSegmentBuffer = new AudioVideoSegmentBuffer(bufferType, codec, this._mediaSource);
+            log_1.default.info("SB: Adding native SegmentBuffer with codec", codec);
+            const nativeSegmentBuffer = new implementations_1.AudioVideoSegmentBuffer(bufferType, codec, this._mediaSource);
             this._initializedSegmentBuffers[bufferType] = nativeSegmentBuffer;
-            this._onNativeBufferAddedOrDisabled.forEach(function (cb) { return cb(); });
+            this._onNativeBufferAddedOrDisabled.forEach(cb => cb());
             return nativeSegmentBuffer;
         }
         if (memorizedSegmentBuffer != null) {
-            log.info("SB: Reusing a previous custom SegmentBuffer for the type", bufferType);
+            log_1.default.info("SB: Reusing a previous custom SegmentBuffer for the type", bufferType);
             return memorizedSegmentBuffer;
         }
-        var segmentBuffer;
+        let segmentBuffer;
         if (bufferType === "text") {
-            log.info("SB: Creating a new text SegmentBuffer");
+            log_1.default.info("SB: Creating a new text SegmentBuffer");
             if (options.textTrackMode === "html") {
-                if (features.htmlTextTracksBuffer == null) {
+                if (features_1.default.htmlTextTracksBuffer == null) {
                     throw new Error("HTML Text track feature not activated");
                 }
-                segmentBuffer = new features.htmlTextTracksBuffer(this._mediaElement, options.textTrackElement);
+                segmentBuffer = new features_1.default.htmlTextTracksBuffer(this._mediaElement, options.textTrackElement);
             }
             else {
-                if (features.nativeTextTracksBuffer == null) {
+                if (features_1.default.nativeTextTracksBuffer == null) {
                     throw new Error("Native Text track feature not activated");
                 }
-                segmentBuffer = new features.nativeTextTracksBuffer(this._mediaElement);
+                segmentBuffer = new features_1.default.nativeTextTracksBuffer(this._mediaElement);
             }
             this._initializedSegmentBuffers.text = segmentBuffer;
             return segmentBuffer;
         }
-        log.error("SB: Unknown buffer type:", bufferType);
-        throw new MediaError("BUFFER_TYPE_UNKNOWN", "The player wants to create a SegmentBuffer " +
+        log_1.default.error("SB: Unknown buffer type:", bufferType);
+        throw new errors_1.MediaError("BUFFER_TYPE_UNKNOWN", "The player wants to create a SegmentBuffer " +
             "of an unknown type.");
-    };
+    }
     /**
      * Dispose of the active SegmentBuffer for the given type.
      * @param {string} bufferType
      */
-    SegmentBuffersStore.prototype.disposeSegmentBuffer = function (bufferType) {
-        var memorizedSegmentBuffer = this._initializedSegmentBuffers[bufferType];
+    disposeSegmentBuffer(bufferType) {
+        const memorizedSegmentBuffer = this._initializedSegmentBuffers[bufferType];
         if (memorizedSegmentBuffer == null) {
-            log.warn("SB: Trying to dispose a SegmentBuffer that does not exist");
+            log_1.default.warn("SB: Trying to dispose a SegmentBuffer that does not exist");
             return;
         }
-        log.info("SB: Aborting SegmentBuffer", bufferType);
+        log_1.default.info("SB: Aborting SegmentBuffer", bufferType);
         memorizedSegmentBuffer.dispose();
         delete this._initializedSegmentBuffers[bufferType];
-    };
+    }
     /**
      * Dispose of all SegmentBuffer created on this SegmentBuffersStore.
      */
-    SegmentBuffersStore.prototype.disposeAll = function () {
-        var _this = this;
-        POSSIBLE_BUFFER_TYPES.forEach(function (bufferType) {
-            if (_this.getStatus(bufferType).type === "initialized") {
-                _this.disposeSegmentBuffer(bufferType);
+    disposeAll() {
+        POSSIBLE_BUFFER_TYPES.forEach((bufferType) => {
+            if (this.getStatus(bufferType).type === "initialized") {
+                this.disposeSegmentBuffer(bufferType);
             }
         });
-    };
+    }
     /**
      * Returns `true` when we're ready to push and decode contents to
      * SourceBuffers created by SegmentBuffers of a native buffer type.
      */
-    SegmentBuffersStore.prototype._areNativeBuffersUsable = function () {
-        var _this = this;
-        var nativeBufferTypes = this.getNativeBufferTypes();
-        var hasUnitializedBuffers = nativeBufferTypes.some(function (sbType) {
-            return _this._initializedSegmentBuffers[sbType] === undefined;
-        });
+    _areNativeBuffersUsable() {
+        const nativeBufferTypes = this.getNativeBufferTypes();
+        const hasUnitializedBuffers = nativeBufferTypes.some(sbType => this._initializedSegmentBuffers[sbType] === undefined);
         if (hasUnitializedBuffers) {
             // one is not yet initialized/disabled
             return false;
         }
-        var areAllDisabled = nativeBufferTypes.every(function (sbType) {
-            return _this._initializedSegmentBuffers[sbType] === null;
-        });
+        const areAllDisabled = nativeBufferTypes.every(sbType => this._initializedSegmentBuffers[sbType] === null);
         if (areAllDisabled) {
             // they all are disabled: we can't play the content
             return false;
         }
         return true;
-    };
-    return SegmentBuffersStore;
-}());
-export default SegmentBuffersStore;
+    }
+}
+exports.default = SegmentBuffersStore;
 /**
  * Returns true if the given buffeType has a linked SourceBuffer implementation,
  * false otherwise.