rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.2022032100

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

@@ -27,18 +27,21 @@ export function createSharedReference(initialValue) {
     /** Current value referenced by this `ISharedReference`. */
     var value = initialValue;
     /**
-     * List of currently subscribed Observables which listen to the referenced
+     * List of currently subscribed listeners which listen to the referenced
      * value's updates.
      *
-     * Contains two properties:
-     *   - `subscriber`: interface through which new value will be communicated.
-     *   - `hasBeenUnsubscribed`: becomes `true` when the Observable becomes
-     *     unsubscribed and thus when it is removed from the `subs` array.
+     * Contains three properties:
+     *   - `trigger`: Function which will be called with the new reference's value
+     *     once it changes
+     *   - `complete`: Allows to clean-up the listener, will be called once the
+     *     reference is finished.
+     *   - `hasBeenCleared`: becomes `true` when the Observable becomes
+     *     unsubscribed and thus when it is removed from the `cbs` array.
      *     Adding this property allows to detect when a previously-added
      *     Observable has since been unsubscribed e.g. as a side-effect during a
      *     function call.
      */
-    var subs = [];
+    var cbs = [];
     var isFinished = false;
     return {
         /**
@@ -63,15 +66,15 @@ export function createSharedReference(initialValue) {
                 }
             }
             value = newVal;
-            if (subs.length === 0) {
+            if (cbs.length === 0) {
                 return;
             }
-            var clonedSubs = subs.slice();
-            for (var _i = 0, clonedSubs_1 = clonedSubs; _i < clonedSubs_1.length; _i++) {
-                var subObj = clonedSubs_1[_i];
+            var clonedCbs = cbs.slice();
+            for (var _i = 0, clonedCbs_1 = clonedCbs; _i < clonedCbs_1.length; _i++) {
+                var cbObj = clonedCbs_1[_i];
                 try {
-                    if (!subObj.hasBeenUnsubscribed) {
-                        subObj.subscriber.next(newVal);
+                    if (!cbObj.hasBeenCleared) {
+                        cbObj.trigger(newVal);
                     }
                 }
                 catch (_) {
@@ -79,6 +82,11 @@ export function createSharedReference(initialValue) {
                 }
             }
         },
+        setValueIfChanged: function (newVal) {
+            if (newVal !== value) {
+                this.setValue(newVal);
+            }
+        },
         /**
          * Returns an Observable which synchronously emits the current value (unless
          * the `skipCurrentValue` argument has been set to `true`) and then each
@@ -95,23 +103,63 @@ export function createSharedReference(initialValue) {
                     obs.complete();
                     return undefined;
                 }
-                var subObj = { subscriber: obs,
-                    hasBeenUnsubscribed: false };
-                subs.push(subObj);
+                var cbObj = { trigger: obs.next.bind(obs),
+                    complete: obs.complete.bind(obs),
+                    hasBeenCleared: false };
+                cbs.push(cbObj);
                 return function () {
                     /**
                      * Code in here can still be running while this is happening.
-                     * Set `hasBeenUnsubscribed` to `true` to avoid still using the
+                     * Set `hasBeenCleared` to `true` to avoid still using the
                      * `subscriber` from this object.
                      */
-                    subObj.hasBeenUnsubscribed = true;
-                    var indexOf = subs.indexOf(subObj);
+                    cbObj.hasBeenCleared = true;
+                    var indexOf = cbs.indexOf(cbObj);
                     if (indexOf >= 0) {
-                        subs.splice(indexOf, 1);
+                        cbs.splice(indexOf, 1);
                     }
                 };
             });
         },
+        /**
+         * Allows to register a callback to be called each time the value inside the
+         * reference is updated.
+         * @param {Function} cb - Callback to be called each time the reference is
+         * updated. Takes the new value im argument.
+         * @param {Object} [options]
+         * @param {Object} [options.clearSignal] - Allows to provide a
+         * CancellationSignal which will unregister the callback when it emits.
+         * @param {boolean} [options.emitCurrentValue] - If `true`, the callback will
+         * also be immediately called with the current value.
+         */
+        onUpdate: function (cb, options) {
+            if ((options === null || options === void 0 ? void 0 : options.emitCurrentValue) === true) {
+                cb(value);
+            }
+            if (isFinished) {
+                return;
+            }
+            var cbObj = { trigger: cb,
+                complete: unlisten,
+                hasBeenCleared: false };
+            cbs.push(cbObj);
+            if ((options === null || options === void 0 ? void 0 : options.clearSignal) === undefined) {
+                return;
+            }
+            options.clearSignal.register(unlisten);
+            function unlisten() {
+                /**
+                 * Code in here can still be running while this is happening.
+                 * Set `hasBeenCleared` to `true` to avoid still using the
+                 * `subscriber` from this object.
+                 */
+                cbObj.hasBeenCleared = true;
+                var indexOf = cbs.indexOf(cbObj);
+                if (indexOf >= 0) {
+                    cbs.splice(indexOf, 1);
+                }
+            }
+        },
         /**
          * Indicate that no new values will be emitted.
          * Allows to automatically close all Observables generated from this shared
@@ -119,12 +167,12 @@ export function createSharedReference(initialValue) {
          */
         finish: function () {
             isFinished = true;
-            var clonedSubs = subs.slice();
-            for (var _i = 0, clonedSubs_2 = clonedSubs; _i < clonedSubs_2.length; _i++) {
-                var subObj = clonedSubs_2[_i];
+            var clonedCbs = cbs.slice();
+            for (var _i = 0, clonedCbs_2 = clonedCbs; _i < clonedCbs_2.length; _i++) {
+                var cbObj = clonedCbs_2[_i];
                 try {
-                    if (!subObj.hasBeenUnsubscribed) {
-                        subObj.subscriber.complete();
+                    if (!cbObj.hasBeenCleared) {
+                        cbObj.complete();
                     }
                 }
                 catch (_) {

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

@@ -53,7 +53,6 @@ import config from "../../config";
 import { NetworkErrorTypes, RequestError, } from "../../errors";
 import log from "../../log";
 import isNullOrUndefined from "../is_null_or_undefined";
-var DEFAULT_REQUEST_TIMEOUT = config.DEFAULT_REQUEST_TIMEOUT;
 var _Headers = typeof Headers === "function" ? Headers :
     null;
 var _AbortController = typeof AbortController === "function" ?
@@ -92,7 +91,7 @@ export default function fetchRequest(options) {
         abortController.abort();
     }
     var requestTimeout = isNullOrUndefined(options.timeout) ?
-        DEFAULT_REQUEST_TIMEOUT :
+        config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
         options.timeout;
     var timeout = window.setTimeout(function () {
         timeouted = true;

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

@@ -17,10 +17,9 @@ import config from "../../config";
 import { RequestError } from "../../errors";
 import isNonEmptyString from "../is_non_empty_string";
 import isNullOrUndefined from "../is_null_or_undefined";
-import PPromise from "../promise";
-var DEFAULT_REQUEST_TIMEOUT = config.DEFAULT_REQUEST_TIMEOUT;
 var DEFAULT_RESPONSE_TYPE = "json";
 export default function request(options) {
+    var DEFAULT_REQUEST_TIMEOUT = config.getCurrent().DEFAULT_REQUEST_TIMEOUT;
     var requestOptions = {
         url: options.url,
         headers: options.headers,
@@ -29,7 +28,7 @@ export default function request(options) {
         timeout: isNullOrUndefined(options.timeout) ? DEFAULT_REQUEST_TIMEOUT :
             options.timeout,
     };
-    return new PPromise(function (resolve, reject) {
+    return new Promise(function (resolve, reject) {
         var onProgress = options.onProgress, cancelSignal = options.cancelSignal;
         var url = requestOptions.url, headers = requestOptions.headers, responseType = requestOptions.responseType, timeout = requestOptions.timeout;
         var xhr = new XMLHttpRequest();

package/dist/_esm5.processed/utils/rx-from_cancellable_promise.js

@@ -38,21 +38,26 @@ import { Observable } from "rxjs";
 export default function fromCancellablePromise(canceller, fn) {
     return new Observable(function (obs) {
         var isUnsubscribedFrom = false;
+        var isComplete = false;
         fn().then(function (i) {
             if (isUnsubscribedFrom) {
                 return;
             }
+            isComplete = true;
             obs.next(i);
             obs.complete();
         }, function (err) {
+            isComplete = true;
             if (isUnsubscribedFrom) {
                 return;
             }
             obs.error(err);
         });
         return function () {
-            isUnsubscribedFrom = true;
-            canceller.cancel();
+            if (!isComplete) {
+                isUnsubscribedFrom = true;
+                canceller.cancel();
+            }
         };
     });
 }

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

@@ -142,9 +142,9 @@ export default class TaskCanceller {
      * An optional CancellationError can be given in argument for when this
      * cancellation is actually triggered as a chain reaction from a previous
      * cancellation.
-     * @param {Error} [originError]
+     * @param {Error} [srcError]
      */
-    cancel(originError?: CancellationError): void;
+    cancel(srcError?: CancellationError): void;
     /**
      * Check that the `error` in argument is a `CancellationError`, most likely
      * meaning that the linked error is due to a task aborted via a
@@ -166,7 +166,9 @@ export declare class CancellationSignal {
      */
     isCancelled: boolean;
     /**
-     * Error associated to the cancellation.
+     * Error associated to the cancellation, only set if the `CancellationSignal`
+     * has been used (which means that the task has been cancelled).
+     *
      * Can be used to notify to a caller that this task was aborted (for example
      * by rejecting it through the Promise associated to that task).
      *

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

@@ -148,14 +148,14 @@ var TaskCanceller = /** @class */ (function () {
      * An optional CancellationError can be given in argument for when this
      * cancellation is actually triggered as a chain reaction from a previous
      * cancellation.
-     * @param {Error} [originError]
+     * @param {Error} [srcError]
      */
-    TaskCanceller.prototype.cancel = function (originError) {
+    TaskCanceller.prototype.cancel = function (srcError) {
         if (this.isUsed) {
             return;
         }
         this.isUsed = true;
-        var cancellationError = originError !== null && originError !== void 0 ? originError : new CancellationError();
+        var cancellationError = srcError !== null && srcError !== void 0 ? srcError : new CancellationError();
         this._trigger(cancellationError);
     };
     /**