rx-player 3.33.0 → 3.33.1

package/src/parsers/texttracks/srt/__tests__/parse_cue.test.ts

@@ -1,123 +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 parseCueBlock from "../parse_cue";
-
-const cueBlock1 = [
-  "112",
-  "00:00:31.080 --> 00:07:32.200",
-  "Je suis le petit chevalier",
-  "Avec le ciel dessus mes yeux",
-  "Je ne peux pas me effroyer",
-];
-
-const cueBlock2 = [
-  "00:17:55.520-->00:17:57.640",
-  "Je suis le petit chevalier",
-];
-
-const cueBlock3 = [
-  "00:18:01--> 00:18:09",
-];
-
-const cueBlock4 = [
-  "112",
-  "00:18:31.080 -->00:18:32.200",
-];
-
-const notCueBlock1 = [
-  "TOTO",
-];
-
-const notCueBlock2 = [
-  "TOTO",
-  "TATA",
-];
-
-const notCueBlock3 = [
-  "TOTO",
-  "TATA",
-  "00:18:31.080 --> 00:18:32.200",
-];
-
-describe("parsers - srt - parseCueBlocks", () => {
-  it("should correctly parse regular cue blocks", () => {
-    expect(parseCueBlock(cueBlock1, 0)).toEqual({
-      start: 31.08,
-      end: 452.2,
-      payload: [
-        "Je suis le petit chevalier",
-        "Avec le ciel dessus mes yeux",
-        "Je ne peux pas me effroyer",
-      ],
-    });
-    expect(parseCueBlock(cueBlock2, 0)).toEqual({
-      start: 1075.52,
-      end: 1077.64,
-      payload: [
-        "Je suis le petit chevalier",
-      ],
-    });
-    expect(parseCueBlock(cueBlock3, 0)).toEqual({
-      start: 1081,
-      end: 1089,
-      payload: [],
-    });
-    expect(parseCueBlock(cueBlock4, 0)).toEqual({
-      start: 1111.08,
-      end: 1112.2,
-      payload: [],
-    });
-  });
-
-  it("should add timeOffset in seconds", () => {
-    expect(parseCueBlock(cueBlock1, 10.1)).toEqual({
-      start: 41.18,
-      end: 462.3,
-      payload: [
-        "Je suis le petit chevalier",
-        "Avec le ciel dessus mes yeux",
-        "Je ne peux pas me effroyer",
-      ],
-    });
-    expect(parseCueBlock(cueBlock2, 6)).toEqual({
-      start: 1081.52,
-      end: 1083.64,
-      payload: [
-        "Je suis le petit chevalier",
-      ],
-    });
-    expect(parseCueBlock(cueBlock3, -1.5)).toEqual({
-      start: 1079.5,
-      end: 1087.5,
-      payload: [],
-    });
-    expect(parseCueBlock(cueBlock4, -1)).toEqual({
-      start: 1110.08,
-      end: 1111.2,
-      payload: [],
-    });
-  });
-
-  it("should return null for invalid cue blocks", () => {
-    expect(parseCueBlock(notCueBlock1, 0)).toEqual(null);
-    expect(parseCueBlock(notCueBlock1, 5)).toEqual(null);
-    expect(parseCueBlock(notCueBlock2, 0)).toEqual(null);
-    expect(parseCueBlock(notCueBlock2, 9)).toEqual(null);
-    expect(parseCueBlock(notCueBlock3, 0)).toEqual(null);
-    expect(parseCueBlock(notCueBlock3, 21)).toEqual(null);
-  });
-});

package/src/parsers/texttracks/srt/__tests__/parse_timestamp.test.ts

@@ -1,36 +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 parseTimestamp from "../parse_timestamp";
-
-const time1 = "00:00:31.080";
-const time2 = "00:18:01";
-const notTime1 = "1";
-const notTime2 = "a";
-const notTime3 = "00:31.080";
-
-describe("parsers - srt - parseTimestamp", () => {
-  it("should correctly parse textual time into seconds", () => {
-    expect(parseTimestamp(time1)).toEqual(31.08);
-    expect(parseTimestamp(time2)).toEqual(1081);
-  });
-
-  it("should return undefined for invalid textual time", () => {
-    expect(parseTimestamp(notTime1)).toEqual(undefined);
-    expect(parseTimestamp(notTime2)).toEqual(undefined);
-    expect(parseTimestamp(notTime3)).toEqual(undefined);
-  });
-});

package/src/parsers/texttracks/srt/find_end_of_cue_block.ts

@@ -1,46 +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 isNonEmptyString from "../../../utils/is_non_empty_string";
-
-/**
- * Returns the first line that is not apart of the given cue block.
- * The index given can be anywhere in a known cue block.
- *
- * This function is extra-resilient due to observed real-life malformed
- * subtitles.
- * Basically, it allows some deviation from the specification as long as the
- * intent is pretty clear.
- * @param {Array<string>} linified - Whole srt. Line by line.
- * @param {number} startIndex - Index in `linified` of the first line within the
- * block.
- * @returns {number}
- */
-export default function findEndOfCueBlock(
-  linified: string[],
-  startIndex: number
-): number {
-  let firstEmptyLineIndex = startIndex + 1;
-
-  // continue incrementing i until either:
-  //   - an empty line
-  //   - the end
-  while (isNonEmptyString(linified[firstEmptyLineIndex])) {
-    firstEmptyLineIndex++;
-  }
-
-  return firstEmptyLineIndex;
-}

package/src/parsers/texttracks/srt/get_cue_blocks.ts

@@ -1,49 +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 isNonEmptyString from "../../../utils/is_non_empty_string";
-import findEndOfCueBlock from "./find_end_of_cue_block";
-
-/**
- * Get cue blocks from a srt file.
- * @param {Array.<string>} linified - Whole srt file. Each new element in this
- * array is a new line.
- * @returns {Array.<Array.<string>>}
- */
-export default function getCueBlocks(linified : string[]) : string[][] {
-  const cueBlocks : string[][] = [];
-  for (let i = 0; i < linified.length; i++) {
-    if (isNonEmptyString(linified[i])) {
-      const endOfCue = findEndOfCueBlock(linified, i);
-      const cueBlockCandidate = linified.slice(i, endOfCue);
-      if (cueBlockCandidate.length > 0) {
-        if (cueBlockCandidate.length === 1) {
-          if (cueBlockCandidate[0].indexOf("-->") >= 0) {
-            cueBlocks.push(cueBlockCandidate);
-          }
-        } else {
-          if (cueBlockCandidate[1].indexOf("-->") >= 0 ||
-              cueBlockCandidate[0].indexOf("-->") >= 0)
-          {
-            cueBlocks.push(cueBlockCandidate);
-          }
-        }
-      }
-      i = endOfCue;
-    }
-  }
-  return cueBlocks;
-}

package/src/parsers/texttracks/srt/html.ts

@@ -1,182 +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.
- */
-
-/**
- * /!\ This file is feature-switchable.
- * It always should be imported through the `features` object.
- */
-
-// Parse SRT subtitles into HTML.
-
-// Done for fun. Understand <b>, <i>, <u> and <font color="#ff0000" /> type
-// of tags.
-
-import getCueBlocks from "./get_cue_blocks";
-import parseCueBlock from "./parse_cue";
-
-export interface ISRTHTMLCue {
-  start : number;
-  end: number;
-  element : HTMLElement;
-}
-
-/**
- * @param {string} srtStr
- * @param {Number} timeOffset
- * @returns {Array.<Object>}
- */
-export default function parseSRTStringToHTML(
-  srtStr : string,
-  timeOffset : number
-) : ISRTHTMLCue[] {
-  // Even if srt only authorize CRLF, we will also take LF or CR as line
-  // terminators for resilience
-  const lines = srtStr.split(/\r\n|\n|\r/);
-
-  const cueBlocks : string[][] = getCueBlocks(lines);
-
-  const cues : ISRTHTMLCue[] = [];
-  for (let i = 0; i < cueBlocks.length; i++) {
-    const cueObject = parseCueBlock(cueBlocks[i], timeOffset);
-    if (cueObject != null) {
-      const htmlCue = toHTML(cueObject);
-      if (htmlCue != null) {
-        cues.push(htmlCue);
-      }
-    }
-  }
-
-  return cues;
-}
-
-/**
- * @param {Array.<string>} cueLines
- * @param {Number} timeOffset
- * @returns {Object|null}
- */
-function toHTML(cueObj : {
-  start : number;
-  end : number;
-  payload : string[];
-}) : ISRTHTMLCue|null {
-  const { start, end, payload } = cueObj;
-
-  const pEl = document.createElement("div");
-  pEl.className = "rxp-texttrack-p";
-  pEl.style.fontSize = "28px";
-  pEl.style.position = "absolute";
-  pEl.style.bottom = "5%";
-  pEl.style.width = "100%";
-  pEl.style.textAlign = "center";
-  pEl.style.color = "#fff";
-  pEl.style.textShadow = "-1px -1px 2px #000," +
-    "1px -1px 2px #000," +
-    "-1px 1px 2px #000," +
-    "1px 1px 2px #000";
-
-  for (let i = 0; i < payload.length; i++) {
-    if (i !== 0) {
-      pEl.appendChild(document.createElement("br"));
-    }
-    const span = generateSpansFromSRTText(payload[i]);
-    pEl.appendChild(span);
-  }
-
-  return {
-    start,
-    end,
-    element: pEl,
-  };
-}
-
-/**
- * Take a single srt line and convert it into a span with the right style while
- * avoiding XSS.
- * What we do is set a whitelist of authorized tags, and recreate the
- * corresponding tag from scratch.
- * Supported tags:
- *   - <b>: make content bold
- *   - <i>: make content italic
- *   - <u>: draw underline on content
- *   - <font color="x">: add color x to the content
- * @param {string} text
- * @returns {HTMLElement}
- */
-function generateSpansFromSRTText(text : string) : HTMLElement {
-  const secureDiv = document.createElement("div");
-  secureDiv.innerHTML = text;
-
-  const _loop = function(node : Node) : HTMLElement {
-    const childNodes = node.childNodes;
-    const span = document.createElement("span");
-    span.className = "rxp-texttrack-span";
-
-    for (let i = 0; i < childNodes.length; i++) {
-      const currentNode = childNodes[i];
-      if (currentNode.nodeName === "#text") {
-        const linifiedText = (currentNode as Text).wholeText
-          .split("\n");
-
-        for (let line = 0; line < linifiedText.length; line++) {
-          if (line !== 0) {
-            span.appendChild(document.createElement("br"));
-          }
-          if (linifiedText[line].length > 0) {
-            const textNode = document.createTextNode(linifiedText[line]);
-            span.appendChild(textNode);
-          }
-        }
-      } else if (currentNode.nodeName === "B") {
-        const spanChild = _loop(currentNode);
-        spanChild.style.fontWeight = "bold";
-        span.appendChild(spanChild);
-      } else if (currentNode.nodeName === "I") {
-        const spanChild = _loop(currentNode);
-        spanChild.style.fontStyle = "italic";
-        span.appendChild(spanChild);
-      } else if (currentNode.nodeName === "U") {
-        const spanChild = _loop(currentNode);
-        spanChild.style.textDecoration = "underline";
-        span.appendChild(spanChild);
-      } else if (isNodeFontWithColorProp(currentNode) &&
-                 typeof currentNode.color === "string")
-      {
-        // TODO loop through attributes to find color?
-        const spanChild = _loop(currentNode);
-        spanChild.style.color = currentNode.color;
-        span.appendChild(spanChild);
-      } else {
-        const spanChild = _loop(currentNode);
-        span.appendChild(spanChild);
-      }
-    }
-    return span;
-  };
-
-  return _loop(secureDiv);
-}
-
-/**
- * Returns `true` if the given node is a `<font>` element which contains a
- * `color` attribute.
- * @param {Node} node
- * @returns {boolean}
- */
-function isNodeFontWithColorProp(
-  node : Node
-) : node is Node & { color : unknown } {
-  return node.nodeName === "FONT" && "color" in node;
-}

package/src/parsers/texttracks/srt/native.ts

@@ -1,74 +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.
- */
-
-/**
- * /!\ This file is feature-switchable.
- * It always should be imported through the `features` object.
- */
-
-// srt to VTTCue parser, Done for fun.
-// Heavily inspired from the WebVTT implementation
-
-import {
-  ICompatVTTCue,
-  makeVTTCue,
-} from "../../../compat/index";
-import getCueBlocks from "./get_cue_blocks";
-import parseCueBlock from "./parse_cue";
-
-/**
- * Parse whole srt file into an array of cues, to be inserted in a video's
- * TrackElement.
- * @param {string} srtStr
- * @param {Number} timeOffset
- * @returns {Array.<VTTCue|TextTrackCue>}
- */
-export default function parseSRTStringToVTTCues(
-  srtStr : string,
-  timeOffset : number
-) : Array<ICompatVTTCue|TextTrackCue> {
-  // Even if srt only authorize CRLF, we will also take LF or CR as line
-  // terminators for resilience
-  const lines = srtStr.split(/\r\n|\n|\r/);
-
-  const cueBlocks : string[][] = getCueBlocks(lines);
-
-  const cues : Array<ICompatVTTCue|TextTrackCue> = [];
-  for (let i = 0; i < cueBlocks.length; i++) {
-    const cueObject = parseCueBlock(cueBlocks[i], timeOffset);
-    if (cueObject !== null) {
-      const nativeCue = toNativeCue(cueObject);
-      if (nativeCue !== null) {
-        cues.push(nativeCue);
-      }
-    }
-  }
-  return cues;
-}
-
-/**
- * @param {Object} cue Object
- * @returns {TextTrackCue|VTTCue|null}
- */
-function toNativeCue(cueObj : {
-  start : number;
-  end : number;
-  payload : string[];
-}) : ICompatVTTCue|TextTrackCue|null {
-  const { start, end, payload } = cueObj;
-  const text = payload.join("\n");
-  return makeVTTCue(start, end, text);
-}

package/src/parsers/texttracks/srt/parse_cue.ts

@@ -1,76 +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 isNonEmptyString from "../../../utils/is_non_empty_string";
-import parseTimestamp from "./parse_timestamp";
-
-export interface ISRTCueObject { start : number;
-                                 end : number;
-                                 payload : string[]; }
-
-/**
- * Parse cue block into a cue object which contains:
- *   - start {number}: the start of the cue as a timestamp in seconds
- *   - end {number}: the end of the cue as a timestamp in seconds
- *   - payload {Array.<string>}: the payload of the cue
- * @param {Array.<string>} cueLines
- * @param {Number} timeOffset
- * @returns {Object}
- */
-export default function parseCueBlock(
-  cueLines : string[],
-  timeOffset : number
-) : ISRTCueObject | null {
-  if (cueLines.length === 0) {
-    return null;
-  }
-
-  let startTimeString : string|undefined;
-  let endTimeString : string|undefined;
-  let payload : string[] = [];
-
-  // normally in srt, the timing is at second position.
-  // We still authorize to put it in the first position for resilience
-  if (isNonEmptyString(cueLines[1]) && cueLines[1].indexOf("-->") !== -1) {
-    [startTimeString, endTimeString] = cueLines[1].split("-->")
-      .map(s => s.trim());
-    payload = cueLines.slice(2, cueLines.length);
-  }
-
-  if (!isNonEmptyString(startTimeString) ||
-      !isNonEmptyString(endTimeString))
-  {
-    // Try to see if we find them in the first position
-    [startTimeString, endTimeString] = cueLines[0].split("-->")
-      .map(s => s.trim());
-    payload = cueLines.slice(1, cueLines.length);
-  }
-
-  if (!isNonEmptyString(startTimeString) || !isNonEmptyString(endTimeString)) {
-    // if the time is still not found, exit
-    return null;
-  }
-
-  const start = parseTimestamp(startTimeString);
-  const end = parseTimestamp(endTimeString);
-  if (start === undefined || end === undefined) {
-    return null;
-  }
-
-  return { start: start + timeOffset,
-           end : end + timeOffset,
-           payload };
-}

package/src/parsers/texttracks/srt/parse_timestamp.ts

@@ -1,37 +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 isNonEmptyString from "../../../utils/is_non_empty_string";
-
-/**
- * Parse a single srt timestamp into seconds
- * @param {string} timestampString
- * @returns {Number|undefined}
- */
-export default function parseTimestamp(
-  timestampString : string
-) : number|undefined {
-  const splittedTS = timestampString.split(":");
-  if (isNonEmptyString(splittedTS[2])) {
-    const hours = parseInt(splittedTS[0], 10);
-    const minutes = parseInt(splittedTS[1], 10);
-    const seconds = parseFloat(splittedTS[2].replace(",", "."));
-    if (isNaN(hours) || isNaN(minutes) || isNaN(seconds)) {
-      return undefined;
-    }
-    return hours * 60 * 60 + minutes * 60 + seconds;
-  }
-}