rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.20220317

package/src/transports/types.ts

@@ -722,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;
 }
 
 /**
@@ -740,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.

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/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 */

package/src/utils/request/fetch.ts

@@ -96,7 +96,6 @@ export interface IFetchOptions {
   timeout? : number | undefined;
 }
 
-const { DEFAULT_REQUEST_TIMEOUT } = config;
 
 type IHeadersConstructor = new() => Headers;
 type IAbortControllerConstructor = new() => AbortController;
@@ -147,7 +146,7 @@ export default function fetchRequest(
   }
 
   const requestTimeout = isNullOrUndefined(options.timeout) ?
-    DEFAULT_REQUEST_TIMEOUT :
+    config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
     options.timeout;
   const timeout = window.setTimeout(() => {
     timeouted = true;

package/src/utils/request/xhr.ts

@@ -24,7 +24,6 @@ import {
   CancellationSignal,
 } from "../task_canceller";
 
-const { DEFAULT_REQUEST_TIMEOUT } = config;
 
 const DEFAULT_RESPONSE_TYPE : XMLHttpRequestResponseType = "json";
 
@@ -130,6 +129,8 @@ export default function request(
 export default function request<T>(
   options : IRequestOptions< XMLHttpRequestResponseType | null | undefined >
 ) : Promise<IRequestResponse< T, XMLHttpRequestResponseType >> {
+
+  const { DEFAULT_REQUEST_TIMEOUT } = config.getCurrent();
   const requestOptions = {
     url: options.url,
     headers: options.headers,

package/src/utils/rx-from_cancellable_promise.ts

@@ -44,23 +44,28 @@ export default function fromCancellablePromise<T>(
 ) : Observable<T> {
   return new Observable((obs) => {
     let isUnsubscribedFrom = false;
+    let isComplete = false;
     fn().then(
       (i) => {
         if (isUnsubscribedFrom) {
           return;
         }
+        isComplete = true;
         obs.next(i);
         obs.complete();
       },
       (err) => {
+        isComplete = true;
         if (isUnsubscribedFrom) {
           return;
         }
         obs.error(err);
       });
     return () => {
-      isUnsubscribedFrom = true;
-      canceller.cancel();
+      if (!isComplete) {
+        isUnsubscribedFrom = true;
+        canceller.cancel();
+      }
     };
   });
 }

package/src/utils/task_canceller.ts

@@ -153,14 +153,14 @@ export default class TaskCanceller {
    * An optional CancellationError can be given in argument for when this
    * cancellation is actually triggered as a chain reaction from a previous
    * cancellation.
-   * @param {Error} [originError]
+   * @param {Error} [srcError]
    */
-  public cancel(originError? : CancellationError) : void {
+  public cancel(srcError? : CancellationError) : void {
     if (this.isUsed) {
       return ;
     }
     this.isUsed = true;
-    const cancellationError = originError ?? new CancellationError();
+    const cancellationError = srcError ?? new CancellationError();
     this._trigger(cancellationError);
   }
 
@@ -188,7 +188,9 @@ export class CancellationSignal {
    */
   public isCancelled : boolean;
   /**
-   * Error associated to the cancellation.
+   * Error associated to the cancellation, only set if the `CancellationSignal`
+   * has been used (which means that the task has been cancelled).
+   *
    * Can be used to notify to a caller that this task was aborted (for example
    * by rejecting it through the Promise associated to that task).
    *

package/dist/_esm5.processed/core/eme/attach_media_keys.js

@@ -1,57 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { defer as observableDefer, mergeMap, tap, of as observableOf, } from "rxjs";
-import { setMediaKeys, } from "../../compat";
-import log from "../../log";
-import MediaKeysInfosStore from "./media_keys_infos_store";
-/**
- * Dispose the media keys on media element.
- * @param {Object} mediaElement
- * @returns {Observable}
- */
-export function disableMediaKeys(mediaElement) {
-    return observableDefer(function () {
-        MediaKeysInfosStore.setState(mediaElement, null);
-        return setMediaKeys(mediaElement, null);
-    });
-}
-/**
- * Attach MediaKeys and its associated state to an HTMLMediaElement.
- *
- * /!\ Mutates heavily MediaKeysInfosStore
- * @param {Object} mediaKeysInfos
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-export default function attachMediaKeys(mediaElement, _a) {
-    var keySystemOptions = _a.keySystemOptions, loadedSessionsStore = _a.loadedSessionsStore, mediaKeySystemAccess = _a.mediaKeySystemAccess, mediaKeys = _a.mediaKeys;
-    return observableDefer(function () {
-        var previousState = MediaKeysInfosStore.getState(mediaElement);
-        var closeAllSessions$ = previousState !== null &&
-            previousState.loadedSessionsStore !== loadedSessionsStore ?
-            previousState.loadedSessionsStore.closeAllSessions() :
-            observableOf(null);
-        return closeAllSessions$.pipe(mergeMap(function () {
-            MediaKeysInfosStore.setState(mediaElement, { keySystemOptions: keySystemOptions, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, loadedSessionsStore: loadedSessionsStore });
-            if (mediaElement.mediaKeys === mediaKeys) {
-                return observableOf(null);
-            }
-            log.info("EME: Attaching MediaKeys to the media element");
-            return setMediaKeys(mediaElement, mediaKeys)
-                .pipe(tap(function () { log.info("EME: MediaKeys attached with success"); }));
-        }));
-    });
-}

package/dist/_esm5.processed/core/eme/clean_old_loaded_sessions.d.ts

@@ -1,59 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Observable } from "rxjs";
-import { ICustomMediaKeySession } from "../../compat";
-import { IInitializationDataInfo } from "./types";
-import LoadedSessionsStore from "./utils/loaded_sessions_store";
-/**
- * Event emitted when an old MediaKeySession has been closed to respect the
- * maximum limit of concurrent MediaKeySession active.
- */
-export interface ICleanedOldSessionEvent {
-    type: "cleaned-old-session";
-    value: {
-        /** The MediaKeySession cleaned. */
-        mediaKeySession: MediaKeySession | ICustomMediaKeySession;
-        /** The type of MediaKeySession (e.g. "temporary"). */
-        sessionType: MediaKeySessionType;
-        /** Initialization data assiociated to this MediaKeySession. */
-        initializationData: IInitializationDataInfo;
-    };
-}
-/**
- * Event emitted when we are beginning to close an old MediaKeySession to
- * respect the maximum limit of concurrent MediaKeySession active.
- */
-export interface ICleaningOldSessionEvent {
-    type: "cleaning-old-session";
-    value: {
-        /** The MediaKeySession that we are currently cleaning. */
-        mediaKeySession: MediaKeySession | ICustomMediaKeySession;
-        /** The type of MediaKeySession (e.g. "temporary"). */
-        sessionType: MediaKeySessionType;
-        /** Initialization data assiociated to this MediaKeySession. */
-        initializationData: IInitializationDataInfo;
-    };
-}
-/**
- * Close sessions from the loadedSessionsStore to allow at maximum `limit`
- * stored MediaKeySessions in it.
- *
- * Emit event when a MediaKeySession begin to be closed and another when the
- * MediaKeySession is closed.
- * @param {Object} loadedSessionsStore
- * @returns {Observable}
- */
-export default function cleanOldLoadedSessions(loadedSessionsStore: LoadedSessionsStore, limit: number): Observable<ICleaningOldSessionEvent | ICleanedOldSessionEvent>;

package/dist/_esm5.processed/core/eme/clear_eme_session.js

@@ -1,50 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { defer as observableDefer, EMPTY, ignoreElements, } from "rxjs";
-import { shouldUnsetMediaKeys } from "../../compat/";
-import log from "../../log";
-import disposeMediaKeys from "./dispose_media_keys";
-import MediaKeysInfosStore from "./media_keys_infos_store";
-/**
- * Clear EME ressources that should be cleared when the current content stops
- * its playback.
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-export default function clearEMESession(mediaElement) {
-    return observableDefer(function () {
-        log.info("EME: Clearing-up EME session.");
-        if (shouldUnsetMediaKeys()) {
-            log.info("EME: disposing current MediaKeys.");
-            return disposeMediaKeys(mediaElement)
-                .pipe(ignoreElements());
-        }
-        var currentState = MediaKeysInfosStore.getState(mediaElement);
-        if (currentState !== null &&
-            currentState.keySystemOptions.closeSessionsOnStop === true) {
-            log.info("EME: closing all current sessions.");
-            return currentState.loadedSessionsStore.closeAllSessions()
-                // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
-                // first type parameter as `any` instead of the perfectly fine `unknown`,
-                // leading to linter issues, as it forbids the usage of `any`.
-                // This is why we're disabling the eslint rule.
-                /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
-                .pipe(ignoreElements());
-        }
-        log.info("EME: Nothing to clear. Returning right away. No state =", currentState === null);
-        return EMPTY;
-    });
-}