inertiajs-use-api 0.0.0

package/AGENTS.md

@@ -0,0 +1,63 @@
+# Agent guidance — inertiajs-use-api
+
+A React hook for calling JSON API endpoints from Inertia.js apps. Pure-ESM library, no runtime deps, two peer deps (`react`, `@inertiajs/core`).
+
+## Project layout
+
+```
+src/
+├── index.ts        # barrel exports
+├── use-api.ts      # the hook
+├── configure.ts    # global config (parseErrors, toast handlers, XSRF, baseUrl)
+├── errors.ts       # ApiError class
+└── types.ts        # public types
+tests/              # vitest + jsdom + @testing-library/react
+SKILL.md            # Anthropic Skills file — for consumers' AI agents
+```
+
+## Development
+
+```sh
+bun install
+bun run typecheck   # tsc --noEmit
+bun run test:run    # vitest run — NOT `bun test`, which uses Bun's own runner
+bun run test        # vitest watch
+bun run build       # tsc → dist/
+```
+
+## Conventions to follow when modifying
+
+- **The hook stays minimal.** Native `fetch` under the hood. Inertia's `router` is touched only for `intoProp` (`router.replaceProp`) and `reloadProps` (`router.reload`).
+- **No app-specific behavior in the hook.** Anything backend-specific (error envelope shape, toast system, auth-token plumbing) goes through `configureUseApi`.
+- **Don't import from `@inertiajs/react`.** It is not a peer dep. The library only depends on `@inertiajs/core`.
+- **Use the public `replaceProp` API.** Don't reach into Inertia internals (`setPage`, the `page` singleton, etc.). The public API is stable since Inertia v2.
+- **ESM only.** `tsconfig.json` uses `moduleResolution: Bundler`. Internal imports use `.js` suffixes so the emitted `dist/` works for both bundlers and Node ESM.
+- **Add a test for every behavior change.** Tests mock both `globalThis.fetch` and `@inertiajs/core`'s `router` via `vi.mock`.
+
+## When adding a new option
+
+If you add a new `SubmitOptions` field or `configureUseApi` key, update:
+
+1. `src/types.ts` (or `src/configure.ts` for global config)
+2. `src/use-api.ts` (or the consumer)
+3. `tests/use-api.test.tsx` — add a test that exercises it
+4. `README.md` — both the prose example and the reference table
+5. `SKILL.md` — only if the change is decision-shaping for an agent (new mode, gotcha, common mistake)
+
+## Release flow
+
+`.github/workflows/release.yml` runs on merged PRs:
+
+1. `test` job — `bun install --frozen-lockfile`, `bun run typecheck`, `bun run test:run`
+2. `release` job — `needs: test`. Uses `offload-project/release-champion` to publish to GitHub Packages.
+
+`.github/workflows/test.yml` runs the same checks plus `bun run build` on every push and PR.
+
+A failed `test` job blocks the publish.
+
+## Things to avoid
+
+- Adding runtime dependencies. The hook should stay zero-dep.
+- Re-introducing toast/error logic that lived in the original `use-api.ts` (it was app-specific). Pluggable handlers only.
+- Calling `setState` after the component unmounts. The existing `processing` reset already guards via in-flight refcounting; don't add unrelated state writes outside that pattern.
+- Making the hook async-iterable or returning observables. Out of scope.

package/README.md

@@ -0,0 +1,266 @@
+<p align="center">
+    <a href="https://packagist.org/packages/offload-project/inertiajs-use-api"><img src="https://img.shields.io/packagist/v/offload-project/inertiajs-use-api.svg?style=flat-square" alt="Latest Version on Packagist"></a>
+    <a href="https://github.com/offload-project/inertiajs-use-api/actions"><img src="https://img.shields.io/github/actions/workflow/status/offload-project/inertiajs-use-api/tests.yml?branch=main&style=flat-square" alt="GitHub Tests Action Status"></a>
+    <a href="https://packagist.org/packages/offload-project/inertiajs-use-api"><img src="https://img.shields.io/packagist/dt/offload-project/inertiajs-use-api.svg?style=flat-square" alt="Total Downloads"></a>
+</p>
+
+# inertiajs-use-api
+
+A React hook for calling JSON API endpoints from [Inertia.js](https://inertiajs.com) apps. Like Inertia's `useForm`, but for plain JSON routes — with optional piping of responses back into Inertia page props.
+
+```ts
+const api = useApi<{ name: string }, User[]>({ name: "" });
+
+// Pipe the response straight into page.props.users (client-side, no roundtrip):
+await api.get("/api/users", { intoProp: "users" });
+
+// Or trigger a partial reload from the server:
+await api.post("/users", { reloadProps: ["users", "stats"] });
+```
+
+## Why
+
+Inertia's built-in `router` and `useForm` are great for navigating between Inertia pages, but they expect Inertia responses. For plain JSON API routes (`/api/*`), you typically drop down to `fetch` and lose the ergonomics — processing flag, field errors, abort, lifecycle callbacks, etc.
+
+`useApi` gives you that ergonomics back, and lets you pipe responses into Inertia page props when you want them to live in `usePage()` alongside server-rendered data.
+
+## Install
+
+```sh
+npm install inertiajs-use-api
+```
+
+Peer dependencies:
+
+- `@inertiajs/core@^2 || ^3`
+- `react@^18 || ^19`
+
+## Quick start
+
+```tsx
+import { useApi } from "inertiajs-use-api";
+
+type Form = { name: string; email: string };
+type User = { id: number; name: string; email: string };
+
+function CreateUserForm() {
+  const api = useApi<Form, User>({ name: "", email: "" });
+
+  const submit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    try {
+      const user = await api.post("/api/users", {
+        successToast: "User created",
+        reloadProps: ["users"],
+      });
+      // user is the typed response body
+    } catch {
+      // ApiError thrown — api.errors is populated
+    }
+  };
+
+  return (
+    <form onSubmit={submit}>
+      <input
+        value={api.data.name}
+        onChange={(e) => api.setData("name", e.target.value)}
+      />
+      {api.errors.name && <span>{api.errors.name}</span>}
+      <button disabled={api.processing}>Create</button>
+    </form>
+  );
+}
+```
+
+## Inertia prop integration
+
+### `intoProp` — write the response into `page.props` client-side
+
+Uses `router.replaceProp` under the hood (no server roundtrip). The data flows straight into `usePage().props`.
+
+```tsx
+import { useApi } from "inertiajs-use-api";
+import { usePage } from "@inertiajs/react";
+
+function UserList() {
+  const api = useApi<{}, User[]>({});
+
+  useEffect(() => {
+    api.get("/api/users", { intoProp: "users" });
+  }, []);
+
+  const { users } = usePage<{ users: User[] }>().props;
+  return <ul>{users?.map((u) => <li key={u.id}>{u.name}</li>)}</ul>;
+}
+```
+
+You can also map a single response into multiple props:
+
+```tsx
+await api.get("/api/dashboard", {
+  intoProp: (res) => ({ users: res.users, stats: res.stats }),
+});
+```
+
+### `reloadProps` — refresh props from the server
+
+Uses `router.reload({ only })`. The server is the source of truth.
+
+```tsx
+await api.post("/api/users", { reloadProps: ["users", "stats"] });
+```
+
+Pass extra options via `reloadOptions` (anything Inertia's `ReloadOptions` accepts, except `only`):
+
+```tsx
+await api.post("/api/users", {
+  reloadProps: "users",
+  reloadOptions: { preserveScroll: true },
+});
+```
+
+### Choosing between them
+
+| Use `intoProp` when…                                         | Use `reloadProps` when…                                 |
+|--------------------------------------------------------------|---------------------------------------------------------|
+| The API endpoint already returns the data you want in props. | The server computes the props (auth filters, scoping…). |
+| You want to avoid an extra HTTP request.                     | You want server-side validation of what the user sees.  |
+| You're piping into client-only state.                        | You want Inertia's normal partial-reload semantics.     |
+
+## Configuration
+
+Configure the library once at app boot — the hook reads from a global config so calls stay terse.
+
+```ts
+// app.tsx
+import { configureUseApi } from "inertiajs-use-api";
+
+configureUseApi({
+  // Optional base URL for relative paths
+  baseUrl: "/",
+
+  // Parse your backend's error envelope into a flat { field: message } map
+  parseErrors: (body) => {
+    const errs = (body as { errors?: Record<string, string[] | string> }).errors ?? {};
+    const flat: Record<string, string> = {};
+    for (const [k, v] of Object.entries(errs)) {
+      flat[k] = Array.isArray(v) ? v[0]! : String(v);
+    }
+    return flat;
+  },
+
+  // Extract a human-readable message (used as the default error toast text)
+  parseMessage: (body) => (body as { message?: string }).message ?? null,
+
+  // Wire your toast/notification system
+  onSuccessToast: (toast) => fireToast({ type: "success", message: toast as string }),
+  onErrorToast: (toast) => fireToast({ type: "error", message: toast as string }),
+
+  // Optional: inspect every response body (e.g. to extract a server-side toast envelope)
+  onResponse: (body, status, ok) => {
+    const alerts = (body as { toastAlerts?: ToastMessage[] })?.toastAlerts;
+    if (alerts?.length) fireToasts(alerts);
+  },
+});
+```
+
+### Config reference
+
+| Option           | Type                                       | Default                   |
+|------------------|--------------------------------------------|---------------------------|
+| `baseUrl`        | `string`                                   | `undefined`               |
+| `defaultHeaders` | `Record<string, string>`                   | `undefined`               |
+| `getXsrfToken`   | `() => string \| null`                     | reads `XSRF-TOKEN` cookie |
+| `xsrfHeaderName` | `string`                                   | `"X-XSRF-TOKEN"`          |
+| `parseErrors`    | `(body, status) => Record<string, string>` | returns `{}`              |
+| `parseMessage`   | `(body, status) => string \| null`         | returns `null`            |
+| `onSuccessToast` | `(toast: unknown) => void`                 | no-op                     |
+| `onErrorToast`   | `(toast: unknown) => void`                 | no-op                     |
+| `onResponse`     | `(body, status, ok) => void`               | no-op                     |
+
+## API
+
+### `useApi<TForm, TResponse>(initialData?)`
+
+Returns an object with:
+
+| Field                       | Type                                                       |
+|-----------------------------|------------------------------------------------------------|
+| `data`                      | `TForm`                                                    |
+| `setData`                   | `(field \| partial, value?) => void`                       |
+| `errors`                    | `Partial<Record<keyof TForm \| string, string>>`           |
+| `hasErrors`                 | `boolean`                                                  |
+| `processing`                | `boolean`                                                  |
+| `response`                  | `TResponse \| null`                                        |
+| `wasSuccessful`             | `boolean`                                                  |
+| `status`                    | `number \| null`                                           |
+| `reset`                     | `() => void`                                               |
+| `clearErrors`               | `() => void`                                               |
+| `cancel`                    | `() => void` — aborts all in-flight requests for this hook |
+| `submit`                    | `(method, url, options?) => Promise<TResponse>`            |
+| `get/post/put/patch/delete` | `(url, options?) => Promise<TResponse>`                    |
+
+### `SubmitOptions`
+
+| Option          | Type                                                               | Notes                                                                   |
+|-----------------|--------------------------------------------------------------------|-------------------------------------------------------------------------|
+| `data`          | `Partial<TForm>`                                                   | Overrides the hook's `data` body                                        |
+| `params`        | `Record<string, string \| number \| boolean \| null \| undefined>` | Query string. `null`/`undefined` values are skipped                     |
+| `headers`       | `Record<string, string>`                                           | Merged on top of defaults                                               |
+| `signal`        | `AbortSignal`                                                      | Aborting it (or calling `cancel()`) aborts the request                  |
+| `intoProp`      | `string \| (response) => Record<string, unknown>`                  | Writes into `page.props` via `router.replaceProp`                       |
+| `reloadProps`   | `string \| string[]`                                               | After success, triggers `router.reload({ only })`                       |
+| `reloadOptions` | `Omit<ReloadOptions, "only">`                                      | Extra options forwarded to `router.reload`                              |
+| `successToast`  | `unknown`                                                          | Forwarded to `onSuccessToast`                                           |
+| `errorToast`    | `unknown \| false`                                                 | Forwarded to `onErrorToast`. `false` suppresses the toast for this call |
+| `onBefore`      | `() => void`                                                       |                                                                         |
+| `onSuccess`     | `(response: TResponse) => void`                                    |                                                                         |
+| `onError`       | `(errors, raw, status) => void`                                    |                                                                         |
+| `onFinish`      | `() => void`                                                       | Always called                                                           |
+
+### `ApiError`
+
+Thrown on non-2xx responses.
+
+```ts
+import { ApiError } from "inertiajs-use-api";
+
+try {
+  await api.post("/api/users");
+} catch (e) {
+  if (e instanceof ApiError) {
+    console.log(e.status, e.message, e.body);
+  }
+}
+```
+
+## Notes
+
+- The hook uses native `fetch` and reads/writes Inertia state only when you ask it to (`intoProp`, `reloadProps`).
+- `@inertiajs/react` is **not** a peer dep — only `@inertiajs/core` is. Use whichever Inertia adapter your app uses to read updated props.
+- All in-flight requests for a given hook share `processing` and can be cancelled together via `cancel()`.
+
+## For AI agents
+
+This package ships an [Anthropic Skill](https://docs.claude.com/en/docs/agents-and-tools/skills) at the package root so coding agents (Claude Code, Claude.ai) can use the library correctly without needing to grep through source.
+
+The skill covers when to reach for `useApi` vs `useForm`, the `intoProp` vs `reloadProps` decision, the one-time `configureUseApi` wiring an app needs, and common Laravel/XSRF gotchas.
+
+**To install it for Claude Code:**
+
+```sh
+mkdir -p ~/.claude/skills/inertiajs-use-api
+cp node_modules/inertiajs-use-api/SKILL.md ~/.claude/skills/inertiajs-use-api/SKILL.md
+```
+
+Or symlink it so it stays in sync with package upgrades:
+
+```sh
+ln -s "$PWD/node_modules/inertiajs-use-api/SKILL.md" ~/.claude/skills/inertiajs-use-api/SKILL.md
+```
+
+Contributors hacking on the library itself should read [`AGENTS.md`](./AGENTS.md) — picked up automatically by Cursor, Windsurf, Cline, and similar in-repo agents.
+
+## License
+
+MIT

package/SKILL.md

@@ -0,0 +1,240 @@
+---
+name: inertiajs-use-api
+description: Use when writing or reviewing code that calls JSON API routes (typically /api/*) from an Inertia.js + React app. Triggers on the `useApi` hook from the `inertiajs-use-api` package, or when the user wants form-like state (data/errors/processing/cancel) for a non-Inertia endpoint and optionally wants to pipe the response into Inertia page props readable via `usePage()`. Covers the one-time `configureUseApi` setup, the `intoProp` vs `reloadProps` decision, and common Laravel/XSRF gotchas.
+---
+
+# inertiajs-use-api
+
+A React hook for calling JSON API endpoints from Inertia.js apps. Like Inertia's `useForm`, but for plain JSON routes.
+
+## When to reach for this
+
+- The user is in an Inertia + React project.
+- The endpoint returns JSON (not a full Inertia page) — typically `/api/*`.
+- They want `useForm`-style ergonomics: `data`, `errors`, `processing`, `cancel`, lifecycle callbacks.
+- Optionally: they want the response to land in `usePage().props` so the rest of the page reads it like any other Inertia prop.
+
+## When NOT to use it
+
+- **Endpoint returns an Inertia page** (`Inertia::render(...)` on the server): use `useForm` or `router.post/visit` from `@inertiajs/react`.
+- **Non-React adapter** (Vue, Svelte): this library is React-only.
+- **You need caching, refetching, dedup, query keys**: TanStack Query / SWR fit better. `useApi` is one-shot per call.
+
+## Quick start
+
+Three steps to a working call:
+
+**1. Install**
+
+```sh
+npm install inertiajs-use-api
+# peer deps you should already have: @inertiajs/core@^2||^3, react@^18||^19
+```
+
+**2. Wire `configureUseApi` once at app boot** (e.g. `resources/js/app.tsx`)
+
+Without this, `api.errors` will stay empty on validation failures.
+
+```ts
+import { configureUseApi } from "inertiajs-use-api";
+
+configureUseApi({
+  parseErrors: (body) => {
+    const errs = (body as { errors?: Record<string, string[] | string> }).errors ?? {};
+    const flat: Record<string, string> = {};
+    for (const [k, v] of Object.entries(errs)) {
+      flat[k] = Array.isArray(v) ? v[0]! : String(v);
+    }
+    return flat;
+  },
+  parseMessage: (body) => (body as { message?: string }).message ?? null,
+});
+```
+
+**3. Use the hook in a component**
+
+```tsx
+import { useApi } from "inertiajs-use-api";
+
+type Form = { name: string };
+type User = { id: number; name: string };
+
+function CreateUser() {
+  const api = useApi<Form, User>({ name: "" });
+
+  return (
+    <form
+      onSubmit={async (e) => {
+        e.preventDefault();
+        try {
+          const user = await api.post("/api/users");
+          // `user` is typed as User; api.response is also set
+        } catch {
+          // ApiError thrown; api.errors is populated for UI
+        }
+      }}
+    >
+      <input
+        value={api.data.name}
+        onChange={(e) => api.setData("name", e.target.value)}
+      />
+      {api.errors.name && <span>{api.errors.name}</span>}
+      <button disabled={api.processing}>Create</button>
+    </form>
+  );
+}
+```
+
+That's it — everything below is options on top of this base.
+
+## The two prop-integration modes
+
+`useApi` exposes two ways to update Inertia page props after a successful response. Pick based on where the source of truth lives:
+
+| Use `intoProp` (client-side write) when…              | Use `reloadProps` (server roundtrip) when…              |
+| ----------------------------------------------------- | ------------------------------------------------------- |
+| The API response already contains exactly the value   | The server computes the prop (auth scoping, derivation) |
+| You want zero extra HTTP                              | You want server-side authorization on what's visible    |
+| Throwaway / UI-only data                              | Persistent page state                                   |
+
+Under the hood:
+- `intoProp` → `router.replaceProp(name, () => response)` — public Inertia v2+ API, no roundtrip.
+- `reloadProps` → `router.reload({ only: [...] })` — partial reload, normal Inertia semantics.
+
+## One-time setup the user must do
+
+`useApi` reads from a global config. **By default it does not parse errors.** If field errors don't show up in `api.errors`, this is almost always why.
+
+Wire this once at app boot (usually `resources/js/app.tsx`):
+
+```ts
+import { configureUseApi } from "inertiajs-use-api";
+
+configureUseApi({
+  // Laravel-style 422 envelope; adjust for your backend
+  parseErrors: (body) => {
+    const errs = (body as { errors?: Record<string, string[] | string> }).errors ?? {};
+    const flat: Record<string, string> = {};
+    for (const [k, v] of Object.entries(errs)) {
+      flat[k] = Array.isArray(v) ? v[0]! : String(v);
+    }
+    return flat;
+  },
+  parseMessage: (body) => (body as { message?: string }).message ?? null,
+
+  // Wire to whatever toast library the app uses
+  onSuccessToast: (toast) => /* fireToast({ type: "success", message: toast as string }) */,
+  onErrorToast:   (toast) => /* fireToast({ type: "error",   message: toast as string }) */,
+});
+```
+
+Other useful config keys: `baseUrl`, `defaultHeaders`, `getXsrfToken`, `xsrfHeaderName`, `onResponse`.
+
+## The hook shape
+
+```ts
+const api = useApi<TForm, TResponse>(initialData);
+
+// State
+api.data           // TForm
+api.errors         // Partial<Record<keyof TForm | string, string>>
+api.hasErrors      // boolean
+api.processing     // boolean — true while ANY request is in flight
+api.response       // TResponse | null — last successful response body
+api.wasSuccessful  // boolean
+api.status         // number | null — HTTP status of last response
+
+// Mutations
+api.setData(field, value);            // or setData(partial)
+api.reset();                           // back to initialData, clears state
+api.clearErrors();
+api.cancel();                          // aborts all in-flight requests
+
+// Requests — return Promise<TResponse>, throw ApiError on non-2xx
+await api.get   (url, options?);
+await api.post  (url, options?);
+await api.put   (url, options?);
+await api.patch (url, options?);
+await api.delete(url, options?);
+await api.submit("post", url, options?);
+```
+
+## SubmitOptions
+
+```ts
+{
+  data?:    Partial<TForm>;            // overrides the hook's data for this call
+  params?:  Record<string, string | number | boolean | null | undefined>;
+  headers?: Record<string, string>;
+  signal?:  AbortSignal;
+
+  intoProp?:      string | ((response) => Record<string, unknown>);
+  reloadProps?:   string | string[];
+  reloadOptions?: Omit<ReloadOptions, "only">;
+
+  successToast?: unknown;              // forwarded to configured onSuccessToast
+  errorToast?:   unknown | false;      // false suppresses error toast for this call
+
+  onBefore?:  () => void;
+  onSuccess?: (response: TResponse) => void;
+  onError?:   (errors, raw, status) => void;
+  onFinish?:  () => void;              // always runs
+}
+```
+
+## Typical component example
+
+```tsx
+import { useApi } from "inertiajs-use-api";
+
+type Form = { name: string; email: string };
+type User = { id: number; name: string; email: string };
+
+function CreateUserForm() {
+  const api = useApi<Form, User>({ name: "", email: "" });
+
+  return (
+    <form
+      onSubmit={async (e) => {
+        e.preventDefault();
+        try {
+          await api.post("/api/users", {
+            successToast: "User created",
+            reloadProps: ["users"],
+          });
+        } catch {
+          // ApiError thrown — api.errors is populated; UI re-renders
+        }
+      }}
+    >
+      <input
+        value={api.data.name}
+        onChange={(e) => api.setData("name", e.target.value)}
+      />
+      {api.errors.name && <span>{api.errors.name}</span>}
+      <button disabled={api.processing}>Create</button>
+    </form>
+  );
+}
+```
+
+## Common gotchas
+
+- **Peer-dep is `@inertiajs/core@^2 || ^3`.** `router.replaceProp` was added in v2. Inertia v1 apps can't use `intoProp` (the rest of the hook still works).
+- **`@inertiajs/react` is NOT a peer dep.** The library only depends on `@inertiajs/core`. Read updated props via `usePage()` from whatever adapter the app uses.
+- **XSRF token defaults to the `XSRF-TOKEN` cookie** (Laravel convention), sent as `X-XSRF-TOKEN`. Override via `getXsrfToken` / `xsrfHeaderName` in `configureUseApi`.
+- **All in-flight requests share `processing`.** `cancel()` aborts them all.
+- **`router` is invoked only on success.** A failing request never calls `replaceProp` or `reload`.
+- **`bun test` won't run the suite** — it uses Bun's runner, not vitest. Use `bun run test` (or `npm test`).
+- **`ApiError` is thrown on non-2xx.** Wrap in try/catch only when you need to act beyond the populated `errors` (e.g. specific status handling).
+
+## Quick decision tree
+
+```
+Need to call a JSON API route from an Inertia+React component?
+├─ Just need the response in local state? → await api.get(url) → use api.response
+├─ Need it visible to other components via usePage()?
+│   ├─ Server should compute the value (auth, scoping)?       → reloadProps
+│   └─ API response IS the value, want no extra roundtrip?    → intoProp
+└─ Need both refresh + local response? → use both options together
+```

package/dist/configure.d.ts

@@ -0,0 +1,36 @@
+export interface UseApiConfig {
+    /** Prepended to relative URLs (e.g. "/api"). Absolute URLs pass through. */
+    baseUrl?: string;
+    /** Merged onto every request before per-call headers. */
+    defaultHeaders?: Record<string, string>;
+    /**
+     * Reads the CSRF token. Defaults to decoding the `XSRF-TOKEN` cookie.
+     * Return `null` for no token.
+     */
+    getXsrfToken?: () => string | null;
+    /** Header name for the CSRF token. Defaults to `X-XSRF-TOKEN`. */
+    xsrfHeaderName?: string;
+    /**
+     * Parses the response body into a flat `{ field: message }` map on a non-2xx response.
+     * If unset, no field errors are populated.
+     */
+    parseErrors?: (body: unknown, status: number) => Record<string, string>;
+    /**
+     * Extracts a human-readable error message from the body (used as the default error toast).
+     */
+    parseMessage?: (body: unknown, status: number) => string | null;
+    /** Invoked with the `successToast` value the caller passed. */
+    onSuccessToast?: (toast: unknown) => void;
+    /** Invoked with the resolved error toast value (caller's or the fallback message). */
+    onErrorToast?: (toast: unknown) => void;
+    /**
+     * Inspect every response body (after JSON parse) regardless of status.
+     * Useful for pulling out server-side toast envelopes.
+     */
+    onResponse?: (body: unknown, status: number, ok: boolean) => void;
+}
+export declare function configureUseApi(next: UseApiConfig): void;
+export declare function getUseApiConfig(): UseApiConfig;
+export declare function resetUseApiConfig(): void;
+export declare function readXsrfToken(): string | null;
+//# sourceMappingURL=configure.d.ts.map

package/dist/configure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../src/configure.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC5B,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACnC,kEAAkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxE;;OAEG;IACH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAChE,+DAA+D;IAC/D,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,sFAAsF;IACtF,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,KAAK,IAAI,CAAC;CAClE;AAID,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAExD;AAED,wBAAgB,eAAe,IAAI,YAAY,CAE9C;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAIxC;AAQD,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAE7C"}

package/dist/configure.js

@@ -0,0 +1,22 @@
+const config = {};
+export function configureUseApi(next) {
+    Object.assign(config, next);
+}
+export function getUseApiConfig() {
+    return config;
+}
+export function resetUseApiConfig() {
+    for (const key of Object.keys(config)) {
+        delete config[key];
+    }
+}
+function defaultXsrfReader() {
+    if (typeof document === "undefined")
+        return null;
+    const match = document.cookie.match(/(?:^|; )XSRF-TOKEN=([^;]*)/);
+    return match && match[1] !== undefined ? decodeURIComponent(match[1]) : null;
+}
+export function readXsrfToken() {
+    return (config.getXsrfToken ?? defaultXsrfReader)();
+}
+//# sourceMappingURL=configure.js.map

package/dist/configure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.js","sourceRoot":"","sources":["../src/configure.ts"],"names":[],"mappings":"AAgCA,MAAM,MAAM,GAAiB,EAAE,CAAC;AAEhC,MAAM,UAAU,eAAe,CAAC,IAAkB;IACjD,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,eAAe;IAC9B,OAAO,MAAM,CAAC;AACf,CAAC;AAED,MAAM,UAAU,iBAAiB;IAChC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAA2B,EAAE,CAAC;QACjE,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;IACpB,CAAC;AACF,CAAC;AAED,SAAS,iBAAiB;IACzB,IAAI,OAAO,QAAQ,KAAK,WAAW;QAAE,OAAO,IAAI,CAAC;IACjD,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAClE,OAAO,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC9E,CAAC;AAED,MAAM,UAAU,aAAa;IAC5B,OAAO,CAAC,MAAM,CAAC,YAAY,IAAI,iBAAiB,CAAC,EAAE,CAAC;AACrD,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, message: string, body: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAS,SAAQ,KAAK;aAEjB,MAAM,EAAE,MAAM;aAEd,IAAI,EAAE,OAAO;gBAFb,MAAM,EAAE,MAAM,EAC9B,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,OAAO;CAK9B"}

package/dist/errors.js

@@ -0,0 +1,9 @@
+export class ApiError extends Error {
+    constructor(status, message, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "ApiError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,QAAS,SAAQ,KAAK;IAClC,YACiB,MAAc,EAC9B,OAAe,EACC,IAAa;QAE7B,KAAK,CAAC,OAAO,CAAC,CAAC;QAJC,WAAM,GAAN,MAAM,CAAQ;QAEd,SAAI,GAAJ,IAAI,CAAS;QAG7B,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;IACxB,CAAC;CACD"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { UseApiConfig } from "./configure.js";
+export { configureUseApi, getUseApiConfig, resetUseApiConfig, } from "./configure.js";
+export { ApiError } from "./errors.js";
+export type { FieldErrors, IntoProp, Method, QueryParams, SubmitOptions, UseApi, } from "./types.js";
+export { useApi } from "./use-api.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EACN,eAAe,EACf,eAAe,EACf,iBAAiB,GACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EACX,WAAW,EACX,QAAQ,EACR,MAAM,EACN,WAAW,EACX,aAAa,EACb,MAAM,GACN,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC"}