rx-player 3.26.1 → 3.26.2

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.d.ts

@@ -13,24 +13,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable, Subject } from "rxjs";
+import { Observable } from "rxjs";
 import { ICustomError } from "../../../errors";
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
-import { ISegmentParserParsedInitSegment, ISegmentParserParsedSegment, ISegmentPipeline } from "../../../transports";
-import { IABRMetricsEvent, IABRRequestBeginEvent, IABRRequestEndEvent, IABRRequestProgressEvent } from "../../abr";
+import { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk, ISegmentPipeline } from "../../../transports";
+import { IABRMetricsEventValue, IABRRequestBeginEventValue, IABRRequestEndEventValue, IABRRequestProgressEventValue } from "../../abr";
 import { IBufferType } from "../../segment_buffers";
 /**
- * Create a function which will fetch and parse segments.
+ * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
+ * segments.
+ * An `ISegmentFetcher` also implements a retry mechanism, based on the given
+ * `options` argument, which may retry a segment request when it fails.
+ *
  * @param {string} bufferType
  * @param {Object} transport
- * @param {Subject} requests$
+ * @param {Object} callbacks
  * @param {Object} options
  * @returns {Function}
  */
-export default function createSegmentFetcher<LoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<LoadedFormat, TSegmentDataType>, requests$: Subject<IABRMetricsEvent | IABRRequestBeginEvent | IABRRequestProgressEvent | IABRRequestEndEvent>, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
+export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>, callbacks: ISegmentFetcherCreatorCallbacks, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
 export declare type ISegmentFetcher<TSegmentDataType> = (content: ISegmentLoaderContent) => Observable<ISegmentFetcherEvent<TSegmentDataType>>;
 /** Event sent by the SegmentFetcher when fetching a segment. */
-export declare type ISegmentFetcherEvent<TSegmentDataType> = ISegmentFetcherChunkCompleteEvent | ISegmentFetcherChunkEvent<TSegmentDataType> | ISegmentFetcherWarning;
+export declare type ISegmentFetcherEvent<TSegmentDataType> = ISegmentFetcherChunkEvent<TSegmentDataType> | ISegmentFetcherChunkCompleteEvent | ISegmentFetcherRetry;
 /**
  * Event sent when a new "chunk" of the segment is available.
  * A segment can contain n chunk(s) for n >= 0.
@@ -49,7 +53,7 @@ export interface ISegmentFetcherChunkEvent<TSegmentDataType> {
      * @param {number} initTimescale
      * @returns {Object}
      */
-    parse(initTimescale?: number): ISegmentParserParsedInitSegment<TSegmentDataType> | ISegmentParserParsedSegment<TSegmentDataType>;
+    parse(initTimescale?: number): ISegmentParserParsedInitChunk<TSegmentDataType> | ISegmentParserParsedMediaChunk<TSegmentDataType>;
 }
 /**
  * Event sent when all "chunk" of the segments have been communicated through
@@ -66,11 +70,38 @@ export interface ISegmentLoaderContent {
     representation: Representation;
     segment: ISegment;
 }
-/** An Error happened while loading (usually a request error). */
-export interface ISegmentFetcherWarning {
-    type: "warning";
+/**
+ * An Error happened while loading which led to a retry.
+ * The request is retried from scratch.
+ */
+export interface ISegmentFetcherRetry {
+    type: "retry";
     value: ICustomError;
 }
+/**
+ * Callbacks that can be bound when creating an `ISegmentFetcher`.
+ * Those allows to be notified of an `ISegmentFetcher` various lifecycles and of
+ * network information.
+ */
+export interface ISegmentFetcherCreatorCallbacks {
+    /** Called when a segment request begins. */
+    onRequestBegin?: (arg: IABRRequestBeginEventValue) => void;
+    /** Called when progress information is available on a pending segment request. */
+    onProgress?: (arg: IABRRequestProgressEventValue) => void;
+    /**
+     * Called when a segment request ends (either because it completed, it failed
+     * or was canceled).
+     */
+    onRequestEnd?: (arg: IABRRequestEndEventValue) => void;
+    /**
+     * Called when network metrics linked to a segment request are available,
+     * once the request has terminated.
+     * This callback may be called before or after the corresponding
+     * `onRequestEnd` callback, you should not rely on the order between the two.
+     */
+    onMetrics?: (arg: IABRMetricsEventValue) => void;
+}
+/** Options allowing to configure an `ISegmentFetcher`'s behavior. */
 export interface ISegmentFetcherOptions {
     /**
      * Initial delay to wait if a request fails before making a new request, in

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.js

@@ -13,12 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable, } from "rxjs";
+import { Observable } from "rxjs";
 import config from "../../../config";
-import { formatError } from "../../../errors";
+import { formatError, } from "../../../errors";
+import log from "../../../log";
+import { getLoggableSegmentId, } from "../../../manifest";
 import arrayIncludes from "../../../utils/array_includes";
 import idGenerator from "../../../utils/id_generator";
 import InitializationSegmentCache from "../../../utils/initialization_segment_cache";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import objectAssign from "../../../utils/object_assign";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
@@ -26,14 +29,18 @@ import { tryURLsWithBackoff } from "../utils/try_urls_with_backoff";
 var DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = config.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = config.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = config.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = config.MAX_BACKOFF_DELAY_BASE;
 var generateRequestID = idGenerator();
 /**
- * Create a function which will fetch and parse segments.
+ * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
+ * segments.
+ * An `ISegmentFetcher` also implements a retry mechanism, based on the given
+ * `options` argument, which may retry a segment request when it fails.
+ *
  * @param {string} bufferType
  * @param {Object} transport
- * @param {Subject} requests$
+ * @param {Object} callbacks
  * @param {Object} options
  * @returns {Function}
  */
-export default function createSegmentFetcher(bufferType, pipeline, requests$, options) {
+export default function createSegmentFetcher(bufferType, pipeline, callbacks, options) {
     /**
      * Cache audio and video initialization segments.
      * This allows to avoid doing too many requests for what are usually very
@@ -46,11 +53,13 @@ export default function createSegmentFetcher(bufferType, pipeline, requests$, op
     /**
      * Fetch a specific segment.
      *
-     * This function returns an Observable which will fetch the segment on
+     * This function returns an Observable which will fetch segments on
      * subscription.
+     * If the corresponding request fails, it may retry it based on the given
+     * options.
+     *
      * This Observable will emit various events during that request lifecycle and
      * throw if the segment request(s) (including potential retries) fail.
-     *
      * The Observable will automatically complete once no events are left to be
      * sent.
      * @param {Object} content
@@ -58,25 +67,38 @@ export default function createSegmentFetcher(bufferType, pipeline, requests$, op
      */
     return function fetchSegment(content) {
         var segment = content.segment;
+        // used by logs
+        var segmentIdString = getLoggableSegmentId(content);
         return new Observable(function (obs) {
-            var _a;
-            // Retrieve from cache if it exists
-            var cached = cache !== undefined ? cache.get(content) :
-                null;
-            if (cached !== null) {
-                obs.next({ type: "chunk",
-                    parse: generateParserFunction(cached, false) });
-                obs.next({ type: "chunk-complete" });
-                obs.complete();
-                return undefined;
-            }
-            var id = generateRequestID();
-            requests$.next({ type: "requestBegin",
-                value: { duration: segment.duration,
-                    time: segment.time,
-                    requestTimestamp: performance.now(), id: id } });
+            var _a, _b;
+            var requestId = generateRequestID();
             var canceller = new TaskCanceller();
-            var hasRequestEnded = false;
+            /**
+             * If the request succeeded, set to the corresponding
+             * `IChunkCompleteInformation` object.
+             * If the request failed or was cancelled, set to `null`.
+             *
+             * Stays to `undefined` when the request is still pending.
+             */
+            var requestInfo;
+            /**
+             * Array containing one entry per loaded chunk, in chronological order.
+             * The boolean indicates if the chunk has been parsed at least once.
+             *
+             * This is used to know when all loaded chunks have been parsed, which
+             * can be useful to e.g. construct metrics about the loaded segment.
+             */
+            var parsedChunks = [];
+            /**
+             * Addition of the duration of each encountered and parsed chunks.
+             * Allows to have an idea of the real duration of the full segment once
+             * all chunks have been parsed.
+             *
+             * `undefined` if at least one of the parsed chunks has unknown duration.
+             */
+            var segmentDurationAcc = 0;
+            /** Set to `true` once network metrics have been sent. */
+            var metricsSent = false;
             var loaderCallbacks = {
                 /**
                  * Callback called when the segment loader has progress information on
@@ -84,12 +106,13 @@ export default function createSegmentFetcher(bufferType, pipeline, requests$, op
                  * @param {Object} info
                  */
                 onProgress: function (info) {
+                    var _a;
                     if (info.totalSize !== undefined && info.size < info.totalSize) {
-                        requests$.next({ type: "progress",
-                            value: { duration: info.duration,
-                                size: info.size,
-                                totalSize: info.totalSize,
-                                timestamp: performance.now(), id: id } });
+                        (_a = callbacks.onProgress) === null || _a === void 0 ? void 0 : _a.call(callbacks, { duration: info.duration,
+                            size: info.size,
+                            totalSize: info.totalSize,
+                            timestamp: performance.now(),
+                            id: requestId });
                     }
                 },
                 /**
@@ -103,8 +126,24 @@ export default function createSegmentFetcher(bufferType, pipeline, requests$, op
                         parse: generateParserFunction(chunkData, true) });
                 },
             };
-            tryURLsWithBackoff((_a = segment.mediaURLs) !== null && _a !== void 0 ? _a : [null], callLoaderWithUrl, objectAssign({ onRetry: onRetry }, options), canceller.signal)
+            // Retrieve from cache if it exists
+            var cached = cache !== undefined ? cache.get(content) :
+                null;
+            if (cached !== null) {
+                log.debug("SF: Found wanted segment in cache", segmentIdString);
+                obs.next({ type: "chunk",
+                    parse: generateParserFunction(cached, false) });
+                obs.next({ type: "chunk-complete" });
+                obs.complete();
+                return undefined;
+            }
+            log.debug("SF: Beginning request", segmentIdString);
+            (_a = callbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(callbacks, { requestTimestamp: performance.now(),
+                id: requestId, content: content });
+            tryURLsWithBackoff((_b = segment.mediaURLs) !== null && _b !== void 0 ? _b : [null], callLoaderWithUrl, objectAssign({ onRetry: onRetry }, options), canceller.signal)
                 .then(function (res) {
+                var _a;
+                log.debug("SF: Segment request ended with success", segmentIdString);
                 if (res.resultType === "segment-loaded") {
                     var loadedData = res.resultData.responseData;
                     if (cache !== undefined) {
@@ -117,38 +156,39 @@ export default function createSegmentFetcher(bufferType, pipeline, requests$, op
                     obs.next({ type: "chunk",
                         parse: generateParserFunction(res.resultData, false) });
                 }
-                hasRequestEnded = true;
+                log.debug("SF: Segment request ended with success", segmentIdString);
                 obs.next({ type: "chunk-complete" });
-                if ((res.resultType === "segment-loaded" ||
-                    res.resultType === "chunk-complete") &&
-                    res.resultData.size !== undefined &&
-                    res.resultData.duration !== undefined) {
-                    requests$.next({ type: "metrics",
-                        value: { size: res.resultData.size,
-                            duration: res.resultData.duration, content: content } });
+                if (res.resultType !== "segment-created") {
+                    requestInfo = res.resultData;
+                    sendNetworkMetricsIfAvailable();
                 }
                 if (!canceller.isUsed) {
                     // The current Observable could have been canceled as a result of one
                     // of the previous `next` calls. In that case, we don't want to send
                     // a "requestEnd" again as it has already been sent on cancellation.
                     //
-                    // Note that we only perform this check for `"requestEnd"` on
+                    // Note that we only perform this check for `onRequestEnd` on
                     // purpose. Observable's events should have been ignored by RxJS if
                     // the Observable has already been canceled and we don't care if
                     // `"metrics"` is sent there.
-                    requests$.next({ type: "requestEnd", value: { id: id } });
+                    (_a = callbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(callbacks, { id: requestId });
                 }
                 obs.complete();
             })
                 .catch(function (err) {
-                hasRequestEnded = true;
+                log.debug("SF: Segment request failed", segmentIdString);
+                requestInfo = null;
                 obs.error(errorSelector(err));
             });
             return function () {
-                if (!hasRequestEnded) {
-                    canceller.cancel();
-                    requests$.next({ type: "requestEnd", value: { id: id } });
+                var _a;
+                if (requestInfo !== undefined) {
+                    return; // Request already terminated
                 }
+                log.debug("SF: Segment request cancelled", segmentIdString);
+                requestInfo = null;
+                canceller.cancel();
+                (_a = callbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(callbacks, { id: requestId });
             };
             /**
              * Call a segment loader for the given URL with the right arguments.
@@ -166,10 +206,23 @@ export default function createSegmentFetcher(bufferType, pipeline, requests$, op
              * @returns {Function}
              */
             function generateParserFunction(data, isChunked) {
+                parsedChunks.push(false);
+                var parsedChunkId = parsedChunks.length - 1;
                 return function parse(initTimescale) {
                     var loaded = { data: data, isChunked: isChunked };
                     try {
-                        return parseSegment(loaded, content, initTimescale);
+                        var parsed = parseSegment(loaded, content, initTimescale);
+                        if (!parsedChunks[parsedChunkId]) {
+                            segmentDurationAcc = segmentDurationAcc !== undefined &&
+                                parsed.segmentType === "media" &&
+                                parsed.chunkInfos !== null &&
+                                parsed.chunkInfos.duration !== undefined ?
+                                segmentDurationAcc + parsed.chunkInfos.duration :
+                                undefined;
+                            parsedChunks[parsedChunkId] = true;
+                            sendNetworkMetricsIfAvailable();
+                        }
+                        return parsed;
                     }
                     catch (error) {
                         throw formatError(error, { defaultCode: "PIPELINE_PARSE_ERROR",
@@ -182,9 +235,28 @@ export default function createSegmentFetcher(bufferType, pipeline, requests$, op
              * @param {*} err
              */
             function onRetry(err) {
-                obs.next({ type: "warning",
+                obs.next({ type: "retry",
                     value: errorSelector(err) });
             }
+            /**
+             * Send netork metrics if they haven't yet been sent and if all data to
+             * define them is available.
+             */
+            function sendNetworkMetricsIfAvailable() {
+                var _a;
+                if (metricsSent) {
+                    return;
+                }
+                if (!isNullOrUndefined(requestInfo) &&
+                    requestInfo.size !== undefined &&
+                    requestInfo.requestDuration !== undefined &&
+                    parsedChunks.length > 0 &&
+                    parsedChunks.every(function (isParsed) { return isParsed; })) {
+                    metricsSent = true;
+                    (_a = callbacks.onMetrics) === null || _a === void 0 ? void 0 : _a.call(callbacks, { size: requestInfo.size,
+                        requestDuration: requestInfo.requestDuration, content: content, segmentDuration: segmentDurationAcc });
+                }
+            }
         });
     };
 }

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher_creator.d.ts

@@ -13,23 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Subject } from "rxjs";
 import { ITransportPipelines } from "../../../transports";
-import { IABRMetricsEvent, IABRRequestBeginEvent, IABRRequestEndEvent, IABRRequestProgressEvent } from "../../abr";
 import { IBufferType } from "../../segment_buffers";
 import { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
-/** Options used by the `SegmentFetcherCreator`. */
-export interface ISegmentFetcherCreatorBackoffOptions {
-    /**
-     * Whether the content is played in a low-latency mode.
-     * This has an impact on default backoff delays.
-     */
-    lowLatencyMode: boolean;
-    /** Maximum number of time a request on error will be retried. */
-    maxRetryRegular: number | undefined;
-    /** Maximum number of time a request be retried when the user is offline. */
-    maxRetryOffline: number | undefined;
-}
+import { ISegmentFetcherCreatorCallbacks } from "./segment_fetcher";
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
@@ -38,12 +25,15 @@ export interface ISegmentFetcherCreatorBackoffOptions {
  *
  * @example
  * ```js
- * const creator = new SegmentFetcherCreator(transport);
+ * const creator = new SegmentFetcherCreator(transport, {
+ *   lowLatencyMode: false,
+ *   maxRetryRegular: Infinity,
+ *   maxRetryOffline: Infinity,
+ * });
  *
  * // 2 - create a new fetcher with its backoff options
  * const fetcher = creator.createSegmentFetcher("audio", {
- *   maxRetryRegular: Infinity,
- *   maxRetryOffline: Infinity,
+ *   // ... (lifecycle callbacks if wanted)
  * });
  *
  * // 3 - load a segment with a given priority
@@ -85,9 +75,20 @@ export default class SegmentFetcherCreator {
      * Create a segment fetcher, allowing to easily perform segment requests.
      * @param {string} bufferType - The type of buffer concerned (e.g. "audio",
      * "video", etc.)
-     * @param {Subject} requests$ - Subject through which request-related events
-     * (such as those needed by the ABRManager) will be sent.
+     * @param {Object} callbacks
      * @returns {Object}
      */
-    createSegmentFetcher(bufferType: IBufferType, requests$: Subject<IABRRequestBeginEvent | IABRRequestProgressEvent | IABRRequestEndEvent | IABRMetricsEvent>): IPrioritizedSegmentFetcher<unknown>;
+    createSegmentFetcher(bufferType: IBufferType, callbacks: ISegmentFetcherCreatorCallbacks): IPrioritizedSegmentFetcher<unknown>;
+}
+/** Options used by the `SegmentFetcherCreator`. */
+export interface ISegmentFetcherCreatorBackoffOptions {
+    /**
+     * Whether the content is played in a low-latency mode.
+     * This has an impact on default backoff delays.
+     */
+    lowLatencyMode: boolean;
+    /** Maximum number of time a request on error will be retried. */
+    maxRetryRegular: number | undefined;
+    /** Maximum number of time a request be retried when the user is offline. */
+    maxRetryOffline: number | undefined;
 }

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher_creator.js

@@ -26,12 +26,15 @@ var MIN_CANCELABLE_PRIORITY = config.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_
  *
  * @example
  * ```js
- * const creator = new SegmentFetcherCreator(transport);
+ * const creator = new SegmentFetcherCreator(transport, {
+ *   lowLatencyMode: false,
+ *   maxRetryRegular: Infinity,
+ *   maxRetryOffline: Infinity,
+ * });
  *
  * // 2 - create a new fetcher with its backoff options
  * const fetcher = creator.createSegmentFetcher("audio", {
- *   maxRetryRegular: Infinity,
- *   maxRetryOffline: Infinity,
+ *   // ... (lifecycle callbacks if wanted)
  * });
  *
  * // 3 - load a segment with a given priority
@@ -61,16 +64,14 @@ var SegmentFetcherCreator = /** @class */ (function () {
      * Create a segment fetcher, allowing to easily perform segment requests.
      * @param {string} bufferType - The type of buffer concerned (e.g. "audio",
      * "video", etc.)
-     * @param {Subject} requests$ - Subject through which request-related events
-     * (such as those needed by the ABRManager) will be sent.
+     * @param {Object} callbacks
      * @returns {Object}
      */
-    SegmentFetcherCreator.prototype.createSegmentFetcher = function (bufferType, requests$) {
+    SegmentFetcherCreator.prototype.createSegmentFetcher = function (bufferType, callbacks) {
         var backoffOptions = getSegmentFetcherOptions(bufferType, this._backoffOptions);
         var pipelines = this._transport[bufferType];
         // Types are very complicated here as they are per-type of buffer.
-        // This is the reason why `any` is used instead.
-        var segmentFetcher = createSegmentFetcher(bufferType, pipelines, requests$, backoffOptions);
+        var segmentFetcher = createSegmentFetcher(bufferType, pipelines, callbacks, backoffOptions);
         return applyPrioritizerToSegmentFetcher(this._prioritizer, segmentFetcher);
     };
     return SegmentFetcherCreator;

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";
@@ -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 */