rx-player 3.26.1 → 3.26.2

package/scripts/doc-generator/construct_page_list.js

@@ -1,120 +0,0 @@
-const { promisify } = require("util");
-const fs = require("fs");
-const path = require("path");
-const readTitleFromMD = require("./read_title_from_md.js");
-
-/**
- * Given the path to a Markdown document, returns its title as a string.
- * null if no title has been found.
- *
- * @param {string} MDFile
- * @returns {string|null}
- * @throws {Error} - Throws if the file cannot be read.
- */
-async function readTitleFromMDFile(MDFile) {
-  let data;
-  try {
-    data = await promisify(fs.readFile)(MDFile, "utf8");
-  } catch (err) {
-    throw new Error("error reading file:", err);
-  }
-  return readTitleFromMD(data);
-}
-
-/**
- * Construct exhaustive list of files converted, known from the filesToConvert
- * Array, as a Markdown document.
- *
- * The filesToConvert Array should contain at least the following keys:
- *   - inputFile {string}: normalized absolute path to the markdown file to
- *     convert
- *   - outputFile {string}: normalized absolute path to where the resulting
- *     HTML file should be stored
- *
- * @param {Array.<Object>} filesToConvert
- * @returns {string}
- */
-module.exports = async function constructPageList(filesToConvert, outputDir) {
-  /**
-   * Add title of pages to filesToConvert as a `title` key.
-   * @type {Array.<Object>}
-   */
-  const withTitle = [];
-  for (let i = 0; i < filesToConvert.length; i++) {
-    const { inputFile } = filesToConvert[i];
-    const title = await readTitleFromMDFile(inputFile);
-    withTitle.push(Object.assign({ title }, filesToConvert[i]));
-  }
-
-  const hierarchy = withTitle
-    .reduce((acc, elem) => {
-      const splittedPath = elem.outputFile.split(path.sep);
-      if (splittedPath.length === 0) {
-        return acc;
-      }
-
-      let consideredObj = acc;
-
-      let i = 0;
-      for (; i < splittedPath.length - 1; i++) {
-        const key = splittedPath[i];
-        if (typeof consideredObj.subdirs[key] === "undefined") {
-          consideredObj.subdirs[key] = { subdirs: {},
-                                         files: [],
-                                         index: null };
-        }
-        consideredObj = consideredObj.subdirs[key];
-      }
-
-      const link = path.relative(outputDir, elem.outputFile);
-      const title = elem.title || link;
-      if (splittedPath[i].toLowerCase() === "index.html") {
-        consideredObj.index = { link, title };
-      } else {
-        consideredObj.files.push({ link, title });
-      }
-      return acc;
-    }, { subdirs: {},
-         files: [],
-         index: null });
-
-  const listArr = [];
-  listArr.push("# Page list");
-  listArr.push("");
-  listArr.push("Here is an exhaustive list of all the pages you can read in " +
-               "this generated documentation:");
-
-  let indentationLevel = 0;
-  function parseDir(obj) {
-    if (obj.index != null) {
-      listArr.push(" ".repeat(indentationLevel * 2) +
-                   "- [" + obj.index.title + "]" +
-                   "(" + obj.index.link + ")");
-      indentationLevel += 1;
-    } else if (obj.files.length || indentationLevel > 0) {
-      listArr.push(" ".repeat(indentationLevel * 2) +
-                   "- Undocumented section");
-      indentationLevel += 1;
-    }
-
-    if (obj.files.length) {
-      obj.files.forEach(file => {
-        listArr.push(" ".repeat(indentationLevel * 2) +
-                     "- [" + file.title + "]" +
-                     "(" + file.link + ")");
-      });
-    }
-
-    const subdirs = Object.keys(obj.subdirs).sort();
-    if (subdirs.length) {
-      for (let i = 0; i < subdirs.length; i++) {
-        const subdir = subdirs[i];
-        parseDir(obj.subdirs[subdir]);
-        indentationLevel -= 1;
-      }
-    }
-  }
-
-  parseDir(hierarchy, 0);
-  return listArr.join("\n");
-};

package/scripts/doc-generator/create_for_dir.js

@@ -1,151 +0,0 @@
-const { promisify } = require("util");
-const fs = require("fs");
-const path = require("path");
-const getFilesToConvert = require("./get_files_to_convert.js");
-const mkdirParent = require("./mkdir_parent.js");
-const createDocumentationPage = require("./create_page.js");
-const constructPageList = require("./construct_page_list.js");
-const constructTableOfContents = require("./construct_table_of_contents.js");
-const convertMDToHTML = require("./convert_MD_to_HMTL.js");
-const constructHTML = require("./construct_html.js");
-
-async function createDirIfDoesntExist(dir) {
-  const doesCSSOutDirExists = await promisify(fs.exists)(dir);
-  if (!doesCSSOutDirExists) {
-    await mkdirParent(dir);
-  }
-}
-
-/**
- * Create documentation for the directory given into the ouput directory given.
- * @param {string} baseInDir
- * @param {string} baseOutDir
- * @param {Object} [options={}]
- * @param {Function} [options.getPageTitle] - Callback returning the name of the
- * page, based on the name of a single markdown document.
- * If not set, the page title will just be the corresponding markdown's title.
- * @param {Array.<string>} [options.css] - Optional CSS files which will be
- * linked to each generated page.
- * Should be the path to each of those.
- * @param {Function|undefined} [options.fileFilter] - Callback allowing to
- * filter out markdown pages from being converted to HTML.
- * Takes 2 arguments: the fileName and its path, both strings.
- * Return true if the file should be converted to HTML. False otherwise.
- * No markdown document is filtered out if this callback is not set.
- * @param {Function|undefined} [options.beforeParse] - Callback which will be
- * called on each markdown document just before transforming it into HTML.
- * Takes in argument the markdown content (as a string) and should return the
- * markdown document you want to convert into HTML (also as a string).
- * If not set, each markdown document will be converted as is.
- * @returns {Promise} - Resolve when done
- */
-module.exports = async function createDocumentationForDir(
-  baseInDir,
-  baseOutDir,
-  options = {},
-) {
-  const { getPageTitle = t => t,
-          fileFilter,
-          beforeParse,
-          css = [] } = options;
-
-  // 1 - copy CSS files
-  const cssOutputDir = path.join(path.resolve(baseOutDir), "styles");
-  const cssOutputPaths = css.map(cssFilepath => {
-    return path.join(cssOutputDir, path.basename(cssFilepath));
-  });
-
-  if (css.length > 0) {
-    await createDirIfDoesntExist(cssOutputDir);
-    await Promise.all(css.map(async (cssInput, i) => {
-      await promisify(fs.copyFile)(cssInput, cssOutputPaths[i]);
-    }));
-  }
-
-  // 2 - Construct list of html files
-  const filesToConvert = await getFilesToConvert(baseInDir,
-                                                 baseOutDir,
-                                                 { fileFilter });
-
-  const [homeLink, listLink] = filesToConvert.length > 1 ?
-    [ path.join(path.resolve(baseOutDir), "pages", "index.html"),
-      path.join(path.resolve(baseOutDir), "list.html") ] :
-    [ null, null ];
-
-  // keys: inputFile; values: outputFile
-  const fileDict = filesToConvert.reduce((acc, entry) => {
-    acc[entry.inputFile] = entry.outputFile;
-    return acc;
-  }, {});
-
-  // 3 - Create documentation pages
-  for (let i = 0; i < filesToConvert.length; i++) {
-    const { inputFile, outputFile } = filesToConvert[i];
-    // Create output directory if it does not exist
-    const outDir = path.dirname(outputFile);
-    await createDirIfDoesntExist(outDir);
-    const cssRelativePaths =
-      cssOutputPaths.map(cssOutput => path.relative(outDir, cssOutput));
-
-    // add link translation to options
-    const linkTranslator = linkTranslatorFactory(inputFile, outDir, fileDict);
-    await createDocumentationPage(inputFile,
-                                  outputFile,
-                                  { linkTranslator,
-                                    getPageTitle,
-                                    beforeParse,
-                                    homeLink: path.relative(outDir, homeLink),
-                                    listLink: path.relative(outDir, listLink),
-                                    css: cssRelativePaths });
-  }
-
-  // 4 - Construct specific "Page List" page.
-  const pageListMD = await constructPageList(filesToConvert, baseOutDir);
-  const { content, toc } = constructTableOfContents(pageListMD);
-  const listPageCss =
-    cssOutputPaths.map(cssOutput => path.relative(baseOutDir, cssOutput));
-  const listHTML = constructHTML(getPageTitle("Page List"),
-                                 convertMDToHTML(content),
-                                 { css: listPageCss,
-                                   toc,
-                                   homeLink: path.relative(baseOutDir,
-                                                           homeLink),
-                                   listLink: path.relative(baseOutDir,
-                                                           listLink) });
-
-  const fileName = path.join(baseOutDir, "list.html");
-  await promisify(fs.writeFile)(fileName, listHTML);
-};
-
-/**
- * Generate linkTranslator functions
- * @param {string} inputFile
- * @param {Object} fileDict
- * @returns {Function}
- */
-function linkTranslatorFactory(inputFile, outputDir, fileDict) {
-  /**
-   * Convert links to files that will be converted to the links of the
-   * corresponding converted output files.
-   * @param {string} link
-   * @returns {string}
-   */
-  return (link) => {
-    const extname = path.extname(link);
-    const indexOfAnchor = extname.indexOf("#");
-
-    const anchor = indexOfAnchor > 0 ?
-      extname.substring(indexOfAnchor) :
-      "";
-
-    const linkWithoutAnchor = link.substring(0, link.length - anchor.length);
-
-    const completeLink = path.join(path.dirname(inputFile), linkWithoutAnchor);
-    const normalizedLink = path.normalize(path.resolve(completeLink));
-
-    const translation = fileDict[normalizedLink];
-    return translation ?
-      path.relative(outputDir, translation + anchor) :
-      link;
-  };
-}

package/scripts/doc-generator/get_files_to_convert.js

@@ -1,71 +0,0 @@
-const { promisify } = require("util");
-const fs = require("fs");
-const path = require("path");
-
-/**
- * Returns information about every Markdown files we have to convert to HTML
- * in an array.
- *
- * The returned Array contains Objects with the following keys:
- *   - inputFile {string}: normalized absolute path to the markdown file to
- *     convert
- *   - outputFile {string}: normalized absolute path to where the resulting
- *     HTML file should be stored
- * @param {string} baseInDir - The directory where the markdown files are. This
- * directory will be checked for files recursively.
- * @param {string} baseOutDir - The directory where the resulting HTML files
- * will reside.
- * @param {Object} [opts = {}]
- * @param {Function|undefined} opts.fileFilter
- * @returns {Promise.<Array.<Object>>}
- */
-module.exports = async function getFilesToConvert(
-  baseInDir,
-  baseOutDir,
-  opts = {},
-) {
-  const filesToConvert = [];
-  const { fileFilter } = opts;
-  async function recusiveGetFilesToConvert(inputDir, outputDir) {
-    // Loop through all the files in the temp directory
-    let files;
-    try {
-      files = await promisify(fs.readdir)(inputDir);
-    } catch (err) {
-      throw new Error("error while reading directory: " + err);
-    }
-
-    const filteredFiles = fileFilter != null ?
-      files.filter((fileName) => fileFilter(fileName, baseInDir)) :
-      files;
-
-    for (let i = 0; i < filteredFiles.length; i++) {
-      const file = filteredFiles[i];
-      const filePath = path.join(inputDir, file);
-      let stat;
-      try {
-        stat = await promisify(fs.stat)(filePath);
-      } catch (err) {
-        throw new Error("error while stating file: " + err);
-      }
-
-      if (stat.isDirectory()) {
-        const newOutDir = path.join(outputDir, file);
-        await recusiveGetFilesToConvert(filePath, newOutDir);
-      } else if(stat.isFile()) {
-        const extname = path.extname(file);
-        if (extname === ".md") {
-          const outputFile =
-            path.join(outputDir, path.basename(filePath, ".md") + ".html");
-
-          filesToConvert.push({
-            inputFile: path.normalize(path.resolve(filePath)),
-            outputFile: path.normalize(path.resolve(outputFile)),
-          });
-        }
-      }
-    }
-  }
-  await recusiveGetFilesToConvert(baseInDir, path.join(baseOutDir, "pages"));
-  return filesToConvert;
-};

package/scripts/doc-generator/mkdir_parent.js

@@ -1,21 +0,0 @@
-const { promisify } = require("util");
-const fs = require("fs");
-const path = require("path");
-
-/**
- * Recursive mkdir (create parent directories if they do not exist).
- * @param {string} dirPath
- * @param {string} mode
- * @returns {Promise}
- */
-module.exports = async function mkdirParent(dirPath, mode) {
-  try {
-    await promisify(fs.mkdir)(dirPath, mode);
-  } catch(error) {
-    if (error && error.errno === -2) {
-      return mkdirParent(path.dirname(dirPath), mode)
-        .then(() => mkdirParent(dirPath, mode));
-    }
-    throw error;
-  }
-};

package/scripts/doc-generator/read_title_from_md.js

@@ -1,22 +0,0 @@
-/**
- * Returns the title read from a Markdown document.
- * That is, the first "#"-prepended chapter.
- *
- * null if not found.
- * @param {string} data
- * @returns {string|null}
- */
-module.exports = function readTitleFromMD(data) {
-  const lines = data.split(/\r\n|\n|\r/);
-
-  // TODO Might be more efficient and less error-prone as a markdown-it plugin.
-  for (let i = 0, len = lines.length; i < len; i++) {
-    if (/^ *# +/.test(lines[i])) {
-      const regExec = /^ *# +(.*)$/.exec(lines[i]);
-      if (regExec && regExec[1]) {
-        return regExec[1].replace(/ #* *$/, "").trim();
-      }
-    }
-  }
-  return null;
-};

package/scripts/doc-generator/remove_toc_from_md.js

@@ -1,20 +0,0 @@
-/**
- * Remove "## table of contents" line from markdown if it exists.
- * @param {string} md
- * @returns {string}
- */
-module.exports = function removeTableOfContentFromMD(md) {
-  const lines = md.split(/\r\n|\n|\r/);
-  for (let i = 0, len = lines.length; i < len; i++) {
-    if (/^ *## +table of contents/i.test(lines[i])) {
-      const start = i;
-      for (i = i + 1; i < len; i++) {
-        if (/^ *## +/.test(lines[i])) {
-          lines.splice(start, i - 1 - start);
-          return lines.join("\n");
-        }
-      }
-    }
-  }
-  return lines.join("\n");
-};

package/src/core/abr/create_filters.ts

@@ -1,59 +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 {
-  combineLatest as observableCombineLatest,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import { map } from "rxjs/operators";
-import objectAssign from "../../utils/object_assign";
-import { IABRFiltersObject } from "./representation_estimator";
-
-/**
- * Create Observable that merge several throttling Observables into one.
- * @param {Observable} limitWidth$ - Emit the width at which the chosen
- * Representation should be limited.
- * @param {Observable} throttleBitrate$ - Emit the maximum bitrate authorized.
- * @param {Observable} throttle$ - Also emit the maximum bitrate authorized.
- * Here for legacy reasons.
- * @returns {Observable}
- */
-export default function createFilters(
-  limitWidth$? : Observable<number>,
-  throttleBitrate$? : Observable<number>,
-  throttle$? : Observable<number>
-) : Observable<IABRFiltersObject> {
-  const deviceEventsArray : Array<Observable<IABRFiltersObject>> = [];
-
-  if (limitWidth$ != null) {
-    deviceEventsArray.push(limitWidth$.pipe(map(width => ({ width }))));
-  }
-  if (throttle$ != null) {
-    deviceEventsArray.push(throttle$.pipe(map(bitrate => ({ bitrate }))));
-  }
-  if (throttleBitrate$ != null) {
-    deviceEventsArray.push(throttleBitrate$.pipe(map(bitrate => ({ bitrate }))));
-  }
-
-  // Emit restrictions on the pools of available representations to choose
-  // from.
-  return deviceEventsArray.length > 0 ?
-    observableCombineLatest(deviceEventsArray)
-      .pipe(map((args : IABRFiltersObject[]) : IABRFiltersObject =>
-        objectAssign({}, ...args) as IABRFiltersObject)) :
-    observableOf({});
-}