rx-player 3.27.0-dev.2022032800 → 3.27.0

package/dist/_esm5.processed/transports/dash/add_segment_integrity_checks_to_loader.js

@@ -36,53 +36,54 @@ import inferSegmentContainer from "../utils/infer_segment_container";
  */
 export default function addSegmentIntegrityChecks(segmentLoader) {
     return function (url, content, initialCancelSignal, callbacks) {
-        return new Promise(function (res, rej) {
-            var canceller = new TaskCanceller();
-            var unregisterCancelLstnr = initialCancelSignal
-                .register(function onCheckCancellation(err) {
-                canceller.cancel();
-                rej(err);
-            });
-            /**
-             * If the data's seems to be corrupted, cancel the loading task and reject
-             * with an `INTEGRITY_ERROR` error.
-             * @param {*} data
-             */
-            function cancelAndRejectOnBadIntegrity(data) {
-                if (!(data instanceof Array) && !(data instanceof Uint8Array) ||
-                    inferSegmentContainer(content.adaptation.type, content.representation) !== "mp4") {
-                    return;
-                }
-                try {
-                    checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
-                }
-                catch (err) {
-                    unregisterCancelLstnr();
-                    canceller.cancel();
-                    rej(err);
-                }
-            }
-            segmentLoader(url, content, canceller.signal, __assign(__assign({}, callbacks), { onNewChunk: function (data) {
-                    cancelAndRejectOnBadIntegrity(data);
-                    if (!canceller.isUsed) {
+        return new Promise(function (resolve, reject) {
+            var requestCanceller = new TaskCanceller({ cancelOn: initialCancelSignal });
+            // Reject the `CancellationError` when `requestCanceller`'s signal emits
+            // `stopRejectingOnCancel` here is a function allowing to stop this mechanism
+            var stopRejectingOnCancel = requestCanceller.signal.register(reject);
+            segmentLoader(url, content, requestCanceller.signal, __assign(__assign({}, callbacks), { onNewChunk: function (data) {
+                    try {
+                        trowOnIntegrityError(data);
                         callbacks.onNewChunk(data);
                     }
+                    catch (err) {
+                        // Do not reject with a `CancellationError` after cancelling the request
+                        stopRejectingOnCancel();
+                        // Cancel the request
+                        requestCanceller.cancel();
+                        // Reject with thrown error
+                        reject(err);
+                    }
                 } })).then(function (info) {
-                if (canceller.isUsed) {
+                if (requestCanceller.isUsed) {
                     return;
                 }
-                unregisterCancelLstnr();
+                stopRejectingOnCancel();
                 if (info.resultType === "segment-loaded") {
-                    cancelAndRejectOnBadIntegrity(info.resultData.responseData);
+                    try {
+                        trowOnIntegrityError(info.resultData.responseData);
+                    }
+                    catch (err) {
+                        reject(err);
+                        return;
+                    }
                 }
-                res(info);
+                resolve(info);
             }, function (error) {
-                // The segmentLoader's cancellations cases are all handled here
-                if (!TaskCanceller.isCancellationError(error)) {
-                    unregisterCancelLstnr();
-                    rej(error);
-                }
+                stopRejectingOnCancel();
+                reject(error);
             });
         });
+        /**
+         * If the data's seems to be corrupted, throws an `INTEGRITY_ERROR` error.
+         * @param {*} data
+         */
+        function trowOnIntegrityError(data) {
+            if (!(data instanceof ArrayBuffer) && !(data instanceof Uint8Array) ||
+                inferSegmentContainer(content.adaptation.type, content.representation) !== "mp4") {
+                return;
+            }
+            checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
+        }
     };
 }

package/dist/_esm5.processed/utils/reference.js

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 import { Observable, } from "rxjs";
-import log from "../log";
 /**
  * Create an `ISharedReference` object encapsulating the mutable `initialValue`
  * value of type T.
@@ -61,7 +60,6 @@ export function createSharedReference(initialValue) {
                     throw new Error("Finished shared references cannot be updated");
                 }
                 else {
-                    log.error("Finished shared references cannot be updated");
                     return;
                 }
             }

package/dist/_esm5.processed/utils/task_canceller.d.ts

@@ -131,8 +131,15 @@ export default class TaskCanceller {
      * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
      * as its `signal` provide.
      * You can then pass this property to async task you wish to be cancellable.
+     * @param {Object|undefined} options
      */
-    constructor();
+    constructor(options?: {
+        /**
+         * If set the TaskCanceller created here will automatically be triggered
+         * when that signal emits.
+         */
+        cancelOn?: CancellationSignal | undefined;
+    } | undefined);
     /**
      * "Trigger" the `TaskCanceller`, notify through its associated
      * `CancellationSignal` (its `signal` property) that a task should be aborted.

package/dist/_esm5.processed/utils/task_canceller.js

@@ -132,12 +132,20 @@ var TaskCanceller = /** @class */ (function () {
      * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
      * as its `signal` provide.
      * You can then pass this property to async task you wish to be cancellable.
+     * @param {Object|undefined} options
      */
-    function TaskCanceller() {
+    function TaskCanceller(options) {
+        var _this = this;
         var _a = createCancellationFunctions(), trigger = _a[0], register = _a[1];
         this.isUsed = false;
         this._trigger = trigger;
         this.signal = new CancellationSignal(register);
+        if ((options === null || options === void 0 ? void 0 : options.cancelOn) !== undefined) {
+            var unregisterParent = options.cancelOn.register(function () {
+                _this.cancel();
+            });
+            this.signal.register(unregisterParent);
+        }
     }
     /**
      * "Trigger" the `TaskCanceller`, notify through its associated