rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/typings/globals.d.ts

@@ -14,49 +14,66 @@
  * limitations under the License.
  */
 
-// Webpack-defined globals
+// Compile-time globals
 // Should be all replaced once the lib built.
 
 /* eslint-disable @typescript-eslint/naming-convention */
 
-declare const __DEV__: boolean;
-declare const __LOGGER_LEVEL__: string;
 declare const __FEATURES__ : {
-  BIF_PARSER : boolean;
-  DASH : boolean;
-  DIRECTFILE : boolean;
-  EME : boolean;
-  HTML_SAMI : boolean;
-  HTML_SRT : boolean;
-  HTML_TTML : boolean;
-  HTML_VTT : boolean;
-  LOCAL_MANIFEST : boolean;
-  METAPLAYLIST : boolean;
-  NATIVE_SAMI : boolean;
-  NATIVE_SRT : boolean;
-  NATIVE_TTML : boolean;
-  NATIVE_VTT : boolean;
-  SMOOTH : boolean;
-};
-declare const __RELATIVE_PATH__ : {
-  BIF_PARSER: string;
-  DASH: string;
-  DASH_JS_PARSER: string;
-  DIRECTFILE: string;
-  EME_MANAGER: string;
-  HTML_SAMI: string;
-  HTML_SRT: string;
-  HTML_TEXT_BUFFER: string;
-  HTML_TTML: string;
-  HTML_VTT: string;
-  IMAGE_BUFFER: string;
-  LOCAL_MANIFEST : string;
-  MEDIA_ELEMENT_TRACK_CHOICE_MANAGER: string;
-  METAPLAYLIST: string;
-  NATIVE_SAMI: string;
-  NATIVE_SRT: string;
-  NATIVE_TEXT_BUFFER: string;
-  NATIVE_TTML: string;
-  NATIVE_VTT: string;
-  SMOOTH: string;
+  IS_ENABLED : number;
+  IS_DISABLED : number;
+
+  BIF_PARSER : number;
+  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;
+} | typeof FEATURES_ENUM;
+
+declare const enum FEATURES_ENUM {
+  IS_DISABLED,
+  IS_ENABLED,
+
+  BIF_PARSER,
+  DASH,
+  DIRECTFILE,
+  EME,
+  HTML_SAMI,
+  HTML_SRT,
+  HTML_TTML,
+  HTML_VTT,
+  LOCAL_MANIFEST,
+  METAPLAYLIST,
+  NATIVE_SAMI,
+  NATIVE_SRT,
+  NATIVE_TTML,
+  NATIVE_VTT,
+  SMOOTH,
+}
+
+declare const __ENVIRONMENT__ : {
+  CURRENT_ENV : number;
+  DEV : number;
+  PRODUCTION : number;
+} | typeof ENVIRONMENT_ENUM;
+
+declare const enum ENVIRONMENT_ENUM {
+  CURRENT_ENV,
+  DEV,
+  PRODUCTION,
+}
+
+declare const __LOGGER_LEVEL__ : {
+  CURRENT_LEVEL : string;
 };
+

package/src/utils/__tests__/array_find.test.ts

@@ -23,16 +23,16 @@
 import arrayFind from "../array_find";
 
 /* eslint-disable @typescript-eslint/unbound-method */
-const initialArrayFind = (Array.prototype as any).find;
+const initialArrayFind = (Array.prototype as { find : unknown }).find;
 /* eslint-enable @typescript-eslint/unbound-method */
 
 describe("utils - arrayFind", () => {
   beforeEach(() => {
-    (Array.prototype as any).find = undefined;
+    (Array.prototype as { find : unknown }).find = undefined;
   });
 
   afterEach(() => {
-    (Array.prototype as any).find = initialArrayFind;
+    (Array.prototype as { find : unknown }).find = initialArrayFind;
   });
 
   it("should return undefined for an empty array", () => {
@@ -83,12 +83,12 @@ describe("utils - arrayFind", () => {
 
   if (typeof initialArrayFind === "function") {
     it("should call the original array.find function if it exists", () => {
-      (Array.prototype as any).find = initialArrayFind;
+      (Array.prototype as { find : unknown }).find = initialArrayFind;
       const obj1 = {};
       const obj2 = {};
       const context = {};
       const arr = [obj2, obj1, obj2, obj1];
-      const spy = jest.spyOn(arr as any, "find");
+      const spy = jest.spyOn(arr as unknown as { find : () => unknown }, "find");
 
       let currentIndex = 0;
       const predicate = function(

package/src/utils/__tests__/array_find_index.test.ts

@@ -23,16 +23,16 @@
 import arrayFindIndex from "../array_find_index";
 
 /* eslint-disable @typescript-eslint/unbound-method */
-const initialArrayFindIndex = (Array.prototype as any).findIndex;
+const initialArrayFindIndex = (Array.prototype as { findIndex : unknown }).findIndex;
 /* eslint-enable @typescript-eslint/unbound-method */
 
 describe("utils - arrayFindIndex", () => {
   beforeEach(() => {
-    (Array.prototype as any).findIndex = undefined;
+    (Array.prototype as { findIndex : unknown }).findIndex = undefined;
   });
 
   afterEach(() => {
-    (Array.prototype as any).findIndex = initialArrayFindIndex;
+    (Array.prototype as { findIndex : unknown }).findIndex = initialArrayFindIndex;
   });
 
   it("should return -1 for an empty array", () => {
@@ -83,12 +83,13 @@ describe("utils - arrayFindIndex", () => {
 
   if (typeof initialArrayFindIndex === "function") {
     it("should call the original array.findIndex function if it exists", () => {
-      (Array.prototype as any).findIndex = initialArrayFindIndex;
+      (Array.prototype as { findIndex : unknown }).findIndex = initialArrayFindIndex;
       const obj1 = {};
       const obj2 = {};
       const context = {};
       const arr = [obj2, obj1, obj2, obj1];
-      const spy = jest.spyOn(arr as any, "findIndex");
+      const spy = jest
+        .spyOn(arr as unknown as { findIndex : () => unknown }, "findIndex");
 
       let currentIndex = 0;
       const predicate = function(

package/src/utils/__tests__/array_includes.test.ts

@@ -24,6 +24,7 @@ const initialArrayIncludes = Array.prototype.includes;
 /* eslint-enable @typescript-eslint/unbound-method */
 describe("utils - array-includes", () => {
   beforeEach(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (Array.prototype as any).includes = undefined;
   });
 

package/src/utils/__tests__/assert.test.ts

@@ -28,13 +28,13 @@ describe("utils - assert", () => {
       assert(false);
     } catch (e) {
       error = e;
-      /* eslint-disable @typescript-eslint/no-unused-expressions */
-      expect(e).toBeDefined();
-      /* eslint-enable @typescript-eslint/no-unused-expressions */
     }
-    /* eslint-disable @typescript-eslint/no-unused-expressions */
-    expect(error).toBeDefined();
-    /* eslint-enable @typescript-eslint/no-unused-expressions */
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(error.message).toBe("invalid assertion");
     expect(error.name).toBe("AssertionError");
   });
@@ -46,13 +46,13 @@ describe("utils - assert", () => {
       assert(false, myMessage);
     } catch (e) {
       error = e;
-      /* eslint-disable @typescript-eslint/no-unused-expressions */
-      expect(e).toBeDefined();
-      /* eslint-enable @typescript-eslint/no-unused-expressions */
     }
-    /* eslint-disable @typescript-eslint/no-unused-expressions */
-    expect(error).toBeDefined();
-    /* eslint-enable @typescript-eslint/no-unused-expressions */
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(error.message).toBe(myMessage);
     expect(error.name).toBe("AssertionError");
   });
@@ -78,9 +78,12 @@ describe("utils - assertInterface", () => {
     } catch (e) {
       error = e;
     }
-    /* eslint-disable @typescript-eslint/no-unused-expressions */
-    expect(error).toBeDefined();
-    /* eslint-enable @typescript-eslint/no-unused-expressions */
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(error.message).toBe(`${nameOfMyObj} should be an object`);
     expect(error.name).toBe("AssertionError");
 
@@ -91,9 +94,12 @@ describe("utils - assertInterface", () => {
     } catch (e) {
       error = e;
     }
-    /* eslint-disable @typescript-eslint/no-unused-expressions */
-    expect(error).toBeDefined();
-    /* eslint-enable @typescript-eslint/no-unused-expressions */
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(error.message).toBe(`${nameOfMyObj} should be an object`);
     expect(error.name).toBe("AssertionError");
   });
@@ -128,6 +134,13 @@ describe("utils - assertInterface", () => {
     /* eslint-disable @typescript-eslint/no-unused-expressions */
     expect(error).toBeDefined();
     /* eslint-enable @typescript-eslint/no-unused-expressions */
+
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(error.message)
       .toBe(`${nameOfMyObj} should have property f as a function`);
     expect(error.name).toBe("AssertionError");
@@ -159,9 +172,12 @@ describe("utils - assertInterface", () => {
     } catch (e) {
       error = e;
     }
-    /* eslint-disable @typescript-eslint/no-unused-expressions */
-    expect(error).toBeDefined();
-    /* eslint-enable @typescript-eslint/no-unused-expressions */
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(error.message)
       .toBe("object should have property f as a function");
     expect(error.name).toBe("AssertionError");
@@ -206,6 +222,7 @@ describe("utils - assertInterface", () => {
       e: true,
     };
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (Object.prototype as any).f = "number";
 
     const objIface = {

package/src/utils/__tests__/assert_unreachable.test.ts

@@ -24,15 +24,16 @@ describe("utils - assert", () => {
     let error;
     try {
       assertUnreachable(4 as never);
-    } catch (e) {
+    } catch (e : unknown) {
       error = e;
-      /* eslint-disable @typescript-eslint/no-unused-expressions */
-      expect(e).toBeDefined();
-      /* eslint-enable @typescript-eslint/no-unused-expressions */
     }
-    /* eslint-disable @typescript-eslint/no-unused-expressions */
-    expect(error).toBeDefined();
-    /* eslint-enable @typescript-eslint/no-unused-expressions */
+
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
     expect(error.message).toBe("Unreachable path taken");
     expect(error.name).toBe("AssertionError");
   });

package/src/utils/__tests__/concat_map_latest.test.ts

@@ -16,19 +16,17 @@
 
 import {
   concat as observableConcat,
+  concatMap,
   interval,
+  map,
   merge as observableMerge,
   Observable,
-  of as observableOf,
   Subject,
-  timer,
-} from "rxjs";
-import {
-  concatMap,
-  mapTo,
+  of as observableOf,
   take,
   tap,
-} from "rxjs/operators";
+  timer,
+} from "rxjs";
 import concatMapLatest from "../concat_map_latest";
 
 describe("utils - concatMapLatest", () => {
@@ -85,7 +83,7 @@ describe("utils - concatMapLatest", () => {
     let lastCount: number|undefined;
 
     const counter$ : Observable<number> = observableOf(...innerValues).pipe(
-      concatMap((v) => timer(5).pipe(mapTo(v)))
+      concatMap((v) => timer(5).pipe(map(() => v)))
     );
     counter$.pipe(
       concatMapLatest((i: number, count: number) => {
@@ -120,7 +118,7 @@ describe("utils - concatMapLatest", () => {
       tap(() => { itemEmittedCounter++; }),
       concatMapLatest((i: number, count: number) => {
         lastCount = count;
-        return timer(230).pipe(mapTo(i));
+        return timer(230).pipe(map(() => i));
       })
     ).subscribe({
       next(result: number) {

package/src/utils/__tests__/defer_subscriptions.test.ts

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-import { timer } from "rxjs";
 import {
-  mapTo,
+  map,
   share,
   startWith,
-} from "rxjs/operators";
+  timer,
+} from "rxjs";
 import deferSubscriptions from "../defer_subscriptions";
 
 describe("utils - deferSubscriptions", () => {
@@ -27,7 +27,7 @@ describe("utils - deferSubscriptions", () => {
   it("should wait until all subscription in the current script are done before emitting", (done) => {
   /* eslint-enable max-len */
     let logs = "";
-    const myObservableDeferred = timer(5).pipe(mapTo("A"),
+    const myObservableDeferred = timer(5).pipe(map(() => "A"),
                                                startWith("S"),
                                                deferSubscriptions(),
                                                share());

package/src/utils/__tests__/event_emitter.test.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { take } from "rxjs/operators";
+import { take } from "rxjs";
 import log from "../../log";
 import EventEmitter, {
   fromEvent,

package/src/utils/__tests__/flat_map.test.ts

@@ -19,20 +19,30 @@
 
 import flatMap from "../flat_map";
 
+interface IProtoWithFlatMap {
+  flatMap? : (<U, This = undefined>(
+    callback: (this: This, value: unknown, index: number, array: unknown[]) => U | U[],
+    thisArg?: This | undefined
+  ) => U[]) | undefined;
+}
+
+
+const proto = Array.prototype as unknown as IProtoWithFlatMap;
+
 /* eslint-disable @typescript-eslint/unbound-method */
-const initialFlatMap = (Array.prototype as any).flatMap;
+const initialFlatMap = proto.flatMap;
 /* eslint-enable @typescript-eslint/unbound-method */
 
 describe("utils - starts-with", () => {
   beforeEach(() => {
-    (Array.prototype as any).flatMap = undefined;
+    delete proto.flatMap;
   });
 
   afterEach(() => {
-    (Array.prototype as any).flatMap = initialFlatMap;
+    (proto).flatMap = initialFlatMap;
   });
 
-  it("should mirror Array.prototype.flatMap behavior", () => {
+  it("should mirror prototype.flatMap behavior", () => {
     expect(flatMap([1, 2, 3], x => [x, x + 1, x - 1]))
       .toEqual([ 1, 2, 0, 2, 3, 1, 3, 4, 2 ]);
     expect(flatMap([1, 2, 3], x => `${x}a`))
@@ -41,8 +51,10 @@ describe("utils - starts-with", () => {
 
   if (typeof initialFlatMap === "function") {
     it("should call the original flatMap function if available", () => {
-      (Array.prototype as any).flatMap = initialFlatMap;
-      const flatMapSpy = jest.spyOn((Array.prototype as any), "flatMap");
+      proto.flatMap = initialFlatMap;
+      // TODO find what bother typescript here instead of adding "as any"
+      /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+      const flatMapSpy = jest.spyOn(proto as any, "flatMap");
       const func1 = (x : number) : number[] => [x, x + 1, x - 1];
       const func2 = (x : number) : string => String(x) + "a";
       expect(flatMap([1, 2, 3], func1))

package/src/utils/__tests__/id_generator.test.ts

@@ -23,7 +23,7 @@ const oldNumberDef = window.Number;
 describe("utils - idGenerator", () => {
   afterEach(() => {
     // There's an ugly test in here that changes the Number object
-    (window as any).Number = oldNumberDef;
+    window.Number = oldNumberDef;
   });
 
   it("should increment an ID", () => {
@@ -54,8 +54,8 @@ describe("utils - idGenerator", () => {
   });
   it ("should preprend a 0 after A LOT of ID generation", () => {
     // Ugly but I don't care
-    (window as any).Number = { MAX_SAFE_INTEGER: 3,
-                               isSafeInteger: (x : number) => x <= 3 };
+    window.Number = { MAX_SAFE_INTEGER: 3,
+                      isSafeInteger: (x : number) => x <= 3 } as typeof window.Number;
     const generateNewID1 = idGenerator();
     const generateNewID2 = idGenerator();
     const generateNewID3 = idGenerator();

package/src/utils/__tests__/initialization_segment_cache.test.ts

@@ -45,6 +45,7 @@ const initSegment1 = {
   duration: 0,
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URLinit1"],
+  complete: true,
 };
 
 const initSegment2 = {
@@ -55,6 +56,7 @@ const initSegment2 = {
   duration: 0,
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URLinit2"],
+  complete: true,
 };
 
 const initSegment3 = {
@@ -65,6 +67,7 @@ const initSegment3 = {
   duration: 0,
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URLinit3"],
+  complete: true,
 };
 
 const segment1 = {
@@ -75,6 +78,7 @@ const segment1 = {
   end: 2,
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URL2"],
+  complete: true,
 };
 
 const segment2 = {
@@ -85,6 +89,7 @@ const segment2 = {
   end: 4,
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URL2"],
+  complete: true,
 };
 
 const segment3 = {
@@ -95,6 +100,7 @@ const segment3 = {
   end: 6,
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URL3"],
+  complete: true,
 };
 
 const segment4 = {
@@ -105,6 +111,7 @@ const segment4 = {
   end: 8,
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URL4"],
+  complete: true,
 };
 
 const data1 = new Uint8Array([0]);

package/src/utils/__tests__/promise.test.ts

@@ -18,6 +18,6 @@ import promise from "../promise";
 
 describe("utils - promise", () => {
   it("should export the browser's Promise as a default", () => {
-    expect(promise).toBe(Promise as any);
+    expect(promise).toBe(Promise);
   });
 });

package/src/utils/__tests__/starts_with.test.ts

@@ -24,8 +24,10 @@ const initialStartsWith = String.prototype.startsWith;
 
 describe("utils - starts-with", () => {
   beforeEach(() => {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     (String.prototype as any).startsWith = undefined;
+    /* eslint-enable @typescript-eslint/no-explicit-any */
   });
 
   afterEach(() => {

package/src/utils/array_find.ts

@@ -20,6 +20,14 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable no-restricted-properties */
 
+// Ugly transitory type to make duck typing work
+type ArrayWithFind<T> = T[] & {
+  find(predicate: (value: T,
+                   index: number,
+                   obj: T[]) => unknown,
+       thisArg?: unknown): T;
+};
+
 /**
  * Array.prototype.find ponyfill.
  * @param {Array} arr
@@ -30,10 +38,10 @@
 export default function arrayFind<T>(
   arr : T[],
   predicate : (arg: T, index : number, fullArray : T[]) => boolean,
-  thisArg? : any
+  thisArg? : unknown
 ) : T | undefined {
-  if (typeof (Array.prototype as any).find === "function") {
-    return (arr as any).find(predicate, thisArg);
+  if (typeof (Array.prototype as ArrayWithFind<T>).find === "function") {
+    return (arr as ArrayWithFind<T>).find(predicate, thisArg);
   }
 
   const len = arr.length >>> 0;

package/src/utils/array_find_index.ts

@@ -20,6 +20,14 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable no-restricted-properties */
 
+// Ugly transitory type to make duck typing work
+type ArrayWithFindIndex<T> = T[] & {
+  findIndex(predicate: (value: T,
+                        index: number,
+                        obj: T[]) => unknown,
+            thisArg?: unknown): number;
+};
+
 /**
  * Array.prototype.find ponyfill.
  * @param {Array} arr
@@ -30,10 +38,10 @@
 export default function arrayFindIndex<T>(
   arr : T[],
   predicate : (arg: T, index : number, fullArray : T[]) => boolean,
-  thisArg? : any
+  thisArg? : unknown
 ) : number {
-  if (typeof (Array.prototype as any).findIndex === "function") {
-    return (arr as any).findIndex(predicate, thisArg);
+  if (typeof (Array.prototype as ArrayWithFindIndex<T>).findIndex === "function") {
+    return (arr as ArrayWithFindIndex<T>).findIndex(predicate, thisArg);
   }
 
   const len = arr.length >>> 0;

package/src/utils/assert.ts

@@ -23,8 +23,11 @@ import isNullOrUndefined from "./is_null_or_undefined";
  * @param {string} [message] - Optional message property for the AssertionError.
  * @throws AssertionError - Throws if the assertion given is false
  */
-export default function assert(assertion : boolean, message? : string) : void {
-  if (!assertion) {
+export default function assert(
+  assertion : boolean,
+  message? : string
+) : asserts assertion {
+  if (__ENVIRONMENT__.DEV === __ENVIRONMENT__.CURRENT_ENV as number && !assertion) {
     throw new AssertionError(message === undefined ? "invalid assertion" :
                                                      message);
   }

package/src/utils/cancellable_sleep.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 PPromise from "./promise";
+import {
+  CancellationError,
+  CancellationSignal,
+} from "./task_canceller";
+
+/**
+ * Wait the given `delay`, resolving the Promise when finished.
+ *
+ * The `cancellationSignal` given allows to cancel that timeout. In the case it
+ * is triggered before the timeout ended, this function will reject the
+ * corresponding `CancellationError` through the returned Promise.
+ *
+ * @param {number} delay - Delay to wait, in milliseconds
+ * @param {Object} cancellationSignal - `CancellationSignal` allowing to abort
+ * the timeout.
+ * @returns {Promise} - Resolve on timeout completion, rejects on timeout
+ * cancellation with the corresponding `CancellationError`.
+ */
+export default function cancellableSleep(
+  delay: number,
+  cancellationSignal: CancellationSignal
+) : Promise<void> {
+  return new PPromise((res, rej) => {
+    const timeout = setTimeout(() => {
+      unregisterCancelSignal();
+      res();
+    }, delay);
+    const unregisterCancelSignal = cancellationSignal
+      .register(function onCancel(cancellationError : CancellationError) {
+        clearTimeout(timeout);
+        rej(cancellationError);
+      });
+  });
+}