rx-player 4.5.0-dev.2026033100 → 4.5.0-dev.2026041501

package/src/core/stream/representation/utils/__tests__/push_media_segment.test.ts

@@ -1,84 +1,104 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { CancellationSignal } from "../../../../../utils/task_canceller";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import configHandler from "../../../../../config";
+import {
+  DummyRepresentation,
+  DummyManifest,
+  DummyPeriod,
+  DummyAdaptation,
+  createSegment,
+} from "../../../../../manifest/classes/__tests__/mocks";
+import {
+  DummyObservationPosition,
+  makeReadyOnlyPlaybackObserver,
+} from "../../../../../playback_observer/__tests__/mocks";
+import type { IRange } from "../../../../../utils/ranges";
+import SharedReference from "../../../../../utils/reference";
+import TaskCanceller from "../../../../../utils/task_canceller";
+import { DummySegmentSink } from "../../../../segment_sinks/__tests__/mocks";
+import type { IRepresentationStreamPlaybackObservation } from "../../types";
 import pushMediaSegment from "../push_media_segment";
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-
-// Mock dependencies with vi.hoisted
-const mockGetCurrent = vi.hoisted(() => vi.fn());
-const mockObjectAssign = vi.hoisted(() => vi.fn());
-const mockAppendSegmentToBuffer = vi.hoisted(() => vi.fn());
-
-vi.mock("../../../../../config", () => ({
-  default: {
-    getCurrent: mockGetCurrent,
-  },
-}));
-
-vi.mock("../../../../../utils/object_assign", () => ({
-  default: mockObjectAssign,
-}));
-
+const mockAppendSegmentToBuffer = vi.hoisted(() =>
+  vi.fn((): Promise<IRange[]> => Promise.resolve([])),
+);
 vi.mock("../append_segment_to_buffer.ts", () => ({
   default: mockAppendSegmentToBuffer,
 }));
 
 describe("pushMediaSegment", () => {
-  const mockPlaybackObserver = {} as any;
-  const mockBufferGoal = { getValue: () => 30 } as any;
-  const mockCancelSignal = {} as CancellationSignal;
-  const mockSegmentSink = {} as any;
+  const mockedPlaybackObserver =
+    makeReadyOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>({
+      position: new DummyObservationPosition({
+        getWanted: vi.fn(() => 10),
+      }),
+      paused: {
+        last: false,
+        pending: undefined,
+      },
+      speed: 1,
+      canStream: true,
+    });
+  const mockGetCurrent = vi.spyOn(configHandler, "getCurrent");
+
+  let mockBufferGoal: SharedReference<number>;
+  let mockCanceller: TaskCanceller;
+  const mockSegmentSink = new DummySegmentSink();
 
   const mockContent = {
-    adaptation: {} as any,
-    manifest: {} as any,
-    period: {} as any,
-    representation: {
+    adaptation: new DummyAdaptation(),
+    manifest: new DummyManifest(),
+    period: new DummyPeriod(),
+    representation: new DummyRepresentation({
       getMimeTypeString: vi.fn(() => 'video/mp4; codecs="avc1.42E01E"'),
-    } as any,
+    }),
   };
 
-  const mockSegment = {
+  const mockSegment = createSegment({
     time: 10,
     duration: 5,
-  } as any;
+    end: 15,
+  });
 
   beforeEach(() => {
     vi.resetAllMocks();
+    mockBufferGoal = new SharedReference<number>(30);
+    mockCanceller = new TaskCanceller("pushInitSegment tests");
     mockGetCurrent.mockReturnValue({
+      ...configHandler.getCurrent(),
       APPEND_WINDOW_SECURITIES: {
         START: 0.1,
         END: 0.2,
       },
     });
-    mockObjectAssign.mockImplementation((target, ...sources) =>
-      // eslint-disable-next-line no-restricted-properties
-      Object.assign(target, ...sources),
-    );
   });
 
-  it("should return null when chunkData is null", async () => {
-    const parsedSegment: any = {
-      chunkData: null,
-      chunkInfos: null,
-      chunkOffset: 0,
-      chunkSize: 0,
-      appendWindow: [undefined, undefined] as [number | undefined, number | undefined],
-    };
+  afterEach(() => {
+    mockedPlaybackObserver.reset();
+    mockBufferGoal.finish();
+    mockCanceller.cancel("test end");
+    vi.resetModules();
+  });
 
+  it("should return null when chunkData is null", async () => {
     const result = await pushMediaSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         bufferGoal: mockBufferGoal,
         content: mockContent,
         initSegmentUniqueId: "init-123",
-        parsedSegment,
+        parsedSegment: {
+          chunkData: null,
+          chunkInfos: null,
+          chunkOffset: 0,
+          chunkSize: 0,
+          appendWindow: [undefined, undefined],
+          segmentType: "media",
+          protectionData: [],
+        },
         segment: mockSegment,
         segmentSink: mockSegmentSink,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(result).toBeNull();
@@ -87,32 +107,33 @@ describe("pushMediaSegment", () => {
 
   it("should append segment with basic data when chunkData is present", async () => {
     const mockChunkData = new Uint8Array([1, 2, 3]);
-    const parsedSegment: any = {
-      chunkData: mockChunkData,
-      chunkInfos: null,
-      chunkOffset: 2.5,
-      chunkSize: 1024,
-      appendWindow: [undefined, undefined] as [number | undefined, number | undefined],
-    };
 
     const mockBuffered = [{ start: 10, end: 15 }];
     mockAppendSegmentToBuffer.mockResolvedValue(mockBuffered);
 
     const result = await pushMediaSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         bufferGoal: mockBufferGoal,
         content: mockContent,
         initSegmentUniqueId: "init-123",
-        parsedSegment,
+        parsedSegment: {
+          chunkData: mockChunkData,
+          chunkInfos: null,
+          chunkOffset: 2.5,
+          chunkSize: 1024,
+          appendWindow: [undefined, undefined],
+          segmentType: "media",
+          protectionData: [],
+        },
         segment: mockSegment,
         segmentSink: mockSegmentSink,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
-      mockPlaybackObserver,
+      mockedPlaybackObserver.observer,
       mockSegmentSink,
       {
         data: {
@@ -122,15 +143,16 @@ describe("pushMediaSegment", () => {
           appendWindow: [undefined, undefined],
           codec: 'video/mp4; codecs="avc1.42E01E"',
         },
-        inventoryInfos: expect.objectContaining({
+        inventoryInfos: {
+          ...mockContent,
           segment: mockSegment,
           chunkSize: 1024,
-          start: 10,
-          end: 15,
-        }),
+          start: mockSegment.time,
+          end: mockSegment.end,
+        },
       },
       mockBufferGoal,
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(result).toEqual({
@@ -142,202 +164,246 @@ describe("pushMediaSegment", () => {
 
   it("should use chunkInfos for time calculations when available", async () => {
     const mockChunkData = new Uint8Array([1, 2, 3]);
-    const parsedSegment: any = {
-      chunkData: mockChunkData,
-      chunkInfos: { time: 20, duration: 8 },
-      chunkOffset: 0,
-      chunkSize: 2048,
-      appendWindow: [undefined, undefined] as [number | undefined, number | undefined],
-    };
-
     mockAppendSegmentToBuffer.mockResolvedValue([]);
 
     await pushMediaSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         bufferGoal: mockBufferGoal,
         content: mockContent,
         initSegmentUniqueId: null,
-        parsedSegment,
+        parsedSegment: {
+          chunkData: mockChunkData,
+          chunkInfos: { time: 20, duration: 8 },
+          chunkOffset: 0,
+          chunkSize: 2048,
+          appendWindow: [undefined, undefined],
+          segmentType: "media",
+          protectionData: [],
+        },
         segment: mockSegment,
         segmentSink: mockSegmentSink,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.anything(),
-      expect.objectContaining({
-        inventoryInfos: expect.objectContaining({
+      mockedPlaybackObserver.observer,
+      mockSegmentSink,
+      {
+        data: {
+          appendWindow: [undefined, undefined],
+          chunk: mockChunkData,
+          codec: 'video/mp4; codecs="avc1.42E01E"',
+          initSegmentUniqueId: null,
+          timestampOffset: 0,
+        },
+        inventoryInfos: {
+          ...mockContent,
+          segment: mockSegment,
           start: 20,
           end: 28,
-        }),
-      }),
-      expect.anything(),
-      expect.anything(),
+          chunkSize: 2048,
+        },
+      },
+      mockBufferGoal,
+      mockCanceller.signal,
     );
   });
 
   it("should apply append window securities to start window", async () => {
     const mockChunkData = new Uint8Array([1, 2, 3]);
-    const parsedSegment: any = {
-      chunkData: mockChunkData,
-      chunkInfos: null,
-      chunkOffset: 0,
-      chunkSize: 1024,
-      appendWindow: [5, undefined] as [number | undefined, number | undefined],
-    };
-
     mockAppendSegmentToBuffer.mockResolvedValue([]);
-
     await pushMediaSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         bufferGoal: mockBufferGoal,
         content: mockContent,
         initSegmentUniqueId: "init-123",
-        parsedSegment,
+        parsedSegment: {
+          chunkData: mockChunkData,
+          chunkInfos: null,
+          chunkOffset: 0,
+          chunkSize: 1024,
+          appendWindow: [5, undefined],
+          segmentType: "media",
+          protectionData: [],
+        },
         segment: mockSegment,
         segmentSink: mockSegmentSink,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.anything(),
-      expect.objectContaining({
-        data: expect.objectContaining({
+      {},
+      mockSegmentSink,
+      {
+        data: {
+          chunk: mockChunkData,
+          initSegmentUniqueId: "init-123",
+          timestampOffset: 0,
           appendWindow: [4.9, undefined], // 5 - 0.1
-        }),
-        inventoryInfos: expect.objectContaining({
+          codec: 'video/mp4; codecs="avc1.42E01E"',
+        },
+        inventoryInfos: {
+          ...mockContent,
           start: 10, // max(10, 4.9)
-        }),
-      }),
-      expect.anything(),
-      expect.anything(),
+          end: mockSegment.end,
+          chunkSize: 1024,
+          segment: mockSegment,
+        },
+      },
+      mockBufferGoal,
+      mockCanceller.signal,
     );
   });
 
   it("should apply append window securities to end window", async () => {
     const mockChunkData = new Uint8Array([1, 2, 3]);
-    const parsedSegment: any = {
-      chunkData: mockChunkData,
-      chunkInfos: null,
-      chunkOffset: 0,
-      chunkSize: 1024,
-      appendWindow: [undefined, 20] as [number | undefined, number | undefined],
-    };
-
     mockAppendSegmentToBuffer.mockResolvedValue([]);
 
     await pushMediaSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         bufferGoal: mockBufferGoal,
         content: mockContent,
         initSegmentUniqueId: "init-123",
-        parsedSegment,
+        parsedSegment: {
+          chunkData: mockChunkData,
+          chunkInfos: null,
+          chunkOffset: 0,
+          chunkSize: 1024,
+          appendWindow: [undefined, 20],
+          segmentType: "media",
+          protectionData: [],
+        },
         segment: mockSegment,
         segmentSink: mockSegmentSink,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.anything(),
-      expect.objectContaining({
-        data: expect.objectContaining({
+      mockedPlaybackObserver.observer,
+      mockSegmentSink,
+      {
+        data: {
+          initSegmentUniqueId: "init-123",
+          chunk: mockChunkData,
+          timestampOffset: 0,
+          codec: 'video/mp4; codecs="avc1.42E01E"',
           appendWindow: [undefined, 20.2], // 20 + 0.2
-        }),
-        inventoryInfos: expect.objectContaining({
+        },
+        inventoryInfos: {
+          ...mockContent,
+          segment: mockSegment,
           end: 15, // min(15, 20.2)
-        }),
-      }),
-      expect.anything(),
-      expect.anything(),
+          chunkSize: 1024,
+          start: mockSegment.time,
+        },
+      },
+      mockBufferGoal,
+      mockCanceller.signal,
     );
   });
 
   it("should apply both start and end append windows", async () => {
     const mockChunkData = new Uint8Array([1, 2, 3]);
-    const parsedSegment: any = {
-      chunkData: mockChunkData,
-      chunkInfos: { time: 8, duration: 4 },
-      chunkOffset: 0,
-      chunkSize: 1024,
-      appendWindow: [9, 11] as [number | undefined, number | undefined],
-    };
-
     mockAppendSegmentToBuffer.mockResolvedValue([]);
 
     await pushMediaSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         bufferGoal: mockBufferGoal,
         content: mockContent,
         initSegmentUniqueId: "init-123",
-        parsedSegment,
+        parsedSegment: {
+          chunkData: mockChunkData,
+          chunkInfos: { time: 8, duration: 4 },
+          chunkOffset: 0,
+          chunkSize: 1024,
+          appendWindow: [9, 11],
+          segmentType: "media",
+          protectionData: [],
+        },
         segment: mockSegment,
         segmentSink: mockSegmentSink,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.anything(),
-      expect.objectContaining({
-        data: expect.objectContaining({
+      mockedPlaybackObserver.observer,
+      mockSegmentSink,
+      {
+        data: {
           appendWindow: [8.9, 11.2], // [9 - 0.1, 11 + 0.2]
-        }),
-        inventoryInfos: expect.objectContaining({
+          initSegmentUniqueId: "init-123",
+          chunk: mockChunkData,
+          timestampOffset: 0,
+          codec: 'video/mp4; codecs="avc1.42E01E"',
+        },
+        inventoryInfos: {
           start: 8.9, // max(8, 8.9)
           end: 11.2, // min(12, 11.2)
-        }),
-      }),
-      expect.anything(),
-      expect.anything(),
+          ...mockContent,
+          segment: mockSegment,
+          chunkSize: 1024,
+        },
+      },
+      mockBufferGoal,
+      mockCanceller.signal,
     );
   });
 
   it("should not go below 0 for start append window", async () => {
     const mockChunkData = new Uint8Array([1, 2, 3]);
-    const parsedSegment: any = {
-      chunkData: mockChunkData,
-      chunkInfos: null,
-      chunkOffset: 0,
-      chunkSize: 1024,
-      appendWindow: [0.05, undefined] as [number | undefined, number | undefined],
-    };
-
     mockAppendSegmentToBuffer.mockResolvedValue([]);
 
     await pushMediaSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         bufferGoal: mockBufferGoal,
         content: mockContent,
         initSegmentUniqueId: "init-123",
-        parsedSegment,
+        parsedSegment: {
+          chunkData: mockChunkData,
+          chunkInfos: null,
+          chunkOffset: 0,
+          chunkSize: 1024,
+          appendWindow: [0.05, undefined],
+          segmentType: "media",
+          protectionData: [],
+        },
         segment: mockSegment,
         segmentSink: mockSegmentSink,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(mockAppendSegmentToBuffer).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.anything(),
-      expect.objectContaining({
-        data: expect.objectContaining({
+      mockedPlaybackObserver.observer,
+      mockSegmentSink,
+      {
+        data: {
           appendWindow: [0, undefined], // max(0, 0.05 - 0.1)
-        }),
-      }),
-      expect.anything(),
-      expect.anything(),
+
+          initSegmentUniqueId: "init-123",
+          chunk: mockChunkData,
+          timestampOffset: 0,
+          codec: 'video/mp4; codecs="avc1.42E01E"',
+        },
+        inventoryInfos: {
+          ...mockContent,
+          segment: mockSegment,
+          chunkSize: 1024,
+          start: mockSegment.time,
+          end: mockSegment.end,
+        },
+      },
+      mockBufferGoal,
+      mockCanceller.signal,
     );
   });
 });

package/src/default_config.ts

@@ -1262,6 +1262,12 @@ const DEFAULT_CONFIG = {
 
   // Compatibility toggles:
 
+  /**
+   * If set to `true`, we will not patch out a `pssh` box if found in an
+   * ISOBMFF segment.
+   */
+  PREVENT_PSSH_PATCHING: false,
+
   /**
    * If set to `true`, we'll always try to check thoroughly that a
    * `MediaKeySystemAccess` can be relied on.

package/src/experimental/README.md

@@ -15,5 +15,5 @@ is mainly to confine the "library path" of that feature to the
 `rx-player/experimental/features` subdirectory.
 
 Note that tools NEED to be declared in their own directory inside a `./tools/<TOOL_NAME>`
-directory, with their inner `index.js` file exporting them, as that's a requirement from
+directory, with their inner `index.ts` file exporting them, as that's a requirement from
 our exporting strategy.

package/src/features/README.md

@@ -3,8 +3,8 @@
 This directory regroups the code importing all the "features" of the RxPlayer piece by
 piece.
 
-It is mostly used for allowing a library user to only imports some features of the
-RxPlayer without importing others.
+It is mostly used for allowing a library user to import only some features of the RxPlayer
+without importing others.
 
 How this is technically done is through a global `features` Object, which will have added
 properties (which corresponds to those features' code) each time a new feature is added.
@@ -12,4 +12,4 @@ properties (which corresponds to those features' code) each time a new feature i
 ## For workers
 
 The `worker` directory contains features intended for the worker-side that will then be
-exported through the RxPlayer's `worker/features` path.
+exported through the RxPlayer's `experimental/worker/features` path.

package/src/main_thread/api/README.md

@@ -20,13 +20,12 @@ As such, its main roles are to:
 
 To facilitate those actions, the API relies on multiple building blocks:
 
-- **the `PlaybackObserver` (./playback_observer.ts)**
-
-  Provide multiple methods allowing to monitor the current playback conditions (e.g. the
-  current position and/or the current playback rate). Many RxPlayer modules rely on this
-  PlaybackObserver.
-
 - **the `option utils` (./option_utils.ts)**
 
   Parse options given to some RxPlayer API calls, to add default parameters and provide
-  inteligible warnings/errors
+  intelligible warnings/errors
+
+- **the `debug` directory (./debug/)**
+
+  Contains the logic for the debug overlay API, (e.g. that can be rendered through the
+  `createDebugElement` RxPlayer API)