shelving 1.196.0 → 1.196.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.196.0",
+	"version": "1.196.2",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",

package/schema/AddressSchema.js

@@ -5,8 +5,8 @@ import { NULLABLE } from "./NullableSchema.js";
 import { StringSchema } from "./StringSchema.js";
 export { formatAddress };
 const ADDRESS_PROPS = {
-    address1: new StringSchema({ title: "Address 1", max: 60, min: 1 }),
-    address2: new StringSchema({ title: "Address 2", max: 60, min: 0 }),
+    address1: new StringSchema({ title: "Address", max: 60, min: 1 }),
+    address2: new StringSchema({ title: undefined, max: 60, min: 0 }),
     city: new StringSchema({ title: "City", min: 1, max: 60 }),
     state: new StringSchema({ title: "State", min: 0, max: 60 }),
     postcode: new StringSchema({ title: "Postcode", min: 1, max: 12, case: "upper" }),

package/store/PayloadFetchStore.d.ts

@@ -16,6 +16,6 @@ export declare class PayloadFetchStore<P, R> extends FetchStore<R> {
      * - New payloads can be set using `this.payload.value`
      */
     readonly payload: Store<P>;
-    constructor(payload: P, value: R | typeof NONE, callback?: PayloadFetchCallback<P, R>, debounce?: number);
+    constructor(payload: P | typeof NONE, value: R | typeof NONE, callback?: PayloadFetchCallback<P, R>, debounce?: number);
     [Symbol.asyncDispose](): Promise<void>;
 }

package/store/PayloadFetchStore.js

@@ -1,4 +1,4 @@
-import { awaitAbort, getDelay } from "../util/async.js";
+import { awaitAbort, awaitRace, getDelay } from "../util/async.js";
 import { awaitDispose } from "../util/dispose.js";
 import { FetchStore } from "./FetchStore.js";
 import { Store } from "./Store.js";
@@ -20,13 +20,12 @@ export class PayloadFetchStore extends FetchStore {
     constructor(payload, value, callback, debounce = 0) {
         const payloadStore = new Store(payload);
         const fetch = callback &&
-            (debounce > 0
-                ? async (signal) => {
-                    const snap = payloadStore.value;
-                    await Promise.race([getDelay(debounce), awaitAbort(signal)]);
-                    return callback(snap, signal);
-                }
-                : (signal) => callback(payloadStore.value, signal));
+            (async (signal) => {
+                if (debounce > 0)
+                    await awaitRace(getDelay(debounce), awaitAbort(signal));
+                const value = payloadStore.loading ? await awaitRace(payloadStore.next, awaitAbort(signal)) : payloadStore.value;
+                return callback(value, signal);
+            });
         super(value, fetch);
         this.payload = payloadStore;
         void _iterate(this);

package/util/async.d.ts

@@ -1,5 +1,5 @@
 import type { ImmutableArray } from "./array.js";
-import type { ErrorCallback, ValueCallback } from "./function.js";
+import { type ErrorCallback, type ValueCallback } from "./function.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
 export declare function isAsync<T>(value: PromiseLike<T> | T): value is PromiseLike<T>;
 /** Is a value a synchronous value. */
@@ -65,8 +65,17 @@ export declare function getDelay(ms: number): Promise<void>;
 /**
  * Get a promise that rejects with the signal's reason when an `AbortSignal` fires.
  * - Rejects immediately if the signal is already aborted.
- * - Use with `Promise.race()` to cancel a concurrent operation when a signal fires.
+ * - Use with `awaitRace()` to cancel a concurrent operation when a signal fires.
  *
- * @example await Promise.race([getDelay(300), awaitAbort(signal)]);
+ * @example await awaitRace(getDelay(300), awaitAbort(signal));
  */
 export declare function awaitAbort(signal: AbortSignal): Promise<never>;
+/**
+ * Race promises like `Promise.race()` but silently swallow rejections from the losers.
+ * - Returns a promise that settles with the first input to settle, exactly like `Promise.race()`.
+ * - The losing inputs keep running (Promises cannot be cancelled), but their eventual rejection — if any — is silently absorbed instead of bubbling up as an unhandled rejection.
+ * - Built for cancellation/timeout patterns, where the loser's eventual fate is genuinely uninteresting once another arm has settled. Do not use when both arms might surface meaningful errors that the caller should see.
+ *
+ * @example await awaitRace(getDelay(300), awaitAbort(signal)); // delay or abort, no leaked ABORT rejection if delay wins
+ */
+export declare function awaitRace<T>(...promises: Promise<T>[]): Promise<T>;

package/util/async.js

@@ -1,5 +1,6 @@
 import { Errors } from "../error/Errors.js";
 import { RequiredError } from "../error/RequiredError.js";
+import { BLACKHOLE } from "./function.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
 export function isAsync(value) {
     return typeof value === "object" && value !== null && typeof value.then === "function";
@@ -113,15 +114,30 @@ export function getDelay(ms) {
 /**
  * Get a promise that rejects with the signal's reason when an `AbortSignal` fires.
  * - Rejects immediately if the signal is already aborted.
- * - Use with `Promise.race()` to cancel a concurrent operation when a signal fires.
+ * - Use with `awaitRace()` to cancel a concurrent operation when a signal fires.
  *
- * @example await Promise.race([getDelay(300), awaitAbort(signal)]);
+ * @example await awaitRace(getDelay(300), awaitAbort(signal));
  */
 export function awaitAbort(signal) {
-    return new Promise((_, reject) => {
+    const promise = new Promise((_, reject) => {
         if (signal.aborted)
             reject(signal.reason);
         else
             signal.addEventListener("abort", () => reject(signal.reason), { once: true });
     });
+    promise.catch(BLACKHOLE);
+    return promise;
+}
+/**
+ * Race promises like `Promise.race()` but silently swallow rejections from the losers.
+ * - Returns a promise that settles with the first input to settle, exactly like `Promise.race()`.
+ * - The losing inputs keep running (Promises cannot be cancelled), but their eventual rejection — if any — is silently absorbed instead of bubbling up as an unhandled rejection.
+ * - Built for cancellation/timeout patterns, where the loser's eventual fate is genuinely uninteresting once another arm has settled. Do not use when both arms might surface meaningful errors that the caller should see.
+ *
+ * @example await awaitRace(getDelay(300), awaitAbort(signal)); // delay or abort, no leaked ABORT rejection if delay wins
+ */
+export function awaitRace(...promises) {
+    for (const promise of promises)
+        promise.catch(BLACKHOLE);
+    return Promise.race(promises);
 }