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

package/src/transports/dash/low_latency_segment_loader.ts

@@ -65,14 +65,14 @@ export default function lowLatencySegmentLoader(
     partialChunk = res[1];
     for (let i = 0; i < completeChunks.length; i++) {
       callbacks.onNewChunk(completeChunks[i]);
-      if (cancelSignal.isCancelled) {
+      if (cancelSignal.isCancelled()) {
         return;
       }
     }
     callbacks.onProgress({ duration: info.duration,
                            size: info.size,
                            totalSize: info.totalSize });
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
       return;
     }
   }

package/src/transports/dash/manifest_parser.ts

@@ -136,7 +136,7 @@ export default function generateManifestParser(
         if (parserResponse.value.warnings.length > 0) {
           onWarnings(parserResponse.value.warnings);
         }
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return Promise.reject(cancelSignal.cancellationError);
         }
         const manifest = new Manifest(parserResponse.value.parsed, options);

package/src/transports/dash/segment_loader.ts

@@ -150,7 +150,7 @@ export default function generateSegmentLoader(
                   size? : number | undefined;
                   duration? : number | undefined; }
       ) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -166,7 +166,7 @@ export default function generateSegmentLoader(
        * @param {*} err - The corresponding error encountered
        */
       const reject = (err : unknown) : void => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -190,7 +190,7 @@ export default function generateSegmentLoader(
                   size : number;
                   totalSize? : number | undefined; }
       ) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         callbacks.onProgress({ duration: _args.duration,
@@ -203,7 +203,7 @@ export default function generateSegmentLoader(
        * the "regular" implementation
        */
       const fallback = () => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;

package/src/transports/local/segment_loader.ts

@@ -20,11 +20,9 @@ import {
   ILocalManifestInitSegmentLoader,
   ILocalManifestSegmentLoader,
 } from "../../parsers/manifest/local";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import {
-  CancellationError,
-  CancellationSignal,
-} from "../../utils/task_canceller";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
   ISegmentContext,
   ISegmentLoaderCallbacks,
@@ -41,7 +39,7 @@ function loadInitSegment(
   customSegmentLoader : ILocalManifestInitSegmentLoader,
   cancelSignal : CancellationSignal
 ) : Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {
-  return new Promise((res, rej) => {
+  return createCancellablePromise(cancelSignal, (res, rej) => {
     /** `true` when the custom segmentLoader should not be active anymore. */
     let hasFinished = false;
 
@@ -54,11 +52,10 @@ function loadInitSegment(
       size? : number;
       duration? : number;
     }) => {
-      if (hasFinished || cancelSignal.isCancelled) {
+      if (hasFinished || cancelSignal.isCancelled()) {
         return;
       }
       hasFinished = true;
-      cancelSignal.deregister(abortLoader);
       res({ resultType: "segment-loaded",
             resultData: { responseData: _args.data,
                           size: _args.size,
@@ -70,22 +67,17 @@ function loadInitSegment(
      * @param {*} err - The corresponding error encountered
      */
     const reject = (err? : Error) => {
-      if (hasFinished || cancelSignal.isCancelled) {
+      if (hasFinished || cancelSignal.isCancelled()) {
         return;
       }
       hasFinished = true;
-      cancelSignal.deregister(abortLoader);
       rej(err);
     };
 
     const abort = customSegmentLoader({ resolve, reject });
 
-    cancelSignal.register(abortLoader);
-    /**
-     * The logic to run when this loader is cancelled while pending.
-     * @param {Error} err
-     */
-    function abortLoader(err : CancellationError) {
+    /** The logic to run when this loader is cancelled while pending. */
+    return () => {
       if (hasFinished) {
         return;
       }
@@ -93,8 +85,7 @@ function loadInitSegment(
       if (typeof abort === "function") {
         abort();
       }
-      rej(err);
-    }
+    };
   });
 }
 
@@ -109,7 +100,7 @@ function loadSegment(
   customSegmentLoader : ILocalManifestSegmentLoader,
   cancelSignal : CancellationSignal
 ) : Promise< ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {
-  return new Promise((res, rej) => {
+  return createCancellablePromise(cancelSignal, (res, rej) => {
     /** `true` when the custom segmentLoader should not be active anymore. */
     let hasFinished = false;
 
@@ -122,11 +113,10 @@ function loadSegment(
       size? : number;
       duration? : number;
     }) => {
-      if (hasFinished || cancelSignal.isCancelled) {
+      if (hasFinished || cancelSignal.isCancelled()) {
         return;
       }
       hasFinished = true;
-      cancelSignal.deregister(abortLoader);
       res({ resultType: "segment-loaded",
             resultData: { responseData: _args.data,
                           size: _args.size,
@@ -138,11 +128,10 @@ function loadSegment(
      * @param {*} err - The corresponding error encountered
      */
     const reject = (err? : Error) => {
-      if (hasFinished || cancelSignal.isCancelled) {
+      if (hasFinished || cancelSignal.isCancelled()) {
         return;
       }
       hasFinished = true;
-      cancelSignal.deregister(abortLoader);
 
       // Format error and send it
       const castedErr = err as (null | undefined | { message? : string;
@@ -159,12 +148,8 @@ function loadSegment(
 
     const abort = customSegmentLoader(segment, { resolve, reject });
 
-    cancelSignal.register(abortLoader);
-    /**
-     * The logic to run when this loader is cancelled while pending.
-     * @param {Error} err
-     */
-    function abortLoader(err : CancellationError) {
+    /** The logic to run when this loader is cancelled while pending. */
+    return () => {
       if (hasFinished) {
         return;
       }
@@ -172,8 +157,7 @@ function loadSegment(
       if (typeof abort === "function") {
         abort();
       }
-      rej(err);
-    }
+    };
   });
 }
 

package/src/transports/smooth/isobmff/create_boxes.ts

@@ -33,7 +33,7 @@ import {
  * @param {Number} height
  * @param {Number} hRes - horizontal resolution, eg 72
  * @param {Number} vRes - vertical resolution, eg 72
- * @param {string} encDepth
+ * @param {string} encName
  * @param {Number} colorDepth - eg 24
  * @param {Uint8Array} avcc - Uint8Array representing the avcC atom
  * @returns {Uint8Array}
@@ -68,7 +68,7 @@ function createAVC1Box(
  * @param {Number} height
  * @param {Number} hRes - horizontal resolution, eg 72
  * @param {Number} vRes - vertical resolution, eg 72
- * @param {string} encDepth
+ * @param {string} encName
  * @param {Number} colorDepth - eg 24
  * @param {Uint8Array} avcc - Uint8Array representing the avcC atom
  * @param {Uint8Array} sinf - Uint8Array representing the sinf atom
@@ -108,8 +108,6 @@ function createENCVBox(
  * @param {Number} packetSize
  * @param {Number} sampleRate
  * @param {Uint8Array} esds - Uint8Array representing the esds atom
- * @param {Uint8Array} [sinf] - Uint8Array representing the sinf atom,
- * only if name == "enca"
  * @returns {Uint8Array}
  */
 function createMP4ABox(
@@ -164,7 +162,7 @@ function createENCABox(
 }
 
 /**
- * @param {url} Uint8Array
+ * @param {Uint8Array} url
  * @returns {Uint8Array}
  */
 function createDREFBox(url : Uint8Array) : Uint8Array {
@@ -415,7 +413,7 @@ function createSMHDBox() : Uint8Array {
 }
 
 /**
- * @param {Array.<Uint8Array>} representations - arrays of Uint8Array,
+ * @param {Array.<Uint8Array>} reps - arrays of Uint8Array,
  * typically [avc1] or [encv, avc1]
  * @returns {Uint8Array}
  */

package/src/transports/smooth/segment_loader.ts

@@ -177,7 +177,7 @@ const generateSegmentLoader = ({
         size? : number | undefined;
         duration? : number | undefined;
       }) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -205,7 +205,7 @@ const generateSegmentLoader = ({
        * @param {*} err - The corresponding error encountered
        */
       const reject = (err : unknown) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -229,7 +229,7 @@ const generateSegmentLoader = ({
                   size : number;
                   totalSize? : number | undefined; }
       ) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         callbacks.onProgress({ duration: _args.duration,
@@ -238,7 +238,7 @@ const generateSegmentLoader = ({
       };
 
       const fallback = () => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;

package/src/transports/utils/call_custom_manifest_loader.ts

@@ -62,7 +62,7 @@ export default function callCustomManifestLoader(
                                  receivingTime? : number | undefined;
                                  sendingTime? : number | undefined; }) =>
       {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -87,7 +87,7 @@ export default function callCustomManifestLoader(
        * @param {*} err - The corresponding error encountered
        */
       const reject = (err : unknown) : void => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -111,7 +111,7 @@ export default function callCustomManifestLoader(
        * the "regular" implementation
        */
       const fallback = () => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;

package/src/typings/globals.d.ts

@@ -20,23 +20,24 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 
 declare const __FEATURES__ : {
-  IS_ENABLED : number;
-  IS_DISABLED : number;
+  IS_DISABLED : 0;
+  IS_ENABLED : 1;
 
-  DASH : number;
-  DIRECTFILE : number;
-  EME : number;
-  HTML_SAMI : number;
-  HTML_SRT : number;
-  HTML_TTML : number;
-  HTML_VTT : number;
-  LOCAL_MANIFEST : number;
-  METAPLAYLIST : number;
-  NATIVE_SAMI : number;
-  NATIVE_SRT : number;
-  NATIVE_TTML : number;
-  NATIVE_VTT : number;
-  SMOOTH : number;
+  DASH : 0 | 1;
+  DIRECTFILE : 0 | 1;
+  EME : 0 | 1;
+  HTML_SAMI : 0 | 1;
+  HTML_SRT : 0 | 1;
+  HTML_TTML : 0 | 1;
+  HTML_VTT : 0 | 1;
+  LOCAL_MANIFEST : 0 | 1;
+  METAPLAYLIST : 0 | 1;
+  DEBUG_ELEMENT : 0 | 1;
+  NATIVE_SAMI : 0 | 1;
+  NATIVE_SRT : 0 | 1;
+  NATIVE_TTML : 0 | 1;
+  NATIVE_VTT : 0 | 1;
+  SMOOTH : 0 | 1;
 } | typeof FEATURES_ENUM;
 
 declare const enum FEATURES_ENUM {
@@ -52,6 +53,7 @@ declare const enum FEATURES_ENUM {
   HTML_VTT,
   LOCAL_MANIFEST,
   METAPLAYLIST,
+  DEBUG_ELEMENT,
   NATIVE_SAMI,
   NATIVE_SRT,
   NATIVE_TTML,
@@ -60,9 +62,9 @@ declare const enum FEATURES_ENUM {
 }
 
 declare const __ENVIRONMENT__ : {
-  CURRENT_ENV : number;
-  DEV : number;
-  PRODUCTION : number;
+  CURRENT_ENV : 0 | 1;
+  DEV : 0;
+  PRODUCTION : 1;
 } | typeof ENVIRONMENT_ENUM;
 
 declare const enum ENVIRONMENT_ENUM {

package/src/utils/cancellable_sleep.ts

@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 
-import {
-  CancellationError,
-  CancellationSignal,
-} from "./task_canceller";
+import createCancellablePromise from "./create_cancellable_promise";
+import { CancellationSignal } from "./task_canceller";
 
 /**
  * Wait the given `delay`, resolving the Promise when finished.
@@ -36,15 +34,8 @@ export default function cancellableSleep(
   delay: number,
   cancellationSignal: CancellationSignal
 ) : Promise<void> {
-  return new Promise((res, rej) => {
-    const timeout = setTimeout(() => {
-      unregisterCancelSignal();
-      res();
-    }, delay);
-    const unregisterCancelSignal = cancellationSignal
-      .register(function onCancel(cancellationError : CancellationError) {
-        clearTimeout(timeout);
-        rej(cancellationError);
-      });
+  return createCancellablePromise(cancellationSignal, (res) => {
+    const timeout = setTimeout(() => res(), delay);
+    return () => clearTimeout(timeout);
   });
 }

package/src/utils/create_cancellable_promise.ts

@@ -0,0 +1,69 @@
+import {
+  CancellationError,
+  CancellationSignal,
+} from "./task_canceller";
+
+/**
+ * Returns a Promise linked to a `CancellationSignal`, which will reject the
+ * corresponding `CancellationError` if that signal emits before the wanted
+ * task finishes (either on success or on error).
+ *
+ * The given callback mimicks the Promise interface with the added possibility
+ * of returning a callback which will be called when and if the task is
+ * cancelled before being either resolved or rejected.
+ * In that case, that logic will be called just before the Promise is rejected
+ * with the corresponding `CancellationError`.
+ * The point of this callback is to implement aborting logic, such as for
+ * example aborting a request.
+ *
+ * @param {Object} cancellationSignal - The `CancellationSignal` the returned
+ * Promise will be linked to.
+ * @param {Function} cb - The function implementing the cancellable Promise. Its
+ * arguments follow Promise's semantics but it can also return a function which
+ * will be called when and if `cancellationSignal` emits before either arguments
+ * are called.
+ * @returns {Promise} - The created Promise, which will resolve when and if the
+ * first argument to `cb` is called first and reject either if the second
+ * argument to `cb` is called first or if the given `CancellationSignal` emits
+ * before either of the two previous conditions.
+ */
+export default function createCancellablePromise<T>(
+  cancellationSignal : CancellationSignal,
+  cb : (
+    resolve : (val : T) => void,
+    reject : (err : unknown) => void,
+  ) => (() => void) | void
+) : Promise<T> {
+  let abortingLogic : (() => void) | void;
+  return new Promise((res, rej) => {
+    if (cancellationSignal.cancellationError !== null) {
+      // If the signal was already triggered before, do not even call `cb`
+      return rej(cancellationSignal.cancellationError);
+    }
+
+    let hasUnregistered = false;
+    abortingLogic = cb(
+      function onCancellablePromiseSuccess(val : T) {
+        cancellationSignal.deregister(onCancellablePromiseCancellation);
+        hasUnregistered = true;
+        res(val);
+      },
+      function onCancellablePromiseFailure(err : unknown) {
+        cancellationSignal.deregister(onCancellablePromiseCancellation);
+        hasUnregistered = true;
+        rej(err);
+      }
+    );
+
+    if (!hasUnregistered) {
+      cancellationSignal.register(onCancellablePromiseCancellation);
+    }
+
+    function onCancellablePromiseCancellation(error : CancellationError) {
+      if (abortingLogic !== undefined) {
+        abortingLogic();
+      }
+      rej(error);
+    }
+  });
+}

package/src/utils/is_null_or_undefined.ts

@@ -20,7 +20,7 @@
  * not always understood by newcomers to the code, and which can be overused when
  * only one of the possibility can arise.
  * @param {*} x
- * @returns {*}
+ * @returns {boolean}
  */
 export default function isNullOrUndefined(x : unknown) : x is null | undefined | void {
   return x === null || x === undefined;

package/src/utils/reference.ts

@@ -294,6 +294,9 @@ export default function createSharedReference<T>(
       options.clearSignal.register(unlisten);
 
       function unlisten() : void {
+        if (options?.clearSignal !== undefined) {
+          options.clearSignal.deregister(unlisten);
+        }
         if (cbObj.hasBeenCleared) {
           return;
         }
@@ -339,6 +342,9 @@ export default function createSharedReference<T>(
     finish,
   };
   function finish() {
+    if (cancelSignal !== undefined) {
+      cancelSignal.deregister(finish);
+    }
     isFinished = true;
     const clonedCbs = cbs.slice();
     for (const cbObj of clonedCbs) {

package/src/utils/request/xhr.ts

@@ -125,7 +125,7 @@ export default function request<T>(
           reject(err);
         });
 
-      if (cancelSignal.isCancelled) {
+      if (cancelSignal.isCancelled()) {
         return;
       }
     }