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

package/src/transports/utils/__tests__/check_isobmff_integrity.test.ts

@@ -1,49 +1,44 @@
-import { describe, beforeEach, it, expect, vi } from "vitest";
-import type { OtherError as IOtherError } from "../../../errors";
-import type ICheckISOBMFFIntegrity from "../check_isobmff_integrity";
+import { describe, beforeEach, it, expect, vi, afterEach } from "vitest";
+import { OtherError } from "../../../errors";
+import checkISOBMFFIntegrity from "../check_isobmff_integrity";
+
+const mocks = vi.hoisted(() => {
+  return {
+    findCompleteBox: vi.fn(),
+  };
+});
+vi.mock("../../../parsers/containers/isobmff", () => ({
+  findCompleteBox: mocks.findCompleteBox,
+}));
 
 describe("transports utils - checkISOBMFFIntegrity", () => {
   beforeEach(() => {
     vi.resetModules();
   });
+  afterEach(() => {
+    mocks.findCompleteBox.mockReset();
+  });
 
-  it("should check just ftyp and and moov integrity for init segments", async () => {
-    const mockFindCompleteBox = vi.fn(() => 45);
-    vi.doMock("../../../parsers/containers/isobmff", () => ({
-      findCompleteBox: mockFindCompleteBox,
-    }));
-    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
-      .default as typeof ICheckISOBMFFIntegrity;
+  it("should check just ftyp and and moov integrity for init segments", () => {
+    mocks.findCompleteBox.mockImplementation(() => 45);
     const myUint8Array = new Uint8Array([0, 1, 2]);
     expect(() => checkISOBMFFIntegrity(myUint8Array, true)).not.toThrow();
-    expect(mockFindCompleteBox).toHaveBeenCalledTimes(2);
-    expect(mockFindCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x66747970);
-    expect(mockFindCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x6d6f6f76);
+    expect(mocks.findCompleteBox).toHaveBeenCalledTimes(2);
+    expect(mocks.findCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x66747970);
+    expect(mocks.findCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x6d6f6f76);
   });
 
-  it("should check just moof and and mdat integrity for regular segments", async () => {
-    const mockFindCompleteBox = vi.fn(() => 45);
-    vi.doMock("../../../parsers/containers/isobmff", () => ({
-      findCompleteBox: mockFindCompleteBox,
-    }));
-    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
-      .default as typeof ICheckISOBMFFIntegrity;
+  it("should check just moof and and mdat integrity for regular segments", () => {
+    mocks.findCompleteBox.mockImplementation(() => 45);
     const myUint8Array = new Uint8Array([0, 1, 2]);
     expect(() => checkISOBMFFIntegrity(myUint8Array, false)).not.toThrow();
-    expect(mockFindCompleteBox).toHaveBeenCalledTimes(2);
-    expect(mockFindCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x6d6f6f66);
-    expect(mockFindCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x6d646174);
+    expect(mocks.findCompleteBox).toHaveBeenCalledTimes(2);
+    expect(mocks.findCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x6d6f6f66);
+    expect(mocks.findCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x6d646174);
   });
 
-  it("should throw an other error if an init segment is missing a complete ftyp", async () => {
-    const mockFindCompleteBox = vi.fn((_, box) => (box === 0x66747970 ? -1 : 45));
-    vi.doMock("../../../parsers/containers/isobmff", () => ({
-      findCompleteBox: mockFindCompleteBox,
-    }));
-    const OtherError = (await vi.importActual("../../../errors"))
-      .OtherError as typeof IOtherError;
-    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
-      .default as typeof ICheckISOBMFFIntegrity;
+  it("should throw an other error if an init segment is missing a complete ftyp", () => {
+    mocks.findCompleteBox.mockImplementation((_, box) => (box === 0x66747970 ? -1 : 45));
     const myUint8Array = new Uint8Array([0, 1, 2]);
     let error: unknown = null;
     try {
@@ -52,23 +47,16 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as IOtherError).name).toEqual("OtherError");
-    expect((error as IOtherError).type).toEqual("OTHER_ERROR");
-    expect((error as IOtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as IOtherError).message).toEqual(
+    expect((error as OtherError).name).toEqual("OtherError");
+    expect((error as OtherError).type).toEqual("OTHER_ERROR");
+    expect((error as OtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as OtherError).message).toEqual(
       "INTEGRITY_ERROR: Incomplete `ftyp` box",
     );
   });
 
-  it("should throw an other error if an init segment is missing a complete moov", async () => {
-    const mockFindCompleteBox = vi.fn((_, box) => (box === 0x6d6f6f76 ? -1 : 45));
-    vi.doMock("../../../parsers/containers/isobmff", () => ({
-      findCompleteBox: mockFindCompleteBox,
-    }));
-    const OtherError = (await vi.importActual("../../../errors"))
-      .OtherError as typeof IOtherError;
-    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
-      .default as typeof ICheckISOBMFFIntegrity;
+  it("should throw an other error if an init segment is missing a complete moov", () => {
+    mocks.findCompleteBox.mockImplementation((_, box) => (box === 0x6d6f6f76 ? -1 : 45));
     const myUint8Array = new Uint8Array([0, 1, 2]);
     let error: unknown = null;
     try {
@@ -77,23 +65,16 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as IOtherError).name).toEqual("OtherError");
-    expect((error as IOtherError).type).toEqual("OTHER_ERROR");
-    expect((error as IOtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as IOtherError).message).toEqual(
+    expect((error as OtherError).name).toEqual("OtherError");
+    expect((error as OtherError).type).toEqual("OTHER_ERROR");
+    expect((error as OtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as OtherError).message).toEqual(
       "INTEGRITY_ERROR: Incomplete `moov` box",
     );
   });
 
-  it("should throw an other error if a regular segment is missing a complete moof", async () => {
-    const mockFindCompleteBox = vi.fn((_, box) => (box === 0x6d6f6f66 ? -1 : 45));
-    vi.doMock("../../../parsers/containers/isobmff", () => ({
-      findCompleteBox: mockFindCompleteBox,
-    }));
-    const OtherError = (await vi.importActual("../../../errors"))
-      .OtherError as typeof IOtherError;
-    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
-      .default as typeof ICheckISOBMFFIntegrity;
+  it("should throw an other error if a regular segment is missing a complete moof", () => {
+    mocks.findCompleteBox.mockImplementation((_, box) => (box === 0x6d6f6f66 ? -1 : 45));
     const myUint8Array = new Uint8Array([0, 1, 2]);
     let error: unknown = null;
     try {
@@ -102,23 +83,16 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as IOtherError).name).toEqual("OtherError");
-    expect((error as IOtherError).type).toEqual("OTHER_ERROR");
-    expect((error as IOtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as IOtherError).message).toEqual(
+    expect((error as OtherError).name).toEqual("OtherError");
+    expect((error as OtherError).type).toEqual("OTHER_ERROR");
+    expect((error as OtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as OtherError).message).toEqual(
       "INTEGRITY_ERROR: Incomplete `moof` box",
     );
   });
 
-  it("should throw an other error if a regular segment is missing a complete mdat", async () => {
-    const mockFindCompleteBox = vi.fn((_, box) => (box === 0x6d646174 ? -1 : 45));
-    vi.doMock("../../../parsers/containers/isobmff", () => ({
-      findCompleteBox: mockFindCompleteBox,
-    }));
-    const OtherError = (await vi.importActual("../../../errors"))
-      .OtherError as typeof IOtherError;
-    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
-      .default as typeof ICheckISOBMFFIntegrity;
+  it("should throw an other error if a regular segment is missing a complete mdat", () => {
+    mocks.findCompleteBox.mockImplementation((_, box) => (box === 0x6d646174 ? -1 : 45));
     const myUint8Array = new Uint8Array([0, 1, 2]);
     let error: unknown = null;
     try {
@@ -127,10 +101,10 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as IOtherError).name).toEqual("OtherError");
-    expect((error as IOtherError).type).toEqual("OTHER_ERROR");
-    expect((error as IOtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as IOtherError).message).toEqual(
+    expect((error as OtherError).name).toEqual("OtherError");
+    expect((error as OtherError).type).toEqual("OTHER_ERROR");
+    expect((error as OtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as OtherError).message).toEqual(
       "INTEGRITY_ERROR: Incomplete `mdat` box",
     );
   });

package/src/transports/utils/parse_text_track.ts

@@ -87,9 +87,16 @@ export function getISOBMFFEmbeddedTextTrackData(
     language,
     codecs,
   }: {
+    /** The segment containing that subtitles data. */
     segment: ISegment;
-    codecs?: string | undefined;
-    language?: string | undefined;
+    /** The wanted subtitles "codecs" as announced by the packager/encoder. */
+    codecs: string | undefined;
+    /**
+     * The wanted language to display.
+     * Some subtitles format embed several different subtitles group for
+     * different languages. This allows to select the right one.
+     */
+    language: string | undefined;
   },
   chunkBytes: Uint8Array<ArrayBuffer>,
   initTimescale: number | undefined,
@@ -175,7 +182,7 @@ export function getPlainTextTrackData(
     }
   }
 
-  const type = getPlainTextTrackFormat(context.codecs, context.mimeType);
+  const type = getPlainTextTrackFormat(context.chosenCodec, context.mimeType);
   return {
     data: textTrackData,
     type,

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

@@ -5,10 +5,10 @@ describe("utils - objectAssign", () => {
   it("should throw if target is not an object", () => {
     expect(() => {
       objectAssign(null as unknown as object, {});
-    }).toThrow("Cannot convert undefined or null to object");
+    }).toThrow();
     expect(() => {
       objectAssign(undefined as unknown as object, {});
-    }).toThrow("Cannot convert undefined or null to object");
+    }).toThrow();
   });
 
   it("should update the first argument and return it", () => {