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

package/dist/commonjs/parsers/manifest/smooth/representation_index.js

@@ -20,7 +20,6 @@ var log_1 = require("../../../log");
 var assert_1 = require("../../../utils/assert");
 var monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
 var index_helpers_1 = require("../utils/index_helpers");
-var is_segment_still_available_1 = require("../utils/is_segment_still_available");
 var tokens_1 = require("./utils/tokens");
 /**
  * @param {Number} start
@@ -270,7 +269,7 @@ var SmoothRepresentationIndex = /** @class */ (function () {
     SmoothRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
         var _a;
         (0, assert_1.default)(start <= end);
-        if (this.isFinished()) {
+        if (this.isStillAwaitingFutureSegments()) {
             return false;
         }
         var lastAvailablePosition = this.getLastAvailablePosition();
@@ -307,7 +306,24 @@ var SmoothRepresentationIndex = /** @class */ (function () {
         }
         this._refreshTimeline();
         var _a = this._sharedSmoothTimeline, timeline = _a.timeline, timescale = _a.timescale;
-        return (0, is_segment_still_available_1.default)(segment, timeline, timescale, 0);
+        for (var i = 0; i < timeline.length; i++) {
+            var tSegment = timeline[i];
+            var tSegmentTime = tSegment.start / timescale;
+            if (tSegmentTime > segment.time) {
+                return false; // We went over it without finding it
+            }
+            else if (tSegmentTime === segment.time) {
+                return true;
+            }
+            else { // tSegment.start < segment.time
+                if (tSegment.repeatCount >= 0 && tSegment.duration !== undefined) {
+                    var timeDiff = tSegmentTime - tSegment.start;
+                    var repeat = (timeDiff / tSegment.duration) - 1;
+                    return repeat % 1 === 0 && repeat <= tSegment.repeatCount;
+                }
+            }
+        }
+        return false;
     };
     /**
      * @param {Error} error
@@ -341,9 +357,9 @@ var SmoothRepresentationIndex = /** @class */ (function () {
         this._sharedSmoothTimeline.update(newIndex._sharedSmoothTimeline);
     };
     /**
-     * Returns `true` if the last segments in this index have already been
+     * Returns `false` if the last segments in this index have already been
      * generated.
-     * Returns `false` if the index is still waiting on future segments to be
+     * Returns `true` if the index is still waiting on future segments to be
      * generated.
      *
      * For Smooth, it should only depend on whether the content is a live content
@@ -351,8 +367,8 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * TODO What about Smooth live content that finishes at some point?
      * @returns {boolean}
      */
-    SmoothRepresentationIndex.prototype.isFinished = function () {
-        return !this._isLive;
+    SmoothRepresentationIndex.prototype.isStillAwaitingFutureSegments = function () {
+        return this._isLive;
     };
     /**
      * @returns {Boolean}
@@ -367,8 +383,8 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
      * after `currentSegment`.
      * @param {Array.<Object>} nextSegments - The segment information parsed.
-     * @param {Object} segment - Information on the segment which contained that
-     * new segment information.
+     * @param {Object} currentSegment - Information on the segment which contained
+     * that new segment information.
      */
     SmoothRepresentationIndex.prototype.addPredictedSegments = function (nextSegments, currentSegment) {
         this._sharedSmoothTimeline.addPredictedSegments(nextSegments, currentSegment);

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

@@ -105,7 +105,7 @@ exports.getTimescaledRange = getTimescaledRange;
  * 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/commonjs/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/commonjs/transports/dash/init_segment_loader.js

@@ -46,14 +46,16 @@ var byte_range_1 = require("../utils/byte_range");
 function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
     if (segment.range === undefined) {
         return (0, request_1.default)({ url: url, responseType: "arraybuffer",
-            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+            timeout: options.timeout,
+            connectionTimeout: options.connectionTimeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
             .then(function (data) { return ({ resultType: "segment-loaded",
             resultData: data }); });
     }
     if (segment.indexRange === undefined) {
         return (0, request_1.default)({ url: url, headers: { Range: (0, byte_range_1.default)(segment.range) },
             responseType: "arraybuffer",
-            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+            timeout: options.timeout,
+            connectionTimeout: options.connectionTimeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
             .then(function (data) { return ({ resultType: "segment-loaded",
             resultData: data }); });
     }
@@ -62,16 +64,19 @@ function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
         return (0, request_1.default)({ url: url, headers: { Range: (0, byte_range_1.default)([segment.range[0],
                     segment.indexRange[1]]) },
             responseType: "arraybuffer",
-            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+            timeout: options.timeout,
+            connectionTimeout: options.connectionTimeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
             .then(function (data) { return ({ resultType: "segment-loaded",
             resultData: data }); });
     }
     var rangeRequest$ = (0, request_1.default)({ url: url, headers: { Range: (0, byte_range_1.default)(segment.range) },
         responseType: "arraybuffer",
-        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
+        timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
     var indexRequest$ = (0, request_1.default)({ url: url, headers: { Range: (0, byte_range_1.default)(segment.indexRange) },
         responseType: "arraybuffer",
-        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
+        timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
     return Promise.all([rangeRequest$, indexRequest$])
         .then(function (_a) {
         var _b = __read(_a, 2), initData = _b[0], indexData = _b[1];

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

@@ -109,12 +109,15 @@ function generateManifestParser(options) {
             var externalResources = value.urls.map(function (resourceUrl) {
                 return scheduleRequest(function () {
                     var defaultTimeout = config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT;
+                    var defaultConnectionTimeout = config_1.default.getCurrent().DEFAULT_CONNECTION_TIMEOUT;
                     return value.format === "string" ? (0, request_1.default)({ url: resourceUrl,
                         responseType: "text",
-                        timeout: defaultTimeout, cancelSignal: cancelSignal }) :
+                        timeout: defaultTimeout,
+                        connectionTimeout: defaultConnectionTimeout, cancelSignal: cancelSignal }) :
                         (0, request_1.default)({ url: resourceUrl,
                             responseType: "arraybuffer",
-                            timeout: defaultTimeout, cancelSignal: cancelSignal });
+                            timeout: defaultTimeout,
+                            connectionTimeout: defaultConnectionTimeout, cancelSignal: cancelSignal });
                 }).then(function (res) {
                     if (value.format === "string") {
                         if (typeof res.responseData !== "string") {

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

@@ -54,7 +54,8 @@ function regularSegmentLoader(url, context, lowLatencyMode, options, callbacks,
         headers: segment.range !== undefined ?
             { Range: (0, byte_range_1.default)(segment.range) } :
             undefined,
-        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+        timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
         .then(function (data) { return ({ resultType: "segment-loaded",
         resultData: data }); });
 }

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

@@ -68,6 +68,7 @@ function generateTextTrackLoader(_a) {
                     { Range: (0, byte_range_1.default)(range) } :
                     null,
                 timeout: options.timeout,
+                connectionTimeout: options.connectionTimeout,
                 onProgress: callbacks.onProgress, cancelSignal: cancelSignal })
                 .then(function (data) { return ({ resultType: "segment-loaded",
                 resultData: data }); });
@@ -77,6 +78,7 @@ function generateTextTrackLoader(_a) {
                 { Range: (0, byte_range_1.default)(range) } :
                 null,
             timeout: options.timeout,
+            connectionTimeout: options.connectionTimeout,
             onProgress: callbacks.onProgress, cancelSignal: cancelSignal })
             .then(function (data) { return ({ resultType: "segment-loaded",
             resultData: data }); });

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

@@ -28,7 +28,8 @@ function regularManifestLoader(url, loaderOptions, cancelSignal) {
         throw new Error("Cannot perform HTTP(s) request. URL not known");
     }
     return (0, request_1.default)({ url: url, responseType: "text",
-        timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
+        timeout: loaderOptions.timeout,
+        connectionTimeout: loaderOptions.connectionTimeout, cancelSignal: cancelSignal });
 }
 /**
  * Generate a manifest loader for the application

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

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

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

@@ -139,13 +139,15 @@ function default_1(transportOptions) {
             var isMP4 = (0, is_mp4_embedded_track_1.default)(context.mimeType);
             if (!isMP4) {
                 return (0, request_1.default)({ url: url, responseType: "text",
-                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+                    timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
                     .then(function (data) { return ({ resultType: "segment-loaded",
                     resultData: data }); });
             }
             else {
                 return (0, request_1.default)({ url: url, responseType: "arraybuffer",
-                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+                    timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
                     .then(function (data) {
                     if (transportOptions.checkMediaSegmentIntegrity !== true) {
                         return { resultType: "segment-loaded",

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

@@ -49,7 +49,8 @@ function regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSign
     if (Array.isArray(range)) {
         headers = { Range: (0, byte_range_1.default)(range) };
     }
-    return (0, request_1.default)({ url: url, responseType: "arraybuffer", headers: headers, timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+    return (0, request_1.default)({ url: url, responseType: "arraybuffer", headers: headers, timeout: loaderOptions.timeout,
+        connectionTimeout: loaderOptions.connectionTimeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
         .then(function (data) {
         var isMP4 = (0, is_mp4_embedded_track_1.default)(context.mimeType);
         if (!isMP4 || checkMediaSegmentIntegrity !== true) {

package/dist/commonjs/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/commonjs/transports/utils/generate_manifest_loader.js

@@ -34,13 +34,16 @@ function generateRegularManifestLoader(preferredType) {
         switch (preferredType) {
             case "arraybuffer":
                 return (0, request_1.default)({ url: url, responseType: "arraybuffer",
-                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
+                    timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout, cancelSignal: cancelSignal });
             case "text":
                 return (0, request_1.default)({ url: url, responseType: "text",
-                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
+                    timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout, cancelSignal: cancelSignal });
             case "document":
                 return (0, request_1.default)({ url: url, responseType: "document",
-                    timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
+                    timeout: loaderOptions.timeout,
+                    connectionTimeout: loaderOptions.connectionTimeout, cancelSignal: cancelSignal });
             default:
                 (0, assert_unreachable_1.default)(preferredType);
         }

package/dist/commonjs/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/commonjs/utils/request/fetch.js

@@ -79,7 +79,8 @@ function fetchRequest(options) {
     }
     log_1.default.debug("Fetch: Called with URL", options.url);
     var cancellation = null;
-    var timeouted = false;
+    var isTimedOut = false;
+    var isConnectionTimedOut = false;
     var sendingTime = (0, monotonic_timestamp_1.default)();
     var abortController = !(0, is_null_or_undefined_1.default)(_AbortController) ? new _AbortController() :
         null;
@@ -94,13 +95,26 @@ function fetchRequest(options) {
         }
         abortController.abort();
     }
-    var timeout;
+    var timeoutId;
     if (options.timeout !== undefined) {
-        timeout = setTimeout(function () {
-            timeouted = true;
+        timeoutId = setTimeout(function () {
+            isTimedOut = true;
+            if (connectionTimeoutId !== undefined) {
+                clearTimeout(connectionTimeoutId);
+            }
             abortFetch();
         }, options.timeout);
     }
+    var connectionTimeoutId;
+    if (options.connectionTimeout !== undefined) {
+        connectionTimeoutId = setTimeout(function () {
+            isConnectionTimedOut = true;
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+            abortFetch();
+        }, options.connectionTimeout);
+    }
     var deregisterCancelLstnr = options.cancelSignal
         .register(function abortRequest(err) {
         cancellation = err;
@@ -113,8 +127,8 @@ function fetchRequest(options) {
     fetchOpts.signal = !(0, is_null_or_undefined_1.default)(abortController) ? abortController.signal :
         null;
     return fetch(options.url, fetchOpts).then(function (response) {
-        if (!(0, is_null_or_undefined_1.default)(timeout)) {
-            clearTimeout(timeout);
+        if (connectionTimeoutId !== undefined) {
+            clearTimeout(connectionTimeoutId);
         }
         if (response.status >= 300) {
             log_1.default.warn("Fetch: Request HTTP Error", response.status, response.url);
@@ -147,6 +161,9 @@ function fetchRequest(options) {
                                 return [2 /*return*/, readBufferAndSendEvents()];
                             }
                             else if (data.done) {
+                                if (timeoutId !== undefined) {
+                                    clearTimeout(timeoutId);
+                                }
                                 deregisterCancelLstnr();
                                 receivedTime = (0, monotonic_timestamp_1.default)();
                                 requestDuration = receivedTime - sendingTime;
@@ -163,8 +180,12 @@ function fetchRequest(options) {
             throw cancellation;
         }
         deregisterCancelLstnr();
-        if (timeouted) {
-            log_1.default.warn("Fetch: Request timeouted.");
+        if (isTimedOut) {
+            log_1.default.warn("Fetch: Request timed out.");
+            throw new errors_1.RequestError(options.url, 0, errors_1.NetworkErrorTypes.TIMEOUT);
+        }
+        else if (isConnectionTimedOut) {
+            log_1.default.warn("Fetch: Request connection timed out.");
             throw new errors_1.RequestError(options.url, 0, errors_1.NetworkErrorTypes.TIMEOUT);
         }
         else if (err instanceof errors_1.RequestError) {

package/dist/commonjs/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/commonjs/utils/request/xhr.js

@@ -27,10 +27,11 @@ function request(options) {
         responseType: (0, is_null_or_undefined_1.default)(options.responseType) ? DEFAULT_RESPONSE_TYPE :
             options.responseType,
         timeout: options.timeout,
+        connectionTimeout: options.connectionTimeout,
     };
     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 url = requestOptions.url, headers = requestOptions.headers, responseType = requestOptions.responseType, timeout = requestOptions.timeout, connectionTimeout = requestOptions.connectionTimeout;
         var xhr = new XMLHttpRequest();
         xhr.open("GET", url, true);
         var timeoutId;
@@ -44,9 +45,19 @@ function request(options) {
             // is more precise, it might also be more efficient.
             timeoutId = setTimeout(function () {
                 clearCancellingProcess();
-                reject(new errors_1.RequestError(url, xhr.status, "TIMEOUT"));
+                reject(new errors_1.RequestError(url, xhr.status, errors_1.NetworkErrorTypes.TIMEOUT));
             }, timeout + 3000);
         }
+        var connectionTimeoutId;
+        if (connectionTimeout !== undefined) {
+            connectionTimeoutId = setTimeout(function () {
+                clearCancellingProcess();
+                if (xhr.readyState !== XMLHttpRequest.DONE) {
+                    xhr.abort();
+                }
+                reject(new errors_1.RequestError(url, xhr.status, errors_1.NetworkErrorTypes.TIMEOUT));
+            }, connectionTimeout);
+        }
         xhr.responseType = responseType;
         if (xhr.responseType === "document") {
             xhr.overrideMimeType("text/xml");
@@ -66,7 +77,7 @@ function request(options) {
             deregisterCancellationListener = cancelSignal
                 .register(function abortRequest(err) {
                 clearCancellingProcess();
-                if (!(0, is_null_or_undefined_1.default)(xhr) && xhr.readyState !== 4) {
+                if (xhr.readyState !== XMLHttpRequest.DONE) {
                     xhr.abort();
                 }
                 reject(err);
@@ -77,12 +88,19 @@ function request(options) {
         }
         xhr.onerror = function onXHRError() {
             clearCancellingProcess();
-            reject(new errors_1.RequestError(url, xhr.status, "ERROR_EVENT"));
+            reject(new errors_1.RequestError(url, xhr.status, errors_1.NetworkErrorTypes.ERROR_EVENT));
         };
         xhr.ontimeout = function onXHRTimeout() {
             clearCancellingProcess();
-            reject(new errors_1.RequestError(url, xhr.status, "TIMEOUT"));
+            reject(new errors_1.RequestError(url, xhr.status, errors_1.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) {
                 var currentTime = (0, monotonic_timestamp_1.default)();
@@ -91,7 +109,7 @@ 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) {
                     var receivedTime = (0, monotonic_timestamp_1.default)();
@@ -115,7 +133,7 @@ function request(options) {
                         responseData = xhr.response;
                     }
                     if ((0, is_null_or_undefined_1.default)(responseData)) {
-                        reject(new errors_1.RequestError(url, xhr.status, "PARSE_ERROR"));
+                        reject(new errors_1.RequestError(url, xhr.status, errors_1.NetworkErrorTypes.PARSE_ERROR));
                         return;
                     }
                     resolve({ status: status_1, url: _url,
@@ -123,7 +141,7 @@ function request(options) {
                         size: totalSize, responseData: responseData });
                 }
                 else {
-                    reject(new errors_1.RequestError(url, xhr.status, "ERROR_HTTP_CODE"));
+                    reject(new errors_1.RequestError(url, xhr.status, errors_1.NetworkErrorTypes.ERROR_HTTP_CODE));
                 }
             }
         };
@@ -135,6 +153,9 @@ function request(options) {
             if (timeoutId !== undefined) {
                 clearTimeout(timeoutId);
             }
+            if (connectionTimeoutId !== undefined) {
+                clearTimeout(connectionTimeoutId);
+            }
             if (deregisterCancellationListener !== null) {
                 deregisterCancellationListener();
             }