rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import arrayFindIndex from "./array_find_index";
-import noop from "./noop";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMappedReference = void 0;
+const array_find_index_1 = require("./array_find_index");
+const noop_1 = require("./noop");
 /**
  * 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 possession of
@@ -51,7 +54,7 @@ import noop from "./noop";
  * 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.
  */
-var SharedReference = /** @class */ (function () {
+class SharedReference {
     /**
      * Create a `SharedReference` object encapsulating the mutable `initialValue`
      * value of type T.
@@ -63,28 +66,27 @@ var SharedReference = /** @class */ (function () {
      * removed - as they cannot be triggered anymore, thus providing a security
      * against memory leaks.
      */
-    function SharedReference(initialValue, cancelSignal) {
-        var _this = this;
+    constructor(initialValue, cancelSignal) {
         this._value = initialValue;
         this._listeners = [];
         this._isFinished = false;
         this._onFinishCbs = [];
         if (cancelSignal !== undefined) {
-            this._deregisterCancellation = cancelSignal.register(function () { return _this.finish(); });
+            this._deregisterCancellation = cancelSignal.register(() => this.finish());
         }
     }
     /**
      * Returns the current value of this shared reference.
      * @returns {*}
      */
-    SharedReference.prototype.getValue = function () {
+    getValue() {
         return this._value;
-    };
+    }
     /**
      * Update the value of this shared reference.
      * @param {*} newVal
      */
-    SharedReference.prototype.setValue = function (newVal) {
+    setValue(newVal) {
         if (this._isFinished) {
             if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
                 /* eslint-disable-next-line no-console */
@@ -96,9 +98,8 @@ var SharedReference = /** @class */ (function () {
         if (this._listeners.length === 0) {
             return;
         }
-        var clonedCbs = this._listeners.slice();
-        for (var _i = 0, clonedCbs_1 = clonedCbs; _i < clonedCbs_1.length; _i++) {
-            var cbObj = clonedCbs_1[_i];
+        const clonedCbs = this._listeners.slice();
+        for (const cbObj of clonedCbs) {
             try {
                 if (!cbObj.hasBeenCleared) {
                     cbObj.trigger(newVal, cbObj.complete);
@@ -108,7 +109,7 @@ var SharedReference = /** @class */ (function () {
                 /* nothing */
             }
         }
-    };
+    }
     /**
      * Update the value of this shared reference only if the value changed.
      *
@@ -117,11 +118,11 @@ var SharedReference = /** @class */ (function () {
      * thus be considered different.
      * @param {*} newVal
      */
-    SharedReference.prototype.setValueIfChanged = function (newVal) {
+    setValueIfChanged(newVal) {
         if (newVal !== this._value) {
             this.setValue(newVal);
         }
-    };
+    }
     /**
      * Allows to register a callback to be called each time the value inside the
      * reference is updated.
@@ -134,9 +135,8 @@ var SharedReference = /** @class */ (function () {
      * @param {boolean|undefined} [options.emitCurrentValue] - If `true`, the
      * callback will also be immediately called with the current value.
      */
-    SharedReference.prototype.onUpdate = function (cb, options) {
-        var _this = this;
-        var unlisten = function () {
+    onUpdate(cb, options) {
+        const unlisten = () => {
             if ((options === null || options === void 0 ? void 0 : options.clearSignal) !== undefined) {
                 options.clearSignal.deregister(unlisten);
             }
@@ -144,12 +144,12 @@ var SharedReference = /** @class */ (function () {
                 return;
             }
             cbObj.hasBeenCleared = true;
-            var indexOf = _this._listeners.indexOf(cbObj);
+            const indexOf = this._listeners.indexOf(cbObj);
             if (indexOf >= 0) {
-                _this._listeners.splice(indexOf, 1);
+                this._listeners.splice(indexOf, 1);
             }
         };
-        var cbObj = { trigger: cb,
+        const cbObj = { trigger: cb,
             complete: unlisten,
             hasBeenCleared: false };
         this._listeners.push(cbObj);
@@ -164,7 +164,7 @@ var SharedReference = /** @class */ (function () {
             return;
         }
         options.clearSignal.register(unlisten);
-    };
+    }
     /**
      * Variant of `onUpdate` which will only call the callback once, once the
      * value inside the reference is different from `undefined`.
@@ -189,15 +189,14 @@ var SharedReference = /** @class */ (function () {
      * @param {Object | undefined} [options.clearSignal] - Allows to provide a
      * CancellationSignal which will unregister the callback when it emits.
      */
-    SharedReference.prototype.waitUntilDefined = function (cb, options) {
-        var _this = this;
-        this.onUpdate(function (val, stopListening) {
+    waitUntilDefined(cb, options) {
+        this.onUpdate((val, stopListening) => {
             if (val !== undefined) {
                 stopListening();
-                cb(_this._value);
+                cb(this._value);
             }
         }, { clearSignal: options === null || options === void 0 ? void 0 : options.clearSignal, emitCurrentValue: true });
-    };
+    }
     /**
      * Allows to register a callback for when the Shared Reference is "finished".
      *
@@ -209,38 +208,36 @@ var SharedReference = /** @class */ (function () {
      * @param {Object} onFinishCancelSignal - Allows to provide a
      * CancellationSignal which will unregister the callback when it emits.
      */
-    SharedReference.prototype._onFinished = function (cb, onFinishCancelSignal) {
-        var _this = this;
+    _onFinished(cb, onFinishCancelSignal) {
         if (onFinishCancelSignal.isCancelled()) {
-            return noop;
+            return noop_1.default;
         }
-        var cleanUp = function () {
-            var indexOf = arrayFindIndex(_this._onFinishCbs, function (x) { return x.trigger === trigger; });
+        const cleanUp = () => {
+            const indexOf = (0, array_find_index_1.default)(this._onFinishCbs, (x) => x.trigger === trigger);
             if (indexOf >= 0) {
-                _this._onFinishCbs[indexOf].hasBeenCleared = true;
-                _this._onFinishCbs.splice(indexOf, 1);
+                this._onFinishCbs[indexOf].hasBeenCleared = true;
+                this._onFinishCbs.splice(indexOf, 1);
             }
         };
-        var trigger = function () {
+        const trigger = () => {
             cleanUp();
             cb();
         };
-        var deregisterCancellation = onFinishCancelSignal.register(cleanUp);
-        this._onFinishCbs.push({ trigger: trigger, hasBeenCleared: false });
+        const deregisterCancellation = onFinishCancelSignal.register(cleanUp);
+        this._onFinishCbs.push({ trigger, hasBeenCleared: false });
         return deregisterCancellation;
-    };
+    }
     /**
      * Indicate that no new values will be emitted.
      * Allows to automatically free all listeners linked to this reference.
      */
-    SharedReference.prototype.finish = function () {
+    finish() {
         if (this._deregisterCancellation !== undefined) {
             this._deregisterCancellation();
         }
         this._isFinished = true;
-        var clonedCbs = this._listeners.slice();
-        for (var _i = 0, clonedCbs_2 = clonedCbs; _i < clonedCbs_2.length; _i++) {
-            var cbObj = clonedCbs_2[_i];
+        const clonedCbs = this._listeners.slice();
+        for (const cbObj of clonedCbs) {
             try {
                 if (!cbObj.hasBeenCleared) {
                     cbObj.complete();
@@ -253,9 +250,8 @@ var SharedReference = /** @class */ (function () {
         }
         this._listeners.length = 0;
         if (this._onFinishCbs.length > 0) {
-            var clonedFinishedCbs = this._onFinishCbs.slice();
-            for (var _a = 0, clonedFinishedCbs_1 = clonedFinishedCbs; _a < clonedFinishedCbs_1.length; _a++) {
-                var cbObj = clonedFinishedCbs_1[_a];
+            const clonedFinishedCbs = this._onFinishCbs.slice();
+            for (const cbObj of clonedFinishedCbs) {
                 try {
                     if (!cbObj.hasBeenCleared) {
                         cbObj.trigger();
@@ -268,9 +264,8 @@ var SharedReference = /** @class */ (function () {
             }
             this._onFinishCbs.length = 0;
         }
-    };
-    return SharedReference;
-}());
+    }
+}
 /**
  * Create a new `SharedReference` based on another one by mapping over its
  * referenced value each time it is updated and finishing once it finishes.
@@ -282,14 +277,15 @@ var SharedReference = /** @class */ (function () {
  * will finish that reference when it emits.
  * @returns {Object} - The new, mapped, reference.
  */
-export function createMappedReference(originalRef, mappingFn, cancellationSignal) {
-    var newRef = new SharedReference(mappingFn(originalRef.getValue()), cancellationSignal);
+function createMappedReference(originalRef, mappingFn, cancellationSignal) {
+    const newRef = new SharedReference(mappingFn(originalRef.getValue()), cancellationSignal);
     originalRef.onUpdate(function mapOriginalReference(x) {
         newRef.setValue(mappingFn(x));
     }, { clearSignal: cancellationSignal });
-    originalRef._onFinished(function () {
+    originalRef._onFinished(() => {
         newRef.finish();
     }, cancellationSignal);
     return newRef;
 }
-export default SharedReference;
+exports.createMappedReference = createMappedReference;
+exports.default = SharedReference;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Copyright 2015 CANAL+ Group
  *
@@ -13,171 +14,140 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import globalScope from "../../compat/global_scope";
-import { NetworkErrorTypes, RequestError, } from "../../errors";
-import log from "../../log";
-import isNullOrUndefined from "../is_null_or_undefined";
-import getMonotonicTimeStamp from "../monotonic_timestamp";
-var _Headers = typeof Headers === "function" ? Headers :
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchIsSupported = void 0;
+const global_scope_1 = require("../../compat/global_scope");
+const errors_1 = require("../../errors");
+const log_1 = require("../../log");
+const is_null_or_undefined_1 = require("../is_null_or_undefined");
+const monotonic_timestamp_1 = require("../monotonic_timestamp");
+const _Headers = typeof Headers === "function" ? Headers :
     null;
-var _AbortController = typeof AbortController === "function" ?
+const _AbortController = typeof AbortController === "function" ?
     AbortController :
     null;
-export default function fetchRequest(options) {
-    var headers;
-    if (!isNullOrUndefined(options.headers)) {
-        if (isNullOrUndefined(_Headers)) {
+function fetchRequest(options) {
+    let headers;
+    if (!(0, is_null_or_undefined_1.default)(options.headers)) {
+        if ((0, is_null_or_undefined_1.default)(_Headers)) {
             headers = options.headers;
         }
         else {
             headers = new _Headers();
-            var headerNames = Object.keys(options.headers);
-            for (var i = 0; i < headerNames.length; i++) {
-                var headerName = headerNames[i];
+            const headerNames = Object.keys(options.headers);
+            for (let i = 0; i < headerNames.length; i++) {
+                const headerName = headerNames[i];
                 headers.append(headerName, options.headers[headerName]);
             }
         }
     }
-    log.debug("Fetch: Called with URL", options.url);
-    var cancellation = null;
-    var timeouted = false;
-    var sendingTime = getMonotonicTimeStamp();
-    var abortController = !isNullOrUndefined(_AbortController) ? new _AbortController() :
+    log_1.default.debug("Fetch: Called with URL", options.url);
+    let cancellation = null;
+    let timeouted = false;
+    const sendingTime = (0, monotonic_timestamp_1.default)();
+    const abortController = !(0, is_null_or_undefined_1.default)(_AbortController) ? new _AbortController() :
         null;
     /**
      * Abort current fetchRequest by triggering AbortController signal.
      * @returns {void}
      */
     function abortFetch() {
-        if (isNullOrUndefined(abortController)) {
-            log.warn("Fetch: AbortController API not available.");
+        if ((0, is_null_or_undefined_1.default)(abortController)) {
+            log_1.default.warn("Fetch: AbortController API not available.");
             return;
         }
         abortController.abort();
     }
-    var timeout;
+    let timeout;
     if (options.timeout !== undefined) {
-        timeout = setTimeout(function () {
+        timeout = setTimeout(() => {
             timeouted = true;
             abortFetch();
         }, options.timeout);
     }
-    var deregisterCancelLstnr = options.cancelSignal
+    const deregisterCancelLstnr = options.cancelSignal
         .register(function abortRequest(err) {
         cancellation = err;
         abortFetch();
     });
-    var fetchOpts = { method: "GET" };
+    const fetchOpts = { method: "GET" };
     if (headers !== undefined) {
         fetchOpts.headers = headers;
     }
-    fetchOpts.signal = !isNullOrUndefined(abortController) ? abortController.signal :
+    fetchOpts.signal = !(0, is_null_or_undefined_1.default)(abortController) ? abortController.signal :
         null;
-    return fetch(options.url, fetchOpts).then(function (response) {
-        if (!isNullOrUndefined(timeout)) {
+    return fetch(options.url, fetchOpts).then((response) => {
+        if (!(0, is_null_or_undefined_1.default)(timeout)) {
             clearTimeout(timeout);
         }
         if (response.status >= 300) {
-            log.warn("Fetch: Request HTTP Error", response.status, response.url);
-            throw new RequestError(response.url, response.status, NetworkErrorTypes.ERROR_HTTP_CODE);
+            log_1.default.warn("Fetch: Request HTTP Error", response.status, response.url);
+            throw new errors_1.RequestError(response.url, response.status, errors_1.NetworkErrorTypes.ERROR_HTTP_CODE);
         }
-        if (isNullOrUndefined(response.body)) {
-            throw new RequestError(response.url, response.status, NetworkErrorTypes.PARSE_ERROR);
+        if ((0, is_null_or_undefined_1.default)(response.body)) {
+            throw new errors_1.RequestError(response.url, response.status, errors_1.NetworkErrorTypes.PARSE_ERROR);
         }
-        var contentLengthHeader = response.headers.get("Content-Length");
-        var contentLength = !isNullOrUndefined(contentLengthHeader) &&
+        const contentLengthHeader = response.headers.get("Content-Length");
+        const contentLength = !(0, is_null_or_undefined_1.default)(contentLengthHeader) &&
             !isNaN(+contentLengthHeader) ? +contentLengthHeader :
             undefined;
-        var reader = response.body.getReader();
-        var size = 0;
+        const reader = response.body.getReader();
+        let size = 0;
         return readBufferAndSendEvents();
-        function readBufferAndSendEvents() {
-            return __awaiter(this, void 0, void 0, function () {
-                var data, currentTime, dataInfo, receivedTime, requestDuration;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, reader.read()];
-                        case 1:
-                            data = _a.sent();
-                            if (!data.done && !isNullOrUndefined(data.value)) {
-                                size += data.value.byteLength;
-                                currentTime = getMonotonicTimeStamp();
-                                dataInfo = { url: response.url, currentTime: currentTime, duration: currentTime - sendingTime, sendingTime: sendingTime, chunkSize: data.value.byteLength,
-                                    chunk: data.value.buffer, size: size, totalSize: contentLength };
-                                options.onData(dataInfo);
-                                return [2 /*return*/, readBufferAndSendEvents()];
-                            }
-                            else if (data.done) {
-                                deregisterCancelLstnr();
-                                receivedTime = getMonotonicTimeStamp();
-                                requestDuration = receivedTime - sendingTime;
-                                return [2 /*return*/, { requestDuration: requestDuration, receivedTime: receivedTime, sendingTime: sendingTime, size: size, status: response.status,
-                                        url: response.url }];
-                            }
-                            return [2 /*return*/, readBufferAndSendEvents()];
-                    }
-                });
-            });
+        async function readBufferAndSendEvents() {
+            const data = await reader.read();
+            if (!data.done && !(0, is_null_or_undefined_1.default)(data.value)) {
+                size += data.value.byteLength;
+                const currentTime = (0, monotonic_timestamp_1.default)();
+                const dataInfo = { url: response.url,
+                    currentTime,
+                    duration: currentTime - sendingTime,
+                    sendingTime,
+                    chunkSize: data.value.byteLength,
+                    chunk: data.value.buffer,
+                    size,
+                    totalSize: contentLength };
+                options.onData(dataInfo);
+                return readBufferAndSendEvents();
+            }
+            else if (data.done) {
+                deregisterCancelLstnr();
+                const receivedTime = (0, monotonic_timestamp_1.default)();
+                const requestDuration = receivedTime - sendingTime;
+                return { requestDuration,
+                    receivedTime,
+                    sendingTime,
+                    size,
+                    status: response.status,
+                    url: response.url };
+            }
+            return readBufferAndSendEvents();
         }
-    }).catch(function (err) {
+    }).catch((err) => {
         if (cancellation !== null) {
             throw cancellation;
         }
         deregisterCancelLstnr();
         if (timeouted) {
-            log.warn("Fetch: Request timeouted.");
-            throw new RequestError(options.url, 0, NetworkErrorTypes.TIMEOUT);
+            log_1.default.warn("Fetch: Request timeouted.");
+            throw new errors_1.RequestError(options.url, 0, errors_1.NetworkErrorTypes.TIMEOUT);
         }
-        else if (err instanceof RequestError) {
+        else if (err instanceof errors_1.RequestError) {
             throw err;
         }
-        log.warn("Fetch: Request Error", err instanceof Error ? err.toString() :
+        log_1.default.warn("Fetch: Request Error", err instanceof Error ? err.toString() :
             "");
-        throw new RequestError(options.url, 0, NetworkErrorTypes.ERROR_EVENT);
+        throw new errors_1.RequestError(options.url, 0, errors_1.NetworkErrorTypes.ERROR_EVENT);
     });
 }
+exports.default = fetchRequest;
 /**
  * Returns true if fetch should be supported in the current browser.
  * @return {boolean}
  */
-export function fetchIsSupported() {
-    return (typeof globalScope.fetch === "function" &&
-        !isNullOrUndefined(_AbortController) &&
-        !isNullOrUndefined(_Headers));
+function fetchIsSupported() {
+    return (typeof global_scope_1.default.fetch === "function" &&
+        !(0, is_null_or_undefined_1.default)(_AbortController) &&
+        !(0, is_null_or_undefined_1.default)(_Headers));
 }
+exports.fetchIsSupported = fetchIsSupported;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import fetchRequest, { fetchIsSupported, } from "./fetch";
-import xhr from "./xhr";
-export default xhr;
-export { fetchIsSupported, fetchRequest, xhr, };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xhr = exports.fetchRequest = exports.fetchIsSupported = void 0;
+const fetch_1 = require("./fetch");
+exports.fetchRequest = fetch_1.default;
+Object.defineProperty(exports, "fetchIsSupported", { enumerable: true, get: function () { return fetch_1.fetchIsSupported; } });
+const xhr_1 = require("./xhr");
+exports.xhr = xhr_1.default;
+exports.default = xhr_1.default;