rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/fetchers/utils/try_urls_with_backoff.d.ts

@@ -13,33 +13,46 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-export interface IBackoffOptions {
+import { CancellationSignal } from "../../../utils/task_canceller";
+/** Settings to give to the backoff functions to configure their behavior. */
+export interface IBackoffSettings {
+    /**
+     * Initial delay to wait if a request fails before making a new request, in
+     * milliseconds.
+     */
     baseDelay: number;
+    /**
+     * Maximum delay to wait if a request fails before making a new request, in
+     * milliseconds.
+     */
     maxDelay: number;
+    /**
+     * Maximum number of retries to perform on "regular" errors (e.g. due to HTTP
+     * status, integrity errors, timeouts...).
+     */
     maxRetryRegular: number;
+    /**
+     * Maximum number of retries to perform when it appears that the user is
+     * currently offline.
+     */
     maxRetryOffline: number;
+    /** Callback called when a request is retried. */
+    onRetry: (err: unknown) => void;
 }
-export interface IBackoffRetry {
-    type: "retry";
-    value: unknown;
-}
-export interface IBackoffResponse<T> {
-    type: "response";
-    value: T;
-}
-export declare type IBackoffEvent<T> = IBackoffRetry | IBackoffResponse<T>;
 /**
  * Specific algorithm used to perform segment and manifest requests.
  *
  * Here how it works:
  *
- *   1. we give it one or multiple URLs available for the element we want to
- *      request, the request callback and some options
+ *   1. You give it one or multiple URLs available for the resource you want to
+ *      request (from the most important URL to the least important), the
+ *      request callback itself, and some options.
  *
  *   2. it tries to call the request callback with the first URL:
- *        - if it works as expected, it wrap the response in a `response` event.
- *        - if it fails, it emits a `retry` event and try with the next one.
+ *        - if it works as expected, it resolves the returned Promise with that
+ *          request's response.
+ *        - if it fails, it calls ther `onRetry` callback given with the
+ *          corresponding error and try with the next URL.
  *
  *   3. When all URLs have been tested (and failed), it decides - according to
  *      the error counters, configuration and errors received - if it can retry
@@ -47,24 +60,26 @@ export declare type IBackoffEvent<T> = IBackoffRetry | IBackoffResponse<T>;
  *        - If it can, it increments the corresponding error counter, wait a
  *          delay (based on an exponential backoff) and restart the same logic
  *          for all retry-able URL.
- *        - If it can't it just throws the error.
+ *        - If it can't it just reject the error through the returned Promise.
  *
  * Note that there are in fact two separate counters:
  *   - one for "offline" errors
  *   - one for other xhr errors
  * Both counters are resetted if the error type changes from an error to the
  * next.
- * @param {Array.<string} obs$
- * @param {Function} request$
+ *
+ * @param {Array.<string>} urls
+ * @param {Function} performRequest
  * @param {Object} options - Configuration options.
- * @returns {Observable}
+ * @param {Object} cancellationSignal
+ * @returns {Promise}
  */
-export default function tryURLsWithBackoff<T>(urls: Array<string | null>, request$: (url: string | null) => Observable<T>, options: IBackoffOptions): Observable<IBackoffEvent<T>>;
+export declare function tryURLsWithBackoff<T>(urls: Array<string | null>, performRequest: (url: string | null, cancellationSignal: CancellationSignal) => Promise<T>, options: IBackoffSettings, cancellationSignal: CancellationSignal): Promise<T>;
 /**
  * Lightweight version of the request algorithm, this time with only a simple
- * Observable given.
+ * Promise given.
  * @param {Function} request$
  * @param {Object} options
  * @returns {Observable}
  */
-export declare function tryRequestObservableWithBackoff<T>(request$: Observable<T>, options: IBackoffOptions): Observable<IBackoffEvent<T>>;
+export declare function tryRequestPromiseWithBackoff<T>(performRequest: () => Promise<T>, options: IBackoffSettings, cancellationSignal: CancellationSignal): Promise<T>;

package/dist/_esm5.processed/core/fetchers/utils/try_urls_with_backoff.js

@@ -13,12 +13,49 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { EMPTY, timer as observableTimer, } from "rxjs";
-import { catchError, map, mergeMap, startWith, } from "rxjs/operators";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { isOffline } from "../../../compat";
 import { CustomLoaderError, isKnownError, NetworkErrorTypes, RequestError, } from "../../../errors";
 import log from "../../../log";
+import cancellableSleep from "../../../utils/cancellable_sleep";
 import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
+import PPromise from "../../../utils/promise";
+import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Called on a loader error.
  * Returns whether the loader request should be retried.
@@ -76,32 +113,29 @@ function isOfflineRequestError(error) {
     }
     return false; // under doubt, return false
 }
-var REQUEST_ERROR_TYPES;
-(function (REQUEST_ERROR_TYPES) {
-    REQUEST_ERROR_TYPES[REQUEST_ERROR_TYPES["None"] = 0] = "None";
-    REQUEST_ERROR_TYPES[REQUEST_ERROR_TYPES["Regular"] = 1] = "Regular";
-    REQUEST_ERROR_TYPES[REQUEST_ERROR_TYPES["Offline"] = 2] = "Offline";
-})(REQUEST_ERROR_TYPES || (REQUEST_ERROR_TYPES = {}));
 /**
  * Guess the type of error obtained.
  * @param {*} error
  * @returns {number}
  */
 function getRequestErrorType(error) {
-    return isOfflineRequestError(error) ? REQUEST_ERROR_TYPES.Offline :
-        REQUEST_ERROR_TYPES.Regular;
+    return isOfflineRequestError(error) ? 2 /* Offline */ :
+        1 /* Regular */;
 }
 /**
  * Specific algorithm used to perform segment and manifest requests.
  *
  * Here how it works:
  *
- *   1. we give it one or multiple URLs available for the element we want to
- *      request, the request callback and some options
+ *   1. You give it one or multiple URLs available for the resource you want to
+ *      request (from the most important URL to the least important), the
+ *      request callback itself, and some options.
  *
  *   2. it tries to call the request callback with the first URL:
- *        - if it works as expected, it wrap the response in a `response` event.
- *        - if it fails, it emits a `retry` event and try with the next one.
+ *        - if it works as expected, it resolves the returned Promise with that
+ *          request's response.
+ *        - if it fails, it calls ther `onRetry` callback given with the
+ *          corresponding error and try with the next URL.
  *
  *   3. When all URLs have been tested (and failed), it decides - according to
  *      the error counters, configuration and errors received - if it can retry
@@ -109,26 +143,31 @@ function getRequestErrorType(error) {
  *        - If it can, it increments the corresponding error counter, wait a
  *          delay (based on an exponential backoff) and restart the same logic
  *          for all retry-able URL.
- *        - If it can't it just throws the error.
+ *        - If it can't it just reject the error through the returned Promise.
  *
  * Note that there are in fact two separate counters:
  *   - one for "offline" errors
  *   - one for other xhr errors
  * Both counters are resetted if the error type changes from an error to the
  * next.
- * @param {Array.<string} obs$
- * @param {Function} request$
+ *
+ * @param {Array.<string>} urls
+ * @param {Function} performRequest
  * @param {Object} options - Configuration options.
- * @returns {Observable}
+ * @param {Object} cancellationSignal
+ * @returns {Promise}
  */
-export default function tryURLsWithBackoff(urls, request$, options) {
-    var baseDelay = options.baseDelay, maxDelay = options.maxDelay, maxRetryRegular = options.maxRetryRegular, maxRetryOffline = options.maxRetryOffline;
+export function tryURLsWithBackoff(urls, performRequest, options, cancellationSignal) {
+    if (cancellationSignal.isCancelled) {
+        return PPromise.reject(cancellationSignal.cancellationError);
+    }
+    var baseDelay = options.baseDelay, maxDelay = options.maxDelay, maxRetryRegular = options.maxRetryRegular, maxRetryOffline = options.maxRetryOffline, onRetry = options.onRetry;
     var retryCount = 0;
-    var lastError = REQUEST_ERROR_TYPES.None;
+    var lastError = 0 /* None */;
     var urlsToTry = urls.slice();
     if (urlsToTry.length === 0) {
         log.warn("Fetchers: no URL given to `tryURLsWithBackoff`.");
-        return EMPTY;
+        return PPromise.reject(new Error("No URL to request"));
     }
     return tryURLsRecursively(urlsToTry[0], 0);
     /**
@@ -145,51 +184,82 @@ export default function tryURLsWithBackoff(urls, request$, options) {
      * @returns {Observable}
      */
     function tryURLsRecursively(url, index) {
-        return request$(url).pipe(map(function (res) { return ({ type: "response", value: res }); }), catchError(function (error) {
-            if (!shouldRetry(error)) { // ban this URL
-                if (urlsToTry.length <= 1) { // This was the last one, throw
-                    throw error;
+        return __awaiter(this, void 0, void 0, function () {
+            var res, error_1, newIndex, currentError, maxRetry, newIndex, delay, fuzzedDelay, nextURL;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 4]);
+                        return [4 /*yield*/, performRequest(url, cancellationSignal)];
+                    case 1:
+                        res = _a.sent();
+                        return [2 /*return*/, res];
+                    case 2:
+                        error_1 = _a.sent();
+                        if (TaskCanceller.isCancellationError(error_1)) {
+                            throw error_1;
+                        }
+                        if (!shouldRetry(error_1)) {
+                            // ban this URL
+                            if (urlsToTry.length <= 1) { // This was the last one, throw
+                                throw error_1;
+                            }
+                            // else, remove that element from the array and go the next URL
+                            urlsToTry.splice(index, 1);
+                            newIndex = index >= urlsToTry.length - 1 ? 0 :
+                                index;
+                            onRetry(error_1);
+                            if (cancellationSignal.isCancelled) {
+                                throw cancellationSignal.cancellationError;
+                            }
+                            return [2 /*return*/, tryURLsRecursively(urlsToTry[newIndex], newIndex)];
+                        }
+                        currentError = getRequestErrorType(error_1);
+                        maxRetry = currentError === 2 /* Offline */ ? maxRetryOffline :
+                            maxRetryRegular;
+                        if (currentError !== lastError) {
+                            retryCount = 0;
+                            lastError = currentError;
+                        }
+                        if (index < urlsToTry.length - 1) { // there is still URLs to test
+                            newIndex = index + 1;
+                            onRetry(error_1);
+                            if (cancellationSignal.isCancelled) {
+                                throw cancellationSignal.cancellationError;
+                            }
+                            return [2 /*return*/, tryURLsRecursively(urlsToTry[newIndex], newIndex)];
+                        }
+                        // Here, we were using the last element of the `urlsToTry` array.
+                        // Increment counter and restart with the first URL
+                        retryCount++;
+                        if (retryCount > maxRetry) {
+                            throw error_1;
+                        }
+                        delay = Math.min(baseDelay * Math.pow(2, retryCount - 1), maxDelay);
+                        fuzzedDelay = getFuzzedDelay(delay);
+                        nextURL = urlsToTry[0];
+                        onRetry(error_1);
+                        if (cancellationSignal.isCancelled) {
+                            throw cancellationSignal.cancellationError;
+                        }
+                        return [4 /*yield*/, cancellableSleep(fuzzedDelay, cancellationSignal)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/, tryURLsRecursively(nextURL, 0)];
+                    case 4: return [2 /*return*/];
                 }
-                // else, remove that element from the array and go the next URL
-                urlsToTry.splice(index, 1);
-                var newIndex = index >= urlsToTry.length - 1 ? 0 :
-                    index;
-                return tryURLsRecursively(urlsToTry[newIndex], newIndex)
-                    .pipe(startWith({ type: "retry", value: error }));
-            }
-            var currentError = getRequestErrorType(error);
-            var maxRetry = currentError === REQUEST_ERROR_TYPES.Offline ? maxRetryOffline :
-                maxRetryRegular;
-            if (currentError !== lastError) {
-                retryCount = 0;
-                lastError = currentError;
-            }
-            if (index < urlsToTry.length - 1) { // there is still URLs to test
-                var newIndex = index + 1;
-                return tryURLsRecursively(urlsToTry[newIndex], newIndex)
-                    .pipe(startWith({ type: "retry", value: error }));
-            }
-            // Here, we were using the last element of the `urlsToTry` array.
-            // Increment counter and restart with the first URL
-            retryCount++;
-            if (retryCount > maxRetry) {
-                throw error;
-            }
-            var delay = Math.min(baseDelay * Math.pow(2, retryCount - 1), maxDelay);
-            var fuzzedDelay = getFuzzedDelay(delay);
-            var nextURL = urlsToTry[0];
-            return observableTimer(fuzzedDelay).pipe(mergeMap(function () { return tryURLsRecursively(nextURL, 0); }), startWith({ type: "retry", value: error }));
-        }));
+            });
+        });
     }
 }
 /**
  * Lightweight version of the request algorithm, this time with only a simple
- * Observable given.
+ * Promise given.
  * @param {Function} request$
  * @param {Object} options
  * @returns {Observable}
  */
-export function tryRequestObservableWithBackoff(request$, options) {
+export function tryRequestPromiseWithBackoff(performRequest, options, cancellationSignal) {
     // same than for a single unknown URL
-    return tryURLsWithBackoff([null], function () { return request$; }, options);
+    return tryURLsWithBackoff([null], performRequest, options, cancellationSignal);
 }

package/dist/_esm5.processed/core/init/create_eme_manager.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { merge as observableMerge, of as observableOf, } from "rxjs";
-import { map } from "rxjs/operators";
+import { map, merge as observableMerge, of as observableOf, } from "rxjs";
 import { events, hasEMEAPIs, } from "../../compat/";
 import { EncryptedMediaError } from "../../errors";
 import features from "../../features";

package/dist/_esm5.processed/core/init/create_media_source.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable, } from "rxjs";
-import { mapTo, mergeMap, take, } from "rxjs/operators";
+import { map, mergeMap, Observable, take, } from "rxjs";
 import { clearElementSrc, events, MediaSource_, } from "../../compat";
 import { MediaError } from "../../errors";
 import log from "../../log";
@@ -36,7 +35,7 @@ function resetMediaSource(mediaElement, mediaSource, mediaSourceURL) {
             var sourceBuffer = sourceBuffers[i];
             try {
                 if (readyState === "open") {
-                    log.info("Init: Removing SourceBuffer from mediaSource", sourceBuffer);
+                    log.info("Init: Removing SourceBuffer from mediaSource");
                     sourceBuffer.abort();
                 }
                 mediaSource.removeSourceBuffer(sourceBuffer);
@@ -103,6 +102,6 @@ function createMediaSource(mediaElement) {
  */
 export default function openMediaSource(mediaElement) {
     return createMediaSource(mediaElement).pipe(mergeMap(function (mediaSource) {
-        return onSourceOpen$(mediaSource).pipe(take(1), mapTo(mediaSource));
+        return onSourceOpen$(mediaSource).pipe(take(1), map(function () { return mediaSource; }));
     }));
 }

package/dist/_esm5.processed/core/init/create_stream_playback_observer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 Manifest from "../../manifest";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { IReadOnlyPlaybackObserver, PlaybackObserver } from "../api";
+import { IStreamOrchestratorPlaybackObservation } from "../stream";
+/** Arguments needed to create the Stream's version of the PlaybackObserver. */
+export interface IStreamPlaybackObserverArguments {
+    /** If true, the player will auto-play when `initialPlayPerformed` becomes `true`. */
+    autoPlay: boolean;
+    /** Becomes `true` after the initial play has been taken care of. */
+    initialPlayPerformed: IReadOnlySharedReference<boolean>;
+    /** Becomes `true` after the initial seek has been taken care of. */
+    initialSeekPerformed: IReadOnlySharedReference<boolean>;
+    /** The last speed requested by the user. */
+    speed: IReadOnlySharedReference<number>;
+    /** The time the player will seek when `initialSeekPerformed` becomes `true`. */
+    startTime: number;
+}
+/**
+ * Create PlaybackObserver for the `Stream` part of the code.
+ * @param {Object} playbackObserver
+ * @param {Object} args
+ * @returns {Observable}
+ */
+export default function createStreamPlaybackObserver(manifest: Manifest, playbackObserver: PlaybackObserver, { autoPlay, initialPlayPerformed, initialSeekPerformed, speed, startTime }: IStreamPlaybackObserverArguments): IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>;

package/dist/_esm5.processed/core/init/create_stream_playback_observer.js

@@ -0,0 +1,50 @@
+/**
+ * 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 { combineLatest as observableCombineLatest, map, } from "rxjs";
+/**
+ * Create PlaybackObserver for the `Stream` part of the code.
+ * @param {Object} playbackObserver
+ * @param {Object} args
+ * @returns {Observable}
+ */
+export default function createStreamPlaybackObserver(manifest, playbackObserver, _a) {
+    var autoPlay = _a.autoPlay, initialPlayPerformed = _a.initialPlayPerformed, initialSeekPerformed = _a.initialSeekPerformed, speed = _a.speed, startTime = _a.startTime;
+    return playbackObserver.deriveReadOnlyObserver(function mapObservable(observation$) {
+        return observableCombineLatest([observation$, speed.asObservable()]).pipe(map(function (_a) {
+            var observation = _a[0], lastSpeed = _a[1];
+            return {
+                liveGap: manifest.isLive ?
+                    manifest.getMaximumPosition() - observation.position :
+                    undefined,
+                position: observation.position,
+                duration: observation.duration,
+                isPaused: initialPlayPerformed.getValue() ? observation.paused :
+                    !autoPlay,
+                readyState: observation.readyState,
+                speed: lastSpeed,
+                // wantedTimeOffset is an offset to add to the timing's current time to have
+                // the "real" wanted position.
+                // For now, this is seen when the media element has not yet seeked to its
+                // initial position, the currentTime will most probably be 0 where the
+                // effective starting position will be _startTime_.
+                // Thus we initially set a wantedTimeOffset equal to startTime.
+                wantedTimeOffset: initialSeekPerformed.getValue() ?
+                    0 :
+                    startTime - observation.position,
+            };
+        }));
+    });
+}

package/dist/_esm5.processed/core/init/duration_updater.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, defer as observableDefer, EMPTY, fromEvent as observableFromEvent, interval as observableInterval, merge as observableMerge, of as observableOf, } from "rxjs";
-import { catchError, distinctUntilChanged, filter, ignoreElements, map, mapTo, mergeMap, startWith, switchMap, take, tap, } from "rxjs/operators";
+import { catchError, combineLatest as observableCombineLatest, defer as observableDefer, distinctUntilChanged, EMPTY, filter, fromEvent as observableFromEvent, ignoreElements, interval as observableInterval, map, merge as observableMerge, mergeMap, of as observableOf, startWith, switchMap, take, tap, } from "rxjs";
 import { onSourceOpen$, onSourceClose$, onSourceEnded$, } from "../../compat/event_listeners";
 import log from "../../log";
 import { fromEvent } from "../../utils/event_emitter";
@@ -32,7 +31,7 @@ var YEAR_IN_SECONDS = 365 * 24 * 3600;
 export default function DurationUpdater(manifest, mediaSource) {
     return observableDefer(function () {
         var lastDurationUpdate;
-        return setMediaSourceDuration(mediaSource, manifest, undefined).pipe(mergeMap(function (initialDurationUpdate) {
+        return setMediaSourceDuration(mediaSource, manifest).pipe(mergeMap(function (initialDurationUpdate) {
             // only update `lastDurationUpdate` if the MediaSource's duration has
             // been updated.
             if (initialDurationUpdate !== null) {
@@ -43,7 +42,13 @@ export default function DurationUpdater(manifest, mediaSource) {
                     lastDurationUpdate = durationUpdate;
                 }
             }));
-        }), ignoreElements());
+        }), 
+        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+        // first type parameter as `any` instead of the perfectly fine `unknown`,
+        // leading to linter issues, as it forbids the usage of `any`.
+        // This is why we're disabling the eslint rule.
+        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
+        ignoreElements());
     });
 }
 /**
@@ -109,13 +114,16 @@ function whenSourceBuffersEndedUpdates$(sourceBuffers) {
         return observableOf(undefined);
     }
     var sourceBufferUpdatingStatuses = [];
-    for (var i = 0; i < sourceBuffers.length; i++) {
+    var _loop_1 = function (i) {
         var sourceBuffer = sourceBuffers[i];
-        sourceBufferUpdatingStatuses.push(observableMerge(observableFromEvent(sourceBuffer, "updatestart").pipe(mapTo(true)), observableFromEvent(sourceBuffer, "update").pipe(mapTo(false)), observableInterval(500).pipe(mapTo(sourceBuffer.updating))).pipe(startWith(sourceBuffer.updating), distinctUntilChanged()));
+        sourceBufferUpdatingStatuses.push(observableMerge(observableFromEvent(sourceBuffer, "updatestart").pipe(map(function () { return true; })), observableFromEvent(sourceBuffer, "update").pipe(map(function () { return false; })), observableInterval(500).pipe(map(function () { return sourceBuffer.updating; }))).pipe(startWith(sourceBuffer.updating), distinctUntilChanged()));
+    };
+    for (var i = 0; i < sourceBuffers.length; i++) {
+        _loop_1(i);
     }
     return observableCombineLatest(sourceBufferUpdatingStatuses).pipe(filter(function (areUpdating) {
         return areUpdating.every(function (isUpdating) { return !isUpdating; });
-    }), mapTo(undefined));
+    }), map(function () { return undefined; }));
 }
 /**
  * Emit a boolean that tells if the media source is opened or not.
@@ -123,5 +131,6 @@ function whenSourceBuffersEndedUpdates$(sourceBuffers) {
  * @returns {Object}
  */
 function isMediaSourceOpened$(mediaSource) {
-    return observableMerge(onSourceOpen$(mediaSource).pipe(mapTo(true)), onSourceEnded$(mediaSource).pipe(mapTo(false)), onSourceClose$(mediaSource).pipe(mapTo(false))).pipe(startWith(mediaSource.readyState === "open"), distinctUntilChanged());
+    return observableMerge(onSourceOpen$(mediaSource).pipe(map(function () { return true; })), onSourceEnded$(mediaSource).pipe(map(function () { return false; })), onSourceClose$(mediaSource).pipe(map(function () { return false; }))).pipe(startWith(mediaSource.readyState === "open"), distinctUntilChanged());
 }
+/* eslint-enable @typescript-eslint/no-unsafe-argument */

package/dist/_esm5.processed/{transports/utils/return_parsed_manifest.d.ts → core/init/emit_loaded_event.d.ts}

@@ -14,14 +14,15 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import Manifest from "../../manifest";
-import { IManifestParserResponseEvent, IManifestParserWarningEvent } from "../types";
+import { IPlaybackObservation } from "../api";
+import SegmentBuffersStore from "../segment_buffers";
+import { ILoadedEvent } from "./types";
 /**
- * As a Manifest instance is obtained, emit the right `warning` events
- * (according to the Manifest's `parsingErrors` property`) followed by the right
- * `parsed` event, as expected from a Manifest parser.
- * @param {Manifest} manifest
- * @param {string|undefined} url
+ * Emit a `ILoadedEvent` once the content can be considered as loaded.
+ * @param {Observable} observation$
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object|null} segmentBuffersStore
+ * @param {boolean} isDirectfile - `true` if this is a directfile content
  * @returns {Observable}
  */
-export default function returnParsedManifest(manifest: Manifest, url?: string): Observable<IManifestParserWarningEvent | IManifestParserResponseEvent>;
+export default function emitLoadedEvent(observation$: Observable<IPlaybackObservation>, mediaElement: HTMLMediaElement, segmentBuffersStore: SegmentBuffersStore | null, isDirectfile: boolean): Observable<ILoadedEvent>;

package/dist/_esm5.processed/core/init/emit_loaded_event.js

@@ -0,0 +1,47 @@
+/**
+ * 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 { take, } from "rxjs";
+import { shouldValidateMetadata, shouldWaitForDataBeforeLoaded, } from "../../compat";
+import filterMap from "../../utils/filter_map";
+import EVENTS from "./events_generators";
+/**
+ * Emit a `ILoadedEvent` once the content can be considered as loaded.
+ * @param {Observable} observation$
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object|null} segmentBuffersStore
+ * @param {boolean} isDirectfile - `true` if this is a directfile content
+ * @returns {Observable}
+ */
+export default function emitLoadedEvent(observation$, mediaElement, segmentBuffersStore, isDirectfile) {
+    return observation$.pipe(filterMap(function (observation) {
+        if (observation.rebuffering !== null ||
+            observation.freezing !== null ||
+            observation.readyState === 0) {
+            return null;
+        }
+        if (!shouldWaitForDataBeforeLoaded(isDirectfile, mediaElement.hasAttribute("playsinline"))) {
+            return mediaElement.duration > 0 ? EVENTS.loaded(segmentBuffersStore) :
+                null;
+        }
+        if (observation.readyState >= 3 && observation.currentRange !== null) {
+            if (!shouldValidateMetadata() || mediaElement.duration > 0) {
+                return EVENTS.loaded(segmentBuffersStore);
+            }
+            return null;
+        }
+        return null;
+    }, null), take(1));
+}

package/dist/_esm5.processed/core/init/end_of_stream.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, merge as observableMerge, of as observableOf, race as observableRace, } from "rxjs";
-import { mergeMap, startWith, switchMap, take, takeLast, } from "rxjs/operators";
+import { defer as observableDefer, merge as observableMerge, mergeMap, of as observableOf, race as observableRace, startWith, switchMap, take, takeLast, } from "rxjs";
 import { events } from "../../compat";
 import log from "../../log";
 var onRemoveSourceBuffers$ = events.onRemoveSourceBuffers$, onSourceOpen$ = events.onSourceOpen$, onUpdate$ = events.onUpdate$;