rx-player 3.28.0-dev.2022071100 → 3.29.0-dev.2022090500

package/.github/workflows/checks.yml

@@ -54,27 +54,29 @@ jobs:
     - run: node tests/integration/run.js --bchromehl
     - run: npm run test:memory
 
-  integration_windows:
+  # Windows seems to be a lot less stable for some reason.
+  # TODO debug?
+  # integration_windows:
 
-    runs-on: windows-latest
+  #   runs-on: windows-latest
 
-    strategy:
-      matrix:
-        node-version: [16.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+  #   strategy:
+  #     matrix:
+  #       node-version: [16.x]
+  #       # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm install
-    # Firefox seems to have issue with integration tests on GitHub actions only
-    # TODO to check
-    - run: node tests/integration/run.js --bchromehl
-    - run: npm run test:memory
+  #   steps:
+  #   - uses: actions/checkout@v2
+  #   - name: Use Node.js ${{ matrix.node-version }}
+  #     uses: actions/setup-node@v2
+  #     with:
+  #       node-version: ${{ matrix.node-version }}
+  #       cache: 'npm'
+  #   - run: npm install
+  #   # Firefox seems to have issue with integration tests on GitHub actions only
+  #   # TODO to check
+  #   - run: node tests/integration/run.js --bchromehl
+  #   - run: npm run test:memory
 
   # MacOS seems to be a lot less stable for some reason.
   # TODO debug?

package/CHANGELOG.md

@@ -1,6 +1,26 @@
 # Changelog
 
-## v3.28.0-dev.2022071100 (2022-07-11)
+## v3.29.0-dev.2022090500 (2022-09-05)
+
+### Features
+
+  - add `networkConfig.segmentRequestTimeout` and `networkConfig.manifestRequestTimeout` options to loadVideo to configure the timeout of respectively segment and manifest requests [#1156]
+  - add `timeout` property to the first argument communicated to a `segmentLoader` (from `loadVideo`'s `transportOptions`) [#1156]
+  - add `timeout` property to a new third argument communicated to a `manifestLoader` (from `loadVideo`'s `transportOptions`) [#1156]
+
+### Bug fixes
+
+  - Compat/Directfile: Fix an issue with LG TV when playing multiple directfile contents with the `stopAtEnd` player option set to `true` [#1154]
+  - Compat: To work around an issue on LG TVs, also specify a request timeout manually through a `setTimeout` call when XMLHttpRequests are created for Manifest and segment requests [#1152]
+  - Compat: Fix issue with Samsung TVs where starting playback on a discontinuity could lead to infinite rebuffering [#1140]
+  - Better handle valid reverse playback use cases by not skipping gaps when the playback rate has been set to `0` or a negative value [#1138]
+  - DRM: When using persistent licenses, create new MediaKeySession when `load` resolves with `false`, instead of relying the same, to fix issues with such persistent sessions [#1139]
+
+### Other improvements
+
+  - In the experimental "local" transport, add `incomingRanges` property to signal the time ranges of remaining data, allowing better discontinuity handling and duration estimates for sill-loading dowloaded contents [#1151]
+
+## v3.28.0 (2022-07-12)
 
 ### Features
 
@@ -10,13 +30,14 @@
 ### Bug fixes
 
   - Use the first **compatible** codec of the current AdaptationSet when creating a SourceBuffer [#1094]
-  - DASH/DRM: Fix potential infinite rebuffering when a KID is not anounced in the MPD [#1113]
+  - DASH/DRM: Fix potential infinite rebuffering when a KID is not announced in the MPD [#1113]
   - DRM: Fix quality fallback when loading a content whose license has been cached under an extended `singleLicensePer` setting and when starting (and staying) with a quality whose key id is not in it [#1133]
   - DASH: Avoid infinite loop due to rounding errors while parsing multi-Periods MPDs [#1111, #1110]
   - After a `RELOADING` state, stay in `PAUSED` if the media element was paused synchronously before the side-effect which triggered the reloading (usually coming from the API) was perform [#1132]
   - Fix issue with `maxVideoBufferSize` setting which could lead to too much data being buffered [#1125]
   - Prevent possibility of requests loops and infinite rebuffering when a pushed segment is always completely and immediately garbage collected by the browser [#1123]
   - DASH: Fix potential rare memory leak when stopping the content after it has reloaded at least once [#1135]
+  - Directfile: Properly announce the audio track's `audioDescription` accessibility attribute in directfile mode on Safari [#1136]
   - DASH: Fix issues that could arise if a segment is calculated to start at a negative position [#1122]
   - DASH: Fix possibility of wrong segments being requested when a SegmentTimeline in a given Period (whose Period@end is set) had an S@r set to `-1` at its end [#1098]
   - DASH: If the first `<S>` has its S@t attribute not set, make as if it is set to `0` [#1118]
@@ -24,6 +45,7 @@
 ### Other improvements
 
   - TTML: Add support for percent based thickness for textOutline in TTML Subtitles [#1108]
+  - Improve TypeScript's language servers auto import feature with the RxPlayer by better redirecting to the exported type [#1126]
   - If seeking after the last potential position, load last segments before ending [#1097]
   - The duration set on the media element is now only relative to the current chosen tracks (it was previously relative to all potential track). This allows to seek later when switching e.g. to a longer video track [#1102]
   - Errors coming from an HTMLMediaElement now have the browser's error message if it exists [#1112]

package/VERSION

@@ -1 +1 @@
-3.28.0-dev.2022071100
+3.29.0-dev.2022090500

package/dist/_esm5.processed/compat/eme/load_session.d.ts

@@ -18,14 +18,13 @@ import { ICustomMediaKeySession } from "./custom_media_keys";
  * Load a persistent session, based on its `sessionId`, on the given
  * MediaKeySession.
  *
- * Returns an Observable which emits:
- *   - true if the persistent MediaKeySession was found and loaded
- *   - false if no persistent MediaKeySession was found with that `sessionId`.
- * Then completes.
+ * Returns a Promise which resolves with:
+ *   - `true` if the persistent MediaKeySession was found and loaded
+ *   - `false` if no persistent MediaKeySession was found with that `sessionId`.
  *
- * The Observable throws if anything goes wrong in the process.
+ * The Promise rejects if anything goes wrong in the process.
  * @param {MediaKeySession} session
  * @param {string} sessionId
- * @returns {Observable}
+ * @returns {Promise.<boolean>}
  */
 export default function loadSession(session: MediaKeySession | ICustomMediaKeySession, sessionId: string): Promise<boolean>;

package/dist/_esm5.processed/compat/eme/load_session.js

@@ -55,15 +55,14 @@ var EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
  * Load a persistent session, based on its `sessionId`, on the given
  * MediaKeySession.
  *
- * Returns an Observable which emits:
- *   - true if the persistent MediaKeySession was found and loaded
- *   - false if no persistent MediaKeySession was found with that `sessionId`.
- * Then completes.
+ * Returns a Promise which resolves with:
+ *   - `true` if the persistent MediaKeySession was found and loaded
+ *   - `false` if no persistent MediaKeySession was found with that `sessionId`.
  *
- * The Observable throws if anything goes wrong in the process.
+ * The Promise rejects if anything goes wrong in the process.
  * @param {MediaKeySession} session
  * @param {string} sessionId
- * @returns {Observable}
+ * @returns {Promise.<boolean>}
  */
 export default function loadSession(session, sessionId) {
     return __awaiter(this, void 0, void 0, function () {

package/dist/_esm5.processed/compat/event_listeners.d.ts

@@ -42,7 +42,8 @@ export interface IPictureInPictureEvent {
 }
 /**
  * Emit when video enters and leaves Picture-In-Picture mode.
- * @param {HTMLMediaElement} mediaElement
+ * @param {HTMLMediaElement} elt
+ * @param {Object} stopListening
  * @returns {Observable}
  */
 declare function getPictureOnPictureStateRef(elt: HTMLMediaElement, stopListening: CancellationSignal): IReadOnlySharedReference<IPictureInPictureEvent>;
@@ -151,6 +152,21 @@ declare const onKeyError$: (element: IEventTargetLike) => Observable<Event>;
  * @returns {Observable}
  */
 declare const onKeyStatusesChange$: (element: IEventTargetLike) => Observable<Event>;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+declare const onSeeking: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+declare const onSeeked: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+declare const onEnded: (element: IEventTargetLike, listener: (event?: unknown) => void, cancelSignal: CancellationSignal) => void;
 /**
  * Utilitary function allowing to add an event listener and remove it
  * automatically once the given `CancellationSignal` emits.
@@ -162,4 +178,4 @@ declare const onKeyStatusesChange$: (element: IEventTargetLike) => Observable<Ev
  * emits
  */
 declare function addEventListener(elt: IEventEmitterLike, evt: string, listener: (x?: unknown) => void, stopListening: CancellationSignal): void;
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked$, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };
+export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked, onSeeked$, onSeeking, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };

package/dist/_esm5.processed/compat/event_listeners.js

@@ -70,6 +70,52 @@ function eventPrefixed(eventNames, prefixes) {
             .map(function (p) { return p + name; }));
     }, []);
 }
+/**
+ * Returns a function allowing to add event listeners for particular event(s)
+ * optionally automatically adding browser prefixes if needed.
+ * @param {Array.<string>} eventNames - The event(s) to listen to. If multiple
+ * events are set, the event listener will be triggered when any of them emits.
+ * @returns {Function} - Returns function allowing to easily add a callback to
+ * be triggered when that event is emitted on a given event target.
+ */
+function createCompatibleEventListener(eventNames) {
+    var mem;
+    var prefixedEvents = eventPrefixed(eventNames);
+    return function (element, listener, cancelSignal) {
+        if (cancelSignal.isCancelled) {
+            return;
+        }
+        // if the element is a HTMLElement we can detect
+        // the supported event, and memoize it in `mem`
+        if (element instanceof HTMLElement) {
+            if (typeof mem === "undefined") {
+                mem = findSupportedEvent(element, prefixedEvents);
+            }
+            if (isNonEmptyString(mem)) {
+                element.addEventListener(mem, listener);
+                cancelSignal.register(function () {
+                    if (mem !== undefined) {
+                        element.removeEventListener(mem, listener);
+                    }
+                });
+            }
+            else {
+                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+                    log.warn("compat: element ".concat(element.tagName) +
+                        " does not support any of these events: " +
+                        prefixedEvents.join(", "));
+                }
+                return;
+            }
+        }
+        prefixedEvents.forEach(function (eventName) {
+            element.addEventListener(eventName, listener);
+            cancelSignal.register(function () {
+                element.removeEventListener(eventName, listener);
+            });
+        });
+    };
+}
 /**
  * @param {Array.<string>} eventNames
  * @param {Array.<string>|undefined} prefixes
@@ -186,7 +232,8 @@ function getVideoWidthFromPIPWindow(mediaElement, pipWindow) {
 }
 /**
  * Emit when video enters and leaves Picture-In-Picture mode.
- * @param {HTMLMediaElement} mediaElement
+ * @param {HTMLMediaElement} elt
+ * @param {Object} stopListening
  * @returns {Observable}
  */
 function getPictureOnPictureStateRef(elt, stopListening) {
@@ -397,6 +444,21 @@ var onKeyError$ = compatibleListener(["keyerror", "error"]);
  * @returns {Observable}
  */
 var onKeyStatusesChange$ = compatibleListener(["keystatuseschange"]);
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+var onSeeking = createCompatibleEventListener(["seeking"]);
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+var onSeeked = createCompatibleEventListener(["seeked"]);
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+var onEnded = createCompatibleEventListener(["ended"]);
 /**
  * Utilitary function allowing to add an event listener and remove it
  * automatically once the given `CancellationSignal` emits.
@@ -413,4 +475,4 @@ function addEventListener(elt, evt, listener, stopListening) {
         elt.removeEventListener(evt, listener);
     });
 }
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked$, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };
+export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked, onSeeked$, onSeeking, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };

package/dist/_esm5.processed/compat/on_height_width_change.d.ts

@@ -13,14 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
+import { IReadOnlySharedReference } from "../utils/reference";
+import { CancellationSignal } from "../utils/task_canceller";
 export interface IResolution {
     width: number;
     height: number;
 }
 /**
- * Emit the current height and width of the given `element` on subscribtion
- * and each time it changes.
+ * Emit the current height and width of the given `element` each time it
+ * changes.
  *
  * On some browsers, we might not be able to rely on a native API to know when
  * it changes, the `interval` argument allow us to provide us an inverval in
@@ -29,4 +30,4 @@ export interface IResolution {
  * @param {number} interval
  * @returns {Observable}
  */
-export default function onHeightWidthChange(element: HTMLElement, interval: number): Observable<IResolution>;
+export default function onHeightWidthChange(element: HTMLElement, interval: number, cancellationSignal: CancellationSignal): IReadOnlySharedReference<IResolution>;

package/dist/_esm5.processed/compat/on_height_width_change.js

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, distinctUntilChanged, interval as observableInterval, map, Observable, startWith, } from "rxjs";
 import log from "../log";
+import createSharedReference from "../utils/reference";
 import isNode from "./is_node";
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
@@ -23,8 +23,8 @@ var _ResizeObserver = isNode ? undefined :
 /* eslint-enable @typescript-eslint/no-unsafe-member-access */
 /* eslint-enable @typescript-eslint/no-unsafe-assignment */
 /**
- * Emit the current height and width of the given `element` on subscribtion
- * and each time it changes.
+ * Emit the current height and width of the given `element` each time it
+ * changes.
  *
  * On some browsers, we might not be able to rely on a native API to know when
  * it changes, the `interval` argument allow us to provide us an inverval in
@@ -33,36 +33,45 @@ var _ResizeObserver = isNode ? undefined :
  * @param {number} interval
  * @returns {Observable}
  */
-export default function onHeightWidthChange(element, interval) {
-    return observableDefer(function () {
-        if (_ResizeObserver !== undefined) {
-            var lastHeight_1 = -1;
-            var lastWidth_1 = -1;
-            return new Observable(function (obs) {
-                var resizeObserver = new _ResizeObserver(function (entries) {
-                    if (entries.length === 0) {
-                        log.error("Compat: Resized but no observed element.");
-                        return;
-                    }
-                    var entry = entries[0];
-                    var _a = entry.contentRect, height = _a.height, width = _a.width;
-                    if (height !== lastHeight_1 || width !== lastWidth_1) {
-                        lastHeight_1 = height;
-                        lastWidth_1 = width;
-                        obs.next({ height: height, width: width });
-                    }
-                });
-                resizeObserver.observe(element);
-                return function () {
-                    resizeObserver.disconnect();
-                };
-            });
-        }
-        return observableInterval(interval).pipe(startWith(null), map(function () {
-            var _a = element.getBoundingClientRect(), height = _a.height, width = _a.width;
-            return { height: height, width: width };
-        }), distinctUntilChanged(function (o, n) {
-            return o.height === n.height && o.width === n.width;
-        }));
+export default function onHeightWidthChange(element, interval, cancellationSignal) {
+    var _a = element.getBoundingClientRect(), initHeight = _a.height, initWidth = _a.width;
+    var ref = createSharedReference({
+        height: initHeight,
+        width: initWidth,
     });
+    var lastHeight = initHeight;
+    var lastWidth = initWidth;
+    if (_ResizeObserver !== undefined) {
+        var resizeObserver_1 = new _ResizeObserver(function (entries) {
+            if (entries.length === 0) {
+                log.error("Compat: Resized but no observed element.");
+                return;
+            }
+            var entry = entries[0];
+            var _a = entry.contentRect, height = _a.height, width = _a.width;
+            if (height !== lastHeight || width !== lastWidth) {
+                lastHeight = height;
+                lastWidth = width;
+                ref.setValue({ height: height, width: width });
+            }
+        });
+        resizeObserver_1.observe(element);
+        cancellationSignal.register(function () {
+            resizeObserver_1.disconnect();
+        });
+    }
+    else {
+        var intervalId_1 = setInterval(function () {
+            var _a = element.getBoundingClientRect(), height = _a.height, width = _a.width;
+            if (height !== lastHeight || width !== lastWidth) {
+                lastHeight = height;
+                lastWidth = width;
+                ref.setValue({ height: height, width: width });
+            }
+        }, interval);
+        cancellationSignal.register(function () {
+            clearInterval(intervalId_1);
+        });
+    }
+    return ref;
 }

package/dist/_esm5.processed/core/api/media_element_track_choice_manager.js

@@ -69,7 +69,7 @@ function createAudioTracks(audioTracks) {
             occurences.toString();
         languagesOccurences[language] = occurences + 1;
         var track = { language: audioTrack.language, id: id, normalized: normalizeLanguage(audioTrack.language),
-            audioDescription: false,
+            audioDescription: audioTrack.kind === "descriptions",
             representations: [] };
         newAudioTracks.push({ track: track, nativeTrack: audioTrack });
     }

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

@@ -54,7 +54,7 @@ export default class PlaybackObserver {
      * This allows us to correctly characterize seeking events: if the counter is
      * superior to `0`, it is probably due to an internal "seek".
      */
-    private _internalSeekingEventsIncomingCounter;
+    private _internalSeeksIncoming;
     /**
      * Stores the last playback observation produced by the `PlaybackObserver`.:
      */
@@ -92,6 +92,11 @@ export default class PlaybackObserver {
      * @returns {number}
      */
     getCurrentTime(): number;
+    /**
+     * Returns the current playback rate advertised by the `HTMLMediaElement`.
+     * @returns {number}
+     */
+    getPlaybackRate(): number;
     /**
      * Returns the current `paused` status advertised by the `HTMLMediaElement`.
      *
@@ -272,7 +277,7 @@ export interface IPlaybackObservation extends IMediaInfos {
      * If `true`, an "internal seek" (a seeking operation triggered by the
      * RxPlayer code) is currently pending.
      */
-    internalSeeking: boolean;
+    pendingInternalSeek: number | null;
 }
 /**
  * Interface providing a generic and read-only version of a `PlaybackObserver`.
@@ -289,6 +294,11 @@ export interface IPlaybackObservation extends IMediaInfos {
 export interface IReadOnlyPlaybackObserver<TObservationType> {
     /** Get the current playing position, in seconds. */
     getCurrentTime(): number;
+    /**
+     * Returns the current playback rate advertised by the `HTMLMediaElement`.
+     * @returns {number}
+     */
+    getPlaybackRate(): number;
     /** Get the HTMLMediaElement's current `readyState`. */
     getReadyState(): number;
     /**

package/dist/_esm5.processed/core/api/playback_observer.js

@@ -58,7 +58,7 @@ var PlaybackObserver = /** @class */ (function () {
      * @param {Object} options
      */
     function PlaybackObserver(mediaElement, options) {
-        this._internalSeekingEventsIncomingCounter = 0;
+        this._internalSeeksIncoming = [];
         this._mediaElement = mediaElement;
         this._withMediaSource = options.withMediaSource;
         this._lowLatencyMode = options.lowLatencyMode;
@@ -86,6 +86,13 @@ var PlaybackObserver = /** @class */ (function () {
     PlaybackObserver.prototype.getCurrentTime = function () {
         return this._mediaElement.currentTime;
     };
+    /**
+     * Returns the current playback rate advertised by the `HTMLMediaElement`.
+     * @returns {number}
+     */
+    PlaybackObserver.prototype.getPlaybackRate = function () {
+        return this._mediaElement.playbackRate;
+    };
     /**
      * Returns the current `paused` status advertised by the `HTMLMediaElement`.
      *
@@ -107,7 +114,7 @@ var PlaybackObserver = /** @class */ (function () {
      * @param {number} time
      */
     PlaybackObserver.prototype.setCurrentTime = function (time) {
-        this._internalSeekingEventsIncomingCounter += 1;
+        this._internalSeeksIncoming.push(time);
         this._mediaElement.currentTime = time;
     };
     /**
@@ -180,24 +187,29 @@ var PlaybackObserver = /** @class */ (function () {
         var _a = config.getCurrent(), SAMPLING_INTERVAL_MEDIASOURCE = _a.SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY = _a.SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE = _a.SAMPLING_INTERVAL_NO_MEDIASOURCE;
         var getCurrentObservation = function (event) {
             var tmpEvt = event;
-            if (tmpEvt === "seeking" && _this._internalSeekingEventsIncomingCounter > 0) {
+            var startedInternalSeekTime;
+            if (tmpEvt === "seeking" && _this._internalSeeksIncoming.length > 0) {
                 tmpEvt = "internal-seeking";
-                _this._internalSeekingEventsIncomingCounter -= 1;
+                startedInternalSeekTime = _this._internalSeeksIncoming.shift();
             }
             var _lastObservation = lastObservation !== null && lastObservation !== void 0 ? lastObservation : _this._generateInitialObservation();
             var mediaTimings = getMediaInfos(_this._mediaElement, tmpEvt);
-            var internalSeeking = mediaTimings.seeking &&
-                // We've just received the event for internally seeking
-                (tmpEvt === "internal-seeking" ||
-                    // or We're still waiting on the previous internal-seek
-                    (_lastObservation.internalSeeking && tmpEvt !== "seeking"));
+            var pendingInternalSeek = null;
+            if (mediaTimings.seeking) {
+                if (typeof startedInternalSeekTime === "number") {
+                    pendingInternalSeek = startedInternalSeekTime;
+                }
+                else if (_lastObservation.pendingInternalSeek !== null && event !== "seeking") {
+                    pendingInternalSeek = _lastObservation.pendingInternalSeek;
+                }
+            }
             var rebufferingStatus = getRebufferingStatus(_lastObservation, mediaTimings, { lowLatencyMode: _this._lowLatencyMode,
                 withMediaSource: _this._withMediaSource });
             var freezingStatus = getFreezingStatus(_lastObservation, mediaTimings);
             var timings = objectAssign({}, { rebuffering: rebufferingStatus,
-                freezing: freezingStatus, internalSeeking: internalSeeking }, mediaTimings);
+                freezing: freezingStatus, pendingInternalSeek: pendingInternalSeek }, mediaTimings);
             if (log.hasLevel("DEBUG")) {
-                log.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeeking", timings.internalSeeking, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
+                log.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeek", timings.pendingInternalSeek, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
             }
             return timings;
         };
@@ -242,7 +254,7 @@ var PlaybackObserver = /** @class */ (function () {
     PlaybackObserver.prototype._generateInitialObservation = function () {
         return objectAssign(getMediaInfos(this._mediaElement, "init"), { rebuffering: null,
             freezing: null,
-            internalSeeking: false });
+            pendingInternalSeek: null });
     };
     return PlaybackObserver;
 }());
@@ -504,6 +516,9 @@ function generateReadOnlyObserver(src, transform, cancellationSignal) {
         getReadyState: function () {
             return src.getReadyState();
         },
+        getPlaybackRate: function () {
+            return src.getPlaybackRate();
+        },
         getIsPaused: function () {
             return src.getIsPaused();
         },

package/dist/_esm5.processed/core/api/public_api.js

@@ -88,7 +88,7 @@ var Player = /** @class */ (function (_super) {
         // Workaround to support Firefox autoplay on FF 42.
         // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
         videoElement.preload = "auto";
-        _this.version = /* PLAYER_VERSION */ "3.28.0-dev.2022071100";
+        _this.version = /* PLAYER_VERSION */ "3.29.0-dev.2022090500";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -373,13 +373,15 @@ var Player = /** @class */ (function (_super) {
                 throw new Error("transport \"".concat(transport, "\" not supported"));
             }
             var transportPipelines = transportFn(transportOptions);
-            var offlineRetry = networkConfig.offlineRetry, segmentRetry = networkConfig.segmentRetry, manifestRetry = networkConfig.manifestRetry;
+            var offlineRetry = networkConfig.offlineRetry, segmentRetry = networkConfig.segmentRetry, manifestRetry = networkConfig.manifestRetry, manifestRequestTimeout = networkConfig.manifestRequestTimeout, segmentRequestTimeout = networkConfig.segmentRequestTimeout;
             /** Interface used to load and refresh the Manifest. */
             var manifestFetcher = new ManifestFetcher(url, transportPipelines, { lowLatencyMode: lowLatencyMode, maxRetryRegular: manifestRetry,
-                maxRetryOffline: offlineRetry });
+                maxRetryOffline: offlineRetry,
+                requestTimeout: manifestRequestTimeout });
             /** Interface used to download segments. */
             var segmentFetcherCreator = new SegmentFetcherCreator(transportPipelines, { lowLatencyMode: lowLatencyMode, maxRetryOffline: offlineRetry,
-                maxRetryRegular: segmentRetry });
+                maxRetryRegular: segmentRetry,
+                requestTimeout: segmentRequestTimeout });
             /** Observable emitting the initial Manifest */
             var manifest$ = void 0;
             if (initialManifest instanceof Manifest) {
@@ -587,15 +589,13 @@ var Player = /** @class */ (function (_super) {
         // Handle state updates
         playerState$
             .pipe(takeUntil(stoppedContent$))
-            .subscribe(function (x) { return _this._priv_setPlayerState(x); });
-        var endedEvent$ = observation$.pipe(filter(function (o) {
-            return o.event === "ended";
-        }));
-        (this._priv_stopAtEnd ? endedEvent$ :
-            EMPTY)
-            .pipe(takeUntil(stoppedContent$))
-            .subscribe(function () {
-            currentContentCanceller.cancel();
+            .subscribe(function (newState) {
+            _this._priv_setPlayerState(newState);
+            // Previous call could have performed all kind of side-effects, thus,
+            // we re-check the current state associated to the RxPlayer
+            if (_this.state === "ENDED" && _this._priv_stopAtEnd) {
+                currentContentCanceller.cancel();
+            }
         });
         // Link playback events to the corresponding callbacks
         playback$.subscribe({
@@ -2295,5 +2295,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.28.0-dev.2022071100";
+Player.version = /* PLAYER_VERSION */ "3.29.0-dev.2022090500";
 export default Player;