shelving 1.85.0 → 1.86.0

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.85.0",
+	"version": "1.86.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -64,21 +64,21 @@
 		"build:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config=jest.config.build.cjs"
 	},
 	"devDependencies": {
-		"@google-cloud/firestore": "^5.0.2",
-		"@types/jest": "^28.1.8",
+		"@google-cloud/firestore": "^6.4.0",
+		"@types/jest": "^29.2.0",
 		"@types/react": "^18.0.21",
 		"@types/react-dom": "^18.0.4",
-		"@typescript-eslint/eslint-plugin": "^5.39.0",
-		"@typescript-eslint/parser": "^5.39.0",
+		"@typescript-eslint/eslint-plugin": "^5.40.0",
+		"@typescript-eslint/parser": "^5.40.0",
 		"dpdm": "^3.9.0",
-		"esbuild": "^0.15.10",
+		"esbuild": "^0.15.11",
 		"esbuild-jest": "^0.5.0",
 		"eslint": "^8.25.0",
 		"eslint-config-prettier": "^8.5.0",
 		"eslint-plugin-import": "^2.26.0",
 		"eslint-plugin-prettier": "^4.0.0",
-		"firebase": "^9.11.0",
-		"jest": "^28.1.0",
+		"firebase": "^9.12.1",
+		"jest": "^29.2.1",
 		"jest-ts-webcompat-resolver": "^1.0.0",
 		"prettier": "^2.6.2",
 		"react": "^18.1.0",

package/sequence/DeferredSequence.d.ts

@@ -21,12 +21,14 @@ export declare class DeferredSequence<T = void, R = void> extends AbstractSequen
     private _nextReason;
     /** Fulfill the current deferred by resolving or rejecting it. */
     private readonly _fulfill;
-    /** Resolve the current deferred from a sequence of values. */
-    resolveSequence(sequence: AsyncIterable<T>): AsyncIterable<T>;
     next(): Promise<IteratorResult<T, R>>;
     then<X = T, Y = never>(onNext?: (v: T) => X | PromiseLike<X>, onError?: (r: unknown) => Y | PromiseLike<Y>): Promise<X | Y>;
     catch<Y>(onError: (r: unknown) => Y | PromiseLike<Y>): Promise<T | Y>;
     finally(onFinally: () => void): Promise<T>;
+    /** 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;
     /** Subscrbe to the value of the sequence with a callback until the returned stop function is called. */
-    subscribe(onNext: Dispatch<[T]>, onError?: Handler): Stop;
+    to(onNext: Dispatch<[T]>, onError?: Handler): Stop;
 }

package/sequence/DeferredSequence.js

@@ -28,10 +28,10 @@ export class DeferredSequence extends AbstractSequence {
         /** Fulfill the current deferred by resolving or rejecting it. */
         this._fulfill = () => {
             const { _deferred, _nextReason, _nextValue } = this;
+            this._deferred = undefined;
+            this._nextReason = _NOVALUE;
+            this._nextValue = _NOVALUE;
             if (_deferred) {
-                this._deferred = undefined;
-                this._nextReason = _NOVALUE;
-                this._nextValue = _NOVALUE;
                 if (_nextReason !== _NOVALUE)
                     _deferred.reject(_nextReason);
                 else if (_nextValue !== _NOVALUE)
@@ -43,13 +43,6 @@ export class DeferredSequence extends AbstractSequence {
     get value() {
         return (this._deferred || (this._deferred = new Deferred()));
     }
-    /** Resolve the current deferred from a sequence of values. */
-    async *resolveSequence(sequence) {
-        for await (const item of sequence) {
-            this.resolve(item);
-            yield item;
-        }
-    }
     // Implement `AsyncIterator`
     async next() {
         return { value: await this.value };
@@ -64,8 +57,19 @@ export class DeferredSequence extends AbstractSequence {
     finally(onFinally) {
         return this.value.finally(onFinally);
     }
+    /** Resolve the current deferred from a sequence of values. */
+    async *through(sequence) {
+        for await (const item of sequence) {
+            this.resolve(item);
+            yield item;
+        }
+    }
+    /** Pull values from a source sequence until the returned stop function is called. */
+    from(source, onError) {
+        return runSequence(this.through(source), undefined, onError);
+    }
     /** Subscrbe to the value of the sequence with a callback until the returned stop function is called. */
-    subscribe(onNext, onError) {
+    to(onNext, onError) {
         return runSequence(this, onNext, onError);
     }
 }

package/state/State.d.ts

@@ -32,12 +32,12 @@ export declare class State<T> implements AsyncIterable<T> {
     /** Set the value of the state. */
     set(value: T): void;
     /** Set the value of the state as values are pulled from a sequence. */
-    setSequence(sequence: AsyncIterable<T>): AsyncIterable<T>;
+    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;
     /** Push values to another state or callback to this state until the returned stop function is called. */
-    to(target: State<T> | Dispatch<[T]>, onError?: Handler): Stop;
-    [Symbol.asyncIterator](): AsyncIterator<T, any, undefined>;
+    to(target: Dispatch<[T]>, onError?: Handler): Stop;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
 }
 /** Is an unknown value a `State` instance. */
 export declare const isState: <T extends AnyState>(v: unknown) => v is T;

package/state/State.js

@@ -45,7 +45,7 @@ export class State {
         }
     }
     /** Set the value of the state as values are pulled from a sequence. */
-    async *setSequence(sequence) {
+    async *through(sequence) {
         for await (const value of sequence) {
             this.set(value);
             yield value;
@@ -53,28 +53,19 @@ export class State {
     }
     /** Pull values from a source sequence until the returned stop function is called. */
     from(source, onError) {
-        return runSequence(this.setSequence(source), onError);
+        return runSequence(this.through(source), onError);
     }
     /** Push values to another state or callback to this state until the returned stop function is called. */
     to(target, onError) {
-        if (isState(target)) {
-            return runSequence(target.setSequence(this), onError);
-        }
-        else {
-            return runSequence(this, target, onError);
-        }
+        return runSequence(this, target, onError);
     }
     // Implement `AsyncIterable`
     // Issues the current value of the state first, then any subsequent values that are issued.
-    [Symbol.asyncIterator]() {
-        // If this is still loading yield the next value as soon as we get one.
-        if (this.loading)
-            return this.next[Symbol.asyncIterator]();
-        // If this has a current value then yield the current value immediately, then the rest of the sequence.
-        // But! If additional values are set synchronously, only the yield the final one. Use a new `DeferredSequence` to make sure this happens cleanly.
-        const deferred = new DeferredSequence();
-        deferred.resolve(this.value);
-        return deferred.resolveSequence(this.next)[Symbol.asyncIterator]();
+    async *[Symbol.asyncIterator]() {
+        await Promise.resolve(); // Introduce a slight delay, i.e. don't immediately yield `this.value` in case it is changed synchronously.
+        if (!this.loading)
+            yield this.value;
+        yield* this.next;
     }
 }
 /** The `NOVALUE` symbol indicates no value has been received by a `State` instance. */

package/util/class.d.ts

@@ -31,7 +31,7 @@ export declare function cacheGetter<T>(target: Object, key: string, { get }: Typ
  *
  * @example
  * 		class MyClass {
- * 			\@setPrototype("myProp", "myValue!") readonly myProp!: string;
+ * 			@setPrototype("myProp", "myValue!") readonly myProp!: string;
  * 		}
  */
 export declare function setPrototype<K extends PropertyKey, T>(key: K, value: T): (prototype: {

package/util/class.js

@@ -61,7 +61,7 @@ export function cacheGetter(target, key, { get }) {
  *
  * @example
  * 		class MyClass {
- * 			\@setPrototype("myProp", "myValue!") readonly myProp!: string;
+ * 			@setPrototype("myProp", "myValue!") readonly myProp!: string;
  * 		}
  */
 export function setPrototype(key, value) {