rx-player 3.26.1 → 3.26.2

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/assert.ts

@@ -27,7 +27,7 @@ export default function assert(
   assertion : boolean,
   message? : string
 ) : asserts assertion {
-  if (!assertion) {
+  if (__ENVIRONMENT__.DEV === __ENVIRONMENT__.CURRENT_ENV as number && !assertion) {
     throw new AssertionError(message === undefined ? "invalid assertion" :
                                                      message);
   }

package/src/utils/concat_map_latest.ts

@@ -18,12 +18,10 @@ import {
   concat as observableConcat,
   defer as observableDefer,
   EMPTY,
-  Observable,
-} from "rxjs";
-import {
   mergeMap,
+  Observable,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 
 /**
  * Same as concatMap, but get last emitted value from source instead of unstack

package/src/utils/defer_subscriptions.ts

@@ -17,8 +17,8 @@
 import {
   asapScheduler,
   Observable,
+  subscribeOn,
 } from "rxjs";
-import { subscribeOn } from "rxjs/operators";
 
 /**
  * At subscription, instead of "running" the Observable right away, wait until

package/src/utils/filter_map.ts

@@ -16,12 +16,10 @@
 
 import {
   defer as observableDefer,
-  Observable,
-} from "rxjs";
-import {
   filter,
   map,
-} from "rxjs/operators";
+  Observable,
+} from "rxjs";
 
 /**
  * Special kind of map which will ignore the result when the value emitted

package/src/utils/reference.ts

@@ -0,0 +1,234 @@
+/**
+ * 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 {
+  Observable,
+  Subscriber,
+} from "rxjs";
+import log from "../log";
+
+/**
+ * A value behind a shared reference, meaning that any update to its value from
+ * anywhere can be retrieved from any other parts of the code in posession of
+ * the "same" (i.e. not cloned) `ISharedReference`.
+ *
+ * @example
+ * ```ts
+ * const myVal = 1;
+ * const myRef : ISharedReference<number> = createSharedReference(1);
+ *
+ * function DoThingsWithVal(num : number) {
+ *   num = 2;
+ * }
+ *
+ * function DoThingsWithRef(num : ISharedReference<number>) {
+ *   num.setValue(2);
+ * }
+ *
+ * myRef.asObservable().subscribe((val) => {
+ *   console.log(val); // outputs first `1`, then `2`
+ * });
+ *
+ * DoThingsWithVal(myVal);
+ * console.log(myVal); // output: 1
+ *
+ * DoThingsWithRef(myRef);
+ * console.log(myRef.getValue()); // output: 2
+ *
+ * myRef.asObservable().subscribe((val) => {
+ *   console.log(val); // outputs only `2`
+ * });
+ * ```
+ *
+ * This type was added because we found that the usage of an explicit type for
+ * those use cases makes the intent of the corresponding code clearer.
+ */
+export interface ISharedReference<T> {
+  /** Get the last set value for this shared reference. */
+  getValue() : T;
+
+  /** Update the value of this shared reference. */
+  setValue(newVal : T) : void;
+
+  /**
+   * Returns an Observable which synchronously emits the current value (unless
+   * the `skipCurrentValue` argument has been set to `true`) and then each time
+   * a new value is set.
+   * @param {boolean} [skipCurrentValue]
+   * @returns {Observable}
+   */
+  asObservable(skipCurrentValue? : boolean) : Observable<T>;
+
+  /**
+   * Indicate that no new values will be emitted.
+   * Allows to automatically close all Observables generated from this shared
+   * reference.
+   */
+  finish() : void;
+}
+
+/**
+ * An `ISharedReference` which can only be read and not updated.
+ *
+ * @example
+ * ```ts
+ * const myReference : ISharedReference<number> = createSharedReference(4);
+ *
+ * function shouldOnlyReadIt(roRef : IReadOnlySharedReference<number>) {
+ *   console.log("current value:", roRef.getValue());
+ * }
+ *
+ * shouldOnlyReadIt(myReference); // output: "current value: 4"
+ *
+ * myReference.setValue(12);
+ * shouldOnlyReadIt(myReference); // output: "current value: 12"
+ * ```
+ *
+ * Because an `ISharedReference` is structurally compatible to a
+ * `IReadOnlySharedReference`, and because of TypeScript variance rules, it can
+ * be upcasted into a `IReadOnlySharedReference` at any time to make it clear in
+ * the code that some logic is not supposed to update the referenced value.
+ */
+export interface IReadOnlySharedReference<T> {
+  getValue() : T;
+  asObservable(skipCurrentValue? : boolean) : Observable<T>;
+}
+
+/**
+ * Create an `ISharedReference` object encapsulating the mutable `initialValue`
+ * value of type T.
+ *
+ * @see ISharedReference
+ * @param {*} initialValue
+ * @returns {Observable}
+ */
+export function createSharedReference<T>(initialValue : T) : ISharedReference<T> {
+  /** Current value referenced by this `ISharedReference`. */
+  let value = initialValue;
+
+  /**
+   * List of currently subscribed Observables which listen to the referenced
+   * value's updates.
+   *
+   * Contains two properties:
+   *   - `subscriber`: interface through which new value will be communicated.
+   *   - `hasBeenUnsubscribed`: becomes `true` when the Observable becomes
+   *     unsubscribed and thus when it is removed from the `subs` array.
+   *     Adding this property allows to detect when a previously-added
+   *     Observable has since been unsubscribed e.g. as a side-effect during a
+   *     function call.
+   */
+  const subs : Array<{ subscriber : Subscriber<T>;
+                       hasBeenUnsubscribed : boolean; }> = [];
+
+  let isFinished = false;
+
+  return {
+    /**
+     * Returns the current value of this shared reference.
+     * @returns {*}
+     */
+    getValue() : T {
+      return value;
+    },
+
+    /**
+     * Update the value of this shared reference.
+     * @param {*}
+     */
+    setValue(newVal : T) : void {
+      if (isFinished) {
+        if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
+          throw new Error("Finished shared references cannot be updated");
+        } else {
+          log.error("Finished shared references cannot be updated");
+          return;
+        }
+      }
+      value = newVal;
+
+      if (subs.length === 0) {
+        return;
+      }
+      const clonedSubs = subs.slice();
+      for (const subObj of clonedSubs) {
+        try {
+          if (!subObj.hasBeenUnsubscribed) {
+            subObj.subscriber.next(newVal);
+          }
+        } catch (_) {
+          /* nothing */
+        }
+      }
+    },
+
+
+    /**
+     * Returns an Observable which synchronously emits the current value (unless
+     * the `skipCurrentValue` argument has been set to `true`) and then each
+     * time a new value is set.
+     * @param {boolean} [skipCurrentValue]
+     * @returns {Observable}
+     */
+    asObservable(skipCurrentValue? : boolean) : Observable<T> {
+      return new Observable((obs : Subscriber<T>) => {
+        if (skipCurrentValue !== true) {
+          obs.next(value);
+        }
+        if (isFinished) {
+          obs.complete();
+          return undefined;
+        }
+        const subObj = { subscriber: obs,
+                         hasBeenUnsubscribed: false };
+        subs.push(subObj);
+        return () => {
+          /**
+           * Code in here can still be running while this is happening.
+           * Set `hasBeenUnsubscribed` to `true` to avoid still using the
+           * `subscriber` from this object.
+           */
+          subObj.hasBeenUnsubscribed = true;
+          const indexOf = subs.indexOf(subObj);
+          if (indexOf >= 0) {
+            subs.splice(indexOf, 1);
+          }
+        };
+      });
+    },
+
+    /**
+     * Indicate that no new values will be emitted.
+     * Allows to automatically close all Observables generated from this shared
+     * reference.
+     */
+    finish() : void {
+      isFinished = true;
+      const clonedSubs = subs.slice();
+      for (const subObj of clonedSubs) {
+        try {
+          if (!subObj.hasBeenUnsubscribed) {
+            subObj.subscriber.complete();
+          }
+        } catch (_) {
+          /* nothing */
+        }
+      }
+    },
+  };
+}
+
+export default createSharedReference;

package/src/utils/request/fetch.ts

@@ -30,7 +30,7 @@ import {
 /** Object returned by `fetchRequest` after the fetch operation succeeded. */
 export interface IFetchedStreamComplete {
   /** Duration of the whole request, in milliseconds. */
-  duration : number;
+  requestDuration : number;
   /** Result of `performance.now()` at the time the request was received. */
   receivedTime : number;
   /** Result of `performance.now()` at the time the request was started. */
@@ -211,8 +211,8 @@ export default function fetchRequest(
       } else if (data.done) {
         deregisterCancelLstnr();
         const receivedTime = performance.now();
-        const duration = receivedTime - sendingTime;
-        return { duration,
+        const requestDuration = receivedTime - sendingTime;
+        return { requestDuration,
                  receivedTime,
                  sendingTime,
                  size,

package/src/utils/request/xhr.ts

@@ -247,7 +247,7 @@ export default function request<T>(
                     responseType: loadedResponseType,
                     sendingTime,
                     receivedTime,
-                    duration: receivedTime - sendingTime,
+                    requestDuration: receivedTime - sendingTime,
                     size: totalSize,
                     responseData });
 
@@ -303,7 +303,7 @@ export interface IRequestOptions<ResponseType> {
 /** Data emitted by `request`'s Promise when the request succeeded. */
 export interface IRequestResponse<T, U> {
   /** Time taken by the request, in milliseconds. */
-  duration : number;
+  requestDuration : number;
   /** Time (relative to the "time origin") at which the request ended. */
   receivedTime : number;
   /** Data requested. Its type will depend on the responseType. */

package/src/utils/rx-retry_with_backoff.ts

@@ -15,13 +15,11 @@
  */
 
 import {
+  catchError,
+  mergeMap,
   Observable,
   timer as observableTimer,
 } from "rxjs";
-import {
-  catchError,
-  mergeMap,
-} from "rxjs/operators";
 import { ICustomError } from "../errors";
 import getFuzzedDelay from "./get_fuzzed_delay";
 import isNullOrUndefined from "./is_null_or_undefined";

package/tsconfig.json

@@ -17,7 +17,10 @@
     "types": ["rxjs", "node", "jest"],
     "moduleResolution": "node",
     "typeRoots": [
-      "./src/typings",
+      "./src/typings/pinkie.d.ts",
+      "./src/typings/next-tick.d.ts",
+      "./src/typings/object-assign.d.ts",
+      "./src/typings/globals.d.ts",
       "./node_modules/@types"
     ]
   },

package/tsconfig.modules.json

@@ -18,14 +18,19 @@
     "moduleResolution": "node",
     "module": "es2015",
     "typeRoots": [
-      "./src/typings",
+      "./scripts/build/constants.d.ts",
+      "./src/typings/pinkie.d.ts",
+      "./src/typings/next-tick.d.ts",
+      "./src/typings/object-assign.d.ts",
       "./node_modules/@types"
     ]
   },
   "include": [
-    "./src/**/*.ts"
+    "./src/**/*.ts",
+    "./scripts/build/constants.d.ts"
   ],
   "exclude":[
-    "./src/**/*.test.ts"
+    "./src/**/*.test.ts",
+    "./src/typings/globals.d.ts"
   ]
 }

package/dist/_esm5.processed/core/abr/create_filters.d.ts

@@ -1,27 +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 { Observable } from "rxjs";
-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>;

package/dist/_esm5.processed/core/abr/create_filters.js

@@ -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.
- */
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import { combineLatest as observableCombineLatest, of as observableOf, } from "rxjs";
-import { map } from "rxjs/operators";
-import objectAssign from "../../utils/object_assign";
-/**
- * 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$, throttleBitrate$, throttle$) {
-    var deviceEventsArray = [];
-    if (limitWidth$ != null) {
-        deviceEventsArray.push(limitWidth$.pipe(map(function (width) { return ({ width: width }); })));
-    }
-    if (throttle$ != null) {
-        deviceEventsArray.push(throttle$.pipe(map(function (bitrate) { return ({ bitrate: bitrate }); })));
-    }
-    if (throttleBitrate$ != null) {
-        deviceEventsArray.push(throttleBitrate$.pipe(map(function (bitrate) { return ({ bitrate: bitrate }); })));
-    }
-    // Emit restrictions on the pools of available representations to choose
-    // from.
-    return deviceEventsArray.length > 0 ?
-        observableCombineLatest(deviceEventsArray)
-            .pipe(map(function (args) {
-            return objectAssign.apply(void 0, __spreadArray([{}], args, false));
-        })) :
-        observableOf({});
-}

package/dist/_esm5.processed/core/api/clock.d.ts

@@ -1,157 +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 defines a global clock for the RxPlayer.
- *
- * Each clock tick also pass information about the current state of the
- * media element to sub-parts of the player.
- */
-import { Observable } from "rxjs";
-/** "Event" that triggered the clock tick. */
-export declare type IClockMediaEventType = 
-/** First clock tick automatically emitted. */
-"init" | // set once on first emit
-/** Regularly emitted clock tick when no event happened in a long time. */
-"timeupdate" | 
-/** On the HTML5 event with the same name */
-"canplay" | 
-/** On the HTML5 event with the same name */
-"canplaythrough" | // HTML5 Event
-/** On the HTML5 event with the same name */
-"play" | 
-/** On the HTML5 event with the same name */
-"seeking" | 
-/** On the HTML5 event with the same name */
-"seeked" | 
-/** On the HTML5 event with the same name */
-"stalled" | 
-/** On the HTML5 event with the same name */
-"loadedmetadata" | 
-/** On the HTML5 event with the same name */
-"ratechange" | 
-/** An internal seek happens */
-"internal-seeking";
-/** Information recuperated on the media element on each clock tick. */
-interface IMediaInfos {
-    /** Gap between `currentTime` and the next position with un-buffered data. */
-    bufferGap: number;
-    /** Value of `buffered` (buffered ranges) for the media element. */
-    buffered: TimeRanges;
-    /** The buffered range we are currently playing. */
-    currentRange: {
-        start: number;
-        end: number;
-    } | null;
-    /** `currentTime` (position) set on the media element at the time of the tick. */
-    position: number;
-    /** Current `duration` set on the media element. */
-    duration: number;
-    /** Current `ended` set on the media element. */
-    ended: boolean;
-    /** Current `paused` set on the media element. */
-    paused: boolean;
-    /** Current `playbackRate` set on the media element. */
-    playbackRate: number;
-    /** Current `readyState` value on the media element. */
-    readyState: number;
-    /** Current `seeking` value on the mediaElement. */
-    seeking: boolean;
-    /** Event that triggered this clock tick. */
-    event: IClockMediaEventType;
-}
-/**
- * Describes when the player is "rebuffering" and what event started that
- * status.
- * "Rebuffering" is a status where the player has not enough buffer ahead to
- * play reliably.
- * The RxPlayer should pause playback when the clock indicates the rebuffering
- * status.
- */
-export interface IRebufferingStatus {
-    /** What started the player to rebuffer. */
-    reason: "seeking" | // Building buffer after seeking
-    "not-ready" | // Building buffer after low readyState
-    "internal-seek" | // Building buffer after a seek happened inside the player
-    "buffering";
-    /** `performance.now` at the time the rebuffering happened. */
-    timestamp: number;
-    /**
-     * Position, in seconds, at which data is awaited.
-     * If `null` the player is rebuffering but not because it is awaiting future data.
-     */
-    position: number | null;
-}
-/**
- * Describes when the player is "frozen".
- * This status is reserved for when the player is stuck at the same position for
- * an unknown reason.
- */
-export interface IFreezingStatus {
-    /** `performance.now` at the time the freezing started to be detected. */
-    timestamp: number;
-}
-/** Information emitted on each clock tick. */
-export interface IClockTick extends IMediaInfos {
-    /**
-     * Set if the player is short on audio and/or video media data and is a such,
-     * rebuffering.
-     * `null` if not.
-     */
-    rebuffering: IRebufferingStatus | null;
-    /**
-     * Set if the player is frozen, that is, stuck in place for unknown reason.
-     * Note that this reason can be a valid one, such as a necessary license not
-     * being obtained yet.
-     *
-     * `null` if the player is not frozen.
-     */
-    freezing: IFreezingStatus | null;
-    getCurrentTime: () => number;
-}
-/** Handle time relative information */
-export interface IClockHandler {
-    clock$: Observable<IClockTick>;
-    setCurrentTime: (time: number) => void;
-}
-export interface IClockOptions {
-    withMediaSource: boolean;
-    lowLatencyMode: boolean;
-}
-/**
- * Timings observable.
- *
- * This Observable samples snapshots of player's current state:
- *   * time position
- *   * playback rate
- *   * current buffered range
- *   * gap with current buffered range ending
- *   * media duration
- *
- * In addition to sampling, this Observable also reacts to "seeking" and "play"
- * events.
- *
- * Observable is shared for performance reason: reduces the number of event
- * listeners and intervals/timeouts but also limit access to the media element
- * properties and gap calculations.
- *
- * The sampling is manual instead of based on "timeupdate" to reduce the
- * number of events.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} options
- * @returns {Observable}
- */
-declare function createClock(mediaElement: HTMLMediaElement, options: IClockOptions): IClockHandler;
-export default createClock;