rx-player 4.0.0-beta.0 → 4.0.0-beta.2

package/src/utils/task_canceller.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import log from "../log";
 import assert from "./assert";
 import noop from "./noop";
 
@@ -120,12 +121,12 @@ export default class TaskCanceller {
    * notified that it should be aborted when this `TaskCanceller` is triggered
    * (through its `cancel` method).
    */
-  public signal : CancellationSignal;
+  public readonly signal : CancellationSignal;
   /**
    * `true` if this `TaskCanceller` has already been triggered.
    * `false` otherwise.
    */
-  public isUsed : boolean;
+  private _isUsed : boolean;
   /**
    * @private
    * Internal function called when the `TaskCanceller` is triggered`.
@@ -136,28 +137,43 @@ export default class TaskCanceller {
    * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
    * as its `signal` provide.
    * You can then pass this property to async task you wish to be cancellable.
-   * @param {Object|undefined} options
    */
-  constructor(options? : {
-    /**
-     * If set the TaskCanceller created here will automatically be triggered
-     * when that signal emits.
-     */
-    cancelOn? : CancellationSignal | undefined;
-  } | undefined) {
+  constructor() {
     const [trigger, register] = createCancellationFunctions();
-    this.isUsed = false;
+    this._isUsed = false;
     this._trigger = trigger;
     this.signal = new CancellationSignal(register);
+  }
 
-    if (options?.cancelOn !== undefined) {
-      const unregisterParent = options.cancelOn.register(() => {
-        this.cancel();
-      });
-      this.signal.register(unregisterParent);
-    }
+  /**
+   * Returns `true` if this `TaskCanceller` has already been triggered.
+   * `false` otherwise.
+   */
+  public isUsed() : boolean {
+    return this._isUsed;
   }
 
+  /**
+   * Bind this `TaskCanceller` to a `CancellationSignal`, so the former
+   * is automatically cancelled when the latter is triggered.
+   *
+   * Note that this call registers a callback on the given signal, until either
+   * the current `TaskCanceller` is cancelled or until this given
+   * `CancellationSignal` is triggered.
+   * To avoid leaking memory, the returned callback allow to undo this link.
+   * It should be called if/when that link is not needed anymore, such as when
+   * there is no need for this `TaskCanceller` anymore.
+   *
+   * @param {Object} signal
+   * @returns {Function}
+   */
+  public linkToSignal(signal : CancellationSignal) : () => void {
+    const unregister = signal.register(() => {
+      this.cancel();
+    });
+    this.signal.register(unregister);
+    return unregister;
+  }
 
   /**
    * "Trigger" the `TaskCanceller`, notify through its associated
@@ -171,10 +187,10 @@ export default class TaskCanceller {
    * @param {Error} [srcError]
    */
   public cancel(srcError? : CancellationError) : void {
-    if (this.isUsed) {
+    if (this._isUsed) {
       return ;
     }
-    this.isUsed = true;
+    this._isUsed = true;
     const cancellationError = srcError ?? new CancellationError();
     this._trigger(cancellationError);
   }
@@ -196,11 +212,6 @@ export default class TaskCanceller {
  * @class
  */
 export class CancellationSignal {
-  /**
-   * True when the cancellation order was already triggered, meaning that the
-   * linked task needs to be aborted.
-   */
-  public isCancelled : boolean;
   /**
    * Error associated to the cancellation, only set if the `CancellationSignal`
    * has been used (which means that the task has been cancelled).
@@ -220,6 +231,12 @@ export class CancellationSignal {
    */
   private _listeners : Array<(error : CancellationError) => void>;
 
+  /**
+   * True when the cancellation order was already triggered, meaning that the
+   * linked task needs to be aborted.
+   */
+  private _isCancelled : boolean;
+
   /**
    * Creates a new CancellationSignal.
    * /!\ Note: Only a `TaskCanceller` is supposed to be able to create one.
@@ -227,20 +244,35 @@ export class CancellationSignal {
    * cancelled.
    */
   constructor(registerToSource : (listener: ICancellationListener) => void) {
-    this.isCancelled = false;
+    this._isCancelled = false;
     this.cancellationError = null;
     this._listeners = [];
 
     registerToSource((cancellationError : CancellationError) : void => {
       this.cancellationError = cancellationError;
-      this.isCancelled = true;
+      this._isCancelled = true;
       while (this._listeners.length > 0) {
-        const listener = this._listeners.splice(this._listeners.length - 1, 1)[0];
-        listener(cancellationError);
+        try {
+          const listener = this._listeners.pop();
+          listener?.(cancellationError);
+        } catch (err) {
+          log.error("Error while calling clean up listener",
+                    err instanceof Error ? err.toString() :
+                                           "Unknown error");
+        }
       }
     });
   }
 
+  /**
+   * Returns `true` when the cancellation order was already triggered, meaning
+   * that the linked task needs to be aborted.
+   * @returns boolean
+   */
+  public isCancelled() : boolean {
+    return this._isCancelled;
+  }
+
   /**
    * Registers a function that will be called when/if the current task is
    * cancelled.
@@ -263,9 +295,10 @@ export class CancellationSignal {
    * performed.
    */
   public register(fn : ICancellationListener) : () => void {
-    if (this.isCancelled) {
+    if (this._isCancelled) {
       assert(this.cancellationError !== null);
       fn(this.cancellationError);
+      return noop;
     }
     this._listeners.push(fn);
     return () => this.deregister(fn);
@@ -280,13 +313,9 @@ export class CancellationSignal {
    * @param {Function} fn
    */
   public deregister(fn : ICancellationListener) : void {
-    if (this.isCancelled) {
-      return;
-    }
-    for (let i = 0; i < this._listeners.length; i++) {
+    for (let i = this._listeners.length - 1; i >= 0; i--) {
       if (this._listeners[i] === fn) {
         this._listeners.splice(i, 1);
-        return;
       }
     }
   }

package/tsconfig.json

@@ -13,7 +13,7 @@
     "strictPropertyInitialization": true,
     "noUnusedParameters": true,
     "noUnusedLocals": true,
-    "types": ["rxjs", "node", "jest"],
+    "types": ["node", "jest"],
     "moduleResolution": "node",
     "typeRoots": [
       "./src/typings/next-tick.d.ts",

package/tsconfig.modules.json

@@ -13,7 +13,7 @@
     "strictPropertyInitialization": true,
     "noUnusedParameters": true,
     "noUnusedLocals": true,
-    "types": ["rxjs", "node", "jest"],
+    "types": ["node", "jest"],
     "moduleResolution": "node",
     "module": "es2015",
     "typeRoots": [

package/dist/_esm5.processed/core/init/utils/media_duration_updater.d.ts

@@ -1,56 +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 Manifest from "../../../manifest";
-/**
- * Keep the MediaSource's duration up-to-date with what is being played.
- * @class MediaDurationUpdater
- */
-export default class MediaDurationUpdater {
-    private _canceller;
-    /**
-     * The last known audio Adaptation (i.e. track) chosen for the last Period.
-     * Useful to determinate the duration of the current content.
-     * `undefined` if the audio track for the last Period has never been known yet.
-     * `null` if there are no chosen audio Adaptation.
-     */
-    private _currentKnownDuration;
-    /**
-     * Create a new `MediaDurationUpdater` that will keep the given MediaSource's
-     * duration as soon as possible.
-     * This duration will be updated until the `stop` method is called.
-     * @param {Object} manifest - The Manifest currently played.
-     * For another content, you will have to create another `MediaDurationUpdater`.
-     * @param {MediaSource} mediaSource - The MediaSource on which the content is
-     * pushed.
-     */
-    constructor(manifest: Manifest, mediaSource: MediaSource);
-    /**
-     * By default, the `MediaDurationUpdater` only set a safe estimate for the
-     * MediaSource's duration.
-     * A more precize duration can be set by communicating to it a more precize
-     * media duration through `updateKnownDuration`.
-     * If the duration becomes unknown, `undefined` can be given to it so the
-     * `MediaDurationUpdater` goes back to a safe estimate.
-     * @param {number | undefined} newDuration
-     */
-    updateKnownDuration(newDuration: number | undefined): void;
-    /**
-     * Stop the `MediaDurationUpdater` from updating and free its resources.
-     * Once stopped, it is not possible to start it again, beside creating another
-     * `MediaDurationUpdater`.
-     */
-    stop(): void;
-}

package/locked_reps.js

@@ -1,46 +0,0 @@
-function chooseQualityBasedOnHeight(height) {
-  const videoReps = player.getAvailableVideoRepresentations(period.id);
-
-  const filtered = videoReps
-    .filter(v => v.height === height);
-
-  if (filtered.length > 0) {
-    player.lockVideoRepresentations(filtered);
-  }
-}
-
-function switchVideoToAuto() {
-  player.unlockVideoRepresentations();
-}
-
-player.areVideoRepresentationsLocked();
-
-
-// -> persisté entre Period => oui
-// -> persisté au changement de piste ?
-//   Si oui, necessité de connaitre d'avance les locked pour une autre piste
-//
-// -> que faire si Array vide ? On plante
-// -> que faire si fallback ? => débloque et on envoie un event
-
-
-player.setVideoBitrate();
-player.getVideoBitrate();
-
-player.lockVideoRepresentations({
-  representations: filtered,
-  periodId,
-  switchBehavior: "reload" | "smooth" | "direct",
-});
-
-player.lockVideoRepresentations({
-  representations: filtered,
-  periodId,
-  switchBehavior: "reload" | "smooth" | "direct",
-});
-
-player.setVideoTrack({
-  periodId,
-  trackId,
-  switchBehavior: "reload" | "smooth" | "direct",
-});

package/scripts/doc-generator/construct_table_of_contents.js

@@ -1,76 +0,0 @@
-/**
- * Create table of contents in markdown referencing the h1 (#), h2 (##) and
- * h3 (###) titles.
- * Also add links to them to the original markdown.
- * @param {string} md - The markdown content
- * @returns {string}
- */
-function constructTableOfContents(md) {
-  const tocLines = [];
-  const newContent = [];
-  const lines = md.split(/\r\n|\n|\r/);
-
-  // Object used to avoid duplicates
-  const generatedAnchors = {};
-
-  // The inputed markdown is read line by line.
-  // When a h1, h2 or h3 is encountered in it, add a new list entry
-  // in the `tocLines` markdown respectively at top, second and third level.
-  // To be able to link the table of content to the corresponding content,
-  // add `<a>` links just before the corresponding h1, h2 or h3 elements in the
-  // inputed markdown.
-  // All Markdown parsing done here corresponds to the CommonMark spec (v0.29)
-  // TODO this might be more efficient and less error-prone if integrated 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]) {
-        const tocLine = regExec[1].replace(/ #* *$/, "").trim();
-        let uri = generateAnchorName(tocLine);
-        tocLines.push(`[${tocLine}](#${uri})`);
-        newContent.push(`<a name="${uri}"></a>`);
-      }
-    } else if (/^ *## +/.test(lines[i])) {
-      const regExec = /^ *## +(.*)$/.exec(lines[i]);
-      if (regExec && regExec[1]) {
-        const tocLine = regExec[1].replace(/ #* *$/, "").trim();
-        let uri = generateAnchorName(tocLine);
-        tocLines.push(`  - [${tocLine}](#${uri})`);
-        newContent.push(`<a name="${uri}"></a>`);
-      }
-    } else if (/^ *### +/.test(lines[i])) {
-      const regExec = /^ *### +(.*)$/.exec(lines[i]);
-      if (regExec && regExec[1]) {
-        const tocLine = regExec[1].replace(/ #* *$/, "").trim();
-        let uri = generateAnchorName(tocLine);
-        tocLines.push(`    - [${tocLine}](#${uri})`);
-        newContent.push(`<a name="${uri}"></a>`);
-      }
-    }
-    newContent.push(lines[i]);
-  }
-  return {
-    tocMd: tocLines.join("\n"),
-    nbTocElements: tocLines.length,
-    content: newContent.join("\n"),
-  };
-
-  function generateAnchorName(title) {
-    const baseUri = encodeURI(title.toLowerCase().replace(/ /g, "_"))
-    if (generatedAnchors[baseUri] !== true) {
-      generatedAnchors[baseUri] = true;
-      return baseUri;
-    }
-    let i = 1;
-    let resultUri;
-    do {
-      resultUri = `${baseUri}_(${i})`;
-      i++;
-    } while (generatedAnchors[resultUri] === true);
-    generatedAnchors[resultUri] = true;
-    return resultUri;
-  }
-};
-
-module.exports = constructTableOfContents;

package/scripts/doc-generator/convert_MD_to_HMTL.js

@@ -1,26 +0,0 @@
-const hljs = require("highlight.js");
-const md = require("markdown-it")({
-  highlight(str, lang) {
-    if (lang && hljs.getLanguage(lang)) {
-      try {
-        return hljs.highlight(str, { language: lang }).value;
-      } catch (_) {
-        /* don't care for now */
-      }
-    }
-    return "";
-  },
-  html: true,
-  linkify: true,
-  typographer: true,
-  xhtmlOut: true,
-});
-
-/**
- * Convert the Markdown document given into an HTML page.
- * @param {string} mdStr
- * @returns {string}
- */
-module.exports = function convertMDToHTML(mdStr) {
-  return md.render(mdStr);
-};