rx-player 3.26.2 → 3.27.0-dev.20220317

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

@@ -24,12 +24,48 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import PPromise from "pinkie";
+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 (_) 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 features from "../../features";
 import log from "../../log";
 import Manifest from "../../manifest";
 import { getMDAT } from "../../parsers/containers/isobmff";
 import createSmoothManifestParser, { SmoothRepresentationIndex, } from "../../parsers/manifest/smooth";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import { strToUtf8, utf8ToStr, } from "../../utils/string_parsing";
 import warnOnce from "../../utils/warn_once";
@@ -134,6 +170,7 @@ export default function (options) {
                 if (segment.isInit) {
                     return { segmentType: "init",
                         initializationData: null,
+                        initializationDataSize: 0,
                         protectionDataUpdate: false,
                         initTimescale: undefined };
                 }
@@ -141,6 +178,7 @@ export default function (options) {
                     chunkData: null,
                     chunkInfos: null,
                     chunkOffset: 0,
+                    chunkSize: 0,
                     protectionDataUpdate: false,
                     appendWindow: [undefined, undefined] };
             }
@@ -150,6 +188,7 @@ export default function (options) {
                 var timescale = (_b = (_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothInitSegment) === null || _b === void 0 ? void 0 : _b.timescale;
                 return { segmentType: "init",
                     initializationData: data,
+                    initializationDataSize: data.byteLength,
                     // smooth init segments are crafted by hand.
                     // Their timescale is the one from the manifest.
                     initTimescale: timescale,
@@ -169,6 +208,7 @@ export default function (options) {
                 addNextSegments(adaptation, nextSegments, segment);
             }
             return { segmentType: "media", chunkData: chunkData, chunkInfos: chunkInfos, chunkOffset: 0,
+                chunkSize: chunkData.length,
                 protectionDataUpdate: false,
                 appendWindow: [undefined, undefined] };
         },
@@ -207,9 +247,11 @@ export default function (options) {
             var isMP4 = isMP4EmbeddedTrack(representation);
             var _b = representation.mimeType, mimeType = _b === void 0 ? "" : _b, _c = representation.codec, codec = _c === void 0 ? "" : _c;
             var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
+            var chunkSize;
             if (segment.isInit) { // text init segment has no use in HSS
                 return { segmentType: "init",
                     initializationData: null,
+                    initializationDataSize: 0,
                     protectionDataUpdate: false,
                     initTimescale: undefined };
             }
@@ -218,6 +260,7 @@ export default function (options) {
                     chunkData: null,
                     chunkInfos: null,
                     chunkOffset: 0,
+                    chunkSize: 0,
                     protectionDataUpdate: false,
                     appendWindow: [undefined, undefined] };
             }
@@ -236,6 +279,7 @@ export default function (options) {
                     chunkBytes = data instanceof Uint8Array ? data :
                         new Uint8Array(data);
                 }
+                chunkSize = chunkBytes.length;
                 var timingInfos = initTimescale !== undefined ?
                     extractTimingsInfos(chunkBytes, isChunked, initTimescale, segment, manifest.isLive) :
                     null;
@@ -279,6 +323,7 @@ export default function (options) {
                 if (typeof data !== "string") {
                     var bytesData = data instanceof Uint8Array ? data :
                         new Uint8Array(data);
+                    chunkSize = bytesData.length;
                     chunkString = utf8ToStr(bytesData);
                 }
                 else {
@@ -316,27 +361,38 @@ export default function (options) {
                 chunkData: { type: _sdType,
                     data: _sdData,
                     start: segmentStart,
-                    end: segmentEnd, language: language }, chunkInfos: chunkInfos, chunkOffset: chunkOffset, protectionDataUpdate: false,
+                    end: segmentEnd, language: language }, chunkSize: chunkSize, chunkInfos: chunkInfos, chunkOffset: chunkOffset, protectionDataUpdate: false,
                 appendWindow: [undefined, undefined] };
         },
     };
     var imageTrackPipeline = {
         loadSegment: function (url, content, cancelSignal, callbacks) {
-            if (content.segment.isInit || url === null) {
-                // image do not need an init segment. Passthrough directly to the parser
-                return PPromise.resolve({ resultType: "segment-created",
-                    resultData: null });
-            }
-            return request({ url: url, responseType: "arraybuffer",
-                onProgress: callbacks.onProgress, cancelSignal: cancelSignal })
-                .then(function (data) { return ({ resultType: "segment-loaded",
-                resultData: data }); });
+            return __awaiter(this, void 0, void 0, function () {
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (content.segment.isInit || url === null) {
+                                // image do not need an init segment. Passthrough directly to the parser
+                                return [2 /*return*/, { resultType: "segment-created",
+                                        resultData: null }];
+                            }
+                            return [4 /*yield*/, request({ url: url, responseType: "arraybuffer",
+                                    onProgress: callbacks.onProgress, cancelSignal: cancelSignal })];
+                        case 1:
+                            data = _a.sent();
+                            return [2 /*return*/, { resultType: "segment-loaded",
+                                    resultData: data }];
+                    }
+                });
+            });
         },
         parseSegment: function (loadedSegment, content, _initTimescale) {
             var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
             if (content.segment.isInit) { // image init segment has no use
                 return { segmentType: "init",
                     initializationData: null,
+                    initializationDataSize: 0,
                     protectionDataUpdate: false,
                     initTimescale: undefined };
             }
@@ -349,6 +405,7 @@ export default function (options) {
                     chunkData: null,
                     chunkInfos: null,
                     chunkOffset: 0,
+                    chunkSize: 0,
                     protectionDataUpdate: false,
                     appendWindow: [undefined, undefined] };
             }
@@ -362,6 +419,7 @@ export default function (options) {
                     type: "bif" },
                 chunkInfos: { time: 0,
                     duration: Number.MAX_VALUE },
+                chunkSize: undefined,
                 chunkOffset: 0,
                 protectionDataUpdate: false,
                 appendWindow: [undefined, undefined] };

package/dist/_esm5.processed/transports/smooth/segment_loader.d.ts

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PPromise from "pinkie";
 import { CancellationSignal } from "../../utils/task_canceller";
 import { ICustomSegmentLoader, ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
 /**

package/dist/_esm5.processed/transports/smooth/segment_loader.js

@@ -24,9 +24,9 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import PPromise from "pinkie";
 import { CustomLoaderError } from "../../errors";
 import assert from "../../utils/assert";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import byteRange from "../utils/byte_range";
 import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
@@ -110,7 +110,7 @@ var generateSegmentLoader = function (_a) {
             if (typeof customSegmentLoader !== "function") {
                 return regularSegmentLoader(url, content, callbacks, cancelSignal, checkMediaSegmentIntegrity);
             }
-            return new Promise(function (res, rej) {
+            return new PPromise(function (res, rej) {
                 /** `true` when the custom segmentLoader should not be active anymore. */
                 var hasFinished = false;
                 /**

package/dist/_esm5.processed/transports/types.d.ts

@@ -300,7 +300,7 @@ export interface IManifestParserResult {
      * This property should only be set when a unique URL is sufficient to
      * retrieve the whole data.
      */
-    url?: string;
+    url?: string | undefined;
 }
 /**
  * Allow the parser to ask for loading supplementary ressources while still
@@ -340,11 +340,11 @@ export interface ITextTrackSegmentData {
      * This is mostly needed for "sami" subtitles, to know which cues can / should
      * be parsed.
      */
-    language?: string;
+    language?: string | undefined;
     /** start time from which the segment apply, in seconds. */
-    start?: number;
+    start?: number | undefined;
     /** end time until which the segment apply, in seconds. */
-    end?: number;
+    end?: number | undefined;
 }
 /** Format under which image data is decodable by the RxPlayer. */
 export interface IImageTrackSegmentData {
@@ -393,18 +393,18 @@ interface IServerSyncInfos {
     clientTime: number;
 }
 export interface ITransportOptions {
-    aggressiveMode?: boolean;
-    checkMediaSegmentIntegrity?: boolean;
+    aggressiveMode?: boolean | undefined;
+    checkMediaSegmentIntegrity?: boolean | undefined;
     lowLatencyMode: boolean;
-    manifestLoader?: ICustomManifestLoader;
-    manifestUpdateUrl?: string;
-    referenceDateTime?: number;
-    representationFilter?: IRepresentationFilter;
-    segmentLoader?: ICustomSegmentLoader;
-    serverSyncInfos?: IServerSyncInfos;
-    supplementaryImageTracks?: ISupplementaryImageTrack[];
-    supplementaryTextTracks?: ISupplementaryTextTrack[];
-    __priv_patchLastSegmentInSidx?: boolean;
+    manifestLoader?: ICustomManifestLoader | undefined;
+    manifestUpdateUrl?: string | undefined;
+    referenceDateTime?: number | undefined;
+    representationFilter?: IRepresentationFilter | undefined;
+    segmentLoader?: ICustomSegmentLoader | undefined;
+    serverSyncInfos?: IServerSyncInfos | undefined;
+    supplementaryImageTracks?: ISupplementaryImageTrack[] | undefined;
+    supplementaryTextTracks?: ISupplementaryTextTrack[] | undefined;
+    __priv_patchLastSegmentInSidx?: boolean | undefined;
 }
 export declare type ICustomSegmentLoader = (infos: {
     url: string;
@@ -422,18 +422,24 @@ export declare type ICustomSegmentLoader = (infos: {
         duration?: number | undefined;
     }) => void;
     reject: (err?: unknown) => void;
-    fallback?: (() => void) | undefined;
+    fallback: () => void;
+    progress: (info: {
+        duration: number;
+        size: number;
+        totalSize?: number | undefined;
+    }) => void;
 }) => (() => void) | void;
 export declare type ICustomManifestLoader = (url: string | undefined, callbacks: {
     resolve: (args: {
         data: ILoadedManifestFormat;
-        sendingTime?: number;
-        receivingTime?: number;
-        size?: number;
-        duration?: number;
+        url?: string | undefined;
+        sendingTime?: number | undefined;
+        receivingTime?: number | undefined;
+        size?: number | undefined;
+        duration?: number | undefined;
     }) => void;
     reject: (err?: Error) => void;
-    fallback?: () => void;
+    fallback: () => void;
 }) => (() => void) | void;
 export interface ISegmentContext {
     /** Manifest object related to this segment. */
@@ -486,7 +492,7 @@ export interface ISegmentLoadingProgressInformation {
     /** Size of the data already downloaded, in bytes. */
     size: number;
     /** Size of whole data to download (data already-loaded included), in bytes. */
-    totalSize?: number;
+    totalSize?: number | undefined;
 }
 /**
  * Result returned by a segment loader when a segment has been loaded in a
@@ -531,19 +537,19 @@ export interface IChunkCompleteInformation {
      * This property should only be set when a unique URL is sufficient to
      * retrieve the whole data.
      */
-    url?: string;
+    url?: string | undefined;
     /**
      * Time at which the request began in terms of `performance.now`.
      * If fetching the corresponding data necessitated to perform multiple
      * requests, this time corresponds to the first request made.
      */
-    sendingTime?: number;
+    sendingTime?: number | undefined;
     /**
      * Time at which the request ended in terms of `performance.now`.
      * If fetching the corresponding data necessitated to perform multiple
      * requests, this time corresponds to the last request to end.
      */
-    receivedTime?: number;
+    receivedTime?: number | undefined;
     /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
     size: number | undefined;
 }
@@ -570,7 +576,7 @@ export interface ISegmentParserParsedInitChunk<DataType> {
      * Timescale metadata found inside this initialization segment.
      * That timescale might be useful when parsing further merdia segments.
      */
-    initTimescale?: number;
+    initTimescale?: number | undefined;
     /**
      * If set to `true`, some protection information has been found in this
      * initialization segment and lead the corresponding `Representation`
@@ -583,6 +589,17 @@ export interface ISegmentParserParsedInitChunk<DataType> {
      * protection initialization data to have been encountered.
      */
     protectionDataUpdate: boolean;
+    /**
+     * Size in bytes of `initializationData`.
+     * `undefined` if unknown.
+     *
+     * Note: In some cases, such as when `initializationData` is under a format
+     * whose size is difficult to estimate (e.g. a JavaScript object), the
+     * `initializationDataSize` may either be set to `undefined` or, if available,
+     * to a sensible estimate (e.g. when a JavaScript object wraps large binary
+     * data, `initializationDataSize` may refer to that binary data only).
+     */
+    initializationDataSize: number | undefined;
 }
 /**
  * Result returned by a segment parser when it parsed a chunk from a media
@@ -600,6 +617,17 @@ export interface ISegmentParserParsedMediaChunk<DataType> {
      * `null` if unknown.
      */
     chunkInfos: IChunkTimeInfo | null;
+    /**
+     * Size in bytes of `chunkData`.
+     * `undefined` if unknown.
+     *
+     * Note: In some cases, such as when `chunkData` is under a format whose size
+     * is difficult to estimate (e.g. a JavaScript object), the `chunkSize` may
+     * either be set to `undefined` or, if available, to a sensible estimate (e.g.
+     * when a JavaScript object wraps large binary data, `chunkSize` may refer to
+     * that binary data only).
+     */
+    chunkSize: number | undefined;
     /**
      * time offset, in seconds, to add to the absolute timed data defined in
      * `chunkData` to obtain the "real" wanted effective time.
@@ -626,7 +654,7 @@ export interface ISegmentParserParsedMediaChunk<DataType> {
      * If set and not empty, then "events" have been encountered in this parsed
      * chunks.
      */
-    inbandEvents?: IInbandEvent[];
+    inbandEvents?: IInbandEvent[] | undefined;
     /**
      * If set to `true`, then parsing this chunk revealed that the current
      * Manifest instance needs to be refreshed.
@@ -659,19 +687,19 @@ export interface IRequestedData<T> {
      * This property should only be set when a unique URL is sufficient to
      * retrieve the whole data.
      */
-    url?: string;
+    url?: string | undefined;
     /**
      * Time at which the request began in terms of `performance.now`.
      * If fetching the corresponding data necessitated to perform multiple
      * requests, this time corresponds to the first request made.
      */
-    sendingTime?: number;
+    sendingTime?: number | undefined;
     /**
      * Time at which the request ended in terms of `performance.now`.
      * If fetching the corresponding data necessitated to perform multiple
      * requests, this time corresponds to the last request to end.
      */
-    receivedTime?: number;
+    receivedTime?: number | undefined;
     /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
     size: number | undefined;
 }

package/dist/_esm5.processed/transports/utils/call_custom_manifest_loader.js

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PPromise from "pinkie";
 import { CustomLoaderError } from "../../errors";
+import PPromise from "../../utils/promise";
 export default function callCustomManifestLoader(customManifestLoader, fallbackManifestLoader) {
     return function (url, cancelSignal) {
         return new PPromise(function (res, rej) {

package/dist/_esm5.processed/transports/utils/generate_manifest_loader.d.ts

@@ -21,5 +21,5 @@ import { ICustomManifestLoader, ILoadedManifestFormat, IRequestedData } from "..
  * @returns {Function}
  */
 export default function generateManifestLoader({ customManifestLoader }: {
-    customManifestLoader?: ICustomManifestLoader;
+    customManifestLoader?: ICustomManifestLoader | undefined;
 }, preferredType: "arraybuffer" | "text" | "document"): (url: string | undefined, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PPromise from "pinkie";
+import PPromise from "./promise";
 /**
  * Wait the given `delay`, resolving the Promise when finished.
  *

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PPromise from "pinkie";
 import { Observable } from "rxjs";
 /**
  * Try to cast the given value into an observable.
@@ -21,5 +20,5 @@ import { Observable } from "rxjs";
  * @param {Observable|Function|*}
  * @returns {Observable}
  */
-declare function castToObservable<T>(value: Observable<T> | Promise<T> | PPromise<T> | Exclude<T, Observable<T>>): Observable<T>;
+declare function castToObservable<T>(value: Observable<T> | Promise<T> | Exclude<T, Observable<T>>): Observable<T>;
 export default castToObservable;

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

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PPromise from "pinkie";
 import { from as observableFrom, Observable, of as observableOf, } from "rxjs";
 import isNullOrUndefined from "./is_null_or_undefined";
+import PPromise from "./promise";
 /**
  * Try to cast the given value into an observable.
  * StraightForward - test first for an Observable then for a Promise.

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

@@ -0,0 +1,12 @@
+declare type IDeepPartial<T> = {
+    [P in keyof T]?: IDeepPartial<T[P]>;
+};
+declare type ISourcesArgument<T> = Array<IDeepPartial<T> | unknown>;
+/**
+ * Deeply merge nested objects
+ * @param target
+ * @param sources
+ * @returns output : merged object
+ */
+export default function deepMerge<T>(target: T, ...sources: ISourcesArgument<T>): T;
+export {};

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

@@ -0,0 +1,53 @@
+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 objectAssign from "./object_assign";
+/**
+ * Check if an item is an object
+ * @param item
+ * @returns {boolean}
+ */
+function isObject(item) {
+    return (item !== null
+        && item !== undefined
+        && !Array.isArray(item)
+        && typeof item === "object");
+}
+/**
+ * Deeply merge nested objects
+ * @param target
+ * @param sources
+ * @returns output : merged object
+ */
+export default function deepMerge(target) {
+    var _a, _b;
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    if (sources.length === 0) {
+        return target;
+    }
+    var source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (var key in source) {
+            if (isObject(source[key])) {
+                if (target[key] === undefined) {
+                    objectAssign(target, (_a = {}, _a[key] = {}, _a));
+                }
+                var newTarget = target[key];
+                deepMerge(newTarget, source[key]);
+            }
+            else {
+                objectAssign(target, (_b = {}, _b[key] = source[key], _b));
+            }
+        }
+    }
+    return deepMerge.apply(void 0, __spreadArray([target], sources, false));
+}

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
+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 posession of
@@ -55,6 +56,7 @@ export interface ISharedReference<T> {
     getValue(): T;
     /** Update the value of this shared reference. */
     setValue(newVal: T): void;
+    setValueIfChanged(newVal: T): void;
     /**
      * Returns an Observable which synchronously emits the current value (unless
      * the `skipCurrentValue` argument has been set to `true`) and then each time
@@ -63,6 +65,21 @@ export interface ISharedReference<T> {
      * @returns {Observable}
      */
     asObservable(skipCurrentValue?: boolean): Observable<T>;
+    /**
+     * 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 the new value im argument.
+     * @param {Object} [options]
+     * @param {Object} [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 called with the current value.
+     */
+    onUpdate(cb: (val: T) => void, options?: {
+        clearSignal?: CancellationSignal;
+        emitCurrentValue?: boolean;
+    }): void;
     /**
      * Indicate that no new values will be emitted.
      * Allows to automatically close all Observables generated from this shared
@@ -93,8 +110,20 @@ export interface ISharedReference<T> {
  * the code that some logic is not supposed to update the referenced value.
  */
 export interface IReadOnlySharedReference<T> {
+    /** Get the last value set on that reference. */
     getValue(): T;
+    /**
+     * Returns an Observable notifying this reference's value each time it is
+     * updated.
+     *
+     * Also emit its current value on subscription unless its argument is set to
+     * `true`.
+     */
     asObservable(skipCurrentValue?: boolean): Observable<T>;
+    onUpdate(cb: (val: T) => void, options?: {
+        clearSignal?: CancellationSignal;
+        emitCurrentValue?: boolean;
+    }): void;
 }
 /**
  * Create an `ISharedReference` object encapsulating the mutable `initialValue`