rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/parsers/texttracks/ttml/html/create_element.js

@@ -13,10 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+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));
 };
 import { addClassName } from "../../../../compat";
 import isNonEmptyString from "../../../../utils/is_non_empty_string";
@@ -373,7 +377,7 @@ function generateTextContent(paragraph, regions, styles, paragraphStyle, shouldT
                     shouldTrimWhiteSpaceFromParent;
                 // compute the new applyable style
                 var newStyle = objectAssign({}, style, getStylingAttributes(SPAN_LEVEL_ATTRIBUTES, [currentNode], styles, regions));
-                elements.push.apply(elements, loop(currentNode, newStyle, __spreadArray([currentNode], spans), shouldTrimWhiteSpaceOnSpan));
+                elements.push.apply(elements, loop(currentNode, newStyle, __spreadArray([currentNode], spans, true), shouldTrimWhiteSpaceOnSpan));
             }
         }
         return elements;
@@ -399,7 +403,7 @@ export default function createElement(paragraph, body, regions, styles, paragrap
     applyGeneralStyle(parentElement, paragraphStyle);
     if (body !== null) {
         // applies to body, div, p, region, span
-        var bodyBackgroundColor = getStylingAttributes(["backgroundColor"], __spreadArray(__spreadArray([], divs), [body]), styles, regions).bodyBackgroundColor;
+        var bodyBackgroundColor = getStylingAttributes(["backgroundColor"], __spreadArray(__spreadArray([], divs, true), [body], false), styles, regions).bodyBackgroundColor;
         if (isNonEmptyString(bodyBackgroundColor)) {
             parentElement.style.backgroundColor = ttmlColorToCSSColor(bodyBackgroundColor);
         }

package/dist/_esm5.processed/parsers/texttracks/ttml/html/generate_css_test_outline.js

@@ -24,8 +24,8 @@
  * @returns {string}
  */
 export default function generateCSSTextOutline(color, thickness) {
-    return "-1px -1px " + thickness + " " + color + "," +
-        ("1px -1px " + thickness + " " + color + ",") +
-        ("-1px 1px " + thickness + " " + color + ",") +
-        ("1px 1px " + thickness + " " + color);
+    return "-1px -1px ".concat(thickness, " ").concat(color, ",") +
+        "1px -1px ".concat(thickness, " ").concat(color, ",") +
+        "-1px 1px ".concat(thickness, " ").concat(color, ",") +
+        "1px 1px ".concat(thickness, " ").concat(color);
 }

package/dist/_esm5.processed/parsers/texttracks/ttml/html/parse_cue.js

@@ -34,6 +34,5 @@ export default function parseCue(parsedCue) {
     var _a = getTimeDelimiters(paragraph, ttParams), start = _a.start, end = _a.end;
     var element = createElement(paragraph, body, regionStyles, idStyles, paragraphStyle, { cellResolution: cellResolution, shouldTrimWhiteSpace: shouldTrimWhiteSpace });
     return { start: start + timeOffset,
-        end: end + timeOffset,
-        element: element };
+        end: end + timeOffset, element: element };
 }

package/dist/_esm5.processed/parsers/texttracks/ttml/nodes.js

@@ -18,7 +18,8 @@
  * @returns {Element}
  */
 function getBodyNode(tt) {
-    return tt.getElementsByTagName("body")[0];
+    var bodyNodes = tt.getElementsByTagName("body");
+    return bodyNodes.length > 0 ? bodyNodes[0] : null;
 }
 /**
  * @param {Element} tt - <tt> node

package/dist/_esm5.processed/parsers/texttracks/ttml/parse_ttml.js

@@ -13,10 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+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));
 };
 import arrayFind from "../../../utils/array_find";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
@@ -87,8 +91,7 @@ export default function parseTTMLString(str, timeOffset) {
                     var extendsStyles = subStyles === null ? [] :
                         subStyles.split(" ");
                     idStyles.push({ id: styleID,
-                        style: getStylingFromElement(styleNode),
-                        extendsStyles: extendsStyles });
+                        style: getStylingFromElement(styleNode), extendsStyles: extendsStyles });
                 }
             }
         }
@@ -132,19 +135,12 @@ export default function parseTTMLString(str, timeOffset) {
             var paragraph = paragraphNodes[i];
             if (paragraph instanceof Element) {
                 var divs = getParentElementsByTagName(paragraph, "div");
-                var paragraphStyle = objectAssign({}, bodyStyle, getStylingAttributes(STYLE_ATTRIBUTES, __spreadArray([paragraph], divs), idStyles, regionStyles));
+                var paragraphStyle = objectAssign({}, bodyStyle, getStylingAttributes(STYLE_ATTRIBUTES, __spreadArray([paragraph], divs, true), idStyles, regionStyles));
                 var paragraphSpaceAttribute = paragraph.getAttribute("xml:space");
                 var shouldTrimWhiteSpace = isNonEmptyString(paragraphSpaceAttribute) ?
                     paragraphSpaceAttribute === "default" :
                     shouldTrimWhiteSpaceOnBody;
-                var cue = { paragraph: paragraph,
-                    timeOffset: timeOffset,
-                    idStyles: idStyles,
-                    regionStyles: regionStyles,
-                    body: body,
-                    paragraphStyle: paragraphStyle,
-                    ttParams: ttParams,
-                    shouldTrimWhiteSpace: shouldTrimWhiteSpace };
+                var cue = { paragraph: paragraph, timeOffset: timeOffset, idStyles: idStyles, regionStyles: regionStyles, body: body, paragraphStyle: paragraphStyle, ttParams: ttParams, shouldTrimWhiteSpace: shouldTrimWhiteSpace };
                 if (cue !== null) {
                     cues.push(cue);
                 }

package/dist/_esm5.processed/parsers/texttracks/webvtt/html/create_default_style_elements.js

@@ -15,8 +15,8 @@ var colorMap = {
 };
 export default function createDefaultStyleElements() {
     return Object.keys(colorMap).reduce(function (result, key) {
-        result[key] = "color: " + colorMap[key] + ";";
-        result["bg_" + key] = "background-color: " + colorMap[key] + ";";
+        result[key] = "color: ".concat(colorMap[key], ";");
+        result["bg_".concat(key)] = "background-color: ".concat(colorMap[key], ";");
         return result;
     }, {});
 }

package/dist/_esm5.processed/parsers/texttracks/webvtt/html/create_style_attribute.js

@@ -33,11 +33,11 @@ var getAttrValue = function (settings) {
     var yPositioning = getPositioningY(settings);
     return ("position: absolute;" +
         "margin: 0;" +
-        ("transform: translate(" + xPositioning.offset + "%," + yPositioning.offset + "%);") +
-        ("width: " + getSizePercentage(settings.size) + "%;") +
-        ("left: " + xPositioning.position + "%;") +
-        ("top: " + (yPositioning.position !== null ? yPositioning.position + "%" : "auto") + ";") +
-        ("text-align: " + getAlignValue(settings.align) + ";"));
+        "transform: translate(".concat(xPositioning.offset, "%,").concat(yPositioning.offset, "%);") +
+        "width: ".concat(getSizePercentage(settings.size), "%;") +
+        "left: ".concat(xPositioning.position, "%;") +
+        "top: ".concat(yPositioning.position !== null ? "".concat(yPositioning.position, "%") : "auto", ";") +
+        "text-align: ".concat(getAlignValue(settings.align), ";"));
 };
 var PositionAlignment;
 (function (PositionAlignment) {

package/dist/_esm5.processed/parsers/texttracks/webvtt/html/to_html.d.ts

@@ -35,9 +35,9 @@ export default function toHTML(cueObj: {
     start: number;
     end: number;
     settings: Partial<Record<string, string>>;
-    header?: string;
+    header?: string | undefined;
     payload: string[];
 }, styling: {
     classes: IStyleElements;
-    global?: string;
+    global?: string | undefined;
 }): IVTTHTMLCue;

package/dist/_esm5.processed/parsers/texttracks/webvtt/html/to_html.js

@@ -66,7 +66,5 @@ export default function toHTML(cueObj, styling) {
     });
     region.appendChild(pElement);
     pElement.appendChild(spanElement);
-    return { start: start,
-        end: end,
-        element: region };
+    return { start: start, end: end, element: region };
 }

package/dist/_esm5.processed/parsers/texttracks/webvtt/parse_cue_block.d.ts

@@ -16,7 +16,7 @@
 export interface IVTTCueObject {
     start: number;
     end: number;
-    header?: string;
+    header: string | undefined;
     settings: Partial<Record<string, string>>;
     payload: string[];
 }

package/dist/_esm5.processed/parsers/texttracks/webvtt/parse_cue_block.js

@@ -56,9 +56,7 @@ function parseTimeAndSettings(timeString) {
         return null;
     }
     var settings = parseSettings(matches[3]);
-    return { start: start,
-        end: end,
-        settings: settings };
+    return { start: start, end: end, settings: settings };
 }
 /**
  * Parse cue block into a cue object which contains:
@@ -94,8 +92,5 @@ export default function parseCueBlock(cueLines, timeOffset) {
     }
     var start = timeAndSettings.start, end = timeAndSettings.end, settings = timeAndSettings.settings;
     return { start: start + timeOffset,
-        end: end + timeOffset,
-        settings: settings,
-        payload: payload,
-        header: header };
+        end: end + timeOffset, settings: settings, payload: payload, header: header };
 }

package/dist/_esm5.processed/public_types.d.ts

@@ -18,3 +18,7 @@
  * Those types are considered as part of the API.
  */
 export { IConstructorOptions, ILoadVideoOptions, ITransportOptions, IKeySystemOption, ISupplementaryTextTrackOption, ISupplementaryImageTrackOption, IDefaultAudioTrackOption, IDefaultTextTrackOption, INetworkConfigOption, IStartAtOption, ITMAudioTrackListItem as IAvailableAudioTrack, ITMTextTrackListItem as IAvailableTextTrack, ITMVideoTrackListItem as IAvailableVideoTrack, ITMAudioTrack as IAudioTrack, ITMTextTrack as ITextTrack, ITMVideoTrack as IVideoTrack, IAudioTrackPreference, ITextTrackPreference, IVideoTrackPreference, IStreamEvent, IStreamEventData, } from "./core/api";
+export { IPersistentSessionInfo, IPersistentSessionStorage, } from "./core/eme";
+export { ICustomError as IPlayerError } from "./errors";
+export { IExposedAdaptation as IAdaptation, IExposedManifest as IManifest, IExposedPeriod as IPeriod, IExposedRepresentation as IRepresentation, IExposedSegment as ISegment, IRepresentationFilter, IRepresentationInfos, } from "./manifest";
+export { ICustomSegmentLoader as ISegmentLoader, ICustomManifestLoader as IManifestLoader, } from "./transports";

package/dist/_esm5.processed/tools/TextTrackRenderer/text_track_renderer.js

@@ -52,9 +52,7 @@ var TextTrackRenderer = /** @class */ (function () {
             0;
         this._segmentBuffer.pushChunkSync({ inventoryInfos: null,
             data: { initSegment: null,
-                codec: args.type,
-                timestampOffset: timestampOffset,
-                appendWindow: [0, Infinity],
+                codec: args.type, timestampOffset: timestampOffset, appendWindow: [0, Infinity],
                 chunk: { start: 0,
                     end: Number.MAX_VALUE,
                     data: args.data,

package/dist/_esm5.processed/transports/dash/add_segment_integrity_checks_to_loader.d.ts

@@ -16,10 +16,9 @@
 import { ISegmentLoader } from "../types";
 /**
  * Add multiple checks on the response given by the `segmentLoader` in argument.
- * If the response appear to be corrupted, this Observable will throw an error
- * with an `INTEGRITY_ERROR` code.
+ * If the response appear to be corrupted, the returned Promise will reject with
+ * an error with an `INTEGRITY_ERROR` code.
  * @param {Function} segmentLoader
  * @returns {Function}
  */
-export default function addSegmentIntegrityChecks(segmentLoader: ISegmentLoader<ArrayBuffer | Uint8Array | null>): ISegmentLoader<ArrayBuffer | Uint8Array | null>;
-export default function addSegmentIntegrityChecks(segmentLoader: ISegmentLoader<ArrayBuffer | Uint8Array | string | null>): ISegmentLoader<ArrayBuffer | Uint8Array | string | null>;
+export default function addSegmentIntegrityChecks<T>(segmentLoader: ISegmentLoader<T>): ISegmentLoader<T>;

package/dist/_esm5.processed/transports/dash/add_segment_integrity_checks_to_loader.js

@@ -13,16 +13,77 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { tap } from "rxjs/operators";
+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);
+};
+import PPromise from "../../utils/promise";
+import TaskCanceller from "../../utils/task_canceller";
 import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
 import inferSegmentContainer from "../utils/infer_segment_container";
+/**
+ * Add multiple checks on the response given by the `segmentLoader` in argument.
+ * If the response appear to be corrupted, the returned Promise will reject with
+ * an error with an `INTEGRITY_ERROR` code.
+ * @param {Function} segmentLoader
+ * @returns {Function}
+ */
 export default function addSegmentIntegrityChecks(segmentLoader) {
-    return function (content) { return segmentLoader(content).pipe(tap(function (res) {
-        if ((res.type === "data-loaded" || res.type === "data-chunk") &&
-            res.value.responseData !== null &&
-            typeof res.value.responseData !== "string" &&
-            inferSegmentContainer(content.adaptation.type, content.representation) === "mp4") {
-            checkISOBMFFIntegrity(new Uint8Array(res.value.responseData), content.segment.isInit);
-        }
-    })); };
+    return function (url, content, initialCancelSignal, callbacks) {
+        return new PPromise(function (res, rej) {
+            var canceller = new TaskCanceller();
+            var unregisterCancelLstnr = initialCancelSignal
+                .register(function onCheckCancellation(err) {
+                canceller.cancel();
+                rej(err);
+            });
+            /**
+             * If the data's seems to be corrupted, cancel the loading task and reject
+             * with an `INTEGRITY_ERROR` error.
+             * @param {*} data
+             */
+            function cancelAndRejectOnBadIntegrity(data) {
+                if (!(data instanceof Array) && !(data instanceof Uint8Array) ||
+                    inferSegmentContainer(content.adaptation.type, content.representation) !== "mp4") {
+                    return;
+                }
+                try {
+                    checkISOBMFFIntegrity(new Uint8Array(data), content.segment.isInit);
+                }
+                catch (err) {
+                    unregisterCancelLstnr();
+                    canceller.cancel();
+                    rej(err);
+                }
+            }
+            segmentLoader(url, content, canceller.signal, __assign(__assign({}, callbacks), { onNewChunk: function (data) {
+                    cancelAndRejectOnBadIntegrity(data);
+                    if (!canceller.isUsed) {
+                        callbacks.onNewChunk(data);
+                    }
+                } })).then(function (info) {
+                if (canceller.isUsed) {
+                    return;
+                }
+                unregisterCancelLstnr();
+                if (info.resultType === "segment-loaded") {
+                    cancelAndRejectOnBadIntegrity(info.resultData.responseData);
+                }
+                res(info);
+            }, function (error) {
+                // The segmentLoader's cancellations cases are all handled here
+                if (!TaskCanceller.isCancellationError(error)) {
+                    unregisterCancelLstnr();
+                    rej(error);
+                }
+            });
+        });
+    };
 }

package/dist/_esm5.processed/transports/dash/image_pipelines.d.ts

@@ -13,17 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { IImageTrackSegmentData, ISegmentLoaderArguments, ISegmentLoaderEvent, ISegmentParserArguments, ISegmentParserInitSegment, ISegmentParserSegment } from "../types";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { IImageTrackSegmentData, ILoadedImageSegmentFormat, ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultChunkedComplete, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded, ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk } from "../types";
 /**
  * Loads an image segment.
- * @param {Object} args
- * @returns {Observable}
+ * @param {string|null} url
+ * @param {Object} content
+ * @param {Object} cancelSignal
+ * @param {Object} callbacks
+ * @returns {Promise}
  */
-export declare function imageLoader({ segment, url }: ISegmentLoaderArguments): Observable<ISegmentLoaderEvent<ArrayBuffer | null>>;
+export declare function imageLoader(url: string | null, content: ISegmentContext, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>): Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> | ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat> | ISegmentLoaderResultChunkedComplete>;
 /**
  * Parses an image segment.
  * @param {Object} args
  * @returns {Object}
  */
-export declare function imageParser({ response, content }: ISegmentParserArguments<Uint8Array | ArrayBuffer | null>): Observable<ISegmentParserInitSegment<null> | ISegmentParserSegment<IImageTrackSegmentData>>;
+export declare function imageParser(loadedSegment: {
+    data: ArrayBuffer | Uint8Array | null;
+    isChunked: boolean;
+}, content: ISegmentContext): ISegmentParserParsedMediaChunk<IImageTrackSegmentData | null> | ISegmentParserParsedInitChunk<null>;

package/dist/_esm5.processed/transports/dash/image_pipelines.js

@@ -13,39 +13,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, } from "rxjs";
 import features from "../../features";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import takeFirstSet from "../../utils/take_first_set";
 /**
  * Loads an image segment.
- * @param {Object} args
- * @returns {Observable}
+ * @param {string|null} url
+ * @param {Object} content
+ * @param {Object} cancelSignal
+ * @param {Object} callbacks
+ * @returns {Promise}
  */
-export function imageLoader(_a) {
-    var segment = _a.segment, url = _a.url;
+export function imageLoader(url, content, cancelSignal, callbacks) {
+    var segment = content.segment;
     if (segment.isInit || url === null) {
-        return observableOf({ type: "data-created",
-            value: { responseData: null } });
+        return PPromise.resolve({ resultType: "segment-created",
+            resultData: null });
     }
-    return request({ url: url,
-        responseType: "arraybuffer",
-        sendProgressEvents: true });
+    return request({ url: url, responseType: "arraybuffer",
+        onProgress: callbacks.onProgress, cancelSignal: cancelSignal })
+        .then(function (data) { return ({ resultType: "segment-loaded",
+        resultData: data }); });
 }
 /**
  * Parses an image segment.
  * @param {Object} args
  * @returns {Object}
  */
-export function imageParser(_a) {
-    var response = _a.response, content = _a.content;
+export function imageParser(loadedSegment, content) {
     var segment = content.segment, period = content.period;
-    var data = response.data, isChunked = response.isChunked;
+    var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
     if (content.segment.isInit) { // image init segment has no use
-        return observableOf({ type: "parsed-init-segment",
-            value: { initializationData: null,
-                protectionDataUpdate: false,
-                initTimescale: undefined } });
+        return { segmentType: "init",
+            initializationData: null,
+            protectionDataUpdate: false,
+            initTimescale: undefined };
     }
     if (isChunked) {
         throw new Error("Image data should not be downloaded in chunks");
@@ -53,26 +56,21 @@ export function imageParser(_a) {
     var chunkOffset = takeFirstSet(segment.timestampOffset, 0);
     // TODO image Parsing should be more on the buffer side, no?
     if (data === null || features.imageParser === null) {
-        return observableOf({ type: "parsed-segment",
-            value: { chunkData: null,
-                chunkInfos: { duration: segment.duration,
-                    time: segment.time },
-                chunkOffset: chunkOffset,
-                appendWindow: [period.start, period.end],
-                protectionDataUpdate: false } });
+        return { segmentType: "media",
+            chunkData: null,
+            chunkInfos: { duration: segment.duration,
+                time: segment.time }, chunkOffset: chunkOffset, protectionDataUpdate: false,
+            appendWindow: [period.start, period.end] };
     }
     var bifObject = features.imageParser(new Uint8Array(data));
     var thumbsData = bifObject.thumbs;
-    return observableOf({ type: "parsed-segment",
-        value: { chunkData: { data: thumbsData,
-                start: 0,
-                end: Number.MAX_VALUE,
-                timescale: 1,
-                type: "bif" },
-            chunkInfos: { time: 0,
-                duration: Number.MAX_VALUE,
-                timescale: bifObject.timescale },
-            chunkOffset: chunkOffset,
-            appendWindow: [period.start, period.end],
-            protectionDataUpdate: false } });
+    return { segmentType: "media",
+        chunkData: { data: thumbsData,
+            start: 0,
+            end: Number.MAX_VALUE,
+            timescale: 1,
+            type: "bif" },
+        chunkInfos: { time: 0,
+            duration: Number.MAX_VALUE }, chunkOffset: chunkOffset, protectionDataUpdate: false,
+        appendWindow: [period.start, period.end] };
 }

package/dist/_esm5.processed/transports/dash/init_segment_loader.d.ts

@@ -13,11 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { ISegmentLoaderArguments, ISegmentLoaderEvent } from "../types";
+import { ISegment } from "../../manifest";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { ISegmentLoaderCallbacks, ISegmentLoaderResultChunkedComplete, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
 /**
  * Perform a request for an initialization segment, agnostic to the container.
  * @param {string} url
- * @param {Object} content
+ * @param {Object} segment
+ * @param {CancellationSignal} cancelSignal
+ * @param {Object} callbacks
+ * @returns {Promise}
  */
-export default function initSegmentLoader(url: string, { segment }: ISegmentLoaderArguments): Observable<ISegmentLoaderEvent<ArrayBuffer | Uint8Array>>;
+export default function initSegmentLoader(url: string, segment: ISegment, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<ArrayBuffer | Uint8Array>): Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | Uint8Array> | ISegmentLoaderResultSegmentCreated<ArrayBuffer | Uint8Array> | ISegmentLoaderResultChunkedComplete>;

package/dist/_esm5.processed/transports/dash/init_segment_loader.js

@@ -13,55 +13,51 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, } from "rxjs";
-import { map } from "rxjs/operators";
 import { concat } from "../../utils/byte_parsing";
-import xhr from "../../utils/request";
+import PPromise from "../../utils/promise";
+import request from "../../utils/request";
 import byteRange from "../utils/byte_range";
 /**
  * Perform a request for an initialization segment, agnostic to the container.
  * @param {string} url
- * @param {Object} content
+ * @param {Object} segment
+ * @param {CancellationSignal} cancelSignal
+ * @param {Object} callbacks
+ * @returns {Promise}
  */
-export default function initSegmentLoader(url, _a) {
-    var segment = _a.segment;
+export default function initSegmentLoader(url, segment, cancelSignal, callbacks) {
     if (segment.range === undefined) {
-        return xhr({ url: url, responseType: "arraybuffer", sendProgressEvents: true });
+        return request({ url: url, responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+            .then(function (data) { return ({ resultType: "segment-loaded",
+            resultData: data }); });
     }
     if (segment.indexRange === undefined) {
-        return xhr({ url: url,
-            headers: { Range: byteRange(segment.range) },
-            responseType: "arraybuffer",
-            sendProgressEvents: true });
+        return request({ url: url, headers: { Range: byteRange(segment.range) },
+            responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+            .then(function (data) { return ({ resultType: "segment-loaded",
+            resultData: data }); });
     }
     // range and indexRange are contiguous (99% of the cases)
     if (segment.range[1] + 1 === segment.indexRange[0]) {
-        return xhr({ url: url,
-            headers: { Range: byteRange([segment.range[0],
+        return request({ url: url, headers: { Range: byteRange([segment.range[0],
                     segment.indexRange[1]]) },
-            responseType: "arraybuffer",
-            sendProgressEvents: true });
+            responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+            .then(function (data) { return ({ resultType: "segment-loaded",
+            resultData: data }); });
     }
-    var rangeRequest$ = xhr({ url: url,
-        headers: { Range: byteRange(segment.range) },
-        responseType: "arraybuffer",
-        sendProgressEvents: false });
-    var indexRequest$ = xhr({ url: url,
-        headers: { Range: byteRange(segment.indexRange) },
-        responseType: "arraybuffer",
-        sendProgressEvents: false });
-    return observableCombineLatest([rangeRequest$, indexRequest$])
-        .pipe(map(function (_a) {
+    var rangeRequest$ = request({ url: url, headers: { Range: byteRange(segment.range) },
+        responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
+    var indexRequest$ = request({ url: url, headers: { Range: byteRange(segment.indexRange) },
+        responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
+    return PPromise.all([rangeRequest$, indexRequest$])
+        .then(function (_a) {
         var initData = _a[0], indexData = _a[1];
-        var data = concat(new Uint8Array(initData.value.responseData), new Uint8Array(indexData.value.responseData));
-        var sendingTime = Math.min(initData.value.sendingTime, indexData.value.sendingTime);
-        var receivedTime = Math.max(initData.value.receivedTime, indexData.value.receivedTime);
-        return { type: "data-loaded",
-            value: { url: url,
-                responseData: data,
-                size: initData.value.size + indexData.value.size,
-                duration: receivedTime - sendingTime,
-                sendingTime: sendingTime,
-                receivedTime: receivedTime } };
-    }));
+        var data = concat(new Uint8Array(initData.responseData), new Uint8Array(indexData.responseData));
+        var sendingTime = Math.min(initData.sendingTime, indexData.sendingTime);
+        var receivedTime = Math.max(initData.receivedTime, indexData.receivedTime);
+        return { resultType: "segment-loaded",
+            resultData: { url: url, responseData: data,
+                size: initData.size + indexData.size,
+                requestDuration: receivedTime - sendingTime, sendingTime: sendingTime, receivedTime: receivedTime } };
+    });
 }

package/dist/_esm5.processed/transports/dash/low_latency_segment_loader.d.ts

@@ -13,6 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { ISegmentLoaderArguments, ISegmentLoaderEvent } from "../types";
-export default function lowLatencySegmentLoader(url: string, args: ISegmentLoaderArguments): Observable<ISegmentLoaderEvent<ArrayBuffer>>;
+import { CancellationSignal } from "../../utils/task_canceller";
+import { ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultChunkedComplete } from "../types";
+/**
+ * Load segments through a "chunk" mode (decodable chunk by decodable chunk).
+ *
+ * This method is particularly adapted to low-latency streams.
+ *
+ * @param {string} url - URL of the segment to download.
+ * @param {Object} content - Context of the segment needed.
+ * @param {Object} callbacks
+ * @param {CancellationSignal} cancelSignal
+ * @returns {Promise}
+ */
+export default function lowLatencySegmentLoader(url: string, content: ISegmentContext, callbacks: ISegmentLoaderCallbacks<Uint8Array>, cancelSignal: CancellationSignal): Promise<ISegmentLoaderResultChunkedComplete>;