rx-player 4.5.0-dev.2026033100 → 4.5.0-dev.2026041501

package/src/playback_observer/__tests__/mocks.ts

@@ -0,0 +1,152 @@
+import SharedReference from "../../utils/reference";
+import type { CancellationSignal } from "../../utils/task_canceller";
+import { makeMockedClass } from "../../utils/test-utils";
+import type CorePlaybackObserver from "../core_playback_observer";
+import type MediaElementPlaybackObserver from "../media_element_playback_observer";
+import type { IReadOnlyPlaybackObserver } from "../types";
+import type ObservationPosition from "../utils/observation_position";
+
+/**
+ * Construct a class implementing the `MediaElementPlaybackObserver` interface.
+ * @class DummyMediaElementPlaybackObserver
+ */
+export const DummyMediaElementPlaybackObserver =
+  makeMockedClass<MediaElementPlaybackObserver>(
+    {
+      attachMediaElement: notImplemented("attachMediaElement"),
+      getCurrentTime: notImplemented("getCurrentTime"),
+      getIsPaused: notImplemented("getIsPaused"),
+      getPendingSeekInformation: notImplemented("getPendingSeekInformation"),
+      getPlaybackRate: notImplemented("getPlaybackRate"),
+      getReadyState: notImplemented("getReadyState"),
+      getReference: notImplemented("getReference"),
+      stop: notImplemented("stop"),
+      blockSeeking: notImplemented("blockSeeking"),
+      unblockSeeking: notImplemented("unblockSeeking"),
+      isSeekingBlocked: notImplemented("isSeekingBlocked"),
+      setCurrentTime: notImplemented("setCurrentTime"),
+      setPlaybackRate: notImplemented("setPlaybackRate"),
+      listen: notImplemented("listen"),
+      deriveReadOnlyObserver: notImplemented("deriveReadOnlyObserver"),
+    },
+    {},
+  );
+
+/**
+ * Construct a class implementing the `CorePlaybackObserver` interface.
+ * @class DummyCorePlaybackObserver
+ */
+export const DummyCorePlaybackObserver = makeMockedClass<CorePlaybackObserver>(
+  {
+    getCurrentTime: notImplemented("getCurrentTime"),
+    getIsPaused: notImplemented("getIsPaused"),
+    getPlaybackRate: notImplemented("getPlaybackRate"),
+    getReadyState: notImplemented("getReadyState"),
+    getReference: notImplemented("getReference"),
+    setPlaybackRate: notImplemented("setPlaybackRate"),
+    listen: notImplemented("listen"),
+    deriveReadOnlyObserver: notImplemented("deriveReadOnlyObserver"),
+  },
+  {},
+);
+
+/**
+ * Object facilitation the usage of a IReadOnlyPlaybackObserver`.
+ * /!\ Do not forget to call `reset` when done to ensure no memory leak.
+ */
+export interface IMockedReadOnlyPlaybackObserver<TObservationData> {
+  /**
+   * The `IReadOnlyPlaybackObserver` itself.
+   */
+  observer: IReadOnlyPlaybackObserver<TObservationData>;
+  /**
+   * Allows to trigger new observations through `observer`.
+   */
+  emit: (data: TObservationData) => void;
+  /**
+   * Reset `observer` to its initial observation, also removing all observation
+   * listener it potentially had.
+   *
+   * Intended to be called between each test to clean-up.
+   */
+  reset: () => void;
+}
+
+/**
+ * Allows to create any `IReadOnlyPlaybackObserver` with TypeScript typechecking
+ * and to obtain a function to emit new observations.
+ * @param {Object} initialData - The initial observation emitted.
+ * @returns {Object} res
+ * @returns {IReadOnlyPlaybackObserver} res.observer - The
+ * `IReadOnlyPlaybackObserver` instance.
+ * @returns {Function} res.emit - A function allowing to emit new observations.
+ * @returns {Function} res.reset - Reset the playback observer to its initial
+ * state, also removing all its listeners. Call this between tests.
+ */
+export function makeReadyOnlyPlaybackObserver<TObservationData>(
+  initialData: TObservationData,
+): IMockedReadOnlyPlaybackObserver<TObservationData> {
+  let ref = new SharedReference<TObservationData>(initialData);
+  const ret = {
+    observer: makeObserver(),
+    emit: (data: TObservationData) => {
+      ref.setValue(data);
+    },
+    reset: () => {
+      ref.finish();
+      ref = new SharedReference<TObservationData>(initialData);
+    },
+  };
+  return ret;
+
+  function makeObserver(): IReadOnlyPlaybackObserver<TObservationData> {
+    const klass = makeMockedClass<IReadOnlyPlaybackObserver<TObservationData>>(
+      {
+        getCurrentTime: notImplemented("getCurrentTime"),
+        getIsPaused: notImplemented("getIsPaused"),
+        getPlaybackRate: notImplemented("getPlaybackRate"),
+        getReadyState: notImplemented("getReadyState"),
+        getReference: () => ref,
+        listen(
+          cb: (observation: TObservationData, stopListening: () => void) => void,
+          params: {
+            includeLastObservation?: boolean | undefined;
+            clearSignal: CancellationSignal;
+          },
+        ) {
+          if (params.clearSignal.isCancelled()) {
+            return;
+          }
+          ref.onUpdate(cb, {
+            clearSignal: params.clearSignal,
+            emitCurrentValue: params.includeLastObservation,
+          });
+        },
+        deriveReadOnlyObserver: notImplemented("deriveReadOnlyObserver"),
+      },
+      {},
+    );
+    return new klass();
+  }
+}
+
+/**
+ * Construct a class implementing the `ObservationPosition` interface.
+ * @class DummyObservationPosition
+ */
+export const DummyObservationPosition = makeMockedClass<ObservationPosition>(
+  {
+    serialize: notImplemented("serialize"),
+    getPolled: notImplemented("getPolled"),
+    getWanted: notImplemented("getWanted"),
+    forceWantedPosition: notImplemented("forceWantedPosition"),
+    isAwaitingFuturePosition: notImplemented("isAwaitingFuturePosition"),
+  },
+  {},
+);
+
+function notImplemented(name: string): () => never {
+  return () => {
+    throw new Error(`${name} not implemented`);
+  };
+}

package/src/playback_observer/core_playback_observer.ts

@@ -93,15 +93,15 @@ export default class CorePlaybackObserver
     this._cancelSignal = cancellationSignal;
   }
 
-  public getCurrentTime(): number | undefined {
+  public getCurrentTime(): undefined {
     return undefined;
   }
 
-  public getReadyState(): number | undefined {
+  public getReadyState(): undefined {
     return undefined;
   }
 
-  public getIsPaused(): boolean | undefined {
+  public getIsPaused(): undefined {
     return undefined;
   }
 
@@ -117,7 +117,7 @@ export default class CorePlaybackObserver
     });
   }
 
-  public getPlaybackRate(): number | undefined {
+  public getPlaybackRate(): undefined {
     return undefined;
   }
 

package/src/playback_observer/media_element_playback_observer.ts

@@ -1106,7 +1106,7 @@ function getInitialObservation(mediaElement: IMediaElement | null): IPlaybackObs
   });
 }
 
-interface IPendingSeekInformation {
+export interface IPendingSeekInformation {
   /** Position to seek to. */
   position: number;
   /** If `true`, the seek was performed by the RxPlayer's internal logic. */

package/src/tools/README.md

@@ -1,7 +1,7 @@
 # Tools
 
-This directory regroup tools, which are functions and classes exported by this library
+This directory regroups tools, which are functions and classes exported by this library
 which are not part of the `RxPlayer` class.
 
-Note that tools NEED to be declared in their own directory, with their inner `index.js`
+Note that tools NEED to be declared in their own directory, with their inner `index.ts`
 file exporting them, as that's a requirement from our exporting strategy.

package/src/transports/README.md

@@ -19,8 +19,8 @@ As such, most network request needed by the player are directly performed by the
 `transports` code.
 
 Note: the only HTTP request which might be done elsewhere would be the request for a
-`directfile` content. That request is not done explicely with a JavaScript API but
-implicitely by the browser (inclusion of an `src` attribute).
+`directfile` content. That request is not done explicitly with a JavaScript API but
+implicitly by the browser (through the `src` attribute).
 
 ## Implementation
 
@@ -184,7 +184,7 @@ It receives information linked to the segment you want to download:
 - The `Representation` it is linked to
 - The `Segment` object it is linked to
 
-It then return a Promise resolving when the segment is loaded.
+It then returns a Promise resolving when the segment is loaded.
 
 ```
   INPUT:                              OUTPUT:
@@ -226,8 +226,8 @@ way.
 A segment parser is a function whose role is to extract some information from the
 segment's data:
 
-- what its precize start time and duration is
-- whether the segment should be offseted when decoded and by what amount
+- what its precise start time and duration is
+- whether the segment should be offset when decoded and by what amount
 - the decodable data (which can be wrapped in a container e.g. subtitles in an ISOBMFF
   container).
 - the attached protection information and data to be able to decrypt that segment.

package/src/transports/dash/segment_parser.ts

@@ -19,7 +19,7 @@ import logger from "../../log";
 import {
   getMDHDTimescale,
   getSegmentsFromSidx,
-  takePSSHOut,
+  extractPssh,
   removeDolbyVisionConfigData,
 } from "../../parsers/containers/isobmff";
 import {
@@ -96,7 +96,7 @@ export default function generateAudioVideoSegmentParser({
 
     const protectionData: IProtectionDataInfo[] = [];
     if (seemsToBeMP4) {
-      const psshInfo = takePSSHOut(chunkData);
+      const psshInfo = extractPssh(chunkData);
       let keyId;
       if (segment.isInit) {
         keyId = getKeyIdFromInitSegment(chunkData) ?? undefined;

package/src/transports/local/segment_parser.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { getMDHDTimescale, takePSSHOut } from "../../parsers/containers/isobmff";
+import { getMDHDTimescale, extractPssh } from "../../parsers/containers/isobmff";
 import { getKeyIdFromInitSegment } from "../../parsers/containers/isobmff/utils";
 import { getTimeCodeScale } from "../../parsers/containers/matroska";
 import type {
@@ -68,7 +68,7 @@ export default function segmentParser(
   const seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
   const protectionData: IProtectionDataInfo[] = [];
   if (seemsToBeMP4) {
-    const psshInfo = takePSSHOut(chunkData);
+    const psshInfo = extractPssh(chunkData);
     let keyId;
     if (segment.isInit) {
       keyId = getKeyIdFromInitSegment(chunkData) ?? undefined;

package/src/transports/metaplaylist/README.md

@@ -50,15 +50,15 @@ To illustrate, it kind of goes like this:
 |                | ---------------------------------------> |              |
 |                |                                          |              |
 |                | <--------------------------------------- |              |
-|                |  4. Gives segment infos asked (offseted) |              |
+|                |  4. Gives segment infos asked (offset)   |              |
 |                |                                          |              |
 |      CORE      |                                          | METAPLAYLIST |
 |                |                                          |    WRAPPER   |
-|                | 5. Ask to download segment (offseted)    |              |
+|                | 5. Ask to download segment (offset)      |              |
 |                | ---------------------------------------> |              |
 |                |                                          |              |
 |                | <--------------------------------------- |              |
-+----------------+              8. Gives segment (offseted) +--------------+
++----------------+               8. Gives segment (offset)  +--------------+
                                                              | ^     |  ^
                                                              | |     |  |
                                                              | |     |  |
@@ -73,7 +73,7 @@ To illustrate, it kind of goes like this:
    | |  HSS  |  |                                                    |  |
    | |       |  |                                                    |  |
    | +-------+  |                                                    |  |
-   | +-------+  |  6. Ask to download non-offseted (normal) segments |  |
+   | +-------+  |   6. Ask to download non-offset (normal) segments  |  |
    | |       |  | <--------------------------------------------------+  |
    | |  ...  |  |                                                       |
    | |       |  |  7. Gives normal segment                              |

package/src/utils/README.md

@@ -7,6 +7,6 @@
 
 ## Overview
 
-This directory regroups utils function, which are small stand-alone (they shouldn't rely
-on any outside code, beside dependencies) functions that might be used by any part of the
-RxPlayer's code.
+This directory regroups utility functions, which are small stand-alone (they shouldn't
+rely on any outside code, beside dependencies) functions that might be used by any part of
+the RxPlayer's code.

package/src/utils/test-utils.ts

@@ -0,0 +1,50 @@
+/**
+ * Util useful to create mocked versions of classes with each of their methods
+ * and properties replaced, while being properly checked by TypeScript.
+ * @param {Object} methods - Each of this class' methods (key is the method
+ * name, value is the implementation).
+ * @param {Object} properties - Each of this class' property (key is the
+ * property name, value is the implementation).
+ * @returns {*} - The mocked class, which should respect its public API.
+ */
+export function makeMockedClass<T>(
+  methods: MethodsMap<T>,
+  properties: PropertiesMap<T>,
+): { new (opts?: Partial<T>): T; prototype: IPrototype<T> } {
+  // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+  class Dummy {
+    constructor(opts: Partial<T> = {}) {
+      // Apply default property values
+      for (const key in properties) {
+        if (Object.prototype.hasOwnProperty.call(properties, key)) {
+          // @ts-expect-error dynamic assignment
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          this[key] = properties[key];
+        }
+      }
+      // Override with any provided opts
+      for (const key in opts) {
+        if (Object.prototype.hasOwnProperty.call(opts, key)) {
+          // @ts-expect-error dynamic assignment
+          this[key] = opts[key];
+        }
+      }
+    }
+  }
+  for (const [name, fn] of Object.entries(methods)) {
+    // @ts-expect-error dynamic assignment
+    Dummy.prototype[name as keyof typeof Dummy.prototype] = fn;
+  }
+  return Dummy as unknown as { new (opts?: Partial<T>): T; prototype: IPrototype<T> };
+}
+
+/* eslint-disable @typescript-eslint/no-unsafe-function-type, @typescript-eslint/no-restricted-types */
+type IPrototype<T> = { [K in keyof T as T[K] extends Function ? K : never]: T[K] };
+
+// Splits T's keys into method keys and property keys
+type MethodKeys<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];
+type PropertyKeys<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];
+/* eslint-enable @typescript-eslint/no-unsafe-function-type, @typescript-eslint/no-restricted-types */
+
+type MethodsMap<T> = { [K in MethodKeys<T>]: T[K] };
+type PropertiesMap<T> = { [K in PropertyKeys<T>]: T[K] };

package/dist/commonjs/core/entry/synchronize_sinks_on_observation.d.ts

@@ -1,11 +0,0 @@
-import type { ICorePlaybackObservation } from "../../main_thread/init/utils/create_core_playback_observer";
-import type SegmentSinksStore from "../segment_sinks";
-/**
- * Synchronize SegmentSinks with what has been buffered.
- * @param {Object} observation - The just-received playback observation,
- * including what has been buffered on lower-level buffers
- * @param {Object} segmentSinksStore - Interface allowing to interact
- * with `SegmentSink`s, so their inventory can be updated accordingly.
- */
-export default function synchronizeSegmentSinksOnObservation(observation: ICorePlaybackObservation, segmentSinksStore: SegmentSinksStore): void;
-//# sourceMappingURL=synchronize_sinks_on_observation.d.ts.map

package/dist/commonjs/core/entry/synchronize_sinks_on_observation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"synchronize_sinks_on_observation.d.ts","sourceRoot":"","sources":["../../../../src/core/entry/synchronize_sinks_on_observation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4DAA4D,CAAC;AAC3G,OAAO,KAAK,iBAAiB,MAAM,kBAAkB,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,oCAAoC,CAC1D,WAAW,EAAE,wBAAwB,EACrC,iBAAiB,EAAE,iBAAiB,GACnC,IAAI,CAQN"}

package/dist/commonjs/core/entry/synchronize_sinks_on_observation.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = synchronizeSegmentSinksOnObservation;
-/**
- * Synchronize SegmentSinks with what has been buffered.
- * @param {Object} observation - The just-received playback observation,
- * including what has been buffered on lower-level buffers
- * @param {Object} segmentSinksStore - Interface allowing to interact
- * with `SegmentSink`s, so their inventory can be updated accordingly.
- */
-function synchronizeSegmentSinksOnObservation(observation, segmentSinksStore) {
-    // Synchronize SegmentSinks with what has been buffered.
-    ["video", "audio", "text"].forEach(function (tType) {
-        var _a;
-        var segmentSinkStatus = segmentSinksStore.getStatus(tType);
-        if (segmentSinkStatus.type === "initialized") {
-            segmentSinkStatus.value.synchronizeInventory((_a = observation.buffered[tType]) !== null && _a !== void 0 ? _a : []);
-        }
-    });
-}

package/dist/commonjs/parsers/containers/isobmff/take_pssh_out.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"take_pssh_out.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/containers/isobmff/take_pssh_out.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,yCAAyC;AACzC,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,gBAAgB,EAAE,CAkCrF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,iBAAiB,EAAE,MAAM,GACxB,MAAM,GAAG,SAAS,CAWpB"}

package/dist/es2017/core/entry/synchronize_sinks_on_observation.d.ts

@@ -1,11 +0,0 @@
-import type { ICorePlaybackObservation } from "../../main_thread/init/utils/create_core_playback_observer";
-import type SegmentSinksStore from "../segment_sinks";
-/**
- * Synchronize SegmentSinks with what has been buffered.
- * @param {Object} observation - The just-received playback observation,
- * including what has been buffered on lower-level buffers
- * @param {Object} segmentSinksStore - Interface allowing to interact
- * with `SegmentSink`s, so their inventory can be updated accordingly.
- */
-export default function synchronizeSegmentSinksOnObservation(observation: ICorePlaybackObservation, segmentSinksStore: SegmentSinksStore): void;
-//# sourceMappingURL=synchronize_sinks_on_observation.d.ts.map

package/dist/es2017/core/entry/synchronize_sinks_on_observation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"synchronize_sinks_on_observation.d.ts","sourceRoot":"","sources":["../../../../src/core/entry/synchronize_sinks_on_observation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4DAA4D,CAAC;AAC3G,OAAO,KAAK,iBAAiB,MAAM,kBAAkB,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,oCAAoC,CAC1D,WAAW,EAAE,wBAAwB,EACrC,iBAAiB,EAAE,iBAAiB,GACnC,IAAI,CAQN"}

package/dist/es2017/core/entry/synchronize_sinks_on_observation.js

@@ -1,17 +0,0 @@
-/**
- * Synchronize SegmentSinks with what has been buffered.
- * @param {Object} observation - The just-received playback observation,
- * including what has been buffered on lower-level buffers
- * @param {Object} segmentSinksStore - Interface allowing to interact
- * with `SegmentSink`s, so their inventory can be updated accordingly.
- */
-export default function synchronizeSegmentSinksOnObservation(observation, segmentSinksStore) {
-    // Synchronize SegmentSinks with what has been buffered.
-    ["video", "audio", "text"].forEach((tType) => {
-        var _a;
-        const segmentSinkStatus = segmentSinksStore.getStatus(tType);
-        if (segmentSinkStatus.type === "initialized") {
-            segmentSinkStatus.value.synchronizeInventory((_a = observation.buffered[tType]) !== null && _a !== void 0 ? _a : []);
-        }
-    });
-}

package/dist/es2017/parsers/containers/isobmff/take_pssh_out.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"take_pssh_out.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/containers/isobmff/take_pssh_out.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,yCAAyC;AACzC,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,gBAAgB,EAAE,CAkCrF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,iBAAiB,EAAE,MAAM,GACxB,MAAM,GAAG,SAAS,CAWpB"}

package/src/core/adaptive/utils/__tests__/bandwith_estimator.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect } from "vitest";
-import BandwidthEstimator from "../bandwidth_estimator";
-
-describe("ABR - BandwidthEstimator", () => {
-  it("should return undefined if no sample has been added yet", () => {
-    const bwEstimator = new BandwidthEstimator();
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-  });
-
-  it("should return undefined if not enough bytes has been received", () => {
-    const bwEstimator = new BandwidthEstimator();
-    bwEstimator.addSample(800, 10);
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-    bwEstimator.addSample(800, 10);
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-    bwEstimator.addSample(800, 10);
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-    bwEstimator.addSample(80000000, 1000000);
-    expect(bwEstimator.getEstimate()).toBe(100);
-  });
-
-  it("should calculate bitrate in function of consecutive request' durations and size", () => {
-    const bwEstimator = new BandwidthEstimator();
-    bwEstimator.addSample(8000, 1000000);
-    expect(bwEstimator.getEstimate()).toBe(1000000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1500000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1400000);
-    bwEstimator.addSample(1000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(3000000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(2000000);
-  });
-
-  it("should reset the estimation when reset is called", () => {
-    const bwEstimator = new BandwidthEstimator();
-    bwEstimator.addSample(8000, 1000000);
-    bwEstimator.addSample(4000, 1000000);
-    bwEstimator.addSample(1000, 1000000);
-
-    bwEstimator.reset();
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-    bwEstimator.addSample(8000, 1000000);
-    expect(bwEstimator.getEstimate()).toBe(1000000);
-  });
-
-  it("should estimate a low bitrate quicker than a higher one", () => {
-    const bwEstimator = new BandwidthEstimator();
-
-    // 1st test:
-    // we raise the bitrate from 1 mega to 2 mega
-    // we should slowly go toward 2 megas as an estimate
-    bwEstimator.addSample(8000, 1000000); // 1 mega
-    bwEstimator.addSample(4000, 1000000); // 2 mega
-    expect(bwEstimator.getEstimate()).toBeLessThan(1500000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1400000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1700000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1600000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1800000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1700000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1900000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1800000);
-    bwEstimator.addSample(4000, 1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1900000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1800000);
-    bwEstimator.addSample(4000, 1000000); // 6 iterations for 1900000+
-    expect(bwEstimator.getEstimate()).toBeLessThan(2000000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1900000);
-
-    bwEstimator.reset();
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-
-    // 2st test:
-    // we decrease the bitrate from 2 mega to 1 mega
-    // we should quickly go to 1 mega
-    bwEstimator.addSample(4000, 1000000); // 2 mega
-    bwEstimator.addSample(8000, 1000000); // 1 mega - only 1 iteration for sub 1100000!
-    expect(bwEstimator.getEstimate()).toBeLessThan(1100000);
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1000000);
-
-    bwEstimator.reset();
-    expect(bwEstimator.getEstimate()).toBe(undefined);
-
-    // 3rd test:
-    // we both go up and down, from 5 mega to 10 then to 1 and come back to 10.
-    // the 1 mega estimate should have a very perceptible influence, even when
-    // going back to 10
-    bwEstimator.addSample(2000, 1250000); // 5 mega
-    expect(bwEstimator.getEstimate()).toBe(5000000);
-    bwEstimator.addSample(2000, 1250100); // 5 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(5000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(5010000);
-    bwEstimator.addSample(1000, 1250700); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(6000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(6500000);
-    bwEstimator.addSample(1000, 1251000); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(6500000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(7000000);
-    bwEstimator.addSample(10000, 1251000); // 1 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(1000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(1500000);
-    bwEstimator.addSample(1000, 1250000); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(3000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(3500000);
-    bwEstimator.addSample(1000, 1250100); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(3500000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(4000000);
-    bwEstimator.addSample(1000, 1250100); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(4000000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(4500000);
-    bwEstimator.addSample(1000, 1250100); // 10 mega
-    expect(bwEstimator.getEstimate()).toBeGreaterThan(4500000);
-    expect(bwEstimator.getEstimate()).toBeLessThan(5000000);
-  });
-});

package/src/core/entry/synchronize_sinks_on_observation.ts

@@ -1,22 +0,0 @@
-import type { ICorePlaybackObservation } from "../../main_thread/init/utils/create_core_playback_observer";
-import type SegmentSinksStore from "../segment_sinks";
-
-/**
- * Synchronize SegmentSinks with what has been buffered.
- * @param {Object} observation - The just-received playback observation,
- * including what has been buffered on lower-level buffers
- * @param {Object} segmentSinksStore - Interface allowing to interact
- * with `SegmentSink`s, so their inventory can be updated accordingly.
- */
-export default function synchronizeSegmentSinksOnObservation(
-  observation: ICorePlaybackObservation,
-  segmentSinksStore: SegmentSinksStore,
-): void {
-  // Synchronize SegmentSinks with what has been buffered.
-  ["video" as const, "audio" as const, "text" as const].forEach((tType) => {
-    const segmentSinkStatus = segmentSinksStore.getStatus(tType);
-    if (segmentSinkStatus.type === "initialized") {
-      segmentSinkStatus.value.synchronizeInventory(observation.buffered[tType] ?? []);
-    }
-  });
-}