shelving 1.96.2 → 1.97.0

package/state/State.js

@@ -1,4 +1,5 @@
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
+import { NONE } from "../util/constants.js";
 import { runSequence } from "../util/sequence.js";
 /**
  * Stream that retains its most recent value
@@ -7,13 +8,15 @@ import { runSequence } from "../util/sequence.js";
  * - States can also be in a loading state where they do not have a current value.
  *
  * @param initial The initial value for the state, a `Promise` that resolves to the initial value, a source `Subscribable` to subscribe to, or another `State` instance to take the initial value from and subscribe to.
- * - To set the state to be loading, use the `State.NOVALUE` constant or a `Promise` value.
+ * - To set the state to be loading, use the `NONE` constant or a `Promise` value.
  * - To set the state to an explicit value, use that value or another `State` instance with a value.
  * */
-class State {
-    /** Most recently dispatched value (or throw `Promise` that resolves to the next value). */
+export class State {
+    /** Current value of the state (or throw a promise that resolves when this state receives its next value or error). */
     get value() {
-        if (this._value === State.NOVALUE)
+        if (this._reason !== undefined)
+            throw this._reason;
+        if (this._value === NONE)
             throw this.next;
         return this._value;
     }
@@ -21,34 +24,47 @@ class State {
     get time() {
         return this._time;
     }
+    /** Is there a current value, or is it still loading. */
+    get loading() {
+        return this._value === NONE;
+    }
     /** How old this state's value is (in milliseconds). */
     get age() {
         const time = this.time;
-        return time !== null ? Date.now() - time : Infinity;
+        return typeof time === "number" ? Date.now() - time : Infinity;
+    }
+    /** Current error of this state (or `undefined` if there is no reason). */
+    get reason() {
+        return this._reason;
     }
     /** State is initiated with an initial state. */
-    constructor(initial = State.NOVALUE, next = new DeferredSequence()) {
-        this._value = State.NOVALUE;
-        this._time = null;
-        if (initial !== State.NOVALUE) {
-            this._value = this.validate(initial);
-            this._time = Date.now();
+    constructor(options = {}) {
+        this._value = NONE;
+        this._time = undefined;
+        this._reason = undefined;
+        if ("value" in options) {
+            this._value = this.validate(options.value);
+            this._time = options.time || Date.now();
         }
-        this.next = next;
-    }
-    /** Is there a current value, or is it still loading. */
-    get loading() {
-        return this._value === State.NOVALUE;
+        this.next = options.next || new DeferredSequence();
     }
     /** Set the value of the state. */
     set(next) {
         const value = this.validate(next);
-        if (value !== this._value) {
+        if (value !== this._value || this._reason !== undefined) {
+            this._reason = undefined;
             this._value = value;
             this._time = Date.now();
             this.next.resolve(value);
         }
     }
+    /** Set the error reason of the state (will be  */
+    error(reason) {
+        this._reason = reason;
+        if (reason !== undefined) {
+            this.next.reject(reason);
+        }
+    }
     /** Set the value of the state as values are pulled from a sequence. */
     async *through(sequence) {
         for await (const value of sequence) {
@@ -77,8 +93,5 @@ class State {
         return value;
     }
 }
-/** The `NOVALUE` symbol indicates no value has been received by a `State` instance. */
-State.NOVALUE = Symbol("shelving/State.NOVALUE");
-export { State };
 /** Is an unknown value a `State` instance. */
 export const isState = (value) => value instanceof State;

package/util/activity.d.ts

@@ -1,38 +1,34 @@
-import type { Arguments, Dispatch, Handler, Start } from "./function.js";
+import type { Dispatch } from "./function.js";
+/** Function that starts something. */
+export type Start<T = void> = (value: T) => Stop | void;
+/** Function that stops something. */
+export type Stop = Dispatch;
 /** Something that can be started and stopped. */
-export interface Activity<A extends Arguments = []> {
+export interface Activity<T = void> {
     /** Start this activity. */
-    start(...args: A): void;
+    start(value: T): void;
     /** Stop this activity. */
     stop(): void;
 }
-/** Wrap a `Start` to create an `Activity` */
-export declare class StartActivity<A extends Arguments = []> implements Activity<A> {
+/** Wrap a `Start` function to create an `Activity` object. */
+export declare class StartActivity<T = void> implements Activity<T> {
     private readonly _start;
     private _stop;
-    constructor(start: Start<A>);
-    start(...args: A): void;
-    stop(): void;
-}
-/** Wrap an `AsyncIterable` to create an `Activity` */
-export declare class SequenceActivity<T> implements Activity<[Dispatch<[T]>, Handler]> {
-    private readonly _sequence;
-    private _stop;
-    constructor(sequence: AsyncIterable<T>);
-    start(onNext?: Dispatch<[T]>, onError?: Handler): void;
+    constructor(start: Start<T>);
+    start(value: T): void;
     stop(): void;
 }
 /** Set of items that starts/stops an `Activity` when it has items. */
 export declare class LazySet<T> extends Set<T> {
     private readonly _activity;
-    constructor(start: Start<[Set<T>]>);
+    constructor(start: Start<Set<T>>);
     add(value: T): this;
     delete(value: T): boolean;
 }
 /** Map of items that starts/stops an `Activity` when it has items. */
 export declare class LazyMap<K, T> extends Map<K, T> {
     private readonly _activity;
-    constructor(start: Start<[Map<K, T>]>);
+    constructor(start: Start<Map<K, T>>);
     set(key: K, value: T): this;
     delete(key: K): boolean;
 }

package/util/activity.js

@@ -1,25 +1,11 @@
 import { BLACKHOLE } from "./function.js";
-import { runSequence } from "./sequence.js";
-/** Wrap a `Start` to create an `Activity` */
+/** Wrap a `Start` function to create an `Activity` object. */
 export class StartActivity {
     constructor(start) {
         this._start = start;
     }
-    start(...args) {
-        this._stop || (this._stop = this._start(...args) || BLACKHOLE);
-    }
-    stop() {
-        if (this._stop)
-            this._stop = void this._stop();
-    }
-}
-/** Wrap an `AsyncIterable` to create an `Activity` */
-export class SequenceActivity {
-    constructor(sequence) {
-        this._sequence = sequence;
-    }
-    start(onNext, onError) {
-        this._stop || (this._stop = runSequence(this._sequence, onNext, onError));
+    start(value) {
+        this._stop || (this._stop = this._start(value) || BLACKHOLE);
     }
     stop() {
         if (this._stop)

package/util/array.d.ts

@@ -30,18 +30,18 @@ export declare function omitArrayItems<T>(input: ImmutableArray<T> | Iterable<T>
 export declare const clearArray: <T>(input: ImmutableArray<T>) => ImmutableArray<T>;
 /** Toggle an item in and out of an array (immutably) and return a new array with or without the specified items (or the same array if no changes were made). */
 export declare function toggleArrayItems<T>(input: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
-/** Get the first item from an array or iterable, or `null` if it didn't exist. */
-export declare function getOptionalFirstItem<T>(items: PossibleArray<T>): T | null;
+/** Get the first item from an array or iterable, or `undefined` if it didn't exist. */
+export declare function getOptionalFirstItem<T>(items: PossibleArray<T>): T | undefined;
 /** Get the first item from an array or iterable. */
 export declare function getFirstItem<T>(items: PossibleArray<T>): T;
-/** Get the last item from an array or iterable, or `null` if it didn't exist. */
-export declare function getOptionalLastItem<T>(items: PossibleArray<T>): T | null;
+/** Get the last item from an array or iterable, or `undefined` if it didn't exist. */
+export declare function getOptionalLastItem<T>(items: PossibleArray<T>): T | undefined;
 /** Get the last item from an array or iterable. */
 export declare function getLastItem<T>(items: PossibleArray<T>): T;
 /** Get the next item in an array or iterable. */
-export declare function getNextItem<T>(items: PossibleArray<T>, value: T): T | null;
+export declare function getOptionalNextItem<T>(items: PossibleArray<T>, value: T): T | undefined;
 /** Get the previous item in an array or iterable. */
-export declare function getPrevItem<T>(items: PossibleArray<T>, value: T): T | null;
+export declare function getOptionalPrevItem<T>(items: PossibleArray<T>, value: T): T | undefined;
 /** Return a shuffled version of an array or iterable. */
 export declare function shuffleArray<T>(input: PossibleArray<T>): ImmutableArray<T>;
 /** Add an item to an array (by reference) and return the set item. */

package/util/array.js

@@ -41,33 +41,34 @@ export function toggleArrayItems(input, ...items) {
     const output = input.filter(_doesNotInclude, items);
     return extras.length ? [...output, ...extras] : output.length !== input.length ? output : input;
 }
-/** Get the first item from an array or iterable, or `null` if it didn't exist. */
+/** Get the first item from an array or iterable, or `undefined` if it didn't exist. */
 export function getOptionalFirstItem(items) {
     const arr = getArray(items);
-    return 0 in arr ? arr[0] : null;
+    return 0 in arr ? arr[0] : undefined;
 }
 /** Get the first item from an array or iterable. */
 export function getFirstItem(items) {
     const item = getOptionalFirstItem(items);
-    if (item === null)
+    if (item === undefined)
         throw new RequiredError("First item is required");
     return item;
 }
-/** Get the last item from an array or iterable, or `null` if it didn't exist. */
+/** Get the last item from an array or iterable, or `undefined` if it didn't exist. */
 export function getOptionalLastItem(items) {
     const arr = getArray(items);
     const j = arr.length - 1;
-    return j in arr ? arr[j] : null;
+    if (j in arr)
+        return arr[j];
 }
 /** Get the last item from an array or iterable. */
 export function getLastItem(items) {
     const item = getOptionalLastItem(items);
-    if (item === null)
+    if (item === undefined)
         throw new RequiredError("Last item is required");
     return item;
 }
 /** Get the next item in an array or iterable. */
-export function getNextItem(items, value) {
+export function getOptionalNextItem(items, value) {
     const arr = getArray(items);
     const i = arr.indexOf(value);
     if (i >= 0) {
@@ -75,10 +76,9 @@ export function getNextItem(items, value) {
         if (j in arr)
             return arr[j];
     }
-    return null;
 }
 /** Get the previous item in an array or iterable. */
-export function getPrevItem(items, value) {
+export function getOptionalPrevItem(items, value) {
     const arr = getArray(items);
     const i = arr.indexOf(value);
     if (i >= 1) {
@@ -86,7 +86,6 @@ export function getPrevItem(items, value) {
         if (j in arr)
             return arr[j];
     }
-    return null;
 }
 /** Return a shuffled version of an array or iterable. */
 export function shuffleArray(input) {

package/util/async.d.ts

@@ -1,5 +1,4 @@
 import type { Dispatch, Handler } from "./function.js";
-import { SIGNAL } from "./constants.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
 export declare const isAsync: <T>(value: T | PromiseLike<T>) => value is PromiseLike<T>;
 /** Is a value a synchronous value. */
@@ -22,28 +21,21 @@ export declare function runMicrotasks(): Promise<void>;
 export declare abstract class AbstractPromise<T> extends Promise<T> {
     static get [Symbol.species](): PromiseConstructor;
     /** Resolve this promise with a value. */
-    protected readonly _resolve: Dispatch<[T]>;
+    protected readonly _resolve: Dispatch<T>;
     /** Reject this promise with a reason. */
     protected readonly _reject: Handler;
     constructor();
 }
-/** Type of `Promise` with its `resolve()` and `reject()` methods exposed publicly. */
-export declare class Deferred<T = void> extends Promise<T> {
-    static get [Symbol.species](): PromiseConstructor;
-    /** Resolve this deferred with a value. */
-    readonly resolve: Dispatch<[T]>;
-    /** Reject this deferred with a reason. */
-    readonly reject: Handler;
-    constructor();
-}
-/** Promise that resolves after a specified delay in milliseconds. */
-export declare class Delay extends AbstractPromise<void> {
-    constructor(ms: number);
-}
-/** Resolve to `SIGNAL` on a specific signal. */
-export declare class Signal extends AbstractPromise<typeof Signal.SIGNAL> {
-    /** The `SIGNAL` symbol indicates a signal. */
-    static SIGNAL: typeof SIGNAL;
-    /** Send this signal now. */
-    readonly send: () => void;
-}
+/** Deferred allows you to access the internal resolve/reject callbacks of a `Promise` */
+export type Deferred<T> = {
+    promise: Promise<T>;
+    resolve: Dispatch<T>;
+    reject: Handler;
+};
+/**
+ * Get a deferred to access the `resolve()` and `reject()` functions of a promise.
+ * - See https://github.com/tc39/proposal-promise-with-resolvers/
+ */
+export declare function getDeferred<T = unknown>(): Deferred<T>;
+/** Get a promise that automatically resolves after a delay. */
+export declare function getDelay(ms: number): Promise<void>;

package/util/async.js

@@ -1,5 +1,4 @@
 import { AssertionError } from "../error/AssertionError.js";
-import { SIGNAL } from "./constants.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
 export const isAsync = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
 /** Is a value a synchronous value. */
@@ -52,39 +51,23 @@ export class AbstractPromise extends Promise {
         this._reject = _reject; // eslint-disable-line @typescript-eslint/no-non-null-assertion
     }
 }
-/** Type of `Promise` with its `resolve()` and `reject()` methods exposed publicly. */
-export class Deferred extends Promise {
-    // Make `this.then()` create a `Promise` not a `Deferred`
-    // Done with a getter because some implementations implement this with a getter and we need to override it.
-    static get [Symbol.species]() {
-        return Promise;
-    }
-    constructor() {
-        let resolve;
-        let reject;
-        super((x, y) => {
+/**
+ * Get a deferred to access the `resolve()` and `reject()` functions of a promise.
+ * - See https://github.com/tc39/proposal-promise-with-resolvers/
+ */
+export function getDeferred() {
+    let resolve;
+    let reject;
+    return {
+        promise: new Promise((x, y) => {
             resolve = x;
             reject = y;
-        });
-        this.resolve = resolve; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-        this.reject = reject; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-    }
+        }),
+        resolve: resolve,
+        reject: reject, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    };
 }
-/** Promise that resolves after a specified delay in milliseconds. */
-export class Delay extends AbstractPromise {
-    constructor(ms) {
-        super();
-        setTimeout(this._resolve, ms);
-    }
-}
-/** Resolve to `SIGNAL` on a specific signal. */
-class Signal extends AbstractPromise {
-    constructor() {
-        super(...arguments);
-        /** Send this signal now. */
-        this.send = () => this._resolve(Signal.SIGNAL);
-    }
+/** Get a promise that automatically resolves after a delay. */
+export function getDelay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
 }
-/** The `SIGNAL` symbol indicates a signal. */
-Signal.SIGNAL = SIGNAL;
-export { Signal };

package/util/constants.d.ts

@@ -30,5 +30,7 @@ export declare const NBSP = "\u00A0";
 export declare const THINSP = "\u2009";
 /** Non-breaking narrow space (goes between numbers and their corresponding units). */
 export declare const NNBSP = "\u202F";
-/** The `SIGNAL` symbol indicates a signal. */
-export declare const SIGNAL: unique symbol;
+/** The `STOP` symbol indicates something should stop. */
+export declare const STOP: unique symbol;
+/** The `NONE` symbol indicates something is nothing. */
+export declare const NONE: unique symbol;

package/util/constants.js

@@ -30,5 +30,7 @@ export const NBSP = "\xA0";
 export const THINSP = "\u2009";
 /** Non-breaking narrow space (goes between numbers and their corresponding units). */
 export const NNBSP = "\u202F";
-/** The `SIGNAL` symbol indicates a signal. */
-export const SIGNAL = Symbol("shelving/SIGNAL");
+/** The `STOP` symbol indicates something should stop. */
+export const STOP = Symbol("shelving/STOP");
+/** The `NONE` symbol indicates something is nothing. */
+export const NONE = Symbol("shelving/NONE");

package/util/data.d.ts

@@ -13,8 +13,6 @@ export type DataValue<T extends Data> = T[keyof T & string];
 export type DataProp<T extends Data> = {
     readonly [K in DataKey<T>]: readonly [K, T[K]];
 }[DataKey<T>];
-/** Data or `null` to indicate the data doesn't exist. */
-export type OptionalData<T extends Data> = T | null;
 /** Set of named data objects. */
 export type Datas = {
     readonly [K in string]: Data;

package/util/function.d.ts

@@ -13,20 +13,18 @@ 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 type Dispatch<T extends Arguments = []> = (...value: T) => void;
+export type Dispatch<T = void> = (value: T) => void;
 /** Function that receives a dispatched value. */
-export type AsyncDispatch<T extends Arguments = []> = (...value: T) => void | PromiseLike<void>;
+export type AsyncDispatch<T = void> = (value: T) => void | PromiseLike<void>;
 /** Safely dispatch a value to a dispatcher function. */
-export declare function dispatch<A extends Arguments>(func: AsyncDispatch<A>, ...value: A): void;
+export declare function dispatch(func: () => void | PromiseLike<void>): void;
+export declare function dispatch<T>(func: (value: T) => void | PromiseLike<void>, value: T): void;
+export declare function dispatch<T>(func: AsyncDispatch<T>, value: T): void;
 /** Return a function that dispatches a value to a dispatcher function. */
-export declare function dispatched<A extends Arguments>(dispatcher: AsyncDispatch<A>): Dispatch<A>;
+export declare function dispatched<T>(dispatcher: Dispatch<T>): Dispatch<T>;
 /** Safely dispatch a value to a dispatcher method on an object. */
-export declare function dispatchMethod<T extends Arguments, M extends string | symbol>(obj: {
+export declare function dispatchMethod<T, M extends string | symbol>(obj: {
     [K in M]: AsyncDispatch<T>;
-}, key: M, ...value: T): void;
-/** Function that starts something. */
-export type Start<A extends Arguments = []> = (...args: A) => Stop | void;
-/** Function that stops something. */
-export type Stop = Dispatch;
+}, key: M, value: T): void;
 /** Function that handles an error. */
 export type Handler = (reason: Error | unknown) => void;

package/util/function.js

@@ -12,10 +12,9 @@ export function assertFunction(value) {
 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(func, ...value) {
+export function dispatch(func, value) {
     try {
-        const result = func(...value);
+        const result = func(value);
         if (isAsync(result))
             result.then(undefined, logError);
     }
@@ -25,12 +24,12 @@ export function dispatch(func, ...value) {
 }
 /** Return a function that dispatches a value to a dispatcher function. */
 export function dispatched(dispatcher) {
-    return (...args) => dispatch(dispatcher, ...args);
+    return (value) => dispatch(dispatcher, value);
 }
 /** Safely dispatch a value to a dispatcher method on an object. */
-export function dispatchMethod(obj, key, ...value) {
+export function dispatchMethod(obj, key, value) {
     try {
-        const result = obj[key](...value);
+        const result = obj[key](value);
         if (isAsync(result))
             result.then(BLACKHOLE, logError);
     }

package/util/map.d.ts

@@ -38,5 +38,5 @@ export declare function setMapItems<K, T>(map: MutableMap<K, T>, items: Iterable
 export declare function removeMapItems<K, T>(map: MutableMap<K, T>, ...keys: K[]): void;
 /** Get an item in a map or throw an error if it doesn't exist. */
 export declare function getMapItem<K, T>(map: ImmutableMap<K, T>, key: K): T;
-/** Get an item in a map or `null` if it doesn't exist. */
-export declare function getOptionalMapItem<K, T>(map: ImmutableMap<K, T>, key: K): T | null;
+/** Get an item in a map or `undefined` if it doesn't exist. */
+export declare function getOptionalMapItem<K, T>(map: ImmutableMap<K, T>, key: K): T | undefined;

package/util/map.js

@@ -40,7 +40,7 @@ export function getMapItem(map, key) {
         throw new RequiredError(`Map item is required`);
     return map.get(key);
 }
-/** Get an item in a map or `null` if it doesn't exist. */
+/** Get an item in a map or `undefined` if it doesn't exist. */
 export function getOptionalMapItem(map, key) {
-    return map.has(key) ? map.get(key) : null;
+    return map.get(key);
 }

package/util/match.d.ts

@@ -6,3 +6,5 @@ export type Match<A extends Arguments = unknown[]> = (...args: A) => boolean;
 export declare function filterItems<T, A extends Arguments = []>(items: Iterable<T>, match: Match<[T, ...A]>, ...args: A): Iterable<T>;
 /** Filter an array (immutably) using a matcher. */
 export declare function filterArray<T, A extends Arguments = []>(input: ImmutableArray<T>, match: Match<[T, ...A]>, ...args: A): ImmutableArray<T>;
+/** Filter a sequence of values using a matcher. */
+export declare function filterSequence<T, A extends Arguments = []>(sequence: AsyncIterable<T>, match: Match, ...args: A): AsyncIterable<T>;

package/util/match.js

@@ -11,3 +11,9 @@ export function filterArray(input, match, ...args) {
     const output = Array.from(filterItems(input, match, ...args));
     return output.length === input.length ? input : output;
 }
+/** Filter a sequence of values using a matcher. */
+export async function* filterSequence(sequence, match, ...args) {
+    for await (const item of sequence)
+        if (match(item, ...args))
+            yield item;
+}

package/util/null.d.ts

@@ -13,9 +13,9 @@ export declare function assertNotNull<T>(value: Nullable<T>): asserts value is T
 /** Get the not-nullish version of value. */
 export declare function getNotNull<T>(value: Nullable<T>): T;
 /** Nullish is the value or `null` or `undefined` */
-export type Nullish<T> = T | null | undefined;
+export type Nullish<T> = T | null | undefined | void;
 /** Is a value nullish? */
-export declare const isNullish: <T>(value: Nullish<T>) => value is null | undefined;
+export declare const isNullish: <T>(value: Nullish<T>) => value is void | null | undefined;
 /** Assert that a value is not nullish. */
 export declare function assertNullish<T>(value: Nullish<T>): asserts value is T;
 /** Is a value not nullish? */

package/util/random.d.ts

@@ -1,6 +1,8 @@
 import type { ImmutableArray } from "./array.js";
 /** Generate a random integer between two numbers. */
-export declare const getRandom: (min: number, max: number) => number;
+export declare const getRandom: (min?: number, max?: number) => number;
+/** Get a random number that is anything except an existing number. */
+export declare function getRandomExcept(existing: number, min?: number, max?: number): number;
 /**
  * Make a random key, e.g. `xs23r34hhsdx` or `e4m29klrugef`
  * - Not designed to be cryptographically random!

package/util/random.js

@@ -1,6 +1,14 @@
 import { getDefined } from "./undefined.js";
 /** Generate a random integer between two numbers. */
-export const getRandom = (min, max) => Math.round(Math.random() * (max - min) + min);
+export const getRandom = (min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) => Math.round(Math.random() * (max - min) + min);
+/** Get a random number that is anything except an existing number. */
+export function getRandomExcept(existing, min, max) {
+    let num;
+    do
+        num = getRandom(min, max);
+    while (num === existing);
+    return num;
+}
 /**
  * Make a random key, e.g. `xs23r34hhsdx` or `e4m29klrugef`
  * - Not designed to be cryptographically random!

package/util/sequence.d.ts

@@ -1,5 +1,6 @@
-import type { AsyncDispatch, Dispatch, Handler, Stop } from "./function.js";
-import { SIGNAL } from "./constants.js";
+import type { Stop } from "./activity.js";
+import type { AsyncDispatch, Dispatch, Handler } from "./function.js";
+import { STOP } from "./constants.js";
 /**
  * Is a value an async iterable object?
  * - Any object with a `Symbol.iterator` property is iterable.
@@ -7,12 +8,12 @@ import { SIGNAL } from "./constants.js";
  */
 export declare const isAsyncIterable: <T extends AsyncIterable<unknown>>(value: unknown) => value is T;
 /** Infinite sequence that yields until a `SIGNAL` is received. */
-export declare function repeatUntil<T>(source: AsyncIterable<T>, ...signals: [Promise<typeof SIGNAL>, ...Promise<typeof SIGNAL>[]]): AsyncIterable<T>;
+export declare function repeatUntil<T>(source: AsyncIterable<T>, ...signals: [Promise<typeof STOP>, ...Promise<typeof STOP>[]]): AsyncIterable<T>;
 /** Infinite sequence that yields every X milliseconds (yields a count of the number of iterations). */
 export declare function repeatDelay(ms: number): AsyncIterable<number>;
 /** Dispatch items in a sequence to a (possibly async) callback. */
-export declare function dispatchSequence<T>(sequence: AsyncIterable<T>, onNext: AsyncDispatch<[T]>): AsyncIterable<T>;
+export declare function dispatchSequence<T>(sequence: AsyncIterable<T>, onNext: AsyncDispatch<T>): AsyncIterable<T>;
 /** Get the first value from an async iterator. **/
 export declare function getNextValue<T>(sequence: AsyncIterable<T>): Promise<T>;
 /** Pull values from a sequence until the returned function is called. */
-export declare function runSequence<T>(sequence: AsyncIterable<T>, onNext?: Dispatch<[T]>, onError?: Handler): Stop;
+export declare function runSequence<T>(sequence: AsyncIterable<T>, onNext?: Dispatch<T>, onError?: Handler): Stop;

package/util/sequence.js

@@ -1,6 +1,6 @@
 import { RequiredError } from "../error/RequiredError.js";
-import { Delay, Signal } from "./async.js";
-import { SIGNAL } from "./constants.js";
+import { getDeferred, getDelay } from "./async.js";
+import { STOP } from "./constants.js";
 import { logError } from "./error.js";
 import { dispatch } from "./function.js";
 /**
@@ -15,9 +15,9 @@ export async function* repeatUntil(source, ...signals) {
     const iterator = source[Symbol.asyncIterator]();
     while (true) {
         const result = await Promise.race([iterator.next(), ...signals]);
-        if (result === SIGNAL) {
+        if (result === STOP) {
             await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator)); // Make sure we call `return()` on the iterator because it might do cleanup.
-            return SIGNAL;
+            return STOP;
         }
         else if (result.done) {
             return result.value;
@@ -31,7 +31,7 @@ export async function* repeatUntil(source, ...signals) {
 export async function* repeatDelay(ms) {
     let count = 1;
     while (true) {
-        await new Delay(ms);
+        await getDelay(ms);
         yield count++;
     }
 }
@@ -44,21 +44,21 @@ export async function* dispatchSequence(sequence, onNext) {
 }
 /** Get the first value from an async iterator. **/
 export async function getNextValue(sequence) {
-    for await (const value of sequence)
-        return value;
+    for await (const item of sequence)
+        return item;
     throw new RequiredError("First value is required");
 }
 /** Pull values from a sequence until the returned function is called. */
 export function runSequence(sequence, onNext, onError = logError) {
-    const stop = new Signal();
-    _runSequence(sequence[Symbol.asyncIterator](), stop, onNext, onError).catch(onError).catch(logError);
-    return stop.send;
+    const { promise, resolve } = getDeferred();
+    _runSequence(sequence[Symbol.asyncIterator](), promise, onNext, onError).catch(onError).catch(logError);
+    return () => resolve(STOP);
 }
-async function _runSequence(iterator, stop, onNext, onError) {
+async function _runSequence(iterator, stopped, onNext, onError) {
     var _a;
     try {
-        const result = await Promise.race([stop, iterator.next()]);
-        if (result === Signal.SIGNAL || result.done) {
+        const result = await Promise.race([stopped, iterator.next()]);
+        if (result === STOP || result.done) {
             // Stop iteration because the stop signal was sent or the iterator is done.
             return (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator); // Make sure we call `return()` on the iterator because it might do cleanup.
         }
@@ -72,5 +72,5 @@ async function _runSequence(iterator, stop, onNext, onError) {
         onError(thrown);
     }
     // Continue iteration.
-    return _runSequence(iterator, stop, onNext, onError);
+    return _runSequence(iterator, stopped, onNext, onError);
 }