rx-player 3.26.1 → 3.26.2

package/dist/_esm5.processed/transports/types.d.ts

@@ -179,7 +179,8 @@ export interface ISegmentPipeline<TLoadedFormat, TParsedSegmentDataFormat> {
  */
 export declare type ISegmentLoader<TLoadedFormat> = (url: string | null, content: ISegmentContext, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<TLoadedFormat>) => Promise<ISegmentLoaderResultSegmentCreated<TLoadedFormat> | ISegmentLoaderResultSegmentLoaded<TLoadedFormat> | ISegmentLoaderResultChunkedComplete>;
 /**
- * Segment parser function, allowing to parse a segment of any type.
+ * Segment parser function, allowing to parse a chunk (which may be a sub-part
+ * of a segment) of any type.
  *
  * This function will throw if it encounters any error it cannot recover from.
  */
@@ -211,15 +212,15 @@ initTimescale: number | undefined) =>
  * The parsed data.
  *
  * Can be of two types:
- *   - `ISegmentParserParsedInitSegment`: When the parsed segment was an
+ *   - `ISegmentParserParsedInitChunk`: When the parsed chunk was part of an
  *     initialization segment.
  *     Such segments only serve to initialize the decoder and do not contain
  *     any decodable media data.
- *   - `ISegmentParserParsedSegment`: When the parsed segment was a media
- *     segment.
+ *   - `ISegmentParserParsedMediaChunk`: When the parsed chunk was part of a
+ *     media segment.
  *     Such segments generally contain decodable media data.
  */
-ISegmentParserParsedInitSegment<TParsedSegmentDataFormat> | ISegmentParserParsedSegment<TParsedSegmentDataFormat>;
+ISegmentParserParsedInitChunk<TParsedSegmentDataFormat> | ISegmentParserParsedMediaChunk<TParsedSegmentDataFormat>;
 export interface IManifestParserOptions {
     /**
      * If set, offset to add to `performance.now()` to obtain the current
@@ -317,7 +318,10 @@ export interface IManifestParserRequestNeeded {
 export interface IChunkTimeInfo {
     /**
      * Difference between the latest and the earliest presentation time
-     * available in that segment, in seconds.
+     * available in that chunk, in seconds.
+     *
+     * If multiple chunks are present in a single segment (e.g. low-latency CMAF
+     * chunks, this is only the duration of the current chunk).
      *
      * Either `undefined` or set to `0` for an initialization segment.
      */
@@ -475,6 +479,7 @@ export interface ISegmentLoaderCallbacks<T> {
      */
     onNewChunk: (data: T) => void;
 }
+/** Information related to a pending Segment request progressing. */
 export interface ISegmentLoadingProgressInformation {
     /** Time since the beginning of the request so far, in seconds. */
     duration: number;
@@ -517,7 +522,7 @@ export interface ISegmentLoaderResultSegmentCreated<T> {
 /** Data emitted in a `ISegmentLoaderResultChunkedComplete`. */
 export interface IChunkCompleteInformation {
     /** Duration the request took to be performed, in seconds. */
-    duration: number | undefined;
+    requestDuration: number | undefined;
     /**
      * "Real" URL (post-redirection) at which the segment was loaded.
      *
@@ -550,8 +555,11 @@ export declare type ILoadedAudioVideoSegmentFormat = Uint8Array | ArrayBuffer |
 export declare type ILoadedTextSegmentFormat = Uint8Array | ArrayBuffer | string | null;
 /** Format of a loaded image segment before parsing. */
 export declare type ILoadedImageSegmentFormat = Uint8Array | ArrayBuffer | null;
-/** Result returned by a segment parser when it parsed an initialization segment. */
-export interface ISegmentParserParsedInitSegment<DataType> {
+/**
+ * Result returned by a segment parser when it parsed a chunk from an init
+ * segment (which does not contain media data).
+ */
+export interface ISegmentParserParsedInitChunk<DataType> {
     segmentType: "init";
     /**
      * Initialization segment that can be directly pushed to the corresponding
@@ -577,14 +585,20 @@ export interface ISegmentParserParsedInitSegment<DataType> {
     protectionDataUpdate: boolean;
 }
 /**
- * Result returned by a segment parser when it parsed a media (not an
- * initialization segment).
+ * Result returned by a segment parser when it parsed a chunk from a media
+ * segment (which contains media data, unlike an initialization segment).
  */
-export interface ISegmentParserParsedSegment<DataType> {
+export interface ISegmentParserParsedMediaChunk<DataType> {
     segmentType: "media";
-    /** Parsed chunk of data that can be decoded. */
+    /**
+     * Parsed chunk of data that can be decoded.
+     * `null` if no data was parsed.
+     */
     chunkData: DataType | null;
-    /** Time information on this parsed chunk. */
+    /**
+     * Time information on this parsed chunk.
+     * `null` if unknown.
+     */
     chunkInfos: IChunkTimeInfo | null;
     /**
      * time offset, in seconds, to add to the absolute timed data defined in
@@ -636,7 +650,7 @@ export interface IRequestedData<T> {
     /** The loaded response data. */
     responseData: T;
     /** Duration the request took to be performed, in seconds. */
-    duration: number | undefined;
+    requestDuration: number | undefined;
     /**
      * "Real" URL (post-redirection) at which the data can be loaded.
      *

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

@@ -20,6 +20,6 @@
  */
 export default function byteRange(_a) {
     var start = _a[0], end = _a[1];
-    return end === Infinity ? "bytes=" + start + "-" :
-        "bytes=" + start + "-" + end;
+    return end === Infinity ? "bytes=".concat(start, "-") :
+        "bytes=".concat(start, "-").concat(end);
 }

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

@@ -37,7 +37,7 @@ export default function callCustomManifestLoader(customManifestLoader, fallbackM
                     undefined;
                 res({ responseData: _args.data,
                     size: _args.size,
-                    duration: _args.duration,
+                    requestDuration: _args.duration,
                     url: _args.url, receivedTime: receivedTime, sendingTime: sendingTime });
             };
             /**

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

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import log from "../../log";
 import { getDurationFromTrun, getTrackFragmentDecodeTime, } from "../../parsers/containers/isobmff";
 /**
  * Get precize start and duration of a chunk.
@@ -37,7 +38,11 @@ export default function getISOBMFFTimingInfos(buffer, isChunked, segment, initTi
         baseDecodeTime + (segment.timestampOffset * initTimescale) :
         baseDecodeTime;
     var trunDuration = getDurationFromTrun(buffer);
-    if (isChunked) { // when chunked, no mean to know the duration for now
+    if (isChunked || !segment.complete) {
+        if (trunDuration === undefined) {
+            log.warn("DASH: Chunked segments should indicate a duration through their" +
+                " trun boxes");
+        }
         return { time: startTime / initTimescale,
             duration: trunDuration !== undefined ? trunDuration / initTimescale :
                 undefined };

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

@@ -45,7 +45,7 @@ export function getISOBMFFTextTrackFormat(representation) {
             return "vtt";
     }
     throw new Error("The codec used for the subtitles " +
-        ("\"" + codec + "\" is not managed yet."));
+        "\"".concat(codec, "\" is not managed yet."));
 }
 /**
  * Returns the a string expliciting the format of a text track in plain text.
@@ -68,7 +68,7 @@ export function getPlainTextTrackFormat(representation) {
     if (codeLC === "srt") {
         return "srt";
     }
-    throw new Error("could not find a text-track parser for the type " + mimeType);
+    throw new Error("could not find a text-track parser for the type ".concat(mimeType));
 }
 /**
  * @param {Object} content
@@ -98,7 +98,7 @@ export function getISOBMFFEmbeddedTextTrackData(_a, chunkBytes, chunkInfos, isCh
         if (chunkInfos.duration !== undefined) {
             endTime = startTime + chunkInfos.duration;
         }
-        else if (!isChunked) {
+        else if (!isChunked && segment.complete) {
             endTime = startTime + segment.duration;
         }
     }
@@ -127,7 +127,9 @@ export function getPlainTextTrackData(_a, textTrackData, isChunked) {
     }
     else {
         start = segment.time;
-        end = segment.time + segment.duration;
+        if (segment.complete) {
+            end = segment.time + segment.duration;
+        }
     }
     var type = getPlainTextTrackFormat(representation);
     return { data: textTrackData, type: type, language: adaptation.language, start: start, end: end };

package/dist/_esm5.processed/utils/assert.js

@@ -22,7 +22,7 @@ import isNullOrUndefined from "./is_null_or_undefined";
  * @throws AssertionError - Throws if the assertion given is false
  */
 export default function assert(assertion, message) {
-    if (!assertion) {
+    if (1 /* DEV */ === 0 /* CURRENT_ENV */ && !assertion) {
         throw new AssertionError(message === undefined ? "invalid assertion" :
             message);
     }
@@ -38,12 +38,12 @@ export default function assert(assertion, message) {
  */
 export function assertInterface(o, iface, name) {
     if (name === void 0) { name = "object"; }
-    assert(!isNullOrUndefined(o), name + " should be an object");
+    assert(!isNullOrUndefined(o), "".concat(name, " should be an object"));
     for (var k in iface) {
         if (iface.hasOwnProperty(k)) {
             /* eslint-disable max-len  */
             /* eslint-disable @typescript-eslint/restrict-template-expressions */
-            assert(typeof o[k] === iface[k], name + " should have property " + k + " as a " + iface[k]);
+            assert(typeof o[k] === iface[k], "".concat(name, " should have property ").concat(k, " as a ").concat(iface[k]));
             /* eslint-enable max-len */
             /* eslint-enable @typescript-eslint/restrict-template-expressions */
         }

package/dist/_esm5.processed/utils/concat_map_latest.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat as observableConcat, defer as observableDefer, EMPTY, } from "rxjs";
-import { mergeMap, tap, } from "rxjs/operators";
+import { concat as observableConcat, defer as observableDefer, EMPTY, mergeMap, tap, } from "rxjs";
 /**
  * Same as concatMap, but get last emitted value from source instead of unstack
  * inner values.

package/dist/_esm5.processed/utils/defer_subscriptions.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { asapScheduler, } from "rxjs";
-import { subscribeOn } from "rxjs/operators";
+import { asapScheduler, subscribeOn, } from "rxjs";
 /**
  * At subscription, instead of "running" the Observable right away, wait until
  * the current task has finished executing before actually running this

package/dist/_esm5.processed/utils/filter_map.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, } from "rxjs";
-import { filter, map, } from "rxjs/operators";
+import { defer as observableDefer, filter, map, } from "rxjs";
 /**
  * Special kind of map which will ignore the result when the value emitted
  * corresponds to a given token.

package/dist/_esm5.processed/utils/reference.d.ts

@@ -0,0 +1,108 @@
+/**
+ * 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";
+/**
+ * A value behind a shared reference, meaning that any update to its value from
+ * anywhere can be retrieved from any other parts of the code in posession of
+ * the "same" (i.e. not cloned) `ISharedReference`.
+ *
+ * @example
+ * ```ts
+ * const myVal = 1;
+ * const myRef : ISharedReference<number> = createSharedReference(1);
+ *
+ * function DoThingsWithVal(num : number) {
+ *   num = 2;
+ * }
+ *
+ * function DoThingsWithRef(num : ISharedReference<number>) {
+ *   num.setValue(2);
+ * }
+ *
+ * myRef.asObservable().subscribe((val) => {
+ *   console.log(val); // outputs first `1`, then `2`
+ * });
+ *
+ * DoThingsWithVal(myVal);
+ * console.log(myVal); // output: 1
+ *
+ * DoThingsWithRef(myRef);
+ * console.log(myRef.getValue()); // output: 2
+ *
+ * myRef.asObservable().subscribe((val) => {
+ *   console.log(val); // outputs only `2`
+ * });
+ * ```
+ *
+ * This type was added because we found that the usage of an explicit type for
+ * those use cases makes the intent of the corresponding code clearer.
+ */
+export interface ISharedReference<T> {
+    /** Get the last set value for this shared reference. */
+    getValue(): T;
+    /** Update the value of this shared reference. */
+    setValue(newVal: T): void;
+    /**
+     * Returns an Observable which synchronously emits the current value (unless
+     * the `skipCurrentValue` argument has been set to `true`) and then each time
+     * a new value is set.
+     * @param {boolean} [skipCurrentValue]
+     * @returns {Observable}
+     */
+    asObservable(skipCurrentValue?: boolean): Observable<T>;
+    /**
+     * Indicate that no new values will be emitted.
+     * Allows to automatically close all Observables generated from this shared
+     * reference.
+     */
+    finish(): void;
+}
+/**
+ * An `ISharedReference` which can only be read and not updated.
+ *
+ * @example
+ * ```ts
+ * const myReference : ISharedReference<number> = createSharedReference(4);
+ *
+ * function shouldOnlyReadIt(roRef : IReadOnlySharedReference<number>) {
+ *   console.log("current value:", roRef.getValue());
+ * }
+ *
+ * shouldOnlyReadIt(myReference); // output: "current value: 4"
+ *
+ * myReference.setValue(12);
+ * shouldOnlyReadIt(myReference); // output: "current value: 12"
+ * ```
+ *
+ * Because an `ISharedReference` is structurally compatible to a
+ * `IReadOnlySharedReference`, and because of TypeScript variance rules, it can
+ * be upcasted into a `IReadOnlySharedReference` at any time to make it clear in
+ * the code that some logic is not supposed to update the referenced value.
+ */
+export interface IReadOnlySharedReference<T> {
+    getValue(): T;
+    asObservable(skipCurrentValue?: boolean): Observable<T>;
+}
+/**
+ * Create an `ISharedReference` object encapsulating the mutable `initialValue`
+ * value of type T.
+ *
+ * @see ISharedReference
+ * @param {*} initialValue
+ * @returns {Observable}
+ */
+export declare function createSharedReference<T>(initialValue: T): ISharedReference<T>;
+export default createSharedReference;

package/dist/_esm5.processed/utils/reference.js

@@ -0,0 +1,137 @@
+/**
+ * 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 log from "../log";
+/**
+ * Create an `ISharedReference` object encapsulating the mutable `initialValue`
+ * value of type T.
+ *
+ * @see ISharedReference
+ * @param {*} initialValue
+ * @returns {Observable}
+ */
+export function createSharedReference(initialValue) {
+    /** Current value referenced by this `ISharedReference`. */
+    var value = initialValue;
+    /**
+     * List of currently subscribed Observables which listen to the referenced
+     * value's updates.
+     *
+     * Contains two properties:
+     *   - `subscriber`: interface through which new value will be communicated.
+     *   - `hasBeenUnsubscribed`: becomes `true` when the Observable becomes
+     *     unsubscribed and thus when it is removed from the `subs` array.
+     *     Adding this property allows to detect when a previously-added
+     *     Observable has since been unsubscribed e.g. as a side-effect during a
+     *     function call.
+     */
+    var subs = [];
+    var isFinished = false;
+    return {
+        /**
+         * Returns the current value of this shared reference.
+         * @returns {*}
+         */
+        getValue: function () {
+            return value;
+        },
+        /**
+         * Update the value of this shared reference.
+         * @param {*}
+         */
+        setValue: function (newVal) {
+            if (isFinished) {
+                if (0 /* CURRENT_ENV */ === 1 /* DEV */) {
+                    throw new Error("Finished shared references cannot be updated");
+                }
+                else {
+                    log.error("Finished shared references cannot be updated");
+                    return;
+                }
+            }
+            value = newVal;
+            if (subs.length === 0) {
+                return;
+            }
+            var clonedSubs = subs.slice();
+            for (var _i = 0, clonedSubs_1 = clonedSubs; _i < clonedSubs_1.length; _i++) {
+                var subObj = clonedSubs_1[_i];
+                try {
+                    if (!subObj.hasBeenUnsubscribed) {
+                        subObj.subscriber.next(newVal);
+                    }
+                }
+                catch (_) {
+                    /* nothing */
+                }
+            }
+        },
+        /**
+         * Returns an Observable which synchronously emits the current value (unless
+         * the `skipCurrentValue` argument has been set to `true`) and then each
+         * time a new value is set.
+         * @param {boolean} [skipCurrentValue]
+         * @returns {Observable}
+         */
+        asObservable: function (skipCurrentValue) {
+            return new Observable(function (obs) {
+                if (skipCurrentValue !== true) {
+                    obs.next(value);
+                }
+                if (isFinished) {
+                    obs.complete();
+                    return undefined;
+                }
+                var subObj = { subscriber: obs,
+                    hasBeenUnsubscribed: false };
+                subs.push(subObj);
+                return function () {
+                    /**
+                     * Code in here can still be running while this is happening.
+                     * Set `hasBeenUnsubscribed` to `true` to avoid still using the
+                     * `subscriber` from this object.
+                     */
+                    subObj.hasBeenUnsubscribed = true;
+                    var indexOf = subs.indexOf(subObj);
+                    if (indexOf >= 0) {
+                        subs.splice(indexOf, 1);
+                    }
+                };
+            });
+        },
+        /**
+         * Indicate that no new values will be emitted.
+         * Allows to automatically close all Observables generated from this shared
+         * reference.
+         */
+        finish: function () {
+            isFinished = true;
+            var clonedSubs = subs.slice();
+            for (var _i = 0, clonedSubs_2 = clonedSubs; _i < clonedSubs_2.length; _i++) {
+                var subObj = clonedSubs_2[_i];
+                try {
+                    if (!subObj.hasBeenUnsubscribed) {
+                        subObj.subscriber.complete();
+                    }
+                }
+                catch (_) {
+                    /* nothing */
+                }
+            }
+        },
+    };
+}
+export default createSharedReference;

package/dist/_esm5.processed/utils/request/fetch.d.ts

@@ -3,7 +3,7 @@ import { CancellationSignal } from "../task_canceller";
 /** Object returned by `fetchRequest` after the fetch operation succeeded. */
 export interface IFetchedStreamComplete {
     /** Duration of the whole request, in milliseconds. */
-    duration: number;
+    requestDuration: number;
     /** Result of `performance.now()` at the time the request was received. */
     receivedTime: number;
     /** Result of `performance.now()` at the time the request was started. */

package/dist/_esm5.processed/utils/request/fetch.js

@@ -126,7 +126,7 @@ export default function fetchRequest(options) {
         return readBufferAndSendEvents();
         function readBufferAndSendEvents() {
             return __awaiter(this, void 0, void 0, function () {
-                var data, currentTime, dataInfo, receivedTime, duration;
+                var data, currentTime, dataInfo, receivedTime, requestDuration;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0: return [4 /*yield*/, reader.read()];
@@ -143,8 +143,8 @@ export default function fetchRequest(options) {
                             else if (data.done) {
                                 deregisterCancelLstnr();
                                 receivedTime = performance.now();
-                                duration = receivedTime - sendingTime;
-                                return [2 /*return*/, { duration: duration, receivedTime: receivedTime, sendingTime: sendingTime, size: size, status: response.status,
+                                requestDuration = receivedTime - sendingTime;
+                                return [2 /*return*/, { requestDuration: requestDuration, receivedTime: receivedTime, sendingTime: sendingTime, size: size, status: response.status,
                                         url: response.url }];
                             }
                             return [2 /*return*/, readBufferAndSendEvents()];

package/dist/_esm5.processed/utils/request/xhr.d.ts

@@ -130,7 +130,7 @@ export interface IRequestOptions<ResponseType> {
 /** Data emitted by `request`'s Promise when the request succeeded. */
 export interface IRequestResponse<T, U> {
     /** Time taken by the request, in milliseconds. */
-    duration: number;
+    requestDuration: number;
     /** Time (relative to the "time origin") at which the request ended. */
     receivedTime: number;
     /** Data requested. Its type will depend on the responseType. */

package/dist/_esm5.processed/utils/request/xhr.js

@@ -113,7 +113,7 @@ export default function request(options) {
                         return;
                     }
                     resolve({ status: status_1, url: _url,
-                        responseType: loadedResponseType, sendingTime: sendingTime, receivedTime: receivedTime, duration: receivedTime - sendingTime,
+                        responseType: loadedResponseType, sendingTime: sendingTime, receivedTime: receivedTime, requestDuration: receivedTime - sendingTime,
                         size: totalSize, responseData: responseData });
                 }
                 else {

package/dist/_esm5.processed/utils/rx-retry_with_backoff.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { timer as observableTimer, } from "rxjs";
-import { catchError, mergeMap, } from "rxjs/operators";
+import { catchError, mergeMap, timer as observableTimer, } from "rxjs";
 import getFuzzedDelay from "./get_fuzzed_delay";
 import isNullOrUndefined from "./is_null_or_undefined";
 /**

package/dist/rx-player.d.ts

@@ -1,17 +1,3 @@
-/**
- * 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 RxPlayer from "./_esm5.processed/index";
 export default RxPlayer;