rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/utils/request/fetch.ts

@@ -14,9 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-} from "rxjs";
 import config from "../../config";
 import {
   NetworkErrorTypes,
@@ -24,37 +21,79 @@ import {
 } from "../../errors";
 import log from "../../log";
 import isNullOrUndefined from "../is_null_or_undefined";
-
-export interface IDataChunk {
-  type : "data-chunk";
-  value : {
-    currentTime : number;
-    duration : number;
-    chunkSize : number;
-    size : number;
-    sendingTime : number;
-    url : string;
-    totalSize? : number;
-    chunk: ArrayBuffer;
-  };
+import {
+  CancellationError,
+  CancellationSignal,
+} from "../task_canceller";
+
+/** Object returned by `fetchRequest` after the fetch operation succeeded. */
+export interface IFetchedStreamComplete {
+  /** Duration of the whole request, in milliseconds. */
+  requestDuration : number;
+  /** Result of `performance.now()` at the time the request was received. */
+  receivedTime : number;
+  /** Result of `performance.now()` at the time the request was started. */
+  sendingTime : number;
+  /** Size of the entire emitted data, in bytes. */
+  size : number;
+  /** HTTP status of the request performed. */
+  status : number;
+  /** URL of the recuperated data (post-redirection if one). */
+  url : string;
 }
 
-export interface IDataComplete {
-  type : "data-complete";
-  value : {
-    duration : number;
-    receivedTime : number;
-    sendingTime : number;
-    size : number;
-    status : number;
-    url : string;
-  };
+/** Object emitted by `fetchRequest` when a new chunk of the data is available. */
+export interface IFetchedDataObject {
+  /** Result of `performance.now()` at the time this data was recuperated. */
+  currentTime : number;
+  /** Duration of the request until `currentTime`, in milliseconds. */
+  duration : number;
+  /** Size in bytes of the data emitted as `chunk`. */
+  chunkSize : number;
+  /** Cumulated size of the received data by the request until now. */
+  size : number;
+  /** Result of `performance.now()` at the time the request began. */
+  sendingTime : number;
+  /** URL of the recuperated data (post-redirection if one). */
+  url : string;
+  /**
+   * Value of the "Content-Length" header, which should (yet also might not be)
+   * the size of the complete data that will be fetched.
+   */
+  totalSize : number | undefined;
+  /**
+   * Current available chunk, which might only be a sub-part of the whole
+   * data.
+   * To retrieve the whole data, all `chunk` received from `fetchRequest` can be
+   * concatenated.
+   */
+  chunk : ArrayBuffer;
 }
 
+/** Options for the `fetchRequest` utils function. */
 export interface IFetchOptions {
+  /** URL you want to perform the HTTP GET request on. */
   url : string;
-  headers? : { [ header: string ] : string }|null;
-  timeout? : number;
+  /**
+   * Callback called as new data is available.
+   * This callback might be called multiple times with chunks of the complete
+   * data until the fetch operation is finished.
+   */
+  onData : (data : IFetchedDataObject) => void;
+  /**
+   * Signal allowing to cancel the fetch operation.
+   * If cancellation happens while the request is pending, `fetchRequest` will
+   * reject with the corresponding `CancellationError`.
+   */
+  cancelSignal : CancellationSignal;
+  /** Optional headers for the HTTP GET request perfomed by `fetchRequest`. */
+  headers? : { [ header: string ] : string } | undefined | null;
+  /**
+   * Optional timeout for the HTTP GET request perfomed by `fetchRequest`.
+   * This timeout is just enabled until the HTTP response from the server, even
+   * if not all data has been received yet.
+   */
+  timeout? : number | undefined;
 }
 
 const { DEFAULT_REQUEST_TIMEOUT } = config;
@@ -70,9 +109,9 @@ const _AbortController : IAbortControllerConstructor|null =
     AbortController :
     null;
 
-function fetchRequest(
+export default function fetchRequest(
   options : IFetchOptions
-) : Observable< IDataChunk | IDataComplete > {
+) : Promise<IFetchedStreamComplete> {
   let headers : Headers | { [key : string ] : string } | undefined;
   if (!isNullOrUndefined(options.headers)) {
     if (isNullOrUndefined(_Headers)) {
@@ -87,127 +126,118 @@ function fetchRequest(
     }
   }
 
-  return new Observable((obs) => {
-    log.debug("Fetch: Called with URL", options.url);
-    let hasAborted = false;
-    let timeouted = false;
-    let isDone = false;
-    const sendingTime = performance.now();
-    const abortController: AbortController | null =
-      !isNullOrUndefined(_AbortController) ? new _AbortController() :
-                                             null;
-
-    /**
-     * Abort current fetchRequest by triggering AbortController signal.
-     * @returns {void}
-     */
-    function abortRequest(): void {
-      if (!isDone) {
-        if (!isNullOrUndefined(abortController)) {
-          abortController.abort();
-          return;
-        }
-        log.warn("Fetch: AbortController API not available.");
-      }
+  log.debug("Fetch: Called with URL", options.url);
+  let cancellation : CancellationError | null = null;
+  let timeouted = false;
+  const sendingTime = performance.now();
+  const abortController: AbortController | null =
+    !isNullOrUndefined(_AbortController) ? new _AbortController() :
+                                           null;
+
+  /**
+   * Abort current fetchRequest by triggering AbortController signal.
+   * @returns {void}
+   */
+  function abortFetch(): void {
+    if (isNullOrUndefined(abortController)) {
+      log.warn("Fetch: AbortController API not available.");
+      return;
     }
+    abortController.abort();
+  }
 
-    const requestTimeout = isNullOrUndefined(options.timeout) ?
-      DEFAULT_REQUEST_TIMEOUT :
-      options.timeout;
-    const timeout = window.setTimeout(() => {
-      timeouted = true;
-      abortRequest();
-    }, requestTimeout);
-
-    fetch(options.url,
-          { headers,
-            method: "GET",
-            signal: !isNullOrUndefined(abortController) ? abortController.signal :
-                                                          undefined }
-    ).then((response) => {
-      if (!isNullOrUndefined(timeout)) {
-        clearTimeout(timeout);
-      }
-      if (response.status >= 300) {
-        log.warn("Fetch: Request HTTP Error", response);
-        obs.error(new RequestError(response.url,
-                                   response.status,
-                                   NetworkErrorTypes.ERROR_HTTP_CODE));
-        return undefined;
-      }
-
-      if (isNullOrUndefined(response.body)) {
-        obs.error(new RequestError(response.url,
-                                   response.status,
-                                   NetworkErrorTypes.PARSE_ERROR));
-        return undefined;
-      }
+  const requestTimeout = isNullOrUndefined(options.timeout) ?
+    DEFAULT_REQUEST_TIMEOUT :
+    options.timeout;
+  const timeout = window.setTimeout(() => {
+    timeouted = true;
+    abortFetch();
+  }, requestTimeout);
+
+  const deregisterCancelLstnr = options.cancelSignal
+    .register(function abortRequest(err : CancellationError) {
+      cancellation = err;
+      abortFetch();
+    });
 
-      const contentLengthHeader = response.headers.get("Content-Length");
-      const contentLength = !isNullOrUndefined(contentLengthHeader) &&
-                            !isNaN(+contentLengthHeader) ? +contentLengthHeader :
-                                                           undefined;
-      const reader = response.body.getReader();
-      let size = 0;
+  const fetchOpts : RequestInit = { method: "GET" };
+  if (headers !== undefined) {
+    fetchOpts.headers = headers;
+  }
+  fetchOpts.signal = !isNullOrUndefined(abortController) ? abortController.signal :
+                                                           null;
+  return fetch(
+    options.url,
+    fetchOpts
+  ).then((response : Response) : Promise<IFetchedStreamComplete> => {
+    if (!isNullOrUndefined(timeout)) {
+      clearTimeout(timeout);
+    }
+    if (response.status >= 300) {
+      log.warn("Fetch: Request HTTP Error", response);
+      throw new RequestError(response.url,
+                             response.status,
+                             NetworkErrorTypes.ERROR_HTTP_CODE);
+    }
 
-      return readBufferAndSendEvents();
+    if (isNullOrUndefined(response.body)) {
+      throw new RequestError(response.url,
+                             response.status,
+                             NetworkErrorTypes.PARSE_ERROR);
+    }
 
-      async function readBufferAndSendEvents() : Promise<undefined> {
-        const data = await reader.read();
-
-        if (!data.done && !isNullOrUndefined(data.value)) {
-          size += data.value.byteLength;
-          const currentTime = performance.now();
-          const dataChunk = { type: "data-chunk" as const,
-                              value: { url: response.url,
-                                       currentTime,
-                                       duration: currentTime - sendingTime,
-                                       sendingTime,
-                                       chunkSize: data.value.byteLength,
-                                       chunk: data.value.buffer,
-                                       size,
-                                       totalSize: contentLength } };
-          obs.next(dataChunk);
-          return readBufferAndSendEvents();
-        } else if (data.done) {
-          const receivedTime = performance.now();
-          const duration = receivedTime - sendingTime;
-          isDone = true;
-          obs.next({ type: "data-complete" as const,
-                     value: { duration,
-                              receivedTime,
-                              sendingTime,
-                              size,
-                              status: response.status,
-                              url: response.url } });
-          obs.complete();
-        }
+    const contentLengthHeader = response.headers.get("Content-Length");
+    const contentLength = !isNullOrUndefined(contentLengthHeader) &&
+                          !isNaN(+contentLengthHeader) ? +contentLengthHeader :
+                                                         undefined;
+    const reader = response.body.getReader();
+    let size = 0;
+
+    return readBufferAndSendEvents();
+
+    async function readBufferAndSendEvents() : Promise<IFetchedStreamComplete> {
+      const data = await reader.read();
+
+      if (!data.done && !isNullOrUndefined(data.value)) {
+        size += data.value.byteLength;
+        const currentTime = performance.now();
+        const dataInfo = { url: response.url,
+                           currentTime,
+                           duration: currentTime - sendingTime,
+                           sendingTime,
+                           chunkSize: data.value.byteLength,
+                           chunk: data.value.buffer,
+                           size,
+                           totalSize: contentLength };
+        options.onData(dataInfo);
+        return readBufferAndSendEvents();
+      } else if (data.done) {
+        deregisterCancelLstnr();
+        const receivedTime = performance.now();
+        const requestDuration = receivedTime - sendingTime;
+        return { requestDuration,
+                 receivedTime,
+                 sendingTime,
+                 size,
+                 status: response.status,
+                 url: response.url };
       }
-    }).catch((err : unknown) => {
-      if (hasAborted) {
-        log.debug("Fetch: Request aborted.");
-        return;
-      }
-      if (timeouted) {
-        log.warn("Fetch: Request timeouted.");
-        obs.error(new RequestError(options.url,
-                                   0,
-                                   NetworkErrorTypes.TIMEOUT));
-        return;
-      }
-      log.warn("Fetch: Request Error", err instanceof Error ?
-                                         err.toString() :
-                                         "");
-      obs.error(new RequestError(options.url,
-                                 0,
-                                 NetworkErrorTypes.ERROR_EVENT));
-      return;
-    });
-
-    return () => {
-      hasAborted = true;
-      abortRequest();
-    };
+      return readBufferAndSendEvents();
+    }
+  }).catch((err : unknown) => {
+    if (cancellation !== null) {
+      throw cancellation;
+    }
+    deregisterCancelLstnr();
+    if (timeouted) {
+      log.warn("Fetch: Request timeouted.");
+      throw new RequestError(options.url, 0, NetworkErrorTypes.TIMEOUT);
+    } else if (err instanceof RequestError) {
+      throw err;
+    }
+    log.warn("Fetch: Request Error", err instanceof Error ? err.toString() :
+                                                            "");
+    throw new RequestError(options.url, 0, NetworkErrorTypes.ERROR_EVENT);
   });
 }
 
@@ -220,5 +250,3 @@ export function fetchIsSupported() : boolean {
           !isNullOrUndefined(_AbortController) &&
           !isNullOrUndefined(_Headers));
 }
-
-export default fetchRequest;

package/src/utils/request/index.ts

@@ -16,12 +16,12 @@
 
 import fetchRequest, {
   fetchIsSupported,
-  IDataChunk,
-  IDataComplete,
+  IFetchedDataObject,
+  IFetchedStreamComplete,
 } from "./fetch";
 import xhr, {
   IRequestOptions,
-  IRequestProgress,
+  IProgressInfo,
   IRequestResponse,
 } from "./xhr";
 
@@ -29,10 +29,10 @@ export default xhr;
 export {
   fetchIsSupported,
   fetchRequest,
-  IDataChunk,
-  IDataComplete,
+  IFetchedDataObject,
+  IFetchedStreamComplete,
+  IProgressInfo,
   IRequestOptions,
-  IRequestProgress,
   IRequestResponse,
   xhr,
 };