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

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

@@ -1,9 +1,11 @@
-import { EncryptedMediaError } from "../../../errors";
-import features from "../../../features";
-import log from "../../../log";
-import SharedReference from "../../../utils/reference";
-import TaskCanceller from "../../../utils/task_canceller";
-import { ContentDecryptorState, } from "../../decrypt";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../../errors");
+const features_1 = require("../../../features");
+const log_1 = require("../../../log");
+const reference_1 = require("../../../utils/reference");
+const task_canceller_1 = require("../../../utils/task_canceller");
+const decrypt_1 = require("../../decrypt");
 /**
  * Initialize content decryption capabilities on the given `HTMLMediaElement`.
  *
@@ -27,74 +29,74 @@ import { ContentDecryptorState, } from "../../decrypt";
  * @returns {Object} - Reference emitting the current status regarding DRM
  * initialization.
  */
-export default function initializeContentDecryption(mediaElement, keySystems, protectionRef, callbacks, cancelSignal) {
+function initializeContentDecryption(mediaElement, keySystems, protectionRef, callbacks, cancelSignal) {
     if (keySystems.length === 0) {
         return createEmeDisabledReference("No `keySystems` option given.");
     }
-    else if (features.decrypt === null) {
+    else if (features_1.default.decrypt === null) {
         return createEmeDisabledReference("EME feature not activated.");
     }
-    var decryptorCanceller = new TaskCanceller();
+    const decryptorCanceller = new task_canceller_1.default();
     decryptorCanceller.linkToSignal(cancelSignal);
-    var drmStatusRef = new SharedReference({
+    const drmStatusRef = new reference_1.default({
         initializationState: { type: "uninitialized", value: null },
         drmSystemId: undefined,
     }, cancelSignal);
-    var ContentDecryptor = features.decrypt;
+    const ContentDecryptor = features_1.default.decrypt;
     if (!ContentDecryptor.hasEmeApis()) {
         return createEmeDisabledReference("EME API not available on the current page.");
     }
-    log.debug("Init: Creating ContentDecryptor");
-    var contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
-    contentDecryptor.addEventListener("stateChange", function (state) {
-        if (state === ContentDecryptorState.WaitingForAttachment) {
-            var isMediaLinked = new SharedReference(false);
-            isMediaLinked.onUpdate(function (isAttached, stopListening) {
+    log_1.default.debug("Init: Creating ContentDecryptor");
+    const contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
+    contentDecryptor.addEventListener("stateChange", (state) => {
+        if (state === decrypt_1.ContentDecryptorState.WaitingForAttachment) {
+            const isMediaLinked = new reference_1.default(false);
+            isMediaLinked.onUpdate((isAttached, stopListening) => {
                 if (isAttached) {
                     stopListening();
-                    if (state === ContentDecryptorState.WaitingForAttachment) {
+                    if (state === decrypt_1.ContentDecryptorState.WaitingForAttachment) {
                         contentDecryptor.attach();
                     }
                 }
             }, { clearSignal: decryptorCanceller.signal });
             drmStatusRef.setValue({ initializationState: { type: "awaiting-media-link",
-                    value: { isMediaLinked: isMediaLinked } },
+                    value: { isMediaLinked } },
                 drmSystemId: contentDecryptor.systemId });
         }
-        else if (state === ContentDecryptorState.ReadyForContent) {
+        else if (state === decrypt_1.ContentDecryptorState.ReadyForContent) {
             drmStatusRef.setValue({ initializationState: { type: "initialized",
                     value: null },
                 drmSystemId: contentDecryptor.systemId });
             contentDecryptor.removeEventListener("stateChange");
         }
     });
-    contentDecryptor.addEventListener("error", function (error) {
+    contentDecryptor.addEventListener("error", (error) => {
         decryptorCanceller.cancel();
         callbacks.onError(error);
     });
-    contentDecryptor.addEventListener("warning", function (error) {
+    contentDecryptor.addEventListener("warning", (error) => {
         callbacks.onWarning(error);
     });
-    protectionRef.onUpdate(function (data) {
+    protectionRef.onUpdate((data) => {
         if (data === null) {
             return;
         }
         contentDecryptor.onInitializationData(data);
     }, { clearSignal: decryptorCanceller.signal });
-    decryptorCanceller.signal.register(function () {
+    decryptorCanceller.signal.register(() => {
         contentDecryptor.dispose();
     });
     return drmStatusRef;
     function createEmeDisabledReference(errMsg) {
-        protectionRef.onUpdate(function (data, stopListening) {
+        protectionRef.onUpdate((data, stopListening) => {
             if (data === null) { // initial value
                 return;
             }
             stopListening();
-            var err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
+            const err = new errors_1.EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
             callbacks.onError(err);
         }, { clearSignal: cancelSignal });
-        var ref = new SharedReference({
+        const ref = new reference_1.default({
             initializationState: { type: "initialized", value: null },
             drmSystemId: undefined
         });
@@ -102,3 +104,4 @@ export default function initializeContentDecryption(mediaElement, keySystems, pr
         return ref;
     }
 }
+exports.default = initializeContentDecryption;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,26 +14,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { onSourceOpen, onSourceEnded, onSourceClose, } from "../../../compat/event_listeners";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_listeners_1 = require("../../../compat/event_listeners");
 /* eslint-disable-next-line max-len */
-import hasIssuesWithHighMediaSourceDuration from "../../../compat/has_issues_with_high_media_source_duration";
-import log from "../../../log";
-import SharedReference from "../../../utils/reference";
-import TaskCanceller from "../../../utils/task_canceller";
+const has_issues_with_high_media_source_duration_1 = require("../../../compat/has_issues_with_high_media_source_duration");
+const log_1 = require("../../../log");
+const reference_1 = require("../../../utils/reference");
+const task_canceller_1 = require("../../../utils/task_canceller");
 /** Number of seconds in a regular year. */
-var YEAR_IN_SECONDS = 365 * 24 * 3600;
+const YEAR_IN_SECONDS = 365 * 24 * 3600;
 /**
  * Keep the MediaSource's `duration` attribute up-to-date with the duration of
  * the content played on it.
  * @class MediaSourceDurationUpdater
  */
-var MediaSourceDurationUpdater = /** @class */ (function () {
+class MediaSourceDurationUpdater {
     /**
      * Create a new `MediaSourceDurationUpdater`,
      * @param {MediaSource} mediaSource - The MediaSource on which the content is
      * played.
      */
-    function MediaSourceDurationUpdater(mediaSource) {
+    constructor(mediaSource) {
         this._mediaSource = mediaSource;
         this._currentMediaSourceDurationUpdateCanceller = null;
     }
@@ -52,16 +54,16 @@ var MediaSourceDurationUpdater = /** @class */ (function () {
      * side-effects of having a too low duration (such as the impossibility to
      * seek over that value).
      */
-    MediaSourceDurationUpdater.prototype.updateDuration = function (newDuration, isRealEndKnown) {
+    updateDuration(newDuration, isRealEndKnown) {
         if (this._currentMediaSourceDurationUpdateCanceller !== null) {
             this._currentMediaSourceDurationUpdateCanceller.cancel();
         }
-        this._currentMediaSourceDurationUpdateCanceller = new TaskCanceller();
-        var mediaSource = this._mediaSource;
-        var currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
-        var isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, currentSignal);
+        this._currentMediaSourceDurationUpdateCanceller = new task_canceller_1.default();
+        const mediaSource = this._mediaSource;
+        const currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
+        const isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, currentSignal);
         /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
-        var msOpenStatusCanceller = new TaskCanceller();
+        let msOpenStatusCanceller = new task_canceller_1.default();
         msOpenStatusCanceller.linkToSignal(currentSignal);
         isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, { emitCurrentValue: true,
             clearSignal: currentSignal });
@@ -70,15 +72,15 @@ var MediaSourceDurationUpdater = /** @class */ (function () {
             if (!isMediaSourceOpened.getValue()) {
                 return;
             }
-            msOpenStatusCanceller = new TaskCanceller();
+            msOpenStatusCanceller = new task_canceller_1.default();
             msOpenStatusCanceller.linkToSignal(currentSignal);
-            var areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, msOpenStatusCanceller.signal);
+            const areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, msOpenStatusCanceller.signal);
             /** TaskCanceller triggered each time SourceBuffers' updating status changes */
-            var sourceBuffersUpdatingCanceller = new TaskCanceller();
+            let sourceBuffersUpdatingCanceller = new task_canceller_1.default();
             sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
-            return areSourceBuffersUpdating.onUpdate(function (areUpdating) {
+            return areSourceBuffersUpdating.onUpdate((areUpdating) => {
                 sourceBuffersUpdatingCanceller.cancel();
-                sourceBuffersUpdatingCanceller = new TaskCanceller();
+                sourceBuffersUpdatingCanceller = new task_canceller_1.default();
                 sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
                 if (areUpdating) {
                     return;
@@ -86,19 +88,18 @@ var MediaSourceDurationUpdater = /** @class */ (function () {
                 recursivelyForceDurationUpdate(mediaSource, newDuration, isRealEndKnown, sourceBuffersUpdatingCanceller.signal);
             }, { clearSignal: msOpenStatusCanceller.signal, emitCurrentValue: true });
         }
-    };
+    }
     /**
      * Abort the last duration-setting operation and free its resources.
      */
-    MediaSourceDurationUpdater.prototype.stopUpdating = function () {
+    stopUpdating() {
         if (this._currentMediaSourceDurationUpdateCanceller !== null) {
             this._currentMediaSourceDurationUpdateCanceller.cancel();
             this._currentMediaSourceDurationUpdateCanceller = null;
         }
-    };
-    return MediaSourceDurationUpdater;
-}());
-export default MediaSourceDurationUpdater;
+    }
+}
+exports.default = MediaSourceDurationUpdater;
 /**
  * Checks that duration can be updated on the MediaSource, and then
  * sets it.
@@ -113,16 +114,16 @@ export default MediaSourceDurationUpdater;
  * @returns {string}
  */
 function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
-    var newDuration = duration;
+    let newDuration = duration;
     if (!isRealEndKnown) {
-        newDuration = hasIssuesWithHighMediaSourceDuration() ?
+        newDuration = (0, has_issues_with_high_media_source_duration_1.default)() ?
             Infinity :
             getMaximumLiveSeekablePosition(duration);
     }
-    var maxBufferedEnd = 0;
-    for (var i = 0; i < mediaSource.sourceBuffers.length; i++) {
-        var sourceBuffer = mediaSource.sourceBuffers[i];
-        var sbBufferedLen = sourceBuffer.buffered.length;
+    let maxBufferedEnd = 0;
+    for (let i = 0; i < mediaSource.sourceBuffers.length; i++) {
+        const sourceBuffer = mediaSource.sourceBuffers[i];
+        const sbBufferedLen = sourceBuffer.buffered.length;
         if (sbBufferedLen > 0) {
             maxBufferedEnd = Math.max(sourceBuffer.buffered.end(sbBufferedLen - 1));
         }
@@ -135,34 +136,34 @@ function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
         // Keep the duration that was set at that time as a security.
         if (maxBufferedEnd < mediaSource.duration) {
             try {
-                log.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
+                log_1.default.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
                 mediaSource.duration = maxBufferedEnd;
             }
             catch (err) {
-                log.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
+                log_1.default.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
                 return "failed" /* MediaSourceDurationUpdateStatus.Failed */;
             }
         }
         return "partial" /* MediaSourceDurationUpdateStatus.Partial */;
     }
     else {
-        var oldDuration = mediaSource.duration;
+        const oldDuration = mediaSource.duration;
         try {
-            log.info("Init: Updating duration", newDuration);
+            log_1.default.info("Init: Updating duration", newDuration);
             mediaSource.duration = newDuration;
             if (mediaSource.readyState === "open" && !isFinite(newDuration)) {
-                var maxSeekable = getMaximumLiveSeekablePosition(duration);
-                log.info("Init: calling `mediaSource.setLiveSeekableRange`", maxSeekable);
+                const maxSeekable = getMaximumLiveSeekablePosition(duration);
+                log_1.default.info("Init: calling `mediaSource.setLiveSeekableRange`", maxSeekable);
                 mediaSource.setLiveSeekableRange(0, maxSeekable);
             }
         }
         catch (err) {
-            log.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
+            log_1.default.warn("Duration Updater: Can't update duration on the MediaSource.", err instanceof Error ? err : "");
             return "failed" /* MediaSourceDurationUpdateStatus.Failed */;
         }
-        var deltaToExpected = Math.abs(mediaSource.duration - newDuration);
+        const deltaToExpected = Math.abs(mediaSource.duration - newDuration);
         if (deltaToExpected >= 0.1) {
-            var deltaToBefore = Math.abs(mediaSource.duration - oldDuration);
+            const deltaToBefore = Math.abs(mediaSource.duration - oldDuration);
             return deltaToExpected < deltaToBefore ? "partial" /* MediaSourceDurationUpdateStatus.Partial */ :
                 "failed" /* MediaSourceDurationUpdateStatus.Failed */;
         }
@@ -178,28 +179,25 @@ function setMediaSourceDuration(mediaSource, duration, isRealEndKnown) {
  */
 function createSourceBuffersUpdatingReference(sourceBuffers, cancelSignal) {
     if (sourceBuffers.length === 0) {
-        var notOpenedRef = new SharedReference(false);
+        const notOpenedRef = new reference_1.default(false);
         notOpenedRef.finish();
         return notOpenedRef;
     }
-    var areUpdatingRef = new SharedReference(false, cancelSignal);
+    const areUpdatingRef = new reference_1.default(false, cancelSignal);
     reCheck();
-    var _loop_1 = function (i) {
-        var sourceBuffer = sourceBuffers[i];
+    for (let i = 0; i < sourceBuffers.length; i++) {
+        const sourceBuffer = sourceBuffers[i];
         sourceBuffer.addEventListener("updatestart", reCheck);
         sourceBuffer.addEventListener("update", reCheck);
-        cancelSignal.register(function () {
+        cancelSignal.register(() => {
             sourceBuffer.removeEventListener("updatestart", reCheck);
             sourceBuffer.removeEventListener("update", reCheck);
         });
-    };
-    for (var i = 0; i < sourceBuffers.length; i++) {
-        _loop_1(i);
     }
     return areUpdatingRef;
     function reCheck() {
-        for (var i = 0; i < sourceBuffers.length; i++) {
-            var sourceBuffer = sourceBuffers[i];
+        for (let i = 0; i < sourceBuffers.length; i++) {
+            const sourceBuffer = sourceBuffers[i];
             if (sourceBuffer.updating) {
                 areUpdatingRef.setValueIfChanged(true);
                 return;
@@ -216,17 +214,17 @@ function createSourceBuffersUpdatingReference(sourceBuffers, cancelSignal) {
  * @returns {Object}
  */
 function createMediaSourceOpenReference(mediaSource, cancelSignal) {
-    var isMediaSourceOpen = new SharedReference(mediaSource.readyState === "open", cancelSignal);
-    onSourceOpen(mediaSource, function () {
-        log.debug("Init: Reacting to MediaSource open in duration updater");
+    const isMediaSourceOpen = new reference_1.default(mediaSource.readyState === "open", cancelSignal);
+    (0, event_listeners_1.onSourceOpen)(mediaSource, () => {
+        log_1.default.debug("Init: Reacting to MediaSource open in duration updater");
         isMediaSourceOpen.setValueIfChanged(true);
     }, cancelSignal);
-    onSourceEnded(mediaSource, function () {
-        log.debug("Init: Reacting to MediaSource ended in duration updater");
+    (0, event_listeners_1.onSourceEnded)(mediaSource, () => {
+        log_1.default.debug("Init: Reacting to MediaSource ended in duration updater");
         isMediaSourceOpen.setValueIfChanged(false);
     }, cancelSignal);
-    onSourceClose(mediaSource, function () {
-        log.debug("Init: Reacting to MediaSource close in duration updater");
+    (0, event_listeners_1.onSourceClose)(mediaSource, () => {
+        log_1.default.debug("Init: Reacting to MediaSource close in duration updater");
         isMediaSourceOpen.setValueIfChanged(false);
     }, cancelSignal);
     return isMediaSourceOpen;
@@ -243,15 +241,15 @@ function createMediaSourceOpenReference(mediaSource, cancelSignal) {
  * @param {Object} cancelSignal
  */
 function recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal) {
-    var res = setMediaSourceDuration(mediaSource, duration, isRealEndKnown);
+    const res = setMediaSourceDuration(mediaSource, duration, isRealEndKnown);
     if (res === "success" /* MediaSourceDurationUpdateStatus.Success */) {
         return;
     }
-    var timeoutId = setTimeout(function () {
+    const timeoutId = setTimeout(() => {
         unregisterClear();
         recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal);
     }, 2000);
-    var unregisterClear = cancelSignal.register(function () {
+    const unregisterClear = cancelSignal.register(() => {
         clearTimeout(timeoutId);
     });
 }