rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/src/utils/reference.ts

@@ -14,23 +14,25 @@
  * limitations under the License.
  */
 
+import arrayFindIndex from "./array_find_index";
+import noop from "./noop";
 import { CancellationSignal } from "./task_canceller";
 
 /**
  * A value behind a shared reference, meaning that any update to its value from
  * anywhere can be retrieved from any other parts of the code in possession of
- * the same `ISharedReference`.
+ * the same `SharedReference`.
  *
  * @example
  * ```ts
  * const myVal = 1;
- * const myRef : ISharedReference<number> = createSharedReference(1);
+ * const myRef : SharedReference<number> = new SharedReference(1);
  *
  * function setValTo2(num : number) {
  *   num = 2;
  * }
  *
- * function setRefTo2(num : ISharedReference<number>) {
+ * function setRefTo2(num : SharedReference<number>) {
  *   num.setValue(2);
  * }
  *
@@ -52,18 +54,104 @@ import { CancellationSignal } from "./task_canceller";
  * This type was added because we found that the usage of an explicit type for
  * those use cases makes the intent of the corresponding code clearer.
  */
-export interface ISharedReference<T> {
+class SharedReference<T> {
+  /** Current value referenced by this `SharedReference`. */
+  private _value : T;
+
+  /**
+   * Attributes each linked to a single registered callbacks which listen to the
+   * referenced value's updates.
+   *
+   * Contains the following properties:
+   *   - `trigger`: Function which will be called with the new reference's value
+   *     once it changes
+   *   - `complete`: Allows to clean-up the listener, will be called once the
+   *     reference is finished.
+   *   - `hasBeenCleared`: becomes `true` when the reference is
+   *     removed from the `cbs` array.
+   *     Adding this property allows to detect when a previously-added
+   *     listener has since been removed e.g. as a side-effect during a
+   *     function call.
+   *   - `complete`: Callback to call when the current Reference is "finished".
+   */
+  private _listeners : Array<{ trigger : (a: T, stopListening: () => void) => void;
+                               complete : () => void;
+                               hasBeenCleared : boolean; }>;
+  /**
+   * Set to `true` when this `SharedReference` is finished in which case it
+   * cannot be updated nor emit values anymore.
+   */
+  private _isFinished : boolean;
+
   /**
-   * Get the last set value for this shared reference.
+   * Callbacks triggered when the `SharedReference` is finished.
+   */
+  private _onFinishCbs : Array<{ trigger : () => void;
+                                 hasBeenCleared : boolean; }>;
+
+  /**
+   * Store a reference to the callback allowing to finish the `SharedReference`
+   * on some event. Allows to remove the logic when it's not needed anymore.
+   */
+  private _deregisterCancellation: (() => void) | undefined;
+
+  /**
+   * Create a `SharedReference` object encapsulating the mutable `initialValue`
+   * value of type T.
+   * @param {*} initialValue
+   * @param {Object|undefined} [cancelSignal] - If set, the created shared
+   * reference will be automatically "finished" once that signal emits.
+   * Finished references won't be able to update their value anymore, and will
+   * also automatically have their listeners (callbacks linked to value change)
+   * removed - as they cannot be triggered anymore, thus providing a security
+   * against memory leaks.
+   */
+  constructor(initialValue: T, cancelSignal?: CancellationSignal) {
+    this._value = initialValue;
+    this._listeners = [];
+    this._isFinished = false;
+    this._onFinishCbs = [];
+    if (cancelSignal !== undefined) {
+      this._deregisterCancellation = cancelSignal.register(() => this.finish());
+    }
+  }
+
+  /**
+   * Returns the current value of this shared reference.
    * @returns {*}
    */
-  getValue() : T;
+  public getValue() : T {
+    return this._value;
+  }
 
   /**
    * Update the value of this shared reference.
    * @param {*} newVal
    */
-  setValue(newVal : T) : void;
+  public setValue(newVal : T) : void {
+    if (this._isFinished) {
+      if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
+        /* eslint-disable-next-line no-console */
+        console.error("Finished shared references cannot be updated");
+      }
+      return;
+    }
+    this._value = newVal;
+
+    if (this._listeners.length === 0) {
+      return;
+    }
+    const clonedCbs = this._listeners.slice();
+    for (const cbObj of clonedCbs) {
+      try {
+        if (!cbObj.hasBeenCleared) {
+          cbObj.trigger(newVal, cbObj.complete);
+        }
+      } catch (_) {
+        /* nothing */
+      }
+    }
+  }
 
   /**
    * Update the value of this shared reference only if the value changed.
@@ -73,27 +161,63 @@ export interface ISharedReference<T> {
    * thus be considered different.
    * @param {*} newVal
    */
-  setValueIfChanged(newVal : T) : void;
+  public setValueIfChanged(newVal : T) : void {
+    if (newVal !== this._value) {
+      this.setValue(newVal);
+    }
+  }
 
   /**
    * Allows to register a callback to be called each time the value inside the
    * reference is updated.
    * @param {Function} cb - Callback to be called each time the reference is
    * updated. Takes as first argument its new value and in second argument a
-   * function allowing to unregister the update listening callback.
-   * @param {Object} [options]
-   * @param {Object} [options.clearSignal] - Allows to provide a
+   * callback allowing to unregister the callback.
+   * @param {Object|undefined} [options]
+   * @param {Object|undefined} [options.clearSignal] - Allows to provide a
    * CancellationSignal which will unregister the callback when it emits.
-   * @param {boolean} [options.emitCurrentValue] - If `true`, the callback will
-   * also be immediately (synchronously) called with the current value.
+   * @param {boolean|undefined} [options.emitCurrentValue] - If `true`, the
+   * callback will also be immediately called with the current value.
    */
-  onUpdate(
+  public onUpdate(
     cb : (val : T, stopListening : () => void) => void,
     options? : {
       clearSignal?: CancellationSignal | undefined;
       emitCurrentValue?: boolean | undefined;
-    } | undefined,
-  ) : void;
+    } | undefined
+  ) : void {
+    const unlisten = (): void => {
+      if (options?.clearSignal !== undefined) {
+        options.clearSignal.deregister(unlisten);
+      }
+      if (cbObj.hasBeenCleared) {
+        return;
+      }
+      cbObj.hasBeenCleared = true;
+      const indexOf = this._listeners.indexOf(cbObj);
+      if (indexOf >= 0) {
+        this._listeners.splice(indexOf, 1);
+      }
+    };
+
+    const cbObj = { trigger: cb,
+                    complete: unlisten,
+                    hasBeenCleared: false };
+    this._listeners.push(cbObj);
+
+    if (options?.emitCurrentValue === true) {
+      cb(this._value, unlisten);
+    }
+
+    if (this._isFinished || cbObj.hasBeenCleared) {
+      unlisten();
+      return ;
+    }
+    if (options?.clearSignal === undefined) {
+      return;
+    }
+    options.clearSignal.register(unlisten);
+  }
 
   /**
    * Variant of `onUpdate` which will only call the callback once, once the
@@ -115,35 +239,107 @@ export interface ISharedReference<T> {
    * ```
    * @param {Function} cb - Callback to be called each time the reference is
    * updated. Takes the new value in argument.
-   * @param {Object} [options]
-   * @param {Object} [options.clearSignal] - Allows to provide a
+   * @param {Object | undefined} [options]
+   * @param {Object | undefined} [options.clearSignal] - Allows to provide a
    * CancellationSignal which will unregister the callback when it emits.
    */
-  waitUntilDefined(
+  public waitUntilDefined(
     cb : (val : Exclude<T, undefined>) => void,
     options? : { clearSignal?: CancellationSignal | undefined } |
-               undefined,
-  ) : void;
+               undefined
+  ) : void {
+    this.onUpdate((val : T, stopListening) => {
+      if (val !== undefined) {
+        stopListening();
+        cb(this._value as Exclude<T, undefined>);
+      }
+    }, { clearSignal: options?.clearSignal, emitCurrentValue: true });
+  }
+
+  /**
+   * Allows to register a callback for when the Shared Reference is "finished".
+   *
+   * This function is mostly there for implementing operators on the shared
+   * reference and isn't meant to be used by regular code, hence it being
+   * prefixed by `_`.
+   * @param {Function} cb - Callback to be called once the reference is
+   * finished.
+   * @param {Object} onFinishCancelSignal - Allows to provide a
+   * CancellationSignal which will unregister the callback when it emits.
+   */
+  public _onFinished(
+    cb: () => void,
+    onFinishCancelSignal: CancellationSignal
+  ) : () => void {
+    if (onFinishCancelSignal.isCancelled()) {
+      return noop;
+    }
+    const cleanUp = (): void => {
+      const indexOf = arrayFindIndex(this._onFinishCbs, (x) => x.trigger === trigger);
+      if (indexOf >= 0) {
+        this._onFinishCbs[indexOf].hasBeenCleared = true;
+        this._onFinishCbs.splice(indexOf, 1);
+      }
+    };
+    const trigger = () => {
+      cleanUp();
+      cb();
+    };
+    const deregisterCancellation = onFinishCancelSignal.register(cleanUp);
+    this._onFinishCbs.push({ trigger, hasBeenCleared: false });
+    return deregisterCancellation;
+
+  }
 
   /**
    * Indicate that no new values will be emitted.
-   * Allows to automatically close all listeners listening to this
-   * `ISharedReference`.
+   * Allows to automatically free all listeners linked to this reference.
    */
-  finish() : void;
+  public finish() {
+    if (this._deregisterCancellation !== undefined) {
+      this._deregisterCancellation();
+    }
+    this._isFinished = true;
+    const clonedCbs = this._listeners.slice();
+    for (const cbObj of clonedCbs) {
+      try {
+        if (!cbObj.hasBeenCleared) {
+          cbObj.complete();
+          cbObj.hasBeenCleared = true;
+        }
+      } catch (_) {
+        /* nothing */
+      }
+    }
+    this._listeners.length = 0;
+    if (this._onFinishCbs.length > 0) {
+      const clonedFinishedCbs = this._onFinishCbs.slice();
+      for (const cbObj of clonedFinishedCbs) {
+        try {
+          if (!cbObj.hasBeenCleared) {
+            cbObj.trigger();
+            cbObj.hasBeenCleared = true;
+          }
+        } catch (_) {
+          /* nothing */
+        }
+      }
+      this._onFinishCbs.length = 0;
+    }
+  }
 }
 
 /**
- * An `ISharedReference` which can only be read and not updated.
+ * A `SharedReference` which can only be read and not updated.
  *
- * Because an `ISharedReference` is structurally compatible to a
+ * Because a `SharedReference` is structurally compatible to a
  * `IReadOnlySharedReference`, and because of TypeScript variance rules, it can
  * be upcasted into a `IReadOnlySharedReference` at any time to make it clear in
  * the code that some logic is not supposed to update the referenced value.
  *
  * @example
  * ```ts
- * const myReference : ISharedReference<number> = createSharedReference(4);
+ * const myReference : SharedReference<number> = new SharedReference(4);
  *
  * function shouldOnlyReadIt(roRef : IReadOnlySharedReference<number>) {
  *   console.log("current value:", roRef.getValue());
@@ -156,215 +352,16 @@ export interface ISharedReference<T> {
  * ```
  */
 export type IReadOnlySharedReference<T> =
-  Pick<ISharedReference<T>,
+  Pick<SharedReference<T>,
        "getValue" |
        "onUpdate" |
-       "waitUntilDefined">;
-
-/**
- * Create an `ISharedReference` object encapsulating the mutable `initialValue`
- * value of type T.
- *
- * @see ISharedReference
- * @param {*} initialValue
- * @param {Object|undefined} [cancelSignal] - If set, the created shared
- * reference will be automatically "finished" once that signal emits.
- * Finished references won't be able to update their value anymore, and will
- * also automatically have their listeners (callbacks linked to value change)
- * removed - as they cannot be triggered anymore, thus providing a security
- * against memory leaks.
- * @returns {Object}
- */
-export default function createSharedReference<T>(
-  initialValue : T,
-  cancelSignal? : CancellationSignal
-) : ISharedReference<T> {
-  /** Current value referenced by this `ISharedReference`. */
-  let value = initialValue;
-
-  /**
-   * Attributes each linked to a single registered callbacks which listen to the
-   * referenced value's updates.
-   *
-   * Contains the following properties:
-   *   - `trigger`: Function which will be called with the new reference's value
-   *     once it changes
-   *   - `complete`: Allows to clean-up the listener, will be called once the
-   *     reference is finished.
-   *   - `hasBeenCleared`: becomes `true` when the reference is
-   *     removed from the `cbs` array.
-   *     Adding this property allows to detect when a previously-added
-   *     listener has since been removed e.g. as a side-effect during a
-   *     function call.
-   *   - `complete`: Callback to call when the current Reference is "finished".
-   */
-  const cbs : Array<{ trigger : (a: T, stopListening: () => void) => void;
-                      complete : () => void;
-                      hasBeenCleared : boolean; }> = [];
-
-  let isFinished = false;
-
-  if (cancelSignal !== undefined) {
-    cancelSignal.register(finish);
-  }
-
-  return {
-    /**
-     * Returns the current value of this shared reference.
-     * @returns {*}
-     */
-    getValue() : T {
-      return value;
-    },
-
-    /**
-     * Update the value of this shared reference.
-     * @param {*} newVal
-     */
-    setValue(newVal : T) : void {
-      if (isFinished) {
-        if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
-          /* eslint-disable-next-line no-console */
-          console.error("Finished shared references cannot be updated");
-        }
-        return;
-      }
-      value = newVal;
-
-      if (cbs.length === 0) {
-        return;
-      }
-      const clonedCbs = cbs.slice();
-      for (const cbObj of clonedCbs) {
-        try {
-          if (!cbObj.hasBeenCleared) {
-            cbObj.trigger(newVal, cbObj.complete);
-          }
-        } catch (_) {
-          /* nothing */
-        }
-      }
-    },
-
-    /**
-     * Update the value of this shared reference only if it changed.
-     * @param {*} newVal
-     */
-    setValueIfChanged(newVal : T) : void {
-      if (newVal !== value) {
-        this.setValue(newVal);
-      }
-    },
-
-    /**
-     * Allows to register a callback to be called each time the value inside the
-     * reference is updated.
-     * @param {Function} cb - Callback to be called each time the reference is
-     * updated. Takes as first argument its new value and in second argument a
-     * callback allowing to unregister the callback.
-     * @param {Object|undefined} [options]
-     * @param {Object|undefined} [options.clearSignal] - Allows to provide a
-     * CancellationSignal which will unregister the callback when it emits.
-     * @param {boolean|undefined} [options.emitCurrentValue] - If `true`, the
-     * callback will also be immediately called with the current value.
-     */
-    onUpdate(
-      cb : (val : T, stopListening : () => void) => void,
-      options? : {
-        clearSignal?: CancellationSignal | undefined;
-        emitCurrentValue?: boolean | undefined;
-      } | undefined
-    ) : void {
-      const cbObj = { trigger: cb,
-                      complete: unlisten,
-                      hasBeenCleared: false };
-      cbs.push(cbObj);
-
-      if (options?.emitCurrentValue === true) {
-        cb(value, unlisten);
-      }
-
-      if (isFinished || cbObj.hasBeenCleared) {
-        unlisten();
-        return ;
-      }
-      if (options?.clearSignal === undefined) {
-        return;
-      }
-      options.clearSignal.register(unlisten);
-
-      function unlisten() : void {
-        if (options?.clearSignal !== undefined) {
-          options.clearSignal.deregister(unlisten);
-        }
-        if (cbObj.hasBeenCleared) {
-          return;
-        }
-        cbObj.hasBeenCleared = true;
-        const indexOf = cbs.indexOf(cbObj);
-        if (indexOf >= 0) {
-          cbs.splice(indexOf, 1);
-        }
-      }
-    },
-
-    /**
-     * Variant of `onUpdate` which will only call the callback once, once the
-     * value inside the reference is different from `undefined`.
-     * The callback is called synchronously if the value already isn't set to
-     * `undefined`.
-     *
-     * This method can be used as a lighter weight alternative to `onUpdate`
-     * when just waiting that the stored value becomes defined.
-     * @param {Function} cb - Callback to be called each time the reference is
-     * updated. Takes the new value in argument.
-     * @param {Object} [options]
-     * @param {Object} [options.clearSignal] - Allows to provide a
-     * CancellationSignal which will unregister the callback when it emits.
-     */
-    waitUntilDefined(
-      cb : (val : Exclude<T, undefined>) => void,
-      options? : { clearSignal?: CancellationSignal | undefined } |
-                 undefined
-    ) : void {
-      this.onUpdate((val : T, stopListening) => {
-        if (val !== undefined) {
-          stopListening();
-          cb(value as Exclude<T, undefined>);
-        }
-      }, { clearSignal: options?.clearSignal, emitCurrentValue: true });
-    },
-
-    /**
-     * Indicate that no new values will be emitted.
-     * Allows to automatically free all listeners linked to this reference.
-     */
-    finish,
-  };
-  function finish() {
-    if (cancelSignal !== undefined) {
-      cancelSignal.deregister(finish);
-    }
-    isFinished = true;
-    const clonedCbs = cbs.slice();
-    for (const cbObj of clonedCbs) {
-      try {
-        if (!cbObj.hasBeenCleared) {
-          cbObj.complete();
-          cbObj.hasBeenCleared = true;
-        }
-      } catch (_) {
-        /* nothing */
-      }
-    }
-    cbs.length = 0;
-  }
-}
+       "waitUntilDefined" |
+       "_onFinished">;
 
 /**
- * Create a new `ISharedReference` based on another one by mapping over its
- * referenced value each time it is updated.
- * @param {Object} originalRef - The Original `ISharedReference` you wish to map
+ * Create a new `SharedReference` based on another one by mapping over its
+ * referenced value each time it is updated and finishing once it finishes.
+ * @param {Object} originalRef - The Original `SharedReference` you wish to map
  * over.
  * @param {Function} mappingFn - The mapping function which will receives
  * `originalRef`'s value and outputs this new reference's value.
@@ -377,16 +374,17 @@ export function createMappedReference<T, U>(
   mappingFn : (x : T) => U,
   cancellationSignal : CancellationSignal
 ) : IReadOnlySharedReference<U> {
-  const newRef = createSharedReference(mappingFn(originalRef.getValue()),
-                                       cancellationSignal);
+  const newRef = new SharedReference(mappingFn(originalRef.getValue()),
+                                     cancellationSignal);
   originalRef.onUpdate(function mapOriginalReference(x) {
     newRef.setValue(mappingFn(x));
   }, { clearSignal: cancellationSignal });
 
-  // TODO nothing is done if `originalRef` is finished, though the returned
-  // reference could also be finished in that case. To do?
+  originalRef._onFinished(() => {
+    newRef.finish();
+  }, cancellationSignal);
 
   return newRef;
 }
 
-export { createSharedReference };
+export default SharedReference;

package/src/utils/request/fetch.ts

@@ -14,12 +14,14 @@
  * limitations under the License.
  */
 
+import globalScope from "../../compat/global_scope";
 import {
   NetworkErrorTypes,
   RequestError,
 } from "../../errors";
 import log from "../../log";
 import isNullOrUndefined from "../is_null_or_undefined";
+import getMonotonicTimeStamp from "../monotonic_timestamp";
 import {
   CancellationError,
   CancellationSignal,
@@ -29,9 +31,9 @@ import {
 export interface IFetchedStreamComplete {
   /** Duration of the whole request, in milliseconds. */
   requestDuration : number;
-  /** Result of `performance.now()` at the time the request was received. */
+  /** Monotonically-raising timestamp at the time the request was received. */
   receivedTime : number;
-  /** Result of `performance.now()` at the time the request was started. */
+  /** Monotonically-raising timestamp at the time the request was started. */
   sendingTime : number;
   /** Size of the entire emitted data, in bytes. */
   size : number;
@@ -43,7 +45,7 @@ export interface IFetchedStreamComplete {
 
 /** 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. */
+  /** Monotonically-raising timestamp at the time this data was recuperated. */
   currentTime : number;
   /** Duration of the request until `currentTime`, in milliseconds. */
   duration : number;
@@ -51,7 +53,7 @@ export interface IFetchedDataObject {
   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. */
+  /** Monotonically-raising timestamp at the time the request began. */
   sendingTime : number;
   /** URL of the recuperated data (post-redirection if one). */
   url : string;
@@ -127,7 +129,7 @@ export default function fetchRequest(
   log.debug("Fetch: Called with URL", options.url);
   let cancellation : CancellationError | null = null;
   let timeouted = false;
-  const sendingTime = performance.now();
+  const sendingTime = getMonotonicTimeStamp();
   const abortController: AbortController | null =
     !isNullOrUndefined(_AbortController) ? new _AbortController() :
                                            null;
@@ -146,7 +148,7 @@ export default function fetchRequest(
 
   let timeout : number | undefined;
   if (options.timeout !== undefined) {
-    timeout = window.setTimeout(() => {
+    timeout = setTimeout(() => {
       timeouted = true;
       abortFetch();
     }, options.timeout);
@@ -198,7 +200,7 @@ export default function fetchRequest(
 
       if (!data.done && !isNullOrUndefined(data.value)) {
         size += data.value.byteLength;
-        const currentTime = performance.now();
+        const currentTime = getMonotonicTimeStamp();
         const dataInfo = { url: response.url,
                            currentTime,
                            duration: currentTime - sendingTime,
@@ -211,7 +213,7 @@ export default function fetchRequest(
         return readBufferAndSendEvents();
       } else if (data.done) {
         deregisterCancelLstnr();
-        const receivedTime = performance.now();
+        const receivedTime = getMonotonicTimeStamp();
         const requestDuration = receivedTime - sendingTime;
         return { requestDuration,
                  receivedTime,
@@ -244,7 +246,7 @@ export default function fetchRequest(
  * @return {boolean}
  */
 export function fetchIsSupported() : boolean {
-  return (typeof window.fetch === "function" &&
+  return (typeof globalScope.fetch === "function" &&
           !isNullOrUndefined(_AbortController) &&
           !isNullOrUndefined(_Headers));
 }