rx-player 4.1.0 → 4.2.0-dev.2024080600

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

@@ -24,50 +24,50 @@ describe("utils - Logger", () => {
 
   it('should be able to change the logger level to "ERROR"', () => {
     const logger = new Logger();
-    logger.setLevel("ERROR");
+    logger.setLevel("ERROR", "standard");
     expect(logger.getLevel()).toEqual("ERROR");
   });
 
   it('should be able to change the logger level to "WARNING"', () => {
     const logger = new Logger();
-    logger.setLevel("WARNING");
+    logger.setLevel("WARNING", "standard");
     expect(logger.getLevel()).toEqual("WARNING");
   });
 
   it('should be able to change the logger level to "INFO"', () => {
     const logger = new Logger();
-    logger.setLevel("INFO");
+    logger.setLevel("INFO", "standard");
     expect(logger.getLevel()).toEqual("INFO");
   });
 
   it('should be able to change the logger level to "DEBUG"', () => {
     const logger = new Logger();
-    logger.setLevel("DEBUG");
+    logger.setLevel("DEBUG", "standard");
     expect(logger.getLevel()).toEqual("DEBUG");
   });
 
   it("should be able to update the logger level multiple times", () => {
     const logger = new Logger();
-    logger.setLevel("DEBUG");
+    logger.setLevel("DEBUG", "standard");
     expect(logger.getLevel()).toEqual("DEBUG");
-    logger.setLevel("WARNING");
+    logger.setLevel("WARNING", "standard");
     expect(logger.getLevel()).toEqual("WARNING");
-    logger.setLevel("ERROR");
+    logger.setLevel("ERROR", "standard");
     expect(logger.getLevel()).toEqual("ERROR");
-    logger.setLevel("INFO");
+    logger.setLevel("INFO", "standard");
     expect(logger.getLevel()).toEqual("INFO");
-    logger.setLevel("WARNING");
+    logger.setLevel("WARNING", "standard");
     expect(logger.getLevel()).toEqual("WARNING");
-    logger.setLevel("ERROR");
+    logger.setLevel("ERROR", "standard");
     expect(logger.getLevel()).toEqual("ERROR");
   });
 
   it('should default unrecognized logger levels to "NONE"', () => {
     const logger = new Logger();
-    logger.setLevel("TOTO");
+    logger.setLevel("TOTO", "standard");
     expect(logger.getLevel()).toEqual("NONE");
-    logger.setLevel("DEBUG"); // initialize to another thing than "NONE"
-    logger.setLevel("TITI");
+    logger.setLevel("DEBUG", "standard"); // initialize to another thing than "NONE"
+    logger.setLevel("TITI", "standard");
     expect(logger.getLevel()).toEqual("NONE");
   });
 
@@ -103,7 +103,7 @@ describe("utils - Logger", () => {
     const mockDebug = vi.spyOn(console, "debug").mockImplementation(vi.fn());
 
     const logger = new Logger();
-    logger.setLevel("ERROR");
+    logger.setLevel("ERROR", "standard");
     logger.error("test");
     logger.warn("test");
     logger.info("test");
@@ -128,7 +128,7 @@ describe("utils - Logger", () => {
     const mockDebug = vi.spyOn(console, "debug").mockImplementation(vi.fn());
 
     const logger = new Logger();
-    logger.setLevel("WARNING");
+    logger.setLevel("WARNING", "standard");
     logger.error("test");
     logger.warn("test");
     logger.info("test");
@@ -153,7 +153,7 @@ describe("utils - Logger", () => {
     const mockDebug = vi.spyOn(console, "debug").mockImplementation(vi.fn());
 
     const logger = new Logger();
-    logger.setLevel("INFO");
+    logger.setLevel("INFO", "standard");
     logger.error("test");
     logger.warn("test");
     logger.info("test");
@@ -178,7 +178,7 @@ describe("utils - Logger", () => {
     const mockDebug = vi.spyOn(console, "debug").mockImplementation(vi.fn());
 
     const logger = new Logger();
-    logger.setLevel("DEBUG");
+    logger.setLevel("DEBUG", "standard");
     logger.error("test");
     logger.warn("test");
     logger.info("test");
@@ -194,4 +194,161 @@ describe("utils - Logger", () => {
     mockInfo.mockRestore();
     mockDebug.mockRestore();
   });
+
+  it('should set a default logger format of "standard"', () => {
+    const logger = new Logger();
+    expect(logger.getFormat()).toEqual("standard");
+  });
+
+  it('should allow setting a format of "full" or "standard"', () => {
+    const logger = new Logger();
+    expect(logger.getFormat()).toEqual("standard");
+    expect(logger.getLevel()).toEqual("NONE");
+
+    logger.setLevel(logger.getLevel(), "full");
+    expect(logger.getFormat()).toEqual("full");
+    expect(logger.getLevel()).toEqual("NONE");
+
+    logger.setLevel(logger.getLevel(), "standard");
+    expect(logger.getFormat()).toEqual("standard");
+    expect(logger.getLevel()).toEqual("NONE");
+  });
+
+  it('should fallback unknown values to "standard"', () => {
+    const logger = new Logger();
+    expect(logger.getFormat()).toEqual("standard");
+
+    logger.setLevel(logger.getLevel(), "foo");
+    expect(logger.getFormat()).toEqual("standard");
+
+    logger.setLevel(logger.getLevel(), "full");
+    expect(logger.getFormat()).toEqual("full");
+
+    logger.setLevel(logger.getLevel(), "foo");
+    expect(logger.getFormat()).toEqual("standard");
+  });
+
+  it("should be able to change both level and format", () => {
+    const logger = new Logger();
+    expect(logger.getFormat()).toEqual("standard");
+    expect(logger.getLevel()).toEqual("NONE");
+
+    logger.setLevel("foo", "foo");
+    expect(logger.getFormat()).toEqual("standard");
+    expect(logger.getLevel()).toEqual("NONE");
+
+    logger.setLevel("foo", "full");
+    expect(logger.getFormat()).toEqual("full");
+    expect(logger.getLevel()).toEqual("NONE");
+
+    logger.setLevel("foo", "foo");
+    expect(logger.getFormat()).toEqual("standard");
+    expect(logger.getLevel()).toEqual("NONE");
+
+    logger.setLevel("INFO", "foo");
+    expect(logger.getFormat()).toEqual("standard");
+    expect(logger.getLevel()).toEqual("INFO");
+
+    logger.setLevel("foo", "full");
+    expect(logger.getFormat()).toEqual("full");
+    expect(logger.getLevel()).toEqual("NONE");
+
+    logger.setLevel("DEBUG", "standard");
+    expect(logger.getFormat()).toEqual("standard");
+    expect(logger.getLevel()).toEqual("DEBUG");
+
+    logger.setLevel("ERROR", "full");
+    expect(logger.getFormat()).toEqual("full");
+    expect(logger.getLevel()).toEqual("ERROR");
+  });
+
+  it('should format logs with more information when `LogFormat` is set to "full"', () => {
+    const logMsgs: unknown[][] = [];
+    const errorMsgs: unknown[][] = [];
+    const warningMsgs: unknown[][] = [];
+    const infoMsgs: unknown[][] = [];
+    const debugMsgs: unknown[][] = [];
+    const mockLog = vi.spyOn(console, "log").mockImplementation((...args: unknown[]) => {
+      logMsgs.push(args);
+    });
+    const mockError = vi
+      .spyOn(console, "error")
+      .mockImplementation((...args: unknown[]) => {
+        errorMsgs.push(args);
+      });
+    const mockWarn = vi
+      .spyOn(console, "warn")
+      .mockImplementation((...args: unknown[]) => {
+        warningMsgs.push(args);
+      });
+    const mockInfo = vi
+      .spyOn(console, "info")
+      .mockImplementation((...args: unknown[]) => {
+        infoMsgs.push(args);
+      });
+    const mockDebug = vi
+      .spyOn(console, "debug")
+      .mockImplementation((...args: unknown[]) => {
+        debugMsgs.push(args);
+      });
+
+    const logger = new Logger();
+
+    logger.setLevel("DEBUG", "full");
+    expect(mockLog).toHaveBeenCalledTimes(1);
+    expect(logMsgs).toHaveLength(1);
+    expect(logMsgs[0]).toHaveLength(3);
+    expect(logMsgs[0][0]).toMatch(/\d+\.\d\d/);
+    expect(logMsgs[0][1]).toMatch("[Init]");
+    expect(logMsgs[0][2]).toMatch(/Local-Date: \d+/);
+
+    expect(mockError).not.toHaveBeenCalled();
+    expect(mockWarn).not.toHaveBeenCalled();
+    expect(mockInfo).not.toHaveBeenCalled();
+    expect(mockDebug).not.toHaveBeenCalled();
+
+    logger.error("teste", "e r");
+    logger.warn("testw", "w a");
+    logger.info("testi", "i n");
+    logger.debug("testd", "d e");
+
+    expect(mockError).toHaveBeenCalledTimes(1);
+    expect(errorMsgs).toHaveLength(1);
+    expect(errorMsgs[0]).toHaveLength(4);
+    expect(errorMsgs[0][0]).toMatch(/\d+\.\d\d/);
+    expect(errorMsgs[0][1]).toMatch("[error]");
+    expect(errorMsgs[0][2]).toMatch("teste");
+    expect(errorMsgs[0][3]).toMatch("e r");
+
+    expect(mockWarn).toHaveBeenCalledTimes(1);
+    expect(warningMsgs).toHaveLength(1);
+    expect(warningMsgs[0]).toHaveLength(4);
+    expect(warningMsgs[0][0]).toMatch(/\d+\.\d\d/);
+    expect(warningMsgs[0][1]).toMatch("[warn]");
+    expect(warningMsgs[0][2]).toMatch("testw");
+    expect(warningMsgs[0][3]).toMatch("w a");
+
+    expect(mockInfo).toHaveBeenCalledTimes(1);
+    expect(infoMsgs).toHaveLength(1);
+    expect(infoMsgs[0]).toHaveLength(4);
+    expect(infoMsgs[0][0]).toMatch(/\d+\.\d\d/);
+    expect(infoMsgs[0][1]).toMatch("[info]");
+    expect(infoMsgs[0][2]).toMatch("testi");
+    expect(infoMsgs[0][3]).toMatch("i n");
+
+    expect(mockDebug).not.toHaveBeenCalled();
+
+    expect(mockLog).toHaveBeenCalledTimes(2);
+    expect(logMsgs[1]).toHaveLength(4);
+    expect(logMsgs[1][0]).toMatch(/\d+\.\d\d/);
+    expect(logMsgs[1][1]).toMatch("[log]");
+    expect(logMsgs[1][2]).toMatch("testd");
+    expect(logMsgs[1][3]).toMatch("d e");
+
+    mockLog.mockRestore();
+    mockError.mockRestore();
+    mockWarn.mockRestore();
+    mockInfo.mockRestore();
+    mockDebug.mockRestore();
+  });
 });

package/src/utils/are_codecs_compatible.ts

@@ -26,26 +26,34 @@ import startsWith from "./starts_with";
  * @returns A boolean that tell whether or not those two codecs provided are even.
  */
 function areCodecsCompatible(a: string, b: string): boolean {
-  const [mimeTypeA, ...propsA] = a.split(";");
-  const [mimeTypeB, ...propsB] = b.split(";");
+  const { mimeType: mimeTypeA, codecs: codecsA } = parseCodec(a);
+  const { mimeType: mimeTypeB, codecs: codecsB } = parseCodec(b);
 
   if (mimeTypeA !== mimeTypeB) {
     return false;
   }
-
-  const codecsA = arrayFind(propsA, (prop) => startsWith(prop, "codecs="));
-  const codecsB = arrayFind(propsB, (prop) => startsWith(prop, "codecs="));
-  if (codecsA === undefined || codecsB === undefined) {
+  if (codecsA === "" || codecsB === "") {
     return false;
   }
-
-  const codecA = codecsA.substring(7);
-  const codecB = codecsB.substring(7);
-  if (codecA.split(".")[0] !== codecB.split(".")[0]) {
+  if (codecsA.split(".")[0] !== codecsB.split(".")[0]) {
     return false;
   }
-
   return true;
 }
 
+const LENGTH_OF_CODEC_PREFIX = "codecs=".length;
+
+export function parseCodec(unparsedCodec: string): { mimeType: string; codecs: string } {
+  const [mimeType, ...props] = unparsedCodec.split(";");
+  let codecs = arrayFind(props, (prop) => startsWith(prop, "codecs=")) ?? "";
+  // remove the 'codecs=' prefix
+  codecs = codecs.substring(LENGTH_OF_CODEC_PREFIX);
+  // remove the leading and trailing quote
+  if (codecs[0] === '"') {
+    codecs = codecs.substring(1, codecs.length - 2);
+  }
+
+  return { mimeType, codecs };
+}
+
 export default areCodecsCompatible;

package/src/utils/create_uuid.ts

@@ -0,0 +1,28 @@
+import globalScope from "./global_scope";
+import getMonotonicTimeStamp from "./monotonic_timestamp";
+
+/**
+ * Create and return a Universally Unique IDentifier (UUID) as defined by
+ * RFC4122.
+ * Depending on browser API availability, we may be generating an approximation
+ * of what the RFC indicates instead.
+ * @returns {string}
+ */
+export default function createUuid(): string {
+  if (typeof globalScope.crypto?.randomUUID === "function") {
+    return globalScope.crypto.randomUUID();
+  }
+  let ts1 = new Date().getTime();
+  let ts2 = getMonotonicTimeStamp();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+    let r = Math.random() * 16;
+    if (ts1 > 0) {
+      r = (ts1 + r) % 16 | 0;
+      ts1 = Math.floor(ts1 / 16);
+    } else {
+      r = (ts2 + r) % 16 | 0;
+      ts2 = Math.floor(ts2 / 16);
+    }
+    return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
+  });
+}

package/src/utils/logger.ts

@@ -15,10 +15,13 @@
  */
 
 import EventEmitter from "./event_emitter";
+import getMonotonicTimeStamp from "./monotonic_timestamp";
 import noop from "./noop";
 
 export type ILoggerLevel = "NONE" | "ERROR" | "WARNING" | "INFO" | "DEBUG";
 
+export type ILogFormat = "standard" | "full";
+
 type IAcceptedLogValue = boolean | string | number | Error | null | undefined;
 
 type IConsoleFn = (...args: IAcceptedLogValue[]) => void;
@@ -30,7 +33,10 @@ const DEFAULT_LOG_LEVEL: ILoggerLevel = "NONE";
  * are the corresponding payloads.
  */
 interface ILoggerEvents {
-  onLogLevelChange: ILoggerLevel;
+  onLogLevelChange: {
+    level: ILoggerLevel;
+    format: ILogFormat;
+  };
 }
 
 /**
@@ -43,6 +49,7 @@ export default class Logger extends EventEmitter<ILoggerEvents> {
   public info: IConsoleFn;
   public debug: IConsoleFn;
   private _currentLevel: ILoggerLevel;
+  private _currentFormat: ILogFormat;
   private readonly _levels: Record<ILoggerLevel, number>;
 
   constructor() {
@@ -52,15 +59,23 @@ export default class Logger extends EventEmitter<ILoggerEvents> {
     this.info = noop;
     this.debug = noop;
     this._levels = { NONE: 0, ERROR: 1, WARNING: 2, INFO: 3, DEBUG: 4 };
+    this._currentFormat = "standard";
     this._currentLevel = DEFAULT_LOG_LEVEL;
   }
 
   /**
-   * @param {string} levelStr
-   * @param {function} [logFn]
+   * Update the logger's level to increase or decrease its verbosity, to change
+   * its format with a newly set one, or to update its logging function.
+   * @param {string} levelStr - One of the [upper-case] logger level. If the
+   * given level is not valid, it will default to `"NONE"`.
+   * @param {function|undefined} [logFn] - Optional logger function which will
+   * be called with logs (with the corresponding upper-case logger level as
+   * first argument).
+   * Can be omited to just rely on regular logging functions.
    */
   public setLevel(
     levelStr: string,
+    format: string,
     logFn?: (
       levelStr: ILoggerLevel,
       logs: Array<boolean | string | number | Error | null | undefined>,
@@ -77,33 +92,88 @@ export default class Logger extends EventEmitter<ILoggerEvents> {
       this._currentLevel = "NONE";
     }
 
+    let actualFormat: ILogFormat;
+    if (format === "standard" || format === "full") {
+      actualFormat = format;
+    } else {
+      actualFormat = "standard";
+    }
+    if (actualFormat === "full" && actualFormat !== this._currentFormat) {
+      // Add the current Date so we can see at which time logs are displayed
+      const now = getMonotonicTimeStamp();
+      /* eslint-disable-next-line no-console */
+      console.log(String(now.toFixed(2)), "[Init]", `Local-Date: ${Date.now()}`);
+    }
+    this._currentFormat = actualFormat;
+
+    const generateLogFn =
+      this._currentFormat === "full"
+        ? (namespace: string, consoleFn: IConsoleFn): IConsoleFn => {
+            return (...args: IAcceptedLogValue[]) => {
+              const now = getMonotonicTimeStamp();
+              return consoleFn(String(now.toFixed(2)), `[${namespace}]`, ...args);
+            };
+          }
+        : (_namespace: string, consoleFn: IConsoleFn): IConsoleFn => consoleFn;
+
     if (logFn === undefined) {
       /* eslint-disable no-invalid-this */
       /* eslint-disable no-console */
-      this.error = level >= this._levels.ERROR ? console.error.bind(console) : noop;
-      this.warn = level >= this._levels.WARNING ? console.warn.bind(console) : noop;
-      this.info = level >= this._levels.INFO ? console.info.bind(console) : noop;
-      this.debug = level >= this._levels.DEBUG ? console.log.bind(console) : noop;
+      this.error =
+        level >= this._levels.ERROR
+          ? generateLogFn("error", console.error.bind(console))
+          : noop;
+      this.warn =
+        level >= this._levels.WARNING
+          ? generateLogFn("warn", console.warn.bind(console))
+          : noop;
+      this.info =
+        level >= this._levels.INFO
+          ? generateLogFn("info", console.info.bind(console))
+          : noop;
+      this.debug =
+        level >= this._levels.DEBUG
+          ? generateLogFn("log", console.log.bind(console))
+          : noop;
       /* eslint-enable no-console */
       /* eslint-enable no-invalid-this */
     } else {
-      this.error = level >= this._levels.ERROR ? (...args) => logFn("ERROR", args) : noop;
-      this.warn =
-        level >= this._levels.WARNING ? (...args) => logFn("WARNING", args) : noop;
-      this.info = level >= this._levels.INFO ? (...args) => logFn("INFO", args) : noop;
-      this.debug = level >= this._levels.DEBUG ? (...args) => logFn("DEBUG", args) : noop;
+      const produceLogFn = (logLevel: ILoggerLevel, namespace: string) => {
+        return level >= this._levels[logLevel]
+          ? (...args: IAcceptedLogValue[]) => {
+              const now = getMonotonicTimeStamp();
+              return logFn(logLevel, [now, namespace, ...args]);
+            }
+          : noop;
+      };
+      this.error = produceLogFn("ERROR", "error");
+      this.warn = produceLogFn("WARNING", "warn");
+      this.info = produceLogFn("INFO", "info");
+      this.debug = produceLogFn("DEBUG", "log");
     }
 
-    this.trigger("onLogLevelChange", this._currentLevel);
+    this.trigger("onLogLevelChange", {
+      level: this._currentLevel,
+      format: this._currentFormat,
+    });
   }
 
   /**
+   * Get the last set logger level, as an upper-case string value.
    * @returns {string}
    */
   public getLevel(): ILoggerLevel {
     return this._currentLevel;
   }
 
+  /**
+   * Get the last set logger's log format.
+   * @returns {string}
+   */
+  public getFormat(): ILogFormat {
+    return this._currentFormat;
+  }
+
   /**
    * Returns `true` if the currently set level includes logs of the level given
    * in argument.

package/src/utils/request/fetch.ts

@@ -81,8 +81,8 @@ export interface IFetchOptions {
    * reject with the corresponding `CancellationError`.
    */
   cancelSignal: CancellationSignal;
-  /** Optional headers for the HTTP GET request perfomed by `fetchRequest`. */
-  headers?: { [header: string]: string } | undefined | null;
+  /** Dictionary of headers you want to set. `null` or `undefined` for no header. */
+  headers?: Record<string, string> | null | undefined;
   /**
    * Optional timeout for the HTTP GET request perfomed by `fetchRequest`.
    * This timeout is just enabled until the HTTP response from the server, even
@@ -108,7 +108,7 @@ const _AbortController: IAbortControllerConstructor | null =
 export default function fetchRequest(
   options: IFetchOptions,
 ): Promise<IFetchedStreamComplete> {
-  let headers: Headers | { [key: string]: string } | undefined;
+  let headers: Headers | Record<string, string> | undefined;
   if (!isNullOrUndefined(options.headers)) {
     if (isNullOrUndefined(_Headers)) {
       headers = options.headers;

package/src/utils/request/xhr.ts

@@ -49,7 +49,7 @@ export default function request(
   options: IRequestOptions<"document">,
 ): Promise<IRequestResponse<Document, "document">>;
 export default function request(
-  options: IRequestOptions<"json">, // eslint-disable-next-line @typescript-eslint/ban-types
+  options: IRequestOptions<"json">, // eslint-disable-next-line @typescript-eslint/no-restricted-types
 ): Promise<IRequestResponse<object, "json">>;
 export default function request(
   options: IRequestOptions<"blob">,
@@ -264,7 +264,7 @@ export interface IRequestOptions<ResponseType> {
   /** URL you want to request. */
   url: string;
   /** Dictionary of headers you want to set. `null` or `undefined` for no header. */
-  headers?: { [header: string]: string } | null | undefined;
+  headers?: Record<string, string> | null | undefined;
   /** Wanted format for the response */
   responseType?: ResponseType | undefined;
   /**

package/src/utils/weak_map_memory.ts

@@ -52,7 +52,7 @@
  * ```
  * @class WeakMapMemory
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-restricted-types
 export default class WeakMapMemory<T extends object, U> {
   private readonly _fn: (obj: T) => U;
   private _weakMap: WeakMap<T, U>;

package/dist/commonjs/mse/main_codec_support_prober.d.ts

@@ -1,27 +0,0 @@
-import type { ICodecSupportProber } from "./types";
-/**
- * Class allowing to check for mimeType + codec support when MSE API are
- * available in the current environment.
- *
- * In that environment, codec support can always be requested synchronously and
- * is relatively cheap.
- * @class {MainCodecSupportProber}
- */
-declare class MainCodecSupportProber implements ICodecSupportProber {
-    /**
-     * Small cache keeping the result of codec support checks for the last one
-     * requested.
-     */
-    private _cachedCodecSupport;
-    constructor();
-    /**
-     * Probe for the support of the given mime-type and codec combination.
-     * @param {string} mimeType
-     * @param {string} codec
-     * @returns {boolean}
-     */
-    isSupported(mimeType: string, codec: string): boolean;
-}
-declare const mainCodecSupportProber: MainCodecSupportProber;
-export default mainCodecSupportProber;
-//# sourceMappingURL=main_codec_support_prober.d.ts.map

package/dist/commonjs/mse/main_codec_support_prober.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"main_codec_support_prober.d.ts","sourceRoot":"","sources":["../../../src/mse/main_codec_support_prober.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAOnD;;;;;;;GAOG;AACH,cAAM,sBAAuB,YAAW,mBAAmB;IACzD;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAuB;;IAMlD;;;;;OAKG;IACI,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;CAe7D;AAED,QAAA,MAAM,sBAAsB,wBAA+B,CAAC;AAC5D,eAAe,sBAAsB,CAAC"}

package/dist/commonjs/mse/main_codec_support_prober.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var is_codec_supported_1 = require("../compat/is_codec_supported");
-/**
- * Maximum size the `MainCodecSupportProber`'s inner cache can be.
- */
-var MAX_CODEC_CACHE_SIZE = 50;
-/**
- * Class allowing to check for mimeType + codec support when MSE API are
- * available in the current environment.
- *
- * In that environment, codec support can always be requested synchronously and
- * is relatively cheap.
- * @class {MainCodecSupportProber}
- */
-var MainCodecSupportProber = /** @class */ (function () {
-    function MainCodecSupportProber() {
-        this._cachedCodecSupport = new Map();
-    }
-    /**
-     * Probe for the support of the given mime-type and codec combination.
-     * @param {string} mimeType
-     * @param {string} codec
-     * @returns {boolean}
-     */
-    MainCodecSupportProber.prototype.isSupported = function (mimeType, codec) {
-        var mimeTypeStr = "".concat(mimeType !== null && mimeType !== void 0 ? mimeType : "", ";codecs=\"").concat(codec !== null && codec !== void 0 ? codec : "", "\"");
-        var knownSupport = this._cachedCodecSupport.get(mimeTypeStr);
-        if (knownSupport !== undefined) {
-            return knownSupport;
-        }
-        if (this._cachedCodecSupport.size >= MAX_CODEC_CACHE_SIZE) {
-            // For simplicity, just clear everything here, we don't care that much
-            // about implementing a true LRU cache here
-            this._cachedCodecSupport.clear();
-        }
-        var isSupported = (0, is_codec_supported_1.default)(mimeTypeStr);
-        this._cachedCodecSupport.set(mimeTypeStr, isSupported);
-        return isSupported;
-    };
-    return MainCodecSupportProber;
-}());
-var mainCodecSupportProber = new MainCodecSupportProber();
-exports.default = mainCodecSupportProber;

package/dist/commonjs/mse/worker_codec_support_prober.d.ts

@@ -1,43 +0,0 @@
-import type { ICodecSupportProber } from "./types";
-/**
- * Class allowing to check for mimeType + codec support in a WebWorker
- * environment where MSE API are not available.
- * @class {WorkerCodecSupportProber}
- */
-declare class WorkerCodecSupportProber implements ICodecSupportProber {
-    /**
-     * Current size of the `_cachedCodecSupport` size.
-     * We cannot rely on `_cachedCodecSupport.size` directly as it is a Map of
-     * Maps.
-     */
-    private _currentCacheSize;
-    /**
-     * Small cache keeping the result of codec support checks for the last one
-     * requested.
-     * The first key is the mime-type, the second is the codec.
-     */
-    private _cachedCodecSupport;
-    constructor();
-    /**
-     * Probe for the support of the given mime-type and codec combination.
-     *
-     * Only returns a boolean if the support was added to this
-     * `WorkerCodecSupportProber`'s cache (through the `updateCache` method).
-     * @param {string} mimeType
-     * @param {string} codec
-     * @returns {boolean|undefined}
-     */
-    isSupported(mimeType: string, codec: string): boolean | undefined;
-    /**
-     * Add an entry into the `WorkerCodecSupportProber`'s cache, so that it can
-     * synchronously determine, through the `isSupported` method, whether a codec
-     * and mimetype combination is currently supported.
-     * @param {string} mimeType
-     * @param {string} codec
-     * @param {boolean} isSupported
-     */
-    updateCache(mimeType: string, codec: string, isSupported: boolean): void;
-}
-declare const _default: WorkerCodecSupportProber;
-export default _default;
-//# sourceMappingURL=worker_codec_support_prober.d.ts.map

package/dist/commonjs/mse/worker_codec_support_prober.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker_codec_support_prober.d.ts","sourceRoot":"","sources":["../../../src/mse/worker_codec_support_prober.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAOnD;;;;GAIG;AACH,cAAM,wBAAyB,YAAW,mBAAmB;IAC3D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB,CAAS;IAClC;;;;OAIG;IACH,OAAO,CAAC,mBAAmB,CAAoC;;IAO/D;;;;;;;;OAQG;IACI,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAQxE;;;;;;;OAOG;IACI,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,IAAI;CAgBhF;;AAED,wBAA8C"}