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

package/dist/_esm5.processed/experimental/tools/createMetaplaylist/get_duration_from_manifest.js

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { map, throwError, } from "rxjs";
+import config from "../../../config";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
 import request from "../../../utils/request/xhr";
 import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
@@ -28,9 +29,7 @@ var iso8601Duration = /^P(([\d.]*)Y)?(([\d.]*)M)?(([\d.]*)D)?T?(([\d.]*)H)?(([\d
  *   2. the second value is a possible error encountered while parsing this
  *      value - set to `null` if no error was encountered.
  * @param {string} val - The value to parse
- * @param {string} displayName - The name of the property. Used for error
- * formatting.
- * @returns {Array.<number | Error | null>}
+ * @returns {number | null}
  */
 function parseDuration(val) {
     if (!isNonEmptyString(val)) {
@@ -69,6 +68,7 @@ function getDurationFromManifest(url, transport) {
     var canceller = new TaskCanceller();
     if (transport === "dash" || transport === "smooth") {
         return fromCancellablePromise(canceller, function () { return request({ url: url, responseType: "document",
+            timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
             cancelSignal: canceller.signal }); }).pipe(map(function (response) {
             var _a;
             var responseData = response.responseData;
@@ -103,6 +103,7 @@ function getDurationFromManifest(url, transport) {
     }
     // metaplaylist
     return fromCancellablePromise(canceller, function () { return request({ url: url, responseType: "text",
+        timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
         cancelSignal: canceller.signal }); }).pipe(map(function (response) {
         var responseData = response.responseData;
         var metaplaylist = JSON.parse(responseData);

package/dist/_esm5.processed/public_types.d.ts

@@ -318,22 +318,39 @@ export interface INetworkConfigOption {
      * request before failing on Error.
      * Set to `Infinity` for an infinite number of requests.
      */
-    manifestRetry?: number;
+    manifestRetry?: number | undefined;
+    /**
+     * Amount of time, in milliseconds, after which a manifest request should be
+     * aborted and optionally retried, depending on the current configuration.
+     *
+     * Setting it to `-1` allows to disable any timeout.
+     * `undefined` means that a default, large, timeout will be used instead.
+     */
+    manifestRequestTimeout?: number | undefined;
     /**
      * The amount of time maximum we should retry a request in general when the
      * user is offline.
      * Set to `Infinity` for an infinite number of requests.
      */
-    offlineRetry?: number;
+    offlineRetry?: number | undefined;
     /**
      * The amount of time maximum we should retry a segment or segment-related
      * request before failing on Error.
      * Set to `Infinity` for an infinite number of requests.
      */
-    segmentRetry?: number;
+    segmentRetry?: number | undefined;
+    /**
+     * Amount of time, in milliseconds, after which a segment request should be
+     * aborted and optionally retried, depending on the current configuration.
+     *
+     * Setting it to `-1` allows to disable any timeout.
+     * `undefined` means that a default, large, timeout will be used instead.
+     */
+    segmentRequestTimeout?: number | undefined;
 }
 export declare type ISegmentLoader = (infos: {
     url: string;
+    timeout: number | undefined;
     manifest: IManifest;
     period: IPeriod;
     adaptation: IAdaptation;
@@ -367,6 +384,8 @@ export declare type IManifestLoader = (url: string | undefined, callbacks: {
     }) => void;
     reject: (err?: Error) => void;
     fallback: () => void;
+}, options: {
+    timeout: number | undefined;
 }) => (() => void) | void;
 /** Options related to a single key system. */
 export interface IKeySystemOption {

package/dist/_esm5.processed/transports/dash/add_segment_integrity_checks_to_loader.js

@@ -35,13 +35,13 @@ import inferSegmentContainer from "../utils/infer_segment_container";
  * @returns {Function}
  */
 export default function addSegmentIntegrityChecks(segmentLoader) {
-    return function (url, content, initialCancelSignal, callbacks) {
+    return function (url, content, loaderOptions, initialCancelSignal, callbacks) {
         return new Promise(function (resolve, reject) {
             var requestCanceller = new TaskCanceller({ cancelOn: initialCancelSignal });
             // Reject the `CancellationError` when `requestCanceller`'s signal emits
             // `stopRejectingOnCancel` here is a function allowing to stop this mechanism
             var stopRejectingOnCancel = requestCanceller.signal.register(reject);
-            segmentLoader(url, content, requestCanceller.signal, __assign(__assign({}, callbacks), { onNewChunk: function (data) {
+            segmentLoader(url, content, loaderOptions, requestCanceller.signal, __assign(__assign({}, callbacks), { onNewChunk: function (data) {
                     try {
                         trowOnIntegrityError(data);
                         callbacks.onNewChunk(data);

package/dist/_esm5.processed/transports/dash/image_pipelines.d.ts

@@ -14,16 +14,17 @@
  * limitations under the License.
  */
 import { CancellationSignal } from "../../utils/task_canceller";
-import { IImageTrackSegmentData, ILoadedImageSegmentFormat, ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded, ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk } from "../types";
+import { IImageTrackSegmentData, ILoadedImageSegmentFormat, ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded, ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk } from "../types";
 /**
  * Loads an image segment.
  * @param {string|null} url
  * @param {Object} content
+ * @param {Object} options
  * @param {Object} cancelSignal
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export declare function imageLoader(url: string | null, content: ISegmentContext, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat>>;
+export declare function imageLoader(url: string | null, content: ISegmentContext, options: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat>>;
 /**
  * Parses an image segment.
  * @param {Object} loadedSegment

package/dist/_esm5.processed/transports/dash/image_pipelines.js

@@ -56,11 +56,12 @@ import takeFirstSet from "../../utils/take_first_set";
  * Loads an image segment.
  * @param {string|null} url
  * @param {Object} content
+ * @param {Object} options
  * @param {Object} cancelSignal
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export function imageLoader(url, content, cancelSignal, callbacks) {
+export function imageLoader(url, content, options, cancelSignal, callbacks) {
     return __awaiter(this, void 0, void 0, function () {
         var segment, data;
         return __generator(this, function (_a) {
@@ -72,6 +73,7 @@ export function imageLoader(url, content, cancelSignal, callbacks) {
                                 resultData: null }];
                     }
                     return [4 /*yield*/, request({ url: url, responseType: "arraybuffer",
+                            timeout: options.timeout,
                             onProgress: callbacks.onProgress, cancelSignal: cancelSignal })];
                 case 1:
                     data = _a.sent();

package/dist/_esm5.processed/transports/dash/init_segment_loader.d.ts

@@ -15,13 +15,14 @@
  */
 import { ISegment } from "../../manifest";
 import { CancellationSignal } from "../../utils/task_canceller";
-import { ISegmentLoaderCallbacks, ISegmentLoaderResultChunkedComplete, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
+import { ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultChunkedComplete, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
 /**
  * Perform a request for an initialization segment, agnostic to the container.
  * @param {string} url
  * @param {Object} segment
+ * @param {Object} options
  * @param {CancellationSignal} cancelSignal
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export default function initSegmentLoader(url: string, segment: ISegment, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<ArrayBuffer | Uint8Array>): Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | Uint8Array> | ISegmentLoaderResultSegmentCreated<ArrayBuffer | Uint8Array> | ISegmentLoaderResultChunkedComplete>;
+export default function initSegmentLoader(url: string, segment: ISegment, options: ISegmentLoaderOptions, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<ArrayBuffer | Uint8Array>): Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | Uint8Array> | ISegmentLoaderResultSegmentCreated<ArrayBuffer | Uint8Array> | ISegmentLoaderResultChunkedComplete>;

package/dist/_esm5.processed/transports/dash/init_segment_loader.js

@@ -20,19 +20,22 @@ import byteRange from "../utils/byte_range";
  * Perform a request for an initialization segment, agnostic to the container.
  * @param {string} url
  * @param {Object} segment
+ * @param {Object} options
  * @param {CancellationSignal} cancelSignal
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export default function initSegmentLoader(url, segment, cancelSignal, callbacks) {
+export default function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
     if (segment.range === undefined) {
-        return request({ url: url, responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+        return request({ url: url, responseType: "arraybuffer",
+            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
             .then(function (data) { return ({ resultType: "segment-loaded",
             resultData: data }); });
     }
     if (segment.indexRange === undefined) {
         return request({ url: url, headers: { Range: byteRange(segment.range) },
-            responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+            responseType: "arraybuffer",
+            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
             .then(function (data) { return ({ resultType: "segment-loaded",
             resultData: data }); });
     }
@@ -40,14 +43,17 @@ export default function initSegmentLoader(url, segment, cancelSignal, callbacks)
     if (segment.range[1] + 1 === segment.indexRange[0]) {
         return request({ url: url, headers: { Range: byteRange([segment.range[0],
                     segment.indexRange[1]]) },
-            responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+            responseType: "arraybuffer",
+            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
             .then(function (data) { return ({ resultType: "segment-loaded",
             resultData: data }); });
     }
     var rangeRequest$ = request({ url: url, headers: { Range: byteRange(segment.range) },
-        responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
+        responseType: "arraybuffer",
+        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
     var indexRequest$ = request({ url: url, headers: { Range: byteRange(segment.indexRange) },
-        responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
+        responseType: "arraybuffer",
+        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
     return Promise.all([rangeRequest$, indexRequest$])
         .then(function (_a) {
         var initData = _a[0], indexData = _a[1];

package/dist/_esm5.processed/transports/dash/low_latency_segment_loader.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { CancellationSignal } from "../../utils/task_canceller";
-import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultChunkedComplete } from "../types";
+import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultChunkedComplete } from "../types";
 /**
  * Load segments through a "chunk" mode (decodable chunk by decodable chunk).
  *
@@ -22,8 +22,9 @@ import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultChunkedCo
  *
  * @param {string} url - URL of the segment to download.
  * @param {Object} content - Context of the segment needed.
+ * @param {Object} options
  * @param {Object} callbacks
  * @param {CancellationSignal} cancelSignal
  * @returns {Promise}
  */
-export default function lowLatencySegmentLoader(url: string, content: ISegmentContext, callbacks: ISegmentLoaderCallbacks<Uint8Array>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultChunkedComplete>;
+export default function lowLatencySegmentLoader(url: string, content: ISegmentContext, options: ISegmentLoaderOptions, callbacks: ISegmentLoaderCallbacks<Uint8Array>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultChunkedComplete>;

package/dist/_esm5.processed/transports/dash/low_latency_segment_loader.js

@@ -24,11 +24,12 @@ import extractCompleteChunks from "./extract_complete_chunks";
  *
  * @param {string} url - URL of the segment to download.
  * @param {Object} content - Context of the segment needed.
+ * @param {Object} options
  * @param {Object} callbacks
  * @param {CancellationSignal} cancelSignal
  * @returns {Promise}
  */
-export default function lowLatencySegmentLoader(url, content, callbacks, cancelSignal) {
+export default function lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal) {
     var segment = content.segment;
     var headers = segment.range !== undefined ? { Range: byteRange(segment.range) } :
         undefined;
@@ -57,7 +58,7 @@ export default function lowLatencySegmentLoader(url, content, callbacks, cancelS
             return;
         }
     }
-    return fetchRequest({ url: url, headers: headers, onData: onData, cancelSignal: cancelSignal })
+    return fetchRequest({ url: url, headers: headers, onData: onData, timeout: options.timeout, cancelSignal: cancelSignal })
         .then(function (res) { return ({ resultType: "chunk-complete",
         resultData: res }); });
 }

package/dist/_esm5.processed/transports/dash/manifest_parser.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import config from "../../config";
 import { formatError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
@@ -105,10 +106,13 @@ export default function generateManifestParser(options) {
             var value = parserResponse.value;
             var externalResources = value.urls.map(function (resourceUrl) {
                 return scheduleRequest(function () {
+                    var defaultTimeout = config.getCurrent().DEFAULT_REQUEST_TIMEOUT;
                     return value.format === "string" ? request({ url: resourceUrl,
-                        responseType: "text", cancelSignal: cancelSignal }) :
+                        responseType: "text",
+                        timeout: defaultTimeout, cancelSignal: cancelSignal }) :
                         request({ url: resourceUrl,
-                            responseType: "arraybuffer", cancelSignal: cancelSignal });
+                            responseType: "arraybuffer",
+                            timeout: defaultTimeout, cancelSignal: cancelSignal });
                 }).then(function (res) {
                     if (value.format === "string") {
                         if (typeof res.responseData !== "string") {

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

@@ -15,17 +15,18 @@
  */
 import { ISegmentLoader as ICustomSegmentLoader } from "../../public_types";
 import { CancellationSignal } from "../../utils/task_canceller";
-import { ILoadedAudioVideoSegmentFormat, ISegmentContext, ISegmentLoader, ISegmentLoaderCallbacks, ISegmentLoaderResultChunkedComplete, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
+import { ILoadedAudioVideoSegmentFormat, ISegmentContext, ISegmentLoader, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultChunkedComplete, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
  * @param {string} url
  * @param {Object} content
  * @param {boolean} lowLatencyMode
+ * @param {Object} options
  * @param {Object} callbacks
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export declare function regularSegmentLoader(url: string, content: ISegmentContext, lowLatencyMode: boolean, callbacks: ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultChunkedComplete>;
+export declare function regularSegmentLoader(url: string, content: ISegmentContext, lowLatencyMode: boolean, options: ISegmentLoaderOptions, callbacks: ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> | ISegmentLoaderResultChunkedComplete>;
 /**
  * @param {Object} config
  * @returns {Function}

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

@@ -26,18 +26,19 @@ import lowLatencySegmentLoader from "./low_latency_segment_loader";
  * @param {string} url
  * @param {Object} content
  * @param {boolean} lowLatencyMode
+ * @param {Object} options
  * @param {Object} callbacks
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export function regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal) {
+export function regularSegmentLoader(url, content, lowLatencyMode, options, callbacks, cancelSignal) {
     if (content.segment.isInit) {
-        return initSegmentLoader(url, content.segment, cancelSignal, callbacks);
+        return initSegmentLoader(url, content.segment, options, cancelSignal, callbacks);
     }
     var containerType = inferSegmentContainer(content.adaptation.type, content.representation);
     if (lowLatencyMode && (containerType === "mp4" || containerType === undefined)) {
         if (fetchIsSupported()) {
-            return lowLatencySegmentLoader(url, content, callbacks, cancelSignal);
+            return lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal);
         }
         else {
             warnOnce("DASH: Your browser does not have the fetch API. You will have " +
@@ -48,7 +49,8 @@ export function regularSegmentLoader(url, content, lowLatencyMode, callbacks, ca
     return request({ url: url, responseType: "arraybuffer",
         headers: segment.range !== undefined ?
             { Range: byteRange(segment.range) } :
-            undefined, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+            undefined,
+        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
         .then(function (data) { return ({ resultType: "segment-loaded",
         resultData: data }); });
 }
@@ -64,26 +66,27 @@ export default function generateSegmentLoader(_a) {
      * @param {Object} content
      * @returns {Observable}
      */
-    function segmentLoader(url, content, cancelSignal, callbacks) {
+    function segmentLoader(url, content, options, cancelSignal, callbacks) {
         if (url == null) {
             return Promise.resolve({ resultType: "segment-created",
                 resultData: null });
         }
         if (lowLatencyMode || customSegmentLoader === undefined) {
-            return regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal);
+            return regularSegmentLoader(url, content, lowLatencyMode, options, callbacks, cancelSignal);
         }
         var args = { adaptation: content.adaptation,
             manifest: content.manifest,
             period: content.period,
             representation: content.representation,
             segment: content.segment,
-            transport: "dash", url: url };
+            transport: "dash",
+            timeout: options.timeout, url: url };
         return new Promise(function (res, rej) {
             /** `true` when the custom segmentLoader should not be active anymore. */
             var hasFinished = false;
             /**
              * Callback triggered when the custom segment loader has a response.
-             * @param {Object} args
+             * @param {Object} _args
              */
             var resolve = function (_args) {
                 if (hasFinished || cancelSignal.isCancelled) {
@@ -132,7 +135,7 @@ export default function generateSegmentLoader(_a) {
                 }
                 hasFinished = true;
                 cancelSignal.deregister(abortCustomLoader);
-                regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal)
+                regularSegmentLoader(url, content, lowLatencyMode, options, callbacks, cancelSignal)
                     .then(res, rej);
             };
             var customCallbacks = { reject: reject, resolve: resolve, progress: progress, fallback: fallback };

package/dist/_esm5.processed/transports/dash/text_loader.js

@@ -32,11 +32,12 @@ export default function generateTextTrackLoader(_a) {
     /**
      * @param {string|null} url
      * @param {Object} content
+     * @param {Object} options
      * @param {Object} cancelSignal
      * @param {Object} callbacks
      * @returns {Promise}
      */
-    function textTrackLoader(url, content, cancelSignal, callbacks) {
+    function textTrackLoader(url, content, options, cancelSignal, callbacks) {
         var adaptation = content.adaptation, representation = content.representation, segment = content.segment;
         var range = segment.range;
         if (url === null) {
@@ -44,13 +45,13 @@ export default function generateTextTrackLoader(_a) {
                 resultData: null });
         }
         if (segment.isInit) {
-            return initSegmentLoader(url, segment, cancelSignal, callbacks);
+            return initSegmentLoader(url, segment, options, cancelSignal, callbacks);
         }
         var containerType = inferSegmentContainer(adaptation.type, representation);
         var seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
         if (lowLatencyMode && seemsToBeMP4) {
             if (fetchIsSupported()) {
-                return lowLatencySegmentLoader(url, content, callbacks, cancelSignal);
+                return lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal);
             }
             else {
                 warnOnce("DASH: Your browser does not have the fetch API. You will have " +
@@ -62,6 +63,7 @@ export default function generateTextTrackLoader(_a) {
                 headers: Array.isArray(range) ?
                     { Range: byteRange(range) } :
                     null,
+                timeout: options.timeout,
                 onProgress: callbacks.onProgress, cancelSignal: cancelSignal })
                 .then(function (data) { return ({ resultType: "segment-loaded",
                 resultData: data }); });
@@ -70,6 +72,7 @@ export default function generateTextTrackLoader(_a) {
             headers: Array.isArray(range) ?
                 { Range: byteRange(range) } :
                 null,
+            timeout: options.timeout,
             onProgress: callbacks.onProgress, cancelSignal: cancelSignal })
             .then(function (data) { return ({ resultType: "segment-loaded",
             resultData: data }); });

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

@@ -16,7 +16,7 @@
 import { ITransportOptions, ITransportPipelines } from "../types";
 /**
  * Returns pipelines used for local Manifest streaming.
- * @param {Object} options
+ * @param {Object} transportOptions
  * @returns {Object}
  */
-export default function getLocalManifestPipelines(options: ITransportOptions): ITransportPipelines;
+export default function getLocalManifestPipelines(transportOptions: ITransportOptions): ITransportPipelines;

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

@@ -26,13 +26,13 @@ import segmentParser from "./segment_parser";
 import textTrackParser from "./text_parser";
 /**
  * Returns pipelines used for local Manifest streaming.
- * @param {Object} options
+ * @param {Object} transportOptions
  * @returns {Object}
  */
-export default function getLocalManifestPipelines(options) {
-    var customManifestLoader = options.manifestLoader;
+export default function getLocalManifestPipelines(transportOptions) {
+    var customManifestLoader = transportOptions.manifestLoader;
     var manifestPipeline = {
-        loadManifest: function (url, cancelSignal) {
+        loadManifest: function (url, loaderOptions, cancelSignal) {
             if (isNullOrUndefined(customManifestLoader)) {
                 throw new Error("A local Manifest is not loadable through regular HTTP(S) " +
                     " calls. You have to set a `manifestLoader` when calling " +
@@ -41,7 +41,7 @@ export default function getLocalManifestPipelines(options) {
             return callCustomManifestLoader(customManifestLoader, function () {
                 throw new Error("Cannot fallback from the `manifestLoader` of a " +
                     "`local` transport");
-            })(url, cancelSignal);
+            })(url, loaderOptions, cancelSignal);
         },
         parseManifest: function (manifestData) {
             var loadedManifest = manifestData.responseData;
@@ -49,7 +49,7 @@ export default function getLocalManifestPipelines(options) {
                 throw new Error("Wrong format for the manifest data");
             }
             var parsed = parseLocalManifest(loadedManifest);
-            var manifest = new Manifest(parsed, options);
+            var manifest = new Manifest(parsed, transportOptions);
             return { manifest: manifest, url: undefined };
         },
     };

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { CancellationSignal } from "../../utils/task_canceller";
-import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultSegmentLoaded } from "../types";
+import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderOptions, ISegmentLoaderResultSegmentLoaded } from "../types";
 /**
  * Generic segment loader for the local Manifest.
  * @param {string | null} _url
@@ -23,4 +23,5 @@ import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultSegmentLo
  * @param {Object} _callbacks
  * @returns {Promise}
  */
-export default function segmentLoader(_url: string | null, content: ISegmentContext, cancelSignal: CancellationSignal, _callbacks: ISegmentLoaderCallbacks<ArrayBuffer | null>): Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>>;
+export default function segmentLoader(_url: string | null, content: ISegmentContext, _loaderOptions: ISegmentLoaderOptions, // TODO use timeout?
+cancelSignal: CancellationSignal, _callbacks: ISegmentLoaderCallbacks<ArrayBuffer | null>): Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>>;

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

@@ -26,7 +26,7 @@ function loadInitSegment(customSegmentLoader, cancelSignal) {
         var hasFinished = false;
         /**
          * Callback triggered when the custom segment loader has a response.
-         * @param {Object} args
+         * @param {Object} _args
          */
         var resolve = function (_args) {
             if (hasFinished || cancelSignal.isCancelled) {
@@ -81,7 +81,7 @@ function loadSegment(segment, customSegmentLoader, cancelSignal) {
         var hasFinished = false;
         /**
          * Callback triggered when the custom segment loader has a response.
-         * @param {Object} args
+         * @param {Object} _args
          */
         var resolve = function (_args) {
             if (hasFinished || cancelSignal.isCancelled) {
@@ -138,7 +138,8 @@ function loadSegment(segment, customSegmentLoader, cancelSignal) {
  * @param {Object} _callbacks
  * @returns {Promise}
  */
-export default function segmentLoader(_url, content, cancelSignal, _callbacks) {
+export default function segmentLoader(_url, content, _loaderOptions, // TODO use timeout?
+cancelSignal, _callbacks) {
     var segment = content.segment;
     var privateInfos = segment.privateInfos;
     if (segment.isInit) {

package/dist/_esm5.processed/transports/metaplaylist/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;
-}): (url: string | undefined, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;
+}): (url: string | undefined, loaderOptions: IManifestLoaderOptions, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;

package/dist/_esm5.processed/transports/metaplaylist/manifest_loader.js

@@ -18,12 +18,15 @@ import callCustomManifestLoader from "../utils/call_custom_manifest_loader";
 /**
  * Manifest loader triggered if there was no custom-defined one in the API.
  * @param {string} url
+ * @param {Object} loaderOptions
+ * @param {Object} cancelSignal
  */
-function regularManifestLoader(url, cancelSignal) {
+function regularManifestLoader(url, loaderOptions, cancelSignal) {
     if (url === undefined) {
         throw new Error("Cannot perform HTTP(s) request. URL not known");
     }
-    return request({ url: url, responseType: "text", cancelSignal: cancelSignal });
+    return request({ url: url, responseType: "text",
+        timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
 }
 /**
  * Generate a manifest loader for the application

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

@@ -24,6 +24,7 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+import config from "../../config";
 import features from "../../features";
 import Manifest from "../../manifest";
 import parseMetaPlaylist from "../../parsers/manifest/metaplaylist";
@@ -106,7 +107,12 @@ export default function (options) {
                         return transport.manifest.parseManifest(data, __assign(__assign({}, parserOptions), { originalUrl: resource.url }), onWarnings, cancelSignal, scheduleRequest);
                     });
                     function loadSubManifest() {
-                        return transport.manifest.loadManifest(resource.url, cancelSignal);
+                        /*
+                         * Whether a ManifestLoader's timeout should be relied on here
+                         * is ambiguous.
+                         */
+                        var manOpts = { timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT };
+                        return transport.manifest.loadManifest(resource.url, manOpts, cancelSignal);
                     }
                 });
                 return Promise.all(loaderProms).then(function (parsedReqs) {
@@ -118,7 +124,6 @@ export default function (options) {
     };
     /**
      * @param {Object} segment
-     * @param {Object} transports
      * @returns {Object}
      */
     function getTransportPipelinesFromSegment(segment) {
@@ -162,11 +167,11 @@ export default function (options) {
             appendWindow: [offsetedWindowStart, offsetedWindowEnd] };
     }
     var audioPipeline = {
-        loadSegment: function (url, content, cancelToken, callbacks) {
+        loadSegment: function (url, content, loaderOptions, cancelToken, callbacks) {
             var segment = content.segment;
             var audio = getTransportPipelinesFromSegment(segment).audio;
             var ogContent = getOriginalContent(segment);
-            return audio.loadSegment(url, ogContent, cancelToken, callbacks);
+            return audio.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
@@ -182,11 +187,11 @@ export default function (options) {
         },
     };
     var videoPipeline = {
-        loadSegment: function (url, content, cancelToken, callbacks) {
+        loadSegment: function (url, content, loaderOptions, cancelToken, callbacks) {
             var segment = content.segment;
             var video = getTransportPipelinesFromSegment(segment).video;
             var ogContent = getOriginalContent(segment);
-            return video.loadSegment(url, ogContent, cancelToken, callbacks);
+            return video.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
@@ -202,11 +207,11 @@ export default function (options) {
         },
     };
     var textTrackPipeline = {
-        loadSegment: function (url, content, cancelToken, callbacks) {
+        loadSegment: function (url, content, loaderOptions, cancelToken, callbacks) {
             var segment = content.segment;
             var text = getTransportPipelinesFromSegment(segment).text;
             var ogContent = getOriginalContent(segment);
-            return text.loadSegment(url, ogContent, cancelToken, callbacks);
+            return text.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;
@@ -222,11 +227,11 @@ export default function (options) {
         },
     };
     var imageTrackPipeline = {
-        loadSegment: function (url, content, cancelToken, callbacks) {
+        loadSegment: function (url, content, loaderOptions, cancelToken, callbacks) {
             var segment = content.segment;
             var image = getTransportPipelinesFromSegment(segment).image;
             var ogContent = getOriginalContent(segment);
-            return image.loadSegment(url, ogContent, cancelToken, callbacks);
+            return image.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
         },
         parseSegment: function (loadedSegment, content, initTimescale) {
             var segment = content.segment;