rx-player 3.33.0 → 3.33.1

package/src/utils/id_generator.ts

@@ -1,35 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-
-/**
- * Creates an ID generator which generates a number containing an incremented
- * number each time you call it.
- * @returns {Function}
- */
-export default function idGenerator() : () => string {
-  let prefix = "";
-  let currId = -1;
-  return function generateNewId() : string {
-    currId++;
-    if (currId >= Number.MAX_SAFE_INTEGER) {
-      prefix += "0";
-      currId = 0;
-    }
-    return prefix + String(currId);
-  };
-}

package/src/utils/initialization_segment_cache.ts

@@ -1,68 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {
-  ISegment,
-  Representation,
-} from "../manifest";
-
-/**
- * Caching object used to cache initialization segments.
- * This allow to have a faster representation switch and faster seeking.
- * @class InitializationSegmentCache
- */
-class InitializationSegmentCache<T> {
-  private _cache : WeakMap<Representation, T>;
-
-  constructor() {
-    this._cache = new WeakMap();
-  }
-
-  /**
-   * @param {Object} obj
-   * @param {*} response
-   */
-  public add(
-    { representation,
-      segment } : { representation : Representation;
-                    segment : ISegment; },
-    response : T
-  ) : void {
-    if (segment.isInit) {
-      this._cache.set(representation, response);
-    }
-  }
-
-  /**
-   * @param {Object} obj
-   * @returns {*} response
-   */
-  public get(
-    { representation,
-      segment } : { representation : Representation;
-                    segment : ISegment; }
-  ) : T|null {
-    if (segment.isInit) {
-      const value = this._cache.get(representation);
-      if (value !== undefined) {
-        return value;
-      }
-    }
-    return null;
-  }
-}
-
-export default InitializationSegmentCache;

package/src/utils/is_non_empty_string.ts

@@ -1,23 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @param {*} x
- * @returns {string}
- */
-export default function isNonEmptyString(x : unknown) : x is Exclude<string, ""> {
-  return typeof x === "string" && x.length > 0;
-}

package/src/utils/is_null_or_undefined.ts

@@ -1,27 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Returns true if the argument given is either null or undefined.
- * This function was added to have a clearer alternative to `== null` which is
- * not always understood by newcomers to the code, and which can be overused when
- * only one of the possibility can arise.
- * @param {*} x
- * @returns {boolean}
- */
-export default function isNullOrUndefined(x : unknown) : x is null | undefined | void {
-  return x === null || x === undefined;
-}

package/src/utils/languages/ISO_639-1_to_ISO_639-3.ts

@@ -1,207 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Translate ISO 639-1 language codes into ISO 639-3 ones.
- */
-const ISO_MAP_1_TO_3 : { [ lang : string ] : string } = {
-  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", // 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/src/utils/languages/ISO_639-2_to_ISO_639-3.ts

@@ -1,43 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Translate ISO 639-2 synonyms to their ISO 639-3 counterparts.
- */
-const ISO_MAP_2_TO_3 : { [ lang : string ] : string } = {
-  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/src/utils/languages/__tests__/normalize.test.ts

@@ -1,290 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import normalizeLanguage, {
-  normalizeAudioTrack,
-  normalizeTextTrack,
-} from "../normalize";
-
-describe("utils - normalizeLanguage", () => {
-  it("should translate an empty string to an empty string", () => {
-    expect(normalizeLanguage("")).toBe("");
-  });
-
-  it("should translate ISO639-1 to ISO639-3", () => {
-    expect(normalizeLanguage("fr")).toBe("fra");
-    expect(normalizeLanguage("hy")).toBe("hye");
-    expect(normalizeLanguage("de")).toBe("deu");
-    expect(normalizeLanguage("ff")).toBe("ful");
-  });
-
-  it("should translate ISO639-2 to ISO639-3", () => {
-    expect(normalizeLanguage("fre")).toBe("fra");
-    expect(normalizeLanguage("alb")).toBe("sqi");
-    expect(normalizeLanguage("ger")).toBe("deu");
-  });
-
-  it("should translate IETF language tags to ISO639-3", () => {
-    expect(normalizeLanguage("fr-FR")).toBe("fra");
-    expect(normalizeLanguage("en-US")).toBe("eng");
-    expect(normalizeLanguage("pt-BR")).toBe("por");
-  });
-
-  it("should not translate languages it doesn't know", () => {
-    expect(normalizeLanguage("ggg")).toBe("ggg");
-  });
-});
-
-describe("utils - normalizeAudioTrack", () => {
-  it("should return null if language is `null`", () => {
-    expect(normalizeAudioTrack(null)).toBe(null);
-  });
-
-  it("should return undefined if language is `undefined`", () => {
-    expect(normalizeAudioTrack(undefined)).toBe(undefined);
-  });
-
-  it("should format a normalized audio track for an empty string", () => {
-    expect(normalizeAudioTrack("")).toEqual({ language: "",
-                                              audioDescription: false,
-                                              normalized: "" });
-  });
-
-  it("should format a normalized audio track for a given language", () => {
-    expect(normalizeAudioTrack("fre")).toEqual({ language: "fre",
-                                                 audioDescription: false,
-                                                 normalized: "fra" });
-    expect(normalizeAudioTrack("en")).toEqual({ language: "en",
-                                                audioDescription: false,
-                                                normalized: "eng" });
-    expect(normalizeAudioTrack("pt-BR")).toEqual({ language: "pt-BR",
-                                                   audioDescription: false,
-                                                   normalized: "por" });
-  });
-
-  it("should accept an object indicating the language", () => {
-    expect(normalizeAudioTrack({ language: "fre" })).toEqual({
-      language: "fre",
-      audioDescription: false,
-      normalized: "fra",
-    });
-    expect(normalizeAudioTrack({ language: "en" })).toEqual({
-      language: "en",
-      audioDescription: false,
-      normalized: "eng",
-    });
-    expect(normalizeAudioTrack({ language: "pt-BR" })).toEqual({
-      language: "pt-BR",
-      audioDescription: false,
-      normalized: "por",
-    });
-  });
-
-  it("should be able to specify that is is not an audio description", () => {
-    expect(normalizeAudioTrack({
-      language: "fre",
-      audioDescription: false,
-    })).toEqual({
-      language: "fre",
-      audioDescription: false,
-      normalized: "fra",
-    });
-    expect(normalizeAudioTrack({
-      language: "en",
-      audioDescription: false,
-    })).toEqual({
-      language: "en",
-      audioDescription: false,
-      normalized: "eng",
-    });
-    expect(normalizeAudioTrack({
-      language: "pt-BR",
-      audioDescription: false,
-    })).toEqual({
-      language: "pt-BR",
-      audioDescription: false,
-      normalized: "por",
-    });
-  });
-
-  it("should be able to specify that is is an audio description", () => {
-    expect(normalizeAudioTrack({
-      language: "fre",
-      audioDescription: true,
-    })).toEqual({
-      language: "fre",
-      audioDescription: true,
-      normalized: "fra",
-    });
-    expect(normalizeAudioTrack({
-      language: "en",
-      audioDescription: true,
-    })).toEqual({
-      language: "en",
-      audioDescription: true,
-      normalized: "eng",
-    });
-    expect(normalizeAudioTrack({
-      language: "pt-BR",
-      audioDescription: true,
-    })).toEqual({
-      language: "pt-BR",
-      audioDescription: true,
-      normalized: "por",
-    });
-  });
-
-  it("should be able to specify that is is a dub", () => {
-    expect(normalizeAudioTrack({
-      language: "fre",
-      audioDescription: true,
-      isDub: true,
-    })).toEqual({
-      language: "fre",
-      isDub: true,
-      audioDescription: true,
-      normalized: "fra",
-    });
-    expect(normalizeAudioTrack({
-      language: "en",
-      audioDescription: false,
-      isDub: true,
-    })).toEqual({
-      language: "en",
-      audioDescription: false,
-      normalized: "eng",
-      isDub: true,
-    });
-    expect(normalizeAudioTrack({
-      language: "pt-BR",
-      audioDescription: true,
-      isDub: true,
-    })).toEqual({
-      language: "pt-BR",
-      audioDescription: true,
-      normalized: "por",
-      isDub: true,
-    });
-  });
-});
-
-describe("utils - normalizeTextTrack", () => {
-  it("should return null if language is `null`", () => {
-    expect(normalizeTextTrack(null)).toBe(null);
-  });
-
-  it("should return undefined if language is `undefined`", () => {
-    expect(normalizeTextTrack(undefined)).toBe(undefined);
-  });
-
-  it("should format a normalized audio track for an empty string", () => {
-    expect(normalizeTextTrack("")).toEqual({
-      language: "",
-      closedCaption: false,
-      normalized: "",
-    });
-  });
-
-  it("should format a normalized audio track for a given language", () => {
-    expect(normalizeTextTrack("fre")).toEqual({
-      language: "fre",
-      closedCaption: false,
-      normalized: "fra",
-    });
-    expect(normalizeTextTrack("en")).toEqual({
-      language: "en",
-      closedCaption: false,
-      normalized: "eng",
-    });
-    expect(normalizeTextTrack("pt-BR")).toEqual({
-      language: "pt-BR",
-      closedCaption: false,
-      normalized: "por",
-    });
-  });
-
-  it("should accept an object indicating the language", () => {
-    expect(normalizeTextTrack({ language: "fre" })).toEqual({
-      language: "fre",
-      closedCaption: false,
-      normalized: "fra",
-    });
-    expect(normalizeTextTrack({ language: "en" })).toEqual({
-      language: "en",
-      closedCaption: false,
-      normalized: "eng",
-    });
-    expect(normalizeTextTrack({ language: "pt-BR" })).toEqual({
-      language: "pt-BR",
-      closedCaption: false,
-      normalized: "por",
-    });
-  });
-
-  it("should be able to specify that is is not a closed caption", () => {
-    expect(normalizeTextTrack({
-      language: "fre",
-      closedCaption: false,
-    })).toEqual({
-      language: "fre",
-      closedCaption: false,
-      normalized: "fra",
-    });
-    expect(normalizeTextTrack({
-      language: "en",
-      closedCaption: false,
-    })).toEqual({
-      language: "en",
-      closedCaption: false,
-      normalized: "eng",
-    });
-    expect(normalizeTextTrack({
-      language: "pt-BR",
-      closedCaption: false,
-    })).toEqual({
-      language: "pt-BR",
-      closedCaption: false,
-      normalized: "por",
-    });
-  });
-
-  it("should be able to specify that is is a closed caption", () => {
-    expect(normalizeTextTrack({
-      language: "fre",
-      closedCaption: true,
-    })).toEqual({
-      language: "fre",
-      closedCaption: true,
-      normalized: "fra",
-    });
-    expect(normalizeTextTrack({
-      language: "en",
-      closedCaption: true,
-    })).toEqual({
-      language: "en",
-      closedCaption: true,
-      normalized: "eng",
-    });
-    expect(normalizeTextTrack({
-      language: "pt-BR",
-      closedCaption: true,
-    })).toEqual({
-      language: "pt-BR",
-      closedCaption: true,
-      normalized: "por",
-    });
-  });
-});