shelving 1.63.0 → 1.65.0

package/firestore/lite/FirestoreLiteProvider.js

@@ -45,10 +45,16 @@ function getQuery(firestore, ref) {
         constraints.push(firestoreLimit(limit));
     return firestoreQuery(getCollection(firestore, ref), ...constraints);
 }
-/** Create a set of results from a collection snapshot. */
-function* getResults(snapshot) {
-    for (const s of snapshot.docs)
-        yield [s.id, s.data()];
+function getEntities(snapshot) {
+    return snapshot.docs.map(getEntity);
+}
+function getEntity(snapshot) {
+    const data = snapshot.data();
+    return { ...data, id: snapshot.id };
+}
+function getOptionalData(snapshot) {
+    const data = snapshot.data();
+    return data ? { ...data, id: snapshot.id } : null;
 }
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* yieldFieldValues(updates, prefix = "") {
@@ -82,32 +88,31 @@ export class FirestoreClientProvider extends Provider {
         super();
         this.firestore = firestore;
     }
-    async get(ref) {
-        const snapshot = await getDoc(getDocument(this.firestore, ref));
-        return snapshot.data() || null;
+    async getDocument(ref) {
+        return getOptionalData(await getDoc(getDocument(this.firestore, ref)));
     }
-    subscribe() {
-        throw new Error("FirestoreLiteProvider does not support realtime subscriptions");
+    subscribeDocument() {
+        throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
-    async add(ref, data) {
-        const reference = await addDoc(getCollection(this.firestore, ref), data); // eslint-disable-line @typescript-eslint/no-explicit-any
+    async addDocument(ref, data) {
+        const reference = await addDoc(getCollection(this.firestore, ref), data);
         return reference.id;
     }
-    async set(ref, data) {
+    async setDocument(ref, data) {
         await setDoc(getDocument(this.firestore, ref), data);
     }
-    async update(ref, update) {
+    async updateDocument(ref, update) {
         const fieldValues = Object.fromEntries(yieldFieldValues(update));
         await updateDoc(getDocument(this.firestore, ref), fieldValues);
     }
-    async delete(ref) {
+    async deleteDocument(ref) {
         await deleteDoc(getDocument(this.firestore, ref));
     }
     async getQuery(ref) {
-        return getResults(await getDocs(getQuery(this.firestore, ref)));
+        return getEntities(await getDocs(getQuery(this.firestore, ref)));
     }
     subscribeQuery() {
-        throw new Error("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async setQuery(ref, data) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,10 +1,10 @@
 import { Firestore } from "@google-cloud/firestore";
 import type { DocumentReference, QueryReference } from "../../db/Reference.js";
-import type { Data, Result } from "../../util/data.js";
-import type { Entries, Entry } from "../../util/entry.js";
+import type { Data, Entities, OptionalEntity } from "../../util/data.js";
+import type { Unsubscribe } from "../../observe/Observable.js";
 import { AsynchronousProvider, Provider } from "../../provider/Provider.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
-import { Observer, Unsubscriber } from "../../util/observe.js";
+import { Observer } from "../../observe/Observer.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
@@ -12,14 +12,14 @@ import { Observer, Unsubscriber } from "../../util/observe.js";
 export declare class FirestoreServerProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore?: Firestore);
-    get<T extends Data>(ref: DocumentReference<T>): Promise<Result<T>>;
-    subscribe<T extends Data>(ref: DocumentReference<T>, observer: Observer<Result<T>>): Unsubscriber;
-    add<T extends Data>(ref: QueryReference<T>, data: T): Promise<string>;
-    set<T extends Data>(ref: DocumentReference<T>, data: T): Promise<void>;
-    update<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): Promise<void>;
-    delete<T extends Data>(ref: DocumentReference<T>): Promise<void>;
-    getQuery<T extends Data>(ref: QueryReference<T>): Promise<Iterable<Entry<T>>>;
-    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    getDocument<T extends Data>(ref: DocumentReference<T>): Promise<OptionalEntity<T>>;
+    subscribeDocument<T extends Data>(ref: DocumentReference<T>, observer: Observer<OptionalEntity<T>>): Unsubscribe;
+    addDocument<T extends Data>(ref: QueryReference<T>, data: T): Promise<string>;
+    setDocument<T extends Data>(ref: DocumentReference<T>, data: T): Promise<void>;
+    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): Promise<void>;
+    deleteDocument<T extends Data>(ref: DocumentReference<T>): Promise<void>;
+    getQuery<T extends Data>(ref: QueryReference<T>): Promise<Entities<T>>;
+    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<Entities<T>>): Unsubscribe;
     setQuery<T extends Data>(ref: QueryReference<T>, data: T): Promise<number>;
     updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): Promise<number>;
     deleteQuery<T extends Data>(ref: QueryReference<T>): Promise<number>;

package/firestore/server/FirestoreServerProvider.js

@@ -5,7 +5,7 @@ import { ArrayUpdate } from "../../update/ArrayUpdate.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
 import { Increment } from "../../update/Increment.js";
 import { ObjectUpdate } from "../../update/ObjectUpdate.js";
-import { dispatchError, dispatchNext } from "../../util/observe.js";
+import { dispatchError, dispatchNext } from "../../observe/Observer.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -46,10 +46,16 @@ function getQuery(firestore, ref) {
         query = query.limit(limit);
     return query;
 }
-/** Create a set of results from a collection snapshot. */
-function* getResults(snapshot) {
-    for (const s of snapshot.docs)
-        yield [s.id, s.data()];
+function getEntities(snapshot) {
+    return snapshot.docs.map(getEntity);
+}
+function getEntity(snapshot) {
+    const data = snapshot.data();
+    return { ...data, id: snapshot.id };
+}
+function getOptionalEntity(snapshot) {
+    const data = snapshot.data();
+    return data ? { ...data, id: snapshot.id } : null;
 }
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* yieldFieldValues(updates, prefix = "") {
@@ -81,36 +87,36 @@ export class FirestoreServerProvider extends Provider {
         super();
         this.firestore = firestore;
     }
-    async get(ref) {
-        return (await getDocument(this.firestore, ref).get()).data() || null;
+    async getDocument(ref) {
+        return getOptionalEntity(await getDocument(this.firestore, ref).get());
     }
-    subscribe(ref, observer) {
-        return getDocument(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, snapshot.data() || null), thrown => dispatchError(observer, thrown));
+    subscribeDocument(ref, observer) {
+        return getDocument(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, getOptionalEntity(snapshot)), thrown => dispatchError(observer, thrown));
     }
-    async add(ref, data) {
+    async addDocument(ref, data) {
         return (await getCollection(this.firestore, ref).add(data)).id;
     }
-    async set(ref, data) {
+    async setDocument(ref, data) {
         await getDocument(this.firestore, ref).set(data);
     }
-    async update(ref, update) {
-        const fieldValues = Object.fromEntries(yieldFieldValues(update)); // eslint-disable-line @typescript-eslint/no-explicit-any
+    async updateDocument(ref, update) {
+        const fieldValues = Object.fromEntries(yieldFieldValues(update));
         await getDocument(this.firestore, ref).update(fieldValues);
     }
-    async delete(ref) {
+    async deleteDocument(ref) {
         await getDocument(this.firestore, ref).delete();
     }
     async getQuery(ref) {
-        return getResults(await getQuery(this.firestore, ref).get());
+        return getEntities(await getQuery(this.firestore, ref).get());
     }
     subscribeQuery(ref, observer) {
-        return getQuery(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, getResults(snapshot)), thrown => dispatchError(observer, thrown));
+        return getQuery(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, getEntities(snapshot)), thrown => dispatchError(observer, thrown));
     }
     async setQuery(ref, data) {
         return await bulkWrite(this.firestore, ref, (w, s) => void w.set(s.ref, data));
     }
     async updateQuery(ref, update) {
-        const fieldValues = Object.fromEntries(yieldFieldValues(update)); // eslint-disable-line @typescript-eslint/no-explicit-any
+        const fieldValues = Object.fromEntries(yieldFieldValues(update));
         return await bulkWrite(this.firestore, ref, (w, s) => void w.update(s.ref, fieldValues));
     }
     async deleteQuery(ref) {

package/index.d.ts

@@ -11,6 +11,7 @@ export * from "./api/index.js";
 export * from "./error/index.js";
 export * from "./feedback/index.js";
 export * from "./markup/index.js";
-export * from "./stream/index.js";
+export * from "./observe/index.js";
+export * from "./state/index.js";
 export * from "./update/index.js";
 export * from "./util/index.js";

package/index.js

@@ -13,7 +13,8 @@ export * from "./api/index.js";
 export * from "./error/index.js";
 export * from "./feedback/index.js";
 export * from "./markup/index.js";
-export * from "./stream/index.js";
+export * from "./observe/index.js";
+export * from "./state/index.js";
 export * from "./update/index.js";
 export * from "./util/index.js";
 // Integrations.

package/markup/rules.js

@@ -39,14 +39,14 @@ const UNORDERED = `[${BULLETS}] +`; // Anything that can be a bullet (used for u
 export const UNORDERED_LIST_RULE = {
     regexp: getBlockRegExp(`${UNORDERED}(${MATCH_BLOCK.source})`),
     render: ([, list = ""]) => {
-        const children = list.split(SPLIT_UL_ITEMS).map(mapUnorderedItem);
+        const children = list.split(SPLIT_UL_ITEMS).map(_mapUnorderedItem);
         return { type: "ul", key: null, props: { children } };
     },
     contexts: ["block", "list"],
     childContext: "list",
 };
 const SPLIT_UL_ITEMS = new RegExp(`\\n+${UNORDERED}`, "g");
-const mapUnorderedItem = (item, key) => {
+const _mapUnorderedItem = (item, key) => {
     const children = item.replace(MATCH_INDENT, "");
     return { type: "li", key, props: { children } };
 };
@@ -59,14 +59,14 @@ const ORDERED = "[0-9]+[.):] +"; // Number for a numbered list (e.g. `1.` or `2)
 export const ORDERED_LIST_RULE = {
     regexp: getBlockRegExp(`(${ORDERED}${MATCH_BLOCK.source})`),
     render: ([, list = ""]) => {
-        const children = list.split(SPLIT_OL_ITEMS).map(mapOrderedItem);
+        const children = list.split(SPLIT_OL_ITEMS).map(_mapOrderedItem);
         return { type: "ol", key: null, props: { children } };
     },
     contexts: ["block", "list"],
     childContext: "list",
 };
 const SPLIT_OL_ITEMS = new RegExp(`\\n+(?=${ORDERED})`, "g");
-const mapOrderedItem = (item, key) => {
+const _mapOrderedItem = (item, key) => {
     const firstSpace = item.indexOf(" ");
     const value = parseInt(item.slice(0, firstSpace), 10);
     const children = item

package/observe/AbstractObserver.d.ts

@@ -0,0 +1,15 @@
+import { Subscribable, Unsubscribe } from "./Observable.js";
+import { PartialObserver, ConnectableObserver } from "./Observer.js";
+/** Abstract observer designed to pass values through to an observer. */
+export declare abstract class AbstractObserver<I, O> implements ConnectableObserver<I> {
+    private _target;
+    private _cleanup;
+    get closed(): boolean;
+    get target(): PartialObserver<O>;
+    constructor(target: PartialObserver<O>);
+    connect(subscribable: Subscribable<I>): Unsubscribe;
+    disconnect(): void;
+    abstract next(value: I): void;
+    error(reason: Error | unknown): void;
+    complete(): void;
+}

package/observe/AbstractObserver.js

@@ -0,0 +1,42 @@
+import { dispatch } from "../util/function.js";
+import { ConditionError } from "../error/ConditionError.js";
+import { subscribe } from "./Observable.js";
+import { dispatchError, dispatchComplete } from "./Observer.js";
+/** Abstract observer designed to pass values through to an observer. */
+export class AbstractObserver {
+    constructor(target) {
+        this._target = target;
+    }
+    get closed() {
+        return !this._target;
+    }
+    get target() {
+        if (!this._target)
+            throw new ConditionError("Observer is closed");
+        return this._target;
+    }
+    connect(subscribable) {
+        if (!this._target)
+            throw new ConditionError("Observer is closed");
+        if (this._cleanup)
+            throw new ConditionError("Observer already connected");
+        this._cleanup = subscribe(subscribable, this);
+        return this.disconnect.bind(this);
+    }
+    disconnect() {
+        if (this._cleanup)
+            this._cleanup = void dispatch(this._cleanup);
+    }
+    error(reason) {
+        const target = this.target;
+        this._target = undefined; // Close this observer.
+        this.disconnect();
+        dispatchError(target, reason);
+    }
+    complete() {
+        const target = this.target;
+        this._target = undefined; // Close this observer.
+        this.disconnect();
+        dispatchComplete(target);
+    }
+}

package/observe/AsyncObserver.d.ts

@@ -0,0 +1,5 @@
+import { AbstractObserver } from "./AbstractObserver.js";
+/** Observer that allows promised values to be passed to `next()`. */
+export declare class AsyncObserver<T> extends AbstractObserver<PromiseLike<T>, T> {
+    next(value: PromiseLike<T>): void;
+}

package/observe/AsyncObserver.js

@@ -0,0 +1,8 @@
+import { AbstractObserver } from "./AbstractObserver.js";
+import { dispatchAsyncNext } from "./Observer.js";
+/** Observer that allows promised values to be passed to `next()`. */
+export class AsyncObserver extends AbstractObserver {
+    next(value) {
+        dispatchAsyncNext(this.target, value);
+    }
+}

package/{stream/LastStream.d.ts → observe/LastSubject.d.ts}

@@ -1,5 +1,5 @@
-import { Stream } from "./Stream.js";
+import { Subject } from "./Subject.js";
 /** Stream that only calls its most recently added subscriber. */
-export declare class LastStream<T> extends Stream<T> {
+export declare class LastSubject<T> extends Subject<T> {
     protected _dispatch(value: T): void;
 }

package/observe/LastSubject.js

@@ -0,0 +1,12 @@
+import { getLastItem } from "../util/array.js";
+import { dispatchNext } from "./Observer.js";
+import { Subject } from "./Subject.js";
+/** Stream that only calls its most recently added subscriber. */
+export class LastSubject extends Subject {
+    // Override to dispatch only to a slice of the subscribers.
+    _dispatch(value) {
+        const observer = getLastItem(this._subscribers);
+        if (observer)
+            dispatchNext(observer, value);
+    }
+}

package/observe/MatchObserver.d.ts

@@ -0,0 +1,9 @@
+import { Matcher } from "../util/match.js";
+import { MatchableObserver } from "./MatchableObserver.js";
+import { PartialObserver } from "./Observer.js";
+/** Observer that filters is next value with a matcher. */
+export declare class MatchObserver<T> extends MatchableObserver<T> {
+    protected _matcher: Matcher<T, void>;
+    constructor(matcher: Matcher<T, void>, target: PartialObserver<T>);
+    match(value: T): boolean;
+}

package/observe/MatchObserver.js

@@ -0,0 +1,12 @@
+import { match } from "../util/match.js";
+import { MatchableObserver } from "./MatchableObserver.js";
+/** Observer that filters is next value with a matcher. */
+export class MatchObserver extends MatchableObserver {
+    constructor(matcher, target) {
+        super(target);
+        this._matcher = matcher;
+    }
+    match(value) {
+        return match(value, this._matcher);
+    }
+}

package/observe/MatchableObserver.d.ts

@@ -0,0 +1,7 @@
+import { Matchable } from "../util/match.js";
+import { AbstractObserver } from "./AbstractObserver.js";
+/** Observer implementing `Matchable` that implements a `match()` property that is called filter the next value before dispatching it. */
+export declare abstract class MatchableObserver<T> extends AbstractObserver<T, T> implements Matchable<T, void> {
+    next(value: T): void;
+    abstract match(value: T): boolean;
+}

package/observe/MatchableObserver.js

@@ -0,0 +1,10 @@
+import { AbstractObserver } from "./AbstractObserver.js";
+import { dispatchNext } from "./Observer.js";
+/** Observer implementing `Matchable` that implements a `match()` property that is called filter the next value before dispatching it. */
+export class MatchableObserver extends AbstractObserver {
+    next(value) {
+        const target = this.target;
+        if (this.match(value))
+            dispatchNext(target, value);
+    }
+}

package/observe/Observable.d.ts

@@ -0,0 +1,20 @@
+import type { Dispatch } from "../util/function.js";
+import type { PartialObserver } from "./Observer.js";
+/** Function that ends a subscription. */
+export declare type Unsubscribe = () => void;
+/** An object that can subscribed to. */
+export interface Observable<T> {
+    /** Subscribe an observer to this observable. */
+    subscribe(observer: PartialObserver<T> | Dispatch<[T]>): Unsubscribe;
+}
+/** Subscribe function is a function that initiates a subscription to an observer. */
+export declare type Subscribe<T> = (observer: PartialObserver<T>) => Unsubscribe;
+/** Subscribable is either an observable object or a subscribe function. */
+export declare type Subscribable<T> = Observable<T> | Subscribe<T>;
+/** Start a subscription to a `Subscribable` and return the `Unsubscriber` function. */
+export declare function subscribe<T>(source: Subscribable<T>, target: PartialObserver<T>): Unsubscribe;
+/** An object that can be connected to a subscribable. */
+export interface Connectable<T> {
+    /** Subscribe this entity to a subscribable. */
+    connect(subscribable: Subscribable<T>): Unsubscribe;
+}

package/observe/Observable.js

@@ -0,0 +1,7 @@
+import { ConditionError } from "../error/ConditionError.js";
+/** Start a subscription to a `Subscribable` and return the `Unsubscriber` function. */
+export function subscribe(source, target) {
+    if (target.closed)
+        throw new ConditionError("Target is closed");
+    return typeof source === "function" ? source(target) : source.subscribe(target);
+}

package/observe/Observer.d.ts

@@ -0,0 +1,31 @@
+import type { Dispatch } from "../util/function.js";
+import { Handler } from "../util/error.js";
+import type { Connectable } from "./Observable.js";
+/**
+ * Observer
+ * - An Observer is used to receive data from an Observable, and is supplied as an argument to subscribe.
+ * - All methods are optional.
+ * - Compatible with https://github.com/tc39/proposal-observable/
+ */
+export interface Observer<T> {
+    /** Send the next value to this object. */
+    readonly next: Dispatch<[T]>;
+    /** End this object with an error. */
+    readonly error: Handler;
+    /** End this object with success. */
+    readonly complete: Dispatch;
+    /** Is this object closed? */
+    readonly closed?: boolean;
+}
+/** Partial observer is an observer missing one or more of its callbacks. */
+export declare type PartialObserver<T> = Partial<Observer<T>>;
+/** Connectable observer is an observer that can connect to a subscribable source. */
+export declare type ConnectableObserver<T> = Observer<T> & Connectable<T>;
+/** Dispatch the next value to an observer (and if the next value errors log the error). */
+export declare function dispatchNext<T>(observer: PartialObserver<T>, value: T): void;
+/** Dispatch the next value to an observer (and if the next value errors log the error). */
+export declare function dispatchAsyncNext<T>(observer: PartialObserver<T>, value: PromiseLike<T>): void;
+/** Dispatch a complete call an observer (and if the next value errors log the error). */
+export declare function dispatchComplete<T>(observer: PartialObserver<T>): void;
+/** Dispatch an error value to an observer. */
+export declare function dispatchError<T>(observer: PartialObserver<T>, reason: Error | unknown): void;

package/observe/Observer.js

@@ -0,0 +1,48 @@
+import { logError } from "../util/error.js";
+/** Dispatch the next value to an observer (and if the next value errors log the error). */
+export function dispatchNext(observer, value) {
+    if (!observer.next)
+        return;
+    try {
+        observer.next(value);
+    }
+    catch (thrown) {
+        logError(thrown);
+    }
+}
+/** Dispatch the next value to an observer (and if the next value errors log the error). */
+export function dispatchAsyncNext(observer, value) {
+    if (!observer.next)
+        return;
+    void _dispatchAsyncNext(observer, value);
+}
+async function _dispatchAsyncNext(observer, value) {
+    try {
+        dispatchNext(observer, await value);
+    }
+    catch (reason) {
+        dispatchError(observer, reason);
+    }
+}
+/** Dispatch a complete call an observer (and if the next value errors log the error). */
+export function dispatchComplete(observer) {
+    if (!observer.complete)
+        return;
+    try {
+        observer.complete();
+    }
+    catch (thrown) {
+        logError(thrown);
+    }
+}
+/** Dispatch an error value to an observer. */
+export function dispatchError(observer, reason) {
+    if (!observer.error)
+        return;
+    try {
+        observer.error(reason);
+    }
+    catch (thrown) {
+        logError(thrown);
+    }
+}

package/observe/OnceObserver.d.ts

@@ -0,0 +1,5 @@
+import { ThroughObserver } from "./ThroughObserver.js";
+/** Observer that fires once then ends itself. */
+export declare class OnceObserver<T> extends ThroughObserver<T> {
+    next(value: T): void;
+}

package/observe/OnceObserver.js

@@ -0,0 +1,8 @@
+import { ThroughObserver } from "./ThroughObserver.js";
+/** Observer that fires once then ends itself. */
+export class OnceObserver extends ThroughObserver {
+    next(value) {
+        super.next(value);
+        this.complete();
+    }
+}

package/observe/Subject.d.ts

@@ -0,0 +1,46 @@
+import { Dispatch } from "../util/function.js";
+import { ConnectableObserver, PartialObserver } from "./Observer.js";
+import { Observable, Subscribable, Unsubscribe } from "./Observable.js";
+/**
+ * Simple subject
+ * - Subject combines `Observer` and `Observable`.
+ * - Multiple observers can subscribe and values are multicase to all of them.
+ * - Does no deriving (input and output types are the same).
+ */
+export declare class Subject<T> implements Observable<T>, ConnectableObserver<T> {
+    /** List of sources this subject is subscribed to. */
+    protected readonly _cleanups: Set<Unsubscribe>;
+    /** List of subscribed observers that values are forwarded to. */
+    protected readonly _subscribers: Set<Partial<import("./Observer.js").Observer<T>>>;
+    /** Get the number of current subscribers. */
+    get connections(): number;
+    /** Get the number of current subscribers. */
+    get subscribers(): number;
+    /** Is this subject open or closed (i.e. `error()` or `complete()` have been called. */
+    readonly closed: boolean;
+    next(value: T): void;
+    /** Call `next()` on the subscribers. */
+    protected _dispatch(value: T): void;
+    error(reason: Error | unknown): void;
+    complete(): void;
+    /** Close this subject (called by `error()` and `complete()`). */
+    private _close;
+    /** Connect this subjet to a source. */
+    connect(source: Subscribable<T>): Unsubscribe;
+    /** Disconnect this subject from all sources. */
+    disconnect(): void;
+    /**
+     * Subscribe to this subject and return an unsubscriber function.
+     * - Allows either an `Observer` object or  separate `next()`, `error()` and `complete()` functions.
+     * - Implements `Observable`
+     */
+    subscribe(next: PartialObserver<T> | Dispatch<[T]>): Unsubscribe;
+    /** Add an observer (called by `subscribe()`). */
+    protected _addObserver(observer: PartialObserver<T>): void;
+    /** Called after adding the first observer. */
+    protected _addFirstObserver(): void;
+    /** Remove an observer. */
+    protected _removeObserver(observer: PartialObserver<T>): void;
+    /** Called after adding the first observer. */
+    protected _removeLastObserver(): void;
+}