rx-player 4.0.0-dev.2023121900 → 4.0.0-rc.2

package/dist/es2017/utils/assert.js

@@ -13,8 +13,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { AssertionError } from "../errors";
 import isNullOrUndefined from "./is_null_or_undefined";
+/**
+ * Error due to an abnormal assertion fails.
+ *
+ * This should be an internal error which is later transformed into a documented
+ * (as part of the API) Error instance before being emitted to the application.
+ * @class AssertionError
+ * @extends Error
+ */
+export class AssertionError extends Error {
+    /**
+     * @param {string} message
+     */
+    constructor(message) {
+        super();
+        // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
+        Object.setPrototypeOf(this, AssertionError.prototype);
+        this.name = "AssertionError";
+        this.message = message;
+    }
+}
 /**
  * Throw an AssertionError if the given assertion is false.
  * @param {boolean} assertion
@@ -49,3 +68,30 @@ export function assertInterface(o, iface, name = "object") {
         }
     }
 }
+/**
+ * TypeScript hack to make sure a code path is never taken.
+ *
+ * This can for example be used to ensure that a switch statement handle all
+ * possible cases by adding a default clause calling assertUnreachable with
+ * an argument (it doesn't matter which one).
+ *
+ * @example
+ * function parseBinary(str : "0" | "1") : number {
+ *   switch (str) {
+ *     case "0:
+ *       return 0;
+ *     case "1":
+ *       return 1;
+ *     default:
+ *       // branch never taken. If it can be, TypeScript will yell at us because
+ *       // its argument (here, `str`) is not of the right type.
+ *       assertUnreachable(str);
+ *   }
+ * }
+ * @param {*} _
+ * @throws AssertionError - Throw an AssertionError when called. If we're
+ * sufficiently strict with how we use TypeScript, this should never happen.
+ */
+export function assertUnreachable(_) {
+    throw new AssertionError("Unreachable path taken");
+}

package/dist/es2017/utils/event_emitter.js

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../log";
 import isNullOrUndefined from "./is_null_or_undefined";
 /**
  * Simple but fully type-safe EventEmitter implementation.
@@ -93,7 +92,14 @@ export default class EventEmitter {
                 listener(arg);
             }
             catch (e) {
-                log.error("EventEmitter: listener error", e instanceof Error ? e : null);
+                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+                    throw e instanceof Error ? e :
+                        new Error("EventEmitter: listener error");
+                }
+                // Cannot use our logger here sadly because our logger is an `EventEmitter`
+                // itself.
+                /* eslint-disable-next-line no-console */
+                console.error("RxPlayer: EventEmitter error", e instanceof Error ? e : null);
             }
         });
     }

package/dist/es2017/utils/languages/ISO_639-1_to_ISO_639-3.js

@@ -17,189 +17,189 @@
  * Translate ISO 639-1 language codes into ISO 639-3 ones.
  */
 const ISO_MAP_1_TO_3 = {
-    aa: "aar",
-    ab: "abk",
-    ae: "ave",
-    af: "afr",
-    ak: "aka",
-    am: "amh",
-    an: "arg",
-    ar: "ara",
-    as: "asm",
-    av: "ava",
-    ay: "aym",
-    az: "aze",
-    ba: "bak",
-    be: "bel",
-    bg: "bul",
-    bi: "bis",
-    bm: "bam",
-    bn: "ben",
-    bo: "bod",
-    br: "bre",
-    bs: "bos",
-    ca: "cat",
-    ce: "che",
-    ch: "cha",
-    co: "cos",
-    cr: "cre",
-    cs: "ces",
-    cu: "chu",
+    aa: "aar", // Afar
+    ab: "abk", // Abkhazian
+    ae: "ave", // Avestan
+    af: "afr", // Afrikaans
+    ak: "aka", // Akan
+    am: "amh", // Amharic
+    an: "arg", // Aragonese
+    ar: "ara", // Arabic
+    as: "asm", // Assamese
+    av: "ava", // Avaric
+    ay: "aym", // Aymara
+    az: "aze", // Azerbaijani
+    ba: "bak", // Bashkir
+    be: "bel", // Belarusian
+    bg: "bul", // Bulgarian
+    bi: "bis", // Bislama
+    bm: "bam", // Bambara
+    bn: "ben", // Bengali
+    bo: "bod", // Tibetan
+    br: "bre", // Breton
+    bs: "bos", // Bosnian
+    ca: "cat", // Catalan, Valencian
+    ce: "che", // Chechen
+    ch: "cha", // Chamorro
+    co: "cos", // Corsican
+    cr: "cre", // Cree
+    cs: "ces", // Czech
+    cu: "chu", // Church Slavic, Church Slavonic, Old Church Slavonic,
     // Old Slavonic, Old Bulgarian
-    cv: "chv",
-    cy: "cym",
-    da: "dan",
-    de: "deu",
-    dv: "div",
-    dz: "dzo",
-    ee: "ewe",
-    el: "ell",
-    en: "eng",
-    eo: "epo",
-    es: "spa",
-    et: "est",
-    eu: "eus",
-    fa: "fas",
-    ff: "ful",
-    fi: "fin",
-    fj: "fij",
-    fo: "fao",
-    fr: "fra",
-    fy: "fry",
-    ga: "gle",
-    gd: "gla",
-    gl: "glg",
-    gn: "grn",
-    gu: "guj",
-    gv: "glv",
-    ha: "hau",
-    he: "heb",
-    hi: "hin",
-    ho: "hmo",
-    hr: "hrv",
-    ht: "hat",
-    hu: "hun",
-    hy: "hye",
-    hz: "her",
-    ia: "ina",
-    id: "ind",
-    ie: "ile",
-    ig: "ibo",
-    ii: "iii",
-    ik: "ipk",
-    io: "ido",
-    is: "isl",
-    it: "ita",
-    iu: "iku",
-    ja: "jpn",
-    jv: "jav",
-    ka: "kat",
-    kg: "kon",
-    ki: "kik",
-    kj: "kua",
-    kk: "kaz",
-    kl: "kal",
-    km: "khm",
-    kn: "kan",
-    ko: "kor",
-    kr: "kau",
-    ks: "kas",
-    ku: "kur",
-    kv: "kom",
-    kw: "cor",
-    ky: "kir",
-    la: "lat",
-    lb: "ltz",
-    lg: "lug",
-    li: "lim",
-    ln: "lin",
-    lo: "lao",
-    lt: "lit",
-    lu: "lub",
-    lv: "lav",
-    mg: "mlg",
-    mh: "mah",
-    mi: "mri",
-    mk: "mkd",
-    ml: "mal",
-    mn: "mon",
-    mr: "mar",
-    ms: "msa",
-    mt: "mlt",
-    my: "mya",
-    na: "nau",
-    nb: "nob",
-    nd: "nde",
-    ne: "nep",
-    ng: "ndo",
-    nl: "nld",
-    nn: "nno",
-    no: "nor",
-    nr: "nbl",
-    nv: "nav",
-    ny: "nya",
-    oc: "oci",
-    oj: "oji",
-    om: "orm",
-    or: "ori",
-    os: "oss",
-    pa: "pan",
-    pi: "pli",
-    pl: "pol",
-    ps: "pus",
-    pt: "por",
-    qu: "que",
-    rm: "roh",
-    rn: "run",
-    ro: "ron",
-    ru: "rus",
-    rw: "kin",
-    sa: "san",
-    sc: "srd",
-    sd: "snd",
-    se: "sme",
-    sg: "sag",
-    si: "sin",
-    sk: "slk",
-    sl: "slv",
-    sm: "smo",
-    sn: "sna",
-    so: "som",
-    sq: "sqi",
-    sr: "srp",
-    ss: "ssw",
-    st: "sot",
-    su: "sun",
-    sv: "swe",
-    sw: "swa",
-    ta: "tam",
-    te: "tel",
-    tg: "tgk",
-    th: "tha",
-    ti: "tir",
-    tk: "tuk",
-    tl: "tgl",
-    tn: "tsn",
-    to: "ton",
-    tr: "tur",
-    ts: "tso",
-    tt: "tat",
-    tw: "twi",
-    ty: "tah",
-    ug: "uig",
-    uk: "ukr",
-    ur: "urd",
-    uz: "uzb",
-    ve: "ven",
-    vi: "vie",
-    vo: "vol",
-    wa: "wln",
-    wo: "wol",
-    xh: "xho",
-    yi: "yid",
-    yo: "yor",
-    za: "zha",
-    zh: "zho",
+    cv: "chv", // Chuvash
+    cy: "cym", // Welsh
+    da: "dan", // Danish
+    de: "deu", // German
+    dv: "div", // Divehi, Dhivehi, Maldivian
+    dz: "dzo", // Dzongkha
+    ee: "ewe", // Ewe
+    el: "ell", // Greek (modern)
+    en: "eng", // English
+    eo: "epo", // Esperanto
+    es: "spa", // Spanish, Castilian
+    et: "est", // Estonian
+    eu: "eus", // Basque
+    fa: "fas", // Persian
+    ff: "ful", // Fulah
+    fi: "fin", // Finnish
+    fj: "fij", // Fijian
+    fo: "fao", // Faroese
+    fr: "fra", // French
+    fy: "fry", // Western Frisian
+    ga: "gle", // Irish
+    gd: "gla", // Gaelic, Scottish Gaelic
+    gl: "glg", // Galician
+    gn: "grn", // Guaraní
+    gu: "guj", // Gujarati
+    gv: "glv", // Manx
+    ha: "hau", // Hausa
+    he: "heb", // Hebrew (modern)
+    hi: "hin", // Hindi
+    ho: "hmo", // Hiri Motu
+    hr: "hrv", // Croatian
+    ht: "hat", // Haitian, Haitian Creole
+    hu: "hun", // Hungarian
+    hy: "hye", // Armenian
+    hz: "her", // Herero
+    ia: "ina", // Interlingua
+    id: "ind", // Indonesian
+    ie: "ile", // Interlingue
+    ig: "ibo", // Igbo
+    ii: "iii", // Sichuan Yi, Nuosu
+    ik: "ipk", // Inupiaq
+    io: "ido", // Ido
+    is: "isl", // Icelandic
+    it: "ita", // Italian
+    iu: "iku", // Inuktitut
+    ja: "jpn", // Japanese
+    jv: "jav", // Javanese
+    ka: "kat", // Georgian
+    kg: "kon", // Kongo
+    ki: "kik", // Kikuyu, Gikuyu
+    kj: "kua", // Kuanyama, Kwanyama
+    kk: "kaz", // Kazakh
+    kl: "kal", // Kalaallisut, Greenlandic
+    km: "khm", // Central Khmer
+    kn: "kan", // Kannada
+    ko: "kor", // Korean
+    kr: "kau", // Kanuri
+    ks: "kas", // Kashmiri
+    ku: "kur", // Kurdish
+    kv: "kom", // Komi
+    kw: "cor", // Cornish
+    ky: "kir", // Kirghiz, Kyrgyz
+    la: "lat", // Latin
+    lb: "ltz", // Luxembourgish, Letzeburgesch
+    lg: "lug", // Ganda
+    li: "lim", // Limburgan, Limburger, Limburgish
+    ln: "lin", // Lingala
+    lo: "lao", // Lao
+    lt: "lit", // Lithuanian
+    lu: "lub", // Luba-Katanga
+    lv: "lav", // Latvian
+    mg: "mlg", // Malagasy
+    mh: "mah", // Marshallese
+    mi: "mri", // Maori
+    mk: "mkd", // Macedonian
+    ml: "mal", // Malayalam
+    mn: "mon", // Mongolian
+    mr: "mar", // Marathi
+    ms: "msa", // Malay
+    mt: "mlt", // Maltese
+    my: "mya", // Burmese
+    na: "nau", // Nauru
+    nb: "nob", // Norwegian Bokmål
+    nd: "nde", // North Ndebele
+    ne: "nep", // Nepali
+    ng: "ndo", // Ndonga
+    nl: "nld", // Dutch, Flemish
+    nn: "nno", // Norwegian Nynorsk
+    no: "nor", // Norwegian
+    nr: "nbl", // South Ndebele
+    nv: "nav", // Navajo, Navaho
+    ny: "nya", // Chichewa, Chewa, Nyanja
+    oc: "oci", // Occitan
+    oj: "oji", // Ojibwa
+    om: "orm", // Oromo
+    or: "ori", // Oriya
+    os: "oss", // Ossetian, Ossetic
+    pa: "pan", // Panjabi, Punjabi
+    pi: "pli", // Pali
+    pl: "pol", // Polish
+    ps: "pus", // Pashto, Pushto
+    pt: "por", // Portuguese
+    qu: "que", // Quechua
+    rm: "roh", // Romansh
+    rn: "run", // Rundi
+    ro: "ron", // Romanian, Moldavian, Moldovan
+    ru: "rus", // Russian
+    rw: "kin", // Kinyarwanda
+    sa: "san", // Sanskrit
+    sc: "srd", // Sardinian
+    sd: "snd", // Sindhi
+    se: "sme", // Northern Sami
+    sg: "sag", // Sango
+    si: "sin", // Sinhala, Sinhalese
+    sk: "slk", // Slovak
+    sl: "slv", // Slovenian
+    sm: "smo", // Samoan
+    sn: "sna", // Shona
+    so: "som", // Somali
+    sq: "sqi", // Albanian
+    sr: "srp", // Serbian
+    ss: "ssw", // Swati
+    st: "sot", // Southern Sotho
+    su: "sun", // Sundanese
+    sv: "swe", // Swedish
+    sw: "swa", // Swahili
+    ta: "tam", // Tamil
+    te: "tel", // Telugu
+    tg: "tgk", // Tajik
+    th: "tha", // Thai
+    ti: "tir", // Tigrinya
+    tk: "tuk", // Turkmen
+    tl: "tgl", // Tagalog
+    tn: "tsn", // Tswana
+    to: "ton", // Tonga (Tonga Islands)
+    tr: "tur", // Turkish
+    ts: "tso", // Tsonga
+    tt: "tat", // Tatar
+    tw: "twi", // Twi
+    ty: "tah", // Tahitian
+    ug: "uig", // Uighur, Uyghur
+    uk: "ukr", // Ukrainian
+    ur: "urd", // Urdu
+    uz: "uzb", // Uzbek
+    ve: "ven", // Venda
+    vi: "vie", // Vietnamese
+    vo: "vol", // Volapük
+    wa: "wln", // Walloon
+    wo: "wol", // Wolof
+    xh: "xho", // Xhosa
+    yi: "yid", // Yiddish
+    yo: "yor", // Yoruba
+    za: "zha", // Zhuang, Chuang
+    zh: "zho", // Chinese
     zu: "zul", // Zulu
 };
 export default ISO_MAP_1_TO_3;

package/dist/es2017/utils/languages/ISO_639-2_to_ISO_639-3.js

@@ -17,25 +17,25 @@
  * Translate ISO 639-2 synonyms to their ISO 639-3 counterparts.
  */
 const ISO_MAP_2_TO_3 = {
-    alb: "sqi",
-    arm: "hye",
-    baq: "eus",
-    bur: "mya",
-    chi: "zho",
-    cze: "ces",
-    dut: "nld",
-    fre: "fra",
-    geo: "kat",
-    ger: "deu",
-    gre: "ell",
-    ice: "isl",
-    mac: "mkd",
-    mao: "mri",
-    may: "msa",
-    per: "fas",
-    slo: "slk",
-    rum: "ron",
-    tib: "bod",
+    alb: "sqi", // Albanian
+    arm: "hye", // Armenian
+    baq: "eus", // Basque
+    bur: "mya", // Burmese
+    chi: "zho", // Chinese
+    cze: "ces", // Czech
+    dut: "nld", // Dutch; Flemish
+    fre: "fra", // French
+    geo: "kat", // Georgian
+    ger: "deu", // German
+    gre: "ell", // Modern Greek (1453–)
+    ice: "isl", // Icelandic
+    mac: "mkd", // Macedonian
+    mao: "mri", // Maori
+    may: "msa", // Malay
+    per: "fas", // Persian
+    slo: "slk", // Slovak
+    rum: "ron", // Moldovan
+    tib: "bod", // Tibetan
     wel: "cym", // Welsh
 };
 export default ISO_MAP_2_TO_3;

package/dist/es2017/utils/logger.d.ts

@@ -13,13 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import EventEmitter from "./event_emitter";
 export type ILoggerLevel = "NONE" | "ERROR" | "WARNING" | "INFO" | "DEBUG";
-type IConsoleFn = (...args: Array<boolean | string | number | Error | null | undefined>) => void;
+type IAcceptedLogValue = boolean | string | number | Error | null | undefined;
+type IConsoleFn = (...args: IAcceptedLogValue[]) => void;
+/**
+ * Events sent by `Logger` where the keys are the events' name and the values
+ * are the corresponding payloads.
+ */
+interface ILoggerEvents {
+    onLogLevelChange: ILoggerLevel;
+}
 /**
  * Logger implementation.
  * @class Logger
  */
-export default class Logger {
+export default class Logger extends EventEmitter<ILoggerEvents> {
     error: IConsoleFn;
     warn: IConsoleFn;
     info: IConsoleFn;
@@ -29,8 +38,9 @@ export default class Logger {
     constructor();
     /**
      * @param {string} levelStr
+     * @param {function} [logFn]
      */
-    setLevel(levelStr: string): void;
+    setLevel(levelStr: string, logFn?: (levelStr: ILoggerLevel, logs: Array<boolean | string | number | Error | null | undefined>) => void): void;
     /**
      * @returns {string}
      */

package/dist/es2017/utils/logger.js

@@ -13,14 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import EventEmitter from "./event_emitter";
 import noop from "./noop";
 const DEFAULT_LOG_LEVEL = "NONE";
 /**
  * Logger implementation.
  * @class Logger
  */
-export default class Logger {
+export default class Logger extends EventEmitter {
     constructor() {
+        super();
         this.error = noop;
         this.warn = noop;
         this.info = noop;
@@ -34,8 +36,9 @@ export default class Logger {
     }
     /**
      * @param {string} levelStr
+     * @param {function} [logFn]
      */
-    setLevel(levelStr) {
+    setLevel(levelStr, logFn) {
         let level;
         const foundLevel = this._levels[levelStr];
         if (typeof foundLevel === "number") {
@@ -46,18 +49,31 @@ export default class Logger {
             level = 0;
             this._currentLevel = "NONE";
         }
-        /* 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;
-        /* eslint-enable no-console */
-        /* eslint-enable no-invalid-this */
+        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;
+            /* 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;
+        }
+        this.trigger("onLogLevelChange", this._currentLevel);
     }
     /**
      * @returns {string}

package/dist/es2017/utils/monotonic_timestamp.d.ts

@@ -1,9 +1,25 @@
+import SharedReference from "./reference";
 /**
- * Returns a monotonically-increasing timestamp in milliseconds that is
- * guaranteed to raise of 1 millisecond every 1 millisecond.
+ * Time difference of the monotonic clock indicated by `performance.now` with
+ * the main thread environment (i.e. amount of time to add to the worker's clock
+ * to obtain the main clock - from the worker-side).
+ */
+declare const mainThreadTimestampDiff: SharedReference<number>;
+export { mainThreadTimestampDiff };
+/**
+ * Provide a "monotonically-raising timestamp". That is, a timestamp that is
+ * guaranteed to keep raising at the same speed of 1000 milliseconds per second
+ * (unlike for example `Date.now()` which may not have the same behavior if the
+ * system's clock is updated, whether it is due to NTP, the user updating the
+ * clock, daylight saving time, leap seconds, or someone deciding that
+ * datekeeping rules have to be changed).
+ *
+ * This function is useful when what you want to do is just time comparaison, in
+ * which case going through `Date` objects would both be unnecessary and
+ * affected by the aforementioned issues.
  *
- * This is in contrast of relying on indirect time values such as `Date.now`
- * which may go back/forward in time due to leap hours or clock changes.
+ * Also, by updating `mainThreadTimestampDiff`, you can ensure that WebWorkers
+ * provide a monotonic timestamp synchronized with the main thread.
  * @returns {number}
  */
 export default function getMonotonicTimeStamp(): number;