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

package/src/parsers/manifest/dash/wasm-parser/rs/processor/attributes.rs

@@ -87,6 +87,7 @@ pub fn report_adaptation_set_attrs(e: &quick_xml::events::BytesStart) {
                 b"bitstreamSwitching" => BitstreamSwitching.try_report_as_bool(&attr),
                 b"audioSamplingRate" => AudioSamplingRate.try_report_as_string(&attr),
                 b"codecs" => Codecs.try_report_as_string(&attr),
+                b"scte214:supplementalCodecs" => SupplementalCodecs.try_report_as_string(&attr),
                 b"profiles" => Profiles.try_report_as_string(&attr),
                 b"segmentProfiles" => SegmentProfiles.try_report_as_string(&attr),
                 b"mimeType" => MimeType.try_report_as_string(&attr),
@@ -116,6 +117,7 @@ pub fn report_representation_attrs(tag_bs: &quick_xml::events::BytesStart) {
                 b"audioSamplingRate" => AudioSamplingRate.try_report_as_string(&attr),
                 b"bandwidth" => Bitrate.try_report_as_u64(&attr),
                 b"codecs" => Codecs.try_report_as_string(&attr),
+                b"scte214:supplementalCodecs" => SupplementalCodecs.try_report_as_string(&attr),
                 b"codingDependency" => CodingDependency.try_report_as_bool(&attr),
                 b"frameRate" => FrameRate.try_report_as_maybe_division(&attr),
                 b"height" => Height.try_report_as_u64(&attr),

package/src/parsers/manifest/dash/wasm-parser/ts/generators/AdaptationSet.ts

@@ -287,6 +287,10 @@ export function generateAdaptationSetAttrParser(
         adaptationAttrs.codecs =
           parseString(textDecoder, linearMemory.buffer, ptr, len);
         break;
+      case AttributeName.SupplementalCodecs:
+        adaptationAttrs.supplementalCodecs =
+          parseString(textDecoder, linearMemory.buffer, ptr, len);
+        break;
       case AttributeName.Profiles:
         adaptationAttrs.profiles =
           parseString(textDecoder, linearMemory.buffer, ptr, len);

package/src/parsers/manifest/dash/wasm-parser/ts/generators/Representation.ts

@@ -165,6 +165,10 @@ export function generateRepresentationAttrParser(
         representationAttrs.codecs =
           parseString(textDecoder, linearMemory.buffer, ptr, len);
         break;
+      case AttributeName.SupplementalCodecs:
+        representationAttrs.supplementalCodecs =
+        parseString(textDecoder, linearMemory.buffer, ptr, len);
+        break;
       case AttributeName.CodingDependency:
         representationAttrs.codingDependency =
           new DataView(linearMemory.buffer).getUint8(0) === 0;

package/src/parsers/manifest/dash/wasm-parser/ts/types.ts

@@ -293,4 +293,6 @@ export const enum AttributeName {
 
   // SegmentTemplate
   EndNumber = 76, // f64
+
+  SupplementalCodecs = 77, // String
 }

package/src/parsers/manifest/local/representation_index.ts

@@ -149,7 +149,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
    * @returns {boolean|undefined}
    */
   awaitSegmentBetween(start: number, end: number): boolean | undefined {
-    if (this.isFinished()) {
+    if (this.isStillAwaitingFutureSegments()) {
       return false;
     }
     if (this._index.incomingRanges === undefined) {
@@ -173,8 +173,8 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
     return true;
   }
 
-  isFinished() : boolean {
-    return this._index.isFinished;
+  isStillAwaitingFutureSegments() : boolean {
+    return !this._index.isFinished;
   }
 
   /**

package/src/parsers/manifest/metaplaylist/representation_index.ts

@@ -203,8 +203,8 @@ export default class MetaRepresentationIndex implements IRepresentationIndex {
   /**
    * @returns {Boolean}
    */
-  public isFinished() : boolean {
-    return this._wrappedIndex.isFinished();
+  public isStillAwaitingFutureSegments() : boolean {
+    return this._wrappedIndex.isStillAwaitingFutureSegments();
   }
 
   /**

package/src/parsers/manifest/smooth/representation_index.ts

@@ -27,7 +27,6 @@ import {
   checkDiscontinuity,
   getIndexSegmentEnd,
 } from "../utils/index_helpers";
-import isSegmentStillAvailable from "../utils/is_segment_still_available";
 import SharedSmoothSegmentTimeline, {
   IIndexSegment,
 } from "./shared_smooth_segment_timeline";
@@ -423,7 +422,7 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    */
   awaitSegmentBetween(start: number, end: number): boolean | undefined {
     assert(start <= end);
-    if (this.isFinished()) {
+    if (this.isStillAwaitingFutureSegments()) {
       return false;
     }
     const lastAvailablePosition = this.getLastAvailablePosition();
@@ -462,7 +461,22 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
     }
     this._refreshTimeline();
     const { timeline, timescale } = this._sharedSmoothTimeline;
-    return isSegmentStillAvailable(segment, timeline, timescale, 0);
+    for (let i = 0; i < timeline.length; i++) {
+      const tSegment = timeline[i];
+      const 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) {
+          const timeDiff = tSegmentTime - tSegment.start;
+          const repeat = (timeDiff / tSegment.duration) - 1;
+          return repeat % 1 === 0 && repeat <= tSegment.repeatCount;
+        }
+      }
+    }
+    return false;
   }
 
   /**
@@ -500,9 +514,9 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
   }
 
   /**
-   * 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
@@ -510,8 +524,8 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * TODO What about Smooth live content that finishes at some point?
    * @returns {boolean}
    */
-  isFinished() : boolean {
-    return !this._isLive;
+  isStillAwaitingFutureSegments() : boolean {
+    return this._isLive;
   }
 
   /**
@@ -529,8 +543,8 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * 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.
    */
   addPredictedSegments(
     nextSegments : Array<{ duration : number; time : number; timescale : number }>,

package/src/parsers/manifest/types.ts

@@ -160,6 +160,8 @@ 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. */

package/src/parsers/manifest/utils/__tests__/get_first_time_from_adaptations.test.ts

@@ -30,7 +30,7 @@ function generateRepresentationIndex(
     awaitSegmentBetween() : undefined { return ; },
     checkDiscontinuity() : number | null { return null; },
     isSegmentStillAvailable() : undefined { return ; },
-    isFinished() { return false; },
+    isStillAwaitingFutureSegments() { return true; },
     canBeOutOfSyncError() : true { return true; },
     isInitialized() : true { return true; },
     initialize() : void { return ; },

package/src/parsers/manifest/utils/__tests__/get_last_time_from_adaptation.test.ts

@@ -30,7 +30,7 @@ function generateRepresentationIndex(
     awaitSegmentBetween() : undefined { return ; },
     checkDiscontinuity() : number | null { return null; },
     isSegmentStillAvailable() : undefined { return ; },
-    isFinished() { return false; },
+    isStillAwaitingFutureSegments() { return true; },
     isInitialized() : true { return true; },
     initialize() : void { return ; },
     addPredictedSegments() : void { return ; },

package/src/parsers/manifest/utils/index_helpers.ts

@@ -136,7 +136,7 @@ export function 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/src/public_types.ts

@@ -255,10 +255,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,
@@ -267,40 +277,38 @@ 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 = (
@@ -949,20 +957,57 @@ export interface ILockedAudioRepresentationsSettings {
 }
 
 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/src/transports/dash/init_segment_loader.ts

@@ -50,6 +50,7 @@ export default function initSegmentLoader(
     return request({ url,
                      responseType: "arraybuffer",
                      timeout: options.timeout,
+                     connectionTimeout: options.connectionTimeout,
                      cancelSignal,
                      onProgress: callbacks.onProgress })
       .then(data => ({ resultType: "segment-loaded",
@@ -61,6 +62,7 @@ export default function initSegmentLoader(
                      headers: { Range: byteRange(segment.range) },
                      responseType: "arraybuffer",
                      timeout: options.timeout,
+                     connectionTimeout: options.connectionTimeout,
                      cancelSignal,
                      onProgress: callbacks.onProgress })
       .then(data => ({ resultType: "segment-loaded",
@@ -74,6 +76,7 @@ export default function initSegmentLoader(
                                                   segment.indexRange[1] ]) },
                      responseType: "arraybuffer",
                      timeout: options.timeout,
+                     connectionTimeout: options.connectionTimeout,
                      cancelSignal,
                      onProgress: callbacks.onProgress })
       .then(data => ({ resultType: "segment-loaded",
@@ -84,12 +87,14 @@ export default function initSegmentLoader(
                                   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 });
 

package/src/transports/dash/manifest_parser.ts

@@ -151,14 +151,20 @@ export default function generateManifestParser(
       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/src/transports/dash/segment_loader.ts

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

package/src/transports/dash/text_loader.ts

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

package/src/transports/metaplaylist/manifest_loader.ts

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

package/src/transports/metaplaylist/pipelines.ts

@@ -177,7 +177,10 @@ export default function(options : ITransportOptions): ITransportPipelines {
              * 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/src/transports/smooth/pipelines.ts

@@ -203,6 +203,7 @@ export default function(transportOptions : ITransportOptions) : ITransportPipeli
         return request({ url,
                          responseType: "text",
                          timeout: loaderOptions.timeout,
+                         connectionTimeout: loaderOptions.connectionTimeout,
                          cancelSignal,
                          onProgress: callbacks.onProgress })
           .then((data) => ({ resultType: "segment-loaded" as const,
@@ -211,6 +212,7 @@ export default function(transportOptions : ITransportOptions) : ITransportPipeli
         return request({ url,
                          responseType: "arraybuffer",
                          timeout: loaderOptions.timeout,
+                         connectionTimeout: loaderOptions.connectionTimeout,
                          cancelSignal,
                          onProgress: callbacks.onProgress })
           .then((data) => {

package/src/transports/smooth/segment_loader.ts

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

package/src/transports/types.ts

@@ -169,6 +169,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. */
@@ -217,6 +223,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;
 }
 
 /**

package/src/transports/utils/generate_manifest_loader.ts

@@ -57,16 +57,19 @@ function generateRegularManifestLoader(
         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/src/utils/queue_microtask.ts

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

package/src/utils/request/fetch.ts

@@ -95,6 +95,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;
 }
 
 
@@ -128,7 +134,8 @@ export default function fetchRequest(
 
   log.debug("Fetch: Called with URL", options.url);
   let cancellation : CancellationError | null = null;
-  let timeouted = false;
+  let isTimedOut = false;
+  let isConnectionTimedOut = false;
   const sendingTime = getMonotonicTimeStamp();
   const abortController: AbortController | null =
     !isNullOrUndefined(_AbortController) ? new _AbortController() :
@@ -146,14 +153,28 @@ export default function fetchRequest(
     abortController.abort();
   }
 
-  let timeout : number | undefined;
+  let timeoutId : number | undefined;
   if (options.timeout !== undefined) {
-    timeout = setTimeout(() => {
-      timeouted = true;
+    timeoutId = setTimeout(() => {
+      isTimedOut = true;
+      if (connectionTimeoutId !== undefined) {
+        clearTimeout(connectionTimeoutId);
+      }
       abortFetch();
     }, options.timeout);
   }
 
+  let connectionTimeoutId: number | undefined;
+  if (options.connectionTimeout !== undefined) {
+    connectionTimeoutId = setTimeout(() => {
+      isConnectionTimedOut = true;
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+      abortFetch();
+    }, options.connectionTimeout);
+  }
+
   const deregisterCancelLstnr = options.cancelSignal
     .register(function abortRequest(err : CancellationError) {
       cancellation = err;
@@ -170,8 +191,8 @@ export default function fetchRequest(
     options.url,
     fetchOpts
   ).then((response : Response) : Promise<IFetchedStreamComplete> => {
-    if (!isNullOrUndefined(timeout)) {
-      clearTimeout(timeout);
+    if (connectionTimeoutId !== undefined) {
+      clearTimeout(connectionTimeoutId);
     }
     if (response.status >= 300) {
       log.warn("Fetch: Request HTTP Error", response.status, response.url);
@@ -212,6 +233,9 @@ export default function fetchRequest(
         options.onData(dataInfo);
         return readBufferAndSendEvents();
       } else if (data.done) {
+        if (timeoutId !== undefined) {
+          clearTimeout(timeoutId);
+        }
         deregisterCancelLstnr();
         const receivedTime = getMonotonicTimeStamp();
         const requestDuration = receivedTime - sendingTime;
@@ -229,8 +253,11 @@ export default function fetchRequest(
       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) {
       throw err;