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

package/jest.config.js

@@ -9,7 +9,7 @@ module.exports = {
     // Without this, Jest just fails when importing rxjs, for some arcane
     // ESM-vs-CommonJS reasons linked to how it works internally.
     moduleNameMapper: {
-      '^rxjs$': require.resolve('rxjs'),
+      "^rxjs$": require.resolve("rxjs"),
   },
   testMatch: ["**/?(*.)+(spec|test).[jt]s?(x)"],
   collectCoverageFrom: [
@@ -17,29 +17,34 @@ module.exports = {
     "!src/**/index.ts",
     "!**/__tests__/**",
   ],
-  globals: {
-    "ts-jest": {
-      tsconfig: {
-        target: "es2017",
-        lib: ["es2017", "dom"],
-        forceConsistentCasingInFileNames: true,
-        skipLibCheck: false,
-        noImplicitAny: true,
-        strict: true,
-        strictNullChecks: true,
-        strictPropertyInitialization: true,
-        noUnusedParameters: true,
-        noUnusedLocals: true,
-        types: ["node", "jest"],
-        module: "es2015",
-        moduleResolution: "node",
-        esModuleInterop: true,
-        typeRoots: [
-          "./src/typings",
-          "./node_modules/@types",
-        ],
+  transform: {
+    "^.+\\.tsx?$": [
+      "ts-jest",
+      {
+        tsconfig: {
+          target: "es2017",
+          lib: ["es2017", "dom"],
+          forceConsistentCasingInFileNames: true,
+          skipLibCheck: false,
+          noImplicitAny: true,
+          strict: true,
+          strictNullChecks: true,
+          strictPropertyInitialization: true,
+          noUnusedParameters: true,
+          noUnusedLocals: true,
+          types: ["node", "jest"],
+          module: "es2015",
+          moduleResolution: "node",
+          esModuleInterop: true,
+          typeRoots: [
+            "./src/typings",
+            "./node_modules/@types",
+          ],
+        },
       },
-    },
+    ],
+  },
+  globals: {
     __FEATURES__: {
       IS_DISABLED: 0,
       IS_ENABLED: 1,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.29.0-dev.2022091600",
+  "version": "3.29.0-dev.2022103100",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [
@@ -78,59 +78,59 @@
   },
   "dependencies": {
     "next-tick": "1.1.0",
-    "rxjs": "7.4.0"
+    "rxjs": "7.5.7"
   },
   "devDependencies": {
-    "@babel/core": "7.18.13",
-    "@babel/plugin-transform-runtime": "7.18.10",
-    "@babel/preset-env": "7.18.10",
+    "@babel/core": "7.19.6",
+    "@babel/plugin-transform-runtime": "7.19.6",
+    "@babel/preset-env": "7.19.4",
     "@babel/preset-react": "7.18.6",
     "@types/chai": "4.3.3",
-    "@types/jest": "28.1.8",
-    "@types/mocha": "9.1.1",
-    "@types/node": "18.7.14",
+    "@types/jest": "29.2.0",
+    "@types/mocha": "10.0.0",
+    "@types/node": "18.11.8",
     "@types/sinon": "10.0.13",
-    "@typescript-eslint/eslint-plugin": "5.36.1",
-    "@typescript-eslint/eslint-plugin-tslint": "5.36.1",
-    "@typescript-eslint/parser": "5.36.1",
+    "@typescript-eslint/eslint-plugin": "5.41.0",
+    "@typescript-eslint/eslint-plugin-tslint": "5.41.0",
+    "@typescript-eslint/parser": "5.41.0",
     "arraybuffer-loader": "1.0.8",
-    "babel-loader": "8.2.5",
+    "babel-loader": "9.0.0",
     "chai": "4.3.6",
     "cheerio": "1.0.0-rc.12",
-    "core-js": "3.25.0",
-    "esbuild": "0.15.6",
-    "eslint": "8.23.0",
+    "core-js": "3.26.0",
+    "esbuild": "0.15.12",
+    "eslint": "8.26.0",
     "eslint-plugin-import": "2.26.0",
-    "eslint-plugin-jsdoc": "39.3.6",
-    "eslint-plugin-react": "7.31.1",
+    "eslint-plugin-jsdoc": "39.4.0",
+    "eslint-plugin-react": "7.31.10",
     "esm": "3.2.25",
-    "express": "4.18.1",
+    "express": "4.18.2",
     "highlight.js": "11.6.0",
     "html-entities": "2.3.3",
-    "jest": "28.1.3",
-    "jest-environment-jsdom": "28.1.3",
-    "karma": "6.4.0",
+    "jest": "29.2.2",
+    "jest-environment-jsdom": "29.2.2",
+    "karma": "6.4.1",
     "karma-chrome-launcher": "3.1.1",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
     "karma-webpack": "5.0.0",
     "markdown-it": "13.0.1",
-    "mocha": "10.0.0",
+    "mocha": "10.1.0",
     "mocha-loader": "5.1.5",
     "raw-loader": "4.0.2",
     "react": "18.2.0",
     "react-dom": "18.2.0",
-    "regenerator-runtime": "0.13.9",
+    "regenerator-runtime": "0.13.10",
     "rimraf": "3.0.2",
-    "semver": "7.3.7",
-    "sinon": "14.0.0",
+    "semver": "7.3.8",
+    "sinon": "14.0.1",
     "terser-webpack-plugin": "5.3.6",
-    "ts-jest": "28.0.8",
-    "ts-loader": "9.3.1",
+    "ts-jest": "29.0.3",
+    "ts-loader": "9.4.1",
     "tslint": "6.1.3",
-    "typescript": "4.8.2",
+    "typescript": "4.8.4",
     "webpack": "5.74.0",
-    "webpack-bundle-analyzer": "4.6.1",
+    "webpack-bundle-analyzer": "4.7.0",
     "webpack-cli": "4.10.0"
   },
   "scripts-list": {

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.29.0-dev.2022091600
+sonar.projectVersion=3.29.0-dev.2022103100
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/compat/__tests__/can_reuse_media_keys.test.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+describe("Compat - canReuseMediaKeys", () => {
+  afterEach(() => {
+    jest.resetModules();
+  });
+
+  it("should return true on any browser but WebOS 2021 and 2022", () => {
+    jest.mock("../browser_detection", () => {
+      return { __esModule: true as const,
+               isWebOs2021: false,
+               isWebOs2022: false };
+    });
+    const canReuseMediaKeys =
+      jest.requireActual("../can_reuse_media_keys.ts");
+    expect(canReuseMediaKeys.default()).toBe(true);
+  });
+
+  it("should return false on WebOs 2021", () => {
+    jest.mock("../browser_detection", () => {
+      return { __esModule: true as const,
+               isWebOs2021: true,
+               isWebOs2022: false };
+    });
+    const canReuseMediaKeys =
+      jest.requireActual("../can_reuse_media_keys.ts");
+    expect(canReuseMediaKeys.default()).toBe(false);
+  });
+
+  it("should return false on WebOs 2022", () => {
+    jest.mock("../browser_detection", () => {
+      return { __esModule: true as const,
+               isWebOs2021: false,
+               isWebOs2022: true };
+    });
+    const canReuseMediaKeys =
+      jest.requireActual("../can_reuse_media_keys.ts");
+    expect(canReuseMediaKeys.default()).toBe(false);
+  });
+
+  it("should return false in the improbable case of both WebOs 2021 and 2022", () => {
+    jest.mock("../browser_detection", () => {
+      return { __esModule: true as const,
+               isWebOs2021: true,
+               isWebOs2022: true };
+    });
+    const canReuseMediaKeys =
+      jest.requireActual("../can_reuse_media_keys.ts");
+    expect(canReuseMediaKeys.default()).toBe(false);
+  });
+});

package/src/compat/__tests__/enable_audio_track.test.ts

@@ -0,0 +1,341 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+describe("compat - enableAudioTrack", () => {
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  it("should enable the wanted audioTrack", () => {
+    jest.mock("../browser_detection", () => {
+      return {
+        __esModule: true as const,
+        isTizen: false,
+      };
+    });
+    const fakeAudioTracks = [
+      {
+        id: "id1",
+        kind: "descriptions",
+        label: "Toto",
+        language: "swa",
+        enabled: true,
+      },
+      {
+        id: "id2",
+        kind: "normal",
+        label: "Titi",
+        language: "fre",
+        enabled: false,
+      },
+      {
+        id: "id26",
+        kind: "bloop",
+        label: "hay",
+        language: "hay",
+        enabled: false,
+      },
+    ];
+    const enableAudioTrack = jest.requireActual("../enable_audio_track");
+    expect(enableAudioTrack.default(fakeAudioTracks, 2)).toEqual(true);
+    expect(fakeAudioTracks[0].enabled).toBe(false);
+    expect(fakeAudioTracks[1].enabled).toBe(false);
+    expect(fakeAudioTracks[2].enabled).toBe(true);
+    expect(enableAudioTrack.default(fakeAudioTracks, 1)).toEqual(true);
+    expect(fakeAudioTracks[0].enabled).toBe(false);
+    expect(fakeAudioTracks[1].enabled).toBe(true);
+    expect(fakeAudioTracks[2].enabled).toBe(false);
+    expect(enableAudioTrack.default(fakeAudioTracks, 0)).toEqual(true);
+    expect(fakeAudioTracks[0].enabled).toBe(true);
+    expect(fakeAudioTracks[1].enabled).toBe(false);
+    expect(fakeAudioTracks[2].enabled).toBe(false);
+  });
+
+  it("should enable the wanted audioTrack on Tizen", () => {
+    jest.mock("../browser_detection", () => {
+      return {
+        __esModule: true as const,
+        isTizen: true,
+      };
+    });
+    const fakeAudioTracks = [
+      {
+        id: "id1",
+        kind: "descriptions",
+        label: "Toto",
+        language: "swa",
+        enabled: true,
+      },
+      {
+        id: "id2",
+        kind: "normal",
+        label: "Titi",
+        language: "fre",
+        enabled: false,
+      },
+      {
+        id: "id26",
+        kind: "bloop",
+        label: "hay",
+        language: "hay",
+        enabled: false,
+      },
+    ];
+    const enableAudioTrack = jest.requireActual("../enable_audio_track");
+    expect(enableAudioTrack.default(fakeAudioTracks, 2)).toEqual(true);
+    expect(fakeAudioTracks[0].enabled).toBe(false);
+    expect(fakeAudioTracks[1].enabled).toBe(false);
+    expect(fakeAudioTracks[2].enabled).toBe(true);
+    expect(enableAudioTrack.default(fakeAudioTracks, 1)).toEqual(true);
+    expect(fakeAudioTracks[0].enabled).toBe(false);
+    expect(fakeAudioTracks[1].enabled).toBe(true);
+    expect(fakeAudioTracks[2].enabled).toBe(false);
+    expect(enableAudioTrack.default(fakeAudioTracks, 0)).toEqual(true);
+    expect(fakeAudioTracks[0].enabled).toBe(true);
+    expect(fakeAudioTracks[1].enabled).toBe(false);
+    expect(fakeAudioTracks[2].enabled).toBe(false);
+  });
+
+  it("should return false if the audio track index does not exist", () => {
+    jest.mock("../browser_detection", () => {
+      return {
+        __esModule: true as const,
+        isTizen: false,
+      };
+    });
+    const fakeAudioTracks = [
+      {
+        id: "id1",
+        kind: "descriptions",
+        label: "Toto",
+        language: "swa",
+        enabled: true,
+      },
+      {
+        id: "id2",
+        kind: "normal",
+        label: "Titi",
+        language: "fre",
+        enabled: false,
+      },
+      {
+        id: "id26",
+        kind: "bloop",
+        label: "hay",
+        language: "hay",
+        enabled: false,
+      },
+    ];
+    const enableAudioTrack = jest.requireActual("../enable_audio_track");
+    expect(enableAudioTrack.default(fakeAudioTracks, -1)).toEqual(false);
+    expect(fakeAudioTracks[0].enabled).toBe(false);
+    expect(fakeAudioTracks[1].enabled).toBe(false);
+    expect(fakeAudioTracks[2].enabled).toBe(false);
+    expect(enableAudioTrack.default(fakeAudioTracks, 0)).toEqual(true);
+    expect(fakeAudioTracks[0].enabled).toBe(true);
+    expect(fakeAudioTracks[1].enabled).toBe(false);
+    expect(fakeAudioTracks[2].enabled).toBe(false);
+    expect(enableAudioTrack.default(fakeAudioTracks, 4)).toEqual(false);
+    expect(fakeAudioTracks[0].enabled).toBe(false);
+    expect(fakeAudioTracks[1].enabled).toBe(false);
+    expect(fakeAudioTracks[2].enabled).toBe(false);
+  });
+
+  it("should return false if the audio track index does not exist on Tizen", () => {
+    jest.mock("../browser_detection", () => {
+      return {
+        __esModule: true as const,
+        isTizen: false,
+      };
+    });
+    let track1IsEnabled = true;
+    let track2IsEnabled = false;
+    let track3IsEnabled = false;
+    let track1WasDisabled = 0;
+    let track2WasDisabled = 0;
+    let track3WasDisabled = 0;
+    let track1WasEnabled = 0;
+    let track2WasEnabled = 0;
+    let track3WasEnabled = 0;
+    const fakeAudioTracks = [
+      {
+        id: "id1",
+        kind: "descriptions",
+        label: "Toto",
+        language: "swa",
+        enabled: true,
+      },
+      {
+        id: "id2",
+        kind: "normal",
+        label: "Titi",
+        language: "fre",
+        enabled: false,
+      },
+      {
+        id: "id26",
+        kind: "bloop",
+        label: "hay",
+        language: "hay",
+        enabled: false,
+      },
+    ];
+    Object.defineProperty(fakeAudioTracks[0], "enabled", {
+      enumerable: true,
+      get() : boolean {
+        return track1IsEnabled;
+      },
+      set(enabled : boolean) {
+        if (!enabled) {
+          track1WasDisabled++;
+        } else {
+          track1WasEnabled++;
+        }
+        track1IsEnabled = enabled;
+      },
+    });
+    Object.defineProperty(fakeAudioTracks[1], "enabled", {
+      enumerable: true,
+      get() : boolean {
+        return track2IsEnabled;
+      },
+      set(enabled : boolean) {
+        if (!enabled) {
+          track2WasDisabled++;
+        } else {
+          track2WasEnabled++;
+        }
+        track2IsEnabled = enabled;
+      },
+    });
+    Object.defineProperty(fakeAudioTracks[2], "enabled", {
+      enumerable: true,
+      get() : boolean {
+        return track3IsEnabled;
+      },
+      set(enabled : boolean) {
+        if (!enabled) {
+          track3WasDisabled++;
+        } else {
+          track3WasEnabled++;
+        }
+        track3IsEnabled = enabled;
+      },
+    });
+    const enableAudioTrack = jest.requireActual("../enable_audio_track");
+    expect(enableAudioTrack.default(fakeAudioTracks, 1)).toBe(true);
+    expect(fakeAudioTracks[0].enabled).toBe(false);
+    expect(fakeAudioTracks[1].enabled).toBe(true);
+    expect(fakeAudioTracks[2].enabled).toBe(false);
+    expect(track1IsEnabled).toBe(false);
+    expect(track2IsEnabled).toBe(true);
+    expect(track3IsEnabled).toBe(false);
+    expect(track1WasDisabled).toBe(1);
+    expect(track2WasDisabled).toBe(1);
+    expect(track3WasDisabled).toBe(1);
+    expect(track1WasEnabled).toBe(0);
+    expect(track2WasEnabled).toBe(1);
+    expect(track3WasEnabled).toBe(0);
+  });
+
+  // eslint-disable-next-line max-len
+  it("should first disable all audioTracks except the one wanted by default on Tizen", () => {
+    jest.mock("../browser_detection", () => {
+      return {
+        __esModule: true as const,
+        isTizen: true,
+      };
+    });
+    let track1IsEnabled = true;
+    let track2IsEnabled = false;
+    let track3IsEnabled = false;
+    let track1WasDisabled = 0;
+    let track2WasDisabled = 0;
+    let track3WasDisabled = 0;
+    let track1WasEnabled = 0;
+    let track2WasEnabled = 0;
+    let track3WasEnabled = 0;
+    const fakeAudioTracks = [
+      {
+        id: "id1",
+        kind: "descriptions",
+        label: "Toto",
+        language: "swa",
+        enabled: true,
+      },
+      {
+        id: "id2",
+        kind: "normal",
+        label: "Titi",
+        language: "fre",
+        enabled: false,
+      },
+      {
+        id: "id26",
+        kind: "bloop",
+        label: "hay",
+        language: "hay",
+        enabled: false,
+      },
+    ];
+    Object.defineProperty(fakeAudioTracks[0], "enabled", {
+      enumerable: true,
+      get() : boolean {
+        return track1IsEnabled;
+      },
+      set(enabled : boolean) {
+        if (!enabled) {
+          track1WasDisabled++;
+        } else {
+          track1WasEnabled++;
+        }
+        track1IsEnabled = enabled;
+      },
+    });
+    Object.defineProperty(fakeAudioTracks[1], "enabled", {
+      enumerable: true,
+      get() : boolean {
+        return track2IsEnabled;
+      },
+      set(enabled : boolean) {
+        if (!enabled) {
+          track2WasDisabled++;
+        } else {
+          track2WasEnabled++;
+        }
+        track2IsEnabled = enabled;
+      },
+    });
+    Object.defineProperty(fakeAudioTracks[2], "enabled", {
+      enumerable: true,
+      get() : boolean {
+        return track3IsEnabled;
+      },
+      set(enabled : boolean) {
+        if (!enabled) {
+          track3WasDisabled++;
+        } else {
+          track3WasEnabled++;
+        }
+        track3IsEnabled = enabled;
+      },
+    });
+    const enableAudioTrack = jest.requireActual("../enable_audio_track");
+    expect(enableAudioTrack.default(fakeAudioTracks, 1)).toBe(true);
+    expect(fakeAudioTracks[0].enabled).toBe(false);
+    expect(fakeAudioTracks[1].enabled).toBe(true);
+    expect(fakeAudioTracks[2].enabled).toBe(false);
+    expect(track1IsEnabled).toBe(false);
+    expect(track2IsEnabled).toBe(true);
+    expect(track3IsEnabled).toBe(false);
+    expect(track1WasDisabled).toBe(1);
+    expect(track2WasDisabled).toBe(0);
+    expect(track3WasDisabled).toBe(1);
+    expect(track1WasEnabled).toBe(0);
+    expect(track2WasEnabled).toBe(1);
+    expect(track3WasEnabled).toBe(0);
+  });
+});

package/src/compat/__tests__/{should_renew_media_keys.test.ts → should_renew_media_key_system_access.test.ts}

@@ -21,7 +21,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 
-describe("compat - shouldRenewMediaKeys", () => {
+describe("compat - shouldRenewMediaKeySystemAccess", () => {
   beforeEach(() => {
     jest.resetModules();
   });
@@ -33,8 +33,9 @@ describe("compat - shouldRenewMediaKeys", () => {
         isIE11: false,
       };
     });
-    const shouldRenewMediaKeys = jest.requireActual("../should_renew_media_keys");
-    expect(shouldRenewMediaKeys.default()).toBe(false);
+    const shouldRenewMediaKeySystemAccess =
+      jest.requireActual("../should_renew_media_key_system_access");
+    expect(shouldRenewMediaKeySystemAccess.default()).toBe(false);
   });
 
   it("should return true if we are on IE11", () => {
@@ -44,8 +45,9 @@ describe("compat - shouldRenewMediaKeys", () => {
         isIE11: true,
       };
     });
-    const shouldRenewMediaKeys = jest.requireActual("../should_renew_media_keys");
-    expect(shouldRenewMediaKeys.default()).toBe(true);
+    const shouldRenewMediaKeySystemAccess =
+      jest.requireActual("../should_renew_media_key_system_access");
+    expect(shouldRenewMediaKeySystemAccess.default()).toBe(true);
   });
   beforeEach(() => {
     jest.resetModules();

package/src/compat/browser_detection.ts

@@ -50,6 +50,13 @@ const isSamsungBrowser : boolean = !isNode &&
 const isTizen : boolean = !isNode &&
                           /Tizen/.test(navigator.userAgent);
 
+const isWebOs : boolean = !isNode &&
+                          /Web0S/.test(navigator.userAgent);
+const isWebOs2021 : boolean = !isNode &&
+                              /WebOS.TV-2021/.test(navigator.userAgent);
+const isWebOs2022 : boolean = !isNode &&
+                              /WebOS.TV-2022/.test(navigator.userAgent);
+
 interface ISafariWindowObject extends Window {
   safari? : { pushNotification? : { toString() : string } };
 }
@@ -76,4 +83,7 @@ export {
   isSafariMobile,
   isSamsungBrowser,
   isTizen,
+  isWebOs,
+  isWebOs2021,
+  isWebOs2022,
 };

package/src/compat/can_reuse_media_keys.ts

@@ -0,0 +1,19 @@
+import {
+  isWebOs2021,
+  isWebOs2022,
+} from "./browser_detection";
+
+/**
+ * Returns `true` if a `MediaKeys` instance (the  `Encrypted Media Extension`
+ * concept) can be reused between contents.
+ *
+ * This should usually be the case but we found rare devices where this would
+ * cause problem:
+ *   - (2022-10-26): WebOS (LG TVs) 2021 and 2022 just rebuffered indefinitely
+ *     when loading a content already-loaded on the HTMLMediaElement.
+ *
+ * @returns {boolean}
+ */
+export default function canReuseMediaKeys() : boolean {
+  return !(isWebOs2021 || isWebOs2022);
+}

package/src/compat/enable_audio_track.ts

@@ -0,0 +1,33 @@
+import { ICompatAudioTrack } from "./browser_compatibility_types";
+import { isTizen } from "./browser_detection";
+
+/**
+ * Enable the audio track at the given index while disabling all others in the
+ * `audioTracks` array.
+ *
+ * Returns false if the given index is not found in the `audioTracks` array.
+ * @param {array.<audioTrack>} audioTracks
+ * @param {number} indexToEnable
+ * @returns {boolean}
+ */
+export default function enableAudioTrack(
+  audioTracks : ICompatAudioTrack[],
+  indexToEnable : number
+) : boolean {
+  // Seen on Safari MacOS only (2022-02-14), not disabling ALL audio tracks
+  // first (even the wanted one), can lead to the media not playing.
+  for (let i = 0; i < audioTracks.length; i++) {
+    // However, Tizen just plays no audio if it is disabled then enabled
+    // synchronously (2022-10-12)
+    if (!isTizen || i !== indexToEnable) {
+      audioTracks[i].enabled = false;
+    }
+  }
+
+  if (indexToEnable < 0 ||  indexToEnable >= audioTracks.length) {
+    return false;
+  }
+
+  audioTracks[indexToEnable].enabled = true;
+  return true;
+}