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

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,168 +14,230 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMappedReference = void 0;
+const array_find_index_1 = require("./array_find_index");
+const noop_1 = require("./noop");
 /**
- * Create an `ISharedReference` object encapsulating the mutable `initialValue`
- * value of type T.
+ * 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
+ * the same `SharedReference`.
  *
- * @see ISharedReference
- * @param {*} initialValue
- * @param {Object|undefined} [cancelSignal] - If set, the created shared
- * reference will be automatically "finished" once that signal emits.
- * Finished references won't be able to update their value anymore, and will
- * also automatically have their listeners (callbacks linked to value change)
- * removed - as they cannot be triggered anymore, thus providing a security
- * against memory leaks.
- * @returns {Object}
+ * @example
+ * ```ts
+ * const myVal = 1;
+ * const myRef : SharedReference<number> = new SharedReference(1);
+ *
+ * function setValTo2(num : number) {
+ *   num = 2;
+ * }
+ *
+ * function setRefTo2(num : SharedReference<number>) {
+ *   num.setValue(2);
+ * }
+ *
+ * setValTo2(myVal);
+ * console.log(myVal); // output: 1
+ *
+ * myRef.onUpdate((val) => {
+ *   console.log(val); // outputs first synchronously `1`, then `2`
+ * }, { emitCurrentValue: true });
+ *
+ * setRefTo2(myRef);
+ * console.log(myRef.getValue()); // output: 2
+ *
+ * myRef.listen((val) => {
+ *   console.log(val); // outputs only `2`
+ * }, { emitCurrentValue: true });
+ * ```
+ *
+ * This type was added because we found that the usage of an explicit type for
+ * those use cases makes the intent of the corresponding code clearer.
  */
-export default function createSharedReference(initialValue, cancelSignal) {
-    /** Current value referenced by this `ISharedReference`. */
-    var value = initialValue;
+class SharedReference {
     /**
-     * Attributes each linked to a single registered callbacks which listen to the
-     * referenced value's updates.
-     *
-     * Contains the following properties:
-     *   - `trigger`: Function which will be called with the new reference's value
-     *     once it changes
-     *   - `complete`: Allows to clean-up the listener, will be called once the
-     *     reference is finished.
-     *   - `hasBeenCleared`: becomes `true` when the reference is
-     *     removed from the `cbs` array.
-     *     Adding this property allows to detect when a previously-added
-     *     listener has since been removed e.g. as a side-effect during a
-     *     function call.
-     *   - `complete`: Callback to call when the current Reference is "finished".
+     * Create a `SharedReference` object encapsulating the mutable `initialValue`
+     * value of type T.
+     * @param {*} initialValue
+     * @param {Object|undefined} [cancelSignal] - If set, the created shared
+     * reference will be automatically "finished" once that signal emits.
+     * Finished references won't be able to update their value anymore, and will
+     * also automatically have their listeners (callbacks linked to value change)
+     * removed - as they cannot be triggered anymore, thus providing a security
+     * against memory leaks.
+     */
+    constructor(initialValue, cancelSignal) {
+        this._value = initialValue;
+        this._listeners = [];
+        this._isFinished = false;
+        this._onFinishCbs = [];
+        if (cancelSignal !== undefined) {
+            this._deregisterCancellation = cancelSignal.register(() => this.finish());
+        }
+    }
+    /**
+     * Returns the current value of this shared reference.
+     * @returns {*}
      */
-    var cbs = [];
-    var isFinished = false;
-    if (cancelSignal !== undefined) {
-        cancelSignal.register(finish);
+    getValue() {
+        return this._value;
     }
-    return {
-        /**
-         * Returns the current value of this shared reference.
-         * @returns {*}
-         */
-        getValue: function () {
-            return value;
-        },
-        /**
-         * Update the value of this shared reference.
-         * @param {*} newVal
-         */
-        setValue: function (newVal) {
-            if (isFinished) {
-                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-                    /* eslint-disable-next-line no-console */
-                    console.error("Finished shared references cannot be updated");
-                }
-                return;
-            }
-            value = newVal;
-            if (cbs.length === 0) {
-                return;
+    /**
+     * Update the value of this shared reference.
+     * @param {*} newVal
+     */
+    setValue(newVal) {
+        if (this._isFinished) {
+            if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+                /* eslint-disable-next-line no-console */
+                console.error("Finished shared references cannot be updated");
             }
-            var clonedCbs = cbs.slice();
-            for (var _i = 0, clonedCbs_1 = clonedCbs; _i < clonedCbs_1.length; _i++) {
-                var cbObj = clonedCbs_1[_i];
-                try {
-                    if (!cbObj.hasBeenCleared) {
-                        cbObj.trigger(newVal, cbObj.complete);
-                    }
-                }
-                catch (_) {
-                    /* nothing */
+            return;
+        }
+        this._value = newVal;
+        if (this._listeners.length === 0) {
+            return;
+        }
+        const clonedCbs = this._listeners.slice();
+        for (const cbObj of clonedCbs) {
+            try {
+                if (!cbObj.hasBeenCleared) {
+                    cbObj.trigger(newVal, cbObj.complete);
                 }
             }
-        },
-        /**
-         * Update the value of this shared reference only if it changed.
-         * @param {*} newVal
-         */
-        setValueIfChanged: function (newVal) {
-            if (newVal !== value) {
-                this.setValue(newVal);
+            catch (_) {
+                /* nothing */
             }
-        },
-        /**
-         * Allows to register a callback to be called each time the value inside the
-         * reference is updated.
-         * @param {Function} cb - Callback to be called each time the reference is
-         * updated. Takes as first argument its new value and in second argument a
-         * callback allowing to unregister the callback.
-         * @param {Object|undefined} [options]
-         * @param {Object|undefined} [options.clearSignal] - Allows to provide a
-         * CancellationSignal which will unregister the callback when it emits.
-         * @param {boolean|undefined} [options.emitCurrentValue] - If `true`, the
-         * callback will also be immediately called with the current value.
-         */
-        onUpdate: function (cb, options) {
-            var cbObj = { trigger: cb,
-                complete: unlisten,
-                hasBeenCleared: false };
-            cbs.push(cbObj);
-            if ((options === null || options === void 0 ? void 0 : options.emitCurrentValue) === true) {
-                cb(value, unlisten);
+        }
+    }
+    /**
+     * Update the value of this shared reference only if the value changed.
+     *
+     * Note that this function only performs a strict equality reference through
+     * the "===" operator. Different objects that are structurally the same will
+     * thus be considered different.
+     * @param {*} 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.
+     * @param {Function} cb - Callback to be called each time the reference is
+     * updated. Takes as first argument its new value and in second argument a
+     * callback allowing to unregister the callback.
+     * @param {Object|undefined} [options]
+     * @param {Object|undefined} [options.clearSignal] - Allows to provide a
+     * CancellationSignal which will unregister the callback when it emits.
+     * @param {boolean|undefined} [options.emitCurrentValue] - If `true`, the
+     * callback will also be immediately called with the current value.
+     */
+    onUpdate(cb, options) {
+        const unlisten = () => {
+            if ((options === null || options === void 0 ? void 0 : options.clearSignal) !== undefined) {
+                options.clearSignal.deregister(unlisten);
             }
-            if (isFinished || cbObj.hasBeenCleared) {
-                unlisten();
+            if (cbObj.hasBeenCleared) {
                 return;
             }
-            if ((options === null || options === void 0 ? void 0 : options.clearSignal) === undefined) {
-                return;
+            cbObj.hasBeenCleared = true;
+            const indexOf = this._listeners.indexOf(cbObj);
+            if (indexOf >= 0) {
+                this._listeners.splice(indexOf, 1);
             }
-            options.clearSignal.register(unlisten);
-            function unlisten() {
-                if ((options === null || options === void 0 ? void 0 : options.clearSignal) !== undefined) {
-                    options.clearSignal.deregister(unlisten);
-                }
-                if (cbObj.hasBeenCleared) {
-                    return;
-                }
-                cbObj.hasBeenCleared = true;
-                var indexOf = cbs.indexOf(cbObj);
-                if (indexOf >= 0) {
-                    cbs.splice(indexOf, 1);
-                }
+        };
+        const cbObj = { trigger: cb,
+            complete: unlisten,
+            hasBeenCleared: false };
+        this._listeners.push(cbObj);
+        if ((options === null || options === void 0 ? void 0 : options.emitCurrentValue) === true) {
+            cb(this._value, unlisten);
+        }
+        if (this._isFinished || cbObj.hasBeenCleared) {
+            unlisten();
+            return;
+        }
+        if ((options === null || options === void 0 ? void 0 : options.clearSignal) === undefined) {
+            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`.
+     * The callback is called synchronously if the value already isn't set to
+     * `undefined`.
+     *
+     * This method can be used as a lighter weight alternative to `onUpdate` when
+     * just waiting that the stored value becomes defined.
+     * As such, it is an explicit equivalent to something like:
+     * ```js
+     * myReference.onUpdate((newVal, stopListening) => {
+     *  if (newVal !== undefined) {
+     *    stopListening();
+     *
+     *    // ... do the logic
+     *  }
+     * }, { emitCurrentValue: true });
+     * ```
+     * @param {Function} cb - Callback to be called each time the reference is
+     * updated. Takes the new value in argument.
+     * @param {Object | undefined} [options]
+     * @param {Object | undefined} [options.clearSignal] - Allows to provide a
+     * CancellationSignal which will unregister the callback when it emits.
+     */
+    waitUntilDefined(cb, options) {
+        this.onUpdate((val, stopListening) => {
+            if (val !== undefined) {
+                stopListening();
+                cb(this._value);
             }
-        },
-        /**
-         * Variant of `onUpdate` which will only call the callback once, once the
-         * value inside the reference is different from `undefined`.
-         * The callback is called synchronously if the value already isn't set to
-         * `undefined`.
-         *
-         * This method can be used as a lighter weight alternative to `onUpdate`
-         * when just waiting that the stored value becomes defined.
-         * @param {Function} cb - Callback to be called each time the reference is
-         * updated. Takes the new value in argument.
-         * @param {Object} [options]
-         * @param {Object} [options.clearSignal] - Allows to provide a
-         * CancellationSignal which will unregister the callback when it emits.
-         */
-        waitUntilDefined: function (cb, options) {
-            this.onUpdate(function (val, stopListening) {
-                if (val !== undefined) {
-                    stopListening();
-                    cb(value);
-                }
-            }, { clearSignal: options === null || options === void 0 ? void 0 : options.clearSignal, emitCurrentValue: true });
-        },
-        /**
-         * Indicate that no new values will be emitted.
-         * Allows to automatically free all listeners linked to this reference.
-         */
-        finish: finish,
-    };
-    function finish() {
-        if (cancelSignal !== undefined) {
-            cancelSignal.deregister(finish);
+        }, { clearSignal: options === null || options === void 0 ? void 0 : options.clearSignal, emitCurrentValue: true });
+    }
+    /**
+     * Allows to register a callback for when the Shared Reference is "finished".
+     *
+     * This function is mostly there for implementing operators on the shared
+     * reference and isn't meant to be used by regular code, hence it being
+     * prefixed by `_`.
+     * @param {Function} cb - Callback to be called once the reference is
+     * finished.
+     * @param {Object} onFinishCancelSignal - Allows to provide a
+     * CancellationSignal which will unregister the callback when it emits.
+     */
+    _onFinished(cb, onFinishCancelSignal) {
+        if (onFinishCancelSignal.isCancelled()) {
+            return noop_1.default;
+        }
+        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);
+            }
+        };
+        const trigger = () => {
+            cleanUp();
+            cb();
+        };
+        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.
+     */
+    finish() {
+        if (this._deregisterCancellation !== undefined) {
+            this._deregisterCancellation();
         }
-        isFinished = true;
-        var clonedCbs = cbs.slice();
-        for (var _i = 0, clonedCbs_2 = clonedCbs; _i < clonedCbs_2.length; _i++) {
-            var cbObj = clonedCbs_2[_i];
+        this._isFinished = true;
+        const clonedCbs = this._listeners.slice();
+        for (const cbObj of clonedCbs) {
             try {
                 if (!cbObj.hasBeenCleared) {
                     cbObj.complete();
@@ -185,13 +248,28 @@ export default function createSharedReference(initialValue, cancelSignal) {
                 /* nothing */
             }
         }
-        cbs.length = 0;
+        this._listeners.length = 0;
+        if (this._onFinishCbs.length > 0) {
+            const clonedFinishedCbs = this._onFinishCbs.slice();
+            for (const cbObj of clonedFinishedCbs) {
+                try {
+                    if (!cbObj.hasBeenCleared) {
+                        cbObj.trigger();
+                        cbObj.hasBeenCleared = true;
+                    }
+                }
+                catch (_) {
+                    /* nothing */
+                }
+            }
+            this._onFinishCbs.length = 0;
+        }
     }
 }
 /**
- * Create a new `ISharedReference` based on another one by mapping over its
- * referenced value each time it is updated.
- * @param {Object} originalRef - The Original `ISharedReference` you wish to map
+ * Create a new `SharedReference` based on another one by mapping over its
+ * referenced value each time it is updated and finishing once it finishes.
+ * @param {Object} originalRef - The Original `SharedReference` you wish to map
  * over.
  * @param {Function} mappingFn - The mapping function which will receives
  * `originalRef`'s value and outputs this new reference's value.
@@ -199,13 +277,15 @@ export default function createSharedReference(initialValue, cancelSignal) {
  * will finish that reference when it emits.
  * @returns {Object} - The new, mapped, reference.
  */
-export function createMappedReference(originalRef, mappingFn, cancellationSignal) {
-    var newRef = createSharedReference(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 });
-    // TODO nothing is done if `originalRef` is finished, though the returned
-    // reference could also be finished in that case. To do?
+    originalRef._onFinished(() => {
+        newRef.finish();
+    }, cancellationSignal);
     return newRef;
 }
-export { createSharedReference };
+exports.createMappedReference = createMappedReference;
+exports.default = SharedReference;

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

@@ -3,9 +3,9 @@ import { CancellationSignal } from "../task_canceller";
 export interface IFetchedStreamComplete {
     /** Duration of the whole request, in milliseconds. */
     requestDuration: number;
-    /** Result of `performance.now()` at the time the request was received. */
+    /** Monotonically-raising timestamp at the time the request was received. */
     receivedTime: number;
-    /** Result of `performance.now()` at the time the request was started. */
+    /** Monotonically-raising timestamp at the time the request was started. */
     sendingTime: number;
     /** Size of the entire emitted data, in bytes. */
     size: number;
@@ -16,7 +16,7 @@ export interface IFetchedStreamComplete {
 }
 /** Object emitted by `fetchRequest` when a new chunk of the data is available. */
 export interface IFetchedDataObject {
-    /** Result of `performance.now()` at the time this data was recuperated. */
+    /** Monotonically-raising timestamp at the time this data was recuperated. */
     currentTime: number;
     /** Duration of the request until `currentTime`, in milliseconds. */
     duration: number;
@@ -24,7 +24,7 @@ export interface IFetchedDataObject {
     chunkSize: number;
     /** Cumulated size of the received data by the request until now. */
     size: number;
-    /** Result of `performance.now()` at the time the request began. */
+    /** Monotonically-raising timestamp at the time the request began. */
     sendingTime: number;
     /** URL of the recuperated data (post-redirection if one). */
     url: string;