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

package/dist/_esm5.processed/utils/ranges.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.removeEmptyRanges = exports.mergeContiguousRanges = exports.keepRangeIntersection = exports.isTimeInRanges = exports.isTimeInRange = exports.isTimeInTimeRanges = exports.isBefore = exports.isAfter = exports.insertInto = exports.getSizeOfRange = exports.getRange = exports.getBufferedTimeRange = exports.getPlayedSizeOfRange = exports.getLeftSizeOfBufferedTimeRange = exports.getPlayedSizeOfBufferedTimeRange = exports.getSizeOfBufferedTimeRange = exports.getNextBufferedTimeRangeGap = exports.getLeftSizeOfRange = exports.getInnerAndOuterRanges = exports.getInnerAndOuterRangesFromBufferedTimeRanges = exports.excludeFromRanges = exports.convertToRanges = void 0;
 /**
  * This file contains functions helping with TimeRanges management.
  *
@@ -28,7 +31,7 @@
  * convertToRanges methods.
  */
 // Factor for rounding errors
-var EPSILON = 1 / 60;
+const EPSILON = 1 / 60;
 /**
  * Check equality with a tolerance of EPSILON.
  * Used for various functions with this sort of tolerance regarding the
@@ -48,9 +51,9 @@ function nearlyEqual(a, b) {
  * @returns {Object}
  */
 function createRangeUnion(range1, range2) {
-    var start = Math.min(range1.start, range2.start);
-    var end = Math.max(range1.end, range2.end);
-    return { start: start, end: end };
+    const start = Math.min(range1.start, range2.start);
+    const end = Math.max(range1.end, range2.end);
+    return { start, end };
 }
 /**
  * Clean array ranges from "empty" ranges.
@@ -60,30 +63,32 @@ function createRangeUnion(range1, range2) {
  * @returns {Array<Object>}
  */
 function removeEmptyRanges(ranges) {
-    for (var index = 0; index < ranges.length; index++) {
-        var range = ranges[index];
+    for (let index = 0; index < ranges.length; index++) {
+        const range = ranges[index];
         if (range.start === range.end) {
             ranges.splice(index--, 1);
         }
     }
     return ranges;
 }
+exports.removeEmptyRanges = removeEmptyRanges;
 /**
  * /!\ Mutate the array of ranges.
  * @param {Array<Object>} ranges
  * @returns {Array<Object>}
  */
 function mergeContiguousRanges(ranges) {
-    for (var index = 1; index < ranges.length; index++) {
-        var prevRange = ranges[index - 1];
-        var currRange = ranges[index];
+    for (let index = 1; index < ranges.length; index++) {
+        const prevRange = ranges[index - 1];
+        const currRange = ranges[index];
         if (areRangesNearlyContiguous(prevRange, currRange)) {
-            var unionRange = createRangeUnion(prevRange, currRange);
+            const unionRange = createRangeUnion(prevRange, currRange);
             ranges.splice(--index, 2, unionRange);
         }
     }
     return ranges;
 }
+exports.mergeContiguousRanges = mergeContiguousRanges;
 /**
  * True if range1 is considered _after_ range2.
  * @param {Object} range1
@@ -93,6 +98,7 @@ function mergeContiguousRanges(ranges) {
 function isAfter(range1, range2) {
     return range1.start >= range2.end;
 }
+exports.isAfter = isAfter;
 /**
  * True if range1 is considered _before_ range2.
  * @param {Object} range1
@@ -102,6 +108,7 @@ function isAfter(range1, range2) {
 function isBefore(range1, range2) {
     return range1.end <= range2.start;
 }
+exports.isBefore = isBefore;
 /**
  * Returns true if the time given can be considered as part of any of the given
  * ranges.
@@ -110,23 +117,24 @@ function isBefore(range1, range2) {
  * @returns {boolean}
  */
 function isTimeInRanges(ranges, time) {
-    for (var i = 0; i < ranges.length; i++) {
+    for (let i = 0; i < ranges.length; i++) {
         if (isTimeInRange(ranges[i], time)) {
             return true;
         }
     }
     return false;
 }
+exports.isTimeInRanges = isTimeInRanges;
 /**
  * Returns true if the time given can be considered as part of the given range.
  * @param {Object} range1
  * @param {Number} Time
  * @returns {Boolean}
  */
-function isTimeInRange(_a, time) {
-    var start = _a.start, end = _a.end;
+function isTimeInRange({ start, end }, time) {
     return start <= time && time < end;
 }
+exports.isTimeInRange = isTimeInRange;
 /**
  * Returns true if the two ranges given are overlapping.
  * @param {Object} range1
@@ -154,46 +162,67 @@ function areRangesNearlyContiguous(range1, range2) {
  * @returns {Array.<Object>}
  */
 function convertToRanges(timeRanges) {
-    var ranges = [];
-    for (var i = 0; i < timeRanges.length; i++) {
+    const ranges = [];
+    for (let i = 0; i < timeRanges.length; i++) {
         ranges.push({ start: timeRanges.start(i),
             end: timeRanges.end(i) });
     }
     return ranges;
 }
+exports.convertToRanges = convertToRanges;
 /**
  * Get range object of a specific time in a TimeRanges object.
  * @param {TimeRanges} timeRanges
  * @returns {Object}
  */
-function getRange(timeRanges, time) {
-    for (var i = timeRanges.length - 1; i >= 0; i--) {
-        var start = timeRanges.start(i);
+function getBufferedTimeRange(timeRanges, time) {
+    for (let i = timeRanges.length - 1; i >= 0; i--) {
+        const start = timeRanges.start(i);
         if (time >= start) {
-            var end = timeRanges.end(i);
+            const end = timeRanges.end(i);
             if (time < end) {
-                return { start: start, end: end };
+                return { start, end };
             }
         }
     }
     return null;
 }
+exports.getBufferedTimeRange = getBufferedTimeRange;
+/**
+ * Get range object of a specific time in a `IRange` object.
+ * @param {Array.<Object>} ranges
+ * @returns {Object}
+ */
+function getRange(ranges, time) {
+    for (let i = ranges.length - 1; i >= 0; i--) {
+        const start = ranges[i].start;
+        if (time >= start) {
+            const end = ranges[i].end;
+            if (time < end) {
+                return ranges[i];
+            }
+        }
+    }
+    return null;
+}
+exports.getRange = getRange;
 /**
  * Get gap from a specific time until the start of the next Range.
  * @param {TimeRanges} timeRanges
  * @param {Number} time
  * @returns {Number}
  */
-function getNextRangeGap(timeRanges, time) {
-    var len = timeRanges.length;
-    for (var i = 0; i < len; i++) {
-        var start = timeRanges.start(i);
+function getNextBufferedTimeRangeGap(timeRanges, time) {
+    const len = timeRanges.length;
+    for (let i = 0; i < len; i++) {
+        const start = timeRanges.start(i);
         if (time < start) {
             return start - time;
         }
     }
     return Infinity;
 }
+exports.getNextBufferedTimeRangeGap = getNextBufferedTimeRangeGap;
 /**
  * @param {TimeRanges} timeRanges
  * @param {Number} time
@@ -202,33 +231,59 @@ function getNextRangeGap(timeRanges, time) {
  *     given time.
  *   - innerRange {Object|null}: the range which contain the given time.
  */
-function getInnerAndOuterTimeRanges(timeRanges, time) {
-    var innerRange = null;
-    var outerRanges = [];
-    for (var i = 0; i < timeRanges.length; i++) {
-        var start = timeRanges.start(i);
-        var end = timeRanges.end(i);
+function getInnerAndOuterRangesFromBufferedTimeRanges(timeRanges, time) {
+    let innerRange = null;
+    const outerRanges = [];
+    for (let i = 0; i < timeRanges.length; i++) {
+        const start = timeRanges.start(i);
+        const end = timeRanges.end(i);
         if (time < start || time >= end) {
-            outerRanges.push({ start: start, end: end });
+            outerRanges.push({ start, end });
         }
         else {
-            innerRange = { start: start, end: end };
+            innerRange = { start, end };
         }
     }
-    return { outerRanges: outerRanges, innerRange: innerRange };
+    return { outerRanges, innerRange };
 }
+exports.getInnerAndOuterRangesFromBufferedTimeRanges = getInnerAndOuterRangesFromBufferedTimeRanges;
 /**
- * Get "size" (difference between end and start) of the range containing the
+ * @param {Array.<Object>} ranges
+ * @param {Number} time
+ * @returns {Object} - Object with two properties:
+ *   - outerRanges {Array.<Object>}: every ranges which does not contain the
+ *     given time.
+ *   - innerRange {Object|null}: the range which contain the given time.
+ */
+function getInnerAndOuterRanges(ranges, time) {
+    let innerRange = null;
+    const outerRanges = [];
+    for (let i = 0; i < ranges.length; i++) {
+        const start = ranges[i].start;
+        const end = ranges[i].end;
+        if (time < start || time >= end) {
+            outerRanges.push({ start, end });
+        }
+        else {
+            innerRange = { start, end };
+        }
+    }
+    return { outerRanges, innerRange };
+}
+exports.getInnerAndOuterRanges = getInnerAndOuterRanges;
+/**
+ * Get "size" (difference between end and start) of the TimeRange containing the
  * given time. 0 if the range is not found.
  * @param {TimeRanges} timeRanges
  * @param {Number} currentTime
  * @returns {Number}
  */
-function getSizeOfRange(timeRanges, currentTime) {
-    var range = getRange(timeRanges, currentTime);
+function getSizeOfBufferedTimeRange(timeRanges, currentTime) {
+    const range = getBufferedTimeRange(timeRanges, currentTime);
     return range !== null ? range.end - range.start :
         0;
 }
+exports.getSizeOfBufferedTimeRange = getSizeOfBufferedTimeRange;
 /**
  * Get "currently played" (difference between time given and start) of the
  * range containing the given time. 0 if the range is not found.
@@ -236,11 +291,12 @@ function getSizeOfRange(timeRanges, currentTime) {
  * @param {Number} currentTime
  * @returns {Number}
  */
-function getPlayedSizeOfRange(timeRanges, currentTime) {
-    var range = getRange(timeRanges, currentTime);
+function getPlayedSizeOfBufferedTimeRange(timeRanges, currentTime) {
+    const range = getBufferedTimeRange(timeRanges, currentTime);
     return range !== null ? currentTime - range.start :
         0;
 }
+exports.getPlayedSizeOfBufferedTimeRange = getPlayedSizeOfBufferedTimeRange;
 /**
  * Get "left to play" (difference between end and time given) of the range
  * containing the given time. Infinity if the range is not found.
@@ -248,11 +304,51 @@ function getPlayedSizeOfRange(timeRanges, currentTime) {
  * @param {Number} currentTime
  * @returns {Number}
  */
-function getLeftSizeOfRange(timeRanges, currentTime) {
-    var range = getRange(timeRanges, currentTime);
+function getLeftSizeOfBufferedTimeRange(timeRanges, currentTime) {
+    const range = getBufferedTimeRange(timeRanges, currentTime);
+    return range !== null ? range.end - currentTime :
+        Infinity;
+}
+exports.getLeftSizeOfBufferedTimeRange = getLeftSizeOfBufferedTimeRange;
+/**
+ * Get "size" (difference between end and start) of the range containing the
+ * given time. 0 if the range is not found.
+ * @param {Array.<Object>} ranges
+ * @param {Number} currentTime
+ * @returns {Number}
+ */
+function getSizeOfRange(ranges, currentTime) {
+    const range = getRange(ranges, currentTime);
+    return range !== null ? range.end - range.start :
+        0;
+}
+exports.getSizeOfRange = getSizeOfRange;
+/**
+ * Get "currently played" (difference between time given and start) of the
+ * range containing the given time. 0 if the range is not found.
+ * @param {Array.<Object>} ranges
+ * @param {Number} currentTime
+ * @returns {Number}
+ */
+function getPlayedSizeOfRange(ranges, currentTime) {
+    const range = getRange(ranges, currentTime);
+    return range !== null ? currentTime - range.start :
+        0;
+}
+exports.getPlayedSizeOfRange = getPlayedSizeOfRange;
+/**
+ * Get "left to play" (difference between end and time given) of the range
+ * containing the given time. Infinity if the range is not found.
+ * @param {Array.<Object>} ranges
+ * @param {Number} currentTime
+ * @returns {Number}
+ */
+function getLeftSizeOfRange(ranges, currentTime) {
+    const range = getRange(ranges, currentTime);
     return range !== null ? range.end - currentTime :
         Infinity;
 }
+exports.getLeftSizeOfRange = getLeftSizeOfRange;
 /**
  * Insert a range object into an array of ranges objects, at the right place.
  * /!\ Mutate the array of ranges.
@@ -264,7 +360,7 @@ function insertInto(ranges, rangeToAddArg) {
     if (rangeToAddArg.start === rangeToAddArg.end) {
         return ranges;
     }
-    var rangeToAdd = rangeToAddArg;
+    let rangeToAdd = rangeToAddArg;
     // For each present range check if we need to:
     // - In case we are overlapping or contiguous:
     //   - if added range has the same bitrate as the overlapped or
@@ -273,11 +369,11 @@ function insertInto(ranges, rangeToAddArg) {
     //     in place
     // - Need to insert in place, we we are completely, not overlapping
     //   and not contiguous in between two ranges.
-    var index = 0;
+    let index = 0;
     for (; index < ranges.length; index++) {
-        var range = ranges[index];
-        var overlapping = areRangesOverlapping(rangeToAdd, range);
-        var contiguous = areRangesNearlyContiguous(rangeToAdd, range);
+        const range = ranges[index];
+        const overlapping = areRangesOverlapping(rangeToAdd, range);
+        const contiguous = areRangesNearlyContiguous(rangeToAdd, range);
         // We assume ranges are ordered and two ranges can not be
         // completely overlapping.
         if (overlapping || contiguous) {
@@ -309,6 +405,7 @@ function insertInto(ranges, rangeToAddArg) {
     ranges.splice(index, 0, rangeToAdd);
     return mergeContiguousRanges(removeEmptyRanges(ranges));
 }
+exports.insertInto = insertInto;
 /**
  * Returns range, from a range objects array overlapping with a range given
  * in argument. null if none is found.
@@ -317,8 +414,8 @@ function insertInto(ranges, rangeToAddArg) {
  * @returns {Array.<Object>}
  */
 function findOverlappingRanges(range, ranges) {
-    var resultingRanges = [];
-    for (var i = 0; i < ranges.length; i++) {
+    const resultingRanges = [];
+    for (let i = 0; i < ranges.length; i++) {
         if (areRangesOverlapping(range, ranges[i])) {
             resultingRanges.push(ranges[i]);
         }
@@ -333,13 +430,13 @@ function findOverlappingRanges(range, ranges) {
  * @returns {Array.<Range>}
  */
 function keepRangeIntersection(ranges1, ranges2) {
-    var result = [];
-    for (var i = 0; i < ranges1.length; i++) {
-        var range = ranges1[i];
-        var overlappingRanges = findOverlappingRanges(range, ranges2);
+    const result = [];
+    for (let i = 0; i < ranges1.length; i++) {
+        const range = ranges1[i];
+        const overlappingRanges = findOverlappingRanges(range, ranges2);
         if (overlappingRanges.length > 0) {
-            for (var j = 0; j < overlappingRanges.length; j++) {
-                var overlappingRange = overlappingRanges[j];
+            for (let j = 0; j < overlappingRanges.length; j++) {
+                const overlappingRange = overlappingRanges[j];
                 result.push({ start: Math.max(range.start, overlappingRange.start),
                     end: Math.min(range.end, overlappingRange.end) });
             }
@@ -347,6 +444,7 @@ function keepRangeIntersection(ranges1, ranges2) {
     }
     return result;
 }
+exports.keepRangeIntersection = keepRangeIntersection;
 /**
  * Exclude from the `baseRanges` everything that is in `rangesToExclude`.
  * Example:
@@ -374,16 +472,16 @@ function keepRangeIntersection(ranges1, ranges2) {
  * @return {Array.<Object>}
  */
 function excludeFromRanges(baseRanges, rangesToExclude) {
-    var result = [];
+    const result = [];
     // For every range in `baseRanges`, find overlapping ranges with
     // `rangesToExclude` and remove them.
-    for (var i = 0; i < baseRanges.length; i++) {
-        var range = baseRanges[i];
-        var intersections = [];
-        var overlappingRanges = findOverlappingRanges(range, rangesToExclude);
+    for (let i = 0; i < baseRanges.length; i++) {
+        const range = baseRanges[i];
+        const intersections = [];
+        const overlappingRanges = findOverlappingRanges(range, rangesToExclude);
         if (overlappingRanges.length > 0) {
-            for (var j = 0; j < overlappingRanges.length; j++) {
-                var overlappingRange = overlappingRanges[j];
+            for (let j = 0; j < overlappingRanges.length; j++) {
+                const overlappingRange = overlappingRanges[j];
                 intersections.push({ start: Math.max(range.start, overlappingRange.start),
                     end: Math.min(range.end, overlappingRange.end) });
             }
@@ -392,8 +490,8 @@ function excludeFromRanges(baseRanges, rangesToExclude) {
             result.push(range);
         }
         else {
-            var lastStart = range.start;
-            for (var j = 0; j < intersections.length; j++) {
+            let lastStart = range.start;
+            for (let j = 0; j < intersections.length; j++) {
                 if (intersections[j].start > lastStart) {
                     result.push({ start: lastStart,
                         end: intersections[j].start });
@@ -408,6 +506,7 @@ function excludeFromRanges(baseRanges, rangesToExclude) {
     }
     return result;
 }
+exports.excludeFromRanges = excludeFromRanges;
 /**
  * Returns `true` if the given `time` is available in the TimeRanges object
  * given.
@@ -417,11 +516,11 @@ function excludeFromRanges(baseRanges, rangesToExclude) {
  * @returns {boolean}
  */
 function isTimeInTimeRanges(ranges, time) {
-    for (var i = 0; i < ranges.length; i++) {
+    for (let i = 0; i < ranges.length; i++) {
         if (ranges.start(i) <= time && time < ranges.end(i)) {
             return true;
         }
     }
     return false;
 }
-export { convertToRanges, excludeFromRanges, getInnerAndOuterTimeRanges, getLeftSizeOfRange, getNextRangeGap, getPlayedSizeOfRange, getRange, getSizeOfRange, insertInto, isAfter, isBefore, isTimeInTimeRanges, isTimeInRange, isTimeInRanges, keepRangeIntersection, mergeContiguousRanges, removeEmptyRanges, };
+exports.isTimeInTimeRanges = isTimeInTimeRanges;

package/dist/_esm5.processed/utils/reference.d.ts

@@ -17,18 +17,18 @@ import { CancellationSignal } from "./task_canceller";
 /**
  * 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 `ISharedReference`.
+ * the same `SharedReference`.
  *
  * @example
  * ```ts
  * const myVal = 1;
- * const myRef : ISharedReference<number> = createSharedReference(1);
+ * const myRef : SharedReference<number> = new SharedReference(1);
  *
  * function setValTo2(num : number) {
  *   num = 2;
  * }
  *
- * function setRefTo2(num : ISharedReference<number>) {
+ * function setRefTo2(num : SharedReference<number>) {
  *   num.setValue(2);
  * }
  *
@@ -50,9 +50,54 @@ import { CancellationSignal } from "./task_canceller";
  * 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 interface ISharedReference<T> {
+declare class SharedReference<T> {
+    /** Current value referenced by this `SharedReference`. */
+    private _value;
     /**
-     * Get the last set value for this shared reference.
+     * 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".
+     */
+    private _listeners;
+    /**
+     * Set to `true` when this `SharedReference` is finished in which case it
+     * cannot be updated nor emit values anymore.
+     */
+    private _isFinished;
+    /**
+     * Callbacks triggered when the `SharedReference` is finished.
+     */
+    private _onFinishCbs;
+    /**
+     * Store a reference to the callback allowing to finish the `SharedReference`
+     * on some event. Allows to remove the logic when it's not needed anymore.
+     */
+    private _deregisterCancellation;
+    /**
+     * 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: T, cancelSignal?: CancellationSignal);
+    /**
+     * Returns the current value of this shared reference.
      * @returns {*}
      */
     getValue(): T;
@@ -75,12 +120,12 @@ export interface ISharedReference<T> {
      * 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
-     * function allowing to unregister the update listening callback.
-     * @param {Object} [options]
-     * @param {Object} [options.clearSignal] - Allows to provide 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} [options.emitCurrentValue] - If `true`, the callback will
-     * also be immediately (synchronously) called with the current value.
+     * @param {boolean|undefined} [options.emitCurrentValue] - If `true`, the
+     * callback will also be immediately called with the current value.
      */
     onUpdate(cb: (val: T, stopListening: () => void) => void, options?: {
         clearSignal?: CancellationSignal | undefined;
@@ -106,31 +151,42 @@ export interface ISharedReference<T> {
      * ```
      * @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
+     * @param {Object | undefined} [options]
+     * @param {Object | undefined} [options.clearSignal] - Allows to provide a
      * CancellationSignal which will unregister the callback when it emits.
      */
     waitUntilDefined(cb: (val: Exclude<T, undefined>) => void, options?: {
         clearSignal?: CancellationSignal | undefined;
     } | undefined): void;
+    /**
+     * 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: () => void, onFinishCancelSignal: CancellationSignal): () => void;
     /**
      * Indicate that no new values will be emitted.
-     * Allows to automatically close all listeners listening to this
-     * `ISharedReference`.
+     * Allows to automatically free all listeners linked to this reference.
      */
     finish(): void;
 }
 /**
- * An `ISharedReference` which can only be read and not updated.
+ * A `SharedReference` which can only be read and not updated.
  *
- * Because an `ISharedReference` is structurally compatible to a
+ * Because a `SharedReference` is structurally compatible to a
  * `IReadOnlySharedReference`, and because of TypeScript variance rules, it can
  * be upcasted into a `IReadOnlySharedReference` at any time to make it clear in
  * the code that some logic is not supposed to update the referenced value.
  *
  * @example
  * ```ts
- * const myReference : ISharedReference<number> = createSharedReference(4);
+ * const myReference : SharedReference<number> = new SharedReference(4);
  *
  * function shouldOnlyReadIt(roRef : IReadOnlySharedReference<number>) {
  *   console.log("current value:", roRef.getValue());
@@ -142,26 +198,11 @@ export interface ISharedReference<T> {
  * shouldOnlyReadIt(myReference); // output: "current value: 12"
  * ```
  */
-export type IReadOnlySharedReference<T> = Pick<ISharedReference<T>, "getValue" | "onUpdate" | "waitUntilDefined">;
-/**
- * Create an `ISharedReference` object encapsulating the mutable `initialValue`
- * value of type T.
- *
- * @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}
- */
-export default function createSharedReference<T>(initialValue: T, cancelSignal?: CancellationSignal): ISharedReference<T>;
+export type IReadOnlySharedReference<T> = Pick<SharedReference<T>, "getValue" | "onUpdate" | "waitUntilDefined" | "_onFinished">;
 /**
- * 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.
@@ -170,4 +211,4 @@ export default function createSharedReference<T>(initialValue: T, cancelSignal?:
  * @returns {Object} - The new, mapped, reference.
  */
 export declare function createMappedReference<T, U>(originalRef: IReadOnlySharedReference<T>, mappingFn: (x: T) => U, cancellationSignal: CancellationSignal): IReadOnlySharedReference<U>;
-export { createSharedReference };
+export default SharedReference;