shelving 1.20.3 → 1.22.2

package/api/Resource.d.ts

@@ -6,24 +6,22 @@ import { Validator, Validatable } from "../util/index.js";
  * @param returns The `Validator` the function's returned value must conform to (defaults to `undefined` if not specified).
  */
 export declare class Resource<P = unknown, R = void> implements Validatable<R> {
-    static create<X, Y>(payload: Validator<X>, result: Validator<Y>): Resource<X, Y>;
-    static create<Y>(payload: undefined, result: Y): Resource<undefined, Y>;
-    static create<X>(payload: Validator<X>, result?: undefined): Resource<X, void>;
-    static create(payload?: undefined, result?: undefined): Resource<undefined, void>;
     /** Payload validator. */
     readonly payload: Validator<P>;
     /** Result validator. */
     readonly result: Validator<R>;
-    protected constructor(payload: Validator<P>, result: Validator<R>);
+    constructor(payload: Validator<P>, result: Validator<R>);
     /**
      * Validate a payload for this resource.
      *
+     * @returns The validated payload for this resource.
+     * @throws InvalidFeedback if the payload could not be validated.
      */
-    validatePayload(unsafePayload: unknown): P;
+    prepare(unsafePayload: unknown): P;
     /**
      * Validate a result for this resource.
      *
-     * @returns The validated payload for this resource.
+     * @returns The validated result for this resource.
      * @throws ValidationError if the result could not be validated.
      */
     validate(unsafeResult: unknown): R;
@@ -32,3 +30,11 @@ export declare class Resource<P = unknown, R = void> implements Validatable<R> {
 export declare type PayloadType<X extends Resource> = X extends Resource<infer Y, unknown> ? Y : never;
 /** Extract the result type from a `Resource`. */
 export declare type ResourceType<X extends Resource> = X extends Resource<unknown, infer Y> ? Y : never;
+/**
+ * Shortcut to create a new `Resource` (consistent with `Schema` shortcuts.
+ * - Sets `undefined` as the default type for payload and result.
+ */
+export declare function RESOURCE<X, Y>(payload: Validator<X>, result: Validator<Y>): Resource<X, Y>;
+export declare function RESOURCE<Y>(payload: undefined, result: Y): Resource<undefined, Y>;
+export declare function RESOURCE<X>(payload: Validator<X>, result?: undefined): Resource<X, void>;
+export declare function RESOURCE(payload?: undefined, result?: undefined): Resource<undefined, void>;

package/api/Resource.js

@@ -1,8 +1,6 @@
 import { UNDEFINED, validate } from "../util/index.js";
-import { Feedback, throwFeedback } from "../feedback/index.js";
+import { Feedback } from "../feedback/index.js";
 import { ResourceValidationError } from "./errors.js";
-/** Validator that always returns void/undefined. */
-const UNDEFINED_VALIDATOR = UNDEFINED;
 /**
  * An abstract API resource definition, used to specify types for e.g. serverless functions..
  *
@@ -15,20 +13,19 @@ export class Resource {
         this.payload = payload;
         this.result = result;
     }
-    static create(payload = UNDEFINED_VALIDATOR, result = UNDEFINED_VALIDATOR) {
-        return new Resource(payload, result);
-    }
     /**
      * Validate a payload for this resource.
      *
+     * @returns The validated payload for this resource.
+     * @throws InvalidFeedback if the payload could not be validated.
      */
-    validatePayload(unsafePayload) {
-        return throwFeedback(validate(unsafePayload, this.payload));
+    prepare(unsafePayload) {
+        return validate(unsafePayload, this.payload);
     }
     /**
      * Validate a result for this resource.
      *
-     * @returns The validated payload for this resource.
+     * @returns The validated result for this resource.
      * @throws ValidationError if the result could not be validated.
      */
     validate(unsafeResult) {
@@ -40,3 +37,6 @@ export class Resource {
         }
     }
 }
+export function RESOURCE(payload = UNDEFINED, result = UNDEFINED) {
+    return new Resource(payload, result);
+}

package/db/Database.d.ts

@@ -1,4 +1,4 @@
-import { Dispatcher, Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType } from "../util/index.js";
+import { Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType, Dispatcher } from "../util/index.js";
 import { Transform, Transforms } from "../transform/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
@@ -58,26 +58,18 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
-     * @param next Callback that is called once initially and again whenever the results change.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribe(next: Observer<Results<T>> | Dispatcher<Results<T>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
+    subscribe(next: Observer<Results<T>> | Dispatcher<[Results<T>]>): Unsubscriber;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
-     * @param next Callback that is called once initially and again whenever the results change.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribeMap(next: Observer<ResultsMap<T>> | Dispatcher<ResultsMap<T>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
+    subscribeMap(next: Observer<ResultsMap<T>> | Dispatcher<[ResultsMap<T>]>): Unsubscriber;
     /**
      * Set all matching documents to the same exact value.
      *
@@ -145,14 +137,10 @@ export declare class DataDocument<T extends Data = Data> implements Observable<R
      * Subscribe to the result of this document (indefinitely).
      * - `next()` is called once with the initial result, and again any time the result changes.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods.
-     * @param next Callback that is called once initially and again whenever the result changes.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribe(next: Observer<Result<T>> | Dispatcher<Result<T>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
+    subscribe(next: Observer<Result<T>> | Dispatcher<[Result<T>]>): Unsubscriber;
     /**
      * Set the complete data of this document.
      *

package/db/Database.js

@@ -1,4 +1,4 @@
-import { callAsync, createObserver, getFirstItem, throwAsync, validate, toMap, countItems, DeriveObserver, } from "../util/index.js";
+import { callAsync, getFirstItem, throwAsync, validate, toMap, countItems, DeriveObserver, } from "../util/index.js";
 import { DataTransform, Transform } from "../transform/index.js";
 import { Feedback, InvalidFeedback } from "../feedback/index.js";
 import { Filters, Query, EqualFilter } from "../query/index.js";
@@ -79,29 +79,21 @@ export class DataQuery extends Query {
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
-     * @param next Callback that is called once initially and again whenever the results change.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribe(next, error, complete) {
-        return this.provider.subscribeQuery(this, createObserver(next, error, complete));
+    subscribe(next) {
+        return this.provider.subscribeQuery(this, typeof next === "function" ? { next } : next);
     }
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
-     * @param next Callback that is called once initially and again whenever the results change.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribeMap(next, error, complete) {
-        return this.provider.subscribeQuery(this, new DeriveObserver(toMap, createObserver(next, error, complete)));
+    subscribeMap(next) {
+        return this.provider.subscribeQuery(this, new DeriveObserver(toMap, typeof next === "function" ? { next } : next));
     }
     /**
      * Set all matching documents to the same exact value.
@@ -210,15 +202,11 @@ export class DataDocument {
      * Subscribe to the result of this document (indefinitely).
      * - `next()` is called once with the initial result, and again any time the result changes.
      *
-     * @param observer Observer with `next`, `error`, or `complete` methods.
-     * @param next Callback that is called once initially and again whenever the result changes.
-     * @param error Callback that is called if an error occurs.
-     * @param complete Callback that is called when the subscription is done.
-     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
      * @return Function that ends the subscription.
      */
-    subscribe(next, error, complete) {
-        return this.provider.subscribe(this, createObserver(next, error, complete));
+    subscribe(next) {
+        return this.provider.subscribe(this, typeof next === "function" ? { next } : next);
     }
     /**
      * Set the complete data of this document.

package/feedback/index.d.ts

@@ -4,4 +4,3 @@ export * from "./WarningFeedback.js";
 export * from "./ErrorFeedback.js";
 export * from "./InvalidFeedback.js";
 export * from "./hydrations.js";
-export * from "./util.js";

package/feedback/index.js

@@ -4,4 +4,3 @@ export * from "./WarningFeedback.js";
 export * from "./ErrorFeedback.js";
 export * from "./InvalidFeedback.js";
 export * from "./hydrations.js";
-export * from "./util.js";

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore";
-import { Results, Provider, DataDocument, DataQuery, Result, Observer, Transform, AsynchronousProvider, Data } from "../../index.js";
+import { Results, Provider, DataDocument, DataQuery, Result, Observer, Transform, AsynchronousProvider, Data, Unsubscriber } from "../../index.js";
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.
@@ -10,10 +10,10 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
     get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): () => void;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
     add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
     write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): () => void;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
     writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/client/FirestoreClientProvider.js

@@ -88,7 +88,7 @@ export class FirestoreClientProvider extends Provider {
         return snapshot.data();
     }
     subscribe(ref, observer) {
-        return onSnapshot(getDocument(this.firestore, ref), snapshot => dispatchNext(snapshot.data(), observer), thrown => dispatchError(thrown, observer));
+        return onSnapshot(getDocument(this.firestore, ref), snapshot => dispatchNext(observer, snapshot.data()), thrown => dispatchError(observer, thrown));
     }
     async add(ref, data) {
         const reference = await addDoc(getCollection(this.firestore, ref), data); // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -106,7 +106,7 @@ export class FirestoreClientProvider extends Provider {
         return getResults(await getDocs(getQuery(this.firestore, ref)));
     }
     subscribeQuery(ref, observer) {
-        return onSnapshot(getQuery(this.firestore, ref), snapshot => dispatchNext(getResults(snapshot), observer), thrown => dispatchError(thrown, observer));
+        return onSnapshot(getQuery(this.firestore, ref), snapshot => dispatchNext(observer, getResults(snapshot)), thrown => dispatchError(observer, thrown));
     }
     async writeQuery(ref, value) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore/lite";
-import { Provider, DataDocument, DataQuery, Result, Transform, AsynchronousProvider, Data, Results } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Result, Transform, AsynchronousProvider, Data, Results, Unsubscriber } from "../../index.js";
 /**
  * Firestore Lite client database provider.
  * - Works with the Firebase JS SDK.
@@ -10,10 +10,10 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
     get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
-    subscribe(): () => void;
+    subscribe(): Unsubscriber;
     add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
     write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
-    subscribeQuery(): () => void;
+    subscribeQuery(): Unsubscriber;
     writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,5 +1,5 @@
 import { Firestore } from "@google-cloud/firestore";
-import { Provider, DataDocument, DataQuery, Observer, Result, Transform, Data, AsynchronousProvider, Entry, Results } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Observer, Result, Transform, Data, AsynchronousProvider, Entry, Results, Unsubscriber } from "../../index.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
@@ -8,10 +8,10 @@ export declare class FirestoreServerProvider extends Provider implements Asynchr
     readonly firestore: Firestore;
     constructor(firestore?: Firestore);
     get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
-    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): () => void;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
     add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
     write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Iterable<Entry<T>>>;
-    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): () => void;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
     writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/server/FirestoreServerProvider.js

@@ -85,7 +85,7 @@ export class FirestoreServerProvider extends Provider {
         return (await getDocument(this.firestore, ref).get()).data();
     }
     subscribe(ref, observer) {
-        return getDocument(this.firestore, ref).onSnapshot(snapshot => dispatchNext(snapshot.data(), observer), thrown => dispatchError(thrown, observer));
+        return getDocument(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, snapshot.data()), thrown => dispatchError(observer, thrown));
     }
     async add(ref, data) {
         return (await getCollection(this.firestore, ref).add(data)).id;
@@ -102,7 +102,7 @@ export class FirestoreServerProvider extends Provider {
         return getResults(await getQuery(this.firestore, ref).get());
     }
     subscribeQuery(ref, observer) {
-        return getQuery(this.firestore, ref).onSnapshot(snapshot => dispatchNext(getResults(snapshot), observer), thrown => dispatchError(thrown, observer));
+        return getQuery(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, getResults(snapshot)), thrown => dispatchError(observer, thrown));
     }
     async writeQuery(ref, value) {
         const writer = this.firestore.bulkWriter();

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.20.3",
+	"version": "1.22.2",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/provider/MemoryProvider.js

@@ -1,4 +1,4 @@
-import { randomId, dispatch, dispatchNext, isMapEqual } from "../util/index.js";
+import { randomId, dispatchNext, isMapEqual, } from "../util/index.js";
 import { Transform } from "../transform/index.js";
 import { DocumentRequiredError } from "../db/index.js";
 import { Provider } from "./Provider.js";
@@ -25,10 +25,10 @@ export class MemoryProvider extends Provider {
         const table = this._table(ref);
         const id = ref.id;
         // Call next() immediately with initial results.
-        dispatchNext(table.data.get(id), observer);
+        dispatchNext(observer, table.data.get(id));
         // Call next() every time the collection changes.
         return table.on(changes => {
-            changes.has(id) && dispatchNext(changes.get(id), observer);
+            changes.has(id) && dispatchNext(observer, changes.get(id));
         });
     }
     add(ref, data) {
@@ -59,7 +59,7 @@ export class MemoryProvider extends Provider {
         const table = this._table(ref);
         // Call `next()` immediately with the initial results.
         let lastResults = new Map(ref.derive(table.data));
-        dispatchNext(lastResults, observer);
+        dispatchNext(observer, lastResults);
         // Possibly call `next()` when the collection changes if any changes affect the subscription.
         return table.on(changes => {
             for (const [id, next] of changes) {
@@ -71,7 +71,7 @@ export class MemoryProvider extends Provider {
                     const nextResults = new Map(ref.derive(table.data));
                     if (!isMapEqual(lastResults, nextResults)) {
                         lastResults = nextResults;
-                        dispatchNext(lastResults, observer);
+                        dispatchNext(observer, lastResults);
                     }
                     return;
                 }
@@ -99,11 +99,11 @@ class Table {
     constructor() {
         this.data = new Map();
         this.changes = new Map();
-        this.dispatchers = new Set();
+        this.listeners = new Set();
         this.fire = () => {
             if (this.changes.size) {
-                for (const dispatcher of this.dispatchers)
-                    dispatch(this.changes, dispatcher);
+                for (const dispatcher of this.listeners)
+                    dispatcher(this.changes);
                 this.changes.clear();
             }
         };
@@ -120,16 +120,16 @@ class Table {
             this.changes.set(id, value);
         }
     }
-    on(dispatcher) {
-        this.dispatchers.add(dispatcher);
-        return this.off.bind(this, dispatcher);
+    on(listener) {
+        this.listeners.add(listener);
+        return this.off.bind(this, listener);
     }
-    off(dispatcher) {
-        this.dispatchers.delete(dispatcher);
+    off(listener) {
+        this.listeners.delete(listener);
     }
     reset() {
         this.data.clear();
         this.changes.clear();
-        this.dispatchers.clear();
+        this.listeners.clear();
     }
 }

package/provider/ValidationProvider.js

@@ -1,6 +1,5 @@
 import { validate, ValidateObserver, callAsync } from "../util/index.js";
 import { Transform, validateTransform } from "../transform/index.js";
-import { throwFeedback } from "../feedback/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Validates any values that are read from or written to a source provider. */
 export class ValidationProvider extends ThroughProvider {
@@ -11,7 +10,7 @@ export class ValidationProvider extends ThroughProvider {
         return super.subscribe(ref, new ValidateObserver(ref, observer));
     }
     add(ref, data) {
-        return super.add(ref, throwFeedback(validate(data, ref.validator)));
+        return super.add(ref, validate(data, ref.validator));
     }
     write(ref, value) {
         return super.write(ref, value ? _validateWrite(value, ref.validator) : value);
@@ -28,5 +27,5 @@ export class ValidationProvider extends ThroughProvider {
 }
 /** Validate data or a transform for a path. */
 function _validateWrite(value, validator) {
-    return throwFeedback(value instanceof Transform ? validateTransform(value, validator) : validate(value, validator));
+    return value instanceof Transform ? validateTransform(value, validator) : validate(value, validator);
 }

package/react/useDocument.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, dispatchAsync } from "../index.js";
+import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE } from "../index.js";
 import { usePureEffect } from "./usePureEffect.js";
 import { usePureMemo } from "./usePureMemo.js";
 import { usePureState } from "./usePureState.js";
@@ -22,7 +22,7 @@ export function useAsyncDocument(ref, maxAge = 1000) {
     // If `maxAge` is `true` open a subscription for 10 seconds.
     // Done before `ref.get()` because efficient providers (i.e. `BatchProvider`) will reuse the subscription's first result as its first get request.
     if (maxAge === true)
-        setTimeout(ref.subscribe(setNext, setError), 10000);
+        setTimeout(ref.subscribe({ next: setNext, error: setError }), 10000);
     // Return a promise for the result.
     return ref.result;
 }
@@ -49,7 +49,7 @@ function subscribeEffect(ref, maxAge, next, error) {
         else {
             // If cache provider's cached document is older than maxAge then force refresh the data.
             if (provider.getCachedAge(ref) > maxAge)
-                dispatchAsync(ref.result, next, error);
+                Promise.resolve(ref.result).then(next, error);
         }
         return stopCache;
     }

package/react/useFetch.js

@@ -23,7 +23,7 @@ export function useFetch(fetcher, deps, maxAge = 86400000) {
         // Create a new state and start a fetch.
         state = new State();
         sources.set(key, state);
-        dispatchAsyncNext(fetcher(...deps), state);
+        dispatchAsyncNext(state, fetcher(...deps));
     }
     else if (state.closed) {
         // Clean up source in a few seconds if it's closed.
@@ -32,7 +32,7 @@ export function useFetch(fetcher, deps, maxAge = 86400000) {
     }
     else if (state.age > maxAge) {
         // Refetch if state has value and it's older than `maxAge`
-        dispatchAsyncNext(fetcher(...deps), state);
+        dispatchAsyncNext(state, fetcher(...deps));
     }
     useSubscribe(state);
     return state;

package/react/usePureState.d.ts

@@ -1,4 +1,4 @@
-import { Arguments, Dispatcher } from "../index.js";
+import { Arguments } from "../index.js";
 /**
  * Version of React's `useState()` that allows the use of a pure (side-effect free) function.
  * - Unlike `useState()` the initialiser will be re-run and the state will be regenerated if `args` changes.
@@ -13,6 +13,6 @@ import { Arguments, Dispatcher } from "../index.js";
  * - This means you can create the function once (outside the component) rather than creating it on every render.
  * - This improves performance (though probably only noticeable on functions that render 1,000s of times).
  */
-export declare function usePureState<T, A extends Arguments>(initial: (...args: A) => T, ...args: A): readonly [T, Dispatcher<T>];
-export declare function usePureState<T, A extends Arguments>(initial: new (...args: A) => T, ...args: A): readonly [T, Dispatcher<T>];
-export declare function usePureState<T>(initial: T, ...args: Arguments): readonly [T, Dispatcher<T>];
+export declare function usePureState<T, A extends Arguments>(initial: (...args: A) => T, ...args: A): readonly [T, (next: T) => void];
+export declare function usePureState<T, A extends Arguments>(initial: new (...args: A) => T, ...args: A): readonly [T, (next: T) => void];
+export declare function usePureState<T>(initial: T, ...args: Arguments): readonly [T, (next: T) => void];

package/react/useQuery.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, dispatchAsync, DeriveObserver, toMap, } from "../index.js";
+import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, DeriveObserver, toMap, } from "../index.js";
 import { usePureEffect } from "./usePureEffect.js";
 import { usePureMemo } from "./usePureMemo.js";
 import { usePureState } from "./usePureState.js";
@@ -22,7 +22,7 @@ export function useAsyncQuery(ref, maxAge = 1000) {
     // If `maxAge` is `true` open a subscription for 10 seconds.
     // Done before `ref.get()` because efficient providers (i.e. `BatchProvider`) will reuse the subscription's first result as its first get request.
     if (maxAge === true)
-        setTimeout(ref.subscribeMap(setNext, setError), 10000);
+        setTimeout(ref.subscribeMap({ next: setNext, error: setError }), 10000);
     // Return a promise for the result.
     return ref.resultsMap;
 }
@@ -50,7 +50,7 @@ function subscribeEffect(ref, maxAge, next, error) {
         else {
             // If cache provider's cached document is older than maxAge then force refresh the data.
             if (provider.getCachedAge(ref) > maxAge)
-                dispatchAsync(ref.resultsMap, next, error);
+                Promise.resolve(ref.resultsMap).then(next, error);
         }
         return stopCache;
     }

package/react/useSubscribe.js

@@ -14,4 +14,4 @@ export function useSubscribe(subscribable) {
     usePureEffect(subscribeEffect, useState(LOADING)[1], subscribable);
 }
 /** Effect that subscribes the component to changes in the `State` instance for the lifetime of the component. */
-const subscribeEffect = (setChange, subscribable) => subscribable ? subscribe(subscribable, { next: setChange, error: setChange }) : undefined;
+const subscribeEffect = (change, subscribable) => subscribable ? subscribe(subscribable, { next: change, error: change }) : undefined;

package/schema/SlugSchema.d.ts

@@ -0,0 +1,18 @@
+import { StringSchema } from "./StringSchema.js";
+/**
+ * Define a valid slug, e.g. `this-is-a-slug`
+ *
+ * - Useful for URL components, usernames, etc.
+ * - Minimum slug length is 2 characters.
+ * - Maximum slug length is 64 characters.
+ */
+export declare class SlugSchema extends StringSchema {
+    readonly multiline = false;
+    readonly min = 2;
+    readonly max = 32;
+    sanitize(unsafeString: string): string;
+}
+/** Valid slug, e.g. `this-is-a-slug` */
+export declare const SLUG: SlugSchema;
+/** Valid slug, e.g. `this-is-a-slug`, or `null` */
+export declare const OPTIONAL_SLUG: import("./OptionalSchema.js").OptionalSchema<string>;

package/schema/SlugSchema.js

@@ -0,0 +1,25 @@
+import { toSlug } from "../util/index.js";
+import { OPTIONAL } from "./OptionalSchema.js";
+import { StringSchema } from "./StringSchema.js";
+/**
+ * Define a valid slug, e.g. `this-is-a-slug`
+ *
+ * - Useful for URL components, usernames, etc.
+ * - Minimum slug length is 2 characters.
+ * - Maximum slug length is 64 characters.
+ */
+export class SlugSchema extends StringSchema {
+    constructor() {
+        super(...arguments);
+        this.multiline = false;
+        this.min = 2;
+        this.max = 32;
+    }
+    sanitize(unsafeString) {
+        return toSlug(unsafeString);
+    }
+}
+/** Valid slug, e.g. `this-is-a-slug` */
+export const SLUG = new SlugSchema({});
+/** Valid slug, e.g. `this-is-a-slug`, or `null` */
+export const OPTIONAL_SLUG = OPTIONAL(SLUG);

package/schema/index.d.ts

@@ -7,12 +7,13 @@ export * from "./DataSchema.js";
 export * from "./DateSchema.js";
 export * from "./EmailSchema.js";
 export * from "./KeySchema.js";
+export * from "./LinkSchema.js";
 export * from "./MapSchema.js";
-export * from "./OptionalSchema.js";
 export * from "./NumberSchema.js";
 export * from "./ObjectSchema.js";
+export * from "./OptionalSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./RequiredSchema.js";
+export * from "./SlugSchema.js";
 export * from "./StringSchema.js";
 export * from "./ThroughSchema.js";
-export * from "./LinkSchema.js";

package/schema/index.js

@@ -7,12 +7,13 @@ export * from "./DataSchema.js";
 export * from "./DateSchema.js";
 export * from "./EmailSchema.js";
 export * from "./KeySchema.js";
+export * from "./LinkSchema.js";
 export * from "./MapSchema.js";
-export * from "./OptionalSchema.js";
 export * from "./NumberSchema.js";
 export * from "./ObjectSchema.js";
+export * from "./OptionalSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./RequiredSchema.js";
+export * from "./SlugSchema.js";
 export * from "./StringSchema.js";
 export * from "./ThroughSchema.js";
-export * from "./LinkSchema.js";

package/stream/LastStream.js

@@ -4,7 +4,7 @@ import { Stream } from "./Stream.js";
 export class LastStream extends Stream {
     // Override to dispatch only to a slice of the subscribers.
     _dispatch(value) {
-        const subscriber = getLastItem(this._subscribers);
+        const subscriber = getLastItem(this._observers);
         if (subscriber)
             dispatchNext(subscriber, value);
     }

package/stream/LazyState.d.ts

@@ -8,5 +8,5 @@ export declare class LazyState<T> extends State<T> {
     private _delay;
     private _timeout?;
     constructor(delay?: number);
-    off(observer: Observer<T>): void;
+    _off(observer: Observer<T>): void;
 }

package/stream/LazyState.js

@@ -9,20 +9,20 @@ export class LazyState extends State {
         this._delay = delay;
     }
     // Override to stop the source subscription when the last subscriber unsubscribes.
-    off(observer) {
-        super.off(observer);
+    _off(observer) {
+        super._off(observer);
         if (this._delay) {
             // Maybe stop in a bit (if there are still no subscribers).
             if (this._timeout)
                 clearTimeout(this._timeout);
             this._timeout = setTimeout(() => {
-                if (!this._subscribers.size && !this.closed)
+                if (!this._observers.size && !this.closed)
                     this.complete();
             }, this._delay);
         }
         else {
             // Stop now.
-            if (!this._subscribers.size && !this.closed)
+            if (!this._observers.size && !this.closed)
                 this.complete();
         }
     }

package/stream/LazyStream.d.ts

@@ -8,5 +8,5 @@ export declare class LazyStream<T> extends Stream<T> {
     private _delay;
     private _timeout?;
     constructor(delay?: number);
-    off(observer: Observer<T>): void;
+    _off(observer: Observer<T>): void;
 }

package/stream/LazyStream.js

@@ -9,19 +9,19 @@ export class LazyStream extends Stream {
         this._delay = delay;
     }
     // Override to stop the source subscription when the last subscriber unsubscribes.
-    off(observer) {
-        super.off(observer);
+    _off(observer) {
+        super._off(observer);
         if (this._delay) {
             // Maybe stop in a bit (if there are still no subscribers).
-            if (!this._subscribers.size && !this.closed) {
+            if (!this._observers.size && !this.closed) {
                 if (this._timeout)
                     clearTimeout(this._timeout);
-                this._timeout = setTimeout(() => !this._subscribers.size && !this.closed && this.complete(), this._delay);
+                this._timeout = setTimeout(() => !this._observers.size && !this.closed && this.complete(), this._delay);
             }
         }
         else {
             // Stop now.
-            if (!this._subscribers.size && !this.closed)
+            if (!this._observers.size && !this.closed)
                 this.complete();
         }
     }

package/stream/State.d.ts

@@ -35,7 +35,7 @@ export declare class State<T> extends Stream<T> {
     /** Apply a deriver to this state. */
     apply(deriver: Deriver<T, T>): void;
     error(reason: Error | unknown): void;
-    on(observer: Observer<T>): void;
+    _on(observer: Observer<T>): void;
     protected _dispatch(value: T): void;
 }
 /** Create a state with an initial value. */

package/stream/State.js

@@ -45,14 +45,14 @@ export class State extends Stream {
         super.error(reason);
     }
     // Override to send the current error or value to any new subscribers.
-    on(observer) {
-        super.on(observer);
+    _on(observer) {
+        super._on(observer);
         if (this.reason !== NOERROR)
-            dispatchError(this.reason, observer);
+            dispatchError(observer, this.reason);
         else if (this.closed)
             dispatchComplete(observer);
         else if (this._value !== LOADING)
-            dispatchNext(this.value, observer);
+            dispatchNext(observer, this._value);
     }
     // Dispatcher saves any values that are dispatched.
     _dispatch(value) {

package/stream/Stream.d.ts

@@ -1,4 +1,4 @@
-import { Deriver, ObserverType, Subscribable, Dispatcher, Unsubscriber, Observer, Observable, Constructor } from "../util/index.js";
+import { Deriver, ObserverType, Subscribable, Unsubscriber, Observer, Observable, Constructor, Dispatcher } from "../util/index.js";
 /** Any stream (useful for `extends AnyStream` clauses). */
 export declare type AnyStream = Stream<any>;
 /**
@@ -11,7 +11,7 @@ export declare class Stream<T> implements Observer<T>, Observable<T> {
     /** List of sources this stream is subscribed to. */
     protected readonly _cleanups: Set<Unsubscriber>;
     /** List of subscribed observers that values are forwarded to. */
-    protected readonly _subscribers: Set<Observer<T>>;
+    protected readonly _observers: Set<Observer<T>>;
     /** Get the number of current subscribers. */
     get subscribers(): number;
     /** Is this stream open or closed (i.e. `error()` or `complete()` have been called. */
@@ -55,9 +55,9 @@ export declare class Stream<T> implements Observer<T>, Observable<T> {
      * - Allows either an `Observer` object or  separate `next()`, `error()` and `complete()` functions.
      * - Implements `Observable`
      */
-    subscribe(next: Observer<T> | Dispatcher<T>, error?: Dispatcher<unknown>, complete?: Dispatcher<void>): Unsubscriber;
-    /** Add an observer to this stream. */
-    on(observer: Observer<T>): void;
-    /** Remove an observer from this stream. */
-    off(observer: Observer<T>): void;
+    subscribe(next: Observer<T> | Dispatcher<[T]>): Unsubscriber;
+    /** Add an observer. */
+    _on(observer: Observer<T>): void;
+    /** Remove an observer. */
+    _off(observer: Observer<T>): void;
 }

package/stream/Stream.js

@@ -1,5 +1,5 @@
 var _a;
-import { AsyncObserver, DeriveObserver, dispatchNext, dispatchError, dispatchComplete, createObserver, subscribe, dispatch, } from "../util/index.js";
+import { AsyncObserver, DeriveObserver, dispatchNext, dispatchError, dispatchComplete, subscribe, dispatch, } from "../util/index.js";
 import { ConditionError } from "../error/index.js";
 /**
  * Simple stream.
@@ -10,13 +10,13 @@ export class Stream {
         /** List of sources this stream is subscribed to. */
         this._cleanups = new Set();
         /** List of subscribed observers that values are forwarded to. */
-        this._subscribers = new Set();
+        this._observers = new Set();
         /** Is this stream open or closed (i.e. `error()` or `complete()` have been called. */
         this.closed = false;
     }
     /** Get the number of current subscribers. */
     get subscribers() {
-        return this._subscribers.size;
+        return this._observers.size;
     }
     /**
      * Send a next value.
@@ -29,8 +29,8 @@ export class Stream {
     }
     /** Call `next()` on the subscribers. */
     _dispatch(value) {
-        for (const subscriber of this._subscribers)
-            dispatchNext(value, subscriber);
+        for (const observer of this._observers)
+            dispatchNext(observer, value);
     }
     /**
      * Complete this stream with an error.
@@ -41,9 +41,9 @@ export class Stream {
         if (this.closed)
             throw new ConditionError("Stream is closed");
         this._close();
-        for (const subscriber of this._subscribers) {
-            dispatchError(reason, subscriber);
-            this.off(subscriber);
+        for (const subscriber of this._observers) {
+            this._observers.delete(subscriber);
+            dispatchError(subscriber, reason);
         }
     }
     /**
@@ -55,17 +55,17 @@ export class Stream {
         if (this.closed)
             throw new ConditionError("Stream is closed");
         this._close();
-        for (const subscriber of this._subscribers) {
+        for (const subscriber of this._observers) {
+            this._observers.delete(subscriber);
             dispatchComplete(subscriber);
-            this.off(subscriber);
         }
     }
     /** Close this stream. */
     _close() {
         this.closed = true;
         for (const cleanup of this._cleanups) {
-            dispatch(undefined, cleanup);
             this._cleanups.delete(cleanup);
+            dispatch(cleanup);
         }
     }
     /** Start a subscription that gets cleaned up when this subscriber ends. */
@@ -102,18 +102,18 @@ export class Stream {
      * - Allows either an `Observer` object or  separate `next()`, `error()` and `complete()` functions.
      * - Implements `Observable`
      */
-    subscribe(next, error, complete) {
-        const observer = createObserver(next, error, complete);
-        this.on(observer);
-        return this.off.bind(this, observer);
+    subscribe(next) {
+        const observer = typeof next === "function" ? { next } : next;
+        this._on(observer);
+        return this._off.bind(this, observer);
     }
-    /** Add an observer to this stream. */
-    on(observer) {
-        this._subscribers.add(observer);
+    /** Add an observer. */
+    _on(observer) {
+        this._observers.add(observer);
     }
-    /** Remove an observer from this stream. */
-    off(observer) {
-        this._subscribers.delete(observer);
+    /** Remove an observer. */
+    _off(observer) {
+        this._observers.delete(observer);
     }
 }
 _a = Symbol.species;

package/util/async.d.ts

@@ -1,6 +1,6 @@
 import { DONE } from "./constants.js";
-import type { Dispatcher } from "./dispatch.js";
-import type { Arguments } from "./function.js";
+import { Handler } from "./error.js";
+import type { Arguments, Dispatcher } from "./function.js";
 /**
  * Throw the value if it's an async (promised) value.
  * @returns Synchronous (not promised) value.
@@ -15,15 +15,15 @@ export declare const _awaitCallAsync: <I, O, A extends Arguments>(callback: (v:
 /** Type of `Promise` with its `resolve()` and `reject()` methods exposed publicly. */
 export declare class Deferred<T> extends Promise<T> {
     static get [Symbol.species](): PromiseConstructor;
-    readonly resolve: Dispatcher<T | PromiseLike<T>>;
-    readonly reject: Dispatcher<Error | unknown | PromiseLike<Error | unknown>>;
+    readonly resolve: Dispatcher<[T]>;
+    readonly reject: Handler;
     constructor();
 }
 /** Type of `Promise` with `._resolve()` and `._reject()` methods available. */
 export declare abstract class AbstractPromise<T> extends Promise<T> {
     static get [Symbol.species](): PromiseConstructor;
-    protected readonly _resolve: Dispatcher<T | PromiseLike<T>>;
-    protected readonly _reject: Dispatcher<Error | unknown>;
+    protected readonly _resolve: Dispatcher<[T]>;
+    protected readonly _reject: Handler;
     constructor();
 }
 /** Promise that resolves after a specified delay in milliseconds. */

package/util/error.js

@@ -1,3 +1,3 @@
 /** Handle an error by logging it to the console. */
 // eslint-disable-next-line no-console
-export const logError = (reason) => void console.error(reason);
+export const logError = reason => console.error(reason);

package/util/function.d.ts

@@ -8,3 +8,11 @@ export declare type Arguments = readonly unknown[];
 export declare const PASSTHROUGH: <T>(value: T) => T;
 /** Function that does nothing with its arguments and always returns void. */
 export declare const BLACKHOLE: (...args: Arguments) => void | undefined;
+/** Function that receives a dispatched value. */
+export declare type Dispatcher<T extends Arguments = []> = (...value: T) => void;
+/** Safely dispatch a value to a dispatcher function. */
+export declare function dispatch<T extends Arguments>(dispatcher: Dispatcher<T>, ...value: T): void;
+/** Safely dispatch a value to a dispatcher method on an object. */
+export declare function dispatchMethod<T extends Arguments, M extends string | symbol>(obj: {
+    [K in M]: Dispatcher<T>;
+}, key: M, ...value: T): void;

package/util/function.js

@@ -1,6 +1,25 @@
+import { logError } from "./error.js";
 /** Is a value a function? */
 export const isFunction = (v) => typeof v === "function";
 /** Function that just passes through the first argument. */
 export const PASSTHROUGH = (value) => value;
 /** Function that does nothing with its arguments and always returns void. */
 export const BLACKHOLE = () => undefined;
+/** Safely dispatch a value to a dispatcher function. */
+export function dispatch(dispatcher, ...value) {
+    try {
+        dispatcher(...value);
+    }
+    catch (thrown) {
+        logError(thrown);
+    }
+}
+/** Safely dispatch a value to a dispatcher method on an object. */
+export function dispatchMethod(obj, key, ...value) {
+    try {
+        obj[key](...value);
+    }
+    catch (thrown) {
+        logError(thrown);
+    }
+}

package/util/index.d.ts

@@ -9,7 +9,6 @@ export * from "./date.js";
 export * from "./debug.js";
 export * from "./derive.js";
 export * from "./diff.js";
-export * from "./dispatch.js";
 export * from "./entry.js";
 export * from "./equal.js";
 export * from "./error.js";

package/util/index.js

@@ -9,7 +9,6 @@ export * from "./date.js";
 export * from "./debug.js";
 export * from "./derive.js";
 export * from "./diff.js";
-export * from "./dispatch.js";
 export * from "./entry.js";
 export * from "./equal.js";
 export * from "./error.js";

package/util/observable.d.ts

@@ -1,14 +1,12 @@
-import { Dispatcher } from "./dispatch.js";
+import { Dispatcher } from "./function.js";
+import { Handler } from "./error.js";
 import { Deriver } from "./derive.js";
 import { Validator } from "./validate.js";
 /** Function that ends a subscription. */
 export declare type Unsubscriber = () => void;
 /** An object that can initiate a subscription with its `subscribe()`. */
 export interface Observable<T> {
-    /** Subscribe allows either an `Observer` or separate `next()`, `error()` and `complete()` functions. */
-    subscribe(observer: Observer<T>): Unsubscriber;
-    subscribe(next: Dispatcher<T>, error?: Dispatcher<unknown>, complete?: Dispatcher<void>): Unsubscriber;
-    subscribe(either: Observer<T> | Dispatcher<T>, error?: Dispatcher<unknown>, complete?: Dispatcher<void>): Unsubscriber;
+    subscribe(observer: Observer<T> | Dispatcher<[T]>): Unsubscriber;
 }
 /** Any observable (useful for `extends AnyObservable` clauses). */
 export declare type AnyObservable = Observable<any>;
@@ -40,11 +38,11 @@ export interface Observer<T> {
      */
     readonly from?: (source: Subscribable<T>) => this;
     /** Receive the next value. */
-    readonly next?: Dispatcher<T>;
+    readonly next: Dispatcher<[T]>;
     /** End the subscription with an error. */
-    readonly error?: Dispatcher<unknown>;
+    readonly error?: Handler;
     /** End the subscription with success. */
-    readonly complete?: Dispatcher<void>;
+    readonly complete?: Dispatcher;
     /** Whether the subscription has ended (either with success or failure). */
     readonly closed?: boolean;
 }
@@ -53,15 +51,13 @@ export declare type ObserverType<T extends AnyObserver> = T extends Observer<inf
 /** Any observer (useful for `extends AnyObserver` clauses). */
 export declare type AnyObserver = Observer<any>;
 /** Dispatch the next value to an observer (and if the next value errors, calls a handler). */
-export declare function dispatchNext<T>(value: T, observer: Observer<T>, handler?: import("./error.js").Handler): void;
+export declare function dispatchNext<T>(observer: Observer<T>, value: T): void;
 /** Dispatch the next value to an observer (and if the next value errors, calls a handler). */
-export declare function dispatchAsyncNext<T>(value: PromiseLike<T>, observer: Observer<T>, handler?: import("./error.js").Handler): void;
+export declare function dispatchAsyncNext<T>(observer: Observer<T>, value: PromiseLike<T>): void;
 /** Dispatch a complete call an observer (and if the next value errors, calls a handler). */
-export declare function dispatchComplete<T>(observer: Observer<T>, handler?: import("./error.js").Handler): void;
+export declare function dispatchComplete<T>(observer: Observer<T>): void;
 /** Dispatch an error value to an observer. */
-export declare function dispatchError<T>(reason: Error | unknown, observer: Observer<T>, handler?: import("./error.js").Handler): void;
-/** Create an `Observer` from a set `next()`, `error()` and `complete()` functions. */
-export declare function createObserver<T>(next: Observer<T> | Dispatcher<T>, error?: Dispatcher<unknown>, complete?: Dispatcher<void>): Observer<T>;
+export declare function dispatchError<T>(observer: Observer<T>, reason: Error | unknown): void;
 /** Abstract observer designed to pass values through to an observer. */
 export declare abstract class AbstractObserver<I, O> implements Observer<I> {
     protected _cleanup: Unsubscriber | undefined;

package/util/observable.js

@@ -1,5 +1,5 @@
 import { ConditionError } from "../error/index.js";
-import { dispatch } from "./dispatch.js";
+import { BLACKHOLE, dispatch } from "./function.js";
 import { logError } from "./error.js";
 import { isData } from "./data.js";
 import { derive } from "./derive.js";
@@ -15,44 +15,38 @@ export function subscribe(source, target) {
     return typeof source === "function" ? source(target) : source.subscribe(target);
 }
 /** Dispatch the next value to an observer (and if the next value errors, calls a handler). */
-export function dispatchNext(value, observer, handler = logError) {
-    var _a;
+export function dispatchNext(observer, value) {
     try {
-        (_a = observer.next) === null || _a === void 0 ? void 0 : _a.call(observer, value);
+        observer.next(value);
     }
     catch (thrown) {
-        handler(thrown);
+        logError(thrown);
     }
 }
 /** Dispatch the next value to an observer (and if the next value errors, calls a handler). */
-export function dispatchAsyncNext(value, observer, handler = logError) {
-    if (observer.next)
-        value.then(v => dispatchNext(v, observer, handler), handler);
+export function dispatchAsyncNext(observer, value) {
+    value.then(v => dispatchNext(observer, v), logError);
 }
 /** Dispatch a complete call an observer (and if the next value errors, calls a handler). */
-export function dispatchComplete(observer, handler = logError) {
+export function dispatchComplete(observer) {
     var _a;
     try {
         (_a = observer.complete) === null || _a === void 0 ? void 0 : _a.call(observer);
     }
     catch (thrown) {
-        handler(thrown);
+        logError(thrown);
     }
 }
 /** Dispatch an error value to an observer. */
-export function dispatchError(reason, observer, handler = logError) {
+export function dispatchError(observer, reason) {
     var _a;
     try {
         (_a = observer.error) === null || _a === void 0 ? void 0 : _a.call(observer, reason);
     }
     catch (thrown) {
-        handler(thrown);
+        logError(thrown);
     }
 }
-/** Create an `Observer` from a set `next()`, `error()` and `complete()` functions. */
-export function createObserver(next, error, complete) {
-    return typeof next === "object" ? next : { next, error, complete };
-}
 /** Abstract observer designed to pass values through to an observer. */
 export class AbstractObserver {
     constructor(target) {
@@ -78,7 +72,7 @@ export class AbstractObserver {
         if (!target)
             throw new ConditionError("Observer is closed");
         this._close();
-        dispatchError(reason, target);
+        dispatchError(target, reason);
     }
     complete() {
         const target = this._target;
@@ -91,7 +85,7 @@ export class AbstractObserver {
         if (this._target)
             this._target = undefined;
         if (this._cleanup)
-            this._cleanup = void dispatch(undefined, this._cleanup);
+            this._cleanup = void dispatch(this._cleanup);
     }
 }
 /** Observer that unsubscribes.*/
@@ -99,7 +93,7 @@ export class ThroughObserver extends AbstractObserver {
     next(value) {
         if (!this._target)
             throw new ConditionError("Observer is closed");
-        dispatchNext(value, this._target);
+        dispatchNext(this._target, value);
     }
 }
 /** Observer that fires once then ends itself. */
@@ -119,7 +113,7 @@ export class DeriveObserver extends AbstractObserver {
         const target = this._target;
         if (!target)
             throw new ConditionError("Observer is closed");
-        dispatchNext(derive(value, this._deriver), target);
+        dispatchNext(target, derive(value, this._deriver));
     }
 }
 /** Observer that validates its next values with a validator. */
@@ -132,7 +126,7 @@ export class ValidateObserver extends AbstractObserver {
         const target = this._target;
         if (!target)
             throw new ConditionError("Observer is closed");
-        dispatchNext(validate(value, this._validator), target);
+        dispatchNext(target, validate(value, this._validator));
     }
 }
 /** Oserver that allows promised values to be passed to `next()`. */
@@ -141,7 +135,7 @@ export class AsyncObserver extends AbstractObserver {
         const target = this._target;
         if (!target)
             throw new ConditionError("Observer is closed");
-        dispatchAsyncNext(value, target);
+        dispatchAsyncNext(target, value);
     }
 }
 /** Get a promise that resolves to the next value of a source subscribable. */
@@ -150,5 +144,5 @@ export function awaitNext(source) {
 }
 /** Get a promise that resolves when a source subscribable is complete. */
 export function awaitComplete(source) {
-    return new Promise((complete, error) => new ThroughObserver({ complete, error }).from(source));
+    return new Promise((complete, error) => new ThroughObserver({ next: BLACKHOLE, complete, error }).from(source));
 }

package/feedback/util.d.ts

@@ -1,3 +0,0 @@
-import { Feedback } from "./Feedback.js";
-/** Throw the value if it's an instance of `Feedback` */
-export declare function throwFeedback<T>(value: T | Feedback): T;

package/feedback/util.js

@@ -1,7 +0,0 @@
-import { Feedback } from "./Feedback.js";
-/** Throw the value if it's an instance of `Feedback` */
-export function throwFeedback(value) {
-    if (value instanceof Feedback)
-        throw value;
-    return value;
-}

package/util/dispatch.d.ts

@@ -1,29 +0,0 @@
-/** Function that dispatches a value (we never care about the returned value). */
-export declare type Dispatcher<T> = (value: T) => void;
-/**
- * Safely dispatch a value to a dispatcher function.
- *
- * @param value The value to dispatch into the dispatcher function.
- * @param dispatcher Any dispatcher function.
- * - Any errors thrown or rejected by the dispatcher are caught and routed to the catcher.
- * @param handler Handler that handles any thrown errors.
- */
-export declare function dispatch<T>(value: T, dispatcher: Dispatcher<T>, handler?: import("./error.js").Handler): void;
-/** Safely dispatch an async value to a dispatcher function. */
-export declare function dispatchAsync<T>(value: T | PromiseLike<T>, dispatcher: Dispatcher<T>, handler?: import("./error.js").Handler): void;
-/**
- * Safely dispatch a value to a dispatcher method on an object.
- *
- * @param value The value to dispatch into the dispatcher method.
- * @param obj The object containing the method.
- * @param key The key specifiying which method to call (if the method is not defined, nothing will be dispatched).
- * - Any errors thrown or rejected by the dispatcher are caught and routed to the catcher.
- * @param handler Handler that handles any thrown errors.
- */
-export declare function thispatch<T, M extends string | symbol>(value: T, obj: {
-    [K in M]: Dispatcher<T>;
-}, key: M, handler?: import("./error.js").Handler): void;
-/** Safely dispatch an async value to a dispatcher method on an object. */
-export declare function thispatchAsync<T, M extends string | symbol>(value: T | PromiseLike<T>, obj: {
-    [K in M]: Dispatcher<T>;
-}, key: M, handler?: import("./error.js").Handler): void;

package/util/dispatch.js

@@ -1,43 +0,0 @@
-import { logError } from "./error.js";
-import { callAsync } from "./async.js";
-/**
- * Safely dispatch a value to a dispatcher function.
- *
- * @param value The value to dispatch into the dispatcher function.
- * @param dispatcher Any dispatcher function.
- * - Any errors thrown or rejected by the dispatcher are caught and routed to the catcher.
- * @param handler Handler that handles any thrown errors.
- */
-export function dispatch(value, dispatcher, handler = logError) {
-    try {
-        dispatcher(value);
-    }
-    catch (thrown) {
-        handler(thrown);
-    }
-}
-/** Safely dispatch an async value to a dispatcher function. */
-export function dispatchAsync(value, dispatcher, handler = logError) {
-    void callAsync(dispatch, value, dispatcher, handler);
-}
-/**
- * Safely dispatch a value to a dispatcher method on an object.
- *
- * @param value The value to dispatch into the dispatcher method.
- * @param obj The object containing the method.
- * @param key The key specifiying which method to call (if the method is not defined, nothing will be dispatched).
- * - Any errors thrown or rejected by the dispatcher are caught and routed to the catcher.
- * @param handler Handler that handles any thrown errors.
- */
-export function thispatch(value, obj, key, handler = logError) {
-    try {
-        obj[key](value);
-    }
-    catch (thrown) {
-        handler(thrown);
-    }
-}
-/** Safely dispatch an async value to a dispatcher method on an object. */
-export function thispatchAsync(value, obj, key, handler = logError) {
-    void callAsync(thispatch, value, obj, key, handler);
-}