shelving 1.96.2 → 1.98.0

package/provider/MemoryProvider.d.ts

@@ -13,14 +13,14 @@ export declare class MemoryProvider implements Provider {
     private _tables;
     /** Get a table for a collection. */
     getTable(collection: string): MemoryTable;
-    getDocumentTime(collection: string, id: string): number | null;
+    getItemTime(collection: string, id: string): number | undefined;
     getItem(collection: string, id: string): ItemValue;
     getItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
     addItem(collection: string, data: Data): string;
-    setItem(collection: string, id: string, data: Data): void;
-    updateItem(collection: string, id: string, updates: Updates): void;
-    deleteItem(collection: string, id: string): void;
-    getQueryTime(collection: string, query: ItemQuery): number | null;
+    setItem(collection: string, id: string, data: Data): boolean;
+    updateItem(collection: string, id: string, updates: Updates): boolean;
+    deleteItem(collection: string, id: string): boolean;
+    getQueryTime(collection: string, query: ItemQuery): number | undefined;
     getQuery(collection: string, query: ItemQuery): ItemArray;
     getQuerySequence(collection: string, query: ItemQuery): AsyncIterable<ItemArray>;
     setQuery(collection: string, query: ItemQuery, data: Data): number;
@@ -35,28 +35,27 @@ export declare class MemoryTable<T extends Data = Data> {
     protected readonly _times: Map<string, number>;
     /** Deferred sequence of next values. */
     readonly _changed: DeferredSequence<void, void>;
-    getItemTime(id: string): number | null;
+    getItemTime(id: string): number | undefined;
     getItem(id: string): ItemValue<T>;
     getItemSequence(id: string): AsyncIterable<ItemValue<T>>;
     /** Subscribe to a query in this table, but only if the query has been explicitly set (i.e. has a time). */
     getCachedItemSequence(id: string): AsyncIterable<ItemValue<T>>;
     addItem(data: T): string;
-    private _setItemData;
-    setItem(id: string, item: ItemData<T> | T): void;
-    setItemValue(id: string, value: ItemData<T> | T | null): void;
+    setItemData(item: ItemData<T>): boolean;
+    setItem(id: string, item: ItemData<T> | T): boolean;
+    setItemValue(id: string, value: ItemData<T> | T | undefined): boolean;
     setItemValueSequence(id: string, sequence: AsyncIterable<ItemValue<T>>): AsyncIterable<ItemValue>;
-    updateItem(id: string, updates: Updates<T>): void;
-    deleteItem(id: string): void;
-    getQueryTime(query: ItemQuery<T>): number | null;
+    updateItem(id: string, updates: Updates<T>): boolean;
+    deleteItem(id: string): boolean;
+    getQueryTime(query: ItemQuery<T>): number | undefined;
     getQuery(query: ItemQuery<T>): ItemArray<T>;
     getQuerySequence(query: ItemQuery<T>): AsyncIterable<ItemArray<T>>;
     /** Subscribe to a query in this table, but only if the query has been explicitly set (i.e. has a time). */
     getCachedQuerySequence(query: ItemQuery<T>): AsyncIterable<ItemArray<T>>;
-    private _setItems;
-    setItems(items: ItemArray<T>): void;
-    setItemsSequence(sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
-    setQueryItems(query: ItemQuery<T>, items: ItemArray<T>): void;
-    setQueryItemsSequence(query: ItemQuery<T>, sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
+    setItemArray(items: ItemArray<T>): number;
+    setItemArraySequence(sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
+    setQueryArray(query: ItemQuery<T>, items: ItemArray<T>): void;
+    setQueryArraySequence(query: ItemQuery<T>, sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
     setQuery(query: ItemQuery<T>, data: T): number;
     updateQuery(query: ItemQuery<T>, updates: Updates<T>): number;
     deleteQuery(query: ItemQuery<T>): number;

package/provider/MemoryProvider.js

@@ -2,6 +2,7 @@ import { RequiredError } from "../error/RequiredError.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 import { getArray } from "../util/array.js";
 import { isArrayEqual } from "../util/equal.js";
+import { filterSequence } from "../util/match.js";
 import { queryItems, queryWritableItems } from "../util/query.js";
 import { getRandomKey } from "../util/random.js";
 import { updateData } from "../util/update.js";
@@ -19,7 +20,7 @@ export class MemoryProvider {
     getTable(collection) {
         return this._tables[collection] || (this._tables[collection] = new MemoryTable());
     }
-    getDocumentTime(collection, id) {
+    getItemTime(collection, id) {
         return this.getTable(collection).getItemTime(id);
     }
     getItem(collection, id) {
@@ -70,57 +71,49 @@ export class MemoryTable {
         this._changed = new DeferredSequence();
     }
     getItemTime(id) {
-        return this._times.get(id) || null;
+        return this._times.get(id);
     }
     getItem(id) {
-        return this._data.get(id) || null;
+        return this._data.get(id);
     }
     async *getItemSequence(id) {
-        let last = this.getItem(id);
-        yield last;
+        let last = this._times.get(id);
+        yield this.getItem(id);
         while (true) {
             await this._changed;
-            const next = this.getItem(id);
-            if (next !== last)
-                yield (last = next);
+            const next = this._times.get(id);
+            if (next !== last) {
+                last = next;
+                yield this.getItem(id);
+            }
         }
     }
     /** Subscribe to a query in this table, but only if the query has been explicitly set (i.e. has a time). */
-    async *getCachedItemSequence(id) {
-        let last = undefined;
-        if (this._times.has(id)) {
-            last = this.getItem(id);
-            yield last;
-        }
-        while (true) {
-            await this._changed;
-            if (this._times.has(id)) {
-                const next = this.getItem(id);
-                if (next !== last)
-                    yield (last = next);
-            }
-        }
+    getCachedItemSequence(id) {
+        return filterSequence(this.getItemSequence(id), () => this._times.has(id));
     }
     addItem(data) {
         let id = getRandomKey();
         while (this._data.has(id))
             id = getRandomKey(); // Regenerate ID until unique.
-        this._data.set(id, { ...data, id });
-        this._times.set(id, Date.now());
-        this._changed.resolve();
+        this.setItemData({ ...data, id });
         return id;
     }
-    _setItemData(item, now = Date.now()) {
+    setItemData(item) {
         const id = item.id;
-        this._data.set(id, item);
-        this._times.set(id, now);
+        if (this._data.get(id) !== item) {
+            this._data.set(id, item);
+            this._times.set(id, Date.now());
+            this._changed.resolve();
+            return true;
+        }
+        return false;
     }
     setItem(id, item) {
-        this._setItemData(item.id === id ? item : { ...item, id });
-        this._changed.resolve();
+        return this.setItemData(item.id === id ? item : { ...item, id });
     }
     setItemValue(id, value) {
-        return value === null ? this.deleteItem(id) : this.setItem(id, value);
+        return value ? this.setItem(id, value) : this.deleteItem(id);
     }
     async *setItemValueSequence(id, sequence) {
         for await (const value of sequence) {
@@ -132,22 +125,19 @@ export class MemoryTable {
         const oldItem = this._data.get(id);
         if (!oldItem)
             throw new RequiredError(`Document "${id}" does not exist`);
-        const newItem = updateData(oldItem, updates);
-        if (oldItem !== newItem) {
-            this._data.set(id, newItem);
-            this._times.set(id, Date.now());
-            this._changed.resolve();
-        }
+        return this.setItemData(updateData(oldItem, updates));
     }
     deleteItem(id) {
         if (this._data.has(id)) {
             this._data.delete(id);
             this._times.set(id, Date.now());
             this._changed.resolve();
+            return true;
         }
+        return false;
     }
     getQueryTime(query) {
-        return this._times.get(_getQueryKey(query)) || null;
+        return this._times.get(_getQueryKey(query)) || undefined;
     }
     getQuery(query) {
         return getArray(queryItems(this._data.values(), query));
@@ -163,99 +153,70 @@ export class MemoryTable {
         }
     }
     /** Subscribe to a query in this table, but only if the query has been explicitly set (i.e. has a time). */
-    async *getCachedQuerySequence(query) {
+    getCachedQuerySequence(query) {
         const key = _getQueryKey(query);
-        let last = undefined;
-        if (this._times.has(key)) {
-            last = this.getQuery(query);
-            yield last;
-        }
-        while (true) {
-            await this._changed;
-            if (this._times.has(key)) {
-                const next = this.getQuery(query);
-                if (!last || !isArrayEqual(last, next))
-                    yield (last = next);
-            }
-        }
+        return filterSequence(this.getQuerySequence(query), () => this._times.has(key));
     }
-    _setItems(items, now = Date.now()) {
+    setItemArray(items) {
+        let count = 0;
         for (const item of items)
-            this._setItemData(item, now);
-    }
-    setItems(items) {
-        this._setItems(items);
-        if (items.length)
-            this._changed.resolve();
+            if (this.setItemData(item))
+                count++;
+        return count;
     }
-    async *setItemsSequence(sequence) {
+    async *setItemArraySequence(sequence) {
         for await (const items of sequence) {
-            this.setItems(items);
+            this.setItemArray(items);
             yield items;
         }
     }
-    setQueryItems(query, items) {
+    setQueryArray(query, items) {
         const key = _getQueryKey(query);
-        const now = Date.now();
-        this._times.set(key, now);
-        this._setItems(items, now);
+        this._times.set(key, Date.now());
+        this.setItemArray(items);
         this._changed.resolve();
     }
-    async *setQueryItemsSequence(query, sequence) {
+    async *setQueryArraySequence(query, sequence) {
         const key = _getQueryKey(query);
         for await (const items of sequence) {
-            const now = Date.now();
-            this._times.set(key, now);
-            this._setItems(items, now);
+            this._times.set(key, Date.now());
+            this.setItemArray(items);
             this._changed.resolve();
             yield items;
         }
     }
     setQuery(query, data) {
-        const now = Date.now();
         let count = 0;
-        for (const { id } of queryWritableItems(this._data.values(), query)) {
-            this._data.set(id, { ...data, id });
-            this._times.set(id, now);
-            count++;
-        }
+        for (const { id } of queryWritableItems(this._data.values(), query))
+            if (this.setItem(id, data))
+                count++;
         if (count) {
             const key = _getQueryKey(query);
-            this._times.set(key, now);
+            this._times.set(key, Date.now());
             this._changed.resolve();
         }
         return count;
     }
     updateQuery(query, updates) {
-        const now = Date.now();
         let count = 0;
-        for (const oldItem of queryWritableItems(this._data.values(), query)) {
-            const newItem = updateData(oldItem, updates);
-            if (oldItem !== newItem) {
-                const id = oldItem.id;
-                this._data.set(id, newItem);
-                this._times.set(id, now);
+        for (const { id } of queryWritableItems(this._data.values(), query))
+            if (this.updateItem(id, updates))
                 count++;
-            }
-        }
         if (count) {
             const key = _getQueryKey(query);
-            this._times.set(key, now);
+            this._times.set(key, Date.now());
             this._changed.resolve();
         }
         return count;
     }
     deleteQuery(query) {
-        const now = Date.now();
         let count = 0;
-        for (const { id } of queryWritableItems(this._data.values(), query)) {
-            this._data.delete(id);
-            this._times.set(id, now);
-            count++;
-        }
+        for (const { id } of queryWritableItems(this._data.values(), query))
+            if (this.deleteItem(id))
+                count++;
         if (count) {
             const key = _getQueryKey(query);
-            this._times.set(key, now);
+            this._times.set(key, Date.now());
             this._changed.resolve();
         }
         return count;

package/provider/ValidationProvider.js

@@ -18,12 +18,12 @@ class BaseValidationProvider {
     async *getItemSequence(collection, id) {
         const schema = this.getSchema(collection);
         for await (const unsafeItem of this.source.getItemSequence(collection, id))
-            yield _validateItem(collection, unsafeItem, schema);
+            yield _validateItemValue(collection, unsafeItem, schema);
     }
     async *getQuerySequence(collection, constraints) {
         const schema = this.getSchema(collection);
         for await (const unsafeItems of this.source.getQuerySequence(collection, constraints))
-            yield _validateItems(collection, unsafeItems, schema);
+            yield _validateItemArray(collection, unsafeItems, schema);
     }
 }
 /** Validate a synchronous source provider (source can have any type because validation guarantees the type). */
@@ -33,7 +33,7 @@ export class ValidationProvider extends BaseValidationProvider {
         this.source = source;
     }
     getItem(collection, id) {
-        return _validateItem(collection, this.source.getItem(collection, id), this.getSchema(collection));
+        return _validateItemValue(collection, this.source.getItem(collection, id), this.getSchema(collection));
     }
     addItem(collection, data) {
         return this.source.addItem(collection, validateWithContext(data, this.getSchema(collection), VALIDATION_CONTEXT_ADD));
@@ -49,7 +49,7 @@ export class ValidationProvider extends BaseValidationProvider {
         return this.source.deleteItem(collection, id);
     }
     getQuery(collection, constraints) {
-        return _validateItems(collection, this.source.getQuery(collection, constraints), this.getSchema(collection));
+        return _validateItemArray(collection, this.source.getQuery(collection, constraints), this.getSchema(collection));
     }
     setQuery(collection, constraints, value) {
         return this.source.setQuery(collection, constraints, validate(value, this.getSchema(collection)));
@@ -69,7 +69,7 @@ export class AsyncValidationProvider extends BaseValidationProvider {
         this.source = source;
     }
     async getItem(collection, id) {
-        return _validateItem(collection, await this.source.getItem(collection, id), this.getSchema(collection));
+        return _validateItemValue(collection, await this.source.getItem(collection, id), this.getSchema(collection));
     }
     addItem(collection, data) {
         return this.source.addItem(collection, validateWithContext(data, this.getSchema(collection), VALIDATION_CONTEXT_ADD));
@@ -85,7 +85,7 @@ export class AsyncValidationProvider extends BaseValidationProvider {
         return this.source.deleteItem(collection, id);
     }
     async getQuery(collection, constraints) {
-        return _validateItems(collection, await this.source.getQuery(collection, constraints), this.getSchema(collection));
+        return _validateItemArray(collection, await this.source.getQuery(collection, constraints), this.getSchema(collection));
     }
     setQuery(collection, constraints, value) {
         return this.source.setQuery(collection, constraints, validateWithContext(value, this.getSchema(collection), VALIDATION_CONTEXT_SET));
@@ -99,9 +99,9 @@ export class AsyncValidationProvider extends BaseValidationProvider {
     }
 }
 /** Validate an entity for a document reference. */
-function _validateItem(collection, unsafeEntity, schema) {
+function _validateItemValue(collection, unsafeEntity, schema) {
     if (!unsafeEntity)
-        return null;
+        return undefined;
     try {
         return validateWithContext(unsafeEntity, schema, VALIDATION_CONTEXT_GET);
     }
@@ -112,10 +112,10 @@ function _validateItem(collection, unsafeEntity, schema) {
     }
 }
 /** Validate a set of entities for this query reference. */
-function _validateItems(collection, unsafeEntities, schema) {
-    return Array.from(_yieldValidItems(collection, unsafeEntities, schema));
+function _validateItemArray(collection, unsafeEntities, schema) {
+    return Array.from(_validateItems(collection, unsafeEntities, schema));
 }
-function* _yieldValidItems(collection, unsafeEntities, schema) {
+function* _validateItems(collection, unsafeEntities, schema) {
     let invalid = false;
     const messages = {};
     for (const unsafeEntity of unsafeEntities) {

package/react/useReduce.js

@@ -1,5 +1,5 @@
 import { useRef } from "react";
 export function useReduce(reduce, ...args) {
-    const r = useRef();
-    return (r.current = reduce(r.current, ...args));
+    const ref = useRef();
+    return (ref.current = reduce(ref.current, ...args));
 }

package/react/useState.js

@@ -1,20 +1,15 @@
 import { useEffect, useState as useReactState } from "react";
-import { dispatch } from "../util/function.js";
+import { call } from "../util/callback.js";
 import { mapArray } from "../util/transform.js";
 import { isDefined } from "../util/undefined.js";
 export function useState(...states) {
     const setValue = useReactState(undefined)[1];
-    const [error, setError] = useReactState(undefined);
     useEffect(() => {
-        const forceRerender = () => setValue({});
-        const stops = mapArray(states, _startState, forceRerender, setError);
-        return () => stops.filter(isDefined).forEach(dispatch);
+        const rerender = () => setValue({});
+        const stops = mapArray(states, _startState, rerender);
+        return () => stops.filter(isDefined).forEach(call);
     }, states);
-    if (error)
-        throw error;
     return states.length <= 1 ? states[0] : states;
 }
-/** Start a subscription to a `ReferenceState` instance. */
-function _startState(state, setValue, setError) {
-    return state === null || state === void 0 ? void 0 : state.next.to(setValue, setError);
-}
+/** Start a subscription to a `ReferenceState` instance and rerender a new value or error is issued. */
+const _startState = (state, rerender) => state === null || state === void 0 ? void 0 : state.next.to(rerender, rerender);

package/sequence/AbstractSequence.d.ts

@@ -1,6 +1,6 @@
 /** Sequence of values designed to be extended that implements the full async generator protocol. */
 export declare abstract class AbstractSequence<T, R> implements AsyncGenerator<T, R, void> {
-    readonly [Symbol.toStringTag]: string;
+    readonly [Symbol.toStringTag] = "Sequence";
     abstract next(): Promise<IteratorResult<T, R>>;
     return(returnValue: R | PromiseLike<R>): Promise<IteratorResult<T, R>>;
     throw(reason: Error | unknown): Promise<IteratorResult<T, R>>;

package/sequence/AbstractSequence.js

@@ -1,13 +1,9 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 var _a;
-import { setPrototype } from "../util/class.js";
 /** Sequence of values designed to be extended that implements the full async generator protocol. */
 export class AbstractSequence {
+    constructor() {
+        this[_a] = "Sequence";
+    }
     async return(returnValue) {
         // Default behaviour for a generator is to return `done: true` and the input value.
         return { done: true, value: await returnValue };
@@ -21,6 +17,3 @@ export class AbstractSequence {
         return this;
     }
 }
-__decorate([
-    setPrototype(Symbol.toStringTag, "Sequence")
-], AbstractSequence.prototype, _a, void 0);

package/sequence/DeferredSequence.d.ts

@@ -1,23 +1,25 @@
-import type { Dispatch, Handler, Stop } from "../util/function.js";
+import type { Deferred } from "../util/async.js";
+import type { Callback, ErrorCallback, StopCallback } from "../util/callback.js";
 import { AbstractSequence } from "./AbstractSequence.js";
 /**
- * Deferred sequence of values.
+ * Deferred sequence of values that can be async iterated and new values can be published.
  * - Implements `AsyncIterable` so values can be iterated over using `for await...of`
  * - Implements `Promise` so the next value can be awaited.
+ * - Implements `Deferred` so next values can be resolved or rejected.
  */
-export declare class DeferredSequence<T = void, R = void> extends AbstractSequence<T, R> implements Promise<T> {
+export declare class DeferredSequence<T = void, R = void> extends AbstractSequence<T, R> implements Deferred<T>, Promise<T> {
     /**
      * Next deferred to be rejected/resolved, or `undefined` if we haven't requested one yet..
      * - Only create the deferred on demand, because we don't want to reject a deferred that isn't used to or it would throw an unhandled promise error.
      */
     private _deferred;
     /** Get the next promise to be deferred/rejected. */
-    get value(): Promise<T>;
+    get promise(): Promise<T>;
     /** Resolve the current deferred in the sequence. */
-    readonly resolve: (value: T) => void;
+    readonly resolve: Callback<T>;
     private _nextValue;
     /** Reject the current deferred in the sequence. */
-    readonly reject: (reason: Error | unknown) => void;
+    readonly reject: ErrorCallback;
     private _nextReason;
     /** Fulfill the current deferred by resolving or rejecting it. */
     private readonly _fulfill;
@@ -28,7 +30,7 @@ export declare class DeferredSequence<T = void, R = void> extends AbstractSequen
     /** Resolve the current deferred from a sequence of values. */
     through(sequence: AsyncIterable<T>): AsyncIterable<T>;
     /** Pull values from a source sequence until the returned stop function is called. */
-    from(source: AsyncIterable<T>, onError?: Handler): Stop;
+    from(source: AsyncIterable<T>, onError?: ErrorCallback): StopCallback;
     /** Subscrbe to the value of the sequence with a callback until the returned stop function is called. */
-    to(onNext: Dispatch<[T]>, onError?: Handler): Stop;
+    to(onNext: Callback<T>, onError?: ErrorCallback): StopCallback;
 }

package/sequence/DeferredSequence.js

@@ -1,25 +1,26 @@
-import { Deferred } from "../util/async.js";
+import { getDeferred } from "../util/async.js";
 import { runSequence } from "../util/sequence.js";
 import { AbstractSequence } from "./AbstractSequence.js";
 /** Used when the deferred sequence has no value or reason queued. */
 const _NOVALUE = Symbol("shelving/DeferredSequence.NOVALUE");
 /**
- * Deferred sequence of values.
+ * Deferred sequence of values that can be async iterated and new values can be published.
  * - Implements `AsyncIterable` so values can be iterated over using `for await...of`
  * - Implements `Promise` so the next value can be awaited.
+ * - Implements `Deferred` so next values can be resolved or rejected.
  */
 export class DeferredSequence extends AbstractSequence {
     constructor() {
         super(...arguments);
         /** Resolve the current deferred in the sequence. */
-        this.resolve = (value) => {
+        this.resolve = value => {
             this._nextValue = value;
             this._nextReason = _NOVALUE;
             queueMicrotask(this._fulfill);
         };
         this._nextValue = _NOVALUE;
         /** Reject the current deferred in the sequence. */
-        this.reject = (reason) => {
+        this.reject = reason => {
             this._nextValue = _NOVALUE;
             this._nextReason = reason;
             queueMicrotask(this._fulfill);
@@ -40,22 +41,22 @@ export class DeferredSequence extends AbstractSequence {
         };
     }
     /** Get the next promise to be deferred/rejected. */
-    get value() {
-        return (this._deferred || (this._deferred = new Deferred()));
+    get promise() {
+        return (this._deferred || (this._deferred = getDeferred())).promise;
     }
     // Implement `AsyncIterator`
     async next() {
-        return { value: await this.value };
+        return { value: await this.promise };
     }
     // Implement `Promise`
     then(onNext, onError) {
-        return this.value.then(onNext, onError);
+        return this.promise.then(onNext, onError);
     }
     catch(onError) {
-        return this.value.catch(onError);
+        return this.promise.catch(onError);
     }
     finally(onFinally) {
-        return this.value.finally(onFinally);
+        return this.promise.finally(onFinally);
     }
     /** Resolve the current deferred from a sequence of values. */
     async *through(sequence) {

package/sequence/SwitchingDeferredSequence.d.ts

@@ -0,0 +1,8 @@
+import type { StartCallback } from "../util/callback.js";
+import { DeferredSequence } from "./DeferredSequence.js";
+/** Deferred sequence of values that switches on when it has iterators that are iterating, and off when all iterators are done. */
+export declare class SwitchingDeferredSequence<T = void, R = void> extends DeferredSequence<T, R> {
+    private readonly _switch;
+    constructor(start: StartCallback<DeferredSequence<T, R>>);
+    [Symbol.asyncIterator](): AsyncGenerator<T, R, void>;
+}

package/sequence/SwitchingDeferredSequence.js

@@ -0,0 +1,13 @@
+import { SwitchingSet } from "../util/switch.js";
+import { DeferredSequence } from "./DeferredSequence.js";
+import { SwitchingSequence } from "./SwitchingSequence.js";
+/** Deferred sequence of values that switches on when it has iterators that are iterating, and off when all iterators are done. */
+export class SwitchingDeferredSequence extends DeferredSequence {
+    constructor(start) {
+        super();
+        this._switch = new SwitchingSet(() => start(this));
+    }
+    [Symbol.asyncIterator]() {
+        return new SwitchingSequence(this, this._switch);
+    }
+}

package/sequence/SwitchingSequence.d.ts

@@ -0,0 +1,10 @@
+import type { PossibleSwitch } from "../util/switch.js";
+import { ThroughSequence } from "./ThroughSequence.js";
+/** Async generator that switches on when it has iterators that are iterating, and off when all iterators are done. */
+export declare class SwitchingSequence<T, R> extends ThroughSequence<T, R> implements ThroughSequence<T, R> {
+    private readonly _switch;
+    constructor(source: AsyncIterator<T, R>, switchable: PossibleSwitch<AsyncIterator<T, R>>);
+    next(): Promise<IteratorResult<T, R>>;
+    return(value: R | PromiseLike<R>): Promise<IteratorResult<T, R>>;
+    throw(reason: Error | unknown): Promise<IteratorResult<T, R>>;
+}

package/sequence/SwitchingSequence.js

@@ -0,0 +1,52 @@
+import { getSwitch } from "../util/switch.js";
+import { ThroughSequence } from "./ThroughSequence.js";
+/** Async generator that switches on when it has iterators that are iterating, and off when all iterators are done. */
+export class SwitchingSequence extends ThroughSequence {
+    constructor(source, switchable) {
+        super(source);
+        this._switch = getSwitch(switchable);
+    }
+    async next() {
+        this._switch.start(this); // Register this in anticipation that it'll continue iterating.
+        try {
+            const result = await super.next();
+            if (result.done)
+                this._switch.stop(this); // Deregister this.
+            else
+                this._switch.start(this); // Register this.
+            return result;
+        }
+        catch (caught) {
+            this._switch.stop(this);
+            throw caught;
+        }
+    }
+    async return(value) {
+        try {
+            const result = await super.return(value);
+            if (result.done)
+                this._switch.stop(this); // Deregister this.
+            else
+                this._switch.start(this); // Stop this.
+            return result;
+        }
+        catch (caught) {
+            this._switch.stop(this);
+            throw caught;
+        }
+    }
+    async throw(reason) {
+        try {
+            const result = await super.throw(reason);
+            if (result.done)
+                this._switch.stop(this); // Deregister this.
+            else
+                this._switch.start(this); // Start this.
+            return result;
+        }
+        catch (caught) {
+            this._switch.stop(this);
+            throw caught;
+        }
+    }
+}

package/sequence/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./AbstractSequence.js";
 export * from "./DeferredSequence.js";
 export * from "./InspectSequence.js";
-export * from "./RegisteringSequence.js";
-export * from "./LazyDeferredSequence.js";
+export * from "./SwitchingSequence.js";
+export * from "./SwitchingDeferredSequence.js";
 export * from "./ThroughSequence.js";