rx-player 3.29.0-dev.2022090500 → 3.29.0-dev.2022091600

package/dist/_esm5.processed/public_types.d.ts

@@ -447,6 +447,7 @@ export interface IKeySystemOption {
     /**
      * If explicitely set to `false`, we won't throw on error when a used license
      * is expired.
+     * @deprecated
      */
     throwOnLicenseExpiration?: boolean;
     /**
@@ -476,6 +477,42 @@ export interface IKeySystemOption {
          */
         keyOutputRestricted?: boolean;
     };
+    /**
+     * Behavior the RxPlayer should have when one of the key is known to be
+     * expired.
+     *
+     * `onKeyExpiration` can be set to a string, each describing a different
+     * behavior, the default one if not is defined being `"error"`:
+     *
+     *   - `"error"`: The RxPlayer will stop on an error when any key is expired.
+     *     This is the default behavior.
+     *
+     *   - `"continue"`: The RxPlayer will not do anything when a key expires.
+     *     This may lead in many cases to infinite rebuffering.
+     *
+     *   - `"fallback"`: The Representation(s) linked to the expired key(s) will
+     *     be fallbacked from, meaning the RxPlayer will switch to other
+     *     representation without expired keys.
+     *
+     *     If no Representation remain, a NO_PLAYABLE_REPRESENTATION error will
+     *     be thrown.
+     *
+     *     Note that when the "fallbacking" action is taken, the RxPlayer might
+     *     temporarily switch to the `"RELOADING"` state - which should thus be
+     *     properly handled.
+     *
+     *   - `"close-session"`: The RxPlayer will close and re-create a DRM session
+     *     (and thus re-download the corresponding license) if any of the key
+     *     associated to this session expired.
+     *
+     *     It will try to do so in an efficient manner, only reloading the license
+     *     when the corresponding content plays.
+     *
+     *     The RxPlayer might go through the `"RELOADING"` state after an expired
+     *     key and/or light decoding glitches can arise, depending on the
+     *     platform, for some seconds, under that mode.
+     */
+    onKeyExpiration?: "error" | "continue" | "fallback" | "close-session";
 }
 /**
  * Data stored in a persistent MediaKeySession storage.
@@ -672,4 +709,14 @@ export interface IAvailableTextTrack extends ITextTrack {
 export interface IAvailableVideoTrack extends IVideoTrack {
     active: boolean;
 }
+/**
+ * Type of a single object from the optional `EncryptedMediaError`'s
+ * `keyStatuses` property.
+ */
+export interface IEncryptedMediaErrorKeyStatusObject {
+    /** Corresponding keyId which encountered the problematic MediaKeyStatus. */
+    keyId: ArrayBuffer;
+    /** Problematic MediaKeyStatus encountered. */
+    keyStatus: MediaKeyStatus;
+}
 export {};

package/dist/_esm5.processed/utils/reference.d.ts

@@ -93,7 +93,24 @@ export interface ISharedReference<T> {
     onUpdate(cb: (val: T) => void, options?: {
         clearSignal?: CancellationSignal | undefined;
         emitCurrentValue?: boolean | undefined;
-    }): void;
+    } | undefined): void;
+    /**
+     * 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 im 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;
     /**
      * Indicate that no new values will be emitted.
      * Allows to automatically close all Observables generated from this shared
@@ -149,6 +166,9 @@ export interface IReadOnlySharedReference<T> {
         clearSignal?: CancellationSignal | undefined;
         emitCurrentValue?: boolean | undefined;
     } | undefined): void;
+    waitUntilDefined(cb: (val: Exclude<T, undefined>) => void, options?: {
+        clearSignal?: CancellationSignal | undefined;
+    } | undefined): void;
 }
 /**
  * Create an `ISharedReference` object encapsulating the mutable `initialValue`
@@ -158,7 +178,7 @@ export interface IReadOnlySharedReference<T> {
  * @param {*} initialValue
  * @returns {Observable}
  */
-export declare function createSharedReference<T>(initialValue: T): ISharedReference<T>;
+export default function createSharedReference<T>(initialValue: T): ISharedReference<T>;
 /**
  * Create a new `ISharedReference` based on another one by mapping over its
  * referenced value each time it is updated.
@@ -171,4 +191,4 @@ export declare function createSharedReference<T>(initialValue: T): ISharedRefere
  * @returns {Object} - The new, mapped, reference.
  */
 export declare function createMappedReference<T, U>(originalRef: IReadOnlySharedReference<T>, mappingFn: (x: T) => U, cancellationSignal?: CancellationSignal): IReadOnlySharedReference<U>;
-export default createSharedReference;
+export { createSharedReference };

package/dist/_esm5.processed/utils/reference.js

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { Observable, } from "rxjs";
+import TaskCanceller from "./task_canceller";
 /**
  * Create an `ISharedReference` object encapsulating the mutable `initialValue`
  * value of type T.
@@ -22,7 +23,7 @@ import { Observable, } from "rxjs";
  * @param {*} initialValue
  * @returns {Observable}
  */
-export function createSharedReference(initialValue) {
+export default function createSharedReference(initialValue) {
     /** Current value referenced by this `ISharedReference`. */
     var value = initialValue;
     /**
@@ -162,6 +163,26 @@ export function createSharedReference(initialValue) {
                 }
             }
         },
+        waitUntilDefined: function (cb, options) {
+            if (value !== undefined) {
+                cb(value);
+                return;
+            }
+            if (isFinished) {
+                return;
+            }
+            var childCanceller = new TaskCanceller();
+            if ((options === null || options === void 0 ? void 0 : options.clearSignal) !== undefined) {
+                options.clearSignal.register(function () { return childCanceller.cancel(); });
+            }
+            this.onUpdate(function (val) {
+                if (val !== undefined) {
+                    childCanceller.cancel();
+                    cb(value);
+                    return;
+                }
+            }, { clearSignal: childCanceller.signal });
+        },
         /**
          * Indicate that no new values will be emitted.
          * Allows to automatically close all Observables generated from this shared
@@ -211,4 +232,4 @@ export function createMappedReference(originalRef, mappingFn, cancellationSignal
     }
     return newRef;
 }
-export default createSharedReference;
+export { createSharedReference };