rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

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

@@ -0,0 +1,457 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var browser_compatibility_types_1 = require("../../compat/browser_compatibility_types");
+var features_1 = require("../../features");
+var log_1 = require("../../log");
+var manifest_1 = require("../../manifest");
+var main_media_source_interface_1 = require("../../mse/main_media_source_interface");
+var worker_media_source_interface_1 = require("../../mse/worker_media_source_interface");
+var id_generator_1 = require("../../utils/id_generator");
+var is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+var task_canceller_1 = require("../../utils/task_canceller");
+var adaptive_1 = require("../adaptive");
+var cmcd_1 = require("../cmcd");
+var fetchers_1 = require("../fetchers");
+var cdn_prioritizer_1 = require("../fetchers/cdn_prioritizer");
+var thumbnail_fetcher_1 = require("../fetchers/thumbnails/thumbnail_fetcher");
+var segment_sinks_1 = require("../segment_sinks");
+var core_text_displayer_interface_1 = require("./core_text_displayer_interface");
+var FreezeResolver_1 = require("./FreezeResolver");
+var track_choice_setter_1 = require("./track_choice_setter");
+var utils_1 = require("./utils");
+/** Function allowing to associate a unique identifier to all created `MediaSource` */
+var generateMediaSourceId = (0, id_generator_1.default)();
+/**
+ * Class facilitating the workflows behind loading a new content for the
+ * RxPlayer Core:
+ *
+ *   - Handle Manifest fetching and Manifest updates.
+ *
+ *   - Handle the `MediaSource`'s creation and indirectly of its `SourceBuffer`s
+ *     as well as handling "MediaSource reloading".
+ *
+ *   - initialize various modules (`segmentQueueCreator`, CmcdDataBuilder`,
+ *     `RepresentationEstimator`) linked to the initialized content.
+ *
+ * You can start loading a content through the `initializeNewContent` method.
+ *
+ * When a content is linked to the `ContentPreparer` you can inspect the
+ * different initialized modules by calling its `getCurrentContent` method.
+ *
+ * @class ContentPreparer
+ */
+var ContentPreparer = /** @class */ (function () {
+    /**
+     * @param {Object} capabilities
+     * @param {boolean} capabilities.hasVideo - If `true`, we're playing on an
+     * element which has video capabilities.
+     * If `false`, we're only able to play audio, optionally with subtitles.
+     *
+     * Typically this boolean is `true` for `<video>` HTMLElement and `false` for
+     * `<audio>` HTMLElement.
+     */
+    function ContentPreparer(_a) {
+        var hasVideo = _a.hasVideo;
+        this._currentContent = null;
+        this._currentMediaSourceCanceller = new task_canceller_1.default("ContentPreparer MediaSource");
+        this._hasVideo = hasVideo;
+        var contentCanceller = new task_canceller_1.default("ContentPreparer");
+        this._contentCanceller = contentCanceller;
+    }
+    /**
+     * Start fetching the wanted content's Manifest and initializing the various
+     * modules stored by the `ContentPreparer` linked to that content.
+     *
+     * The returned Promise resolves with the parsed Manifest when those modules
+     * are all ready and you can thus begin to load the content.
+     *
+     * Reject if it failed to do so.
+     * @param {Object} context - Information on the content that should be
+     * initialized.
+     * @param {Object} corePlugins - Callbacks that may have been registered by
+     * the application if it loaded the core independently as a worker.
+     * @returns {Promise.<Object>}
+     */
+    ContentPreparer.prototype.initializeNewContent = function (sendMessage, context, 
+    /** Allows to filter which Representations can be choosen. */
+    throttlers, corePlugins) {
+        var _this = this;
+        return new Promise(function (res, rej) {
+            var _a, _b;
+            _this.disposeCurrentContent("new init");
+            var contentCanceller = _this._contentCanceller;
+            var currentMediaSourceCanceller = new task_canceller_1.default("ContentPreparer MediaSource");
+            _this._currentMediaSourceCanceller = currentMediaSourceCanceller;
+            currentMediaSourceCanceller.linkToSignal(contentCanceller.signal);
+            var contentId = context.contentId, url = context.url, hasText = context.hasText, transportOptions = context.transportOptions, useMseInWorker = context.useMseInWorker, enableRepresentationAvoidance = context.enableRepresentationAvoidance, transport = context.transport;
+            var manifest = null;
+            var transportFn = features_1.default.transports[transport];
+            if (typeof transportFn !== "function") {
+                rej(new Error("transport \"".concat(transport, "\" not supported. ") +
+                    "Did you add the corresponding feature?"));
+                return;
+            }
+            var transportPipelines = transportFn(__assign(__assign({}, transportOptions), extractExternalPlugins(transportOptions, corePlugins)));
+            var cmcdDataBuilder = context.cmcd === undefined ? null : new cmcd_1.default(context.cmcd);
+            var manifestFetcher = new fetchers_1.ManifestFetcher(url === undefined ? undefined : [url], transportPipelines, __assign({ cmcdDataBuilder: cmcdDataBuilder }, context.manifestRetryOptions));
+            var representationEstimator = (0, adaptive_1.default)({
+                initialBitrates: {
+                    audio: (_a = context.initialAudioBitrate) !== null && _a !== void 0 ? _a : 0,
+                    video: (_b = context.initialVideoBitrate) !== null && _b !== void 0 ? _b : 0,
+                },
+                lowLatencyMode: transportOptions.lowLatencyMode,
+                throttlers: throttlers,
+            });
+            var unbindRejectOnCancellation = currentMediaSourceCanceller.signal.register(function (error) {
+                rej(error);
+            });
+            var cdnPrioritizer = new cdn_prioritizer_1.default(contentCanceller.signal);
+            var segmentQueueCreator = new fetchers_1.SegmentQueueCreator(transportPipelines, cdnPrioritizer, cmcdDataBuilder, context.segmentRetryOptions);
+            var fetchThumbnailData = (0, thumbnail_fetcher_1.default)(transportPipelines.thumbnails, cdnPrioritizer);
+            var trackChoiceSetter = new track_choice_setter_1.default();
+            var _c = __read(createMediaSourceInterfaceAndSegmentSinksStore(sendMessage, contentId, {
+                useMseInWorker: useMseInWorker,
+                hasVideo: _this._hasVideo,
+                hasText: hasText,
+            }, currentMediaSourceCanceller.signal), 3), mediaSource = _c[0], segmentSinksStore = _c[1], coreTextSender = _c[2];
+            var freezeResolver = new FreezeResolver_1.default(segmentSinksStore);
+            _this._currentContent = {
+                cmcdDataBuilder: cmcdDataBuilder,
+                contentId: contentId,
+                enableRepresentationAvoidance: enableRepresentationAvoidance,
+                freezeResolver: freezeResolver,
+                mediaSource: mediaSource,
+                manifest: null,
+                manifestFetcher: manifestFetcher,
+                representationEstimator: representationEstimator,
+                segmentSinksStore: segmentSinksStore,
+                segmentQueueCreator: segmentQueueCreator,
+                fetchThumbnailData: fetchThumbnailData,
+                coreTextSender: coreTextSender,
+                trackChoiceSetter: trackChoiceSetter,
+                useMseInWorker: useMseInWorker,
+            };
+            mediaSource.addEventListener("mediaSourceOpen", function () {
+                checkIfReadyAndValidate();
+            }, currentMediaSourceCanceller.signal);
+            contentCanceller.signal.register(function (err) {
+                manifestFetcher.dispose(err.reason);
+            });
+            manifestFetcher.addEventListener("warning", function (err) {
+                sendMessage({
+                    type: "warning" /* CoreMessageType.Warning */,
+                    contentId: contentId,
+                    value: (0, utils_1.formatErrorForSender)(err),
+                });
+            }, contentCanceller.signal);
+            manifestFetcher.addEventListener("manifestReady", function (man) {
+                if (manifest !== null) {
+                    log_1.default.warn("Core", "Multiple `manifestReady` events, ignoring");
+                    return;
+                }
+                manifest = man;
+                if (_this._currentContent !== null) {
+                    _this._currentContent.manifest = manifest;
+                }
+                checkIfReadyAndValidate();
+            }, currentMediaSourceCanceller.signal);
+            manifestFetcher.addEventListener("error", function (err) {
+                sendMessage({
+                    type: "error" /* CoreMessageType.Error */,
+                    contentId: contentId,
+                    value: (0, utils_1.formatErrorForSender)(err),
+                });
+                rej(err);
+            }, contentCanceller.signal);
+            manifestFetcher.start();
+            function checkIfReadyAndValidate() {
+                if (manifest === null ||
+                    mediaSource.readyState === "closed" ||
+                    currentMediaSourceCanceller.isUsed()) {
+                    return;
+                }
+                updateCodecSupportInWorkerMode(manifest);
+                manifest.addEventListener("manifestUpdate", function (updates) {
+                    if (manifest === null) {
+                        // TODO log warn?
+                        return;
+                    }
+                    sendMessage({
+                        type: "manifest-update" /* CoreMessageType.ManifestUpdate */,
+                        contentId: contentId,
+                        value: { manifest: manifest, updates: updates },
+                    });
+                }, contentCanceller.signal);
+                unbindRejectOnCancellation();
+                res(manifest);
+            }
+        });
+    };
+    /**
+     * Get information on the current content prepared through the
+     * `initializeNewContent` method, or `null` if no content is currently
+     * prepared.
+     * @returns {Object|null}
+     */
+    ContentPreparer.prototype.getCurrentContent = function () {
+        return this._currentContent;
+    };
+    /**
+     * Schedule an update for the Manifest file,
+     *
+     * Do nothing if no content is currently prepared.
+     * @param {Object} settings - Various settings to configure the ways and
+     * moment at which the Manifest will be refreshed.
+     */
+    ContentPreparer.prototype.scheduleManifestRefresh = function (settings) {
+        var _a;
+        (_a = this._currentContent) === null || _a === void 0 ? void 0 : _a.manifestFetcher.scheduleManualRefresh(settings);
+    };
+    /**
+     * Change the MediaSource attached for the current content.
+     * It is assumed that main thread is already notified that such a reload is
+     * happening.
+     *
+     * The returned Promise resolves when it restarts being ready.
+     * @param {Function} sendMessage
+     * @returns {Promise}
+     */
+    ContentPreparer.prototype.reloadMediaSource = function (sendMessage) {
+        var _this = this;
+        this._currentMediaSourceCanceller.cancel("ContentPreparer MediaSource reload");
+        if (this._currentContent === null) {
+            return Promise.reject(new Error("CP: No content anymore"));
+        }
+        this._currentContent.trackChoiceSetter.reset();
+        this._currentMediaSourceCanceller = new task_canceller_1.default("ContentPreparer MediaSource");
+        var _a = __read(createMediaSourceInterfaceAndSegmentSinksStore(sendMessage, this._currentContent.contentId, {
+            useMseInWorker: this._currentContent.useMseInWorker,
+            hasVideo: this._hasVideo,
+            hasText: this._currentContent.coreTextSender !== null,
+        }, this._currentMediaSourceCanceller.signal), 3), mediaSourceInterface = _a[0], segmentSinksStore = _a[1], coreTextSender = _a[2];
+        this._currentContent.mediaSource = mediaSourceInterface;
+        this._currentContent.segmentSinksStore = segmentSinksStore;
+        this._currentContent.freezeResolver = new FreezeResolver_1.default(segmentSinksStore);
+        this._currentContent.coreTextSender = coreTextSender;
+        return new Promise(function (res, rej) {
+            mediaSourceInterface.addEventListener("mediaSourceOpen", function () {
+                res();
+            }, _this._currentMediaSourceCanceller.signal);
+            mediaSourceInterface.addEventListener("mediaSourceClose", function () {
+                rej(new Error("MediaSource ReadyState changed to close during init."));
+            }, _this._currentMediaSourceCanceller.signal);
+            _this._currentMediaSourceCanceller.signal.register(function (error) {
+                rej(error);
+            });
+        });
+    };
+    /**
+     * Dispose all resources linked to the currently preopared content if one and
+     * stop linking it to this `ContentPreparer`.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    ContentPreparer.prototype.disposeCurrentContent = function (reason) {
+        this._contentCanceller.cancel(reason);
+        this._contentCanceller = new task_canceller_1.default("ContentPreparer");
+    };
+    return ContentPreparer;
+}());
+exports.default = ContentPreparer;
+/**
+ * @param {Function} sendMessage
+ * @param {string} contentId
+ * @param {Object} capabilities
+ * @param {boolean} capabilities.useMseInWorker
+ * @param {boolean} capabilities.hasVideo
+ * @param {boolean} capabilities.hasText
+ * @param {Object} cancelSignal
+ * @returns {Array.<Object>}
+ */
+function createMediaSourceInterfaceAndSegmentSinksStore(sendMessage, contentId, capabilities, cancelSignal) {
+    var mediaSourceInterface;
+    if (capabilities.useMseInWorker) {
+        var mainMediaSource = new main_media_source_interface_1.default(generateMediaSourceId());
+        mediaSourceInterface = mainMediaSource;
+        var sentMediaSourceLink = void 0;
+        var handle = mainMediaSource.handle;
+        if (handle.type === "handle") {
+            sentMediaSourceLink = { type: "handle", value: handle.value };
+        }
+        else {
+            var url_1 = URL.createObjectURL(handle.value);
+            sentMediaSourceLink = { type: "url", value: url_1 };
+            cancelSignal.register(function () {
+                URL.revokeObjectURL(url_1);
+            });
+        }
+        sendMessage({
+            type: "attach-media-source" /* CoreMessageType.AttachMediaSource */,
+            contentId: contentId,
+            value: sentMediaSourceLink,
+            mediaSourceId: mediaSourceInterface.id,
+        }, [handle.value]);
+    }
+    else {
+        mediaSourceInterface = new worker_media_source_interface_1.default(generateMediaSourceId(), contentId, sendMessage);
+    }
+    var textSender = capabilities.hasText
+        ? new core_text_displayer_interface_1.default(contentId, sendMessage)
+        : null;
+    var hasVideo = capabilities.hasVideo;
+    var segmentSinksStore = new segment_sinks_1.default(mediaSourceInterface, hasVideo, textSender);
+    cancelSignal.register(function (err) {
+        segmentSinksStore.disposeAll(err.reason);
+        textSender === null || textSender === void 0 ? void 0 : textSender.stop(err.reason);
+        mediaSourceInterface.dispose(err.reason);
+    });
+    return [mediaSourceInterface, segmentSinksStore, textSender];
+}
+/**
+ * Set Representation.isCodecSupportedInWebWorker to true or false
+ * If the codec is supported in the current context.
+ * If MSE in worker is not available, the attribute is not set.
+ */
+function updateCodecSupportInWorkerMode(manifestToUpdate) {
+    var e_1, _a, e_2, _b, e_3, _c;
+    var _d, _e;
+    if ((0, is_null_or_undefined_1.default)(browser_compatibility_types_1.MediaSource_)) {
+        return;
+    }
+    var codecsMap = new Map();
+    try {
+        for (var _f = __values(manifestToUpdate.periods), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var period = _g.value;
+            var checkedAdaptations = __spreadArray(__spreadArray([], __read(((_d = period.adaptations.video) !== null && _d !== void 0 ? _d : [])), false), __read(((_e = period.adaptations.audio) !== null && _e !== void 0 ? _e : [])), false);
+            try {
+                for (var checkedAdaptations_1 = (e_2 = void 0, __values(checkedAdaptations)), checkedAdaptations_1_1 = checkedAdaptations_1.next(); !checkedAdaptations_1_1.done; checkedAdaptations_1_1 = checkedAdaptations_1.next()) {
+                    var adaptation = checkedAdaptations_1_1.value;
+                    try {
+                        for (var _h = (e_3 = void 0, __values(adaptation.representations)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                            var representation = _j.value;
+                            var codec = "".concat(representation.mimeType, ";codecs=\"").concat(representation.codecs[0], "\"");
+                            if (codecsMap.has(codec)) {
+                                representation.isCodecSupportedInWebWorker = codecsMap.get(codec);
+                            }
+                            else {
+                                var supported = browser_compatibility_types_1.MediaSource_.isTypeSupported(codec);
+                                representation.isCodecSupportedInWebWorker = supported;
+                                codecsMap.set(codec, supported);
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (checkedAdaptations_1_1 && !checkedAdaptations_1_1.done && (_b = checkedAdaptations_1.return)) _b.call(checkedAdaptations_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+/**
+ * Some functions may be defined by the API, we call those "plugins".
+ * This function parses and extract the actual function from the different
+ * ways an application can provide it to us.
+ * @param {Object} input - The API input
+ * @param {Object} corePlugins - Context on what identified functions are
+ * defined right now.
+ * @returns {Function}
+ */
+function extractExternalPlugins(input, corePlugins) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    var manifestLoader;
+    var segmentLoader;
+    var representationFilter;
+    if (typeof ((_a = input.representationFilter) === null || _a === void 0 ? void 0 : _a.fn) === "function") {
+        representationFilter = input.representationFilter.fn;
+    }
+    else if (typeof ((_b = input.representationFilter) === null || _b === void 0 ? void 0 : _b.eval) === "string") {
+        representationFilter = (0, manifest_1.createRepresentationFilterFromFnString)(input.representationFilter.eval);
+    }
+    else if (typeof ((_c = input.representationFilter) === null || _c === void 0 ? void 0 : _c.workerId) === "string") {
+        representationFilter = corePlugins.representationFilters.get(input.representationFilter.workerId);
+    }
+    if (typeof ((_d = input.manifestLoader) === null || _d === void 0 ? void 0 : _d.fn) === "function") {
+        manifestLoader = input.manifestLoader.fn;
+    }
+    else if (typeof ((_e = input.manifestLoader) === null || _e === void 0 ? void 0 : _e.workerId) === "string") {
+        manifestLoader = corePlugins.manifestLoaders.get(input.manifestLoader.workerId);
+    }
+    if (typeof ((_f = input.segmentLoader) === null || _f === void 0 ? void 0 : _f.fn) === "function") {
+        segmentLoader = input.segmentLoader.fn;
+    }
+    else if (typeof ((_g = input.segmentLoader) === null || _g === void 0 ? void 0 : _g.workerId) === "string") {
+        segmentLoader = corePlugins.segmentLoaders.get(input.segmentLoader.workerId);
+    }
+    return {
+        manifestLoader: manifestLoader,
+        segmentLoader: segmentLoader,
+        representationFilter: representationFilter,
+    };
+}

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

@@ -0,0 +1,195 @@
+/**
+ * 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 type { IStreamOrchestratorPlaybackObservation, IBufferType } from "../../core/types";
+import type { IManifest, IAdaptation, IPeriod } from "../../manifest";
+import type { IReadOnlyPlaybackObserver } from "../../playback_observer";
+import type { IPlayerError } from "../../public_types";
+import EventEmitter from "../../utils/event_emitter";
+/**
+ * Observes what's being played and take care of media events relating to time
+ * boundaries:
+ *   - Emits a `endingPositionChange` when the known maximum playable position
+ *     of the current content is known and every time it changes.
+ *   - Emits `endOfStream` API once segments have been pushed until the end and
+ *     `resumeStream` if downloads starts back.
+ *   - Emits a `periodChange` event when the currently-playing Period seemed to
+ *     have changed.
+ *   - emit "warning" events when what is being played is outside of the
+ *     Manifest range.
+ * @class ContentTimeBoundariesObserver
+ */
+export default class ContentTimeBoundariesObserver extends EventEmitter<IContentTimeBoundariesObserverEvent> {
+    /** Allows to interrupt everything the `ContentTimeBoundariesObserver` is doing. */
+    private _canceller;
+    /** Store information on every created "Streams". */
+    private _activeStreams;
+    /** The `Manifest` object linked to the current content. */
+    private _manifest;
+    /** Allows to calculate at any time maximum positions of the content */
+    private _maximumPositionCalculator;
+    /** Enumerate all possible buffer types in the current content. */
+    private _allBufferTypes;
+    /**
+     * Stores the `id` property of the last Period for which a `periodChange`
+     * event has been sent.
+     * Allows to avoid multiple times in a row `periodChange` for the same
+     * Period.
+     */
+    private _lastCurrentPeriodId;
+    /**
+     * @param {Object} manifest
+     * @param {Object} playbackObserver
+     */
+    constructor(manifest: IManifest, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, bufferTypes: IBufferType[]);
+    /**
+     * Returns an estimate of the current last position which may be played in
+     * the content at the moment.
+     * @returns {Object}
+     */
+    getCurrentEndingTime(): IEndingPositionInformation;
+    /**
+     * Method to call any time an Adaptation has been selected.
+     *
+     * That Adaptation switch will be considered as active until the
+     * `onPeriodCleared` method has been called for the same `bufferType` and
+     * `Period`, or until `dispose` is called.
+     * @param {string} bufferType - The type of buffer concerned by the Adaptation
+     * switch
+     * @param {Object} period - The Period concerned by the Adaptation switch
+     * @param {Object|null} adaptation - The Adaptation selected. `null` if the
+     * absence of `Adaptation` has been explicitely selected for this Period and
+     * buffer type (e.g. no video).
+     */
+    onAdaptationChange(bufferType: IBufferType, period: IPeriod, adaptation: IAdaptation | null): void;
+    /**
+     * Method to call any time a Representation has been selected.
+     *
+     * That Representation switch will be considered as active until the
+     * `onPeriodCleared` method has been called for the same `bufferType` and
+     * `Period`, or until `dispose` is called.
+     * @param {string} bufferType - The type of buffer concerned by the
+     * Representation switch
+     * @param {Object} period - The Period concerned by the Representation switch
+     */
+    onRepresentationChange(bufferType: IBufferType, period: IPeriod): void;
+    /**
+     * Method to call any time a Period and type combination is not considered
+     * anymore.
+     *
+     * Calling this method allows to signal that a previous Adaptation and/or
+     * Representation change respectively indicated by an `onAdaptationChange` and
+     * an `onRepresentationChange` call, are not active anymore.
+     * @param {string} bufferType - The type of buffer concerned
+     * @param {Object} period - The Period concerned
+     */
+    onPeriodCleared(bufferType: IBufferType, period: IPeriod): void;
+    /**
+     * Method to call when the last chronological segment for a given buffer type
+     * is known to have been loaded and is either pushed or in the process of
+     * being pushed to the corresponding MSE `SourceBuffer` or equivalent.
+     *
+     * This method can even be called multiple times in a row as long as the
+     * aforementioned condition is true, if it simplify your code's management.
+     * @param {string} bufferType
+     */
+    onLastSegmentFinishedLoading(bufferType: IBufferType): void;
+    /**
+     * Method to call to "cancel" a previous call to
+     * `onLastSegmentFinishedLoading`.
+     *
+     * That is, calling this method indicates that the last chronological segment
+     * of a given buffer type is now either not loaded or it is not known.
+     *
+     * This method can even be called multiple times in a row as long as the
+     * aforementioned condition is true, if it simplify your code's management.
+     * @param {string} bufferType
+     */
+    onLastSegmentLoadingResume(bufferType: IBufferType): void;
+    /**
+     * Free all resources used by the `ContentTimeBoundariesObserver` and cancels
+     * all recurring processes it performs.
+     * @param {string | undefined} reason - Human-inspectable reason behind the
+     * dispose. Used for debugging matters, especially for debug log
+     * inspection.
+     */
+    dispose(reason: string | undefined): void;
+    private _addActivelyLoadedPeriod;
+    private _removeActivelyLoadedPeriod;
+    private _checkCurrentPeriod;
+    private _getManifestEndTime;
+    private _lazilyCreateActiveStreamInfo;
+    private _checkEndOfStream;
+}
+export interface IEndingPositionInformation {
+    /**
+     * The new maximum known position (note that this is the ending position
+     * currently known of the current content, it might be superior to the last
+     * position at which segments are available and it might also evolve over
+     * time), in seconds.
+     */
+    endingPosition: number;
+    /**
+     * If `true`, the communicated `endingPosition` is the actual end of the content.
+     * It may still be updated due to a track change or to add precision, but it
+     * is still a (rough) estimate of the maximum position that content should
+     * have.
+     *
+     * If `false`, this is the currently known maximum position associated to
+     * the content, but the content is still evolving (typically, new media
+     * segments are still being generated) and as such it can still have a
+     * longer `endingPosition` in the future.
+     */
+    isEnd: boolean;
+}
+/**
+ * Events triggered by a `ContentTimeBoundariesObserver` where the keys are the
+ * event names and the value is the payload of those events.
+ */
+export interface IContentTimeBoundariesObserverEvent {
+    /** Triggered when a minor error is encountered. */
+    warning: IPlayerError;
+    /** Triggered when a new `Period` is currently playing. */
+    periodChange: IPeriod;
+    /**
+     * Triggered when the ending position of the currently-playing content became
+     * known or changed.
+     */
+    endingPositionChange: IEndingPositionInformation;
+    /**
+     * Triggered when the last possible chronological segment for all types of
+     * buffers has either been pushed or is being pushed to the corresponding
+     * MSE `SourceBuffer` or equivalent.
+     * As such, the `endOfStream` MSE API might from now be able to be called.
+     *
+     * Note that it is possible to receive this event even if `endOfStream` has
+     * already been called and even if an "endOfStream" event has already been
+     * triggered.
+     */
+    endOfStream: null;
+    /**
+     * Triggered when the last possible chronological segment for all types of
+     * buffers have NOT been pushed, or if it is not known whether is has been
+     * pushed, and as such any potential pending `endOfStream` MSE API call
+     * need to be cancelled.
+     *
+     * Note that it is possible to receive this event even if `endOfStream` has
+     * not been called and even if an "resumeStream" event has already been
+     * triggered.
+     */
+    resumeStream: null;
+}
+export type IContentTimeObserverPlaybackObservation = Pick<IStreamOrchestratorPlaybackObservation, "position">;
+//# sourceMappingURL=content_time_boundaries_observer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content_time_boundaries_observer.d.ts","sourceRoot":"","sources":["../../../../src/core/entry/content_time_boundaries_observer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,sCAAsC,EACtC,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EAEX,OAAO,EACR,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,YAAY,MAAM,2BAA2B,CAAC;AAMrD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,OAAO,6BAA8B,SAAQ,YAAY,CAAC,mCAAmC,CAAC;IAC1G,mFAAmF;IACnF,OAAO,CAAC,UAAU,CAAgB;IAElC,oDAAoD;IACpD,OAAO,CAAC,cAAc,CAAuC;IAE7D,2DAA2D;IAC3D,OAAO,CAAC,SAAS,CAAY;IAE7B,uEAAuE;IACvE,OAAO,CAAC,0BAA0B,CAA4B;IAE9D,kEAAkE;IAClE,OAAO,CAAC,eAAe,CAAgB;IAEvC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB,CAAgB;IAE5C;;;OAGG;gBAED,QAAQ,EAAE,SAAS,EACnB,gBAAgB,EAAE,yBAAyB,CAAC,sCAAsC,CAAC,EACnF,WAAW,EAAE,WAAW,EAAE;IA6D5B;;;;OAIG;IACI,oBAAoB,IAAI,0BAA0B;IAIzD;;;;;;;;;;;;OAYG;IACI,kBAAkB,CACvB,UAAU,EAAE,WAAW,EACvB,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,WAAW,GAAG,IAAI,GAC7B,IAAI;IA+BP;;;;;;;;;OASG;IACI,sBAAsB,CAAC,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAI7E;;;;;;;;;OASG;IACI,eAAe,CAAC,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAItE;;;;;;;;OAQG;IACI,4BAA4B,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI;IAQlE;;;;;;;;;;OAUG;IACI,0BAA0B,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI;IAQhE;;;;;;OAMG;IACI,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS;IAKzC,OAAO,CAAC,wBAAwB;IAQhC,OAAO,CAAC,2BAA2B;IAWnC,OAAO,CAAC,mBAAmB;IAkC3B,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,6BAA6B;IAYrC,OAAO,CAAC,iBAAiB;CAc1B;AAED,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;;;;;OAUG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,mCAAmC;IAClD,mDAAmD;IACnD,OAAO,EAAE,YAAY,CAAC;IACtB,0DAA0D;IAC1D,YAAY,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,oBAAoB,EAAE,0BAA0B,CAAC;IACjD;;;;;;;;;OASG;IACH,WAAW,EAAE,IAAI,CAAC;IAClB;;;;;;;;;OASG;IACH,YAAY,EAAE,IAAI,CAAC;CACpB;AAgPD,MAAM,MAAM,uCAAuC,GAAG,IAAI,CACxD,sCAAsC,EACtC,UAAU,CACX,CAAC"}