rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -13,40 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-export interface IRequestProgress {
-    type: "progress";
-    value: {
-        currentTime: number;
-        duration: number;
-        size: number;
-        sendingTime: number;
-        url: string;
-        totalSize?: number;
-    };
-}
-export interface IRequestResponse<T, U> {
-    type: "data-loaded";
-    value: {
-        duration: number;
-        receivedTime: number;
-        responseData: T;
-        responseType: U;
-        sendingTime: number;
-        size: number;
-        status: number;
-        url: string;
-    };
-}
-export interface IRequestOptions<T, U> {
-    url: string;
-    headers?: {
-        [header: string]: string;
-    } | null;
-    responseType?: T;
-    timeout?: number;
-    sendProgressEvents?: U;
-}
+import { CancellationSignal } from "../task_canceller";
 /**
  * # request function
  *
@@ -128,16 +95,66 @@ export interface IRequestOptions<T, U> {
  * @param {Object} options
  * @returns {Observable}
  */
-declare function request(options: IRequestOptions<undefined | null | "" | "text", false | undefined>): Observable<IRequestResponse<string, "text">>;
-declare function request(options: IRequestOptions<undefined | null | "" | "text", true>): Observable<IRequestResponse<string, "text"> | IRequestProgress>;
-declare function request(options: IRequestOptions<"arraybuffer", false | undefined>): Observable<IRequestResponse<ArrayBuffer, "arraybuffer">>;
-declare function request(options: IRequestOptions<"arraybuffer", true>): Observable<IRequestResponse<ArrayBuffer, "arraybuffer"> | IRequestProgress>;
-declare function request(options: IRequestOptions<"document", false | undefined>): Observable<IRequestResponse<Document, "document">>;
-declare function request(options: IRequestOptions<"document", true>): Observable<IRequestResponse<Document, "document"> | IRequestProgress>;
-declare function request(options: IRequestOptions<"json", false | undefined>): Observable<IRequestResponse<object, "json">>;
-declare function request(options: IRequestOptions<"json", true>): Observable<IRequestResponse<object, "json"> | IRequestProgress>;
-declare function request(options: IRequestOptions<"blob", false | undefined>): Observable<IRequestResponse<Blob, "blob">>;
-declare function request(options: IRequestOptions<"blob", true>): Observable<IRequestResponse<Blob, "blob"> | IRequestProgress>;
-declare function request<T>(options: IRequestOptions<XMLHttpRequestResponseType | null | undefined, false | undefined>): Observable<IRequestResponse<T, XMLHttpRequestResponseType>>;
-declare function request<T>(options: IRequestOptions<XMLHttpRequestResponseType | null | undefined, true>): Observable<IRequestResponse<T, XMLHttpRequestResponseType> | IRequestProgress>;
-export default request;
+export default function request(options: IRequestOptions<undefined | null | "" | "text">): Promise<IRequestResponse<string, "text">>;
+export default function request(options: IRequestOptions<"arraybuffer">): Promise<IRequestResponse<ArrayBuffer, "arraybuffer">>;
+export default function request(options: IRequestOptions<"document">): Promise<IRequestResponse<Document, "document">>;
+export default function request(options: IRequestOptions<"json">): Promise<IRequestResponse<object, "json">>;
+export default function request(options: IRequestOptions<"blob">): Promise<IRequestResponse<Blob, "blob">>;
+/** Options given to `request` */
+export interface IRequestOptions<ResponseType> {
+    /** URL you want to request. */
+    url: string;
+    /** Dictionary of headers you want to set. `null` or `undefined` for no header. */
+    headers?: {
+        [header: string]: string;
+    } | null | undefined;
+    /** Wanted format for the response */
+    responseType?: ResponseType | undefined;
+    /**
+     * Optional timeout, in milliseconds, after which we will cancel a request.
+     * Set to DEFAULT_REQUEST_TIMEOUT by default.
+     */
+    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 | 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) | undefined;
+}
+/** Data emitted by `request`'s Promise when the request succeeded. */
+export interface IRequestResponse<T, U> {
+    /** Time taken by the request, in milliseconds. */
+    requestDuration: number;
+    /** Time (relative to the "time origin") at which the request ended. */
+    receivedTime: number;
+    /** Data requested. Its type will depend on the responseType. */
+    responseData: T;
+    /** `responseType` requested, gives an indice on the type of `responseData`. */
+    responseType: U;
+    /** Time (relative to the "time origin") at which the request began. */
+    sendingTime: number;
+    /** Full size of the requested data, in bytes. */
+    size: number;
+    /** HTTP status of the response */
+    status: number;
+    /**
+     * Actual URL requested.
+     * Can be different from the one given to `request` due to a possible
+     * redirection.
+     */
+    url: string;
+}
+export interface IProgressInfo {
+    currentTime: number;
+    duration: number;
+    size: number;
+    sendingTime: number;
+    url: string;
+    totalSize?: number | undefined;
+}

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

@@ -13,26 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 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";
-/**
- * @param {string} data
- * @returns {Object|null}
- */
-function toJSONForIE(data) {
-    try {
-        return JSON.parse(data);
-    }
-    catch (e) {
-        return null;
-    }
-}
-function request(options) {
+export default function request(options) {
     var requestOptions = {
         url: options.url,
         headers: options.headers,
@@ -41,7 +29,8 @@ function request(options) {
         timeout: isNullOrUndefined(options.timeout) ? DEFAULT_REQUEST_TIMEOUT :
             options.timeout,
     };
-    return new Observable(function (obs) {
+    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();
         xhr.open("GET", url, true);
@@ -61,26 +50,44 @@ function request(options) {
             }
         }
         var sendingTime = performance.now();
+        // Handle request cancellation
+        var deregisterCancellationListener = null;
+        if (cancelSignal !== undefined) {
+            deregisterCancellationListener = cancelSignal
+                .register(function abortRequest(err) {
+                if (!isNullOrUndefined(xhr) && xhr.readyState !== 4) {
+                    xhr.abort();
+                }
+                reject(err);
+            });
+            if (cancelSignal.isCancelled) {
+                return;
+            }
+        }
         xhr.onerror = function onXHRError() {
-            obs.error(new RequestError(url, xhr.status, "ERROR_EVENT", xhr));
+            if (deregisterCancellationListener !== null) {
+                deregisterCancellationListener();
+            }
+            reject(new RequestError(url, xhr.status, "ERROR_EVENT", xhr));
         };
         xhr.ontimeout = function onXHRTimeout() {
-            obs.error(new RequestError(url, xhr.status, "TIMEOUT", xhr));
+            if (deregisterCancellationListener !== null) {
+                deregisterCancellationListener();
+            }
+            reject(new RequestError(url, xhr.status, "TIMEOUT", xhr));
         };
-        if (options.sendProgressEvents === true) {
+        if (onProgress !== undefined) {
             xhr.onprogress = function onXHRProgress(event) {
                 var currentTime = performance.now();
-                obs.next({ type: "progress",
-                    value: { url: url,
-                        duration: currentTime - sendingTime,
-                        sendingTime: sendingTime,
-                        currentTime: currentTime,
-                        size: event.loaded,
-                        totalSize: event.total } });
+                onProgress({ url: url, duration: currentTime - sendingTime, sendingTime: sendingTime, currentTime: currentTime, size: event.loaded,
+                    totalSize: event.total });
             };
         }
         xhr.onload = function onXHRLoad(event) {
             if (xhr.readyState === 4) {
+                if (deregisterCancellationListener !== null) {
+                    deregisterCancellationListener();
+                }
                 if (xhr.status >= 200 && xhr.status < 300) {
                     var receivedTime = performance.now();
                     var totalSize = xhr.response instanceof
@@ -103,31 +110,30 @@ function request(options) {
                         responseData = xhr.response;
                     }
                     if (isNullOrUndefined(responseData)) {
-                        obs.error(new RequestError(url, xhr.status, "PARSE_ERROR", xhr));
+                        reject(new RequestError(url, xhr.status, "PARSE_ERROR", xhr));
                         return;
                     }
-                    obs.next({ type: "data-loaded",
-                        value: { status: status_1,
-                            url: _url,
-                            responseType: loadedResponseType,
-                            sendingTime: sendingTime,
-                            receivedTime: receivedTime,
-                            duration: receivedTime - sendingTime,
-                            size: totalSize,
-                            responseData: responseData } });
-                    obs.complete();
+                    resolve({ status: status_1, url: _url,
+                        responseType: loadedResponseType, sendingTime: sendingTime, receivedTime: receivedTime, requestDuration: receivedTime - sendingTime,
+                        size: totalSize, responseData: responseData });
                 }
                 else {
-                    obs.error(new RequestError(url, xhr.status, "ERROR_HTTP_CODE", xhr));
+                    reject(new RequestError(url, xhr.status, "ERROR_HTTP_CODE", xhr));
                 }
             }
         };
         xhr.send();
-        return function () {
-            if (!isNullOrUndefined(xhr) && xhr.readyState !== 4) {
-                xhr.abort();
-            }
-        };
     });
 }
-export default request;
+/**
+ * @param {string} data
+ * @returns {Object|null}
+ */
+function toJSONForIE(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch (e) {
+        return null;
+    }
+}

package/dist/_esm5.processed/utils/rx-from_cancellable_promise.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Observable } from "rxjs";
+import TaskCanceller from "./task_canceller";
+/**
+ * Transform a Promise that can be cancelled (through the usage of a
+ * `TaskCanceller`) to an Observable, while keeping the cancellation logic
+ * between both in sync.
+ *
+ * @example
+ * ```js
+ * const canceller = new TaskCanceller();
+ * fromCancellablePromise(
+ *   canceller,
+ *   () => doSomeCancellableTasks(canceller.signal)
+ * ).subscribe(
+ *   (i) => console.log("Emitted: ", i);
+ *   (e) => console.log("Error: ", e);
+ *   () => console.log("Complete.")
+ * );
+ * ```
+ * @param {Object} canceller
+ * @param {Function} fn
+ * @returns {Observable}
+ */
+export default function fromCancellablePromise<T>(canceller: TaskCanceller, fn: () => Promise<T>): Observable<T>;

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

@@ -0,0 +1,58 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Observable } from "rxjs";
+/**
+ * Transform a Promise that can be cancelled (through the usage of a
+ * `TaskCanceller`) to an Observable, while keeping the cancellation logic
+ * between both in sync.
+ *
+ * @example
+ * ```js
+ * const canceller = new TaskCanceller();
+ * fromCancellablePromise(
+ *   canceller,
+ *   () => doSomeCancellableTasks(canceller.signal)
+ * ).subscribe(
+ *   (i) => console.log("Emitted: ", i);
+ *   (e) => console.log("Error: ", e);
+ *   () => console.log("Complete.")
+ * );
+ * ```
+ * @param {Object} canceller
+ * @param {Function} fn
+ * @returns {Observable}
+ */
+export default function fromCancellablePromise(canceller, fn) {
+    return new Observable(function (obs) {
+        var isUnsubscribedFrom = false;
+        fn().then(function (i) {
+            if (isUnsubscribedFrom) {
+                return;
+            }
+            obs.next(i);
+            obs.complete();
+        }, function (err) {
+            if (isUnsubscribedFrom) {
+                return;
+            }
+            obs.error(err);
+        });
+        return function () {
+            isUnsubscribedFrom = true;
+            canceller.cancel();
+        };
+    });
+}

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { timer as observableTimer, } from "rxjs";
-import { catchError, mergeMap, } from "rxjs/operators";
+import { catchError, mergeMap, timer as observableTimer, } from "rxjs";
 import getFuzzedDelay from "./get_fuzzed_delay";
 import isNullOrUndefined from "./is_null_or_undefined";
 /**

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

@@ -0,0 +1,240 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Class facilitating asynchronous task cancellation.
+ *
+ * This class can be used to notify some code running an asynchronous task (for
+ * example, a request) that is should abort what it is doing (for example, abort
+ * a request when it isn't needed anymore).
+ *
+ * To do that, the code which might ask for cancellation have to create a new
+ * `TaskCanceller`:
+ * ```js
+ * const canceller = new TaskCanceller();
+ * ```
+ *
+ * And has to provide its associated `CancellationSignal` to the code running
+ * the asynchronous task:
+ * ```js
+ * runAsyncTask(canceller.signal);
+ * ```
+ *
+ * In the asynchronous task, the signal can be listened to (see documentation
+ * on `CancellationSignal` for more information):
+ * ```js
+ * function runAsyncTask(cancellationSignal) {
+ *  // Let's say this function returns a Promise (this is not mandatory however)
+ *  return Promise((resolve, reject) => {
+ *    // In this example, we'll even catch the case where an asynchronous task
+ *    // was already cancelled before being called.
+ *    // This ensure that no code will run if that's the case.
+ *    if (cancellationSignal.isCancelled) {
+ *      // Here we're rejecting the CancellationError to notify the caller that
+ *      // this error was due to the task being aborted.
+ *      reject(cancellationSignal.cancellationError);
+ *      return;
+ *    }
+ *
+ *    // Example:
+ *    // performing asynchronous task and registering callbacks on success/failure.
+ *    const myCancellableTask = doSomeAsyncTasks()
+ *      .onFinished(onTaskFinished);
+ *      .onFailed(onTaskFailed);
+ *
+ *    // Run a callback when/if the corresponding `TaskCanceller` was triggered.
+ *    // Run immediately if the TaskCanceller was already triggered.
+ *    const deregisterSignal = cancellationSignal.register(onCancellation);
+ *
+ *    // Callback called on cancellation (if this task was cancelled while the
+ *    // cancellationSignal's listener is still registered).
+ *    // The `error` in argument is linked to that cancellation. It is usually
+ *    // expected that the same Error instance is used when rejecting Promises.
+ *    function onCancellation(error : CancellationError) {
+ *      // abort asynchronous task
+ *      myCancellableTask.cancel();
+ *
+ *      // In this example, reject the current pending Promise
+ *      reject(CancellationError);
+ *    }
+ *
+ *    // Callback called after the asynchronous task has finished with success.
+ *    function onTaskFinished() {
+ *      // Stop listening to the cancellationSignal
+ *      deregisterSignal();
+ *
+ *      // Resolve the Promise
+ *      resolve();
+ *    }
+ *
+ *    // Callback called after the asynchronous task has finished with failure.
+ *    function onTaskFailed(someError : Error) {
+ *      // Stop listening to the cancellationSignal
+ *      deregisterSignal();
+ *
+ *      // Resolve the Promise
+ *      reject(error);
+ *    }
+ *  });
+ * }
+ * ```
+ *
+ * The code asking for cancellation can then trigger a cancellation at any time
+ * (even before the signal was given) and listen to possible CancellationErrors
+ * to know when it was cancelled.
+ * ```js
+ * const canceller = new TaskCanceller();
+ *
+ * runAsyncTask(canceller.signal)
+ *   .then(() => { console.log("Task succeeded!"); )
+ *   .catch((err) => {
+ *      if (TaskCanceller.isCancellationError(err)) {
+ *        console.log("Task cancelled!");
+ *      } else {
+ *        console.log("Task failed:", err);
+ *      }
+ *   });
+ * canceller.cancel(); // Cancel the task, calling registered callbacks
+ * ```
+ * @class TaskCanceller
+ */
+export default class TaskCanceller {
+    /**
+     * `CancellationSignal` that can be given to an async task, so it can be
+     * notified that it should be aborted when this `TaskCanceller` is triggered
+     * (through its `cancel` method).
+     */
+    signal: CancellationSignal;
+    /**
+     * `true` if this `TaskCanceller` has already been triggered.
+     * `false` otherwise.
+     */
+    isUsed: boolean;
+    /**
+     * @private
+     * Internal function called when the `TaskCanceller` is triggered`.
+     */
+    private _trigger;
+    /**
+     * 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.
+     */
+    constructor();
+    /**
+     * "Trigger" the `TaskCanceller`, notify through its associated
+     * `CancellationSignal` (its `signal` property) that a task should be aborted.
+     *
+     * Once called the `TaskCanceller` is permanently triggered.
+     *
+     * 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]
+     */
+    cancel(originError?: 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
+     * `CancellationSignal`.
+     * @param {*} error
+     * @returns {boolean}
+     */
+    static isCancellationError(error: unknown): boolean;
+}
+/**
+ * Class associated to a TaskCanceller allowing to be notified when a task
+ * needs to be aborted.
+ * @class
+ */
+export declare class CancellationSignal {
+    /**
+     * True when the associated `TaskCanceller` was already triggered, meaning
+     * that the current task needs to be aborted.
+     */
+    isCancelled: boolean;
+    /**
+     * Error associated to the cancellation.
+     * 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).
+     *
+     * Always set if `isCancelled` is equal to `true`.
+     */
+    cancellationError: CancellationError | null;
+    /**
+     * @private
+     * Functions called when the corresponding `TaskCanceller` is triggered.
+     * Those should perform all logic allowing to cancel the current task(s)
+     * which depend on this CancellationSignal.
+     */
+    private _listeners;
+    /**
+     * Creates a new CancellationSignal.
+     * /!\ Note: Only a `TaskCanceller` is supposed to be able to create one.
+     * @param {Function} registerToSource - Function called when the task is
+     * cancelled.
+     */
+    constructor(registerToSource: (listener: ICancellationListener) => void);
+    /**
+     * Registers a function that will be called when/if the current task is
+     * cancelled.
+     *
+     * Multiple calls to `register` can be performed to register multiple
+     * callbacks on cancellation associated to the same `CancellationSignal`.
+     *
+     * @param {Function} fn - This function should perform all logic allowing to
+     * abort everything the task is doing.
+     *
+     * It takes in argument the `CancellationError` which was created when the
+     * task was aborted.
+     * You can use this error to notify callers that the task has been aborted,
+     * for example through a rejected Promise.
+     *
+     * @return {Function} - Removes that cancellation listener. You can call this
+     * once you don't want the callback to be triggered anymore (e.g. after the
+     * task succeeded or failed).
+     * You don't need to call that function when cancellation has already been
+     * performed.
+     */
+    register(fn: ICancellationListener): () => void;
+    /**
+     * De-register a function registered through the `register` function.
+     * Do nothing if that function wasn't registered.
+     *
+     * You can call this method when using the return value of `register` is not
+     * practical.
+     * @param {Function} fn
+     */
+    deregister(fn: ICancellationListener): void;
+}
+/**
+ * Helper type allowing a `CancellationSignal` to register to a cancellation asked
+ * by a `TaskCanceller`.
+ */
+export declare type ICancellationListener = (error: CancellationError) => void;
+/**
+ * Error created when a task is cancelled through the TaskCanceller.
+ *
+ * @class CancellationError
+ * @extends Error
+ */
+export declare class CancellationError extends Error {
+    readonly name: "CancellationError";
+    readonly message: string;
+    /**
+     * @param {string} message
+     */
+    constructor();
+}