@snail-js/api 0.1.27 → 1.0.0

package/dist/strategies/shared/state.d.ts

@@ -0,0 +1,117 @@
+import type { SnailStateAdapter, SnailStateRef } from "../../typings/adapter.js";
+/** Partial write accepted by {@link StrategyState.update}. */
+export interface StrategyStatePatch<TData> {
+    data?: TData;
+    loading?: boolean;
+    error?: unknown;
+    code?: number | string;
+    message?: string;
+}
+/** The resolved snapshot {@link StrategyState.bind} returns. */
+export interface StrategyBoundState<TData> {
+    loading: boolean;
+    data: TData | undefined;
+    error: unknown;
+    code: number | string | undefined;
+    message: string | undefined;
+}
+/**
+ * The state surface every request strategy exposes.
+ *
+ * ## Why handles and not values
+ *
+ * A strategy cannot know whether it is being read by a Vue render effect, a React
+ * render or a plain script. Handing back a `SnailStateRef` keeps the strategy
+ * framework-free: a Vue `Ref` already satisfies the interface, React goes through
+ * `bind()`, and a script may read `.value` directly.
+ *
+ * ## Why `update()` exists
+ *
+ * An optimistic update has to write the cache entry into the state *before* the
+ * server confirms it, and has to roll it back when the request fails. Without
+ * `update()` every caller would reach into the refs and bypass the adapter.
+ */
+export interface StrategyState<TData> {
+    /** `true` from the start of a send until it settles. */
+    readonly loading: SnailStateRef<boolean>;
+    /** Payload of the most recent successful send. */
+    readonly data: SnailStateRef<TData | undefined>;
+    /** Failure of the most recent send. Never set for a cancellation. */
+    readonly error: SnailStateRef<unknown>;
+    /** Business/HTTP code of the most recent send. */
+    readonly code: SnailStateRef<number | string | undefined>;
+    /** Business message of the most recent send. */
+    readonly message: SnailStateRef<string | undefined>;
+    /** Abort the in-flight request, if any. */
+    abort(): void;
+    /** Patch state directly — e.g. after an optimistic update. */
+    update(patch: StrategyStatePatch<TData>): void;
+    /** Resolved values, subscribing the current component when the adapter supports it. */
+    bind(): StrategyBoundState<TData>;
+    /** Called after a successful send. Returns an unsubscribe function. */
+    onSuccess(callback: (data: TData) => void): () => void;
+    /** Called after a failed send. Cancellations are not failures. */
+    onError(callback: (error: unknown) => void): () => void;
+    /** Called once a send settles, successfully or not. */
+    onFinish(callback: () => void): () => void;
+}
+/**
+ * Events a state controller emits.
+ *
+ * A type alias rather than an interface so it satisfies the `Record<string,
+ * unknown>` constraint `Emitter` requires — interfaces do not get implicit index
+ * signatures.
+ */
+export type StrategyStateEvents<TData> = {
+    success: TData;
+    error: unknown;
+    finish: undefined;
+};
+/** Options accepted by {@link createStrategyState}. */
+export interface StrategyStateOptions<TData> {
+    adapter?: SnailStateAdapter;
+    /** Value `data` starts at. Defaults to `undefined`. */
+    initialData?: TData;
+    /** Invoked by `state.abort()`. The hook owns what "abort" means. */
+    onAbort?: () => void;
+}
+/**
+ * The {@link StrategyState} plus the write side only the hook should use.
+ *
+ * Keeping the writers off the caller-visible object is what stops application code
+ * from poking `data` mid-flight: the handle is readable, the transitions are not.
+ */
+export interface StrategyStateController<TData> {
+    readonly adapter: SnailStateAdapter;
+    readonly state: StrategyState<TData>;
+    setLoading(value: boolean): void;
+    setData(value: TData | undefined): void;
+    setError(value: unknown): void;
+    setCode(value: number | string | undefined): void;
+    setMessage(value: string | undefined): void;
+    /** Clear the failure fields at the start of a send. `data` is left alone. */
+    resetForSend(): void;
+    /** Write `data`/`code`/`message` from a successful result and clear `error`. */
+    applySuccess(result: {
+        data: TData;
+        code?: number | string | undefined;
+        message?: string | undefined;
+    }): TData;
+    /** Write `error` — plus the code/message the error carries. */
+    applyFailure(error: unknown): void;
+    emitSuccess(data: TData): void;
+    emitError(error: unknown): void;
+    emitFinish(): void;
+    /** Release adapter resources and drop every listener. */
+    dispose(): void;
+}
+/**
+ * Build the state handles, the listeners and the writers for one hook.
+ *
+ * All five refs are created here, even for a hook that will not use them: a
+ * `useFetcher({ withState: false })` still has to answer `abort()` and
+ * `onFinish()`, and creating state lazily would hand the UI handles that appear
+ * only after the first request.
+ */
+export declare function createStrategyState<TData>(options?: StrategyStateOptions<TData>): StrategyStateController<TData>;
+//# sourceMappingURL=state.d.ts.map

package/dist/strategies/shared/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/state.ts"],"names":[],"mappings":"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"}

package/dist/strategies/shared/timing.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Sleep for `ms`, rejecting with a {@link SnailCancelledError} the moment the
+ * signal aborts.
+ *
+ * A plain `setTimeout` promise is the wrong primitive for a backoff: `abort()`
+ * during a 30 second retry delay would leave the loop asleep and the caller's
+ * promise pending long after it cancelled. The listener is `{ once: true }` and
+ * removed on either outcome so a long-lived signal cannot accumulate handlers.
+ */
+export declare function cancellableDelay(ms: number, signal?: AbortSignal): Promise<void>;
+/**
+ * Detach a Node timer from the event loop, when it has an `unref`.
+ *
+ * A polling strategy that is never stopped would otherwise keep a Node process
+ * (or a test worker) alive forever. In a browser `setTimeout` returns a number,
+ * which has no `unref` — hence the optional call rather than a feature test.
+ */
+export declare function unrefTimer(timer: unknown): void;
+/** Scheduler contract used by `useWatcher`. */
+export interface RequestScheduler {
+    /** Queue `task` for the next allowed run. The latest task always wins. */
+    schedule(task: () => void): void;
+    /** `true` while a run is still pending on a timer. */
+    readonly pending: boolean;
+    /** Drop a pending run without executing it. */
+    cancel(): void;
+}
+/** Timing options accepted by {@link createRequestScheduler}. */
+export interface SchedulerOptions {
+    /** Wait for quiet before running. Wins over `throttle` when both are set. */
+    debounce?: number;
+    /** Run at most once per window, on the leading edge. */
+    throttle?: number;
+}
+/**
+ * Collapse a burst of `schedule()` calls into at most one request.
+ *
+ * Two modes, one rule — **the most recent task wins**, because a request must be
+ * sent with the latest arguments, never with the ones captured when the burst
+ * started:
+ *
+ * - `debounce` waits for `debounce` ms of quiet. Every new call pushes the run
+ *   back, so ten keystrokes produce one request, not ten.
+ * - `throttle` runs on the leading edge and then books exactly one trailing run
+ *   per window. Without the trailing run the last change in a burst would be
+ *   silently dropped — a search box that ignores the final character.
+ *
+ * `debounce` is preferred when both are configured (see `useWatcher`): the two
+ * express contradictory intents, and picking one deterministically beats a
+ * half-debounced, half-throttled hybrid nobody can reason about.
+ */
+export declare function createRequestScheduler(options?: SchedulerOptions): RequestScheduler;
+//# sourceMappingURL=timing.d.ts.map

package/dist/strategies/shared/timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/timing.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBhF;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAE/C;AAED,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAEjC,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B,+CAA+C;IAC/C,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,iEAAiE;AACjE,MAAM,WAAW,gBAAgB;IAC/B,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,gBAAqB,GAAG,gBAAgB,CA8DvF"}

package/dist/strategies/shared/watcher.d.ts

@@ -0,0 +1,37 @@
+import type { SnailStateAdapter } from "../../typings/adapter.js";
+/**
+ * Read one entry of a `watching()` result.
+ *
+ * `docs/guide/plugin-lifecycle.md`'s adapter contract exposes no way to ask "is this a state
+ * handle?" portably: the Vue adapter has `isState`, React's has none, and the
+ * plain adapter's boxes are bare `{ value }` objects. So three cases are handled,
+ * in order of confidence:
+ *
+ * 1. `adapter.isState(value)` says yes — unwrap it (Vue).
+ * 2. the value is a plain object whose *only* own key is `value` — the exact shape
+ *    the plain and React adapters allocate — unwrap it.
+ * 3. anything else is the value itself.
+ *
+ * Case 2 is a heuristic, and it is the reason `watching: () => [{ value: 1 }]`
+ * should be written as `() => [{ value: 1 }.value]` if the object is genuine
+ * data rather than a handle. Without it, `() => [pageRef]` — the natural thing to
+ * write — would compare the ref object itself and never detect a change.
+ */
+export declare function unwrapWatchedValue(adapter: SnailStateAdapter, value: unknown): unknown;
+/**
+ * Evaluate a `watching()` function into the plain values that get compared.
+ *
+ * A watcher is user code, so a non-array return is normalised to a one-element
+ * list rather than iterated blindly — spreading a string would compare its
+ * characters, and spreading `undefined` would throw inside the hook.
+ */
+export declare function readWatchedValues(adapter: SnailStateAdapter, watching: () => readonly unknown[]): unknown[];
+/**
+ * Compare two watched snapshots with `Object.is`.
+ *
+ * `Object.is` rather than `===` so `NaN` does not look like a change on every
+ * render — a watcher over a numeric field that happens to be `NaN` would
+ * otherwise re-send forever.
+ */
+export declare function shallowEqual(a: readonly unknown[], b: readonly unknown[]): boolean;
+//# sourceMappingURL=watcher.d.ts.map

package/dist/strategies/shared/watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.d.ts","sourceRoot":"","sources":["../../../src/strategies/shared/watcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,uBAAuB,CAAC;AAE9E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAatF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,MAAM,SAAS,OAAO,EAAE,GACjC,OAAO,EAAE,CAIX;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAOlF"}

package/dist/strategies/use-auto-request.d.ts

@@ -0,0 +1,77 @@
+import type { SnailStateRef } from "../typings/adapter.js";
+import type { StrategyMethod } from "./shared/method.js";
+import type { UseRequestOptions, UseRequestResult } from "./use-request.js";
+/** Options accepted by {@link useAutoRequest}. */
+export interface UseAutoRequestOptions<TData> extends UseRequestOptions<TData> {
+    /**
+     * Poll every `pollingInterval` ms.
+     *
+     * The next tick is scheduled only **after** the previous request settles, so a
+     * backend slower than the interval produces a queue of one, not an unbounded
+     * pile of overlapping requests.
+     */
+    pollingInterval?: number;
+    /** Refresh when the window regains focus. */
+    enableFocusRefresh?: boolean;
+    /** Refresh when the browser reports the network is back. */
+    enableReconnectRefresh?: boolean;
+    /** Refresh when the tab becomes visible again. */
+    refreshOnVisible?: boolean;
+}
+/** What {@link useAutoRequest} returns. */
+export interface UseAutoRequestResult<TData, TArgs extends readonly unknown[] = readonly unknown[]> extends UseRequestResult<TData, TArgs> {
+    /** `true` between `start()` and `stop()`. */
+    readonly running: SnailStateRef<boolean>;
+    /**
+     * Arm polling and the refresh listeners.
+     *
+     * Also fires the first request immediately — waiting a whole interval before the
+     * first call would leave the view empty for no reason. Because that first request
+     * uses {@link refresh}, it carries no arguments unless a `send()` already
+     * provided some.
+     */
+    start(): void;
+    /** Disarm polling and remove every listener this hook registered. */
+    stop(): void;
+    /**
+     * Run one request now, reusing the arguments of the previous send.
+     *
+     * Before any `send()`, that means no arguments at all — a method whose `@Params`
+     * cannot be satisfied would reject, which is the same contract `immediate` has.
+     */
+    refresh(): Promise<TData>;
+    /** `stop()` plus a permanent flag: a disposed hook ignores `start()`. */
+    dispose(): void;
+}
+/**
+ * Keep a request fresh by itself: polling plus the three "the user is back"
+ * signals a dashboard actually needs.
+ *
+ * ```ts
+ * const stats = useAutoRequest(statsApi.get, {
+ *   pollingInterval: 5000,
+ *   refreshOnVisible: true
+ * });
+ * stats.start();
+ * stats.dispose();     // on unmount
+ * ```
+ *
+ * ## Lifecycle
+ *
+ * `stop()` is the single release point: it halts the polling timer **and** removes
+ * every listener, so an unmounted view cannot be kept alive by a focus handler.
+ * `start()` re-arms both. The refresh listeners are attached at creation rather
+ * than in `start()` — a hook whose only job is "refresh when the user comes back"
+ * should not need an extra call — while polling itself only runs between `start()`
+ * and `stop()`.
+ *
+ * ## Node safety
+ *
+ * `window`/`document` are looked up lazily and may be absent, so creating the hook
+ * during SSR is harmless. Every listener goes through one listener scope, which is
+ * what makes `stop()` remove exactly what was added; a listener removed with a
+ * fresh closure reference would leak silently. The polling timer is `unref`'d on
+ * Node so it never holds the process (or a test worker) open.
+ */
+export declare function useAutoRequest<TArgs extends readonly unknown[], TData>(method: StrategyMethod<TArgs, TData>, options?: UseAutoRequestOptions<TData>): UseAutoRequestResult<TData, TArgs>;
+//# sourceMappingURL=use-auto-request.d.ts.map

package/dist/strategies/use-auto-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-auto-request.d.ts","sourceRoot":"","sources":["../../src/strategies/use-auto-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEzE,kDAAkD;AAClD,MAAM,WAAW,qBAAqB,CAAC,KAAK,CAAE,SAAQ,iBAAiB,CAAC,KAAK,CAAC;IAC5E;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,6CAA6C;IAC7C,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,4DAA4D;IAC5D,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,2CAA2C;AAC3C,MAAM,WAAW,oBAAoB,CACnC,KAAK,EACL,KAAK,SAAS,SAAS,OAAO,EAAE,GAAG,SAAS,OAAO,EAAE,CACrD,SAAQ,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC;IACtC,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAEzC;;;;;;;OAOG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd,qEAAqE;IACrE,IAAI,IAAI,IAAI,CAAC;IAEb;;;;;OAKG;IACH,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;IAE1B,yEAAyE;IACzE,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,EACpE,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,EACpC,OAAO,GAAE,qBAAqB,CAAC,KAAK,CAAM,GACzC,oBAAoB,CAAC,KAAK,EAAE,KAAK,CAAC,CAkGpC"}

package/dist/strategies/use-download.d.ts

@@ -0,0 +1,103 @@
+import type { SnailStateRef, SnailStrategyCommonOptions } from "../typings/adapter.js";
+import { type TriggerDownloadResult } from "../utils/download.js";
+import { type StrategyMethod } from "./shared/method.js";
+import { type StrategyState } from "./shared/state.js";
+/**
+ * The download descriptor a server is expected to return.
+ *
+ * The shape is intentionally tiny, because the whole design rests on the server
+ * doing the work: it prepares the file out of band and answers with a short-lived
+ * URL. The client never receives the bytes.
+ */
+export interface DownloadDescriptor {
+    /** Where to fetch the file from. A relative path, an absolute URL or a `blob:` URL. */
+    url: string;
+    /** Filename to suggest. Honoured only for a same-origin URL — see `triggerDownload`. */
+    filename?: string;
+}
+/** Options accepted by {@link useDownload}. */
+export interface UseDownloadOptions<TPayload> extends SnailStrategyCommonOptions {
+    /**
+     * Read the descriptor out of the payload your endpoint returned.
+     *
+     * The default accepts a bare URL string, or an object carrying `url`,
+     * `downloadUrl` or `fileUrl` plus an optional `filename`/`name`. Supply this when
+     * your backend wraps them differently, so a naming choice never forces you to
+     * reshape the response.
+     */
+    pick?: (payload: TPayload) => DownloadDescriptor;
+    /**
+     * Trigger the browser download as soon as the URL arrives. Defaults to `true`.
+     *
+     * Turn it off to inspect the descriptor first — for instance to show a
+     * confirmation, or to hand the URL to a different download manager.
+     */
+    autoTrigger?: boolean;
+    /** Open the URL in a new tab rather than downloading it. */
+    openInNewTab?: boolean;
+    /**
+     * Filename override, taking precedence over whatever `pick` produced.
+     *
+     * Only `useDownload` can do this: a hook knows the local file's intended name,
+     * the server does not.
+     */
+    filename?: string;
+    /** Anchor container, for the old Firefox "must be in the document" behaviour. */
+    container?: HTMLElement;
+    /** `referrerpolicy` for the navigation. */
+    referrerPolicy?: string;
+}
+/** What {@link useDownload} returns. */
+export interface UseDownloadResult<TPayload> extends StrategyState<TPayload> {
+    /**
+     * Ask the server for the download URL, then hand it to the browser.
+     *
+     * Resolves once the download has been *started* — not completed. There is no
+     * completion signal, and that is deliberate: the browser's own download manager
+     * owns the transfer, which is exactly what makes a multi-gigabyte file work where
+     * a buffered `blob` would exhaust memory.
+     */
+    download(...args: readonly unknown[]): Promise<TriggerDownloadResult>;
+    /** The most recently resolved descriptor. `undefined` until the first success. */
+    readonly info: SnailStateRef<DownloadDescriptor | undefined>;
+    /** Called with the descriptor once it has been resolved AND triggered. */
+    onDownload(callback: (info: DownloadDescriptor) => void): () => void;
+}
+/**
+ * Drive a server-prepared download.
+ *
+ * ```ts
+ * @Api("/report")
+ * class ReportApi {
+ *   /** Prepares the export server-side and answers with a temp url. *\/
+ *   @Post("/export")
+ *   create(@Data() query: ReportQuery): Promise<{ url: string; filename: string }> {
+ *     return null!;
+ *   }
+ * }
+ *
+ * const { download, loading, error } = useDownload(reportApi.create);
+ * await download({ from: "2026-01-01" });
+ * ```
+ *
+ * ## Why it does not fetch the file
+ *
+ * `useDownload` awaits the request that *mints* a download URL, and only that. It
+ * never fetches the file itself. Buffering a response into a `Blob` costs the whole
+ * file in JavaScript memory — twice, once for the body and once for the object URL
+ * — with no progress and no resume. Letting the browser fetch the URL instead gives
+ * you the native download manager, streaming to disk, resume support and a download
+ * that survives navigation.
+ *
+ * ## Why this is a strategy and not a plugin
+ *
+ * A plugin is for a cross-cutting concern that applies to requests an application
+ * did not write specially: caching, interceptors, validation. A download is the
+ * opposite — one explicit user action, with its own visible state and its own
+ * failure modes, invoked from a click handler. That is the definition of a request
+ * strategy. The reusable half that is *not* about reactivity — clicking a temporary
+ * anchor — lives in `triggerDownload()`, which is exported from the package root so
+ * a non-hook caller can use it directly.
+ */
+export declare function useDownload<TArgs extends readonly unknown[], TPayload>(method: StrategyMethod<TArgs, TPayload>, options?: UseDownloadOptions<TPayload>): UseDownloadResult<TPayload>;
+//# sourceMappingURL=use-download.d.ts.map

package/dist/strategies/use-download.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-download.d.ts","sourceRoot":"","sources":["../../src/strategies/use-download.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEzE;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,uFAAuF;IACvF,GAAG,EAAE,MAAM,CAAC;IAEZ,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB,CAAC,QAAQ,CAAE,SAAQ,0BAA0B;IAC9E;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,kBAAkB,CAAC;IAEjD;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,4DAA4D;IAC5D,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,iFAAiF;IACjF,SAAS,CAAC,EAAE,WAAW,CAAC;IAExB,2CAA2C;IAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wCAAwC;AACxC,MAAM,WAAW,iBAAiB,CAAC,QAAQ,CAAE,SAAQ,aAAa,CAAC,QAAQ,CAAC;IAC1E;;;;;;;OAOG;IACH,QAAQ,CAAC,GAAG,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAEtE,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAAC;IAE7D,0EAA0E;IAC1E,UAAU,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACtE;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,WAAW,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,QAAQ,EACpE,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,EACvC,OAAO,GAAE,kBAAkB,CAAC,QAAQ,CAAM,GACzC,iBAAiB,CAAC,QAAQ,CAAC,CA4F7B"}

package/dist/strategies/use-fetcher.d.ts

@@ -0,0 +1,52 @@
+import type { SnailStrategyCommonOptions } from "../typings/adapter.js";
+import type { StrategyMethod } from "./shared/method.js";
+import type { StrategyState } from "./shared/state.js";
+/** Options accepted by {@link useFetcher}. */
+export interface UseFetcherOptions<TData> extends SnailStrategyCommonOptions {
+    /**
+     * Mirror each request into `loading`/`data`/`error`/`code`/`message`.
+     *
+     * Off by default: a fetcher is usually a *background* request — a prefetch, an
+     * SSR pass, a silent refresh — and writing to the caller's state would make a
+     * spinner appear for work nobody asked to watch. Turn it on when the fetcher is
+     * the only thing driving a visible view.
+     */
+    withState?: boolean;
+}
+/**
+ * The always-present surface of {@link useFetcher}.
+ *
+ * Returned whether or not state is enabled, because `abort()` and the lifecycle
+ * callbacks have nothing to do with rendering.
+ */
+export interface UseFetcherCore<TData, TArgs extends readonly unknown[] = readonly unknown[]> {
+    /** Run the request. Resolves with the unwrapped payload. */
+    fetch(...args: TArgs): Promise<TData>;
+    /** Abort the in-flight request, if any. */
+    abort(): void;
+    onSuccess(callback: (data: TData) => void): () => void;
+    onError(callback: (error: unknown) => void): () => void;
+    onFinish(callback: () => void): () => void;
+}
+/** {@link useFetcher} with `withState: true`. */
+export interface UseFetcherResult<TData, TArgs extends readonly unknown[] = readonly unknown[]> extends UseFetcherCore<TData, TArgs>, StrategyState<TData> {
+}
+/** Options accepted by {@link useFetcher} when state is requested. */
+export type UseFetcherStateOptions<TData> = UseFetcherOptions<TData> & {
+    withState: true;
+};
+/**
+ * Run an api method without a view.
+ *
+ * ```ts
+ * const prefetch = useFetcher(userApi.getUser);
+ * await prefetch.fetch("1");          // warms the cache, touches no state
+ * ```
+ *
+ * This is the hook for prefetching, SSR and background refresh: it deliberately
+ * has no `loading`/`data`/`error` handles unless `withState` asks for them, so
+ * calling it can never make an unrelated spinner appear.
+ */
+export declare function useFetcher<TArgs extends readonly unknown[], TData>(method: StrategyMethod<TArgs, TData>, options: UseFetcherStateOptions<TData>): UseFetcherResult<TData, TArgs>;
+export declare function useFetcher<TArgs extends readonly unknown[], TData>(method: StrategyMethod<TArgs, TData>, options?: UseFetcherOptions<TData>): UseFetcherCore<TData, TArgs>;
+//# sourceMappingURL=use-fetcher.d.ts.map

package/dist/strategies/use-fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-fetcher.d.ts","sourceRoot":"","sources":["../../src/strategies/use-fetcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAIrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,8CAA8C;AAC9C,MAAM,WAAW,iBAAiB,CAAC,KAAK,CAAE,SAAQ,0BAA0B;IAC1E;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAC7B,KAAK,EACL,KAAK,SAAS,SAAS,OAAO,EAAE,GAAG,SAAS,OAAO,EAAE;IAErD,4DAA4D;IAC5D,KAAK,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAEtC,2CAA2C;IAC3C,KAAK,IAAI,IAAI,CAAC;IAEd,SAAS,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACvD,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC5C;AAED,iDAAiD;AACjD,MAAM,WAAW,gBAAgB,CAC/B,KAAK,EACL,KAAK,SAAS,SAAS,OAAO,EAAE,GAAG,SAAS,OAAO,EAAE,CACrD,SAAQ,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,EAClC,aAAa,CAAC,KAAK,CAAC;CAAG;AAE3B,sEAAsE;AACtE,MAAM,MAAM,sBAAsB,CAAC,KAAK,IAAI,iBAAiB,CAAC,KAAK,CAAC,GAAG;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC;AAE3F;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,EAChE,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,EACpC,OAAO,EAAE,sBAAsB,CAAC,KAAK,CAAC,GACrC,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAClC,wBAAgB,UAAU,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,EAChE,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,EACpC,OAAO,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,GACjC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC"}

package/dist/strategies/use-pagination.d.ts

@@ -0,0 +1,101 @@
+import type { SnailStateRef, SnailStrategyCommonOptions } from "../typings/adapter.js";
+import type { StrategyMethod } from "./shared/method.js";
+import type { StrategyState } from "./shared/state.js";
+/**
+ * The request descriptor a paginated method receives as its single argument.
+ *
+ * ```ts
+ * @Get("/users")
+ * list(@Query() query: PageRequest): Promise<Page<User>> { return null!; }
+ * ```
+ *
+ * The hook owns paging, so it — not the caller — supplies these two values. A
+ * method that declares extra query fields (`PageRequest & { keyword: string }`)
+ * still matches, because the hook's argument is assignable to the wider shape.
+ */
+export interface PageRequest {
+    /** 1-based page number. */
+    page: number;
+    /** Items per page. */
+    pageSize: number;
+}
+/** Options accepted by {@link usePagination}. */
+export interface UsePaginationOptions<TData> extends SnailStrategyCommonOptions {
+    /** Page the hook starts on. Defaults to `1`. */
+    initialPage?: number;
+    /** Items per page the hook starts with. Defaults to `10`. */
+    initialPageSize?: number;
+    /**
+     * Read the total row count out of the payload.
+     *
+     * Defaults to `payload.total ?? payload.count ?? payload.length` — the three
+     * shapes backends actually return. Without a trustworthy total the hook falls
+     * back to "a short page is the last page", which cannot detect the final page
+     * when it happens to be exactly full.
+     */
+    total?: (payload: TData) => number;
+    /**
+     * Read the page's rows out of the payload.
+     *
+     * Defaults to the payload itself when it is an array, otherwise
+     * `payload.list ?? payload.items`.
+     */
+    list?: (payload: TData) => unknown[];
+    /**
+     * Append each page to `list` instead of replacing it.
+     *
+     * This is the infinite-scroll mode. It is off by default because the *replacing*
+     * behaviour is what a table with page controls needs, and appending silently
+     * grows the array forever.
+     */
+    append?: boolean;
+    /**
+     * Fetch the next page in the background and serve it instantly on `next()`.
+     *
+     * Costs one extra request per page, so it is off by default; useful for a
+     * "next" button a user is likely to press. A preload never touches
+     * `loading`/`data`: it is speculative work and must not flash a spinner.
+     */
+    preloadNext?: boolean;
+}
+/** What {@link usePagination} returns. */
+export interface UsePaginationResult<TData> extends StrategyState<TData> {
+    /** Current page, 1-based. */
+    readonly page: SnailStateRef<number>;
+    /** Items per page. */
+    readonly pageSize: SnailStateRef<number>;
+    /** Total row count, as read by the `total` extractor. */
+    readonly total: SnailStateRef<number>;
+    /** Rows, accumulated or replaced according to `append`. */
+    readonly list: SnailStateRef<unknown[]>;
+    /** `true` once the last page has been loaded. */
+    readonly isLastPage: SnailStateRef<boolean>;
+    /** Load the next page. A no-op at the last page. */
+    next(): Promise<TData | undefined>;
+    /** Load the previous page. A no-op at the first page. */
+    prev(): Promise<TData | undefined>;
+    /** Jump to a page, clamped into range. A no-op on the current page. */
+    goTo(page: number): Promise<TData | undefined>;
+    /** Go back to the first page and re-fetch it. */
+    reload(): Promise<TData | undefined>;
+    /** Change the page size, reset to page 1 and re-fetch. */
+    changePageSize(pageSize: number): Promise<TData | undefined>;
+}
+/**
+ * Page through one api method.
+ *
+ * ```ts
+ * const users = usePagination(userApi.list, {
+ *   total: (payload) => payload.total,
+ *   list: (payload) => payload.rows
+ * });
+ * await users.reload();
+ * await users.next();
+ * ```
+ *
+ * `next()`/`prev()` are **no-ops at the bounds and fire no request**: a user
+ * holding down the "next" button at the last page must not hammer the server, and
+ * the promise still resolves (with `undefined`) so an `await` never hangs.
+ */
+export declare function usePagination<TData>(method: StrategyMethod<[PageRequest], TData>, options?: UsePaginationOptions<TData>): UsePaginationResult<TData>;
+//# sourceMappingURL=use-pagination.d.ts.map

package/dist/strategies/use-pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pagination.d.ts","sourceRoot":"","sources":["../../src/strategies/use-pagination.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAGpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC1B,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,iDAAiD;AACjD,MAAM,WAAW,oBAAoB,CAAC,KAAK,CAAE,SAAQ,0BAA0B;IAC7E,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,6DAA6D;IAC7D,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,MAAM,CAAC;IAEnC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,OAAO,EAAE,CAAC;IAErC;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,0CAA0C;AAC1C,MAAM,WAAW,mBAAmB,CAAC,KAAK,CAAE,SAAQ,aAAa,CAAC,KAAK,CAAC;IACtE,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAErC,sBAAsB;IACtB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAEzC,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAEtC,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC;IAExC,iDAAiD;IACjD,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAE5C,oDAAoD;IACpD,IAAI,IAAI,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IAEnC,yDAAyD;IACzD,IAAI,IAAI,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IAEnC,uEAAuE;IACvE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IAE/C,iDAAiD;IACjD,MAAM,IAAI,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IAErC,0DAA0D;IAC1D,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;CAC9D;AAoBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,KAAK,EACjC,MAAM,EAAE,cAAc,CAAC,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,EAC5C,OAAO,GAAE,oBAAoB,CAAC,KAAK,CAAM,GACxC,mBAAmB,CAAC,KAAK,CAAC,CA4K5B"}

package/dist/strategies/use-request.d.ts

@@ -0,0 +1,50 @@
+import type { SnailStrategyCommonOptions } from "../typings/adapter.js";
+import type { StrategyMethod } from "./shared/method.js";
+import type { StrategyState } from "./shared/state.js";
+/** Options accepted by {@link useRequest}. */
+export interface UseRequestOptions<TData> extends SnailStrategyCommonOptions {
+    /** Value `data` starts at, before the first successful send. */
+    initialData?: TData;
+    /**
+     * Reset `data` back to `initialData` before every send.
+     *
+     * Off by default because the previous payload is usually still worth rendering
+     * while the next one is in flight (no flicker on refresh). Turn it on for a
+     * detail pane that must not show the *previous* record's data while loading the
+     * next one.
+     */
+    resetOnSend?: boolean;
+}
+/**
+ * What {@link useRequest} returns.
+ *
+ * `send` resolves with the **unwrapped payload** (`result.data`) rather than the
+ * whole `SnailResult`: the envelope's `code`/`message` are already on the state
+ * handles, and every caller that wants more can still reach the method's own
+ * `result`.
+ */
+export interface UseRequestResult<TData, TArgs extends readonly unknown[] = readonly unknown[]> extends StrategyState<TData> {
+    send(...args: TArgs): Promise<TData>;
+}
+/**
+ * Drive one api method from component state.
+ *
+ * ```ts
+ * const user = useRequest(userApi.getUser);
+ * await user.send("1");              // → payload
+ * user.data.value;                   // → the same payload
+ * ```
+ *
+ * The hook owns exactly one `SnailMethod`, built from the arguments of the first
+ * send and reused afterwards. That is what keeps the reactive handles stable
+ * across re-sends — see `shared/method.ts` for why a second instance would break
+ * the UI — while `send("2")` still overrides the arguments per call.
+ *
+ * One instance also means one request at a time: `SnailMethod` resets its context
+ * at the start of every `send()`, so a second `send()` issued while the first is
+ * still in flight would leave the first reading a context that belongs to the
+ * second. Call `abort()` first, or use `useWatcher`/`useAutoRequest`, which
+ * collapse bursts for exactly this reason.
+ */
+export declare function useRequest<TArgs extends readonly unknown[], TData>(method: StrategyMethod<TArgs, TData>, options?: UseRequestOptions<TData>): UseRequestResult<TData, TArgs>;
+//# sourceMappingURL=use-request.d.ts.map

package/dist/strategies/use-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-request.d.ts","sourceRoot":"","sources":["../../src/strategies/use-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAIrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,8CAA8C;AAC9C,MAAM,WAAW,iBAAiB,CAAC,KAAK,CAAE,SAAQ,0BAA0B;IAC1E,gEAAgE;IAChE,WAAW,CAAC,EAAE,KAAK,CAAC;IAEpB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB,CAC/B,KAAK,EACL,KAAK,SAAS,SAAS,OAAO,EAAE,GAAG,SAAS,OAAO,EAAE,CACrD,SAAQ,aAAa,CAAC,KAAK,CAAC;IAC5B,IAAI,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,EAChE,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,EACpC,OAAO,GAAE,iBAAiB,CAAC,KAAK,CAAM,GACrC,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAuDhC"}