shelving 1.188.1 → 1.188.2

package/error/ResponseError.d.ts

@@ -7,6 +7,8 @@ interface ResponseErrorOptions extends BaseErrorOptions {
 export declare class ResponseError extends Error implements BaseError {
     /** Provide additional named contextual data that is relevant to the `Error` instance. */
     readonly [key: string]: unknown;
-    constructor(message?: string, options?: ResponseErrorOptions);
+    /** HTTP status code for the response. */
+    readonly code: number;
+    constructor(message?: string, { code, ...options }?: ResponseErrorOptions);
 }
 export {};

package/error/ResponseError.js

@@ -1,8 +1,11 @@
 import { setBaseErrorOptions } from "./BaseError.js";
 /** Error thrown when a received HTTP response isn't OK. */
 export class ResponseError extends Error {
-    constructor(message, options = {}) {
+    /** HTTP status code for the response. */
+    code;
+    constructor(message, { code = 400, ...options } = {}) {
         super(message, options);
+        this.code = code;
         setBaseErrorOptions(ResponseError, this, options);
     }
 }

package/package.json

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

package/store/FetchStore.d.ts

@@ -2,7 +2,7 @@ import { type NONE } from "../util/constants.js";
 import { BooleanStore } from "./BooleanStore.js";
 import { Store } from "./Store.js";
 /** Callback for a callback fetch store. */
-export type FetchCallback<T> = () => PromiseLike<T>;
+export type FetchCallback<T> = () => T | PromiseLike<T>;
 /**
  * Store that fetches its values from a remote source.
  *
@@ -24,16 +24,17 @@ export declare class FetchStore<T> extends Store<T> {
      * - Triggered automatically when someone reads `value` or `loading`
      * - Multiple requests to `fetch()` while one is inflight will return the same promise.
      *
+     * @returns {Promise} that resolves when the fetch is done.
+     * @returns {void} if this store returned a synchronous value.
      * @throws {never} Never throws so safe to call unhandled.
      */
-    refresh(): Promise<void>;
+    refresh(): Promise<void> | void;
     /** An in-flight refresh, so we don't de-duplicate these. */
     private _inflight;
-    private _refresh;
     await(value: PromiseLike<T>): Promise<void>;
     private _awaits;
     /** Call the callback with the current payload. */
-    protected _fetch(): PromiseLike<T>;
+    protected _fetch(): T | PromiseLike<T>;
     private _callback;
     /** Invalidate this endpoint, so a new fetch is triggered next time `this.value` is called. */
     invalidate(): void;

package/store/FetchStore.js

@@ -1,4 +1,5 @@
 import { RequiredError } from "../error/RequiredError.js";
+import { isAsync } from "../util/async.js";
 import { ABORTED } from "../util/constants.js";
 import { awaitDispose } from "../util/dispose.js";
 import { BooleanStore } from "./BooleanStore.js";
@@ -45,22 +46,25 @@ export class FetchStore extends Store {
      * - Triggered automatically when someone reads `value` or `loading`
      * - Multiple requests to `fetch()` while one is inflight will return the same promise.
      *
+     * @returns {Promise} that resolves when the fetch is done.
+     * @returns {void} if this store returned a synchronous value.
      * @throws {never} Never throws so safe to call unhandled.
      */
     refresh() {
-        return (this._inflight ||= this._refresh());
-    }
-    /** An in-flight refresh, so we don't de-duplicate these. */
-    _inflight = undefined;
-    /** Kick off a refresh. */
-    async _refresh() {
+        if (this._inflight)
+            return this._inflight;
         try {
-            await this.await(this._fetch());
+            const value = this._fetch();
+            if (isAsync(value))
+                return (this._inflight = this.await(value));
+            this.value = value;
         }
-        finally {
-            this._inflight = undefined;
+        catch (thrown) {
+            this.reason = thrown;
         }
     }
+    /** An in-flight refresh, so we don't de-duplicate these. */
+    _inflight = undefined;
     // Override to start/stop `this.busy` when awaiting values, and handle aborts correctly.
     async await(value) {
         this.busy.value = true;
@@ -81,8 +85,10 @@ export class FetchStore extends Store {
         }
         finally {
             this._awaits.delete(value);
-            if (!this._awaits.size)
+            if (!this._awaits.size) {
                 this.busy.value = false;
+                this._inflight = undefined; // Clear any inflight refresh if this was the last await.
+            }
             this._controller = undefined;
         }
     }

package/store/PayloadFetchStore.d.ts

@@ -1,7 +1,7 @@
 import type { NONE } from "../util/constants.js";
 import { FetchStore } from "./FetchStore.js";
 import { Store } from "./Store.js";
-export type PayloadFetchCallback<P, R> = (payload: P) => PromiseLike<R>;
+export type PayloadFetchCallback<P, R> = (payload: P) => R | PromiseLike<R>;
 /**
  * Store that fetches its values from a remote source by sending a payload to them.
  *