rx-player 3.30.0-dev.2023020100 → 3.30.0-dev.2023022200

package/dist/_esm5.processed/transports/utils/call_custom_manifest_loader.js

@@ -25,7 +25,7 @@ export default function callCustomManifestLoader(customManifestLoader, fallbackM
              * @param {Object} args
              */
             var resolve = function (_args) {
-                if (hasFinished || cancelSignal.isCancelled) {
+                if (hasFinished || cancelSignal.isCancelled()) {
                     return;
                 }
                 hasFinished = true;
@@ -45,7 +45,7 @@ export default function callCustomManifestLoader(customManifestLoader, fallbackM
              */
             var reject = function (err) {
                 var _a, _b, _c;
-                if (hasFinished || cancelSignal.isCancelled) {
+                if (hasFinished || cancelSignal.isCancelled()) {
                     return;
                 }
                 hasFinished = true;
@@ -62,7 +62,7 @@ export default function callCustomManifestLoader(customManifestLoader, fallbackM
              * the "regular" implementation
              */
             var fallback = function () {
-                if (hasFinished || cancelSignal.isCancelled) {
+                if (hasFinished || cancelSignal.isCancelled()) {
                     return;
                 }
                 hasFinished = true;

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

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import createCancellablePromise from "./create_cancellable_promise";
 /**
  * Wait the given `delay`, resolving the Promise when finished.
  *
@@ -27,15 +28,8 @@
  * cancellation with the corresponding `CancellationError`.
  */
 export default function cancellableSleep(delay, cancellationSignal) {
-    return new Promise(function (res, rej) {
-        var timeout = setTimeout(function () {
-            unregisterCancelSignal();
-            res();
-        }, delay);
-        var unregisterCancelSignal = cancellationSignal
-            .register(function onCancel(cancellationError) {
-            clearTimeout(timeout);
-            rej(cancellationError);
-        });
+    return createCancellablePromise(cancellationSignal, function (res) {
+        var timeout = setTimeout(function () { return res(); }, delay);
+        return function () { return clearTimeout(timeout); };
     });
 }

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

@@ -0,0 +1,26 @@
+import { CancellationSignal } from "./task_canceller";
+/**
+ * Returns a Promise linked to a `CancellationSignal`, which will reject the
+ * corresponding `CancellationError` if that signal emits before the wanted
+ * task finishes (either on success or on error).
+ *
+ * The given callback mimicks the Promise interface with the added possibility
+ * of returning a callback which will be called when and if the task is
+ * cancelled before being either resolved or rejected.
+ * In that case, that logic will be called just before the Promise is rejected
+ * with the corresponding `CancellationError`.
+ * The point of this callback is to implement aborting logic, such as for
+ * example aborting a request.
+ *
+ * @param {Object} cancellationSignal - The `CancellationSignal` the returned
+ * Promise will be linked to.
+ * @param {Function} cb - The function implementing the cancellable Promise. Its
+ * arguments follow Promise's semantics but it can also return a function which
+ * will be called when and if `cancellationSignal` emits before either arguments
+ * are called.
+ * @returns {Promise} - The created Promise, which will resolve when and if the
+ * first argument to `cb` is called first and reject either if the second
+ * argument to `cb` is called first or if the given `CancellationSignal` emits
+ * before either of the two previous conditions.
+ */
+export default function createCancellablePromise<T>(cancellationSignal: CancellationSignal, cb: (resolve: (val: T) => void, reject: (err: unknown) => void) => (() => void) | void): Promise<T>;

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

@@ -0,0 +1,52 @@
+/**
+ * Returns a Promise linked to a `CancellationSignal`, which will reject the
+ * corresponding `CancellationError` if that signal emits before the wanted
+ * task finishes (either on success or on error).
+ *
+ * The given callback mimicks the Promise interface with the added possibility
+ * of returning a callback which will be called when and if the task is
+ * cancelled before being either resolved or rejected.
+ * In that case, that logic will be called just before the Promise is rejected
+ * with the corresponding `CancellationError`.
+ * The point of this callback is to implement aborting logic, such as for
+ * example aborting a request.
+ *
+ * @param {Object} cancellationSignal - The `CancellationSignal` the returned
+ * Promise will be linked to.
+ * @param {Function} cb - The function implementing the cancellable Promise. Its
+ * arguments follow Promise's semantics but it can also return a function which
+ * will be called when and if `cancellationSignal` emits before either arguments
+ * are called.
+ * @returns {Promise} - The created Promise, which will resolve when and if the
+ * first argument to `cb` is called first and reject either if the second
+ * argument to `cb` is called first or if the given `CancellationSignal` emits
+ * before either of the two previous conditions.
+ */
+export default function createCancellablePromise(cancellationSignal, cb) {
+    var abortingLogic;
+    return new Promise(function (res, rej) {
+        if (cancellationSignal.cancellationError !== null) {
+            // If the signal was already triggered before, do not even call `cb`
+            return rej(cancellationSignal.cancellationError);
+        }
+        var hasUnregistered = false;
+        abortingLogic = cb(function onCancellablePromiseSuccess(val) {
+            cancellationSignal.deregister(onCancellablePromiseCancellation);
+            hasUnregistered = true;
+            res(val);
+        }, function onCancellablePromiseFailure(err) {
+            cancellationSignal.deregister(onCancellablePromiseCancellation);
+            hasUnregistered = true;
+            rej(err);
+        });
+        if (!hasUnregistered) {
+            cancellationSignal.register(onCancellablePromiseCancellation);
+        }
+        function onCancellablePromiseCancellation(error) {
+            if (abortingLogic !== undefined) {
+                abortingLogic();
+            }
+            rej(error);
+        }
+    });
+}

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

@@ -126,6 +126,9 @@ export default function createSharedReference(initialValue, cancelSignal) {
             }
             options.clearSignal.register(unlisten);
             function unlisten() {
+                if ((options === null || options === void 0 ? void 0 : options.clearSignal) !== undefined) {
+                    options.clearSignal.deregister(unlisten);
+                }
                 if (cbObj.hasBeenCleared) {
                     return;
                 }
@@ -165,6 +168,9 @@ export default function createSharedReference(initialValue, cancelSignal) {
         finish: finish,
     };
     function finish() {
+        if (cancelSignal !== undefined) {
+            cancelSignal.deregister(finish);
+        }
         isFinished = true;
         var clonedCbs = cbs.slice();
         for (var _i = 0, clonedCbs_2 = clonedCbs; _i < clonedCbs_2.length; _i++) {

package/dist/_esm5.processed/utils/request/xhr.js

@@ -68,7 +68,7 @@ export default function request(options) {
                 }
                 reject(err);
             });
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
                 return;
             }
         }

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

@@ -116,12 +116,12 @@ export default class TaskCanceller {
      * notified that it should be aborted when this `TaskCanceller` is triggered
      * (through its `cancel` method).
      */
-    signal: CancellationSignal;
+    readonly signal: CancellationSignal;
     /**
      * `true` if this `TaskCanceller` has already been triggered.
      * `false` otherwise.
      */
-    isUsed: boolean;
+    private _isUsed;
     /**
      * @private
      * Internal function called when the `TaskCanceller` is triggered`.
@@ -131,15 +131,28 @@ 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(options?: {
-        /**
-         * If set the TaskCanceller created here will automatically be triggered
-         * when that signal emits.
-         */
-        cancelOn?: CancellationSignal | undefined;
-    } | undefined);
+    constructor();
+    /**
+     * Returns `true` if this `TaskCanceller` has already been triggered.
+     * `false` otherwise.
+     */
+    isUsed(): boolean;
+    /**
+     * Bind this `TaskCanceller` to a `CancellationSignal`, so the former
+     * is automatically cancelled when the latter is triggered.
+     *
+     * Note that this call registers a callback on the given signal, until either
+     * the current `TaskCanceller` is cancelled or until this given
+     * `CancellationSignal` is triggered.
+     * To avoid leaking memory, the returned callback allow to undo this link.
+     * It should be called if/when that link is not needed anymore, such as when
+     * there is no need for this `TaskCanceller` anymore.
+     *
+     * @param {Object} signal
+     * @returns {Function}
+     */
+    linkToSignal(signal: CancellationSignal): () => void;
     /**
      * "Trigger" the `TaskCanceller`, notify through its associated
      * `CancellationSignal` (its `signal` property) that a task should be aborted.
@@ -166,11 +179,6 @@ export default class TaskCanceller {
  * @class
  */
 export declare class CancellationSignal {
-    /**
-     * True when the cancellation order was already triggered, meaning that the
-     * linked task needs to be aborted.
-     */
-    isCancelled: boolean;
     /**
      * Error associated to the cancellation, only set if the `CancellationSignal`
      * has been used (which means that the task has been cancelled).
@@ -188,6 +196,11 @@ export declare class CancellationSignal {
      * which depend on this CancellationSignal.
      */
     private _listeners;
+    /**
+     * True when the cancellation order was already triggered, meaning that the
+     * linked task needs to be aborted.
+     */
+    private _isCancelled;
     /**
      * Creates a new CancellationSignal.
      * /!\ Note: Only a `TaskCanceller` is supposed to be able to create one.
@@ -195,6 +208,12 @@ export declare class CancellationSignal {
      * cancelled.
      */
     constructor(registerToSource: (listener: ICancellationListener) => void);
+    /**
+     * Returns `true` when the cancellation order was already triggered, meaning
+     * that the linked task needs to be aborted.
+     * @returns boolean
+     */
+    isCancelled(): boolean;
     /**
      * Registers a function that will be called when/if the current task is
      * cancelled.

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

@@ -28,6 +28,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+import log from "../log";
 import assert from "./assert";
 import noop from "./noop";
 /**
@@ -132,21 +133,42 @@ 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(options) {
-        var _this = this;
+    function TaskCanceller() {
         var _a = createCancellationFunctions(), trigger = _a[0], register = _a[1];
-        this.isUsed = false;
+        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);
-        }
     }
+    /**
+     * Returns `true` if this `TaskCanceller` has already been triggered.
+     * `false` otherwise.
+     */
+    TaskCanceller.prototype.isUsed = function () {
+        return this._isUsed;
+    };
+    /**
+     * Bind this `TaskCanceller` to a `CancellationSignal`, so the former
+     * is automatically cancelled when the latter is triggered.
+     *
+     * Note that this call registers a callback on the given signal, until either
+     * the current `TaskCanceller` is cancelled or until this given
+     * `CancellationSignal` is triggered.
+     * To avoid leaking memory, the returned callback allow to undo this link.
+     * It should be called if/when that link is not needed anymore, such as when
+     * there is no need for this `TaskCanceller` anymore.
+     *
+     * @param {Object} signal
+     * @returns {Function}
+     */
+    TaskCanceller.prototype.linkToSignal = function (signal) {
+        var _this = this;
+        var unregister = signal.register(function () {
+            _this.cancel();
+        });
+        this.signal.register(unregister);
+        return unregister;
+    };
     /**
      * "Trigger" the `TaskCanceller`, notify through its associated
      * `CancellationSignal` (its `signal` property) that a task should be aborted.
@@ -159,10 +181,10 @@ var TaskCanceller = /** @class */ (function () {
      * @param {Error} [srcError]
      */
     TaskCanceller.prototype.cancel = function (srcError) {
-        if (this.isUsed) {
+        if (this._isUsed) {
             return;
         }
-        this.isUsed = true;
+        this._isUsed = true;
         var cancellationError = srcError !== null && srcError !== void 0 ? srcError : new CancellationError();
         this._trigger(cancellationError);
     };
@@ -192,18 +214,32 @@ var CancellationSignal = /** @class */ (function () {
      */
     function CancellationSignal(registerToSource) {
         var _this = this;
-        this.isCancelled = false;
+        this._isCancelled = false;
         this.cancellationError = null;
         this._listeners = [];
         registerToSource(function (cancellationError) {
             _this.cancellationError = cancellationError;
-            _this.isCancelled = true;
+            _this._isCancelled = true;
             while (_this._listeners.length > 0) {
-                var listener = _this._listeners.splice(_this._listeners.length - 1, 1)[0];
-                listener(cancellationError);
+                try {
+                    var listener = _this._listeners.pop();
+                    listener === null || listener === void 0 ? void 0 : listener(cancellationError);
+                }
+                catch (err) {
+                    log.error("Error while calling clean up listener", err instanceof Error ? err.toString() :
+                        "Unknown error");
+                }
             }
         });
     }
+    /**
+     * Returns `true` when the cancellation order was already triggered, meaning
+     * that the linked task needs to be aborted.
+     * @returns boolean
+     */
+    CancellationSignal.prototype.isCancelled = function () {
+        return this._isCancelled;
+    };
     /**
      * Registers a function that will be called when/if the current task is
      * cancelled.
@@ -227,9 +263,10 @@ var CancellationSignal = /** @class */ (function () {
      */
     CancellationSignal.prototype.register = function (fn) {
         var _this = this;
-        if (this.isCancelled) {
+        if (this._isCancelled) {
             assert(this.cancellationError !== null);
             fn(this.cancellationError);
+            return noop;
         }
         this._listeners.push(fn);
         return function () { return _this.deregister(fn); };
@@ -243,13 +280,9 @@ var CancellationSignal = /** @class */ (function () {
      * @param {Function} fn
      */
     CancellationSignal.prototype.deregister = function (fn) {
-        if (this.isCancelled) {
-            return;
-        }
-        for (var i = 0; i < this._listeners.length; i++) {
+        for (var i = this._listeners.length - 1; i >= 0; i--) {
             if (this._listeners[i] === fn) {
                 this._listeners.splice(i, 1);
-                return;
             }
         }
     };