rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat } from "../../utils/byte_parsing";
-import request from "../../utils/request";
-import byteRange from "../utils/byte_range";
+Object.defineProperty(exports, "__esModule", { value: true });
+const byte_parsing_1 = require("../../utils/byte_parsing");
+const request_1 = require("../../utils/request");
+const byte_range_1 = require("../utils/byte_range");
 /**
  * Perform a request for an initialization segment, agnostic to the container.
  * @param {string} url
@@ -25,44 +27,62 @@ import byteRange from "../utils/byte_range";
  * @param {Object} callbacks
  * @returns {Promise}
  */
-export default function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
+function initSegmentLoader(url, segment, options, cancelSignal, callbacks) {
     if (segment.range === undefined) {
-        return request({ url: url, responseType: "arraybuffer",
-            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-            .then(function (data) { return ({ resultType: "segment-loaded",
-            resultData: data }); });
+        return (0, request_1.default)({ url,
+            responseType: "arraybuffer",
+            timeout: options.timeout,
+            cancelSignal,
+            onProgress: callbacks.onProgress })
+            .then(data => ({ resultType: "segment-loaded",
+            resultData: data }));
     }
     if (segment.indexRange === undefined) {
-        return request({ url: url, headers: { Range: byteRange(segment.range) },
+        return (0, request_1.default)({ url,
+            headers: { Range: (0, byte_range_1.default)(segment.range) },
             responseType: "arraybuffer",
-            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-            .then(function (data) { return ({ resultType: "segment-loaded",
-            resultData: data }); });
+            timeout: options.timeout,
+            cancelSignal,
+            onProgress: callbacks.onProgress })
+            .then(data => ({ resultType: "segment-loaded",
+            resultData: data }));
     }
     // range and indexRange are contiguous (99% of the cases)
     if (segment.range[1] + 1 === segment.indexRange[0]) {
-        return request({ url: url, headers: { Range: byteRange([segment.range[0],
+        return (0, request_1.default)({ url,
+            headers: { Range: (0, byte_range_1.default)([segment.range[0],
                     segment.indexRange[1]]) },
             responseType: "arraybuffer",
-            timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
-            .then(function (data) { return ({ resultType: "segment-loaded",
-            resultData: data }); });
+            timeout: options.timeout,
+            cancelSignal,
+            onProgress: callbacks.onProgress })
+            .then(data => ({ resultType: "segment-loaded",
+            resultData: data }));
     }
-    var rangeRequest$ = request({ url: url, headers: { Range: byteRange(segment.range) },
+    const rangeRequest$ = (0, request_1.default)({ url,
+        headers: { Range: (0, byte_range_1.default)(segment.range) },
         responseType: "arraybuffer",
-        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
-    var indexRequest$ = request({ url: url, headers: { Range: byteRange(segment.indexRange) },
+        timeout: options.timeout,
+        cancelSignal,
+        onProgress: callbacks.onProgress });
+    const indexRequest$ = (0, request_1.default)({ url,
+        headers: { Range: (0, byte_range_1.default)(segment.indexRange) },
         responseType: "arraybuffer",
-        timeout: options.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress });
+        timeout: options.timeout,
+        cancelSignal,
+        onProgress: callbacks.onProgress });
     return Promise.all([rangeRequest$, indexRequest$])
-        .then(function (_a) {
-        var initData = _a[0], indexData = _a[1];
-        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);
+        .then(([initData, indexData]) => {
+        const data = (0, byte_parsing_1.concat)(new Uint8Array(initData.responseData), new Uint8Array(indexData.responseData));
+        const sendingTime = Math.min(initData.sendingTime, indexData.sendingTime);
+        const receivedTime = Math.max(initData.receivedTime, indexData.receivedTime);
         return { resultType: "segment-loaded",
-            resultData: { url: url, responseData: data,
+            resultData: { url,
+                responseData: data,
                 size: initData.size + indexData.size,
-                requestDuration: receivedTime - sendingTime, sendingTime: sendingTime, receivedTime: receivedTime } };
+                requestDuration: receivedTime - sendingTime,
+                sendingTime,
+                receivedTime } };
     });
 }
+exports.default = initSegmentLoader;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,10 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat } from "../../utils/byte_parsing";
-import fetchRequest from "../../utils/request/fetch";
-import byteRange from "../utils/byte_range";
-import extractCompleteChunks from "./extract_complete_chunks";
+Object.defineProperty(exports, "__esModule", { value: true });
+const byte_parsing_1 = require("../../utils/byte_parsing");
+const fetch_1 = require("../../utils/request/fetch");
+const byte_range_1 = require("../utils/byte_range");
+const extract_complete_chunks_1 = require("./extract_complete_chunks");
 /**
  * Load segments through a "chunk" mode (decodable chunk by decodable chunk).
  *
@@ -29,23 +31,23 @@ import extractCompleteChunks from "./extract_complete_chunks";
  * @param {CancellationSignal} cancelSignal
  * @returns {Promise}
  */
-export default function lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal) {
-    var segment = content.segment;
-    var headers = segment.range !== undefined ? { Range: byteRange(segment.range) } :
+function lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal) {
+    const { segment } = content;
+    const headers = segment.range !== undefined ? { Range: (0, byte_range_1.default)(segment.range) } :
         undefined;
-    var partialChunk = null;
+    let partialChunk = null;
     /**
      * Called each time `fetch` has new data available.
      * @param {Object} info
      */
     function onData(info) {
-        var chunk = new Uint8Array(info.chunk);
-        var concatenated = partialChunk !== null ? concat(partialChunk, chunk) :
+        const chunk = new Uint8Array(info.chunk);
+        const concatenated = partialChunk !== null ? (0, byte_parsing_1.concat)(partialChunk, chunk) :
             chunk;
-        var res = extractCompleteChunks(concatenated);
-        var completeChunks = res[0];
+        const res = (0, extract_complete_chunks_1.default)(concatenated);
+        const completeChunks = res[0];
         partialChunk = res[1];
-        for (var i = 0; i < completeChunks.length; i++) {
+        for (let i = 0; i < completeChunks.length; i++) {
             callbacks.onNewChunk(completeChunks[i]);
             if (cancelSignal.isCancelled()) {
                 return;
@@ -58,7 +60,12 @@ export default function lowLatencySegmentLoader(url, content, options, callbacks
             return;
         }
     }
-    return fetchRequest({ url: url, headers: headers, onData: onData, timeout: options.timeout, cancelSignal: cancelSignal })
-        .then(function (res) { return ({ resultType: "chunk-complete",
-        resultData: res }); });
+    return (0, fetch_1.default)({ url,
+        headers,
+        onData,
+        timeout: options.timeout,
+        cancelSignal })
+        .then((res) => ({ resultType: "chunk-complete",
+        resultData: res }));
 }
+exports.default = lowLatencySegmentLoader;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,60 +14,64 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../config";
-import { formatError } from "../../errors";
-import features from "../../features";
-import log from "../../log";
-import Manifest from "../../manifest";
-import objectAssign from "../../utils/object_assign";
-import request from "../../utils/request";
-import { strToUtf8, utf8ToStr, } from "../../utils/string_parsing";
-export default function generateManifestParser(options) {
-    var referenceDateTime = options.referenceDateTime;
-    var serverTimeOffset = options.serverSyncInfos !== undefined ?
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../config");
+const errors_1 = require("../../errors");
+const features_1 = require("../../features");
+const log_1 = require("../../log");
+const manifest_1 = require("../../manifest");
+const object_assign_1 = require("../../utils/object_assign");
+const request_1 = require("../../utils/request");
+const string_parsing_1 = require("../../utils/string_parsing");
+function generateManifestParser(options) {
+    const { referenceDateTime } = options;
+    const serverTimeOffset = options.serverSyncInfos !== undefined ?
         options.serverSyncInfos.serverTimestamp - options.serverSyncInfos.clientTime :
         undefined;
     return function manifestParser(manifestData, parserOptions, onWarnings, cancelSignal, scheduleRequest) {
         var _a;
-        var responseData = manifestData.responseData;
-        var argClockOffset = parserOptions.externalClockOffset;
-        var url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
-        var externalClockOffset = serverTimeOffset !== null && serverTimeOffset !== void 0 ? serverTimeOffset : argClockOffset;
-        var unsafelyBaseOnPreviousManifest = parserOptions.unsafeMode ?
+        const { responseData } = manifestData;
+        const argClockOffset = parserOptions.externalClockOffset;
+        const url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
+        const externalClockOffset = serverTimeOffset !== null && serverTimeOffset !== void 0 ? serverTimeOffset : argClockOffset;
+        const unsafelyBaseOnPreviousManifest = parserOptions.unsafeMode ?
             parserOptions.previousManifest :
             null;
-        var dashParserOpts = { unsafelyBaseOnPreviousManifest: unsafelyBaseOnPreviousManifest, url: url, referenceDateTime: referenceDateTime, externalClockOffset: externalClockOffset };
-        var parsers = features.dashParsers;
+        const dashParserOpts = { unsafelyBaseOnPreviousManifest,
+            url,
+            referenceDateTime,
+            externalClockOffset };
+        const parsers = features_1.default.dashParsers;
         if (parsers.wasm === null ||
             parsers.wasm.status === "uninitialized" ||
             parsers.wasm.status === "failure") {
-            log.debug("DASH: WASM MPD Parser not initialized. Running JS one.");
+            log_1.default.debug("DASH: WASM MPD Parser not initialized. Running JS one.");
             return runDefaultJsParser();
         }
         else {
-            var manifestAB_1 = getManifestAsArrayBuffer(responseData);
-            if (!doesXmlSeemsUtf8Encoded(manifestAB_1)) {
-                log.info("DASH: MPD doesn't seem to be UTF-8-encoded. " +
+            const manifestAB = getManifestAsArrayBuffer(responseData);
+            if (!doesXmlSeemsUtf8Encoded(manifestAB)) {
+                log_1.default.info("DASH: MPD doesn't seem to be UTF-8-encoded. " +
                     "Running JS parser instead of the WASM one.");
                 return runDefaultJsParser();
             }
             if (parsers.wasm.status === "initialized") {
-                log.debug("DASH: Running WASM MPD Parser.");
-                var parsed = parsers.wasm.runWasmParser(manifestAB_1, dashParserOpts);
+                log_1.default.debug("DASH: Running WASM MPD Parser.");
+                const parsed = parsers.wasm.runWasmParser(manifestAB, dashParserOpts);
                 return processMpdParserResponse(parsed);
             }
             else {
-                log.debug("DASH: Awaiting WASM initialization before parsing the MPD.");
-                var initProm = parsers.wasm.waitForInitialization()
-                    .catch(function () { });
-                return initProm.then(function () {
+                log_1.default.debug("DASH: Awaiting WASM initialization before parsing the MPD.");
+                const initProm = parsers.wasm.waitForInitialization()
+                    .catch(() => { });
+                return initProm.then(() => {
                     if (parsers.wasm === null || parsers.wasm.status !== "initialized") {
-                        log.warn("DASH: WASM MPD parser initialization failed. " +
+                        log_1.default.warn("DASH: WASM MPD parser initialization failed. " +
                             "Running JS parser instead");
                         return runDefaultJsParser();
                     }
-                    log.debug("DASH: Running WASM MPD Parser.");
-                    var parsed = parsers.wasm.runWasmParser(manifestAB_1, dashParserOpts);
+                    log_1.default.debug("DASH: Running WASM MPD Parser.");
+                    const parsed = parsers.wasm.runWasmParser(manifestAB, dashParserOpts);
                     return processMpdParserResponse(parsed);
                 });
             }
@@ -81,8 +86,8 @@ export default function generateManifestParser(options) {
             if (parsers.js === null) {
                 throw new Error("No MPD parser is imported");
             }
-            var manifestDoc = getManifestAsDocument(responseData);
-            var parsedManifest = parsers.js(manifestDoc, dashParserOpts);
+            const manifestDoc = getManifestAsDocument(responseData);
+            const parsedManifest = parsers.js(manifestDoc, dashParserOpts);
             return processMpdParserResponse(parsedManifest);
         }
         /**
@@ -99,25 +104,28 @@ export default function generateManifestParser(options) {
                 if (cancelSignal.isCancelled()) {
                     return Promise.reject(cancelSignal.cancellationError);
                 }
-                var manifest = new Manifest(parserResponse.value.parsed, options);
-                return { manifest: manifest, url: url };
+                const warnings = [];
+                const manifest = new manifest_1.default(parserResponse.value.parsed, options, warnings);
+                return { manifest, url, warnings };
             }
-            var value = parserResponse.value;
-            var externalResources = value.urls.map(function (resourceUrl) {
-                return scheduleRequest(function () {
-                    var defaultTimeout = config.getCurrent().DEFAULT_REQUEST_TIMEOUT;
-                    return value.format === "string" ? request({ url: resourceUrl,
+            const { value } = parserResponse;
+            const externalResources = value.urls.map(resourceUrl => {
+                return scheduleRequest(() => {
+                    const defaultTimeout = config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT;
+                    return value.format === "string" ? (0, request_1.default)({ url: resourceUrl,
                         responseType: "text",
-                        timeout: defaultTimeout, cancelSignal: cancelSignal }) :
-                        request({ url: resourceUrl,
+                        timeout: defaultTimeout,
+                        cancelSignal }) :
+                        (0, request_1.default)({ url: resourceUrl,
                             responseType: "arraybuffer",
-                            timeout: defaultTimeout, cancelSignal: cancelSignal });
-                }).then(function (res) {
+                            timeout: defaultTimeout,
+                            cancelSignal });
+                }).then((res) => {
                     if (value.format === "string") {
                         if (typeof res.responseData !== "string") {
                             throw new Error("External DASH resources should have been a string");
                         }
-                        return objectAssign(res, {
+                        return (0, object_assign_1.default)(res, {
                             responseData: {
                                 success: true,
                                 data: res.responseData
@@ -128,29 +136,29 @@ export default function generateManifestParser(options) {
                         if (!(res.responseData instanceof ArrayBuffer)) {
                             throw new Error("External DASH resources should have been ArrayBuffers");
                         }
-                        return objectAssign(res, {
+                        return (0, object_assign_1.default)(res, {
                             responseData: {
                                 success: true,
                                 data: res.responseData
                             },
                         });
                     }
-                }, function (err) {
-                    var error = formatError(err, {
+                }, (err) => {
+                    const error = (0, errors_1.formatError)(err, {
                         defaultCode: "PIPELINE_PARSE_ERROR",
                         defaultReason: "An unknown error occured when parsing ressources.",
                     });
-                    return objectAssign({}, {
+                    return (0, object_assign_1.default)({}, {
                         size: undefined,
                         requestDuration: undefined,
                         responseData: {
                             success: false,
-                            error: error
+                            error
                         },
                     });
                 });
             });
-            return Promise.all(externalResources).then(function (loadedResources) {
+            return Promise.all(externalResources).then(loadedResources => {
                 if (value.format === "string") {
                     assertLoadedResourcesFormatString(loadedResources);
                     return processMpdParserResponse(value.continue(loadedResources));
@@ -163,6 +171,7 @@ export default function generateManifestParser(options) {
         }
     };
 }
+exports.default = generateManifestParser;
 /**
  * Throw if the given input is not in the expected format.
  * Allows to enforce runtime type-checking as compile-time type-checking here is
@@ -175,8 +184,8 @@ function assertLoadedResourcesFormatString(loadedResources) {
     if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 0 /* __ENVIRONMENT__.PRODUCTION */) {
         return;
     }
-    loadedResources.forEach(function (loadedResource) {
-        var responseData = loadedResource.responseData;
+    loadedResources.forEach((loadedResource) => {
+        const { responseData } = loadedResource;
         if (responseData.success && typeof responseData.data === "string") {
             return;
         }
@@ -198,8 +207,8 @@ function assertLoadedResourcesFormatArrayBuffer(loadedResources) {
     if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 0 /* __ENVIRONMENT__.PRODUCTION */) {
         return;
     }
-    loadedResources.forEach(function (loadedResource) {
-        var responseData = loadedResource.responseData;
+    loadedResources.forEach((loadedResource) => {
+        const { responseData } = loadedResource;
         if (responseData.success && responseData.data instanceof ArrayBuffer) {
             return;
         }
@@ -220,7 +229,7 @@ function assertLoadedResourcesFormatArrayBuffer(loadedResources) {
 function getManifestAsDocument(manifestSrc) {
     if (manifestSrc instanceof ArrayBuffer) {
         return new DOMParser()
-            .parseFromString(utf8ToStr(new Uint8Array(manifestSrc)), "text/xml");
+            .parseFromString((0, string_parsing_1.utf8ToStr)(new Uint8Array(manifestSrc)), "text/xml");
     }
     else if (typeof manifestSrc === "string") {
         return new DOMParser().parseFromString(manifestSrc, "text/xml");
@@ -243,10 +252,10 @@ function getManifestAsArrayBuffer(manifestSrc) {
         return manifestSrc;
     }
     else if (typeof manifestSrc === "string") {
-        return strToUtf8(manifestSrc).buffer;
+        return (0, string_parsing_1.strToUtf8)(manifestSrc).buffer;
     }
     else if (manifestSrc instanceof Document) {
-        return strToUtf8(manifestSrc.documentElement.innerHTML).buffer;
+        return (0, string_parsing_1.strToUtf8)(manifestSrc.documentElement.innerHTML).buffer;
     }
     else {
         throw new Error("DASH Manifest Parser: Unrecognized Manifest format");
@@ -261,7 +270,7 @@ function getManifestAsArrayBuffer(manifestSrc) {
  * @returns {boolean}
  */
 function doesXmlSeemsUtf8Encoded(xmlData) {
-    var dv = new DataView(xmlData);
+    const dv = new DataView(xmlData);
     if (dv.getUint16(0) === 0xEFBB && dv.getUint8(2) === 0XBF) {
         // (UTF-8 BOM)
         return true;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,27 +14,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import features from "../../features";
-import generateManifestLoader from "../utils/generate_manifest_loader";
-import generateManifestParser from "./manifest_parser";
-import generateSegmentLoader from "./segment_loader";
-import generateAudioVideoSegmentParser from "./segment_parser";
-import generateTextTrackLoader from "./text_loader";
-import generateTextTrackParser from "./text_parser";
+Object.defineProperty(exports, "__esModule", { value: true });
+const features_1 = require("../../features");
+const generate_manifest_loader_1 = require("../utils/generate_manifest_loader");
+const manifest_parser_1 = require("./manifest_parser");
+const segment_loader_1 = require("./segment_loader");
+const segment_parser_1 = require("./segment_parser");
+const text_loader_1 = require("./text_loader");
+const text_parser_1 = require("./text_parser");
 /**
  * Returns pipelines used for DASH streaming.
  * @param {Object} options
  * implementation. Used for each generated http request.
  * @returns {Object}
  */
-export default function (options) {
-    var manifestLoader = generateManifestLoader({ customManifestLoader: options.manifestLoader }, mightUseDashWasmFeature() ? "text" :
+function default_1(options) {
+    const manifestLoader = (0, generate_manifest_loader_1.default)({ customManifestLoader: options.manifestLoader }, mightUseDashWasmFeature() ? "text" :
         "arraybuffer");
-    var manifestParser = generateManifestParser(options);
-    var segmentLoader = generateSegmentLoader(options);
-    var audioVideoSegmentParser = generateAudioVideoSegmentParser(options);
-    var textTrackLoader = generateTextTrackLoader(options);
-    var textTrackParser = generateTextTrackParser(options);
+    const manifestParser = (0, manifest_parser_1.default)(options);
+    const segmentLoader = (0, segment_loader_1.default)(options);
+    const audioVideoSegmentParser = (0, segment_parser_1.default)(options);
+    const textTrackLoader = (0, text_loader_1.default)(options);
+    const textTrackParser = (0, text_parser_1.default)(options);
     return { manifest: { loadManifest: manifestLoader,
             parseManifest: manifestParser },
         audio: { loadSegment: segmentLoader,
@@ -43,13 +45,14 @@ export default function (options) {
         text: { loadSegment: textTrackLoader,
             parseSegment: textTrackParser } };
 }
+exports.default = default_1;
 /**
  * Returns true if the DASH-WASM parser is either initialized or being
  * initialized.
  * @returns {boolean}
  */
 function mightUseDashWasmFeature() {
-    return features.dashParsers.wasm !== null &&
-        (features.dashParsers.wasm.status === "initialized" ||
-            features.dashParsers.wasm.status === "initializing");
+    return features_1.default.dashParsers.wasm !== null &&
+        (features_1.default.dashParsers.wasm.status === "initialized" ||
+            features_1.default.dashParsers.wasm.status === "initializing");
 }