rx-player 4.0.0-dev.2023110700 → 4.0.0-dev.2023120600

package/dist/es2017/parsers/manifest/types.d.ts

@@ -154,6 +154,7 @@ export interface IParsedRepresentation {
     hdrInfo?: IHDRInformation | undefined;
     /** `true` if audio has Dolby Atmos. */
     isSpatialAudio?: boolean | undefined;
+    supplementalCodecs?: string | undefined;
 }
 /** Every possible types an Adaptation can have. */
 export type IParsedAdaptationType = "audio" | "video" | "text";

package/dist/es2017/parsers/manifest/utils/index_helpers.js

@@ -97,7 +97,7 @@ export function getTimescaledRange(start, duration, timescale) {
  * timescaled time.
  * Returns -1 if the given time is lower than the start of the first available
  * segment.
- * @param {Object} index
+ * @param {Object} timeline
  * @param {Number} timeTScaled
  * @returns {Number}
  */

package/dist/es2017/public_types.d.ts

@@ -203,10 +203,20 @@ export type IStartAtOption = {
     percentage: number;
 } | {
     /**
-     * If set, we should begin at this position relative to the content's end,
-     * in seconds.
+     * If set, we should begin at this position relative to the content's maximum
+     * seekable position, in seconds.
      */
     fromLastPosition: number;
+} | {
+    /**
+     * If set, we should begin at this position relative to the content's live
+     * edge if it makes sense, in seconds.
+     *
+     * If the live edge is unknown or if it does not make sense for the current
+     * content, that position is relative to the content's maximum position
+     * instead.
+     */
+    fromLivePosition: number;
 } | {
     /**
      * If set, we should begin at this position relative to the content's start,
@@ -214,40 +224,37 @@ export type IStartAtOption = {
      */
     fromFirstPosition: number;
 };
+export interface RequestRetryParameters {
+    /**
+     * The amount of time maximum we should retry a request before failing on Error.
+     * Set to `Infinity` for an infinite number of requests.
+     */
+    maxRetry?: number | undefined;
+    /**
+     * Amount of time, in milliseconds, after which a request should be
+     * aborted and optionally retried, depending on the maxRetry configuration.
+     *
+     * Setting it to `-1` allows to disable any timeout.
+     * `undefined` means that a default, large, timeout will be used instead.
+     */
+    timeout?: number | undefined;
+    /**
+     * Amount of time, in milliseconds, after which a request that hasn't receive
+     * the headers and status code should be aborted and optionnaly retried,
+     * depending on the maxRetry configuration.
+     */
+    connectionTimeout?: number | undefined;
+}
 /** Value for the `requestConfig` option of the `loadVideo` method. */
 export interface IRequestConfig {
-    manifest?: {
-        /**
-         * The amount of time maximum we should retry a Manifest or Manifest-related
-         * request before failing on Error.
-         * Set to `Infinity` for an infinite number of requests.
-         */
-        maxRetry?: 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.
-         */
-        timeout?: number | undefined;
-    } | undefined;
-    segment?: {
-        /**
-         * 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.
-         */
-        maxRetry?: 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.
-         */
-        timeout?: number | undefined;
-    } | undefined;
+    /**
+     * Defines the retry parameters when requesting manifest
+     */
+    manifest?: RequestRetryParameters | undefined;
+    /**
+     * Defines the retry parameters when requesting a segment
+     */
+    segment?: RequestRetryParameters | undefined;
 }
 export type ISegmentLoader = (
 /** Information on the segment to request */
@@ -808,18 +815,55 @@ export interface ILockedAudioRepresentationsSettings {
     switchingMode?: IAudioRepresentationsSwitchingMode | undefined;
 }
 export interface IAudioTrackSetting {
+    /** `id` of the audio track you want to set. */
     trackId: string;
+    /**
+     * `id` of the Period for which you want that setting applied.
+     * Keeping it undefined means it will apply to the currently-playing Period.
+     */
     periodId?: string | undefined;
+    /**
+     * Behavior wanted when replacing an audio track / Adaptation by another.
+     * @see IAudioTrackSwitchingMode
+     *
+     * Keeping it undefined means that the RxPlayer will automatically select
+     * the most adapted choice.
+     */
     switchingMode?: IAudioTrackSwitchingMode | undefined;
+    /**
+     * Representations (a.k.a. qualities) you want to play in that new track.
+     * Keeping it undefined means that all compatible qualities may be played.
+     */
     lockedRepresentations?: string[] | undefined;
 }
 export interface IVideoTrackSetting {
+    /** `id` of the video track you want to set. */
     trackId: string;
+    /**
+     * `id` of the Period for which you want that setting applied.
+     * Keeping it undefined means it will apply to the currently-playing Period.
+     */
     periodId?: string | undefined;
+    /**
+     * Behavior wanted when replacing an video track / Adaptation by another.
+     * @see IVideoTrackSwitchingMode
+     *
+     * Keeping it undefined means that the RxPlayer will automatically select
+     * the most adapted choice.
+     */
     switchingMode?: IVideoTrackSwitchingMode | undefined;
+    /**
+     * Representations (a.k.a. qualities) you want to play in that new track.
+     * Keeping it undefined means that all compatible qualities may be played.
+     */
     lockedRepresentations?: string[] | undefined;
 }
 export interface ITextTrackSetting {
+    /** `id` of the text track you want to set. */
     trackId: string;
+    /**
+     * `id` of the Period for which you want that setting applied.
+     * Keeping it undefined means it will apply to the currently-playing Period.
+     */
     periodId?: string | undefined;
 }

package/dist/es2017/transports/dash/init_segment_loader.js

@@ -30,6 +30,7 @@ export default function initSegmentLoader(url, segment, options, cancelSignal, c
         return request({ url,
             responseType: "arraybuffer",
             timeout: options.timeout,
+            connectionTimeout: options.connectionTimeout,
             cancelSignal,
             onProgress: callbacks.onProgress })
             .then(data => ({ resultType: "segment-loaded",
@@ -40,6 +41,7 @@ export default function initSegmentLoader(url, segment, options, cancelSignal, c
             headers: { Range: byteRange(segment.range) },
             responseType: "arraybuffer",
             timeout: options.timeout,
+            connectionTimeout: options.connectionTimeout,
             cancelSignal,
             onProgress: callbacks.onProgress })
             .then(data => ({ resultType: "segment-loaded",
@@ -52,6 +54,7 @@ export default function initSegmentLoader(url, segment, options, cancelSignal, c
                     segment.indexRange[1]]) },
             responseType: "arraybuffer",
             timeout: options.timeout,
+            connectionTimeout: options.connectionTimeout,
             cancelSignal,
             onProgress: callbacks.onProgress })
             .then(data => ({ resultType: "segment-loaded",
@@ -61,12 +64,14 @@ export default function initSegmentLoader(url, segment, options, cancelSignal, c
         headers: { Range: byteRange(segment.range) },
         responseType: "arraybuffer",
         timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout,
         cancelSignal,
         onProgress: callbacks.onProgress });
     const indexRequest$ = request({ url,
         headers: { Range: byteRange(segment.indexRange) },
         responseType: "arraybuffer",
         timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout,
         cancelSignal,
         onProgress: callbacks.onProgress });
     return Promise.all([rangeRequest$, indexRequest$])

package/dist/es2017/transports/dash/manifest_parser.js

@@ -110,13 +110,16 @@ export default function generateManifestParser(options) {
             const externalResources = value.urls.map(resourceUrl => {
                 return scheduleRequest(() => {
                     const defaultTimeout = config.getCurrent().DEFAULT_REQUEST_TIMEOUT;
+                    const defaultConnectionTimeout = config.getCurrent().DEFAULT_CONNECTION_TIMEOUT;
                     return value.format === "string" ? request({ url: resourceUrl,
                         responseType: "text",
                         timeout: defaultTimeout,
+                        connectionTimeout: defaultConnectionTimeout,
                         cancelSignal }) :
                         request({ url: resourceUrl,
                             responseType: "arraybuffer",
                             timeout: defaultTimeout,
+                            connectionTimeout: defaultConnectionTimeout,
                             cancelSignal });
                 }).then((res) => {
                     if (value.format === "string") {

package/dist/es2017/transports/dash/segment_loader.js

@@ -53,6 +53,7 @@ export function regularSegmentLoader(url, context, lowLatencyMode, options, call
             { Range: byteRange(segment.range) } :
             undefined,
         timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout,
         cancelSignal,
         onProgress: callbacks.onProgress })
         .then((data) => ({ resultType: "segment-loaded",

package/dist/es2017/transports/dash/text_loader.js

@@ -66,6 +66,7 @@ export default function generateTextTrackLoader({ lowLatencyMode, checkMediaSegm
                     { Range: byteRange(range) } :
                     null,
                 timeout: options.timeout,
+                connectionTimeout: options.connectionTimeout,
                 onProgress: callbacks.onProgress,
                 cancelSignal })
                 .then((data) => ({ resultType: "segment-loaded",
@@ -77,6 +78,7 @@ export default function generateTextTrackLoader({ lowLatencyMode, checkMediaSegm
                 { Range: byteRange(range) } :
                 null,
             timeout: options.timeout,
+            connectionTimeout: options.connectionTimeout,
             onProgress: callbacks.onProgress,
             cancelSignal })
             .then((data) => ({ resultType: "segment-loaded",

package/dist/es2017/transports/metaplaylist/manifest_loader.js

@@ -28,6 +28,7 @@ function regularManifestLoader(url, loaderOptions, cancelSignal) {
     return request({ url,
         responseType: "text",
         timeout: loaderOptions.timeout,
+        connectionTimeout: loaderOptions.connectionTimeout,
         cancelSignal });
 }
 /**

package/dist/es2017/transports/metaplaylist/pipelines.js

@@ -107,7 +107,10 @@ export default function (options) {
                          * Whether a ManifestLoader's timeout should be relied on here
                          * is ambiguous.
                          */
-                        const manOpts = { timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT };
+                        const manOpts = {
+                            timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
+                            connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
+                        };
                         return transport.manifest.loadManifest(resource.url, manOpts, cancelSignal);
                     }
                 });

package/dist/es2017/transports/smooth/pipelines.js

@@ -133,6 +133,7 @@ export default function (transportOptions) {
                 return request({ url,
                     responseType: "text",
                     timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout,
                     cancelSignal,
                     onProgress: callbacks.onProgress })
                     .then((data) => ({ resultType: "segment-loaded",
@@ -142,6 +143,7 @@ export default function (transportOptions) {
                 return request({ url,
                     responseType: "arraybuffer",
                     timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout,
                     cancelSignal,
                     onProgress: callbacks.onProgress })
                     .then((data) => {

package/dist/es2017/transports/smooth/segment_loader.js

@@ -40,6 +40,7 @@ function regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSign
         responseType: "arraybuffer",
         headers,
         timeout: loaderOptions.timeout,
+        connectionTimeout: loaderOptions.connectionTimeout,
         cancelSignal,
         onProgress: callbacks.onProgress })
         .then((data) => {

package/dist/es2017/transports/types.d.ts

@@ -135,6 +135,12 @@ export interface IManifestLoaderOptions {
      * `undefined` means that no timeout will be enforced.
      */
     timeout?: number | undefined;
+    /**
+     * Connection timeout, in milliseconds, after which the request is canceled
+     * if the responses headers has not being received.
+     * Do not set or set to "undefined" to disable it.
+     */
+    connectionTimeout?: number | undefined;
 }
 /** Functions allowing to load and parse segments of any type. */
 export interface ISegmentPipeline<TLoadedFormat, TParsedSegmentDataFormat> {
@@ -168,6 +174,12 @@ export interface ISegmentLoaderOptions {
      * `undefined` means that no timeout will be enforced.
      */
     timeout?: number | undefined;
+    /**
+     * Connection timeout, in milliseconds, after which the request is canceled
+     * if the responses headers has not being received.
+     * Do not set or set to "undefined" to disable it.
+     */
+    connectionTimeout?: number | undefined;
 }
 /**
  * Segment parser function, allowing to parse a chunk (which may be a sub-part

package/dist/es2017/transports/utils/generate_manifest_loader.js

@@ -34,16 +34,19 @@ function generateRegularManifestLoader(preferredType) {
                 return request({ url,
                     responseType: "arraybuffer",
                     timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout,
                     cancelSignal });
             case "text":
                 return request({ url,
                     responseType: "text",
                     timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout,
                     cancelSignal });
             case "document":
                 return request({ url,
                     responseType: "document",
                     timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout,
                     cancelSignal });
             default:
                 assertUnreachable(preferredType);

package/dist/es2017/utils/queue_microtask.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof queueMicrotask;
+export default _default;

package/dist/es2017/utils/queue_microtask.js

@@ -0,0 +1,5 @@
+export default typeof queueMicrotask === "function" ?
+    queueMicrotask :
+    function queueMicrotaskPonyfill(cb) {
+        Promise.resolve().then(cb, () => cb());
+    };

package/dist/es2017/utils/request/fetch.d.ts

@@ -67,6 +67,12 @@ export interface IFetchOptions {
      * if not all data has been received yet.
      */
     timeout?: number | undefined;
+    /**
+     * Optional connection timeout, in milliseconds, after which the request is canceled
+     * if the responses headers has not being received.
+     * Do not set or set to "undefined" to disable it.
+     */
+    connectionTimeout?: number | undefined;
 }
 export default function fetchRequest(options: IFetchOptions): Promise<IFetchedStreamComplete>;
 /**

package/dist/es2017/utils/request/fetch.js

@@ -40,7 +40,8 @@ export default function fetchRequest(options) {
     }
     log.debug("Fetch: Called with URL", options.url);
     let cancellation = null;
-    let timeouted = false;
+    let isTimedOut = false;
+    let isConnectionTimedOut = false;
     const sendingTime = getMonotonicTimeStamp();
     const abortController = !isNullOrUndefined(_AbortController) ? new _AbortController() :
         null;
@@ -55,13 +56,26 @@ export default function fetchRequest(options) {
         }
         abortController.abort();
     }
-    let timeout;
+    let timeoutId;
     if (options.timeout !== undefined) {
-        timeout = setTimeout(() => {
-            timeouted = true;
+        timeoutId = setTimeout(() => {
+            isTimedOut = true;
+            if (connectionTimeoutId !== undefined) {
+                clearTimeout(connectionTimeoutId);
+            }
             abortFetch();
         }, options.timeout);
     }
+    let connectionTimeoutId;
+    if (options.connectionTimeout !== undefined) {
+        connectionTimeoutId = setTimeout(() => {
+            isConnectionTimedOut = true;
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+            abortFetch();
+        }, options.connectionTimeout);
+    }
     const deregisterCancelLstnr = options.cancelSignal
         .register(function abortRequest(err) {
         cancellation = err;
@@ -74,8 +88,8 @@ export default function fetchRequest(options) {
     fetchOpts.signal = !isNullOrUndefined(abortController) ? abortController.signal :
         null;
     return fetch(options.url, fetchOpts).then((response) => {
-        if (!isNullOrUndefined(timeout)) {
-            clearTimeout(timeout);
+        if (connectionTimeoutId !== undefined) {
+            clearTimeout(connectionTimeoutId);
         }
         if (response.status >= 300) {
             log.warn("Fetch: Request HTTP Error", response.status, response.url);
@@ -108,6 +122,9 @@ export default function fetchRequest(options) {
                 return readBufferAndSendEvents();
             }
             else if (data.done) {
+                if (timeoutId !== undefined) {
+                    clearTimeout(timeoutId);
+                }
                 deregisterCancelLstnr();
                 const receivedTime = getMonotonicTimeStamp();
                 const requestDuration = receivedTime - sendingTime;
@@ -125,8 +142,12 @@ export default function fetchRequest(options) {
             throw cancellation;
         }
         deregisterCancelLstnr();
-        if (timeouted) {
-            log.warn("Fetch: Request timeouted.");
+        if (isTimedOut) {
+            log.warn("Fetch: Request timed out.");
+            throw new RequestError(options.url, 0, NetworkErrorTypes.TIMEOUT);
+        }
+        else if (isConnectionTimedOut) {
+            log.warn("Fetch: Request connection timed out.");
             throw new RequestError(options.url, 0, NetworkErrorTypes.TIMEOUT);
         }
         else if (err instanceof RequestError) {

package/dist/es2017/utils/request/xhr.d.ts

@@ -18,14 +18,14 @@ import { CancellationSignal } from "../task_canceller";
  * Perform an HTTP request, according to the options given.
  *
  * Several errors can be rejected. Namely:
- *   - RequestErrorTypes.TIMEOUT_ERROR: the request timeouted (took too long to
- *     respond).
- *   - RequestErrorTypes.PARSE_ERROR: the browser APIs used to parse the
+ *   - NetworkErrorTypes.TIMEOUT: the request timed out (took too long)
+ *
+ *   - NetworkErrorTypes.PARSE_ERROR: the browser APIs used to parse the
  *                                    data failed.
- *   - RequestErrorTypes.ERROR_HTTP_CODE: the HTTP code at the time of reception
+ *   - NetworkErrorTypes.ERROR_HTTP_CODE: the HTTP code at the time of reception
  *                                        was not in the 200-299 (included)
  *                                        range.
- *   - RequestErrorTypes.ERROR_EVENT: The XHR had an error event before the
+ *   - NetworkErrorTypes.ERROR_EVENT: The XHR had an error event before the
  *                                    response could be fetched.
  * @param {Object} options
  * @returns {Promise.<Object>}
@@ -50,6 +50,12 @@ export interface IRequestOptions<ResponseType> {
      * To not set or to set to `undefined` for disable.
      */
     timeout?: number | undefined;
+    /**
+     * Optional connection timeout, in milliseconds, after which the request is canceled
+     * if the responses headers has not being received.
+     * Do not set or set to "undefined" to disable it.
+     */
+    connectionTimeout?: 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

package/dist/es2017/utils/request/xhr.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { RequestError } from "../../errors";
+import { NetworkErrorTypes, RequestError } from "../../errors";
 import isNonEmptyString from "../is_non_empty_string";
 import isNullOrUndefined from "../is_null_or_undefined";
 import getMonotonicTimeStamp from "../monotonic_timestamp";
@@ -25,10 +25,11 @@ export default function request(options) {
         responseType: isNullOrUndefined(options.responseType) ? DEFAULT_RESPONSE_TYPE :
             options.responseType,
         timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout,
     };
     return new Promise((resolve, reject) => {
         const { onProgress, cancelSignal } = options;
-        const { url, headers, responseType, timeout } = requestOptions;
+        const { url, headers, responseType, timeout, connectionTimeout } = requestOptions;
         const xhr = new XMLHttpRequest();
         xhr.open("GET", url, true);
         let timeoutId;
@@ -42,9 +43,19 @@ export default function request(options) {
             // is more precise, it might also be more efficient.
             timeoutId = setTimeout(() => {
                 clearCancellingProcess();
-                reject(new RequestError(url, xhr.status, "TIMEOUT"));
+                reject(new RequestError(url, xhr.status, NetworkErrorTypes.TIMEOUT));
             }, timeout + 3000);
         }
+        let connectionTimeoutId;
+        if (connectionTimeout !== undefined) {
+            connectionTimeoutId = setTimeout(() => {
+                clearCancellingProcess();
+                if (xhr.readyState !== XMLHttpRequest.DONE) {
+                    xhr.abort();
+                }
+                reject(new RequestError(url, xhr.status, NetworkErrorTypes.TIMEOUT));
+            }, connectionTimeout);
+        }
         xhr.responseType = responseType;
         if (xhr.responseType === "document") {
             xhr.overrideMimeType("text/xml");
@@ -64,7 +75,7 @@ export default function request(options) {
             deregisterCancellationListener = cancelSignal
                 .register(function abortRequest(err) {
                 clearCancellingProcess();
-                if (!isNullOrUndefined(xhr) && xhr.readyState !== 4) {
+                if (xhr.readyState !== XMLHttpRequest.DONE) {
                     xhr.abort();
                 }
                 reject(err);
@@ -75,12 +86,19 @@ export default function request(options) {
         }
         xhr.onerror = function onXHRError() {
             clearCancellingProcess();
-            reject(new RequestError(url, xhr.status, "ERROR_EVENT"));
+            reject(new RequestError(url, xhr.status, NetworkErrorTypes.ERROR_EVENT));
         };
         xhr.ontimeout = function onXHRTimeout() {
             clearCancellingProcess();
-            reject(new RequestError(url, xhr.status, "TIMEOUT"));
+            reject(new RequestError(url, xhr.status, NetworkErrorTypes.TIMEOUT));
         };
+        if (connectionTimeout !== undefined) {
+            xhr.onreadystatechange = function clearConnectionTimeout() {
+                if (xhr.readyState >= XMLHttpRequest.HEADERS_RECEIVED) {
+                    clearTimeout(connectionTimeoutId);
+                }
+            };
+        }
         if (onProgress !== undefined) {
             xhr.onprogress = function onXHRProgress(event) {
                 const currentTime = getMonotonicTimeStamp();
@@ -93,7 +111,7 @@ export default function request(options) {
             };
         }
         xhr.onload = function onXHRLoad(event) {
-            if (xhr.readyState === 4) {
+            if (xhr.readyState === XMLHttpRequest.DONE) {
                 clearCancellingProcess();
                 if (xhr.status >= 200 && xhr.status < 300) {
                     const receivedTime = getMonotonicTimeStamp();
@@ -117,7 +135,7 @@ export default function request(options) {
                         responseData = xhr.response;
                     }
                     if (isNullOrUndefined(responseData)) {
-                        reject(new RequestError(url, xhr.status, "PARSE_ERROR"));
+                        reject(new RequestError(url, xhr.status, NetworkErrorTypes.PARSE_ERROR));
                         return;
                     }
                     resolve({ status,
@@ -130,7 +148,7 @@ export default function request(options) {
                         responseData });
                 }
                 else {
-                    reject(new RequestError(url, xhr.status, "ERROR_HTTP_CODE"));
+                    reject(new RequestError(url, xhr.status, NetworkErrorTypes.ERROR_HTTP_CODE));
                 }
             }
         };
@@ -142,6 +160,9 @@ export default function request(options) {
             if (timeoutId !== undefined) {
                 clearTimeout(timeoutId);
             }
+            if (connectionTimeoutId !== undefined) {
+                clearTimeout(connectionTimeoutId);
+            }
             if (deregisterCancellationListener !== null) {
                 deregisterCancellationListener();
             }