rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/transports/types.ts

@@ -373,7 +373,7 @@ export interface IManifestParserResult {
    * This property should only be set when a unique URL is sufficient to
    * retrieve the whole data.
    */
-  url? : string;
+  url? : string | undefined;
 }
 
 /**
@@ -416,11 +416,11 @@ export interface ITextTrackSegmentData {
    * This is mostly needed for "sami" subtitles, to know which cues can / should
    * be parsed.
    */
-  language? : string;
+  language? : string | undefined;
   /** start time from which the segment apply, in seconds. */
-  start? : number;
+  start? : number | undefined;
   /** end time until which the segment apply, in seconds. */
-  end? : number;
+  end? : number | undefined;
 }
 
 /** Format under which image data is decodable by the RxPlayer. */
@@ -487,21 +487,21 @@ interface IServerSyncInfos { serverTimestamp : number;
                              clientTime : number; }
 
 export interface ITransportOptions {
-  aggressiveMode? : boolean;
-  checkMediaSegmentIntegrity? : boolean;
+  aggressiveMode? : boolean | undefined;
+  checkMediaSegmentIntegrity? : boolean | undefined;
   lowLatencyMode : boolean;
-  manifestLoader?: ICustomManifestLoader;
-  manifestUpdateUrl? : string;
-  referenceDateTime? : number;
-  representationFilter? : IRepresentationFilter;
-  segmentLoader? : ICustomSegmentLoader;
-  serverSyncInfos? : IServerSyncInfos;
+  manifestLoader?: ICustomManifestLoader | undefined;
+  manifestUpdateUrl? : string | undefined;
+  referenceDateTime? : number | undefined;
+  representationFilter? : IRepresentationFilter | undefined;
+  segmentLoader? : ICustomSegmentLoader | undefined;
+  serverSyncInfos? : IServerSyncInfos | undefined;
   /* eslint-disable import/no-deprecated */
-  supplementaryImageTracks? : ISupplementaryImageTrack[];
-  supplementaryTextTracks? : ISupplementaryTextTrack[];
+  supplementaryImageTracks? : ISupplementaryImageTrack[] | undefined;
+  supplementaryTextTracks? : ISupplementaryTextTrack[] | undefined;
   /* eslint-enable import/no-deprecated */
 
-  __priv_patchLastSegmentInSidx? : boolean;
+  __priv_patchLastSegmentInSidx? : boolean | undefined;
 }
 
 export type ICustomSegmentLoader = (
@@ -521,7 +521,13 @@ export type ICustomSegmentLoader = (
                                      duration? : number | undefined; }) => void;
 
                  reject : (err? : unknown) => void;
-                 fallback? : (() => void) | undefined; }
+                 fallback : () => void;
+                 progress : (
+                   info : { duration : number;
+                            size : number;
+                            totalSize? : number | undefined; }
+                 ) => void;
+  }
 ) =>
   // returns either the aborting callback or nothing
   (() => void)|void;
@@ -532,14 +538,15 @@ export type ICustomManifestLoader = (
 
   // second argument: callbacks
   callbacks : { resolve : (args : { data : ILoadedManifestFormat;
-                                    sendingTime? : number;
-                                    receivingTime? : number;
-                                    size? : number;
-                                    duration? : number; })
+                                    url? : string | undefined;
+                                    sendingTime? : number | undefined;
+                                    receivingTime? : number | undefined;
+                                    size? : number | undefined;
+                                    duration? : number | undefined; })
                           => void;
 
                  reject : (err? : Error) => void;
-                 fallback? : () => void; }
+                 fallback : () => void; }
 ) =>
   // returns either the aborting callback or nothing
   (() => void)|void;
@@ -597,7 +604,7 @@ export interface ISegmentLoadingProgressInformation {
   /** Size of the data already downloaded, in bytes. */
   size : number;
   /** Size of whole data to download (data already-loaded included), in bytes. */
-  totalSize? : number;
+  totalSize? : number | undefined;
 }
 
 /**
@@ -646,19 +653,19 @@ export interface IChunkCompleteInformation {
    * This property should only be set when a unique URL is sufficient to
    * retrieve the whole data.
    */
-  url? : string;
+  url? : string | undefined;
   /**
    * Time at which the request began in terms of `performance.now`.
    * If fetching the corresponding data necessitated to perform multiple
    * requests, this time corresponds to the first request made.
    */
-  sendingTime? : number;
+  sendingTime? : number | undefined;
   /**
    * Time at which the request ended in terms of `performance.now`.
    * If fetching the corresponding data necessitated to perform multiple
    * requests, this time corresponds to the last request to end.
    */
-  receivedTime? : number;
+  receivedTime? : number | undefined;
   /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
   size : number | undefined;
 }
@@ -702,7 +709,7 @@ export interface ISegmentParserParsedInitChunk<DataType> {
    * Timescale metadata found inside this initialization segment.
    * That timescale might be useful when parsing further merdia segments.
    */
-  initTimescale? : number;
+  initTimescale? : number | undefined;
   /**
    * If set to `true`, some protection information has been found in this
    * initialization segment and lead the corresponding `Representation`
@@ -715,6 +722,17 @@ export interface ISegmentParserParsedInitChunk<DataType> {
    * protection initialization data to have been encountered.
    */
   protectionDataUpdate : boolean;
+  /**
+   * Size in bytes of `initializationData`.
+   * `undefined` if unknown.
+   *
+   * Note: In some cases, such as when `initializationData` is under a format
+   * whose size is difficult to estimate (e.g. a JavaScript object), the
+   * `initializationDataSize` may either be set to `undefined` or, if available,
+   * to a sensible estimate (e.g. when a JavaScript object wraps large binary
+   * data, `initializationDataSize` may refer to that binary data only).
+   */
+  initializationDataSize : number | undefined;
 }
 
 /**
@@ -733,6 +751,17 @@ export interface ISegmentParserParsedMediaChunk<DataType> {
    * `null` if unknown.
    */
   chunkInfos : IChunkTimeInfo | null;
+  /**
+   * Size in bytes of `chunkData`.
+   * `undefined` if unknown.
+   *
+   * Note: In some cases, such as when `chunkData` is under a format whose size
+   * is difficult to estimate (e.g. a JavaScript object), the `chunkSize` may
+   * either be set to `undefined` or, if available, to a sensible estimate (e.g.
+   * when a JavaScript object wraps large binary data, `chunkSize` may refer to
+   * that binary data only).
+   */
+  chunkSize : number | undefined;
   /**
    * time offset, in seconds, to add to the absolute timed data defined in
    * `chunkData` to obtain the "real" wanted effective time.
@@ -757,7 +786,7 @@ export interface ISegmentParserParsedMediaChunk<DataType> {
    * If set and not empty, then "events" have been encountered in this parsed
    * chunks.
    */
-  inbandEvents? : IInbandEvent[];
+  inbandEvents? : IInbandEvent[] | undefined;
   /**
    * If set to `true`, then parsing this chunk revealed that the current
    * Manifest instance needs to be refreshed.
@@ -791,19 +820,19 @@ export interface IRequestedData<T> {
    * This property should only be set when a unique URL is sufficient to
    * retrieve the whole data.
    */
-  url? : string;
+  url? : string | undefined;
   /**
    * Time at which the request began in terms of `performance.now`.
    * If fetching the corresponding data necessitated to perform multiple
    * requests, this time corresponds to the first request made.
    */
-  sendingTime? : number;
+  sendingTime? : number | undefined;
   /**
    * Time at which the request ended in terms of `performance.now`.
    * If fetching the corresponding data necessitated to perform multiple
    * requests, this time corresponds to the last request to end.
    */
-  receivedTime? : number;
+  receivedTime? : number | undefined;
   /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
   size : number | undefined;
 }

package/src/transports/utils/call_custom_manifest_loader.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import { CustomLoaderError } from "../../errors";
+import PPromise from "../../utils/promise";
 import {
   CancellationError,
   CancellationSignal,
@@ -51,11 +51,11 @@ export default function callCustomManifestLoader(
        * @param {Object} args
        */
       const resolve = (_args : { data : ILoadedManifestFormat;
-                                 size? : number;
-                                 duration? : number;
-                                 url? : string;
-                                 receivingTime? : number;
-                                 sendingTime? : number; }) =>
+                                 size? : number | undefined;
+                                 duration? : number | undefined;
+                                 url? : string | undefined;
+                                 receivingTime? : number | undefined;
+                                 sendingTime? : number | undefined; }) =>
       {
         if (hasFinished || cancelSignal.isCancelled) {
           return;

package/src/transports/utils/generate_manifest_loader.ts

@@ -66,7 +66,7 @@ function generateRegularManifestLoader(
  * @returns {Function}
  */
 export default function generateManifestLoader(
-  { customManifestLoader } : { customManifestLoader?: ICustomManifestLoader },
+  { customManifestLoader } : { customManifestLoader?: ICustomManifestLoader | undefined },
   preferredType: "arraybuffer" | "text" | "document"
 ) : (
     url : string | undefined,

package/src/utils/__tests__/deep_merge.test.ts

@@ -0,0 +1,48 @@
+import deepMerge from "../deep_merge";
+
+
+describe("utils - deep_merge", () => {
+  it("should return the first argument if no other arguments", () => {
+    const obj1 = { a: 1 };
+    expect(deepMerge(obj1)).toStrictEqual(obj1);
+  });
+
+  it("should concat if no common key is found", () => {
+    const obj1 = { a: 1 };
+    const obj2 = { b: 2 };
+    const result = { a: 1, b: 2 };
+    expect(deepMerge(obj1, obj2)).toStrictEqual(result);
+  });
+
+  it("should override the 1st object with the second", () => {
+    const obj1 = { a: 1 };
+    const obj2 = { a: 2 };
+    const result = { a: 2 };
+    expect(deepMerge(obj1, obj2)).toStrictEqual(result);
+  });
+
+  it("should return a deeply merged object", () => {
+    const obj1 = { a: { b: 1 } };
+    const obj2 = { a: { c: 2 } };
+    const result = { a: { b: 1, c: 2 } };
+    expect(deepMerge(obj1, obj2)).toStrictEqual(result);
+  });
+
+  it("should be able to merge multiple objects", () => {
+    const obj1 = { a: { b: 1 }, d: { e: 1 } };
+    const obj2 = { a: { c: 2 } };
+    const obj3 = { a: { f: 3 }, d: { g: 2 } };
+    const result = {
+      a: {
+        b: 1,
+        c: 2,
+        f: 3,
+      },
+      d: {
+        e: 1,
+        g: 2,
+      },
+    };
+    expect(deepMerge(obj1, obj2, obj3)).toStrictEqual(result);
+  });
+});

package/src/utils/__tests__/flat_map.test.ts

@@ -19,12 +19,15 @@
 
 import flatMap from "../flat_map";
 
-const proto = Array.prototype as unknown as {
-  flatMap?<U, This = undefined>(
+interface IProtoWithFlatMap {
+  flatMap? : (<U, This = undefined>(
     callback: (this: This, value: unknown, index: number, array: unknown[]) => U | U[],
-    thisArg?: This
-  ): U[];
-};
+    thisArg?: This | undefined
+  ) => U[]) | undefined;
+}
+
+
+const proto = Array.prototype as unknown as IProtoWithFlatMap;
 
 /* eslint-disable @typescript-eslint/unbound-method */
 const initialFlatMap = proto.flatMap;
@@ -32,7 +35,7 @@ const initialFlatMap = proto.flatMap;
 
 describe("utils - starts-with", () => {
   beforeEach(() => {
-    proto.flatMap = undefined;
+    delete proto.flatMap;
   });
 
   afterEach(() => {
@@ -49,7 +52,9 @@ describe("utils - starts-with", () => {
   if (typeof initialFlatMap === "function") {
     it("should call the original flatMap function if available", () => {
       proto.flatMap = initialFlatMap;
-      const flatMapSpy = jest.spyOn(proto, "flatMap");
+      // TODO find what bother typescript here instead of adding "as any"
+      /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+      const flatMapSpy = jest.spyOn(proto as any, "flatMap");
       const func1 = (x : number) : number[] => [x, x + 1, x - 1];
       const func2 = (x : number) : string => String(x) + "a";
       expect(flatMap([1, 2, 3], func1))

package/src/utils/cancellable_sleep.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
+import PPromise from "./promise";
 import {
   CancellationError,
   CancellationSignal,

package/src/utils/cast_to_observable.ts

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import {
   from as observableFrom,
   Observable,
   of as observableOf,
 } from "rxjs";
 import isNullOrUndefined from "./is_null_or_undefined";
+import PPromise from "./promise";
 
 /**
  * Try to cast the given value into an observable.
@@ -30,7 +30,6 @@ import isNullOrUndefined from "./is_null_or_undefined";
  */
 function castToObservable<T>(value : Observable<T> |
                                      Promise<T> |
-                                     PPromise<T> |
                                      Exclude<T, Observable<T>>) : Observable<T> {
   if (value instanceof Observable) {
     return value;

package/src/utils/deep_merge.ts

@@ -0,0 +1,46 @@
+import objectAssign from "./object_assign";
+
+/**
+ * Check if an item is an object
+ * @param item
+ * @returns {boolean}
+ */
+function isObject(item: unknown) : boolean {
+  return (item !== null
+          && item !== undefined
+          && !Array.isArray(item)
+          && typeof item === "object");
+}
+
+type IDeepPartial<T> = {
+  [P in keyof T]?: IDeepPartial<T[P]> ;
+};
+
+type ISourcesArgument<T> = Array<IDeepPartial<T>|unknown>;
+
+/**
+ * Deeply merge nested objects
+ * @param target
+ * @param sources
+ * @returns output : merged object
+ */
+export default function deepMerge<T>(target: T, ...sources: ISourcesArgument<T>): T {
+  if (sources.length === 0) {
+    return target;
+  }
+  const source = sources.shift() as IDeepPartial<T>;
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (target[key] === undefined) {
+          objectAssign(target, { [key]: {} });
+        }
+        const newTarget = target[key];
+        deepMerge(newTarget, source[key] as IDeepPartial<typeof newTarget>);
+      } else {
+        objectAssign(target, { [key]: source[key] });
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
+}

package/src/utils/reference.ts

@@ -19,6 +19,7 @@ import {
   Subscriber,
 } from "rxjs";
 import log from "../log";
+import { CancellationSignal } from "./task_canceller";
 
 /**
  * A value behind a shared reference, meaning that any update to its value from
@@ -62,6 +63,7 @@ export interface ISharedReference<T> {
 
   /** Update the value of this shared reference. */
   setValue(newVal : T) : void;
+  setValueIfChanged(newVal : T) : void;
 
   /**
    * Returns an Observable which synchronously emits the current value (unless
@@ -72,6 +74,25 @@ export interface ISharedReference<T> {
    */
   asObservable(skipCurrentValue? : boolean) : Observable<T>;
 
+  /**
+   * 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 the new value im argument.
+   * @param {Object} [options]
+   * @param {Object} [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 called with the current value.
+   */
+  onUpdate(
+    cb : (val : T) => void,
+    options? : {
+      clearSignal?: CancellationSignal;
+      emitCurrentValue?: boolean;
+    },
+  ) : void;
+
   /**
    * Indicate that no new values will be emitted.
    * Allows to automatically close all Observables generated from this shared
@@ -103,8 +124,23 @@ export interface ISharedReference<T> {
  * the code that some logic is not supposed to update the referenced value.
  */
 export interface IReadOnlySharedReference<T> {
+  /** Get the last value set on that reference. */
   getValue() : T;
+  /**
+   * Returns an Observable notifying this reference's value each time it is
+   * updated.
+   *
+   * Also emit its current value on subscription unless its argument is set to
+   * `true`.
+   */
   asObservable(skipCurrentValue? : boolean) : Observable<T>;
+  onUpdate(
+    cb : (val : T) => void,
+    options? : {
+      clearSignal?: CancellationSignal;
+      emitCurrentValue?: boolean;
+    },
+  ) : void;
 }
 
 /**
@@ -120,19 +156,23 @@ export function createSharedReference<T>(initialValue : T) : ISharedReference<T>
   let value = initialValue;
 
   /**
-   * List of currently subscribed Observables which listen to the referenced
+   * List of currently subscribed listeners which listen to the referenced
    * value's updates.
    *
-   * Contains two properties:
-   *   - `subscriber`: interface through which new value will be communicated.
-   *   - `hasBeenUnsubscribed`: becomes `true` when the Observable becomes
-   *     unsubscribed and thus when it is removed from the `subs` array.
+   * Contains three 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 Observable becomes
+   *     unsubscribed and thus when it is removed from the `cbs` array.
    *     Adding this property allows to detect when a previously-added
    *     Observable has since been unsubscribed e.g. as a side-effect during a
    *     function call.
    */
-  const subs : Array<{ subscriber : Subscriber<T>;
-                       hasBeenUnsubscribed : boolean; }> = [];
+  const cbs : Array<{ trigger : (a: T) => void;
+                      complete : () => void;
+                      hasBeenCleared : boolean; }> = [];
 
   let isFinished = false;
 
@@ -160,14 +200,14 @@ export function createSharedReference<T>(initialValue : T) : ISharedReference<T>
       }
       value = newVal;
 
-      if (subs.length === 0) {
+      if (cbs.length === 0) {
         return;
       }
-      const clonedSubs = subs.slice();
-      for (const subObj of clonedSubs) {
+      const clonedCbs = cbs.slice();
+      for (const cbObj of clonedCbs) {
         try {
-          if (!subObj.hasBeenUnsubscribed) {
-            subObj.subscriber.next(newVal);
+          if (!cbObj.hasBeenCleared) {
+            cbObj.trigger(newVal);
           }
         } catch (_) {
           /* nothing */
@@ -175,6 +215,11 @@ export function createSharedReference<T>(initialValue : T) : ISharedReference<T>
       }
     },
 
+    setValueIfChanged(newVal : T) : void {
+      if (newVal !== value) {
+        this.setValue(newVal);
+      }
+    },
 
     /**
      * Returns an Observable which synchronously emits the current value (unless
@@ -192,24 +237,72 @@ export function createSharedReference<T>(initialValue : T) : ISharedReference<T>
           obs.complete();
           return undefined;
         }
-        const subObj = { subscriber: obs,
-                         hasBeenUnsubscribed: false };
-        subs.push(subObj);
+        const cbObj = { trigger: obs.next.bind(obs),
+                        complete: obs.complete.bind(obs),
+                        hasBeenCleared: false };
+        cbs.push(cbObj);
         return () => {
           /**
            * Code in here can still be running while this is happening.
-           * Set `hasBeenUnsubscribed` to `true` to avoid still using the
+           * Set `hasBeenCleared` to `true` to avoid still using the
            * `subscriber` from this object.
            */
-          subObj.hasBeenUnsubscribed = true;
-          const indexOf = subs.indexOf(subObj);
+          cbObj.hasBeenCleared = true;
+          const indexOf = cbs.indexOf(cbObj);
           if (indexOf >= 0) {
-            subs.splice(indexOf, 1);
+            cbs.splice(indexOf, 1);
           }
         };
       });
     },
 
+    /**
+     * 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 the new value im argument.
+     * @param {Object} [options]
+     * @param {Object} [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 called with the current value.
+     */
+    onUpdate(
+      cb : (val : T) => void,
+      options? : {
+        clearSignal?: CancellationSignal;
+        emitCurrentValue?: boolean;
+      }
+    ) : void {
+      if (options?.emitCurrentValue === true) {
+        cb(value);
+      }
+      if (isFinished) {
+        return ;
+      }
+      const cbObj = { trigger: cb,
+                      complete: unlisten,
+                      hasBeenCleared: false };
+      cbs.push(cbObj);
+      if (options?.clearSignal === undefined) {
+        return;
+      }
+      options.clearSignal.register(unlisten);
+
+      function unlisten() : void {
+        /**
+         * Code in here can still be running while this is happening.
+         * Set `hasBeenCleared` to `true` to avoid still using the
+         * `subscriber` from this object.
+         */
+        cbObj.hasBeenCleared = true;
+        const indexOf = cbs.indexOf(cbObj);
+        if (indexOf >= 0) {
+          cbs.splice(indexOf, 1);
+        }
+      }
+    },
+
     /**
      * Indicate that no new values will be emitted.
      * Allows to automatically close all Observables generated from this shared
@@ -217,11 +310,11 @@ export function createSharedReference<T>(initialValue : T) : ISharedReference<T>
      */
     finish() : void {
       isFinished = true;
-      const clonedSubs = subs.slice();
-      for (const subObj of clonedSubs) {
+      const clonedCbs = cbs.slice();
+      for (const cbObj of clonedCbs) {
         try {
-          if (!subObj.hasBeenUnsubscribed) {
-            subObj.subscriber.complete();
+          if (!cbObj.hasBeenCleared) {
+            cbObj.complete();
           }
         } catch (_) {
           /* nothing */