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

package/dist/_esm5.processed/manifest/update_periods.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,20 +14,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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 { MediaError } from "../errors";
-import log from "../log";
-import arrayFindIndex from "../utils/array_find_index";
-import { MANIFEST_UPDATE_TYPE } from "./types";
-import updatePeriodInPlace from "./update_period_in_place";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePeriods = exports.replacePeriods = void 0;
+const errors_1 = require("../errors");
+const log_1 = require("../log");
+const array_find_index_1 = require("../utils/array_find_index");
+const types_1 = require("./types");
+const update_period_in_place_1 = require("./update_period_in_place");
 /**
  * Update old periods by adding new periods and removing
  * not available ones.
@@ -34,49 +28,48 @@ import updatePeriodInPlace from "./update_period_in_place";
  * @param {Array.<Object>} newPeriods
  * @returns {Object}
  */
-export function replacePeriods(oldPeriods, newPeriods) {
-    var _a, _b, _c, _d;
-    var res = {
+function replacePeriods(oldPeriods, newPeriods) {
+    const res = {
         updatedPeriods: [],
         addedPeriods: [],
         removedPeriods: [],
     };
-    var firstUnhandledPeriodIdx = 0;
-    for (var i = 0; i < newPeriods.length; i++) {
-        var newPeriod = newPeriods[i];
-        var j = firstUnhandledPeriodIdx;
-        var oldPeriod = oldPeriods[j];
+    let firstUnhandledPeriodIdx = 0;
+    for (let i = 0; i < newPeriods.length; i++) {
+        const newPeriod = newPeriods[i];
+        let j = firstUnhandledPeriodIdx;
+        let oldPeriod = oldPeriods[j];
         while (oldPeriod != null && oldPeriod.id !== newPeriod.id) {
             j++;
             oldPeriod = oldPeriods[j];
         }
         if (oldPeriod != null) {
-            var result = updatePeriodInPlace(oldPeriod, newPeriod, MANIFEST_UPDATE_TYPE.Full);
-            res.updatedPeriods.push({ period: oldPeriod, result: result });
-            var periodsToInclude = newPeriods.slice(firstUnhandledPeriodIdx, i);
-            var nbrOfPeriodsToRemove = j - firstUnhandledPeriodIdx;
-            var removed = oldPeriods.splice.apply(oldPeriods, __spreadArray([firstUnhandledPeriodIdx,
-                nbrOfPeriodsToRemove], periodsToInclude, false));
-            (_a = res.removedPeriods).push.apply(_a, removed);
-            (_b = res.addedPeriods).push.apply(_b, periodsToInclude);
+            const result = (0, update_period_in_place_1.default)(oldPeriod, newPeriod, types_1.MANIFEST_UPDATE_TYPE.Full);
+            res.updatedPeriods.push({ period: oldPeriod, result });
+            const periodsToInclude = newPeriods.slice(firstUnhandledPeriodIdx, i);
+            const nbrOfPeriodsToRemove = j - firstUnhandledPeriodIdx;
+            const removed = oldPeriods.splice(firstUnhandledPeriodIdx, nbrOfPeriodsToRemove, ...periodsToInclude);
+            res.removedPeriods.push(...removed);
+            res.addedPeriods.push(...periodsToInclude);
             firstUnhandledPeriodIdx = i + 1;
         }
     }
     if (firstUnhandledPeriodIdx > oldPeriods.length) {
-        log.error("Manifest: error when updating Periods");
+        log_1.default.error("Manifest: error when updating Periods");
         return res;
     }
     if (firstUnhandledPeriodIdx < oldPeriods.length) {
-        var removed = oldPeriods.splice(firstUnhandledPeriodIdx, oldPeriods.length - firstUnhandledPeriodIdx);
-        (_c = res.removedPeriods).push.apply(_c, removed);
+        const removed = oldPeriods.splice(firstUnhandledPeriodIdx, oldPeriods.length - firstUnhandledPeriodIdx);
+        res.removedPeriods.push(...removed);
     }
-    var remainingNewPeriods = newPeriods.slice(firstUnhandledPeriodIdx, newPeriods.length);
+    const remainingNewPeriods = newPeriods.slice(firstUnhandledPeriodIdx, newPeriods.length);
     if (remainingNewPeriods.length > 0) {
-        oldPeriods.push.apply(oldPeriods, remainingNewPeriods);
-        (_d = res.addedPeriods).push.apply(_d, remainingNewPeriods);
+        oldPeriods.push(...remainingNewPeriods);
+        res.addedPeriods.push(...remainingNewPeriods);
     }
     return res;
 }
+exports.replacePeriods = replacePeriods;
 /**
  * Update old periods by adding new periods and removing
  * not available ones.
@@ -84,85 +77,82 @@ export function replacePeriods(oldPeriods, newPeriods) {
  * @param {Array.<Object>} newPeriods
  * @returns {Object}
  */
-export function updatePeriods(oldPeriods, newPeriods) {
-    var _a, _b, _c, _d, _e;
-    var res = {
+function updatePeriods(oldPeriods, newPeriods) {
+    const res = {
         updatedPeriods: [],
         addedPeriods: [],
         removedPeriods: [],
     };
     if (oldPeriods.length === 0) {
-        oldPeriods.splice.apply(oldPeriods, __spreadArray([0, 0], newPeriods, false));
-        (_a = res.addedPeriods).push.apply(_a, newPeriods);
+        oldPeriods.splice(0, 0, ...newPeriods);
+        res.addedPeriods.push(...newPeriods);
         return res;
     }
     if (newPeriods.length === 0) {
         return res;
     }
-    var oldLastPeriod = oldPeriods[oldPeriods.length - 1];
+    const oldLastPeriod = oldPeriods[oldPeriods.length - 1];
     if (oldLastPeriod.start < newPeriods[0].start) {
         if (oldLastPeriod.end !== newPeriods[0].start) {
-            throw new MediaError("MANIFEST_UPDATE_ERROR", "Cannot perform partial update: not enough data");
+            throw new errors_1.MediaError("MANIFEST_UPDATE_ERROR", "Cannot perform partial update: not enough data");
         }
-        oldPeriods.push.apply(oldPeriods, newPeriods);
-        (_b = res.addedPeriods).push.apply(_b, newPeriods);
+        oldPeriods.push(...newPeriods);
+        res.addedPeriods.push(...newPeriods);
         return res;
     }
     /** Index, in `oldPeriods` of the first element of `newPeriods` */
-    var indexOfNewFirstPeriod = arrayFindIndex(oldPeriods, function (_a) {
-        var id = _a.id;
-        return id === newPeriods[0].id;
-    });
+    const indexOfNewFirstPeriod = (0, array_find_index_1.default)(oldPeriods, ({ id }) => id === newPeriods[0].id);
     if (indexOfNewFirstPeriod < 0) {
-        throw new MediaError("MANIFEST_UPDATE_ERROR", "Cannot perform partial update: incoherent data");
+        throw new errors_1.MediaError("MANIFEST_UPDATE_ERROR", "Cannot perform partial update: incoherent data");
     }
     // The first updated Period can only be a partial part
-    var updateRes = updatePeriodInPlace(oldPeriods[indexOfNewFirstPeriod], newPeriods[0], MANIFEST_UPDATE_TYPE.Partial);
+    const updateRes = (0, update_period_in_place_1.default)(oldPeriods[indexOfNewFirstPeriod], newPeriods[0], types_1.MANIFEST_UPDATE_TYPE.Partial);
     res.updatedPeriods.push({ period: oldPeriods[indexOfNewFirstPeriod],
         result: updateRes });
     // Search each consecutive elements of `newPeriods` - after the initial one already
     // processed - in `oldPeriods`, removing and adding unfound Periods in the process
-    var prevIndexOfNewPeriod = indexOfNewFirstPeriod + 1;
-    for (var i = 1; i < newPeriods.length; i++) {
-        var newPeriod = newPeriods[i];
-        var indexOfNewPeriod = -1;
-        for (var j = prevIndexOfNewPeriod; j < oldPeriods.length; j++) {
+    let prevIndexOfNewPeriod = indexOfNewFirstPeriod + 1;
+    for (let i = 1; i < newPeriods.length; i++) {
+        const newPeriod = newPeriods[i];
+        let indexOfNewPeriod = -1;
+        for (let j = prevIndexOfNewPeriod; j < oldPeriods.length; j++) {
             if (newPeriod.id === oldPeriods[j].id) {
                 indexOfNewPeriod = j;
                 break; // end the loop
             }
         }
         if (indexOfNewPeriod < 0) { // Next element of `newPeriods` not found: insert it
-            var toRemoveUntil = -1;
-            for (var j = prevIndexOfNewPeriod; j < oldPeriods.length; j++) {
+            let toRemoveUntil = -1;
+            for (let j = prevIndexOfNewPeriod; j < oldPeriods.length; j++) {
                 if (newPeriod.start < oldPeriods[j].start) {
                     toRemoveUntil = j;
                     break; // end the loop
                 }
             }
-            var nbElementsToRemove = toRemoveUntil - prevIndexOfNewPeriod;
-            var removed = oldPeriods.splice(prevIndexOfNewPeriod, nbElementsToRemove, newPeriod);
+            const nbElementsToRemove = toRemoveUntil - prevIndexOfNewPeriod;
+            const removed = oldPeriods.splice(prevIndexOfNewPeriod, nbElementsToRemove, newPeriod);
             res.addedPeriods.push(newPeriod);
-            (_c = res.removedPeriods).push.apply(_c, removed);
+            res.removedPeriods.push(...removed);
         }
         else {
             if (indexOfNewPeriod > prevIndexOfNewPeriod) {
                 // Some old periods were not found: remove
-                log.warn("Manifest: old Periods not found in new when updating, removing");
-                var removed = oldPeriods.splice(prevIndexOfNewPeriod, indexOfNewPeriod - prevIndexOfNewPeriod);
-                (_d = res.removedPeriods).push.apply(_d, removed);
+                log_1.default.warn("Manifest: old Periods not found in new when updating, removing");
+                const removed = oldPeriods.splice(prevIndexOfNewPeriod, indexOfNewPeriod - prevIndexOfNewPeriod);
+                res.removedPeriods.push(...removed);
                 indexOfNewPeriod = prevIndexOfNewPeriod;
             }
             // Later Periods can be fully replaced
-            var result = updatePeriodInPlace(oldPeriods[indexOfNewPeriod], newPeriod, MANIFEST_UPDATE_TYPE.Full);
-            res.updatedPeriods.push({ period: oldPeriods[indexOfNewPeriod], result: result });
+            const result = (0, update_period_in_place_1.default)(oldPeriods[indexOfNewPeriod], newPeriod, types_1.MANIFEST_UPDATE_TYPE.Full);
+            res.updatedPeriods.push({ period: oldPeriods[indexOfNewPeriod], result });
         }
         prevIndexOfNewPeriod++;
     }
     if (prevIndexOfNewPeriod < oldPeriods.length) {
-        log.warn("Manifest: Ending Periods not found in new when updating, removing");
-        var removed = oldPeriods.splice(prevIndexOfNewPeriod, oldPeriods.length - prevIndexOfNewPeriod);
-        (_e = res.removedPeriods).push.apply(_e, removed);
+        log_1.default.warn("Manifest: Ending Periods not found in new when updating, removing");
+        const removed = oldPeriods.splice(prevIndexOfNewPeriod, oldPeriods.length - prevIndexOfNewPeriod);
+        res.removedPeriods.push(...removed);
     }
     return res;
 }
+exports.updatePeriods = updatePeriods;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,30 +14,34 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNullOrUndefined from "../utils/is_null_or_undefined";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoggableSegmentId = exports.areSameContent = void 0;
+const is_null_or_undefined_1 = require("../utils/is_null_or_undefined");
 /**
  * Check if two contents are the same
  * @param {Object} content1
  * @param {Object} content2
  * @returns {boolean}
  */
-export function areSameContent(content1, content2) {
+function areSameContent(content1, content2) {
     return (content1.segment.id === content2.segment.id &&
         content1.representation.uniqueId === content2.representation.uniqueId);
 }
+exports.areSameContent = areSameContent;
 /**
  * Get string describing a given ISegment, useful for log functions.
  * @param {Object} content
  * @returns {string|null|undefined}
  */
-export function getLoggableSegmentId(content) {
-    if (isNullOrUndefined(content)) {
+function getLoggableSegmentId(content) {
+    if ((0, is_null_or_undefined_1.default)(content)) {
         return "";
     }
-    var period = content.period, adaptation = content.adaptation, representation = content.representation, segment = content.segment;
-    return "".concat(adaptation.type, " P: ").concat(period.id, " A: ").concat(adaptation.id, " ") +
-        "R: ".concat(representation.id, " S: ") +
+    const { period, adaptation, representation, segment } = content;
+    return `${adaptation.type} P: ${period.id} A: ${adaptation.id} ` +
+        `R: ${representation.id} S: ` +
         (segment.isInit ? "init" :
-            segment.complete ? "".concat(segment.time, "-").concat(segment.duration) :
-                "".concat(segment.time));
+            segment.complete ? `${segment.time}-${segment.duration}` :
+                `${segment.time}`);
 }
+exports.getLoggableSegmentId = getLoggableSegmentId;

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

@@ -13,21 +13,5 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * This file exports a MinimalPlayer class for which features can be lazy-loaded.
- *
- * This allows to import a "minimal" player with a small bundle size and then
- * import only features that is needed.
- */
 import Player from "./core/api";
-import { IFeature } from "./features";
-/**
- * Minimal Player for which you can features at will:
- *   - start with no features
- *   - Allow to only load features wanted
- *
- * @class MinimalPlayer
- */
-export default class MinimalPlayer extends Player {
-    static addFeatures(featureList: IFeature[]): void;
-}
+export default Player;

package/dist/_esm5.processed/minimal.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,51 +14,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * This file exports a MinimalPlayer class for which features can be lazy-loaded.
  *
  * This allows to import a "minimal" player with a small bundle size and then
  * import only features that is needed.
  */
-import Player from "./core/api";
-import { addFeatures, } from "./features";
-import logger from "./log";
-if (typeof __RX_PLAYER_DEBUG_MODE__ === "boolean" && __RX_PLAYER_DEBUG_MODE__) {
-    logger.setLevel("DEBUG");
+const is_debug_mode_enabled_1 = require("./compat/is_debug_mode_enabled");
+const api_1 = require("./core/api");
+const log_1 = require("./log");
+if ((0, is_debug_mode_enabled_1.default)()) {
+    log_1.default.setLevel("DEBUG");
 }
 else if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-    logger.setLevel("NONE" /* __LOGGER_LEVEL__.CURRENT_LEVEL */);
+    log_1.default.setLevel("NONE" /* __LOGGER_LEVEL__.CURRENT_LEVEL */);
 }
-/**
- * Minimal Player for which you can features at will:
- *   - start with no features
- *   - Allow to only load features wanted
- *
- * @class MinimalPlayer
- */
-var MinimalPlayer = /** @class */ (function (_super) {
-    __extends(MinimalPlayer, _super);
-    function MinimalPlayer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    MinimalPlayer.addFeatures = function (featureList) {
-        addFeatures(featureList);
-    };
-    return MinimalPlayer;
-}(Player));
-export default MinimalPlayer;
+exports.default = api_1.default;

package/dist/_esm5.processed/parsers/containers/isobmff/constants.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_32_BIT_INT = void 0;
 /**
  * Maximum integer that can be stored on 32 bits.
  *
@@ -20,4 +23,4 @@
  * that can be stored on the first four bytes of a box. Any value higher than
  * that will need 8 bytes (64 bits) to be stored.
  */
-export var MAX_32_BIT_INT = Math.pow(2, 32) - 1;
+exports.MAX_32_BIT_INT = Math.pow(2, 32) - 1;

package/dist/_esm5.processed/parsers/containers/isobmff/create_box.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat, itobe4, itobe8, } from "../../../utils/byte_parsing";
-import { strToUtf8 } from "../../../utils/string_parsing";
-import { MAX_32_BIT_INT } from "./constants";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBoxWithChildren = exports.createBox = void 0;
+const byte_parsing_1 = require("../../../utils/byte_parsing");
+const string_parsing_1 = require("../../../utils/string_parsing");
+const constants_1 = require("./constants");
 /**
  * Speed up string to bytes conversion by memorizing the result
  *
@@ -25,7 +28,7 @@ import { MAX_32_BIT_INT } from "./constants";
  * Used by the boxName method.
  * @type {Object}
  */
-var boxNamesMem = {};
+const boxNamesMem = {};
 /**
  * Convert the string name of an ISOBMFF box into the corresponding bytes.
  * Has a memorization mechanism to speed-up if you want to translate the
@@ -37,7 +40,7 @@ function boxName(str) {
     if (boxNamesMem[str] != null) {
         return boxNamesMem[str];
     }
-    var nameInBytes = strToUtf8(str);
+    const nameInBytes = (0, string_parsing_1.strToUtf8)(str);
     boxNamesMem[str] = nameInBytes;
     return nameInBytes;
 }
@@ -49,16 +52,17 @@ function boxName(str) {
  * @returns {Uint8Array} - The entire ISOBMFF box (length+name+content)
  */
 function createBox(name, buff) {
-    var len = buff.length + 8;
-    return len <= MAX_32_BIT_INT ? concat(itobe4(len), boxName(name), buff) :
-        concat(itobe4(1), boxName(name), itobe8(len + 8), buff);
+    const len = buff.length + 8;
+    return len <= constants_1.MAX_32_BIT_INT ? (0, byte_parsing_1.concat)((0, byte_parsing_1.itobe4)(len), boxName(name), buff) :
+        (0, byte_parsing_1.concat)((0, byte_parsing_1.itobe4)(1), boxName(name), (0, byte_parsing_1.itobe8)(len + 8), buff);
 }
+exports.createBox = createBox;
 /**
  * @param {string} name
  * @param {Array.<Uint8Array>} children
  * @returns {Uint8Array}
  */
 function createBoxWithChildren(name, children) {
-    return createBox(name, concat.apply(void 0, children));
+    return createBox(name, (0, byte_parsing_1.concat)(...children));
 }
-export { createBox, createBoxWithChildren, };
+exports.createBoxWithChildren = createBoxWithChildren;

package/dist/_esm5.processed/parsers/containers/isobmff/drm/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,4 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { getPlayReadyKIDFromPrivateData } from "./playready";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlayReadyKIDFromPrivateData = void 0;
+var playready_1 = require("./playready");
+Object.defineProperty(exports, "getPlayReadyKIDFromPrivateData", { enumerable: true, get: function () { return playready_1.getPlayReadyKIDFromPrivateData; } });

package/dist/_esm5.processed/parsers/containers/isobmff/drm/playready.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,24 +14,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { base64ToBytes } from "../../../../utils/base64";
-import { le2toi } from "../../../../utils/byte_parsing";
-import { bytesToHex, guidToUuid, utf16LEToStr, } from "../../../../utils/string_parsing";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlayReadyKIDFromPrivateData = void 0;
+const base64_1 = require("../../../../utils/base64");
+const byte_parsing_1 = require("../../../../utils/byte_parsing");
+const string_parsing_1 = require("../../../../utils/string_parsing");
 /**
  * Parse PlayReady privateData to get its Hexa-coded KeyID.
  * @param {Uint8Array} privateData
  * @returns {string}
  */
-export function getPlayReadyKIDFromPrivateData(data) {
-    var xmlLength = le2toi(data, 8);
-    var xml = utf16LEToStr(data.subarray(10, xmlLength + 10));
-    var doc = new DOMParser().parseFromString(xml, "application/xml");
-    var kidElement = doc.querySelector("KID");
+function getPlayReadyKIDFromPrivateData(data) {
+    const xmlLength = (0, byte_parsing_1.le2toi)(data, 8);
+    const xml = (0, string_parsing_1.utf16LEToStr)(data.subarray(10, xmlLength + 10));
+    const doc = new DOMParser().parseFromString(xml, "application/xml");
+    const kidElement = doc.querySelector("KID");
     if (kidElement === null) {
         throw new Error("Cannot parse PlayReady private data: invalid XML");
     }
-    var b64guidKid = kidElement.textContent === null ? "" :
+    const b64guidKid = kidElement.textContent === null ? "" :
         kidElement.textContent;
-    var uuidKid = guidToUuid(base64ToBytes(b64guidKid));
-    return bytesToHex(uuidKid).toLowerCase();
+    const uuidKid = (0, string_parsing_1.guidToUuid)((0, base64_1.base64ToBytes)(b64guidKid));
+    return (0, string_parsing_1.bytesToHex)(uuidKid).toLowerCase();
 }
+exports.getPlayReadyKIDFromPrivateData = getPlayReadyKIDFromPrivateData;