rx-player 3.26.2 → 3.27.0-dev.20220317

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.d.ts

@@ -1,4 +1,3 @@
-import PPromise from "pinkie";
 import { CancellationSignal } from "../task_canceller";
 /** Object returned by `fetchRequest` after the fetch operation succeeded. */
 export interface IFetchedStreamComplete {
@@ -33,7 +32,7 @@ export interface IFetchedDataObject {
      * Value of the "Content-Length" header, which should (yet also might not be)
      * the size of the complete data that will be fetched.
      */
-    totalSize?: number;
+    totalSize: number | undefined;
     /**
      * Current available chunk, which might only be a sub-part of the whole
      * data.
@@ -61,15 +60,15 @@ export interface IFetchOptions {
     /** Optional headers for the HTTP GET request perfomed by `fetchRequest`. */
     headers?: {
         [header: string]: string;
-    } | null;
+    } | undefined | null;
     /**
      * Optional timeout for the HTTP GET request perfomed by `fetchRequest`.
      * This timeout is just enabled until the HTTP response from the server, even
      * if not all data has been received yet.
      */
-    timeout?: number;
+    timeout?: number | undefined;
 }
-export default function fetchRequest(options: IFetchOptions): PPromise<IFetchedStreamComplete>;
+export default function fetchRequest(options: IFetchOptions): Promise<IFetchedStreamComplete>;
 /**
  * Returns true if fetch should be supported in the current browser.
  * @return {boolean}

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

@@ -49,12 +49,10 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-import PPromise from "pinkie";
 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" ?
@@ -93,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;
@@ -104,9 +102,13 @@ export default function fetchRequest(options) {
         cancellation = err;
         abortFetch();
     });
-    return fetch(options.url, { headers: headers, method: "GET",
-        signal: !isNullOrUndefined(abortController) ? abortController.signal :
-            undefined }).then(function (response) {
+    var fetchOpts = { method: "GET" };
+    if (headers !== undefined) {
+        fetchOpts.headers = headers;
+    }
+    fetchOpts.signal = !isNullOrUndefined(abortController) ? abortController.signal :
+        null;
+    return fetch(options.url, fetchOpts).then(function (response) {
         if (!isNullOrUndefined(timeout)) {
             clearTimeout(timeout);
         }

package/dist/_esm5.processed/utils/request/xhr.d.ts

@@ -107,25 +107,25 @@ export interface IRequestOptions<ResponseType> {
     /** Dictionary of headers you want to set. `null` or `undefined` for no header. */
     headers?: {
         [header: string]: string;
-    } | null;
+    } | null | undefined;
     /** Wanted format for the response */
-    responseType?: ResponseType;
+    responseType?: ResponseType | undefined;
     /**
      * Optional timeout, in milliseconds, after which we will cancel a request.
      * Set to DEFAULT_REQUEST_TIMEOUT by default.
      */
-    timeout?: number;
+    timeout?: number | undefined;
     /**
      * "Cancelation token" used to be able to cancel the request.
      * When this token is "cancelled", the request will be aborted and the Promise
      * returned by `request` will be rejected.
      */
-    cancelSignal?: CancellationSignal;
+    cancelSignal?: CancellationSignal | undefined;
     /**
      * When defined, this callback will be called on each XHR "progress" event
      * with data related to this request's progress.
      */
-    onProgress?: (info: IProgressInfo) => void;
+    onProgress?: ((info: IProgressInfo) => void) | undefined;
 }
 /** Data emitted by `request`'s Promise when the request succeeded. */
 export interface IRequestResponse<T, U> {
@@ -156,5 +156,5 @@ export interface IProgressInfo {
     size: number;
     sendingTime: number;
     url: string;
-    totalSize?: number;
+    totalSize?: number | undefined;
 }

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

@@ -17,9 +17,10 @@ import config from "../../config";
 import { RequestError } from "../../errors";
 import isNonEmptyString from "../is_non_empty_string";
 import isNullOrUndefined from "../is_null_or_undefined";
-var DEFAULT_REQUEST_TIMEOUT = config.DEFAULT_REQUEST_TIMEOUT;
+import PPromise from "../promise";
 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,
@@ -28,7 +29,7 @@ export default function request(options) {
         timeout: isNullOrUndefined(options.timeout) ? DEFAULT_REQUEST_TIMEOUT :
             options.timeout,
     };
-    return new Promise(function (resolve, reject) {
+    return new PPromise(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.d.ts

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PPromise from "pinkie";
 import { Observable } from "rxjs";
 import TaskCanceller from "./task_canceller";
 /**
@@ -37,4 +36,4 @@ import TaskCanceller from "./task_canceller";
  * @param {Function} fn
  * @returns {Observable}
  */
-export default function fromCancellablePromise<T>(canceller: TaskCanceller, fn: () => PPromise<T>): Observable<T>;
+export default function fromCancellablePromise<T>(canceller: TaskCanceller, fn: () => Promise<T>): Observable<T>;

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);
     };
     /**