@formancy/react 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,4 @@
+formancy
+Copyright 2026 Daniel Bacher
+
+This product includes software developed by the formancy project.

package/README.md

@@ -0,0 +1,48 @@
+<!-- Part of formancy: https://github.com/sharkysan/formancy.ai -->
+
+# @formancy/react
+
+The React binding for formancy: hooks over the engine's snapshot protocol, plus
+unstyled components you can keep or replace entirely.
+
+Requires React 19.
+
+## The load-bearing decision
+
+`useField` binds through `useSyncExternalStore` against identity-stable engine
+snapshots. The consequence is the headline: **typing in one field does not
+re-render its siblings** — there is a test that counts renders to keep it that
+way. The third argument serves SSR from the same snapshot the client hydrates
+with, and because the engine's ids are deterministic, the markup matches.
+
+The second is that markup belongs to you. Prop getters carry every id and ARIA
+attribute, so a design system can render every element itself and still be
+correct:
+
+```tsx
+const field = useField('email')
+<label {...field.labelProps}>Email</label>
+<input {...field.controlProps} value={field.value as string} />
+```
+
+## Use
+
+```tsx
+import { FormancyProvider, FormancyForm, ErrorSummary } from '@formancy/react'
+
+<FormancyProvider engine={engine}>
+  <ErrorSummary />
+  <FormancyForm onSubmit={(outcome) => console.log(outcome)} />
+</FormancyProvider>
+```
+
+`FormancyForm` renders pages, repeaters and a submit control from the schema.
+Swap any field renderer through the registry — per-path beats per-type beats the
+built-in defaults — without forking anything.
+
+Also exported: `useRepeater`, `useWizard`, `useSubmit` (which moves focus to the
+first problem, or defers to a mounted `ErrorSummary`).
+
+This renderer passes the shared conformance suite; so does the Angular one.
+
+Docs: `apps/docs` (Quickstart: React).

package/dist/index.d.mts

@@ -0,0 +1,147 @@
+import { ComponentType, ReactNode } from "react";
+import { ControlProps, FieldSnapshot, FormEngine, Path } from "@formancy/core";
+import { FieldType } from "@formancy/spec";
+//#region src/context.d.ts
+export declare function FormancyProvider({ engine, children }: {
+  engine: FormEngine;
+  children?: ReactNode;
+}): import("react").JSX.Element;
+export declare function useFormEngine(): FormEngine;
+//#endregion
+//#region src/use-field.d.ts
+interface FieldBinding extends FieldSnapshot {
+  setValue(value: unknown): void;
+  touch(): void;
+  /** Spread onto the input/select/textarea element. */
+  controlProps: ControlProps;
+  /** Spread onto the label element. */
+  labelProps: {
+    id: string;
+    htmlFor: string;
+  };
+  /** Spread onto the error text element. */
+  errorProps: {
+    id: string;
+  };
+}
+/**
+ * One field's live state, re-rendering exactly when that field's snapshot
+ * changes and never for its siblings.
+ *
+ * useSyncExternalStore is the honest way to bind an external store in React:
+ * the engine's snapshots are identity-stable, so getSnapshot needs no
+ * memoisation and concurrent rendering gets a consistent tearing guard for
+ * free. The third argument makes SSR render from the same snapshot the client
+ * will hydrate with — ids are deterministic, so markup matches.
+ */
+export declare function useField(path: string | Path): FieldBinding;
+//#endregion
+//#region src/use-repeater.d.ts
+interface RepeaterBinding {
+  rowCount: number;
+  /** Stable per-row keys, in row order. Never key a row by its index. */
+  rowIds: readonly string[];
+  addRow(): void;
+  removeRow(index: number): void;
+}
+/**
+ * A repeater's live row list. Renders exactly when rows are added, removed or
+ * edited — the engine treats the repeater path as subscribable in its own
+ * right, so this hook needs no polling and no array identity tricks.
+ */
+export declare function useRepeater(path: string | Path): RepeaterBinding;
+//#endregion
+//#region src/use-wizard.d.ts
+interface WizardBinding {
+  page: number;
+  pageCount: number;
+  /** Resolves true iff the page advanced; a failed validation keeps the page. */
+  next(): Promise<boolean>;
+  back(): void;
+  /** Unvalidated jump — error navigation, never a way past a gate. */
+  goTo(pageIndex: number): void;
+}
+/**
+ * The wizard's live position. Throws on an unpaged form rather than degrading
+ * to a one-page pseudo-wizard: a stepper rendered over a flat form is a bug in
+ * the caller, and a loud error at mount beats a mute component.
+ */
+export declare function useWizard(): WizardBinding;
+//#endregion
+//#region src/use-submit.d.ts
+/**
+ * Submit the form: touch everything, validate everything, and on failure move
+ * focus to the first invalid control — the WCAG-required behaviour that every
+ * consumer would otherwise have to hand-roll, and most would forget.
+ *
+ * Focus lives in the binding, not the engine, because it needs the DOM after
+ * the commit; the engine only names the field (firstInvalid) and mints the id.
+ */
+export declare function useSubmit(): () => {
+  ok: boolean;
+  errors: Record<string, string[]>;
+};
+//#endregion
+//#region src/form.d.ts
+/**
+ * The component registry — theming mechanism number two. The schema decides
+ * WHAT a field is; the registry decides what RENDERS it, with per-path entries
+ * beating per-type entries beating the built-in defaults. A design system
+ * replaces the entire visual layer by handing in a registry, without forking
+ * anything.
+ */
+interface FieldComponentProps {
+  path: string;
+  label: string;
+}
+type FieldComponent = ComponentType<FieldComponentProps>;
+interface Registry {
+  byType?: Partial<Record<FieldType, FieldComponent>>;
+  byPath?: Record<string, FieldComponent>;
+}
+interface SubmitOutcome {
+  ok: boolean;
+  errors: Record<string, string[]>;
+  /** The canonical value, present when accepted. */
+  data?: unknown;
+}
+interface FormancyFormProps {
+  /**
+   * Display text per wire path (row fields by their template wire,
+   * `items[].name`). A `label` on the model definition wins — that is how
+   * fixture schemas carry text until the spec's i18n section lands; a missing
+   * entry falls back to the wire path, which is at least honest.
+   */
+  labels?: Record<string, string>;
+  registry?: Registry;
+  submitLabel?: string;
+  onSubmit?: (outcome: SubmitOutcome) => void;
+}
+/**
+ * Renders the whole form from the engine: one slot per field, resolved through
+ * the registry. Slots subscribe individually, so a keystroke re-renders one
+ * field and a visibility flip mounts or unmounts exactly the fields it hit.
+ * A paged schema renders a stepper, one page at a time, navigation, and the
+ * submit control on the last page — a failed submit navigates to the first
+ * page with a problem instead of leaving the user on a clean review page
+ * staring at a rejection.
+ */
+export declare function FormancyForm(props: FormancyFormProps): import("react").JSX.Element;
+//#endregion
+//#region src/error-summary.d.ts
+interface ErrorSummaryProps {
+  labels?: Record<string, string>;
+}
+/**
+ * The error summary a failed submit focuses.
+ *
+ * The semantics are deliberate and easy to get wrong: the container takes
+ * focus via tabindex="-1" — focusing it already makes screen readers announce
+ * it, so role="alert" would announce it TWICE. Each entry is a real in-page
+ * link to the offending control, because links are what "take me to the
+ * problem" already means to assistive tech.
+ */
+export declare function ErrorSummary({ labels }: ErrorSummaryProps): import("react").JSX.Element | null;
+//#endregion
+export type { ErrorSummaryProps, FieldBinding, FieldComponent, FieldComponentProps, FormancyFormProps, Registry, RepeaterBinding, SubmitOutcome, WizardBinding };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/context.tsx","../src/use-field.ts","../src/use-repeater.ts","../src/use-wizard.ts","../src/use-submit.ts","../src/form.tsx","../src/error-summary.tsx"],"mappings":";;;;wBAYgB,mBAAmB,QAAQ;EAAc,QAAQ;EAAY,WAAW;oBAAW,IAAA;wBAInF,iBAAiB;;;UCXhB,qBAAqB;EACpC,SAAS;EACT;;EAEA,cAAc;;EAEd;IAAc;IAAY;;;EAE1B;IAAc;;;;;;;;;;;;;wBAaA,SAAS,eAAe,OAAO;;;UCrB9B;EACf;;EAEA;EACA;EACA,UAAU;;;;;;;wBAQI,YAAY,eAAe,OAAO;;;UCfjC;EACf;EACA;;EAEA,QAAQ;EACR;;EAEA,KAAK;;;;;;;wBAQS,aAAa;;;;;;;;;;;wBCNb;EAAqB;EAAa,QAAQ;;;;;;;;;;;UCKzC;EACf;EACA;;KAGU,iBAAiB,cAAc;UAE1B;EACf,SAAS,QAAQ,OAAO,WAAW;EACnC,SAAS,eAAe;;UAGT;EACf;EACA,QAAQ;;EAER;;UAGe;;;;;;;EAOf,SAAS;EACT,WAAW;EACX;EACA,YAAY,SAAS;;;;;;;;;;;wBAYP,aAAa,OAAO,oCAAiB,IAAA;;;UCtDpC;EACf,SAAS;;;;;;;;;;;wBAYK,eAAe,UAAU,oCAAiB,IAAA"}

package/dist/index.mjs

@@ -0,0 +1,505 @@
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useSyncExternalStore } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { formatPath, parsePath } from "@formancy/core";
+//#region src/context.tsx
+/**
+* The engine reaches components through context, never through props drilling:
+* a form is one engine instance, and every hook resolves against it. Kept in
+* its own module so tree-shaking can drop the provider for consumers that only
+* use prop getters.
+*/
+const FormancyContext = createContext(null);
+function FormancyProvider({ engine, children }) {
+	return /* @__PURE__ */ jsx(FormancyContext.Provider, {
+		value: engine,
+		children
+	});
+}
+function useFormEngine() {
+	const engine = useContext(FormancyContext);
+	if (!engine) throw new Error("formancy hooks need a <FormancyProvider engine={...}> above them in the tree");
+	return engine;
+}
+//#endregion
+//#region src/use-field.ts
+/**
+* One field's live state, re-rendering exactly when that field's snapshot
+* changes and never for its siblings.
+*
+* useSyncExternalStore is the honest way to bind an external store in React:
+* the engine's snapshots are identity-stable, so getSnapshot needs no
+* memoisation and concurrent rendering gets a consistent tearing guard for
+* free. The third argument makes SSR render from the same snapshot the client
+* will hydrate with — ids are deterministic, so markup matches.
+*/
+function useField(path) {
+	const engine = useFormEngine();
+	const wire = typeof path === "string" ? path : formatPath(path);
+	const parsed = useMemo(() => parsePath(wire), [wire]);
+	const subscribe = useCallback((onChange) => engine.subscribeField(parsed, onChange), [engine, parsed]);
+	const getSnapshot = useCallback(() => engine.getFieldSnapshot(parsed), [engine, parsed]);
+	const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+	const setValue = useCallback((value) => engine.setValue(parsed, value), [engine, parsed]);
+	const touch = useCallback(() => engine.touch(parsed), [engine, parsed]);
+	return useMemo(() => ({
+		...snapshot,
+		setValue,
+		touch,
+		controlProps: snapshot.props.control,
+		labelProps: {
+			id: snapshot.props.label.id,
+			htmlFor: snapshot.props.label.for
+		},
+		errorProps: snapshot.props.error
+	}), [
+		snapshot,
+		setValue,
+		touch
+	]);
+}
+//#endregion
+//#region src/use-repeater.ts
+/**
+* A repeater's live row list. Renders exactly when rows are added, removed or
+* edited — the engine treats the repeater path as subscribable in its own
+* right, so this hook needs no polling and no array identity tricks.
+*/
+function useRepeater(path) {
+	const engine = useFormEngine();
+	const wire = typeof path === "string" ? path : formatPath(path);
+	const parsed = useMemo(() => parsePath(wire), [wire]);
+	const subscribe = useCallback((onChange) => engine.subscribeField(parsed, onChange), [engine, parsed]);
+	const getRowCount = useCallback(() => engine.rowCount(parsed), [engine, parsed]);
+	const rowCount = useSyncExternalStore(subscribe, getRowCount, getRowCount);
+	const addRow = useCallback(() => engine.addRow(parsed), [engine, parsed]);
+	const removeRow = useCallback((index) => engine.removeRow(parsed, index), [engine, parsed]);
+	const rowIds = useMemo(() => Array.from({ length: rowCount }, (_, index) => engine.rowId(parsed, index)), [
+		engine,
+		parsed,
+		rowCount
+	]);
+	return useMemo(() => ({
+		rowCount,
+		rowIds,
+		addRow,
+		removeRow
+	}), [
+		rowCount,
+		rowIds,
+		addRow,
+		removeRow
+	]);
+}
+//#endregion
+//#region src/use-wizard.ts
+/**
+* The wizard's live position. Throws on an unpaged form rather than degrading
+* to a one-page pseudo-wizard: a stepper rendered over a flat form is a bug in
+* the caller, and a loud error at mount beats a mute component.
+*/
+function useWizard() {
+	const wizard = useFormEngine().wizard();
+	if (wizard === void 0) throw new Error("useWizard needs a schema with pages; this form has none");
+	const subscribe = useCallback((onChange) => wizard.subscribe(onChange), [wizard]);
+	const getPage = useCallback(() => wizard.page(), [wizard]);
+	const page = useSyncExternalStore(subscribe, getPage, getPage);
+	return useMemo(() => ({
+		page,
+		pageCount: wizard.pageCount,
+		next: () => wizard.next(),
+		back: () => wizard.back(),
+		goTo: (pageIndex) => wizard.goTo(pageIndex)
+	}), [page, wizard]);
+}
+//#endregion
+//#region src/use-submit.ts
+/**
+* Submit the form: touch everything, validate everything, and on failure move
+* focus to the first invalid control — the WCAG-required behaviour that every
+* consumer would otherwise have to hand-roll, and most would forget.
+*
+* Focus lives in the binding, not the engine, because it needs the DOM after
+* the commit; the engine only names the field (firstInvalid) and mints the id.
+*/
+function useSubmit() {
+	const engine = useFormEngine();
+	return useCallback(() => {
+		const outcome = engine.submit();
+		if (!outcome.ok && typeof document !== "undefined") {
+			if (document.querySelector("[data-formancy-part=\"error-summary\"]") === null) {
+				const firstInvalid = engine.firstInvalid();
+				if (firstInvalid !== null) {
+					const ids = engine.getFieldSnapshot(parsePath(firstInvalid)).ids;
+					document.getElementById(ids.control)?.focus();
+				}
+			}
+		}
+		return outcome;
+	}, [engine]);
+}
+//#endregion
+//#region src/form.tsx
+/**
+* Renders the whole form from the engine: one slot per field, resolved through
+* the registry. Slots subscribe individually, so a keystroke re-renders one
+* field and a visibility flip mounts or unmounts exactly the fields it hit.
+* A paged schema renders a stepper, one page at a time, navigation, and the
+* submit control on the last page — a failed submit navigates to the first
+* page with a problem instead of leaving the user on a clean review page
+* staring at a rejection.
+*/
+function FormancyForm(props) {
+	return useFormEngine().wizard() === void 0 ? /* @__PURE__ */ jsx(FlatForm, { ...props }) : /* @__PURE__ */ jsx(PagedForm, { ...props });
+}
+function SubmitButton({ submitLabel, onSubmit, onFailedNavigate }) {
+	const engine = useFormEngine();
+	const submit = useSubmit();
+	return /* @__PURE__ */ jsx("button", {
+		type: "button",
+		"data-formancy-part": "submit",
+		onClick: () => {
+			const outcome = submit();
+			if (!outcome.ok && onFailedNavigate !== void 0) {
+				const firstInvalid = engine.firstInvalid();
+				if (firstInvalid !== null) onFailedNavigate(engine.pageOf(parsePath(firstInvalid)));
+			}
+			onSubmit?.(outcome.ok ? {
+				ok: true,
+				errors: outcome.errors,
+				data: engine.value()
+			} : {
+				ok: false,
+				errors: outcome.errors
+			});
+		},
+		children: submitLabel ?? "Submit"
+	});
+}
+function FlatForm(props) {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(FieldList, { ...props }), /* @__PURE__ */ jsx(SubmitButton, { ...props })] });
+}
+function PagedForm(props) {
+	const engine = useFormEngine();
+	const wizard = useWizard();
+	const pages = engine.pages();
+	const lastPage = wizard.pageCount - 1;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("nav", {
+			"data-formancy-part": "stepper",
+			"aria-label": "Progress",
+			children: /* @__PURE__ */ jsx("ol", { children: pages.map((page, index) => /* @__PURE__ */ jsx("li", {
+				"aria-current": index === wizard.page ? "step" : void 0,
+				children: engine.text(page.def.label) ?? page.key
+			}, page.key)) })
+		}),
+		/* @__PURE__ */ jsx(FieldList, {
+			...props,
+			page: wizard.page
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			"data-formancy-part": "wizard-nav",
+			children: [wizard.page > 0 ? /* @__PURE__ */ jsx("button", {
+				type: "button",
+				onClick: () => wizard.back(),
+				children: "Back"
+			}) : null, wizard.page < lastPage ? /* @__PURE__ */ jsx("button", {
+				type: "button",
+				onClick: () => void wizard.next(),
+				children: "Next"
+			}) : /* @__PURE__ */ jsx(SubmitButton, {
+				...props,
+				onFailedNavigate: (page) => wizard.goTo(page)
+			})]
+		})
+	] });
+}
+function FieldList({ labels, registry, page }) {
+	const engine = useFormEngine();
+	const repeaterWires = engine.repeaterPaths();
+	const inPage = (wire) => page === void 0 || engine.pageOf(parsePath(wire)) === page;
+	const staticWires = engine.fieldPaths().filter((wire) => !repeaterWires.some((repeater) => wire.startsWith(`${repeater}[`)));
+	return /* @__PURE__ */ jsxs(Fragment, { children: [staticWires.filter(inPage).map((wire) => /* @__PURE__ */ jsx(FieldSlot, {
+		path: wire,
+		fallbackLabel: labels?.[wire],
+		registry
+	}, wire)), repeaterWires.filter(inPage).map((wire) => /* @__PURE__ */ jsx(RepeaterSection, {
+		wire,
+		labels,
+		registry
+	}, wire))] });
+}
+function FieldSlot({ path, fallbackLabel, registry }) {
+	const field = useField(path);
+	if (!field.visible) return null;
+	const Component = registry?.byPath?.[path] ?? registry?.byType?.[field.type] ?? DEFAULT_COMPONENTS[field.type];
+	if (Component === null) return null;
+	const label = field.label ?? fallbackLabel ?? path;
+	return /* @__PURE__ */ jsx(Component, {
+		path,
+		label
+	});
+}
+function RepeaterSection({ wire, labels, registry }) {
+	const engine = useFormEngine();
+	const repeater = useRepeater(wire);
+	const def = engine.repeaters().find((candidate) => candidate.wire === wire)?.def;
+	const label = engine.text(def?.label) ?? labels?.[wire] ?? wire;
+	const addLabel = def?.addLabel ?? `Add ${label}`;
+	const removeLabel = def?.removeLabel ?? `Remove ${label}`;
+	const fallbackFor = (instanceWire) => {
+		const template = instanceWire.replace(/\[\d+\]/, "[]");
+		return labels?.[template] ?? labels?.[instanceWire];
+	};
+	return /* @__PURE__ */ jsxs("fieldset", {
+		"data-formancy-part": "repeater",
+		children: [
+			/* @__PURE__ */ jsx("legend", {
+				"data-formancy-part": "repeater-legend",
+				children: label
+			}),
+			repeater.rowIds.map((rowId, index) => /* @__PURE__ */ jsxs("div", {
+				"data-formancy-part": "row",
+				children: [engine.fieldPaths().filter((candidate) => candidate.startsWith(`${wire}[${index}]`)).map((instanceWire) => /* @__PURE__ */ jsx(FieldSlot, {
+					path: instanceWire,
+					fallbackLabel: fallbackFor(instanceWire),
+					registry
+				}, instanceWire)), /* @__PURE__ */ jsx("button", {
+					type: "button",
+					onClick: () => repeater.removeRow(index),
+					children: `${removeLabel} ${index + 1} of ${repeater.rowCount}`
+				})]
+			}, rowId)),
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				onClick: () => repeater.addRow(),
+				children: addLabel
+			})
+		]
+	});
+}
+/** Shared unstyled shell: real label, control, error text as the describedby
+*  target. Zero CSS; `data-formancy-part` is the styling hook. */
+function FieldShell({ field, label, children }) {
+	return /* @__PURE__ */ jsxs("div", {
+		"data-formancy-part": "field",
+		"data-state": field.touched && field.errors.length > 0 ? "invalid" : "valid",
+		children: [
+			/* @__PURE__ */ jsx("label", {
+				"data-formancy-part": "label",
+				...field.labelProps,
+				children: label
+			}),
+			children,
+			field.touched && field.errors.length > 0 ? /* @__PURE__ */ jsx("p", {
+				"data-formancy-part": "error",
+				...field.errorProps,
+				children: field.errors.join(", ")
+			}) : null
+		]
+	});
+}
+function TextField({ path, label }) {
+	const field = useField(path);
+	return /* @__PURE__ */ jsx(FieldShell, {
+		field,
+		label,
+		children: /* @__PURE__ */ jsx("input", {
+			type: "text",
+			...field.controlProps,
+			value: typeof field.value === "string" ? field.value : "",
+			onChange: (event) => field.setValue(event.target.value),
+			onBlur: () => field.touch()
+		})
+	});
+}
+function TextareaField({ path, label }) {
+	const field = useField(path);
+	return /* @__PURE__ */ jsx(FieldShell, {
+		field,
+		label,
+		children: /* @__PURE__ */ jsx("textarea", {
+			...field.controlProps,
+			value: typeof field.value === "string" ? field.value : "",
+			onChange: (event) => field.setValue(event.target.value),
+			onBlur: () => field.touch()
+		})
+	});
+}
+function NumberField({ path, label }) {
+	const field = useField(path);
+	return /* @__PURE__ */ jsx(FieldShell, {
+		field,
+		label,
+		children: /* @__PURE__ */ jsx("input", {
+			type: "number",
+			...field.controlProps,
+			value: typeof field.value === "number" ? field.value : "",
+			onChange: (event) => field.setValue(event.target.value === "" ? null : event.target.valueAsNumber),
+			onBlur: () => field.touch()
+		})
+	});
+}
+function CheckboxField({ path, label }) {
+	const field = useField(path);
+	return /* @__PURE__ */ jsx(FieldShell, {
+		field,
+		label,
+		children: /* @__PURE__ */ jsx("input", {
+			type: "checkbox",
+			...field.controlProps,
+			checked: field.value === true,
+			onChange: (event) => field.setValue(event.target.checked),
+			onBlur: () => field.touch()
+		})
+	});
+}
+function DateField({ path, label }) {
+	const field = useField(path);
+	return /* @__PURE__ */ jsx(FieldShell, {
+		field,
+		label,
+		children: /* @__PURE__ */ jsx("input", {
+			type: "date",
+			...field.controlProps,
+			value: typeof field.value === "string" ? field.value : "",
+			onChange: (event) => field.setValue(event.target.value === "" ? null : event.target.value),
+			onBlur: () => field.touch()
+		})
+	});
+}
+/**
+* Option labels resolved to strings, since a label may be a message reference.
+* Falling back to the stored value keeps an untranslated option selectable
+* rather than blank.
+*/
+function useResolvedOptions(field) {
+	const engine = useFormEngine();
+	return (field.def.options ?? []).map((option) => ({
+		value: option.value,
+		label: engine.text(option.label) ?? option.value
+	}));
+}
+function SelectField({ path, label }) {
+	const field = useField(path);
+	const options = useResolvedOptions(field);
+	return /* @__PURE__ */ jsx(FieldShell, {
+		field,
+		label,
+		children: /* @__PURE__ */ jsxs("select", {
+			...field.controlProps,
+			value: typeof field.value === "string" ? field.value : "",
+			onChange: (event) => field.setValue(event.target.value === "" ? null : event.target.value),
+			onBlur: () => field.touch(),
+			children: [/* @__PURE__ */ jsx("option", { value: "" }), options.map((option) => /* @__PURE__ */ jsx("option", {
+				value: option.value,
+				children: option.label
+			}, option.value))]
+		})
+	});
+}
+function RadioGroupField({ path, label }) {
+	const field = useField(path);
+	const options = useResolvedOptions(field);
+	const showError = field.touched && field.errors.length > 0;
+	return /* @__PURE__ */ jsxs("fieldset", {
+		"data-formancy-part": "field",
+		"data-state": showError ? "invalid" : "valid",
+		"aria-describedby": field.controlProps["aria-describedby"],
+		children: [
+			/* @__PURE__ */ jsx("legend", {
+				"data-formancy-part": "label",
+				children: label
+			}),
+			options.map((option) => {
+				const optionId = `${field.ids.control}:${option.value}`;
+				return /* @__PURE__ */ jsxs("span", {
+					"data-formancy-part": "radio-option",
+					children: [/* @__PURE__ */ jsx("input", {
+						type: "radio",
+						id: optionId,
+						name: field.controlProps.name,
+						value: option.value,
+						checked: field.value === option.value,
+						onChange: () => field.setValue(option.value),
+						onBlur: () => field.touch()
+					}), /* @__PURE__ */ jsx("label", {
+						htmlFor: optionId,
+						children: option.label
+					})]
+				}, option.value);
+			}),
+			showError ? /* @__PURE__ */ jsx("p", {
+				"data-formancy-part": "error",
+				...field.errorProps,
+				children: field.errors.join(", ")
+			}) : null
+		]
+	});
+}
+/**
+* The built-in unstyled components. `null` means the type renders nothing here:
+* hidden and static are non-inputs, and the container types are laid out by
+* their own machinery, not by a leaf slot.
+*/
+const DEFAULT_COMPONENTS = {
+	text: TextField,
+	textarea: TextareaField,
+	number: NumberField,
+	checkbox: CheckboxField,
+	date: DateField,
+	select: SelectField,
+	radio: RadioGroupField,
+	hidden: null,
+	static: null,
+	group: null,
+	page: null,
+	repeater: null
+};
+//#endregion
+//#region src/error-summary.tsx
+/**
+* The error summary a failed submit focuses.
+*
+* The semantics are deliberate and easy to get wrong: the container takes
+* focus via tabindex="-1" — focusing it already makes screen readers announce
+* it, so role="alert" would announce it TWICE. Each entry is a real in-page
+* link to the offending control, because links are what "take me to the
+* problem" already means to assistive tech.
+*/
+function ErrorSummary({ labels }) {
+	const engine = useFormEngine();
+	const subscribe = useCallback((onChange) => engine.subscribe(onChange), [engine]);
+	const getErrors = useCallback(() => engine.visibleErrors(), [engine]);
+	const errors = useSyncExternalStore(subscribe, getErrors, getErrors);
+	const region = useRef(null);
+	const previousCount = useRef(0);
+	useEffect(() => {
+		if (errors.length > 0 && previousCount.current === 0) region.current?.focus();
+		previousCount.current = errors.length;
+	}, [errors]);
+	if (errors.length === 0) return null;
+	const labelFor = (path) => labels?.[path] ?? labels?.[path.replace(/\[\d+\]/, "[]")] ?? path;
+	return /* @__PURE__ */ jsxs("div", {
+		"data-formancy-part": "error-summary",
+		tabIndex: -1,
+		ref: region,
+		children: [/* @__PURE__ */ jsx("h2", {
+			"data-formancy-part": "error-summary-heading",
+			children: errors.length === 1 ? "There is 1 problem to fix" : `There are ${errors.length} problems to fix`
+		}), /* @__PURE__ */ jsx("ul", { children: errors.map(({ path, codes }) => {
+			const controlId = engine.getFieldSnapshot(parsePath(path)).ids.control;
+			return /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx("a", {
+				href: `#${controlId}`,
+				onClick: (event) => {
+					event.preventDefault();
+					document.getElementById(controlId)?.focus();
+				},
+				children: `${labelFor(path)}: ${codes.join(", ")}`
+			}) }, path);
+		}) })]
+	});
+}
+//#endregion
+export { ErrorSummary, FormancyForm, FormancyProvider, useField, useFormEngine, useRepeater, useSubmit, useWizard };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/context.tsx","../src/use-field.ts","../src/use-repeater.ts","../src/use-wizard.ts","../src/use-submit.ts","../src/form.tsx","../src/error-summary.tsx"],"sourcesContent":["import { createContext, useContext } from 'react'\nimport type { ReactNode } from 'react'\nimport type { FormEngine } from '@formancy/core'\n\n/**\n * The engine reaches components through context, never through props drilling:\n * a form is one engine instance, and every hook resolves against it. Kept in\n * its own module so tree-shaking can drop the provider for consumers that only\n * use prop getters.\n */\nconst FormancyContext = createContext<FormEngine | null>(null)\n\nexport function FormancyProvider({ engine, children }: { engine: FormEngine; children?: ReactNode }) {\n  return <FormancyContext.Provider value={engine}>{children}</FormancyContext.Provider>\n}\n\nexport function useFormEngine(): FormEngine {\n  const engine = useContext(FormancyContext)\n  if (!engine) {\n    throw new Error('formancy hooks need a <FormancyProvider engine={...}> above them in the tree')\n  }\n  return engine\n}\n","import { useCallback, useMemo, useSyncExternalStore } from 'react'\nimport { formatPath, parsePath } from '@formancy/core'\nimport type { ControlProps, FieldSnapshot, Path } from '@formancy/core'\nimport { useFormEngine } from './context.js'\n\nexport interface FieldBinding extends FieldSnapshot {\n  setValue(value: unknown): void\n  touch(): void\n  /** Spread onto the input/select/textarea element. */\n  controlProps: ControlProps\n  /** Spread onto the label element. */\n  labelProps: { id: string; htmlFor: string }\n  /** Spread onto the error text element. */\n  errorProps: { id: string }\n}\n\n/**\n * One field's live state, re-rendering exactly when that field's snapshot\n * changes and never for its siblings.\n *\n * useSyncExternalStore is the honest way to bind an external store in React:\n * the engine's snapshots are identity-stable, so getSnapshot needs no\n * memoisation and concurrent rendering gets a consistent tearing guard for\n * free. The third argument makes SSR render from the same snapshot the client\n * will hydrate with — ids are deterministic, so markup matches.\n */\nexport function useField(path: string | Path): FieldBinding {\n  const engine = useFormEngine()\n\n  const wire = typeof path === 'string' ? path : formatPath(path)\n  const parsed = useMemo(() => parsePath(wire), [wire])\n\n  const subscribe = useCallback(\n    (onChange: () => void) => engine.subscribeField(parsed, onChange),\n    [engine, parsed],\n  )\n  const getSnapshot = useCallback(() => engine.getFieldSnapshot(parsed), [engine, parsed])\n\n  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot)\n\n  const setValue = useCallback((value: unknown) => engine.setValue(parsed, value), [engine, parsed])\n  const touch = useCallback(() => engine.touch(parsed), [engine, parsed])\n\n  return useMemo(\n    () => ({\n      ...snapshot,\n      setValue,\n      touch,\n      controlProps: snapshot.props.control,\n      labelProps: { id: snapshot.props.label.id, htmlFor: snapshot.props.label.for },\n      errorProps: snapshot.props.error,\n    }),\n    [snapshot, setValue, touch],\n  )\n}\n","import { useCallback, useMemo, useSyncExternalStore } from 'react'\nimport { formatPath, parsePath } from '@formancy/core'\nimport type { Path } from '@formancy/core'\nimport { useFormEngine } from './context.js'\n\nexport interface RepeaterBinding {\n  rowCount: number\n  /** Stable per-row keys, in row order. Never key a row by its index. */\n  rowIds: readonly string[]\n  addRow(): void\n  removeRow(index: number): void\n}\n\n/**\n * A repeater's live row list. Renders exactly when rows are added, removed or\n * edited — the engine treats the repeater path as subscribable in its own\n * right, so this hook needs no polling and no array identity tricks.\n */\nexport function useRepeater(path: string | Path): RepeaterBinding {\n  const engine = useFormEngine()\n\n  const wire = typeof path === 'string' ? path : formatPath(path)\n  const parsed = useMemo(() => parsePath(wire), [wire])\n\n  const subscribe = useCallback(\n    (onChange: () => void) => engine.subscribeField(parsed, onChange),\n    [engine, parsed],\n  )\n  const getRowCount = useCallback(() => engine.rowCount(parsed), [engine, parsed])\n  const rowCount = useSyncExternalStore(subscribe, getRowCount, getRowCount)\n\n  const addRow = useCallback(() => engine.addRow(parsed), [engine, parsed])\n  const removeRow = useCallback((index: number) => engine.removeRow(parsed, index), [engine, parsed])\n\n  // Derived from rowCount rather than subscribed separately: the engine mints\n  // an id when a row is created, so the count changing is exactly when the ids\n  // change.\n  const rowIds = useMemo(\n    () => Array.from({ length: rowCount }, (_, index) => engine.rowId(parsed, index)),\n    [engine, parsed, rowCount],\n  )\n\n  return useMemo(\n    () => ({ rowCount, rowIds, addRow, removeRow }),\n    [rowCount, rowIds, addRow, removeRow],\n  )\n}\n","import { useCallback, useMemo, useSyncExternalStore } from 'react'\nimport { useFormEngine } from './context.js'\n\nexport interface WizardBinding {\n  page: number\n  pageCount: number\n  /** Resolves true iff the page advanced; a failed validation keeps the page. */\n  next(): Promise<boolean>\n  back(): void\n  /** Unvalidated jump — error navigation, never a way past a gate. */\n  goTo(pageIndex: number): void\n}\n\n/**\n * The wizard's live position. Throws on an unpaged form rather than degrading\n * to a one-page pseudo-wizard: a stepper rendered over a flat form is a bug in\n * the caller, and a loud error at mount beats a mute component.\n */\nexport function useWizard(): WizardBinding {\n  const engine = useFormEngine()\n  const wizard = engine.wizard()\n  if (wizard === undefined) {\n    throw new Error('useWizard needs a schema with pages; this form has none')\n  }\n\n  const subscribe = useCallback((onChange: () => void) => wizard.subscribe(onChange), [wizard])\n  const getPage = useCallback(() => wizard.page(), [wizard])\n  const page = useSyncExternalStore(subscribe, getPage, getPage)\n\n  return useMemo(\n    () => ({\n      page,\n      pageCount: wizard.pageCount,\n      next: () => wizard.next(),\n      back: () => wizard.back(),\n      goTo: (pageIndex: number) => wizard.goTo(pageIndex),\n    }),\n    [page, wizard],\n  )\n}\n","import { useCallback } from 'react'\nimport { parsePath } from '@formancy/core'\nimport { useFormEngine } from './context.js'\n\n/**\n * Submit the form: touch everything, validate everything, and on failure move\n * focus to the first invalid control — the WCAG-required behaviour that every\n * consumer would otherwise have to hand-roll, and most would forget.\n *\n * Focus lives in the binding, not the engine, because it needs the DOM after\n * the commit; the engine only names the field (firstInvalid) and mints the id.\n */\nexport function useSubmit(): () => { ok: boolean; errors: Record<string, string[]> } {\n  const engine = useFormEngine()\n\n  return useCallback(() => {\n    const outcome = engine.submit()\n    if (!outcome.ok && typeof document !== 'undefined') {\n      // An ErrorSummary takes precedence: it lists every problem, and focusing\n      // it announces the situation once. It focuses ITSELF when errors appear,\n      // so nothing to do here. Without one, fall back to the first control.\n      const summary = document.querySelector('[data-formancy-part=\"error-summary\"]')\n      if (summary === null) {\n        const firstInvalid = engine.firstInvalid()\n        if (firstInvalid !== null) {\n          const ids = engine.getFieldSnapshot(parsePath(firstInvalid)).ids\n          document.getElementById(ids.control)?.focus()\n        }\n      }\n    }\n    return outcome\n  }, [engine])\n}\n","import type { ComponentType, ReactNode } from 'react'\nimport { parsePath } from '@formancy/core'\nimport type { FieldDef, FieldType } from '@formancy/spec'\nimport { useFormEngine } from './context.js'\nimport { useField } from './use-field.js'\nimport type { FieldBinding } from './use-field.js'\nimport { useRepeater } from './use-repeater.js'\nimport { useSubmit } from './use-submit.js'\nimport { useWizard } from './use-wizard.js'\n\n/**\n * The component registry — theming mechanism number two. The schema decides\n * WHAT a field is; the registry decides what RENDERS it, with per-path entries\n * beating per-type entries beating the built-in defaults. A design system\n * replaces the entire visual layer by handing in a registry, without forking\n * anything.\n */\nexport interface FieldComponentProps {\n  path: string\n  label: string\n}\n\nexport type FieldComponent = ComponentType<FieldComponentProps>\n\nexport interface Registry {\n  byType?: Partial<Record<FieldType, FieldComponent>>\n  byPath?: Record<string, FieldComponent>\n}\n\nexport interface SubmitOutcome {\n  ok: boolean\n  errors: Record<string, string[]>\n  /** The canonical value, present when accepted. */\n  data?: unknown\n}\n\nexport interface FormancyFormProps {\n  /**\n   * Display text per wire path (row fields by their template wire,\n   * `items[].name`). A `label` on the model definition wins — that is how\n   * fixture schemas carry text until the spec's i18n section lands; a missing\n   * entry falls back to the wire path, which is at least honest.\n   */\n  labels?: Record<string, string>\n  registry?: Registry\n  submitLabel?: string\n  onSubmit?: (outcome: SubmitOutcome) => void\n}\n\n/**\n * Renders the whole form from the engine: one slot per field, resolved through\n * the registry. Slots subscribe individually, so a keystroke re-renders one\n * field and a visibility flip mounts or unmounts exactly the fields it hit.\n * A paged schema renders a stepper, one page at a time, navigation, and the\n * submit control on the last page — a failed submit navigates to the first\n * page with a problem instead of leaving the user on a clean review page\n * staring at a rejection.\n */\nexport function FormancyForm(props: FormancyFormProps) {\n  const engine = useFormEngine()\n  return engine.wizard() === undefined ? <FlatForm {...props} /> : <PagedForm {...props} />\n}\n\nfunction SubmitButton({ submitLabel, onSubmit, onFailedNavigate }: FormancyFormProps & { onFailedNavigate?: (page: number) => void }) {\n  const engine = useFormEngine()\n  const submit = useSubmit()\n  return (\n    <button\n      type=\"button\"\n      data-formancy-part=\"submit\"\n      onClick={() => {\n        const outcome = submit()\n        if (!outcome.ok && onFailedNavigate !== undefined) {\n          const firstInvalid = engine.firstInvalid()\n          if (firstInvalid !== null) onFailedNavigate(engine.pageOf(parsePath(firstInvalid)))\n        }\n        onSubmit?.(\n          outcome.ok\n            ? { ok: true, errors: outcome.errors, data: engine.value() }\n            : { ok: false, errors: outcome.errors },\n        )\n      }}\n    >\n      {submitLabel ?? 'Submit'}\n    </button>\n  )\n}\n\nfunction FlatForm(props: FormancyFormProps) {\n  return (\n    <>\n      <FieldList {...props} />\n      <SubmitButton {...props} />\n    </>\n  )\n}\n\nfunction PagedForm(props: FormancyFormProps) {\n  const engine = useFormEngine()\n  const wizard = useWizard()\n  const pages = engine.pages()\n  const lastPage = wizard.pageCount - 1\n\n  return (\n    <>\n      <nav data-formancy-part=\"stepper\" aria-label=\"Progress\">\n        <ol>\n          {pages.map((page, index) => (\n            <li key={page.key} aria-current={index === wizard.page ? 'step' : undefined}>\n              {engine.text(page.def.label) ?? page.key}\n            </li>\n          ))}\n        </ol>\n      </nav>\n      <FieldList {...props} page={wizard.page} />\n      <div data-formancy-part=\"wizard-nav\">\n        {wizard.page > 0 ? (\n          <button type=\"button\" onClick={() => wizard.back()}>\n            Back\n          </button>\n        ) : null}\n        {wizard.page < lastPage ? (\n          <button type=\"button\" onClick={() => void wizard.next()}>\n            Next\n          </button>\n        ) : (\n          <SubmitButton {...props} onFailedNavigate={(page) => wizard.goTo(page)} />\n        )}\n      </div>\n    </>\n  )\n}\n\nfunction FieldList({ labels, registry, page }: FormancyFormProps & { page?: number }) {\n  const engine = useFormEngine()\n  const repeaterWires = engine.repeaterPaths()\n\n  const inPage = (wire: string): boolean =>\n    page === undefined || engine.pageOf(parsePath(wire)) === page\n\n  // Row fields render inside their repeater's own section, never in the flat\n  // list — a row needs its remove button and its position context.\n  const staticWires = engine\n    .fieldPaths()\n    .filter((wire) => !repeaterWires.some((repeater) => wire.startsWith(`${repeater}[`)))\n\n  return (\n    <>\n      {staticWires.filter(inPage).map((wire) => (\n        <FieldSlot key={wire} path={wire} fallbackLabel={labels?.[wire]} registry={registry} />\n      ))}\n      {repeaterWires.filter(inPage).map((wire) => (\n        <RepeaterSection key={wire} wire={wire} labels={labels} registry={registry} />\n      ))}\n    </>\n  )\n}\n\nfunction FieldSlot({\n  path,\n  fallbackLabel,\n  registry,\n}: {\n  path: string\n  fallbackLabel?: string | undefined\n  registry?: Registry | undefined\n}) {\n  const field = useField(path)\n\n  // A hidden field leaves the DOM entirely: display:none would still ship the\n  // markup, keep it in the accessibility tree's shadow, and leak its labels\n  // to screen-reader \"read all\" passes.\n  if (!field.visible) return null\n\n  const Component =\n    registry?.byPath?.[path] ?? registry?.byType?.[field.type] ?? DEFAULT_COMPONENTS[field.type]\n  if (Component === null) return null\n\n  const label = field.label ?? fallbackLabel ?? path\n  return <Component path={path} label={label} />\n}\n\nfunction RepeaterSection({\n  wire,\n  labels,\n  registry,\n}: {\n  wire: string\n  labels?: Record<string, string> | undefined\n  registry?: Registry | undefined\n}) {\n  const engine = useFormEngine()\n  const repeater = useRepeater(wire)\n  const def = engine.repeaters().find((candidate) => candidate.wire === wire)?.def\n  const label = engine.text(def?.label) ?? labels?.[wire] ?? wire\n  const addLabel = def?.addLabel ?? `Add ${label}`\n  const removeLabel = def?.removeLabel ?? `Remove ${label}`\n\n  const fallbackFor = (instanceWire: string): string | undefined => {\n    const template = instanceWire.replace(/\\[\\d+\\]/, '[]')\n    return labels?.[template] ?? labels?.[instanceWire]\n  }\n\n  return (\n    <fieldset data-formancy-part=\"repeater\">\n      <legend data-formancy-part=\"repeater-legend\">{label}</legend>\n      {repeater.rowIds.map((rowId, index) => (\n        // Keyed by identity, not position: removing a row renumbers every row\n        // after it, and an index key would make React reuse the wrong DOM\n        // nodes — moving focus and animating the wrong element.\n        <div data-formancy-part=\"row\" key={rowId}>\n          {engine\n            .fieldPaths()\n            .filter((candidate) => candidate.startsWith(`${wire}[${index}]`))\n            .map((instanceWire) => (\n              <FieldSlot\n                key={instanceWire}\n                path={instanceWire}\n                fallbackLabel={fallbackFor(instanceWire)}\n                registry={registry}\n              />\n            ))}\n          {/* Position context in the NAME, so a screen-reader user knows which\n              row this button kills without walking the tree. */}\n          <button type=\"button\" onClick={() => repeater.removeRow(index)}>\n            {`${removeLabel} ${index + 1} of ${repeater.rowCount}`}\n          </button>\n        </div>\n      ))}\n      <button type=\"button\" onClick={() => repeater.addRow()}>\n        {addLabel}\n      </button>\n    </fieldset>\n  )\n}\n\n/** Shared unstyled shell: real label, control, error text as the describedby\n *  target. Zero CSS; `data-formancy-part` is the styling hook. */\nfunction FieldShell({\n  field,\n  label,\n  children,\n}: {\n  field: FieldBinding\n  label: string\n  children: ReactNode\n}) {\n  return (\n    <div\n      data-formancy-part=\"field\"\n      data-state={field.touched && field.errors.length > 0 ? 'invalid' : 'valid'}\n    >\n      <label data-formancy-part=\"label\" {...field.labelProps}>\n        {label}\n      </label>\n      {children}\n      {field.touched && field.errors.length > 0 ? (\n        <p data-formancy-part=\"error\" {...field.errorProps}>\n          {field.errors.join(', ')}\n        </p>\n      ) : null}\n    </div>\n  )\n}\n\nfunction TextField({ path, label }: FieldComponentProps) {\n  const field = useField(path)\n  return (\n    <FieldShell field={field} label={label}>\n      <input\n        type=\"text\"\n        {...field.controlProps}\n        value={typeof field.value === 'string' ? field.value : ''}\n        onChange={(event) => field.setValue(event.target.value)}\n        onBlur={() => field.touch()}\n      />\n    </FieldShell>\n  )\n}\n\nfunction TextareaField({ path, label }: FieldComponentProps) {\n  const field = useField(path)\n  return (\n    <FieldShell field={field} label={label}>\n      <textarea\n        {...field.controlProps}\n        value={typeof field.value === 'string' ? field.value : ''}\n        onChange={(event) => field.setValue(event.target.value)}\n        onBlur={() => field.touch()}\n      />\n    </FieldShell>\n  )\n}\n\nfunction NumberField({ path, label }: FieldComponentProps) {\n  const field = useField(path)\n  return (\n    <FieldShell field={field} label={label}>\n      <input\n        type=\"number\"\n        {...field.controlProps}\n        value={typeof field.value === 'number' ? field.value : ''}\n        onChange={(event) =>\n          field.setValue(event.target.value === '' ? null : event.target.valueAsNumber)\n        }\n        onBlur={() => field.touch()}\n      />\n    </FieldShell>\n  )\n}\n\nfunction CheckboxField({ path, label }: FieldComponentProps) {\n  const field = useField(path)\n  return (\n    <FieldShell field={field} label={label}>\n      <input\n        type=\"checkbox\"\n        {...field.controlProps}\n        checked={field.value === true}\n        onChange={(event) => field.setValue(event.target.checked)}\n        onBlur={() => field.touch()}\n      />\n    </FieldShell>\n  )\n}\n\nfunction DateField({ path, label }: FieldComponentProps) {\n  const field = useField(path)\n  return (\n    <FieldShell field={field} label={label}>\n      <input\n        type=\"date\"\n        {...field.controlProps}\n        value={typeof field.value === 'string' ? field.value : ''}\n        onChange={(event) => field.setValue(event.target.value === '' ? null : event.target.value)}\n        onBlur={() => field.touch()}\n      />\n    </FieldShell>\n  )\n}\n\n/**\n * Option labels resolved to strings, since a label may be a message reference.\n * Falling back to the stored value keeps an untranslated option selectable\n * rather than blank.\n */\nfunction useResolvedOptions(field: { def: FieldDef }): Array<{ value: string; label: string }> {\n  const engine = useFormEngine()\n  return (field.def.options ?? []).map((option) => ({\n    value: option.value,\n    label: engine.text(option.label) ?? option.value,\n  }))\n}\n\nfunction SelectField({ path, label }: FieldComponentProps) {\n  const field = useField(path)\n  const options = useResolvedOptions(field)\n  return (\n    <FieldShell field={field} label={label}>\n      {/* Setting `value` on the select works only because React applies it\n          AFTER the option children render; a select's value property is\n          settable once its options exist. Angular binds [selected] per option\n          for the same reason — the explicit form of the same contract. */}\n      <select\n        {...field.controlProps}\n        value={typeof field.value === 'string' ? field.value : ''}\n        onChange={(event) => field.setValue(event.target.value === '' ? null : event.target.value)}\n        onBlur={() => field.touch()}\n      >\n        {/* The empty option is the unanswered state; without it the browser\n            silently pre-selects the first real option, which the engine never\n            heard about. */}\n        <option value=\"\" />\n        {options.map((option) => (\n          <option key={option.value} value={option.value}>\n            {option.label}\n          </option>\n        ))}\n      </select>\n    </FieldShell>\n  )\n}\n\nfunction RadioGroupField({ path, label }: FieldComponentProps) {\n  const field = useField(path)\n  const options = useResolvedOptions(field)\n  const showError = field.touched && field.errors.length > 0\n  return (\n    <fieldset\n      data-formancy-part=\"field\"\n      data-state={showError ? 'invalid' : 'valid'}\n      aria-describedby={field.controlProps['aria-describedby']}\n    >\n      <legend data-formancy-part=\"label\">{label}</legend>\n      {options.map((option) => {\n        const optionId = `${field.ids.control}:${option.value}`\n        return (\n          <span key={option.value} data-formancy-part=\"radio-option\">\n            <input\n              type=\"radio\"\n              id={optionId}\n              name={field.controlProps.name}\n              value={option.value}\n              checked={field.value === option.value}\n              onChange={() => field.setValue(option.value)}\n              onBlur={() => field.touch()}\n            />\n            <label htmlFor={optionId}>{option.label}</label>\n          </span>\n        )\n      })}\n      {showError ? (\n        <p data-formancy-part=\"error\" {...field.errorProps}>\n          {field.errors.join(', ')}\n        </p>\n      ) : null}\n    </fieldset>\n  )\n}\n\n/**\n * The built-in unstyled components. `null` means the type renders nothing here:\n * hidden and static are non-inputs, and the container types are laid out by\n * their own machinery, not by a leaf slot.\n */\nconst DEFAULT_COMPONENTS: Record<FieldType, FieldComponent | null> = {\n  text: TextField,\n  textarea: TextareaField,\n  number: NumberField,\n  checkbox: CheckboxField,\n  date: DateField,\n  select: SelectField,\n  radio: RadioGroupField,\n  hidden: null,\n  static: null,\n  group: null,\n  page: null,\n  repeater: null,\n}\n","import { useCallback, useEffect, useRef, useSyncExternalStore } from 'react'\nimport { parsePath } from '@formancy/core'\nimport { useFormEngine } from './context.js'\n\nexport interface ErrorSummaryProps {\n  labels?: Record<string, string>\n}\n\n/**\n * The error summary a failed submit focuses.\n *\n * The semantics are deliberate and easy to get wrong: the container takes\n * focus via tabindex=\"-1\" — focusing it already makes screen readers announce\n * it, so role=\"alert\" would announce it TWICE. Each entry is a real in-page\n * link to the offending control, because links are what \"take me to the\n * problem\" already means to assistive tech.\n */\nexport function ErrorSummary({ labels }: ErrorSummaryProps) {\n  const engine = useFormEngine()\n  const subscribe = useCallback((onChange: () => void) => engine.subscribe(onChange), [engine])\n  const getErrors = useCallback(() => engine.visibleErrors(), [engine])\n  const errors = useSyncExternalStore(subscribe, getErrors, getErrors)\n  const region = useRef<HTMLDivElement | null>(null)\n  const previousCount = useRef(0)\n\n  // Focus when errors APPEAR (a submit surfaced them), not on every keystroke\n  // that edits an already-broken field.\n  useEffect(() => {\n    if (errors.length > 0 && previousCount.current === 0) region.current?.focus()\n    previousCount.current = errors.length\n  }, [errors])\n\n  if (errors.length === 0) return null\n\n  const labelFor = (path: string): string =>\n    labels?.[path] ?? labels?.[path.replace(/\\[\\d+\\]/, '[]')] ?? path\n\n  return (\n    <div data-formancy-part=\"error-summary\" tabIndex={-1} ref={region}>\n      <h2 data-formancy-part=\"error-summary-heading\">\n        {errors.length === 1 ? 'There is 1 problem to fix' : `There are ${errors.length} problems to fix`}\n      </h2>\n      <ul>\n        {errors.map(({ path, codes }) => {\n          const controlId = engine.getFieldSnapshot(parsePath(path)).ids.control\n          return (\n            <li key={path}>\n              <a\n                href={`#${controlId}`}\n                onClick={(event) => {\n                  // The hash alone scrolls but does not focus; do both.\n                  event.preventDefault()\n                  document.getElementById(controlId)?.focus()\n                }}\n              >\n                {`${labelFor(path)}: ${codes.join(', ')}`}\n              </a>\n            </li>\n          )\n        })}\n      </ul>\n    </div>\n  )\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@formancy/react",
+  "version": "0.1.0",
+  "description": "Idiomatic React binding for the formancy form engine.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "@formancy/conformance": "0.1.0",
+    "@formancy/core": "0.1.0",
+    "@formancy/spec": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@testing-library/react": "^16.3.3",
+    "@testing-library/user-event": "^14.6.7",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "jsdom": "^30.1.0",
+    "publint": "^0.3.24",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "tsdown": "^0.23.0",
+    "typescript": "~6.0.3",
+    "unrun": "^0.3.1",
+    "vitest": "^5.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sharkysan/formancy.ai.git",
+    "directory": "packages/react"
+  },
+  "homepage": "https://github.com/sharkysan/formancy.ai",
+  "bugs": "https://github.com/sharkysan/formancy.ai/issues",
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "check:pkg": "publint && attw --pack . --profile esm-only"
+  }
+}