rx-player 3.28.1-dev.2022083000 → 3.29.0-dev.2022090500

package/dist/_esm5.processed/transports/smooth/pipelines.d.ts

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 import { ITransportOptions, ITransportPipelines } from "../types";
-export default function (options: ITransportOptions): ITransportPipelines;
+export default function (transportOptions: ITransportOptions): ITransportPipelines;

package/dist/_esm5.processed/transports/smooth/pipelines.js

@@ -95,10 +95,10 @@ function addNextSegments(adaptation, nextSegments, dlSegment) {
         }
     }
 }
-export default function (options) {
-    var smoothManifestParser = createSmoothManifestParser(options);
-    var segmentLoader = generateSegmentLoader(options);
-    var manifestLoaderOptions = { customManifestLoader: options.manifestLoader };
+export default function (transportOptions) {
+    var smoothManifestParser = createSmoothManifestParser(transportOptions);
+    var segmentLoader = generateSegmentLoader(transportOptions);
+    var manifestLoaderOptions = { customManifestLoader: transportOptions.manifestLoader };
     var manifestLoader = generateManifestLoader(manifestLoaderOptions, "text");
     var manifestPipeline = {
         // TODO (v4.x.x) Remove that function
@@ -138,9 +138,9 @@ export default function (options) {
                 responseData; // TODO find a way to check if Document?
             var parserResult = smoothManifestParser(documentData, url, manifestReceivedTime);
             var manifest = new Manifest(parserResult, {
-                representationFilter: options.representationFilter,
-                supplementaryImageTracks: options.supplementaryImageTracks,
-                supplementaryTextTracks: options.supplementaryTextTracks,
+                representationFilter: transportOptions.representationFilter,
+                supplementaryImageTracks: transportOptions.supplementaryImageTracks,
+                supplementaryTextTracks: transportOptions.supplementaryTextTracks,
             });
             return { manifest: manifest, url: url };
         },
@@ -154,12 +154,13 @@ export default function (options) {
          * Load a Smooth audio/video segment.
          * @param {string|null} url
          * @param {Object} content
+         * @param {Object} loaderOptions
          * @param {Object} cancelSignal
          * @param {Object} callbacks
          * @returns {Promise}
          */
-        loadSegment: function (url, content, cancelSignal, callbacks) {
-            return segmentLoader(url, content, cancelSignal, callbacks);
+        loadSegment: function (url, content, loaderOptions, cancelSignal, callbacks) {
+            return segmentLoader(url, content, loaderOptions, cancelSignal, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
             var _a, _b;
@@ -213,7 +214,7 @@ export default function (options) {
         },
     };
     var textTrackPipeline = {
-        loadSegment: function (url, content, cancelSignal, callbacks) {
+        loadSegment: function (url, content, loaderOptions, cancelSignal, callbacks) {
             var segment = content.segment, representation = content.representation;
             if (segment.isInit || url === null) {
                 return Promise.resolve({ resultType: "segment-created",
@@ -221,14 +222,16 @@ export default function (options) {
             }
             var isMP4 = isMP4EmbeddedTrack(representation);
             if (!isMP4) {
-                return request({ url: url, responseType: "text", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+                return request({ url: url, responseType: "text",
+                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
                     .then(function (data) { return ({ resultType: "segment-loaded",
                     resultData: data }); });
             }
             else {
-                return request({ url: url, responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+                return request({ url: url, responseType: "arraybuffer",
+                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
                     .then(function (data) {
-                    if (options.checkMediaSegmentIntegrity !== true) {
+                    if (transportOptions.checkMediaSegmentIntegrity !== true) {
                         return { resultType: "segment-loaded",
                             resultData: data };
                     }
@@ -365,7 +368,7 @@ export default function (options) {
         },
     };
     var imageTrackPipeline = {
-        loadSegment: function (url, content, cancelSignal, callbacks) {
+        loadSegment: function (url, content, loaderOptions, cancelSignal, callbacks) {
             return __awaiter(this, void 0, void 0, function () {
                 var data;
                 return __generator(this, function (_a) {
@@ -377,6 +380,7 @@ export default function (options) {
                                         resultData: null }];
                             }
                             return [4 /*yield*/, request({ url: url, responseType: "arraybuffer",
+                                    timeout: loaderOptions.timeout,
                                     onProgress: callbacks.onProgress, cancelSignal: cancelSignal })];
                         case 1:
                             data = _a.sent();

package/dist/_esm5.processed/transports/smooth/segment_loader.d.ts

@@ -15,7 +15,7 @@
  */
 import { ISegmentLoader as ICustomSegmentLoader } from "../../public_types";
 import { CancellationSignal } from "../../utils/task_canceller";
-import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
+import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
 /**
  * Defines the url for the request, load the right loader (custom/default
  * one).
@@ -23,5 +23,5 @@ import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultSegmentCr
 declare const generateSegmentLoader: ({ checkMediaSegmentIntegrity, customSegmentLoader, }: {
     checkMediaSegmentIntegrity?: boolean | undefined;
     customSegmentLoader?: ICustomSegmentLoader | undefined;
-}) => (url: string | null, content: ISegmentContext, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>) => Promise<ISegmentLoaderResultSegmentLoaded<Uint8Array | ArrayBuffer | null> | ISegmentLoaderResultSegmentCreated<Uint8Array | ArrayBuffer | null>>;
+}) => (url: string | null, content: ISegmentContext, loaderOptions: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>) => Promise<ISegmentLoaderResultSegmentLoaded<Uint8Array | ArrayBuffer | null> | ISegmentLoaderResultSegmentCreated<Uint8Array | ArrayBuffer | null>>;
 export default generateSegmentLoader;

package/dist/_esm5.processed/transports/smooth/segment_loader.js

@@ -35,18 +35,19 @@ import { isMP4EmbeddedTrack } from "./utils";
  * Segment loader triggered if there was no custom-defined one in the API.
  * @param {string} url
  * @param {Object} content
+ * @param {Object} loaderOptions
  * @param {Object} callbacks
  * @param {Object} cancelSignal
  * @param {boolean} checkMediaSegmentIntegrity
  * @returns {Promise}
  */
-function regularSegmentLoader(url, content, callbacks, cancelSignal, checkMediaSegmentIntegrity) {
+function regularSegmentLoader(url, content, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity) {
     var headers;
     var range = content.segment.range;
     if (Array.isArray(range)) {
         headers = { Range: byteRange(range) };
     }
-    return request({ url: url, responseType: "arraybuffer", headers: headers, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+    return request({ url: url, responseType: "arraybuffer", headers: headers, timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
         .then(function (data) {
         var isMP4 = isMP4EmbeddedTrack(content.representation);
         if (!isMP4 || checkMediaSegmentIntegrity !== true) {
@@ -65,7 +66,7 @@ function regularSegmentLoader(url, content, callbacks, cancelSignal, checkMediaS
  */
 var generateSegmentLoader = function (_a) {
     var checkMediaSegmentIntegrity = _a.checkMediaSegmentIntegrity, customSegmentLoader = _a.customSegmentLoader;
-    return function (url, content, cancelSignal, callbacks) {
+    return function (url, content, loaderOptions, cancelSignal, callbacks) {
         var segment = content.segment, manifest = content.manifest, period = content.period, adaptation = content.adaptation, representation = content.representation;
         if (segment.isInit) {
             if (segment.privateInfos === undefined ||
@@ -105,9 +106,10 @@ var generateSegmentLoader = function (_a) {
                 resultData: null });
         }
         else {
-            var args_1 = { adaptation: adaptation, manifest: manifest, period: period, representation: representation, segment: segment, transport: "smooth", url: url };
+            var args_1 = { adaptation: adaptation, manifest: manifest, period: period, representation: representation, segment: segment, transport: "smooth",
+                timeout: loaderOptions.timeout, url: url };
             if (typeof customSegmentLoader !== "function") {
-                return regularSegmentLoader(url, content, callbacks, cancelSignal, checkMediaSegmentIntegrity);
+                return regularSegmentLoader(url, content, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity);
             }
             return new Promise(function (res, rej) {
                 /** `true` when the custom segmentLoader should not be active anymore. */
@@ -169,7 +171,7 @@ var generateSegmentLoader = function (_a) {
                     }
                     hasFinished = true;
                     cancelSignal.deregister(abortCustomLoader);
-                    regularSegmentLoader(url, content, callbacks, cancelSignal, checkMediaSegmentIntegrity)
+                    regularSegmentLoader(url, content, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity)
                         .then(res, rej);
                 };
                 var customCallbacks = { reject: reject, resolve: resolve, fallback: fallback, progress: progress };

package/dist/_esm5.processed/transports/types.d.ts

@@ -65,7 +65,7 @@ export interface ITransportManifestPipeline {
      *   - The loading operation failed, most likely due to a request error.
      *     In that case, this Promise will reject with the corresponding Error.
      */
-    loadManifest: (url: string | undefined, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;
+    loadManifest: (url: string | undefined, options: IManifestLoaderOptions, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;
     /**
      * "Parser" of the Manifest pipeline, allowing to parse a loaded Manifest so
      * it can be exploited by the rest of the RxPlayer's logic.
@@ -154,6 +154,19 @@ export interface ITransportManifestPipeline {
      */
     resolveManifestUrl?: (url: string | undefined, cancelSignal: CancellationSignal) => Promise<string | undefined>;
 }
+/**
+ * Options given to the `loadManifest` method of an
+ * `ITransportManifestPipeline` to configure its behavior.
+ */
+export interface IManifestLoaderOptions {
+    /**
+     * Timeout, in milliseconds, after which a manifest request should be aborted
+     * with the corresponding error.
+     *
+     * `undefined` means that no timeout will be enforced.
+     */
+    timeout?: number | undefined;
+}
 /** Functions allowing to load and parse segments of any type. */
 export interface ISegmentPipeline<TLoadedFormat, TParsedSegmentDataFormat> {
     loadSegment: ISegmentLoader<TLoadedFormat>;
@@ -175,7 +188,17 @@ export interface ISegmentPipeline<TLoadedFormat, TParsedSegmentDataFormat> {
  * @returns {Promise.<Object>} - Promise resolving when it has finished loading
  * the segment.
  */
-export declare type ISegmentLoader<TLoadedFormat> = (url: string | null, content: ISegmentContext, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<TLoadedFormat>) => Promise<ISegmentLoaderResultSegmentCreated<TLoadedFormat> | ISegmentLoaderResultSegmentLoaded<TLoadedFormat> | ISegmentLoaderResultChunkedComplete>;
+export declare type ISegmentLoader<TLoadedFormat> = (url: string | null, content: ISegmentContext, options: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<TLoadedFormat>) => Promise<ISegmentLoaderResultSegmentCreated<TLoadedFormat> | ISegmentLoaderResultSegmentLoaded<TLoadedFormat> | ISegmentLoaderResultChunkedComplete>;
+/** Options given to an `ISegmentLoader` to configure its behavior. */
+export interface ISegmentLoaderOptions {
+    /**
+     * Timeout, in milliseconds, after which a segment request should be aborted
+     * with the corresponding error.
+     *
+     * `undefined` means that no timeout will be enforced.
+     */
+    timeout?: number | undefined;
+}
 /**
  * Segment parser function, allowing to parse a chunk (which may be a sub-part
  * of a segment) of any type.

package/dist/_esm5.processed/transports/utils/call_custom_manifest_loader.d.ts

@@ -15,5 +15,5 @@
  */
 import { IManifestLoader, ILoadedManifestFormat } from "../../public_types";
 import { CancellationSignal } from "../../utils/task_canceller";
-import { IRequestedData } from "../types";
-export default function callCustomManifestLoader(customManifestLoader: IManifestLoader, fallbackManifestLoader: (url: string | undefined, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>): (url: string | undefined, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;
+import { IManifestLoaderOptions, IRequestedData } from "../types";
+export default function callCustomManifestLoader(customManifestLoader: IManifestLoader, fallbackManifestLoader: (url: string | undefined, loaderOptions: IManifestLoaderOptions, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>): (url: string | undefined, loaderOptions: IManifestLoaderOptions, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;

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

@@ -15,7 +15,7 @@
  */
 import { CustomLoaderError } from "../../errors";
 export default function callCustomManifestLoader(customManifestLoader, fallbackManifestLoader) {
-    return function (url, cancelSignal) {
+    return function (url, loaderOptions, cancelSignal) {
         return new Promise(function (res, rej) {
             var timeAPIsDelta = Date.now() - performance.now();
             /** `true` when the custom segmentLoader should not be active anymore. */
@@ -67,10 +67,10 @@ export default function callCustomManifestLoader(customManifestLoader, fallbackM
                 }
                 hasFinished = true;
                 cancelSignal.deregister(abortCustomLoader);
-                fallbackManifestLoader(url, cancelSignal).then(res, rej);
+                fallbackManifestLoader(url, loaderOptions, cancelSignal).then(res, rej);
             };
             var callbacks = { reject: reject, resolve: resolve, fallback: fallback };
-            var abort = customManifestLoader(url, callbacks);
+            var abort = customManifestLoader(url, callbacks, { timeout: loaderOptions.timeout });
             cancelSignal.register(abortCustomLoader);
             /**
              * The logic to run when the custom loader is cancelled while pending.

package/dist/_esm5.processed/transports/utils/generate_manifest_loader.d.ts

@@ -15,7 +15,7 @@
  */
 import { IManifestLoader, ILoadedManifestFormat } from "../../public_types";
 import { CancellationSignal } from "../../utils/task_canceller";
-import { IRequestedData } from "../types";
+import { IManifestLoaderOptions, IRequestedData } from "../types";
 /**
  * Generate a manifest loader for the application
  * @param {Function} [customManifestLoader]
@@ -23,4 +23,4 @@ import { IRequestedData } from "../types";
  */
 export default function generateManifestLoader({ customManifestLoader }: {
     customManifestLoader?: IManifestLoader | undefined;
-}, preferredType: "arraybuffer" | "text" | "document"): (url: string | undefined, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;
+}, preferredType: "arraybuffer" | "text" | "document"): (url: string | undefined, loaderOptions: IManifestLoaderOptions, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;

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

@@ -18,11 +18,11 @@ import request from "../../utils/request";
 import callCustomManifestLoader from "./call_custom_manifest_loader";
 /**
  * Manifest loader triggered if there was no custom-defined one in the API.
- * @param {string} url
- * @returns {Observable}
+ * @param {string} preferredType
+ * @returns {Function}
  */
 function generateRegularManifestLoader(preferredType) {
-    return function regularManifestLoader(url, cancelSignal) {
+    return function regularManifestLoader(url, loaderOptions, cancelSignal) {
         if (url === undefined) {
             throw new Error("Cannot perform HTTP(s) request. URL not known");
         }
@@ -31,11 +31,14 @@ function generateRegularManifestLoader(preferredType) {
         // So I wrote that instead, temporarily of course ;)
         switch (preferredType) {
             case "arraybuffer":
-                return request({ url: url, responseType: "arraybuffer", cancelSignal: cancelSignal });
+                return request({ url: url, responseType: "arraybuffer",
+                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
             case "text":
-                return request({ url: url, responseType: "text", cancelSignal: cancelSignal });
+                return request({ url: url, responseType: "text",
+                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
             case "document":
-                return request({ url: url, responseType: "document", cancelSignal: cancelSignal });
+                return request({ url: url, responseType: "document",
+                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
             default:
                 assertUnreachable(preferredType);
         }

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

@@ -49,7 +49,6 @@ 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 config from "../../config";
 import { NetworkErrorTypes, RequestError, } from "../../errors";
 import log from "../../log";
 import isNullOrUndefined from "../is_null_or_undefined";
@@ -90,13 +89,13 @@ export default function fetchRequest(options) {
         }
         abortController.abort();
     }
-    var requestTimeout = isNullOrUndefined(options.timeout) ?
-        config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
-        options.timeout;
-    var timeout = window.setTimeout(function () {
-        timeouted = true;
-        abortFetch();
-    }, requestTimeout);
+    var timeout;
+    if (options.timeout !== undefined) {
+        timeout = window.setTimeout(function () {
+            timeouted = true;
+            abortFetch();
+        }, options.timeout);
+    }
     var deregisterCancelLstnr = options.cancelSignal
         .register(function abortRequest(err) {
         cancellation = err;

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

@@ -112,7 +112,7 @@ export interface IRequestOptions<ResponseType> {
     responseType?: ResponseType | undefined;
     /**
      * Optional timeout, in milliseconds, after which we will cancel a request.
-     * Set to DEFAULT_REQUEST_TIMEOUT by default.
+     * To not set or to set to `undefined` for disable.
      */
     timeout?: number | undefined;
     /**

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

@@ -13,28 +13,36 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../config";
 import { RequestError } from "../../errors";
 import isNonEmptyString from "../is_non_empty_string";
 import isNullOrUndefined from "../is_null_or_undefined";
 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,
         responseType: isNullOrUndefined(options.responseType) ? DEFAULT_RESPONSE_TYPE :
             options.responseType,
-        timeout: isNullOrUndefined(options.timeout) ? DEFAULT_REQUEST_TIMEOUT :
-            options.timeout,
+        timeout: options.timeout,
     };
     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();
         xhr.open("GET", url, true);
-        if (timeout >= 0) {
+        var timeoutId;
+        if (timeout !== undefined) {
             xhr.timeout = timeout;
+            // We've seen on some browser (mainly on some LG TVs), that `xhr.timeout`
+            // was either not supported or did not function properly despite the
+            // browser being recent enough to support it.
+            // That's why we also start a manual timeout. We do this a little later
+            // than the "native one" performed on the xhr assuming that the latter
+            // is more precise, it might also be more efficient.
+            timeoutId = window.setTimeout(function () {
+                clearCancellingProcess();
+                reject(new RequestError(url, xhr.status, "TIMEOUT", xhr));
+            }, timeout + 3000);
         }
         xhr.responseType = responseType;
         if (xhr.responseType === "document") {
@@ -54,6 +62,7 @@ export default function request(options) {
         if (cancelSignal !== undefined) {
             deregisterCancellationListener = cancelSignal
                 .register(function abortRequest(err) {
+                clearCancellingProcess();
                 if (!isNullOrUndefined(xhr) && xhr.readyState !== 4) {
                     xhr.abort();
                 }
@@ -64,15 +73,11 @@ export default function request(options) {
             }
         }
         xhr.onerror = function onXHRError() {
-            if (deregisterCancellationListener !== null) {
-                deregisterCancellationListener();
-            }
+            clearCancellingProcess();
             reject(new RequestError(url, xhr.status, "ERROR_EVENT", xhr));
         };
         xhr.ontimeout = function onXHRTimeout() {
-            if (deregisterCancellationListener !== null) {
-                deregisterCancellationListener();
-            }
+            clearCancellingProcess();
             reject(new RequestError(url, xhr.status, "TIMEOUT", xhr));
         };
         if (onProgress !== undefined) {
@@ -84,9 +89,7 @@ export default function request(options) {
         }
         xhr.onload = function onXHRLoad(event) {
             if (xhr.readyState === 4) {
-                if (deregisterCancellationListener !== null) {
-                    deregisterCancellationListener();
-                }
+                clearCancellingProcess();
                 if (xhr.status >= 200 && xhr.status < 300) {
                     var receivedTime = performance.now();
                     var totalSize = xhr.response instanceof
@@ -122,6 +125,17 @@ export default function request(options) {
             }
         };
         xhr.send();
+        /**
+         * Clear resources and timers created to handle cancellation and timeouts.
+         */
+        function clearCancellingProcess() {
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+            if (deregisterCancellationListener !== null) {
+                deregisterCancellationListener();
+            }
+        }
     });
 }
 /**

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

@@ -233,8 +233,7 @@ export declare class CancellationSignal {
  */
 export declare type ICancellationListener = (error: CancellationError) => void;
 /**
- * Error created when a task is cancelled through the TaskCanceller.
- *
+ * Error created when a task is cancelled.
  * @class CancellationError
  * @extends Error
  */

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

@@ -257,8 +257,7 @@ var CancellationSignal = /** @class */ (function () {
 }());
 export { CancellationSignal };
 /**
- * Error created when a task is cancelled through the TaskCanceller.
- *
+ * Error created when a task is cancelled.
  * @class CancellationError
  * @extends Error
  */