@thomasfosterau/effect-forms-svelte 0.1.0 → 0.3.1

package/README.md

@@ -1,17 +1,27 @@
 # @thomasfosterau/effect-forms-svelte
 
-Svelte 5 (runes) bindings for [`@thomasfosterau/effect-forms`](../effect-forms). A reactive form store with progressive-enhancement submission, tainted tracking, lifecycle events, and optional client-side validation against the **same Effect Schema the server uses**.
+Svelte 5 (runes) bindings for [`@thomasfosterau/effect-forms`](https://www.npmjs.com/package/@thomasfosterau/effect-forms): a reactive form store with progressive-enhancement submission, tainted tracking, lifecycle events, and optional client-side validation against the **same Effect Schema the server uses**.
 
-This package depends only on `svelte` (a peer) and the framework-neutral core — not SvelteKit — so it works in any Svelte 5 app.
+The root entry depends only on `svelte` and the framework-neutral core, not SvelteKit, so it works in any Svelte 5 app. The [`/kit` entry](#kit) (`@thomasfosterau/effect-forms-svelte/kit`) is the SvelteKit-only half: derived form actions, JSON:API error routing and `$app/forms` glue.
+
+## Install
+
+```sh
+pnpm add @thomasfosterau/effect-forms-svelte @thomasfosterau/effect-forms effect svelte
+# for the /kit entry
+pnpm add @sveltejs/kit
+```
+
+`effect` and `svelte` are required peers. `@sveltejs/kit` is an optional peer, required by `/kit`; `@thomasfosterau/effect-jsonapi` is an optional, type-only peer of `/kit`.
 
 ## Usage
 
-Server (`+page.server.ts` or any action) produces a `FormState` with the core's `makeForm`, and returns it to the page. The component hydrates it:
+Server (`+page.server.ts` or any action) produces a `FormState` with the core's `Form.make(schema, …).validate(request)`, and returns it to the page. The component hydrates it:
 
 ```svelte
 <script lang="ts">
   import { createForm } from "@thomasfosterau/effect-forms-svelte";
-  import { Signup } from "$lib/schemas";
+  import { Signup } from "#lib/schemas";
 
   let { data } = $props(); // data.form is the server FormState
 
@@ -35,24 +45,24 @@ Server (`+page.server.ts` or any action) produces a `FormState` with the core's
 
 ## The store
 
-`createForm(source, options)` returns a [`FormStore`](src/FormStore.svelte.ts). `source` is a server-produced `FormState`, a `{ schema, defaults }` seed, or a [`FormBuilder`](../effect-forms/src/FormBuilder.ts) — the builder derives its schema, blank defaults, and array-item defaults for you:
+`createForm(source, options)` returns a [`FormStore`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/FormStore.svelte.ts). `source` is a server-produced `FormState`, a `{ schema, defaults }` seed, or a [`FormBuilder`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/forms/src/FormBuilder.ts) — the builder derives its schema, blank defaults, and array-item defaults for you:
 
 ```ts
 import { createForm } from "@thomasfosterau/effect-forms-svelte";
-import { signup } from "$lib/forms"; // a FormBuilder
+import { signup } from "#lib/forms"; // a FormBuilder
 
 const form = createForm(signup, { mode: { validation: "onChange", debounce: 300 } });
 ```
 
 **Reactive state** — `data` (mutable, bind inputs to it), `errors` (merged client + server), `clientErrors` / `serverErrors` (per-source views), `message`, `constraints`, `submitting`, `delayed`, `posted`, `valid`, `canSubmit`, `isValidating`, `isSubmitted`, `isSubmitSuccessful`, `submissionAttempts`, `tainted`, `isTainted`, and (against the last submission) `changedSinceSubmit` / `hasChangedSinceSubmit`.
 
-**Methods** — `enhance(node)` (the form action), `validate()` / `validateField(path)` (client-side, needs `schema`; also runs a builder's `refineEffect` refinements), `errorsAt(path)` / `taintedAt(path)` / `isValidatingAt(path)`, `setValue(path, v)` / `valueAt(path)`, `handleBlur(path)` / `setTouched(path)` / `isTouchedAt(path)`, `isDirtyAt(path)` / `isDefaultValueAt(path)` (persistent per-field dirty tracking — see [Field handles](#field-handles)), `setFieldValidators(path, validators)` (register a field's validators dynamically), `shouldShowError(path)` / `visibleErrorsAt(path)` (mode-aware display gating), `constraintAt(path)`, `revertToLastSubmit()`, `reset()`, `capture()` / `restore()` (SvelteKit snapshots), `setServerState(data, errors)` (apply a result received some other way), `toFormData()`.
+**Methods** — `enhance(node)` (the form action), `validate()` / `validateField(path)` (client-side, needs `schema`; also runs a builder's `refineEffect` refinements, on the decoded values as the server does, once they decode), `errorsAt(path)` / `taintedAt(path)` / `isValidatingAt(path)`, `setValue(path, v)` / `valueAt(path)`, `handleBlur(path)` / `setTouched(path)` / `isTouchedAt(path)`, `isDirtyAt(path)` / `isDefaultValueAt(path)` (persistent per-field dirty tracking — see [Field handles](#field-handles)), `setFieldValidators(path, validators)` (register a field's validators dynamically), `shouldShowError(path)` / `visibleErrorsAt(path)` (mode-aware display gating), `constraintAt(path)`, `revertToLastSubmit()`, `reset()`, `capture()` / `restore()` (SvelteKit snapshots), `setServerState(data, errors)` (apply a result received some other way), `toFormData()`.
 
 **Field arrays** — `append(path, value?)`, `insertItem(path, i, value?)`, `replaceItem(path, i, value)`, `removeItem(path, i)`, `clearItems(path)`, `swap(path, a, b)`, `move(path, from, to)` mutate the array at `path` immutably. `append` / `insertItem` derive a blank item by walking the bound schema's AST at `path` (any nesting depth, e.g. `authors[0].emails`), falling back to the top-level `FormBuilder` field when no schema is bound. Every index-shifting mutation (`insertItem` / `removeItem` / `swap` / `move` / `clearItems`) remaps per-index touched flags and errors so they keep following their row — `replaceItem` drops only the replaced index's own touched flag / errors.
 
 ## Field handles
 
-`form.field(path)` (modelled on TanStack Form's `FieldApi`) returns a typed, reactive [`FieldHandle`](src/FormStore.svelte.ts) bundling everything one input needs, instead of wiring `bind:value` / `name` / `handleBlur` / `visibleErrorsAt` / `constraints` against the store separately:
+`form.field(path)` (modelled on TanStack Form's `FieldApi`) returns a typed, reactive [`FieldHandle`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/FormStore.svelte.ts) bundling everything one input needs, instead of wiring `bind:value` / `name` / `handleBlur` / `visibleErrorsAt` / `constraints` against the store separately:
 
 ```svelte
 <script lang="ts">
@@ -68,11 +78,11 @@ const form = createForm(signup, { mode: { validation: "onChange", debounce: 300
 {#each name.visibleErrors as message}<small>{message}</small>{/each}
 ```
 
-`path` is checked against the form data's shape via `Path.FieldPath<A>` — a typo'd segment (`"authr.name"`) or a path into a field that doesn't exist is a compile error, and `field.value` is the leaf's actual type, not `unknown`. This replaced the core's unconsumed `FieldRef` seam.
+`path` is checked against the form data's shape via `Path.FieldPath<A>` — a typo'd segment (`"authr.name"`) or a path into a field that doesn't exist is a compile error, and `field.value` is the leaf's actual type, not `unknown`.
 
 `field.meta` exposes TanStack-style field state: `isBlurred` (lost focus at least once), `isTouched` (`isBlurred || isDirty`), `isDirty` (changed away from the default at some point — **persistent**, unlike `taintedAt` it does not clear on reverting to the default; only `reset()` clears it), and `isDefaultValue` (current value equals the default — flips back on revert). `isDirty` only tracks writes made through `field.value = …` / `setValue` / the array mutators (`append` / `removeItem` / `swap` / `move`) — a form that still binds `bind:value={form.data.x}` directly, bypassing `field()`, never marks that field dirty.
 
-**Validation modes** — the `mode` option (see [`Mode`](../effect-forms/src/Mode.ts)) drives when the form validates: `onSubmit` (default), `onBlur` (call `handleBlur` from an input's blur), or `onChange` (debounced). `onBlur` / `onChange` may `autoSubmit`, turning the form into a live-saving surface. `revalidate` (`"onChange"` default / `"onBlur"` / `"never"`) governs what happens _after_ a failed post in `onSubmit` mode: fixing a field re-validates just that field, clearing its error without a resubmit. Errors are computed for the whole form; gate their display per field with `visibleErrorsAt(path)` (shown only once the field is tainted / touched, or after a submit).
+**Validation modes** — the `mode` option (see [`Mode`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/forms/src/Mode.ts)) drives when the form validates: `onSubmit` (default), `onBlur` (call `handleBlur` from an input's blur), or `onChange` (debounced). `onBlur` / `onChange` may `autoSubmit`, turning the form into a live-saving surface. `revalidate` (`"onChange"` default / `"onBlur"` / `"never"`) governs what happens _after_ a failed post in `onSubmit` mode: fixing a field re-validates just that field, clearing its error without a resubmit. Errors are computed for the whole form; gate their display per field with `visibleErrorsAt(path)` (shown only once the field is tainted / touched, or after a submit).
 
 **Per-field validators** — the `validators` option (or `setFieldValidators`) attaches TanStack-Form-style `{ onChange?, onBlur?, onChangeAsync?, onBlurAsync?, asyncDebounceMs? }` per field, keyed by `Path.toString` (e.g. `"author.name"`, `"tags[0]"`). Sync validators return a `Schema.FilterOutput`; async ones are `Effect`s, run as a fiber per field — a new value interrupts the field's in-flight fiber before forking the next run, which is what gives the debounce + "latest wins" cancellation (no timer bookkeeping needed). Pass `layer` when a validator (or a builder's `refineEffect` refinement) needs services on its `R` channel:
 
@@ -93,23 +103,127 @@ const form = createForm(
 
 **Error sources** — a field's server-reported error (from the last submission) survives a client-side revalidation of some _other_ field; it clears once _that_ field's own value changes (or the server clears it on the next submit). `errors` is the merged view; `clientErrors` / `serverErrors` expose the two trees separately for a UI that wants to style them differently.
 
-**Lifecycle options** — `onSubmit` (with `cancel()`), `onResult`, `onUpdate`, `onUpdated`, `onError`, `onRedirect`, plus `resetForm`, `taintedMessage`, `delayMs`, and a `submit` transport override (defaults to `fetch` to the form's action, parsing a JSON [`FormActionResult`](../effect-forms/src/Result.ts) or a bare `FormState`).
+**Lifecycle options** — `onSubmit` (with `cancel()`), `onResult`, `onUpdate`, `onUpdated`, `onError`, `onRedirect`, plus `resetForm`, `taintedMessage`, `delayMs`, and a `submit` transport override (defaults to `fetch` to the form's action, parsing a JSON [`FormActionResult`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/forms/src/Result.ts) or a bare `FormState`).
 
-## Layout
+## API
 
-The reactive store lives in `FormStore.svelte.ts` (rune-compiled, checked by `svelte-check`). Its logic is delegated to pure, unit-tested modules:
+Everything below is exported flat from the root entry (`@thomasfosterau/effect-forms-svelte`).
 
-| Module                                    | Purpose                                                                   |
-| ----------------------------------------- | ------------------------------------------------------------------------- |
-| [`Tainted`](src/Tainted.ts)               | Deep-diff the data to compute the tainted tree.                           |
-| [`ClientValidate`](src/ClientValidate.ts) | Validate the form / one field against the schema.                         |
-| [`EnhanceCore`](src/EnhanceCore.ts)       | Serialise data → form body, parse the response, compute the store update. |
+| Module                                                                                                              | Exports                                                                                                                                                                                         |
+| ------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`FormStore`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/FormStore.svelte.ts)    | `createForm`, `FormStore`, `FieldHandle`, `FieldMeta`, `FormOptions`, `FormSeed` — the reactive store above.                                                                                    |
+| [`EntityForm`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/EntityForm.ts)         | `defineEntityForm` — an ordered, key-checked field list over a core `Command.plan`, walked by one generic renderer component; its entry types (`ScalarEntry`, `SelectEntry`, `WidgetEntry`, …). |
+| [`SvelteKit`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/SvelteKit.ts)           | `applyActionResult` — apply a SvelteKit `ActionResult` (`ServerActionResult`) to a store; returns whether it consumed a validation failure.                                                     |
+| [`Listeners`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/Listeners.ts)           | `changeEvents` / `dispatchChange` and the `FormListeners` / `FieldListener` types — per-field and form-wide change listeners (linked fields).                                                   |
+| [`Tainted`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/Tainted.ts)               | Deep-diff the data to compute the tainted tree.                                                                                                                                                 |
+| [`ClientValidate`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/ClientValidate.ts) | `validateData` / `validateField` — validate the form, or one field, against the schema.                                                                                                         |
+| [`EnhanceCore`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/src/EnhanceCore.ts)       | Serialise data → form body, parse the response, compute the store update.                                                                                                                       |
 
-The store itself is mostly exercised only by `svelte-check`, but the submitter-aware enhanced submit path (`enhance` → `#runSubmit` → the posted `FormData`) is directly unit-tested in [`FormStore.svelte.test.ts`](tests/FormStore.svelte.test.ts) — a `.svelte.ts` rune file needs the Svelte compiler to run at all, hence the `.svelte.test.ts` extension and the `svelte()` plugin in `vite.config.ts` (scoped to a `happy-dom` DOM via a per-file `@vitest-environment` docblock, not the package default).
+The reactive store (`FormStore.svelte.ts`, rune-compiled) delegates its logic to the pure, unit-tested modules. The store itself is type-checked (by `vp check` and by `svelte-check`); its submitter-aware submit path (`enhance` → the posted `FormData`) is unit-tested in [`FormStore.svelte.test.ts`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/tests/FormStore.svelte.test.ts).
 
-## Development
+## /kit
 
-```sh
-vp exec svelte-check --tsconfig ./tsconfig.json   # typecheck (incl. runes)
-vp test run tests                                 # unit tests (pure modules + the submit path)
+`@thomasfosterau/effect-forms-svelte/kit` holds the SvelteKit form-action glue: the derived page action, the JSON:API error routing, the idempotent create retry, the `$app/forms` enhance, the `PageProps["form"]` readers, and failure routing for action-only routes. The root entry (`@thomasfosterau/effect-forms-svelte`) stays framework-neutral Svelte; only `/kit` imports `@sveltejs/kit` and `$app/forms`.
+
+| Export                                                     | What it does                                                                                                         |
+| ---------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `formAction(form, run, locationFor, options?)`             | A page action: validate, run the command, then `redirect(303)`, `fail(status, { form })` or `fail(500, { message })` |
+| `runFormAction(form, request, run, locationFor, options?)` | The same, as a framework-neutral `Result.FormActionResult`                                                           |
+| `fieldFromPointer(pointer)`                                | `/data/attributes/<field>…` → `Option<field>`                                                                        |
+| `idempotentCreate(create, fetchExisting)`                  | A 409 on the caller's own client id resolves as success                                                              |
+| `CommandFailure.*`, `jsonapiFailure`                       | Classify a command failure into routed JSON:API errors or a root message                                             |
+| `enhanceForm(store)`                                       | Spreadable `<form>` props on `$app/forms` `enhance`                                                                  |
+| `formStateOf` / `issuesFor` / `rootIssuesOf` / `valueOf`   | Total readers over `PageProps["form"]`                                                                               |
+| `userFixableMessage` / `withFailureParams`                 | Redirect-with-query failure routing for routes that have no page                                                     |
+
+### Peers
+
+- `@sveltejs/kit` (`^3.0.0`) is an **optional** peer of the package and **required** by `/kit`. SvelteKit 2 is not supported. The repository's tests run against the SvelteKit version pinned in its `pnpm-workspace.yaml`.
+- `$app/forms` is a SvelteKit virtual module, not a dependency. It resolves because SvelteKit compiles this package (its `exports` carry the `svelte` condition), so `/kit` only works inside a SvelteKit build.
+- `@thomasfosterau/effect-jsonapi` (`>=0.16.0`) is an **optional** peer used **for its types only**. `CommandFailure.ErrorObject` is `Document.ErrorObject.Type`. At runtime a failure is recognised by its `_tag`, so an application's own `JsonapiError` with the same shape is recognised too.
+
+### Commands and failures
+
+A command is `(input, event) => Promise<O> | Effect<O, E>`. An Effect command must have no requirements left. Provide them first, e.g. with the application's `ManagedRuntime`. `locationFor(output, input)` builds the redirect, and must return a same-origin path such as `/organisations/${id}`. SvelteKit 3's `redirect` rejects an external location unless it is given `{ external }`, which `formAction` never passes, so an absolute URL on another origin (or a protocol-relative `//host/...`) makes the action throw an `Error` after the command has run. To send the user off-site, redirect to a same-origin route that performs the external redirect itself. `runFormAction` returns the location unchecked.
+
+`jsonapiFailure`, the default classifier, recognises:
+
+- `{ _tag: "JsonapiError", status, errors }`: effect-jsonapi's `ServerErrors.JsonapiError`, or any error of the same shape. Each error object goes to the field its `source.pointer` names, or to the root (`form.errors._errors`), at the cause's own status.
+- `{ _tag: "ErrorResponse", status, message, document }`: effect-jsonapi's client-side decoded error. The document's error objects are routed as above. With no document, the message goes to the root.
+- An `Error` with a numeric `status`, such as a transport's 413: its message goes to the root.
+
+Anything else is unexpected. By default it becomes `fail(500, { message })`. Pass `unrecognised: "throw"` to hand it to `handleError` instead. `classify` replaces the classifier; compose with `CommandFailure.jsonapiFailure` to extend it. `redact` runs on every state echoed back to the browser. `idempotent: { clientId, fetchExisting }` turns on the client-id retry.
+
+### Worked example: a login action
+
+A hand-written sign-in action typically hand-rolls validation, password blanking, 401 → generic message, a rethrow for anything else, and a same-origin redirect. With `/kit` it becomes:
+
+```ts
+// src/routes/login/+page.server.ts
+import { Form, State } from "@thomasfosterau/effect-forms";
+import { CommandFailure, formAction } from "@thomasfosterau/effect-forms-svelte/kit";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { SessionCallError } from "#lib/server/api/binding";
+import { safeRedirect } from "#lib/redirects";
+
+const SignInFields = Schema.Struct({
+  email: Schema.String,
+  _password: Schema.String,
+  redirectTo: Schema.optional(Schema.String),
+});
+
+const signInForm = Form.make(SignInFields, {
+  defaults: { email: "", _password: "", redirectTo: undefined },
+  id: "sign-in",
+});
+
+type SignIn = typeof SignInFields.Type;
+
+/** Blank the password before a state is echoed back to the browser. */
+const blankPassword = (state: State.FormState<SignIn>): State.FormState<SignIn> => ({
+  ...state,
+  data: { ...state.data, _password: "" },
+});
+
+/** A 401 → one generic whole-form message (never reveal whether the email exists). */
+const classify: CommandFailure.Classify = (cause) =>
+  cause instanceof SessionCallError && cause.status === 401
+    ? Option.some(CommandFailure.message(401, "Invalid email or password"))
+    : Option.none();
+
+export const actions = {
+  default: formAction(
+    signInForm,
+    (input, { locals }) =>
+      locals.session.signIn({ email: input.email, password: input._password, rememberMe: true }),
+    (_, input) => safeRedirect(input.redirectTo, "/"),
+    { classify, redact: blankPassword, unrecognised: "throw" },
+  ),
+};
 ```
+
+The runnable copy is [`packages/svelte/tests/kit/examples/login.page.server.ts`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/tests/kit/examples/login.page.server.ts). [`login.example.test.ts`](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/tests/kit/login.example.test.ts) runs it against the real `@sveltejs/kit`, covering the success redirect, the off-site `redirectTo` guard, the 401 with a blanked password, and the rethrow.
+
+The page renders server state without a client store:
+
+```svelte
+<script lang="ts">
+  import { formStateOf, issuesFor, rootIssuesOf, valueOf } from "@thomasfosterau/effect-forms-svelte/kit";
+  let { form } = $props();
+  const state = $derived(formStateOf(form));
+</script>
+
+<form method="post">
+  {#each rootIssuesOf(state) as message}<p role="alert">{message}</p>{/each}
+  <input name="email" value={valueOf(state, "email")} />
+  {#each issuesFor(state, "email") as message}<small>{message}</small>{/each}
+  <input name="_password" type="password" />
+</form>
+```
+
+With a client store, spread `enhanceForm(form)` onto the `<form>` instead.
+
+## License
+
+[MIT](https://github.com/thomasfosterau/effect-forms/blob/trunk/packages/svelte/LICENSE)

package/dist/ClientValidate.d.ts

@@ -5,14 +5,14 @@ type FormErrors = Errors.FormErrors;
 type FormPath = Issues.FormPath;
 type LeafFormatter = Issues.LeafFormatter;
 /** Validate the whole form's data, returning the nested error tree (empty when valid). */
-declare function validateData<S extends Schema.Top>(schema: S, data: unknown, format?: LeafFormatter): FormErrors;
+export declare function validateData<S extends Schema.Top>(schema: S, data: unknown, format?: LeafFormatter): FormErrors;
 /**
  * Validate the whole form and return just the messages at `path`. Validating
  * the whole object (rather than the leaf in isolation) keeps cross-field rules
  * working; the caller merges the result into its existing error tree for that
  * field only.
  */
-declare function validateField<S extends Schema.Top>(schema: S, data: unknown, path: FormPath, format?: LeafFormatter): readonly string[];
+export declare function validateField<S extends Schema.Top>(schema: S, data: unknown, path: FormPath, format?: LeafFormatter): readonly string[];
 //#endregion
-export { validateData, validateField };
+export {};
 //# sourceMappingURL=ClientValidate.d.ts.map

package/dist/ClientValidate.js

@@ -1,8 +1,6 @@
 import { Errors, Validate } from "@thomasfosterau/effect-forms";
 //#region src/ClientValidate.ts
 /**
-* @copyright Thomas Foster
-*
 * Client-side validation helpers — validate the whole form or a single field
 * against the same Effect Schema the server uses, returning the nested
 * {@link FormErrors} tree (or one field's messages).
@@ -12,6 +10,7 @@ import { Errors, Validate } from "@thomasfosterau/effect-forms";
 * have no decoding-service requirements (the common case for form schemas) so
 * validation can run synchronously in an event handler.
 *
+* @copyright Thomas Foster
 * @module effect-forms-svelte/ClientValidate
 */
 const { getError, noErrors } = Errors;

package/dist/ClientValidate.js.map

@@ -1 +1 @@
-{"version":3,"file":"ClientValidate.js","names":[],"sources":["../src/ClientValidate.ts"],"sourcesContent":["/**\n * @copyright Thomas Foster\n *\n * Client-side validation helpers — validate the whole form or a single field\n * against the same Effect Schema the server uses, returning the nested\n * {@link FormErrors} tree (or one field's messages).\n *\n * Re-running the schema in the browser gives instant feedback; this is\n * the framework-neutral plumbing the Svelte store calls. Schemas used here must\n * have no decoding-service requirements (the common case for form schemas) so\n * validation can run synchronously in an event handler.\n *\n * @module effect-forms-svelte/ClientValidate\n */\n\nimport { Errors, Issues, Validate } from \"@thomasfosterau/effect-forms\";\n\n// Terse local aliases onto the namespaced core exports.\ntype FormErrors = Errors.FormErrors;\ntype FormPath = Issues.FormPath;\ntype LeafFormatter = Issues.LeafFormatter;\nconst { getError, noErrors } = Errors;\nconst { validateValueSync } = Validate;\nimport type * as Schema from \"effect/Schema\";\n\n/** Validate the whole form's data, returning the nested error tree (empty when valid). */\nexport function validateData<S extends Schema.Top>(\n  schema: S,\n  data: unknown,\n  format?: LeafFormatter,\n): FormErrors {\n  const result = validateValueSync(schema, data, format);\n  return result.valid ? noErrors : result.errors;\n}\n\n/**\n * Validate the whole form and return just the messages at `path`. Validating\n * the whole object (rather than the leaf in isolation) keeps cross-field rules\n * working; the caller merges the result into its existing error tree for that\n * field only.\n */\nexport function validateField<S extends Schema.Top>(\n  schema: S,\n  data: unknown,\n  path: FormPath,\n  format?: LeafFormatter,\n): readonly string[] {\n  const errors = validateData(schema, data, format);\n  return getError(errors, path) ?? [];\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAqBA,MAAM,EAAE,UAAU,aAAa;AAC/B,MAAM,EAAE,sBAAsB;;AAI9B,SAAgB,aACd,QACA,MACA,QACY;CACZ,MAAM,SAAS,kBAAkB,QAAQ,MAAM,MAAM;CACrD,OAAO,OAAO,QAAQ,WAAW,OAAO;AAC1C;;;;;;;AAQA,SAAgB,cACd,QACA,MACA,MACA,QACmB;CACnB,MAAM,SAAS,aAAa,QAAQ,MAAM,MAAM;CAChD,OAAO,SAAS,QAAQ,IAAI,KAAK,CAAC;AACpC"}
+{"version":3,"file":"ClientValidate.js","names":[],"sources":["../src/ClientValidate.ts"],"sourcesContent":["/**\n * Client-side validation helpers — validate the whole form or a single field\n * against the same Effect Schema the server uses, returning the nested\n * {@link FormErrors} tree (or one field's messages).\n *\n * Re-running the schema in the browser gives instant feedback; this is\n * the framework-neutral plumbing the Svelte store calls. Schemas used here must\n * have no decoding-service requirements (the common case for form schemas) so\n * validation can run synchronously in an event handler.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/ClientValidate\n */\n\nimport { Errors, Issues, Validate } from \"@thomasfosterau/effect-forms\";\n\n// Terse local aliases onto the namespaced core exports.\ntype FormErrors = Errors.FormErrors;\ntype FormPath = Issues.FormPath;\ntype LeafFormatter = Issues.LeafFormatter;\nconst { getError, noErrors } = Errors;\nconst { validateValueSync } = Validate;\nimport type * as Schema from \"effect/Schema\";\n\n/** Validate the whole form's data, returning the nested error tree (empty when valid). */\nexport function validateData<S extends Schema.Top>(\n  schema: S,\n  data: unknown,\n  format?: LeafFormatter,\n): FormErrors {\n  const result = validateValueSync(schema, data, format);\n  return result.valid ? noErrors : result.errors;\n}\n\n/**\n * Validate the whole form and return just the messages at `path`. Validating\n * the whole object (rather than the leaf in isolation) keeps cross-field rules\n * working; the caller merges the result into its existing error tree for that\n * field only.\n */\nexport function validateField<S extends Schema.Top>(\n  schema: S,\n  data: unknown,\n  path: FormPath,\n  format?: LeafFormatter,\n): readonly string[] {\n  const errors = validateData(schema, data, format);\n  return getError(errors, path) ?? [];\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoBA,MAAM,EAAE,UAAU,aAAa;AAC/B,MAAM,EAAE,sBAAsB;;AAI9B,SAAgB,aACd,QACA,MACA,QACY;CACZ,MAAM,SAAS,kBAAkB,QAAQ,MAAM,MAAM;CACrD,OAAO,OAAO,QAAQ,WAAW,OAAO;AAC1C;;;;;;;AAQA,SAAgB,cACd,QACA,MACA,MACA,QACmB;CACnB,MAAM,SAAS,aAAa,QAAQ,MAAM,MAAM;CAChD,OAAO,SAAS,QAAQ,IAAI,KAAK,CAAC;AACpC"}

package/dist/EnhanceCore.d.ts

@@ -2,19 +2,50 @@ import { Errors, Result } from "@thomasfosterau/effect-forms";
 //#region src/EnhanceCore.d.ts
 type FormActionResult<A, Message = unknown> = Result.FormActionResult<A, Message>;
 type FormErrors = Errors.FormErrors;
-/** Flatten a nested data object into `[name, value]` entries using path notation. */
-declare function objectToEntries(data: unknown, prefix?: string): Array<[string, string]>;
-/** Serialise the store's data into a {@link FormData} body for submission. */
-declare function objectToFormData(data: unknown): FormData;
+/**
+ * Flatten a nested data object into `[name, value]` string entries using path
+ * notation.
+ *
+ * Nested objects become dotted names (`author.name`) and array items indexed
+ * names (`tags[0]`). Each leaf kind is handled as follows:
+ *
+ * - A `string`, `number`, `boolean` or `bigint` is stringified.
+ * - `null` becomes `""`.
+ * - A `Date` becomes the `YYYY-MM-DD` of its **UTC** calendar day (what
+ *   `<input type="date">` submits, and what `Schema.DateFromString` decodes
+ *   back to UTC midnight); the time of day is dropped, so a datetime needs its
+ *   own string field. An invalid `Date` is omitted.
+ * - A `Blob` or `File` is omitted here, since a string entry can't carry it;
+ *   {@link objectToFormData} keeps it.
+ * - An `undefined`, `function` or `symbol` is omitted, as `JSON.stringify`
+ *   omits such object properties, so a callback or symbol left in form data
+ *   never reaches the form body as `"Symbol(…)"` or function source.
+ * - Any other object contributes its own enumerable fields, so one with none
+ *   (a `Map`, a `Set`, an empty object) contributes no entries.
+ *
+ * An omitted array item leaves a gap (where `JSON.stringify` would write
+ * `null`), so the remaining items keep their indices (`tags[0]`, `tags[2]`).
+ */
+export declare function objectToEntries(data: unknown, prefix?: string): Array<[string, string]>;
+/**
+ * Serialise the store's data into a {@link FormData} body for submission.
+ *
+ * Names and leaves follow {@link objectToEntries}, except that a `Blob` or
+ * `File` leaf is appended as a file (a `File` keeps its name; a bare `Blob`
+ * arrives as a `File` named `"blob"`, the `FormData` default), as an
+ * `<input type="file">` would submit it, so it reaches the core's
+ * `FormData.formDataToObject` (`@thomasfosterau/effect-forms`) unchanged.
+ */
+export declare function objectToFormData(data: unknown): FormData;
 /**
  * Normalise a parsed JSON response body into a {@link FormActionResult}. The
  * server may return a full action result (`{ _tag, … }`) or a bare
  * {@link FormState} — a bare state maps to `Success` / `Failure` by its `valid`
  * flag, using `status` for the failure code.
  */
-declare function parseActionResult<A, Message>(body: unknown, status?: number): FormActionResult<A, Message>;
+export declare function parseActionResult<A, Message>(body: unknown, status?: number): FormActionResult<A, Message>;
 /** The mutation a {@link FormActionResult} implies for the store. */
-interface FormUpdate<A, Message> {
+export interface FormUpdate<A, Message> {
   readonly data?: A | undefined;
   readonly errors?: FormErrors | undefined;
   readonly message?: Message | undefined;
@@ -27,9 +58,9 @@ interface FormUpdate<A, Message> {
  * caller applies the returned fields to its reactive state and acts on
  * `redirect` / `error`.
  */
-declare function resultToUpdate<A, Message>(result: FormActionResult<A, Message>): FormUpdate<A, Message>;
+export declare function resultToUpdate<A, Message>(result: FormActionResult<A, Message>): FormUpdate<A, Message>;
 /** How a successful/failed submit's data should land on `data` and the tainted baseline. */
-interface DataApplication<A> {
+export interface DataApplication<A> {
   /** The next value for `data`, or `undefined` to leave it untouched (an auto-submit keeps local edits). */
   readonly data: A | undefined;
   /** The next tainted baseline (`#initial`), or `undefined` when this isn't a successful submit. */
@@ -48,7 +79,7 @@ interface DataApplication<A> {
  * `submittedData` (the snapshot actually sent), not the live value, since the
  * user may have typed further edits that haven't been submitted yet.
  */
-declare function computeDataApplication<A>(params: {
+export declare function computeDataApplication<A>(params: {
   readonly isSuccess: boolean;
   readonly appliedData: A;
   readonly initial: A;
@@ -57,5 +88,5 @@ declare function computeDataApplication<A>(params: {
   readonly autoSubmit: boolean;
 }): DataApplication<A>;
 //#endregion
-export { DataApplication, FormUpdate, computeDataApplication, objectToEntries, objectToFormData, parseActionResult, resultToUpdate };
+export {};
 //# sourceMappingURL=EnhanceCore.d.ts.map

package/dist/EnhanceCore.js

@@ -1,49 +1,119 @@
 import { Result } from "@thomasfosterau/effect-forms";
+import * as Arr from "effect/Array";
+import * as Match from "effect/Match";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
 //#region src/EnhanceCore.ts
 /**
-* @copyright Thomas Foster
-*
 * Pure plumbing for the `enhance` action: serialise the store's data back into
 * a form body, interpret a server response into a {@link FormActionResult}, and
 * compute the store update a result implies. Kept framework-free and side-
 * effect-free so it is unit-testable in isolation; the rune store
-* (`superForm.svelte.ts`) wires these to the DOM.
+* (`FormStore.svelte.ts`) wires these to the DOM.
 *
+* @copyright Thomas Foster
 * @module effect-forms-svelte/EnhanceCore
 */
 const { failure, success } = Result;
-/** Flatten a nested data object into `[name, value]` entries using path notation. */
-function objectToEntries(data, prefix = "") {
+/**
+* Whether a value is a `Blob` (a `File` is one). Guards on `globalThis.Blob`
+* so it holds in any runtime, including one without a global `Blob`.
+*/
+const isBlob = (value) => !Predicate.isUndefined(globalThis.Blob) && value instanceof Blob;
+/**
+* Encode a `Date` as the `YYYY-MM-DD` of its UTC calendar day, or `undefined`
+* for an invalid `Date`. The UTC day round-trips: a `YYYY-MM-DD` string
+* decodes to UTC midnight. Taking everything before the `T` keeps
+* `toISOString`'s expanded form for a year outside 0000–9999
+* (`+010000-01-01`), where a fixed 10-character slice would cut it off.
+*/
+const encodeDate = (value) => {
+	if (Number.isNaN(value.getTime())) return void 0;
+	const iso = value.toISOString();
+	return iso.slice(0, iso.indexOf("T"));
+};
+/** Append the entries for one named value to `out`, recursing into containers. */
+function appendEntries(out, key, value) {
+	if (value === null) out.push([key, ""]);
+	else if (isBlob(value)) out.push([key, value]);
+	else if (value instanceof Date) {
+		const encoded = encodeDate(value);
+		if (encoded !== void 0) out.push([key, encoded]);
+	} else if (Array.isArray(value)) value.forEach((item, i) => appendEntries(out, `${key}[${i}]`, item));
+	else if (Predicate.isObject(value)) appendFields(out, value, key);
+	else if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value) || Predicate.isBigInt(value)) out.push([key, String(value)]);
+}
+/** Append an object's own enumerable fields to `out`, as `prefix.key` names. */
+function appendFields(out, data, prefix) {
+	Arr.forEach(Record.toEntries(data), ([key, value]) => appendEntries(out, prefix ? `${prefix}.${key}` : key, value));
+}
+/** Flatten `data` into form-body entries, `Blob` / `File` leaves included. */
+function toBodyEntries(data, prefix) {
 	const out = [];
-	const push = (key, value) => {
-		if (value === void 0) return;
-		if (value === null) out.push([key, ""]);
-		else if (Array.isArray(value)) value.forEach((item, i) => out.push(...objectToEntries(item, `${key}[${i}]`)));
-		else if (typeof value === "object") out.push(...objectToEntries(value, key));
-		else out.push([key, String(value)]);
-	};
-	if (data !== null && typeof data === "object" && !Array.isArray(data)) for (const [key, value] of Object.entries(data)) push(prefix ? `${prefix}.${key}` : key, value);
-	else if (prefix) push(prefix, data);
+	if (prefix) appendEntries(out, prefix, data);
+	else if (Predicate.isObject(data)) appendFields(out, data, "");
 	return out;
 }
-/** Serialise the store's data into a {@link FormData} body for submission. */
+/**
+* Flatten a nested data object into `[name, value]` string entries using path
+* notation.
+*
+* Nested objects become dotted names (`author.name`) and array items indexed
+* names (`tags[0]`). Each leaf kind is handled as follows:
+*
+* - A `string`, `number`, `boolean` or `bigint` is stringified.
+* - `null` becomes `""`.
+* - A `Date` becomes the `YYYY-MM-DD` of its **UTC** calendar day (what
+*   `<input type="date">` submits, and what `Schema.DateFromString` decodes
+*   back to UTC midnight); the time of day is dropped, so a datetime needs its
+*   own string field. An invalid `Date` is omitted.
+* - A `Blob` or `File` is omitted here, since a string entry can't carry it;
+*   {@link objectToFormData} keeps it.
+* - An `undefined`, `function` or `symbol` is omitted, as `JSON.stringify`
+*   omits such object properties, so a callback or symbol left in form data
+*   never reaches the form body as `"Symbol(…)"` or function source.
+* - Any other object contributes its own enumerable fields, so one with none
+*   (a `Map`, a `Set`, an empty object) contributes no entries.
+*
+* An omitted array item leaves a gap (where `JSON.stringify` would write
+* `null`), so the remaining items keep their indices (`tags[0]`, `tags[2]`).
+*/
+function objectToEntries(data, prefix = "") {
+	return toBodyEntries(data, prefix).filter((entry) => Predicate.isString(entry[1]));
+}
+/**
+* Serialise the store's data into a {@link FormData} body for submission.
+*
+* Names and leaves follow {@link objectToEntries}, except that a `Blob` or
+* `File` leaf is appended as a file (a `File` keeps its name; a bare `Blob`
+* arrives as a `File` named `"blob"`, the `FormData` default), as an
+* `<input type="file">` would submit it, so it reaches the core's
+* `FormData.formDataToObject` (`@thomasfosterau/effect-forms`) unchanged.
+*/
 function objectToFormData(data) {
 	const formData = new FormData();
-	for (const [key, value] of objectToEntries(data)) formData.append(key, value);
+	Arr.forEach(toBodyEntries(data, ""), ([key, value]) => formData.append(key, value));
 	return formData;
 }
-/** Whether a value looks like a {@link FormActionResult} (carries a known `_tag`). */
+/**
+* Whether a value looks like a {@link FormActionResult} (carries a known
+* `_tag`). Only the tag is checked: `A` / `Message` are the caller's declared
+* expectation of the server's response, not verified here.
+*/
 function isActionResult(value) {
-	return typeof value === "object" && value !== null && typeof value._tag === "string" && [
+	return Predicate.isObjectOrArray(value) && Predicate.hasProperty(value, "_tag") && Predicate.isString(value._tag) && [
 		"Success",
 		"Failure",
 		"Redirect",
 		"Error"
 	].includes(value._tag);
 }
-/** Whether a value looks like a bare {@link FormState}. */
+/**
+* Whether a value looks like a bare {@link FormState}. Only the keys are
+* checked: `A` / `Message` are the caller's declared expectation, not verified.
+*/
 function isFormState(value) {
-	return typeof value === "object" && value !== null && "valid" in value && "data" in value && "errors" in value;
+	return Predicate.isObjectOrArray(value) && "valid" in value && "data" in value && "errors" in value;
 }
 /**
 * Normalise a parsed JSON response body into a {@link FormActionResult}. The
@@ -53,10 +123,7 @@ function isFormState(value) {
 */
 function parseActionResult(body, status = 200) {
 	if (isActionResult(body)) return body;
-	if (isFormState(body)) {
-		const state = body;
-		return state.valid ? success(state, status) : failure(state, status);
-	}
+	if (isFormState(body)) return body.valid ? success(body, status) : failure(body, status);
 	return {
 		_tag: "Error",
 		status,
@@ -69,25 +136,25 @@ function parseActionResult(body, status = 200) {
 * `redirect` / `error`.
 */
 function resultToUpdate(result) {
-	switch (result._tag) {
-		case "Success": return {
-			data: result.state.data,
-			errors: result.state.errors,
-			message: result.state.message,
+	return Match.valueTags(result, {
+		Success: ({ state }) => ({
+			data: state.data,
+			errors: state.errors,
+			message: state.message,
 			valid: true
-		};
-		case "Failure": return {
-			data: result.state.data,
-			errors: result.state.errors,
-			message: result.state.message,
+		}),
+		Failure: ({ state }) => ({
+			data: state.data,
+			errors: state.errors,
+			message: state.message,
 			valid: false
-		};
-		case "Redirect": return { redirect: result.location };
-		case "Error": return {
-			error: result.message,
+		}),
+		Redirect: ({ location }) => ({ redirect: location }),
+		Error: ({ message }) => ({
+			error: message,
 			valid: false
-		};
-	}
+		})
+	});
 }
 /**
 * Decide how a submit result's data applies to the store, given a defined

package/dist/EnhanceCore.js.map

@@ -1 +1 @@
-{"version":3,"file":"EnhanceCore.js","names":[],"sources":["../src/EnhanceCore.ts"],"sourcesContent":["/**\n * @copyright Thomas Foster\n *\n * Pure plumbing for the `enhance` action: serialise the store's data back into\n * a form body, interpret a server response into a {@link FormActionResult}, and\n * compute the store update a result implies. Kept framework-free and side-\n * effect-free so it is unit-testable in isolation; the rune store\n * (`superForm.svelte.ts`) wires these to the DOM.\n *\n * @module effect-forms-svelte/EnhanceCore\n */\n\nimport { Errors, Result, State } from \"@thomasfosterau/effect-forms\";\n\n// Terse local aliases onto the namespaced core exports.\ntype FormActionResult<A, Message = unknown> = Result.FormActionResult<A, Message>;\ntype FormErrors = Errors.FormErrors;\ntype FormState<A, Message = unknown> = State.FormState<A, Message>;\nconst { failure, success } = Result;\n\n/** Flatten a nested data object into `[name, value]` entries using path notation. */\nexport function objectToEntries(data: unknown, prefix = \"\"): Array<[string, string]> {\n  const out: Array<[string, string]> = [];\n  const push = (key: string, value: unknown): void => {\n    if (value === undefined) return;\n    if (value === null) {\n      out.push([key, \"\"]);\n    } else if (Array.isArray(value)) {\n      value.forEach((item, i) => out.push(...objectToEntries(item, `${key}[${i}]`)));\n    } else if (typeof value === \"object\") {\n      out.push(...objectToEntries(value, key));\n    } else {\n      out.push([key, String(value)]);\n    }\n  };\n\n  if (data !== null && typeof data === \"object\" && !Array.isArray(data)) {\n    for (const [key, value] of Object.entries(data as Record<string, unknown>)) {\n      push(prefix ? `${prefix}.${key}` : key, value);\n    }\n  } else if (prefix) {\n    push(prefix, data);\n  }\n  return out;\n}\n\n/** Serialise the store's data into a {@link FormData} body for submission. */\nexport function objectToFormData(data: unknown): FormData {\n  const formData = new FormData();\n  for (const [key, value] of objectToEntries(data)) formData.append(key, value);\n  return formData;\n}\n\n/** Whether a value looks like a {@link FormActionResult} (carries a known `_tag`). */\nfunction isActionResult(value: unknown): value is FormActionResult<unknown, unknown> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as { _tag?: unknown })._tag === \"string\" &&\n    [\"Success\", \"Failure\", \"Redirect\", \"Error\"].includes((value as { _tag: string })._tag)\n  );\n}\n\n/** Whether a value looks like a bare {@link FormState}. */\nfunction isFormState(value: unknown): value is FormState<unknown, unknown> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"valid\" in value &&\n    \"data\" in value &&\n    \"errors\" in value\n  );\n}\n\n/**\n * Normalise a parsed JSON response body into a {@link FormActionResult}. The\n * server may return a full action result (`{ _tag, … }`) or a bare\n * {@link FormState} — a bare state maps to `Success` / `Failure` by its `valid`\n * flag, using `status` for the failure code.\n */\nexport function parseActionResult<A, Message>(\n  body: unknown,\n  status = 200,\n): FormActionResult<A, Message> {\n  if (isActionResult(body)) return body as FormActionResult<A, Message>;\n  if (isFormState(body)) {\n    const state = body as FormState<A, Message>;\n    return state.valid ? success(state, status) : failure(state, status);\n  }\n  return { _tag: \"Error\", status, message: \"Unrecognised form response\" };\n}\n\n/** The mutation a {@link FormActionResult} implies for the store. */\nexport interface FormUpdate<A, Message> {\n  readonly data?: A | undefined;\n  readonly errors?: FormErrors | undefined;\n  readonly message?: Message | undefined;\n  readonly redirect?: string | undefined;\n  readonly error?: string | undefined;\n  readonly valid?: boolean | undefined;\n}\n\n/**\n * Compute the store update implied by a {@link FormActionResult}. Pure: the\n * caller applies the returned fields to its reactive state and acts on\n * `redirect` / `error`.\n */\nexport function resultToUpdate<A, Message>(\n  result: FormActionResult<A, Message>,\n): FormUpdate<A, Message> {\n  switch (result._tag) {\n    case \"Success\":\n      return {\n        data: result.state.data,\n        errors: result.state.errors,\n        message: result.state.message,\n        valid: true,\n      };\n    case \"Failure\":\n      return {\n        data: result.state.data,\n        errors: result.state.errors,\n        message: result.state.message,\n        valid: false,\n      };\n    case \"Redirect\":\n      return { redirect: result.location };\n    case \"Error\":\n      return { error: result.message, valid: false };\n  }\n}\n\n/** How a successful/failed submit's data should land on `data` and the tainted baseline. */\nexport interface DataApplication<A> {\n  /** The next value for `data`, or `undefined` to leave it untouched (an auto-submit keeps local edits). */\n  readonly data: A | undefined;\n  /** The next tainted baseline (`#initial`), or `undefined` when this isn't a successful submit. */\n  readonly rebaseTo: A | undefined;\n}\n\n/**\n * Decide how a submit result's data applies to the store, given a defined\n * `update.data` (redirects/errors never reach this — see {@link resultToUpdate}).\n * Pure so the save-then-navigate baseline rebase is unit-testable without\n * compiling the rune store: on a successful submit the tainted baseline\n * rebases to whatever was actually persisted, so `isTainted` goes back to\n * `false` for values that were just saved, not just the original seed. An\n * auto-submitting (live-save) form keeps its local `data` as the source of\n * truth while a request is in flight — adopting the server's echo would\n * discard keystrokes made during the round-trip — but on success rebases to\n * `submittedData` (the snapshot actually sent), not the live value, since the\n * user may have typed further edits that haven't been submitted yet.\n */\nexport function computeDataApplication<A>(params: {\n  readonly isSuccess: boolean;\n  readonly appliedData: A;\n  readonly initial: A;\n  readonly submittedData: A;\n  readonly resetForm: boolean;\n  readonly autoSubmit: boolean;\n}): DataApplication<A> {\n  const { isSuccess, appliedData, initial, submittedData, resetForm, autoSubmit } = params;\n  if (resetForm && isSuccess) return { data: initial, rebaseTo: initial };\n  if (autoSubmit) return { data: undefined, rebaseTo: isSuccess ? submittedData : undefined };\n  return { data: appliedData, rebaseTo: isSuccess ? appliedData : undefined };\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,MAAM,EAAE,SAAS,YAAY;;AAG7B,SAAgB,gBAAgB,MAAe,SAAS,IAA6B;CACnF,MAAM,MAA+B,CAAC;CACtC,MAAM,QAAQ,KAAa,UAAyB;EAClD,IAAI,UAAU,KAAA,GAAW;EACzB,IAAI,UAAU,MACZ,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;OACb,IAAI,MAAM,QAAQ,KAAK,GAC5B,MAAM,SAAS,MAAM,MAAM,IAAI,KAAK,GAAG,gBAAgB,MAAM,GAAG,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC;OACxE,IAAI,OAAO,UAAU,UAC1B,IAAI,KAAK,GAAG,gBAAgB,OAAO,GAAG,CAAC;OAEvC,IAAI,KAAK,CAAC,KAAK,OAAO,KAAK,CAAC,CAAC;CAEjC;CAEA,IAAI,SAAS,QAAQ,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI,GAClE,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,IAA+B,GACvE,KAAK,SAAS,GAAG,OAAO,GAAG,QAAQ,KAAK,KAAK;MAE1C,IAAI,QACT,KAAK,QAAQ,IAAI;CAEnB,OAAO;AACT;;AAGA,SAAgB,iBAAiB,MAAyB;CACxD,MAAM,WAAW,IAAI,SAAS;CAC9B,KAAK,MAAM,CAAC,KAAK,UAAU,gBAAgB,IAAI,GAAG,SAAS,OAAO,KAAK,KAAK;CAC5E,OAAO;AACT;;AAGA,SAAS,eAAe,OAA6D;CACnF,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAA6B,SAAS,YAC9C;EAAC;EAAW;EAAW;EAAY;CAAO,CAAC,CAAC,SAAU,MAA2B,IAAI;AAEzF;;AAGA,SAAS,YAAY,OAAsD;CACzE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,WAAW,SACX,UAAU,SACV,YAAY;AAEhB;;;;;;;AAQA,SAAgB,kBACd,MACA,SAAS,KACqB;CAC9B,IAAI,eAAe,IAAI,GAAG,OAAO;CACjC,IAAI,YAAY,IAAI,GAAG;EACrB,MAAM,QAAQ;EACd,OAAO,MAAM,QAAQ,QAAQ,OAAO,MAAM,IAAI,QAAQ,OAAO,MAAM;CACrE;CACA,OAAO;EAAE,MAAM;EAAS;EAAQ,SAAS;CAA6B;AACxE;;;;;;AAiBA,SAAgB,eACd,QACwB;CACxB,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO;GACL,MAAM,OAAO,MAAM;GACnB,QAAQ,OAAO,MAAM;GACrB,SAAS,OAAO,MAAM;GACtB,OAAO;EACT;EACF,KAAK,WACH,OAAO;GACL,MAAM,OAAO,MAAM;GACnB,QAAQ,OAAO,MAAM;GACrB,SAAS,OAAO,MAAM;GACtB,OAAO;EACT;EACF,KAAK,YACH,OAAO,EAAE,UAAU,OAAO,SAAS;EACrC,KAAK,SACH,OAAO;GAAE,OAAO,OAAO;GAAS,OAAO;EAAM;CACjD;AACF;;;;;;;;;;;;;;AAuBA,SAAgB,uBAA0B,QAOnB;CACrB,MAAM,EAAE,WAAW,aAAa,SAAS,eAAe,WAAW,eAAe;CAClF,IAAI,aAAa,WAAW,OAAO;EAAE,MAAM;EAAS,UAAU;CAAQ;CACtE,IAAI,YAAY,OAAO;EAAE,MAAM,KAAA;EAAW,UAAU,YAAY,gBAAgB,KAAA;CAAU;CAC1F,OAAO;EAAE,MAAM;EAAa,UAAU,YAAY,cAAc,KAAA;CAAU;AAC5E"}
+{"version":3,"file":"EnhanceCore.js","names":[],"sources":["../src/EnhanceCore.ts"],"sourcesContent":["/**\n * Pure plumbing for the `enhance` action: serialise the store's data back into\n * a form body, interpret a server response into a {@link FormActionResult}, and\n * compute the store update a result implies. Kept framework-free and side-\n * effect-free so it is unit-testable in isolation; the rune store\n * (`FormStore.svelte.ts`) wires these to the DOM.\n *\n * @copyright Thomas Foster\n * @module effect-forms-svelte/EnhanceCore\n */\n\nimport { Errors, Result, State } from \"@thomasfosterau/effect-forms\";\nimport * as Arr from \"effect/Array\";\nimport * as Match from \"effect/Match\";\nimport * as Predicate from \"effect/Predicate\";\nimport * as Record from \"effect/Record\";\n\n// Terse local aliases onto the namespaced core exports.\ntype FormActionResult<A, Message = unknown> = Result.FormActionResult<A, Message>;\ntype FormErrors = Errors.FormErrors;\ntype FormState<A, Message = unknown> = State.FormState<A, Message>;\nconst { failure, success } = Result;\n\n/** A form-body entry: a stringified leaf, or a `Blob` / `File` passed through. */\ntype BodyEntry = [string, string | Blob];\n\n/**\n * Whether a value is a `Blob` (a `File` is one). Guards on `globalThis.Blob`\n * so it holds in any runtime, including one without a global `Blob`.\n */\nconst isBlob = (value: unknown): value is Blob =>\n  !Predicate.isUndefined(globalThis.Blob) && value instanceof Blob;\n\n/**\n * Encode a `Date` as the `YYYY-MM-DD` of its UTC calendar day, or `undefined`\n * for an invalid `Date`. The UTC day round-trips: a `YYYY-MM-DD` string\n * decodes to UTC midnight. Taking everything before the `T` keeps\n * `toISOString`'s expanded form for a year outside 0000–9999\n * (`+010000-01-01`), where a fixed 10-character slice would cut it off.\n */\nconst encodeDate = (value: Date): string | undefined => {\n  if (Number.isNaN(value.getTime())) return undefined;\n  const iso = value.toISOString();\n  return iso.slice(0, iso.indexOf(\"T\"));\n};\n\n/** Append the entries for one named value to `out`, recursing into containers. */\nfunction appendEntries(out: Array<BodyEntry>, key: string, value: unknown): void {\n  if (value === null) {\n    out.push([key, \"\"]);\n  } else if (isBlob(value)) {\n    out.push([key, value]);\n  } else if (value instanceof Date) {\n    const encoded = encodeDate(value);\n    if (encoded !== undefined) out.push([key, encoded]);\n  } else if (Array.isArray(value)) {\n    value.forEach((item, i) => appendEntries(out, `${key}[${i}]`, item));\n  } else if (Predicate.isObject(value)) {\n    appendFields(out, value, key);\n  } else if (\n    Predicate.isString(value) ||\n    Predicate.isNumber(value) ||\n    Predicate.isBoolean(value) ||\n    Predicate.isBigInt(value)\n  ) {\n    out.push([key, String(value)]);\n  }\n  // `undefined`, `function` and `symbol` leaves are omitted.\n}\n\n/** Append an object's own enumerable fields to `out`, as `prefix.key` names. */\nfunction appendFields<V>(\n  out: Array<BodyEntry>,\n  data: Record.ReadonlyRecord<string, V>,\n  prefix: string,\n): void {\n  Arr.forEach(Record.toEntries(data), ([key, value]) =>\n    appendEntries(out, prefix ? `${prefix}.${key}` : key, value),\n  );\n}\n\n/** Flatten `data` into form-body entries, `Blob` / `File` leaves included. */\nfunction toBodyEntries(data: unknown, prefix: string): Array<BodyEntry> {\n  const out: Array<BodyEntry> = [];\n  if (prefix) appendEntries(out, prefix, data);\n  else if (Predicate.isObject(data)) {\n    appendFields(out, data, \"\");\n  }\n  return out;\n}\n\n/**\n * Flatten a nested data object into `[name, value]` string entries using path\n * notation.\n *\n * Nested objects become dotted names (`author.name`) and array items indexed\n * names (`tags[0]`). Each leaf kind is handled as follows:\n *\n * - A `string`, `number`, `boolean` or `bigint` is stringified.\n * - `null` becomes `\"\"`.\n * - A `Date` becomes the `YYYY-MM-DD` of its **UTC** calendar day (what\n *   `<input type=\"date\">` submits, and what `Schema.DateFromString` decodes\n *   back to UTC midnight); the time of day is dropped, so a datetime needs its\n *   own string field. An invalid `Date` is omitted.\n * - A `Blob` or `File` is omitted here, since a string entry can't carry it;\n *   {@link objectToFormData} keeps it.\n * - An `undefined`, `function` or `symbol` is omitted, as `JSON.stringify`\n *   omits such object properties, so a callback or symbol left in form data\n *   never reaches the form body as `\"Symbol(…)\"` or function source.\n * - Any other object contributes its own enumerable fields, so one with none\n *   (a `Map`, a `Set`, an empty object) contributes no entries.\n *\n * An omitted array item leaves a gap (where `JSON.stringify` would write\n * `null`), so the remaining items keep their indices (`tags[0]`, `tags[2]`).\n */\nexport function objectToEntries(data: unknown, prefix = \"\"): Array<[string, string]> {\n  return toBodyEntries(data, prefix).filter((entry): entry is [string, string] =>\n    Predicate.isString(entry[1]),\n  );\n}\n\n/**\n * Serialise the store's data into a {@link FormData} body for submission.\n *\n * Names and leaves follow {@link objectToEntries}, except that a `Blob` or\n * `File` leaf is appended as a file (a `File` keeps its name; a bare `Blob`\n * arrives as a `File` named `\"blob\"`, the `FormData` default), as an\n * `<input type=\"file\">` would submit it, so it reaches the core's\n * `FormData.formDataToObject` (`@thomasfosterau/effect-forms`) unchanged.\n */\nexport function objectToFormData(data: unknown): FormData {\n  const formData = new FormData();\n  Arr.forEach(toBodyEntries(data, \"\"), ([key, value]) => formData.append(key, value));\n  return formData;\n}\n\n/**\n * Whether a value looks like a {@link FormActionResult} (carries a known\n * `_tag`). Only the tag is checked: `A` / `Message` are the caller's declared\n * expectation of the server's response, not verified here.\n */\nfunction isActionResult<A, Message>(value: unknown): value is FormActionResult<A, Message> {\n  return (\n    Predicate.isObjectOrArray(value) &&\n    Predicate.hasProperty(value, \"_tag\") &&\n    Predicate.isString(value._tag) &&\n    [\"Success\", \"Failure\", \"Redirect\", \"Error\"].includes(value._tag)\n  );\n}\n\n/**\n * Whether a value looks like a bare {@link FormState}. Only the keys are\n * checked: `A` / `Message` are the caller's declared expectation, not verified.\n */\nfunction isFormState<A, Message>(value: unknown): value is FormState<A, Message> {\n  return (\n    Predicate.isObjectOrArray(value) && \"valid\" in value && \"data\" in value && \"errors\" in value\n  );\n}\n\n/**\n * Normalise a parsed JSON response body into a {@link FormActionResult}. The\n * server may return a full action result (`{ _tag, … }`) or a bare\n * {@link FormState} — a bare state maps to `Success` / `Failure` by its `valid`\n * flag, using `status` for the failure code.\n */\nexport function parseActionResult<A, Message>(\n  body: unknown,\n  status = 200,\n): FormActionResult<A, Message> {\n  if (isActionResult<A, Message>(body)) return body;\n  if (isFormState<A, Message>(body)) {\n    return body.valid ? success(body, status) : failure(body, status);\n  }\n  return { _tag: \"Error\", status, message: \"Unrecognised form response\" };\n}\n\n/** The mutation a {@link FormActionResult} implies for the store. */\nexport interface FormUpdate<A, Message> {\n  readonly data?: A | undefined;\n  readonly errors?: FormErrors | undefined;\n  readonly message?: Message | undefined;\n  readonly redirect?: string | undefined;\n  readonly error?: string | undefined;\n  readonly valid?: boolean | undefined;\n}\n\n/**\n * Compute the store update implied by a {@link FormActionResult}. Pure: the\n * caller applies the returned fields to its reactive state and acts on\n * `redirect` / `error`.\n */\nexport function resultToUpdate<A, Message>(\n  result: FormActionResult<A, Message>,\n): FormUpdate<A, Message> {\n  return Match.valueTags(result, {\n    Success: ({ state }): FormUpdate<A, Message> => ({\n      data: state.data,\n      errors: state.errors,\n      message: state.message,\n      valid: true,\n    }),\n    Failure: ({ state }): FormUpdate<A, Message> => ({\n      data: state.data,\n      errors: state.errors,\n      message: state.message,\n      valid: false,\n    }),\n    Redirect: ({ location }): FormUpdate<A, Message> => ({ redirect: location }),\n    Error: ({ message }): FormUpdate<A, Message> => ({ error: message, valid: false }),\n  });\n}\n\n/** How a successful/failed submit's data should land on `data` and the tainted baseline. */\nexport interface DataApplication<A> {\n  /** The next value for `data`, or `undefined` to leave it untouched (an auto-submit keeps local edits). */\n  readonly data: A | undefined;\n  /** The next tainted baseline (`#initial`), or `undefined` when this isn't a successful submit. */\n  readonly rebaseTo: A | undefined;\n}\n\n/**\n * Decide how a submit result's data applies to the store, given a defined\n * `update.data` (redirects/errors never reach this — see {@link resultToUpdate}).\n * Pure so the save-then-navigate baseline rebase is unit-testable without\n * compiling the rune store: on a successful submit the tainted baseline\n * rebases to whatever was actually persisted, so `isTainted` goes back to\n * `false` for values that were just saved, not just the original seed. An\n * auto-submitting (live-save) form keeps its local `data` as the source of\n * truth while a request is in flight — adopting the server's echo would\n * discard keystrokes made during the round-trip — but on success rebases to\n * `submittedData` (the snapshot actually sent), not the live value, since the\n * user may have typed further edits that haven't been submitted yet.\n */\nexport function computeDataApplication<A>(params: {\n  readonly isSuccess: boolean;\n  readonly appliedData: A;\n  readonly initial: A;\n  readonly submittedData: A;\n  readonly resetForm: boolean;\n  readonly autoSubmit: boolean;\n}): DataApplication<A> {\n  const { isSuccess, appliedData, initial, submittedData, resetForm, autoSubmit } = params;\n  if (resetForm && isSuccess) return { data: initial, rebaseTo: initial };\n  if (autoSubmit) return { data: undefined, rebaseTo: isSuccess ? submittedData : undefined };\n  return { data: appliedData, rebaseTo: isSuccess ? appliedData : undefined };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAqBA,MAAM,EAAE,SAAS,YAAY;;;;;AAS7B,MAAM,UAAU,UACd,CAAC,UAAU,YAAY,WAAW,IAAI,KAAK,iBAAiB;;;;;;;;AAS9D,MAAM,cAAc,UAAoC;CACtD,IAAI,OAAO,MAAM,MAAM,QAAQ,CAAC,GAAG,OAAO,KAAA;CAC1C,MAAM,MAAM,MAAM,YAAY;CAC9B,OAAO,IAAI,MAAM,GAAG,IAAI,QAAQ,GAAG,CAAC;AACtC;;AAGA,SAAS,cAAc,KAAuB,KAAa,OAAsB;CAC/E,IAAI,UAAU,MACZ,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;MACb,IAAI,OAAO,KAAK,GACrB,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC;MAChB,IAAI,iBAAiB,MAAM;EAChC,MAAM,UAAU,WAAW,KAAK;EAChC,IAAI,YAAY,KAAA,GAAW,IAAI,KAAK,CAAC,KAAK,OAAO,CAAC;CACpD,OAAO,IAAI,MAAM,QAAQ,KAAK,GAC5B,MAAM,SAAS,MAAM,MAAM,cAAc,KAAK,GAAG,IAAI,GAAG,EAAE,IAAI,IAAI,CAAC;MAC9D,IAAI,UAAU,SAAS,KAAK,GACjC,aAAa,KAAK,OAAO,GAAG;MACvB,IACL,UAAU,SAAS,KAAK,KACxB,UAAU,SAAS,KAAK,KACxB,UAAU,UAAU,KAAK,KACzB,UAAU,SAAS,KAAK,GAExB,IAAI,KAAK,CAAC,KAAK,OAAO,KAAK,CAAC,CAAC;AAGjC;;AAGA,SAAS,aACP,KACA,MACA,QACM;CACN,IAAI,QAAQ,OAAO,UAAU,IAAI,IAAI,CAAC,KAAK,WACzC,cAAc,KAAK,SAAS,GAAG,OAAO,GAAG,QAAQ,KAAK,KAAK,CAC7D;AACF;;AAGA,SAAS,cAAc,MAAe,QAAkC;CACtE,MAAM,MAAwB,CAAC;CAC/B,IAAI,QAAQ,cAAc,KAAK,QAAQ,IAAI;MACtC,IAAI,UAAU,SAAS,IAAI,GAC9B,aAAa,KAAK,MAAM,EAAE;CAE5B,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,gBAAgB,MAAe,SAAS,IAA6B;CACnF,OAAO,cAAc,MAAM,MAAM,CAAC,CAAC,QAAQ,UACzC,UAAU,SAAS,MAAM,EAAE,CAC7B;AACF;;;;;;;;;;AAWA,SAAgB,iBAAiB,MAAyB;CACxD,MAAM,WAAW,IAAI,SAAS;CAC9B,IAAI,QAAQ,cAAc,MAAM,EAAE,IAAI,CAAC,KAAK,WAAW,SAAS,OAAO,KAAK,KAAK,CAAC;CAClF,OAAO;AACT;;;;;;AAOA,SAAS,eAA2B,OAAuD;CACzF,OACE,UAAU,gBAAgB,KAAK,KAC/B,UAAU,YAAY,OAAO,MAAM,KACnC,UAAU,SAAS,MAAM,IAAI,KAC7B;EAAC;EAAW;EAAW;EAAY;CAAO,CAAC,CAAC,SAAS,MAAM,IAAI;AAEnE;;;;;AAMA,SAAS,YAAwB,OAAgD;CAC/E,OACE,UAAU,gBAAgB,KAAK,KAAK,WAAW,SAAS,UAAU,SAAS,YAAY;AAE3F;;;;;;;AAQA,SAAgB,kBACd,MACA,SAAS,KACqB;CAC9B,IAAI,eAA2B,IAAI,GAAG,OAAO;CAC7C,IAAI,YAAwB,IAAI,GAC9B,OAAO,KAAK,QAAQ,QAAQ,MAAM,MAAM,IAAI,QAAQ,MAAM,MAAM;CAElE,OAAO;EAAE,MAAM;EAAS;EAAQ,SAAS;CAA6B;AACxE;;;;;;AAiBA,SAAgB,eACd,QACwB;CACxB,OAAO,MAAM,UAAU,QAAQ;EAC7B,UAAU,EAAE,aAAqC;GAC/C,MAAM,MAAM;GACZ,QAAQ,MAAM;GACd,SAAS,MAAM;GACf,OAAO;EACT;EACA,UAAU,EAAE,aAAqC;GAC/C,MAAM,MAAM;GACZ,QAAQ,MAAM;GACd,SAAS,MAAM;GACf,OAAO;EACT;EACA,WAAW,EAAE,gBAAwC,EAAE,UAAU,SAAS;EAC1E,QAAQ,EAAE,eAAuC;GAAE,OAAO;GAAS,OAAO;EAAM;CAClF,CAAC;AACH;;;;;;;;;;;;;;AAuBA,SAAgB,uBAA0B,QAOnB;CACrB,MAAM,EAAE,WAAW,aAAa,SAAS,eAAe,WAAW,eAAe;CAClF,IAAI,aAAa,WAAW,OAAO;EAAE,MAAM;EAAS,UAAU;CAAQ;CACtE,IAAI,YAAY,OAAO;EAAE,MAAM,KAAA;EAAW,UAAU,YAAY,gBAAgB,KAAA;CAAU;CAC1F,OAAO;EAAE,MAAM;EAAa,UAAU,YAAY,cAAc,KAAA;CAAU;AAC5E"}