rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -1,124 +0,0 @@
-/**
- * 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 { concat as observableConcat, EMPTY, of as observableOf, } from "rxjs";
-import { catchError, map, mergeMap, } from "rxjs/operators";
-import assertUnreachable from "../../../utils/assert_unreachable";
-import castToObservable from "../../../utils/cast_to_observable";
-import objectAssign from "../../../utils/object_assign";
-import tryCatch from "../../../utils/rx-try_catch";
-import errorSelector from "../utils/error_selector";
-import tryURLsWithBackoff from "../utils/try_urls_with_backoff";
-/**
- * Returns a function allowing to load any wanted segment.
- *
- * The function returned takes in argument information about the wanted segment
- * and returns an Observable which will emit various events related to the
- * segment request (see ISegmentLoaderEvent).
- *
- * This observable will throw if, following the options given, the request and
- * possible retry all failed.
- *
- * This observable will complete after emitting all the segment's data.
- *
- * Type parameters:
- *   - T: type of the data emitted
- *
- * @param {Function} loader
- * @param {Object | undefined} cache
- * @param {Object} options
- * @returns {Function}
- */
-export default function createSegmentLoader(loader, cache, backoffOptions) {
-    /**
-     * Try to retrieve the segment from the cache and if not found call the
-     * pipeline's loader (with possible retries) to load it.
-     * @param {Object} loaderArgument - Context for the wanted segment.
-     * @returns {Observable}
-     */
-    function loadData(wantedContent) {
-        /**
-         * Call the Pipeline's loader with an exponential Backoff.
-         * @returns {Observable}
-         */
-        function startLoaderWithBackoff() {
-            var _a;
-            var request$ = function (url) {
-                var loaderArgument = objectAssign({ url: url }, wantedContent);
-                return observableConcat(observableOf({ type: "request", value: loaderArgument }), tryCatch(loader, loaderArgument));
-            };
-            return tryURLsWithBackoff((_a = wantedContent.segment.mediaURLs) !== null && _a !== void 0 ? _a : [null], request$, backoffOptions).pipe(catchError(function (error) {
-                throw errorSelector(error);
-            }), map(function (evt) {
-                if (evt.type === "retry") {
-                    return { type: "warning",
-                        value: errorSelector(evt.value) };
-                }
-                else if (evt.value.type === "request") {
-                    return evt.value;
-                }
-                var response = evt.value;
-                if (response.type === "data-loaded" && cache != null) {
-                    cache.add(wantedContent, response.value);
-                }
-                return evt.value;
-            }));
-        }
-        var dataFromCache = cache != null ? cache.get(wantedContent) :
-            null;
-        if (dataFromCache != null) {
-            return castToObservable(dataFromCache).pipe(map(function (response) { return ({ type: "cache", value: response }); }), catchError(startLoaderWithBackoff));
-        }
-        return startLoaderWithBackoff();
-    }
-    /**
-     * Load the corresponding segment.
-     * @param {Object} content
-     * @returns {Observable}
-     */
-    return function loadSegment(content) {
-        return loadData(content).pipe(mergeMap(function (arg) {
-            var metrics$;
-            if ((arg.type === "data-chunk-complete" || arg.type === "data-loaded") &&
-                arg.value.size !== undefined && arg.value.duration !== undefined) {
-                metrics$ = observableOf({ type: "metrics",
-                    value: { size: arg.value.size,
-                        duration: arg.value.duration,
-                        content: content } });
-            }
-            else {
-                metrics$ = EMPTY;
-            }
-            switch (arg.type) {
-                case "warning":
-                case "request":
-                case "progress":
-                    return observableOf(arg);
-                case "cache":
-                case "data-created":
-                case "data-loaded":
-                    return observableConcat(observableOf({ type: "data",
-                        value: arg.value }), metrics$);
-                case "data-chunk":
-                    return observableOf({ type: "chunk", value: arg.value });
-                case "data-chunk-complete":
-                    return observableConcat(observableOf({ type: "chunk-complete",
-                        value: null }), metrics$);
-                default:
-                    assertUnreachable(arg);
-            }
-        }));
-    };
-}

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

@@ -1,32 +0,0 @@
-/**
- * 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 config from "../../../config";
-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;
-/**
- * @param {string} bufferType
- * @param {Object}
- * @returns {Object}
- */
-export default function getSegmentBackoffOptions(bufferType, _a) {
-    var maxRetryRegular = _a.maxRetryRegular, maxRetryOffline = _a.maxRetryOffline, lowLatencyMode = _a.lowLatencyMode;
-    return { maxRetryRegular: bufferType === "image" ? 0 :
-            maxRetryRegular !== null && maxRetryRegular !== void 0 ? maxRetryRegular : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
-        maxRetryOffline: maxRetryOffline !== null && maxRetryOffline !== void 0 ? maxRetryOffline : DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
-        baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            INITIAL_BACKOFF_DELAY_BASE.REGULAR,
-        maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
-            MAX_BACKOFF_DELAY_BASE.REGULAR };
-}

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

@@ -1,38 +0,0 @@
-/**
- * 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 { catchError } from "rxjs/operators";
-import filterMap from "../../../utils/filter_map";
-import tryCatch from "../../../utils/rx-try_catch";
-import errorSelector from "./error_selector";
-import { tryRequestObservableWithBackoff, } from "./try_urls_with_backoff";
-export default function createRequestScheduler(backoffOptions, warning$) {
-    /**
-     * Allow the parser to schedule a new request.
-     * @param {Function} request - Function performing the request.
-     * @returns {Function}
-     */
-    return function scheduleRequest(request) {
-        return tryRequestObservableWithBackoff(tryCatch(request, undefined), backoffOptions).pipe(filterMap(function (evt) {
-            if (evt.type === "retry") {
-                warning$.next(errorSelector(evt.value));
-                return null;
-            }
-            return evt.value;
-        }, null), catchError(function (error) {
-            throw errorSelector(error);
-        }));
-    };
-}

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

@@ -1,34 +0,0 @@
-/**
- * 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 { Observable } from "rxjs";
-import Manifest from "../../manifest";
-import { IStreamOrchestratorClockTick } from "../stream";
-import { IInitClockTick } from "./types";
-export interface IStreamClockArguments {
-    autoPlay: boolean;
-    initialPlay$: Observable<unknown>;
-    initialSeek$: Observable<unknown>;
-    manifest: Manifest;
-    speed$: Observable<number>;
-    startTime: number;
-}
-/**
- * Create clock Observable for the `Stream` part of the code.
- * @param {Observable} initClock$
- * @param {Object} streamClockArgument
- * @returns {Observable}
- */
-export default function createStreamClock(initClock$: Observable<IInitClockTick>, { autoPlay, initialPlay$, initialSeek$, manifest, speed$, startTime }: IStreamClockArguments): Observable<IStreamOrchestratorClockTick>;

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

@@ -1,56 +0,0 @@
-/**
- * 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, merge as observableMerge, } from "rxjs";
-import { ignoreElements, map, tap, } from "rxjs/operators";
-/**
- * Create clock Observable for the `Stream` part of the code.
- * @param {Observable} initClock$
- * @param {Object} streamClockArgument
- * @returns {Observable}
- */
-export default function createStreamClock(initClock$, _a) {
-    var autoPlay = _a.autoPlay, initialPlay$ = _a.initialPlay$, initialSeek$ = _a.initialSeek$, manifest = _a.manifest, speed$ = _a.speed$, startTime = _a.startTime;
-    var initialPlayPerformed = false;
-    var initialSeekPerformed = false;
-    var updateIsPaused$ = initialPlay$.pipe(tap(function () { initialPlayPerformed = true; }), ignoreElements());
-    var updateTimeOffset$ = initialSeek$.pipe(tap(function () { initialSeekPerformed = true; }), ignoreElements());
-    var clock$ = observableCombineLatest([initClock$, speed$])
-        .pipe(map(function (_a) {
-        var tick = _a[0], speed = _a[1];
-        var isLive = manifest.isLive;
-        return {
-            position: tick.position,
-            getCurrentTime: tick.getCurrentTime,
-            duration: tick.duration,
-            isPaused: initialPlayPerformed ? tick.paused :
-                !autoPlay,
-            liveGap: isLive ? manifest.getMaximumPosition() - tick.position :
-                Infinity,
-            readyState: tick.readyState,
-            speed: speed,
-            stalled: tick.stalled,
-            // 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 ? 0 :
-                startTime - tick.position,
-        };
-    }));
-    return observableMerge(updateIsPaused$, updateTimeOffset$, clock$);
-}

package/dist/_esm5.processed/core/stream/utils.d.ts

@@ -1,60 +0,0 @@
-/**
- * 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 { Observable } from "rxjs";
-import { Period } from "../../manifest";
-import { INeedsMediaSourceReload } from "./types";
-/**
- * Switching to another `Adaptation` and or `Representation` can necessitate a
- * complete reload of the MediaSource.
- *
- * This is done through the `INeedsMediaSourceReload` event which among other
- * things indicate the position the player should seek to after "reloading".
- * That position depends on the playback conditions at the time of the switch.
- *
- * When you already know you have to reload, you can call this function to take
- * care of that complex behavior:
- *
- *   - If `period` is not being played when that function is called, this
- *     function will emit regularly the `INeedsMediaSourceReload` event after
- *     applying the given `deltaPos` value to the reloading position.
- *
- *   - If `period` is not being when that function is called, it emits regularly
- *     the `INeedsMediaSourceReload` without applying the given `deltaPos` value
- *     to the reloading position.
- *     This is because that value is only applied when the previous Adaptation
- *     or Representation for the current Period was being played and should not
- *     be for cases like entering the current Period, or seeking _into_ th
- *     current Period.
- *     The main point of that configuration variable being to give back some
- *     context, there is no context to give back on those cases (as the Period
- *     was not already playing).
- *
- * @param {Object} period - The Period linked to the Adaptation or
- * Representation that you want to switch to.
- * @param {Observable} clock$ - Observable emitting playback conditions.
- * Has to emit last playback conditions immediately on subscribe.
- * @param {number} deltaPos - If the concerned Period is playing at the time
- * this function is called, we will add this value, in seconds, to the current
- * position to indicate the position we should reload at.
- * This value allows to give back context (by replaying some media data) after
- * a switch.
- * @returns {Observable}
- */
-export default function reloadAfterSwitch(period: Period, clock$: Observable<{
-    getCurrentTime: () => number;
-    position: number;
-    isPaused: boolean;
-}>, deltaPos: number): Observable<INeedsMediaSourceReload>;

package/dist/_esm5.processed/core/stream/utils.js

@@ -1,70 +0,0 @@
-/**
- * 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 { of as observableOf, } from "rxjs";
-import { map, mergeMap, take, } from "rxjs/operators";
-import EVENTS from "./events_generators";
-/**
- * Switching to another `Adaptation` and or `Representation` can necessitate a
- * complete reload of the MediaSource.
- *
- * This is done through the `INeedsMediaSourceReload` event which among other
- * things indicate the position the player should seek to after "reloading".
- * That position depends on the playback conditions at the time of the switch.
- *
- * When you already know you have to reload, you can call this function to take
- * care of that complex behavior:
- *
- *   - If `period` is not being played when that function is called, this
- *     function will emit regularly the `INeedsMediaSourceReload` event after
- *     applying the given `deltaPos` value to the reloading position.
- *
- *   - If `period` is not being when that function is called, it emits regularly
- *     the `INeedsMediaSourceReload` without applying the given `deltaPos` value
- *     to the reloading position.
- *     This is because that value is only applied when the previous Adaptation
- *     or Representation for the current Period was being played and should not
- *     be for cases like entering the current Period, or seeking _into_ th
- *     current Period.
- *     The main point of that configuration variable being to give back some
- *     context, there is no context to give back on those cases (as the Period
- *     was not already playing).
- *
- * @param {Object} period - The Period linked to the Adaptation or
- * Representation that you want to switch to.
- * @param {Observable} clock$ - Observable emitting playback conditions.
- * Has to emit last playback conditions immediately on subscribe.
- * @param {number} deltaPos - If the concerned Period is playing at the time
- * this function is called, we will add this value, in seconds, to the current
- * position to indicate the position we should reload at.
- * This value allows to give back context (by replaying some media data) after
- * a switch.
- * @returns {Observable}
- */
-export default function reloadAfterSwitch(period, clock$, deltaPos) {
-    return clock$.pipe(take(1), // only the first (current) event interests us here
-    mergeMap(function (initialTick) {
-        var _a;
-        if (period.start <= initialTick.position &&
-            (period.end === undefined || period.end > initialTick.position)) {
-            // if the Period was playing at the time of the switch
-            var pos = initialTick.getCurrentTime() + deltaPos;
-            var reloadAt = Math.min(Math.max(period.start, pos), (_a = period.end) !== null && _a !== void 0 ? _a : Infinity);
-            return observableOf(EVENTS.needsMediaSourceReload(period, reloadAt, !initialTick.isPaused));
-        }
-        // If the Period was not playing, just ask to reload to the exact same position
-        return clock$.pipe(map(function (tick) { return EVENTS.needsMediaSourceReload(period, tick.getCurrentTime(), !tick.isPaused); }));
-    }));
-}

package/dist/_esm5.processed/parsers/manifest/dash/common/extract_minimum_availability_time_offset.d.ts

@@ -1,31 +0,0 @@
-/**
- * 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 { IBaseUrlIntermediateRepresentation } from "../node_parser_types";
-/**
- * From 0 to N baseURL elements takes the minimum availabilityTimeOffset
- * possible.
- *
- * `0` if no baseURL was given (which means `no delay added`: coherent with how
- * this value is used).
- *
- * Taking the minimum time allow to simplify its processing:
- * Instead of having multiple URL each with a different pool of available
- * segment at a given instant, let's always consider every URLs by aligning with
- * the one with the most segment.
- *
- * @param {Array.<Object>} baseURLs
- */
-export default function extractMinimumAvailabilityTimeOffset(baseURLs: IBaseUrlIntermediateRepresentation[]): number;

package/dist/_esm5.processed/parsers/manifest/dash/common/extract_minimum_availability_time_offset.js

@@ -1,37 +0,0 @@
-/**
- * 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.
- */
-/**
- * From 0 to N baseURL elements takes the minimum availabilityTimeOffset
- * possible.
- *
- * `0` if no baseURL was given (which means `no delay added`: coherent with how
- * this value is used).
- *
- * Taking the minimum time allow to simplify its processing:
- * Instead of having multiple URL each with a different pool of available
- * segment at a given instant, let's always consider every URLs by aligning with
- * the one with the most segment.
- *
- * @param {Array.<Object>} baseURLs
- */
-export default function extractMinimumAvailabilityTimeOffset(baseURLs) {
-    return baseURLs.length === 0 ?
-        0 :
-        baseURLs.reduce(function (acc, baseURL) {
-            var _a;
-            return Math.min((_a = baseURL.attributes.availabilityTimeOffset) !== null && _a !== void 0 ? _a : 0, acc);
-        }, Infinity);
-}

package/dist/_esm5.processed/transports/utils/return_parsed_manifest.js

@@ -1,32 +0,0 @@
-/**
- * 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 { concat as observableConcat, of as observableOf, } from "rxjs";
-/**
- * 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
- * @returns {Observable}
- */
-export default function returnParsedManifest(manifest, url) {
-    var warningEvts$ = observableOf.apply(void 0, manifest.parsingErrors.map(function (error) { return ({
-        type: "warning",
-        value: error,
-    }); }));
-    return observableConcat(warningEvts$, observableOf({ type: "parsed",
-        value: { manifest: manifest, url: url } }));
-}

package/scripts/clean-up_builds

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-# Clean-up builds
-# =================
-#
-# This script removes the directories automatically generated when doing a
-# modular build.
-#
-# You can call it at any time, it will not update any staged file.
-
-set -e
-rm -rf dist/_esm5.processed
-rm -rf dist/_esm5.raw
-
-rm -rf features
-rm -rf minimal
-rm -rf experimental
-rm -rf tools