shelving 1.64.0 → 1.65.0

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,13 +46,14 @@ 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.data(), id: s.id };
+function getEntities(snapshot) {
+    return snapshot.docs.map(getEntity);
 }
-/** Get a result from a document snapshot. */
-function getResult(snapshot) {
+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;
 }
@@ -86,30 +87,30 @@ export class FirestoreServerProvider extends Provider {
         super();
         this.firestore = firestore;
     }
-    async get(ref) {
-        return getResult(await getDocument(this.firestore, ref).get());
+    async getDocument(ref) {
+        return getOptionalEntity(await getDocument(this.firestore, ref).get());
     }
-    subscribe(ref, observer) {
-        return getDocument(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, getResult(snapshot)), 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) {
+    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));

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;
+}

package/observe/Subject.js

@@ -0,0 +1,110 @@
+import { ConditionError } from "../error/ConditionError.js";
+import { dispatch } from "../util/function.js";
+import { dispatchComplete, dispatchError, dispatchNext } from "./Observer.js";
+import { subscribe } 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 class Subject {
+    constructor() {
+        /** List of sources this subject is subscribed to. */
+        this._cleanups = new Set();
+        /** List of subscribed observers that values are forwarded to. */
+        this._subscribers = new Set();
+        /** Is this subject open or closed (i.e. `error()` or `complete()` have been called. */
+        this.closed = false;
+    }
+    /** Get the number of current subscribers. */
+    get connections() {
+        return this._cleanups.size;
+    }
+    /** Get the number of current subscribers. */
+    get subscribers() {
+        return this._subscribers.size;
+    }
+    next(value) {
+        if (this.closed)
+            throw new ConditionError("Subject is closed");
+        this._dispatch(value);
+    }
+    /** Call `next()` on the subscribers. */
+    _dispatch(value) {
+        for (const observer of this._subscribers)
+            dispatchNext(observer, value);
+    }
+    error(reason) {
+        if (this.closed)
+            throw new ConditionError("Subject is closed");
+        this._close();
+        for (const subscriber of this._subscribers) {
+            this._subscribers.delete(subscriber);
+            dispatchError(subscriber, reason);
+        }
+    }
+    complete() {
+        if (this.closed)
+            throw new ConditionError("Subject is closed");
+        this._close();
+        for (const subscriber of this._subscribers) {
+            this._subscribers.delete(subscriber);
+            dispatchComplete(subscriber);
+        }
+    }
+    /** Close this subject (called by `error()` and `complete()`). */
+    _close() {
+        this.closed = true;
+        this.disconnect();
+    }
+    /** Connect this subjet to a source. */
+    connect(source) {
+        if (this.closed)
+            throw new ConditionError("Subject is closed");
+        const unsubscribe = subscribe(source, this);
+        const cleanup = () => {
+            this._cleanups.delete(cleanup);
+            dispatch(unsubscribe);
+        };
+        this._cleanups.add(cleanup);
+        return cleanup;
+    }
+    /** Disconnect this subject from all sources. */
+    disconnect() {
+        for (const cleanup of this._cleanups)
+            dispatch(cleanup); // Cleanups are self-cleaning.
+    }
+    /**
+     * 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) {
+        const observer = typeof next === "function" ? { next } : next;
+        this._addObserver(observer);
+        return this._removeObserver.bind(this, observer);
+    }
+    /** Add an observer (called by `subscribe()`). */
+    _addObserver(observer) {
+        const size = this._subscribers.size;
+        this._subscribers.add(observer);
+        if (!size && this._subscribers.size)
+            this._addFirstObserver();
+    }
+    /** Called after adding the first observer. */
+    _addFirstObserver() {
+        //
+    }
+    /** Remove an observer. */
+    _removeObserver(observer) {
+        const size = this._subscribers.size;
+        this._subscribers.delete(observer);
+        if (size && !this._subscribers.size)
+            this._removeLastObserver();
+    }
+    /** Called after adding the first observer. */
+    _removeLastObserver() {
+        // Nothing.
+    }
+}

package/observe/ThroughObserver.d.ts

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

package/observe/ThroughObserver.js

@@ -0,0 +1,8 @@
+import { AbstractObserver } from "./AbstractObserver.js";
+import { dispatchNext } from "./Observer.js";
+/** Observer that unsubscribes.*/
+export class ThroughObserver extends AbstractObserver {
+    next(value) {
+        dispatchNext(this.target, value);
+    }
+}

package/observe/TransformObserver.d.ts

@@ -0,0 +1,9 @@
+import { Transformer } from "../util/transform.js";
+import type { PartialObserver } from "./Observer.js";
+import { TransformableObserver } from "./TransformableObserver.js";
+/** Observer that transforms its next values with a transformer. */
+export declare class TransformObserver<I, O> extends TransformableObserver<I, O> {
+    protected _transformer: Transformer<I, O>;
+    constructor(transformer: Transformer<I, O>, target: PartialObserver<O>);
+    transform(value: I): O;
+}

package/observe/TransformObserver.js

@@ -0,0 +1,12 @@
+import { transform } from "../util/transform.js";
+import { TransformableObserver } from "./TransformableObserver.js";
+/** Observer that transforms its next values with a transformer. */
+export class TransformObserver extends TransformableObserver {
+    constructor(transformer, target) {
+        super(target);
+        this._transformer = transformer;
+    }
+    transform(value) {
+        return transform(value, this._transformer);
+    }
+}

package/observe/TransformableObserver.d.ts

@@ -0,0 +1,7 @@
+import type { Transformable } from "../util/transform.js";
+import { AbstractObserver } from "./AbstractObserver.js";
+/** Observer implementing `Transformable` that implements a `transform()` property that is called to transform the next value before dispatching it. */
+export declare abstract class TransformableObserver<I, O> extends AbstractObserver<I, O> implements Transformable<I, O> {
+    next(value: I): void;
+    abstract transform(input: I): O;
+}

package/observe/TransformableObserver.js

@@ -0,0 +1,8 @@
+import { AbstractObserver } from "./AbstractObserver.js";
+import { dispatchNext } from "./Observer.js";
+/** Observer implementing `Transformable` that implements a `transform()` property that is called to transform the next value before dispatching it. */
+export class TransformableObserver extends AbstractObserver {
+    next(value) {
+        dispatchNext(this.target, this.transform(value));
+    }
+}

package/observe/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./LastSubject.js";
+export * from "./AsyncObserver.js";
+export * from "./MatchableObserver.js";
+export * from "./MatchObserver.js";
+export * from "./Observable.js";
+export * from "./Observer.js";
+export * from "./OnceObserver.js";
+export * from "./Subject.js";
+export * from "./ThroughObserver.js";
+export * from "./TransformableObserver.js";
+export * from "./TransformObserver.js";
+export * from "./AbstractObserver.js";
+export * from "./util.js";

package/observe/index.js

@@ -0,0 +1,13 @@
+export * from "./LastSubject.js";
+export * from "./AsyncObserver.js";
+export * from "./MatchableObserver.js";
+export * from "./MatchObserver.js";
+export * from "./Observable.js";
+export * from "./Observer.js";
+export * from "./OnceObserver.js";
+export * from "./Subject.js";
+export * from "./ThroughObserver.js";
+export * from "./TransformableObserver.js";
+export * from "./TransformObserver.js";
+export * from "./AbstractObserver.js";
+export * from "./util.js";