rx-player 4.3.0-dev.2024112900 → 4.3.0-dev.2025012900

package/src/compat/browser_compatibility_types.ts

@@ -270,8 +270,20 @@ export interface IMediaElement extends IEventTarget<IMediaElementEventMap> {
   oncanplay: ((evt: Event) => void) | null;
   oncanplaythrough: ((evt: Event) => void) | null;
   onended: ((evt: Event) => void) | null;
-  onenterpictureinpicture?: ((evt: Event) => void) | null;
-  onleavepictureinpicture?: ((evt: Event) => void) | null;
+  onenterpictureinpicture?:
+    | ((
+        evt: Event & {
+          pictureInPictureWindow: ICompatPictureInPictureWindow;
+        },
+      ) => void)
+    | null;
+  onleavepictureinpicture?:
+    | ((
+        evt: Event & {
+          pictureInPictureWindow: ICompatPictureInPictureWindow;
+        },
+      ) => void)
+    | null;
   onerror: ((evt: Event) => void) | null;
   onloadeddata: ((evt: Event) => void) | null;
   onloadedmetadata: ((evt: Event) => void) | null;
@@ -402,11 +414,17 @@ interface ICompatVideoTrack {
 export interface ICompatPictureInPictureWindow extends EventTarget {
   width: number;
   height: number;
+  onresize: ((evt: Event) => void) | null;
 }
 
-/* eslint-disable */
 /** MediaSource implementation, including vendored implementations. */
-const gs = globalScope as any;
+const gs = globalScope as typeof window & {
+  MozMediaSource?: typeof MediaSource | undefined | null;
+  WebKitMediaSource?: typeof MediaSource | undefined | null;
+  MSMediaSource?: typeof MediaSource | undefined | null;
+  ManagedMediaSource?: typeof MediaSource | undefined | null;
+};
+
 const MediaSource_:
   | { new (): IMediaSource; isTypeSupported(type: string): boolean }
   | undefined =

package/src/compat/browser_detection.ts

@@ -170,7 +170,7 @@ let isA1KStb40xx = false;
     isPanasonic = true;
   } else if (navigator.userAgent.indexOf("Xbox") !== -1) {
     isXbox = true;
-  } else if (navigator.userAgent.indexOf("Model/a1-kstb40xx")) {
+  } else if (navigator.userAgent.indexOf("Model/a1-kstb40xx") !== -1) {
     isA1KStb40xx = true;
   }
 })();

package/src/compat/event_listeners.ts

@@ -176,16 +176,14 @@ function createCompatibleEventListener(
         (element as IEventEmitterLike).addEventListener(eventName, listener);
       } else {
         hasSetOnFn = true;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-        (element as any)["on" + eventName] = listener;
+        element[("on" + eventName) as keyof IEventTargetLike] = listener;
       }
       cancelSignal.register(() => {
         if (typeof element.removeEventListener === "function") {
           (element as IEventEmitterLike).removeEventListener(eventName, listener);
         }
         if (hasSetOnFn) {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-          delete (element as any)["on" + eventName];
+          delete element[("on" + eventName) as keyof IEventTargetLike];
         }
       });
     });

package/src/compat/has_mse_in_worker.ts

@@ -1,6 +1,6 @@
 const hasMseInWorker =
   typeof MediaSource === "function" &&
   // eslint-disable-next-line
-  (MediaSource as any).canConstructInDedicatedWorker === true;
+  MediaSource.canConstructInDedicatedWorker === true;
 
 export default hasMseInWorker;

package/src/core/cmcd/cmcd_data_builder.ts

@@ -333,10 +333,7 @@ export default class CmcdDataBuilder {
     props.st = content.manifest.isDynamic ? "l" : "v";
     props.tb = content.adaptation.representations.reduce(
       (acc: number | undefined, representation: IRepresentation) => {
-        if (
-          representation.isSupported !== true ||
-          representation.decipherable === false
-        ) {
+        if (representation.isPlayable() !== true) {
           return acc;
         }
         if (acc === undefined) {

package/src/core/main/worker/send_message.ts

@@ -11,8 +11,10 @@ export default function sendMessage(
     postMessage(msg);
   } else {
     // TypeScript made a mistake here, and 2busy2fix
-    // eslint-disable-next-line
-    (postMessage as any)(msg, transferables);
+    (postMessage as (msg: IWorkerMessage, transferables: Transferable[]) => void)(
+      msg,
+      transferables,
+    );
   }
 }
 

package/src/core/main/worker/worker_main.ts

@@ -594,7 +594,7 @@ function loadOrReloadPreparedContent(
   );
 
   StreamOrchestrator(
-    { initialPeriod: manifest.periods[0], manifest },
+    { initialPeriod, manifest },
     playbackObserver,
     representationEstimator,
     segmentSinksStore,

package/src/core/stream/adaptation/adaptation_stream.ts

@@ -95,10 +95,7 @@ export default function AdaptationStream(
 
   const initialRepIds = content.representations.getValue().representationIds;
   const initialRepresentations = content.adaptation.representations.filter(
-    (r) =>
-      arrayIncludes(initialRepIds, r.id) &&
-      r.decipherable !== false &&
-      r.isSupported !== false,
+    (r) => arrayIncludes(initialRepIds, r.id) && r.isPlayable() !== false,
   );
 
   /** Emit the list of Representation for the adaptive logic. */
@@ -336,11 +333,11 @@ export default function AdaptationStream(
       representation,
     };
     currentRepresentation.setValue(representation);
-    if (adapStreamCanceller.isUsed()) {
+    if (fnCancelSignal.isCancelled()) {
       return; // previous callback has stopped everything by side-effect
     }
     callbacks.representationChange(repInfo);
-    if (adapStreamCanceller.isUsed()) {
+    if (fnCancelSignal.isCancelled()) {
       return; // previous callback has stopped everything by side-effect
     }
 
@@ -453,7 +450,7 @@ export default function AdaptationStream(
 
           // We wait 4 seconds to let the situation evolve by itself before
           // retrying loading segments with a lower buffer goal
-          cancellableSleep(4000, adapStreamCanceller.signal)
+          cancellableSleep(4000, fnCancelSignal)
             .then(() => {
               return createRepresentationStream(
                 representation,

package/src/core/stream/period/period_stream.ts

@@ -470,9 +470,9 @@ function createOrReuseSegmentSink(
  * @returns {string}
  */
 function getFirstDeclaredMimeType(adaptation: IAdaptation): string {
-  const representations = adaptation.representations.filter((r) => {
-    return r.isSupported === true && r.decipherable !== false;
-  });
+  const representations = adaptation.representations.filter(
+    (r) => r.isPlayable() !== false,
+  );
   if (representations.length === 0) {
     const noRepErr = new MediaError(
       "NO_PLAYABLE_REPRESENTATION",

package/src/core/stream/period/utils/get_adaptation_switch_strategy.ts

@@ -189,8 +189,7 @@ export default function getAdaptationSwitchStrategy(
 function hasCompatibleCodec(adaptation: IAdaptation, segmentSinkCodec: string): boolean {
   return adaptation.representations.some(
     (rep) =>
-      rep.isSupported === true &&
-      rep.decipherable !== false &&
+      rep.isPlayable() === true &&
       areCodecsCompatible(rep.getMimeTypeString(), segmentSinkCodec),
   );
 }

package/src/main_thread/api/public_api.ts

@@ -411,7 +411,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.3.0-dev.2024112900";
+    this.version = /* PLAYER_VERSION */ "4.3.0-dev.2025012900";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -1335,7 +1335,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
    * `false` otherwise.
    */
   isPaused(): boolean {
-    if (this.videoElement) {
+    if (this.videoElement !== null) {
       if (arrayIncludes(["LOADING", "RELOADING"], this.state)) {
         return !this._priv_lastAutoPlay;
       } else {
@@ -2778,7 +2778,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // Emit initial events for the Period
     if (!isNullOrUndefined(tracksStore)) {
       const periodRef = tracksStore.getPeriodObjectFromPeriod(period);
-      if (periodRef) {
+      if (periodRef !== undefined) {
         const audioTrack = tracksStore.getChosenAudioTrack(periodRef, true);
         this._priv_triggerEventIfNotStopped("audioTrackChange", audioTrack, cancelSignal);
         const textTrack = tracksStore.getChosenTextTrack(periodRef);
@@ -3330,7 +3330,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.3.0-dev.2024112900";
+Player.version = /* PLAYER_VERSION */ "4.3.0-dev.2025012900";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts

@@ -367,6 +367,108 @@ describe("decrypt - global tests - media key system access", () => {
     );
   });
 
+  it("should want only persistent sessions if wantedSessionTypes is set to `['persistent-license']`", async () => {
+    const mockRequestMediaKeySystemAccess = vi
+      .fn()
+      .mockImplementation(() => Promise.reject("nope"));
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
+    await checkIncompatibleKeySystemsErrorMessage([
+      {
+        type: "foo",
+        getLicense: neverCalledFn,
+        wantedSessionTypes: ["persistent-license"],
+      },
+    ]);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
+      return {
+        ...conf,
+        sessionTypes: ["persistent-license"],
+      };
+    });
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
+  });
+
+  it("should want only temporary sessions if wantedSessionTypes is set to `['temporary']`", async () => {
+    const mockRequestMediaKeySystemAccess = vi
+      .fn()
+      .mockImplementation(() => Promise.reject("nope"));
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
+    await checkIncompatibleKeySystemsErrorMessage([
+      {
+        type: "foo",
+        getLicense: neverCalledFn,
+        wantedSessionTypes: ["temporary"],
+      },
+    ]);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
+      return {
+        ...conf,
+        sessionTypes: ["temporary"],
+      };
+    });
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
+  });
+
+  it("should want both temporary and persistent sessions if wantedSessionTypes is set to `['persistent-license', 'temporary']`", async () => {
+    const mockRequestMediaKeySystemAccess = vi
+      .fn()
+      .mockImplementation(() => Promise.reject("nope"));
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
+    await checkIncompatibleKeySystemsErrorMessage([
+      {
+        type: "foo",
+        getLicense: neverCalledFn,
+        wantedSessionTypes: ["persistent-license", "temporary"],
+      },
+    ]);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
+      return {
+        ...conf,
+        sessionTypes: ["persistent-license", "temporary"],
+      };
+    });
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
+  });
+
   it("should want persistent sessions if persistentLicenseConfig is set", async () => {
     const mockRequestMediaKeySystemAccess = vi
       .fn()
@@ -387,6 +489,137 @@ describe("decrypt - global tests - media key system access", () => {
     ]);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
 
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
+      return {
+        ...conf,
+        persistentState: "required",
+        sessionTypes: ["persistent-license"],
+      };
+    });
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
+  });
+
+  it("should not want persistent sessions if persistentLicenseConfig is set but wantedSessionTypes only wants temporary licenses", async () => {
+    const mockRequestMediaKeySystemAccess = vi
+      .fn()
+      .mockImplementation(() => Promise.reject("nope"));
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
+    const persistentLicenseConfig = {
+      save() {
+        throw new Error("Should not save.");
+      },
+      load() {
+        throw new Error("Should not load.");
+      },
+    };
+    await checkIncompatibleKeySystemsErrorMessage([
+      {
+        type: "foo",
+        getLicense: neverCalledFn,
+        wantedSessionTypes: ["temporary"],
+        persistentLicenseConfig,
+      },
+    ]);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
+      return {
+        ...conf,
+        sessionTypes: ["temporary"],
+      };
+    });
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
+  });
+
+  it("should properly handle persistentLicenseConfig and wantedSessionTypes set to persistent-license", async () => {
+    const mockRequestMediaKeySystemAccess = vi
+      .fn()
+      .mockImplementation(() => Promise.reject("nope"));
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
+    const persistentLicenseConfig = {
+      save() {
+        throw new Error("Should not save.");
+      },
+      load() {
+        throw new Error("Should not load.");
+      },
+    };
+    await checkIncompatibleKeySystemsErrorMessage([
+      {
+        type: "foo",
+        getLicense: neverCalledFn,
+        wantedSessionTypes: ["persistent-license"],
+        persistentLicenseConfig,
+      },
+    ]);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
+      return {
+        ...conf,
+        persistentState: "required",
+        sessionTypes: ["persistent-license"],
+      };
+    });
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
+  });
+
+  it("should properly handle persistentLicenseConfig and wantedSessionTypes set to both temporary and persistent-license", async () => {
+    const mockRequestMediaKeySystemAccess = vi
+      .fn()
+      .mockImplementation(() => Promise.reject("nope"));
+    mockCompat({
+      requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
+    });
+    const persistentLicenseConfig = {
+      save() {
+        throw new Error("Should not save.");
+      },
+      load() {
+        throw new Error("Should not load.");
+      },
+    };
+    await checkIncompatibleKeySystemsErrorMessage([
+      {
+        type: "foo",
+        getLicense: neverCalledFn,
+        wantedSessionTypes: ["temporary", "persistent-license"],
+        persistentLicenseConfig,
+      },
+    ]);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+
     const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
       return {
         ...conf,
@@ -680,7 +913,7 @@ describe("decrypt - global tests - media key system access", () => {
         return {
           ...conf,
           persistentState: "required",
-          sessionTypes: ["temporary", "persistent-license"],
+          sessionTypes: ["persistent-license"],
         };
       });
     const expectedPersistentConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map(
@@ -688,7 +921,7 @@ describe("decrypt - global tests - media key system access", () => {
         return {
           ...conf,
           persistentState: "required",
-          sessionTypes: ["temporary", "persistent-license"],
+          sessionTypes: ["persistent-license"],
         };
       },
     );
@@ -786,7 +1019,7 @@ describe("decrypt - global tests - media key system access", () => {
         return {
           ...conf,
           persistentState: "required",
-          sessionTypes: ["temporary", "persistent-license"],
+          sessionTypes: ["persistent-license"],
         };
       });
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
@@ -833,7 +1066,7 @@ describe("decrypt - global tests - media key system access", () => {
         return {
           ...conf,
           persistentState: "required",
-          sessionTypes: ["temporary", "persistent-license"],
+          sessionTypes: ["persistent-license"],
         };
       },
     );
@@ -842,7 +1075,7 @@ describe("decrypt - global tests - media key system access", () => {
         return {
           ...conf,
           persistentState: "required",
-          sessionTypes: ["temporary", "persistent-license"],
+          sessionTypes: ["persistent-license"],
         };
       });
     const expectedIdentifierConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map(
@@ -939,7 +1172,7 @@ describe("decrypt - global tests - media key system access", () => {
         return {
           ...conf,
           persistentState: "required",
-          sessionTypes: ["temporary", "persistent-license"],
+          sessionTypes: ["persistent-license"],
         };
       });
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);