feature-form 0.0.59 → 0.1.0

package/MIGRATION.md

@@ -0,0 +1,153 @@
+# Migration Guide
+
+## 0.0.x to 0.1.0
+
+`feature-form` now uses Standard Schema validators directly and the shared `.with(feature())` composition model from `feature-core`. The form model is still framework-agnostic, but validation setup, status values, submit callbacks, and helper exports changed.
+
+### Use Standard Schema Directly
+
+Validation adapters such as `zValidator`, `vValidator`, and `createValidator` are no longer used by `feature-form`.
+
+Pass a Standard Schema-compatible schema directly:
+
+```ts
+import { createForm } from 'feature-form';
+import { z } from 'zod';
+
+const form = createForm({
+  fields: {
+    email: {
+      defaultValue: '',
+      validator: z.string().email()
+    }
+  }
+});
+```
+
+Zod, Valibot, ArkType, and other Standard Schema-compatible validators can be used without wrapping.
+
+### Replace Validation Mode Flags
+
+The old bitwise `validateMode` and `reValidateMode` flags were removed.
+
+Use `validateOn` and `revalidateOn` string arrays:
+
+```ts
+// old
+createForm({
+  fields: {
+    email: {
+      defaultValue: '',
+      validator,
+      validateMode: VALIDATION_MODE.BLUR,
+      reValidateMode: VALIDATION_MODE.CHANGE
+    }
+  }
+});
+
+// new
+createForm({
+  fields: {
+    email: {
+      defaultValue: '',
+      validator,
+      validateOn: ['blur'],
+      revalidateOn: ['change']
+    }
+  }
+});
+```
+
+Form-created fields now default to `submit` validation and `change` revalidation.
+
+### Update Status Checks
+
+Status values are now lowercase.
+
+| Old status    | New status    |
+| ------------- | ------------- |
+| `UNVALIDATED` | `unvalidated` |
+| `VALID`       | `valid`       |
+| `INVALID`     | `invalid`     |
+
+```ts
+const status = form.fields.email.status.get();
+
+if (status.type === 'invalid') {
+  console.error(status.errors[0]?.message);
+}
+```
+
+Field errors now use `{ message, path?: PropertyKey[] }`. The old `{ code, message?, path?: string }` shape was removed.
+
+### Use Form-Level Status Instead Of `isValid`
+
+Form and field `isValid()` helpers were removed.
+
+Use reactive status state instead:
+
+```ts
+const formStatus = form.status.get();
+
+if (formStatus.type === 'valid') {
+  // Submit or continue.
+}
+```
+
+Fields with validators start as `unvalidated`. Forms without validators start as `valid`.
+
+### Update Submit Callbacks
+
+Submit callbacks now return `void | Promise<void>`. The old `TSubmitCallbackResponse`, `TSubmitData`, `postSubmitCallback`, and return-object aggregation model was removed.
+
+`assignToInitial` was replaced by `submit({ updateDefaultValues: true })`:
+
+```ts
+await form.submit({
+  updateDefaultValues: true,
+  onValidSubmit: async (values) => {
+    await saveProfile(values);
+  }
+});
+```
+
+Use form-level `isSubmitting` instead of field-level `isSubmitting`.
+
+### Update Error Collection
+
+`getErrors()` now returns grouped errors:
+
+```ts
+const errors = form.getErrors();
+
+console.log(errors.fields.email);
+console.log(errors.form);
+```
+
+The old flat field-keyed object was removed. Unvalidated fields are omitted instead of returned as synthetic errors.
+
+### Replace Change Helpers With `dirtyFeature`
+
+`hasFormChanged()` was removed.
+
+Use `dirtyFeature()` when you need reactive dirty state:
+
+```ts
+import { createForm, dirtyFeature } from 'feature-form';
+
+const form = createForm({
+  fields: {
+    name: { defaultValue: '' }
+  }
+}).with(dirtyFeature());
+
+form.isDirty.get();
+form.dirtyFields.get();
+form.resetDirty();
+```
+
+### Removed Exports
+
+The root export no longer includes `BitwiseFlag`, `bitwiseFlag`, `helper/*`, `form-field/*` barrels, or `isFormWithFeatures`.
+
+Use the root exports for `createForm`, `createFormField`, `dirtyFeature`, and public types. Deep imports from old `dist/.../form-field`, `dist/.../helper`, or split `types/*` paths are not supported.

package/README.md

@@ -17,98 +17,420 @@
     </a>
 </p>
 
-> Status: Experimental
+`feature-form` is framework-agnostic form state built from reactive fields. It uses Standard Schema validators directly, lets each field choose when validation runs, and keeps submit handling on the form object.
 
-`feature-form` is a straightforward, typesafe, and feature-based form library.
+- Validate with Zod, Valibot, ArkType, or any [Standard Schema](https://github.com/standard-schema/standard-schema) validator without resolver packages
+- Tune validation per field: stay quiet while typing, validate on blur or submit, then revalidate on change
+- Subscribe only to the state a view renders: value, status, touched, submitted, dirty
+- Add typed behavior with `.with()` features, including built-in dirty tracking
 
-- **Lightweight & Tree Shakable**: Function-based and modular design
-- **Fast**: Optimized for speed and efficiency, ensuring smooth user experience
-- **Modular & Extendable**: Easily extendable with features
-- **Typesafe**: Build with TypeScript for strong type safety
-- **Standalone**: Zero external dependencies, ensuring ease of use in various environments
+```ts
+import { createForm, dirtyFeature } from 'feature-form';
+import * as z from 'zod';
 
-### 📚 Examples
+const $form = createForm({
+  fields: {
+    email: {
+      defaultValue: '',
+      validator: z.string().email(),
+      validateOn: ['blur', 'submit'], // no errors while typing
+      revalidateOn: ['change', 'submit'] // revalidate after first submit
+    },
+    password: {
+      defaultValue: '',
+      validator: z.string().min(8),
+      validateOn: ['touched', 'submit'], // first blur, subsequent changes, and submit
+      revalidateOn: ['change', 'submit']
+    }
+  },
+  onValidSubmit: (data) => console.log(data)
+}).with(dirtyFeature());
 
-- [ReactJs Basic](https://github.com/builder-group/community/tree/develop/examples/feature-form/react/basic) ([Code Sandbox](https://codesandbox.io/p/sandbox/basic-c4gd3t))
+const unbind = $form.fields.email.status.listen(({ value }) => {
+  if (value.type === 'invalid') {
+    console.log(value.errors[0].message);
+  }
+});
 
-### 🌟 Motivation
+$form.fields.email.set('not-an-email');
+$form.fields.email.blur(); // validates email and notifies the status listener
+
+await $form.submit(); // runs submit-triggered validators and calls onValidSubmit when valid
+$form.isDirty.get(); // true if any field differs from its default value
+unbind();
+```
+
+Migrating from `0.0.x`? See [MIGRATION.md](./MIGRATION.md).
+
+## Install
+
+```bash
+npm install feature-form
+```
 
-Create a typesafe, straightforward, and lightweight form library designed to be modular and extendable with features.
+Examples use Zod, but any Standard Schema validator works:
 
-### ⚖️ Alternatives
+```bash
+npm install zod
+```
 
-- [react-hook-form](https://github.com/react-hook-form/react-hook-form)
+## Usage
 
-## 📖 Usage
+Fields are reactive states. Subscribe to status changes to wire validation feedback directly into your UI:
 
-```tsx
+```ts
 import { createForm } from 'feature-form';
-import { useForm } from 'feature-react/form';
-import * as v from 'valibot';
-import { vValidator } from 'validation-adapters/valibot';
-import { zValidator } from 'validation-adapters/zod';
 import * as z from 'zod';
 
-interface TFormData {
-	name: string;
-	email: string;
-}
+const $form = createForm({
+  fields: {
+    email: { defaultValue: '', validator: z.string().email() }
+  },
+  onValidSubmit: (data) => console.log(data)
+});
+
+$form.fields.email.status.listen(({ value }) => {
+  if (value.type === 'invalid') {
+    console.log(value.errors[0].message);
+  }
+});
+
+$form.fields.email.set('not-an-email'); // set() alone does not validate (validateOn defaults to ['submit'])
+await $form.submit(); // triggers validation, listener fires with error
+```
+
+Control when validation fires with per-field triggers. Keep errors quiet before the user has finished, then switch to immediate feedback once they have tried to submit:
+
+```ts
+const $form = createForm({
+  fields: {
+    email: {
+      defaultValue: '',
+      validator: z.string().email(),
+      validateOn: ['blur', 'submit'], // quiet while typing, fires on blur
+      revalidateOn: ['change', 'submit'] // immediate feedback after first submit
+    }
+  }
+});
+```
+
+## Form
+
+### `createForm(config)`
+
+Creates a form and returns it as a feature host. Each key in `fields` becomes a reactive `TFormField` with validation, blur tracking, and status.
+
+```ts
+const $form = createForm({
+  fields: {
+    age: { defaultValue: 0 },
+    username: {
+      defaultValue: '',
+      validator: z.string().min(3),
+      validateOn: ['submit', 'blur'],
+      revalidateOn: ['submit', 'change', 'blur']
+    }
+  }
+});
+```
+
+| Option             | Default                | Description                                                                                              |
+| ------------------ | ---------------------- | -------------------------------------------------------------------------------------------------------- |
+| `fields`           | required               | Field configs or pre-built fields keyed by form data property.                                           |
+| `validator`        | none                   | Form-level validator for cross-field constraints.                                                        |
+| `validateOn`       | `['submit']`           | Default triggers for the form validator and fields that do not override them.                            |
+| `revalidateOn`     | `['submit', 'change']` | Default revalidation triggers for the form validator and fields that do not override them.               |
+| `collectErrorMode` | `'firstError'`         | Default Standard Schema error collection mode for the form validator and fields that do not override it. |
+| `onValidSubmit`    | none                   | Called on every valid submit. Per-call overrides can be passed to `submit()`.                            |
+| `onInvalidSubmit`  | none                   | Called on every invalid submit. Per-call overrides can be passed to `submit()`.                          |
+
+**Field config options**
+
+| Option             | Default                | Description                                                                      |
+| ------------------ | ---------------------- | -------------------------------------------------------------------------------- |
+| `defaultValue`     | required               | Initial value and reset target.                                                  |
+| `validator`        | none                   | Field-level validator.                                                           |
+| `validateOn`       | `['submit']`           | Triggers that run the validator before the first submit.                         |
+| `revalidateOn`     | `['submit', 'change']` | Triggers that run the validator after the first submit.                          |
+| `collectErrorMode` | `'firstError'`         | `'firstError'` keeps the first Standard Schema issue; `'all'` keeps every issue. |
+
+### `submit()` / `validate()` / `reset()`
+
+```ts
+const isValid = await $form.submit();
 
-const $form = createForm<TFormData>({
-	fields: {
-		name: {
-			validator: zValidator(z.string().min(2).max(10)),
-			defaultValue: ''
-		},
-		email: {
-			validator: vValidator(v.pipe(v.string(), v.email())),
-			defaultValue: ''
-		}
-	},
-	onValidSubmit: (data) => console.log('ValidSubmit', data),
-	onInvalidSubmit: (errors) => console.log('InvalidSubmit', errors)
+await $form.submit({
+  onValidSubmit: (data) => console.log(data),
+  onInvalidSubmit: (errors) => console.error(errors),
+  updateDefaultValues: true, // treat submitted values as new reset baseline
+  context: { source: 'settings-form' } // passed through to submit callbacks
 });
 
-export const MyFormComponent: React.FC = () => {
-	const { handleSubmit, register, status } = useForm($form);
+const unbind = $form.onValidSubmit((data) => console.log(data));
+unbind();
+
+const isValid = await $form.validate(); // runs all validators without submitting
+
+$form.reset(); // resets values, validation status, isTouched, and isSubmitted
+```
+
+`submit()` runs validators configured for the submit trigger. All matching field validators and the form validator run together. No failing validator prevents the others from completing, so submit gives you a complete error picture for validators that ran. Returns `true` if the form was valid, `false` otherwise. Persistent callbacks registered via `onValidSubmit()` / `onInvalidSubmit()` and per-call options passed to `submit()` both run in parallel.
+
+`validate()` runs all validators the same way but has no submit side effects: it updates validation state, but does not set `isSubmitted`, does not fire `onValidSubmit` or `onInvalidSubmit`, and does not update default values.
+
+`reset()` restores all fields to their `defaultValue` and clears `status`, `isTouched`, and `isSubmitted` on both the form and every field. Any in-flight async validation is invalidated so stale results cannot update field status.
+
+### `getData()` / `getValidData()` / `getErrors()`
+
+```ts
+const data = $form.getData(); // current field values, regardless of validity
+const data = $form.getValidData(); // current field values, or null if form status is not 'valid'
+
+const errors = $form.getErrors();
+errors.fields; // invalid fields and form-level errors whose path points at a field
+errors.form; // pathless or unknown-path form-level errors
+```
 
-	return (
-		<form onSubmit={handleSubmit()}>
-			<div>
-				<label>Name</label>
-				<input {...register('name')} />
-				{status('name').error && <span>{status('name').error}</span>}
-			</div>
-			<div>
-				<label>Email</label>
-				<input {...register('email')} />
-				{status('email').error && <span>{status('email').error}</span>}
-			</div>
-			<button type="submit">Submit</button>
-		</form>
-	);
-};
+### `fields` / `getField(key)`
+
+```ts
+$form.fields.name; // TFormField<string>
+$form.getField('name'); // same, useful when the key is dynamic
 ```
 
-### Validators ([`validation-adapters`](https://github.com/builder-group/community/tree/develop/packages/validation-adapters))
+### Reactive states
+
+| State          | Type                | Description                                                  |
+| -------------- | ------------------- | ------------------------------------------------------------ |
+| `status`       | `TValidationStatus` | Aggregate form status: `unvalidated`, `valid`, or `invalid`. |
+| `isValidating` | `TState<boolean>`   | True while the latest validation run is pending.             |
+| `isSubmitted`  | `TState<boolean>`   | True after the first submit attempt.                         |
+| `isSubmitting` | `TState<boolean>`   | True while `submit()` is in progress.                        |
+
+### Validation triggers
+
+`validateOn` controls which events run the validator before the first submit. `revalidateOn` controls the same after the first submit.
+
+| Trigger     | When it fires                                                                                                       |
+| ----------- | ------------------------------------------------------------------------------------------------------------------- |
+| `'submit'`  | On `submit()`.                                                                                                      |
+| `'blur'`    | On every `blur()`.                                                                                                  |
+| `'change'`  | On every value change via `set()`.                                                                                  |
+| `'touched'` | On the first `blur()`, and on every subsequent `set()` once the field has been touched. Only valid in `validateOn`. |
 
-`feature-form` supports various validators such as [Zod](https://github.com/colinhacks/zod), [Yup](https://github.com/jquense/yup), [Valibot](https://github.com/fabian-hiller/valibot) and more.
+The `'touched'` trigger covers the "validate once the user has interacted" pattern: no validation fires until the first blur, then validation follows every change from that point on. In `revalidateOn` use `'blur'` instead.
+
+```ts
+// validate on blur before submit, revalidate on every change after
+const $form = createForm({
+  fields: {
+    email: {
+      defaultValue: '',
+      validator: z.string().email(),
+      validateOn: ['blur', 'submit'],
+      revalidateOn: ['change', 'submit']
+    }
+  }
+});
+```
+
+### Form-level validator
+
+Use `validator` for cross-field constraints. `validateOn`, `revalidateOn`, and `collectErrorMode` are shared defaults for the form validator and field validators unless a field overrides them.
+
+The library routes form-level validator errors by path. An issue that points at a field appears in `getErrors().fields` and in the matching field's `status`, with the field key stripped from the path. Pathless issues and paths with no matching field appear in `getErrors().form`.
+
+```ts
+const $form = createForm({
+  fields: {
+    password: { defaultValue: '' },
+    confirm: { defaultValue: '' }
+  },
+  validator: z
+    .object({ password: z.string(), confirm: z.string() })
+    .refine((d) => d.password === d.confirm, {
+      message: 'Passwords do not match',
+      path: ['confirm']
+    }),
+  validateOn: ['submit'],
+  revalidateOn: ['change', 'submit']
+});
+```
+
+### Validation status
+
+Both `form.status` and `field.status` are discriminated unions:
+
+```ts
+const status = $form.fields.email.status.get();
+
+if (status.type === 'invalid') {
+  status.errors; // readonly TValidationError[]
+  status.errors[0].message; // string
+  status.errors[0].path; // validator path, e.g. ['address', 'city']
+}
+```
+
+| `type`          | Meaning                                         |
+| --------------- | ----------------------------------------------- |
+| `'unvalidated'` | No validator has run yet.                       |
+| `'valid'`       | Last run passed.                                |
+| `'invalid'`     | Last run failed; `errors` contains the details. |
+
+### Validators
+
+Any [Standard Schema](https://github.com/standard-schema/standard-schema) compatible validator works directly without an adapter.
 
 ```ts
 import * as v from 'valibot';
-import { vValidator } from 'validation-adapters/valibot';
-import { zValidator } from 'validation-adapters/zod';
 import * as z from 'zod';
 
-const zodNameValidator = zValidator(
-	z
-		.string()
-		.min(2)
-		.max(10)
-		.regex(/^([^0-9]*)$/)
-);
+const zodValidator = z.string().min(2).max(50);
+const valibotValidator = v.pipe(v.string(), v.minLength(2), v.maxLength(50));
+```
+
+For custom validators, implement the `StandardSchemaV1` interface from [`@standard-schema/spec`](https://github.com/standard-schema/standard-schema).
+
+Validators run for validation only. If a schema transforms or coerces output values, the parsed output does not write back into the field state. `getValidData()` and submit callbacks keep returning the current field values.
+
+## Field
+
+Each entry in `form.fields` is a `TFormField<GValue>`: a full `feature-state` state with form-specific methods added.
+
+### `createFormField(defaultValue, config)`
+
+Creates a field independently of any form. Use this for a shared search input or a field conditionally composed into different forms. `config.key` is required because validation errors use it for path routing. Pass the resulting `TFormField` directly into the `createForm` fields config.
+
+```ts
+import { createFormField } from 'feature-form';
+
+const $name = createFormField('', {
+  key: 'name',
+  validator: z.string().min(2),
+  validateOn: ['blur'],
+  revalidateOn: ['change']
+});
+
+$name.set('Alice');
+await $name.validate();
+```
+
+### `set()` / `get()` / `value`
 
-const valibotNameValidator = vValidator(
-	v.pipe(v.string(), v.minLength(2), v.maxLength(10), v.regex(/^([^0-9]*)$/))
-);
+```ts
+$form.fields.name.set('Alice');
+$form.fields.name.get(); // 'Alice'
+$form.fields.name.value; // 'Alice'
+$form.fields.name.value = 'Bob'; // same as set('Bob')
+```
+
+### `blur()` / `validate()` / `reset()`
+
+```ts
+$form.fields.name.blur(); // marks touched, runs blur/touched validators
+await $form.fields.name.validate(); // runs the field validator, returns true if valid
+$form.fields.name.reset(); // resets value, touched, submitted, and status
+```
+
+### `onBlur(callback)`
+
+```ts
+const unbind = $form.fields.name.onBlur(({ wasTouched }) => {
+  if (!wasTouched) {
+    // first time this field was blurred
+  }
+});
+
+unbind();
+```
+
+### Reactive states
+
+| State          | Type                | Description                                                                          |
+| -------------- | ------------------- | ------------------------------------------------------------------------------------ |
+| `status`       | `TValidationStatus` | Field display status, including field validator errors and routed form-level errors. |
+| `isTouched`    | `TState<boolean>`   | True after the field has been blurred at least once.                                 |
+| `isSubmitted`  | `TState<boolean>`   | True after the form has been submitted.                                              |
+| `isValidating` | `TState<boolean>`   | True while the field validator is running.                                           |
+
+### `defaultValue` / `key`
+
+```ts
+$form.fields.name.defaultValue; // the value used when reset() is called
+$form.fields.name.key; // 'name', used in validation error paths
 ```
+
+## Built-in Features
+
+Features are installed via `.with()` and extend the form with new methods.
+
+### `dirtyFeature()`
+
+Adds `isDirty`, `dirtyFields`, and `resetDirty()`. Tracks whether each field differs from its default value. By default it compares primitives, arrays, and plain objects structurally. Pass `dirtyFeature({ isEqual })` for other value types.
+
+```ts
+import { dirtyFeature } from 'feature-form';
+
+const $form = createForm({
+  fields: {
+    name: { defaultValue: 'Alice' },
+    email: { defaultValue: 'alice@example.com' }
+  }
+}).with(dirtyFeature());
+
+$form.fields.name.set('Bob');
+
+$form.isDirty.get(); // true
+$form.dirtyFields.get(); // { name: true, email: false }
+
+$form.resetDirty(); // updates each field's defaultValue to its current value
+$form.isDirty.get(); // false
+```
+
+`isDirty` and `dirtyFields` are reactive states. `resetDirty()` makes the current values the new baseline without clearing them. When `submit({ updateDefaultValues: true })` succeeds, dirty state clears automatically.
+
+## Extending with Features
+
+Forms are `feature-core` feature hosts. Add behavior with `.with(yourFeature())`. See the [feature-core README](https://github.com/builder-group/community/tree/develop/packages/feature-core) for a full guide on `defineFeature()`, dependency declaration, and the feature model.
+
+## Examples
+
+- [React Basic](https://github.com/builder-group/community/tree/develop/examples/feature-form/react/basic) ([CodeSandbox](https://codesandbox.io/p/sandbox/basic-c4gd3t))
+
+## FAQ
+
+### How does it compare to react-hook-form, Formik, and TanStack Form?
+
+`feature-form` puts the form object outside the UI framework. That makes it closer to a reactive model than a React hook. Use it when you want one form core that can be reused across React, Vue, Svelte, tests, and plain JavaScript.
+
+- [react-hook-form](https://github.com/react-hook-form/react-hook-form): strong React-first uncontrolled form library with validation resolvers
+- [Formik](https://formik.org): mature controlled React form library
+- [TanStack Form](https://tanstack.com/form): framework-agnostic form library with official framework adapters
+
+### Does it work outside React?
+
+Yes. The form and field objects are plain JavaScript. Fields are reactive states from `feature-state`, which has no framework dependency. Subscribe with `.listen()` in Vue, Svelte, vanilla JS, or any runtime. The [feature-react](https://github.com/builder-group/community/tree/develop/packages/feature-react) package provides React hooks if you want them.
+
+### Why separate `validateOn` and `revalidateOn`?
+
+Before the first submit, aggressive validation (e.g. `'change'`) can feel intrusive because the user has not finished yet. After submit they expect immediate feedback as they correct errors. Keeping the phases separate lets you configure each independently without a single `mode` flag that tries to cover both.
+
+### Does it support async validators?
+
+Yes. Any Standard Schema validator can be async. `submit()` and `validate()` are both async and await all validators. The `isValidating` state on both the form and each field reflects whether a run is in progress. In-flight async runs are invalidated by run ID when `reset()` is called, so stale results never overwrite reset state.
+
+### Do all field validators run on submit, or does it stop at the first error?
+
+All validators configured for the submit trigger run together. No failing submit-triggered validator skips the others, so submit gives a complete picture of every submit-triggered validation error.
+
+### What does `getErrors()` return before any validation has run?
+
+Only fields with `'invalid'` status or form-level path errors appear in `errors.fields`. Unvalidated fields are omitted. `errors.form` contains only pathless form-level errors.
+
+### Can I register multiple `onValidSubmit` callbacks?
+
+Yes. Callbacks registered via `form.onValidSubmit(callback)` are additive. On submit, all persistent callbacks and any per-call callback passed to `submit({ onValidSubmit })` run in parallel. There is no guaranteed order between them.
+
+### When should I use `createFormField` instead of defining fields inside `createForm`?
+
+Use `createFormField` when a field needs to exist independently of any specific form: a shared search input, or a field conditionally composed into different forms. Pass the resulting `TFormField` directly into the `createForm` fields config.

package/dist/cjs/create-form-field.js

@@ -0,0 +1 @@
+"use strict";var v=require("feature-core"),n=require("feature-state"),f=require("./lib/deep-copy.js"),_=require("./lib/standard-schema.js"),y=require("./lib/validation-status.js"),g=(t,e,l)=>new Promise((o,r)=>{var i=d=>{try{s(l.next(d))}catch(c){r(c)}},a=d=>{try{s(l.throw(d))}catch(c){r(c)}},s=d=>d.done?o(d.value):Promise.resolve(d.value).then(i,a);s((l=l.apply(t,e)).next())});function m(t,e){const{key:l,validator:o,validateOn:r=["submit"],revalidateOn:i=["submit","change"],collectErrorMode:a="firstError"}=e,s=n.createState(t).with(p({key:l,validation:o==null?void 0:{validator:o,config:{validateOn:r,revalidateOn:i,collectErrorMode:a}}}));return V(s),s}function S(t){return v.hasFeature(t,"form-field")}function p(t){const{key:e,validation:l}=t;return v.defineFeature({key:"form-field",install(o){const r=l==null?{type:"valid"}:{type:"unvalidated"};return{_validation:l,_validationRunId:0,_fieldValidatorStatus:r,_formValidatorErrors:[],_callbacks:{blur:[]},key:e,defaultValue:f.deepCopy(o._v),isTouched:n.createState(!1),isSubmitted:n.createState(!1),isValidating:n.createState(!1),status:n.createState(r).with(n.isEqualFeature(y.areValidationStatusesEqual)),_applyFormValidatorErrors(i){this._formValidatorErrors=i,this.status.set(u(this))},validate(){return g(this,null,function*(){if(this._validation==null)return this._fieldValidatorStatus={type:"valid"},this.status.set(u(this)),this.status.get().type==="valid";const i=++this._validationRunId;let a={type:"valid"};this.isValidating.set(!0);try{a=yield _.validateStandardSchema(this._validation.validator,this.get(),this._validation.config.collectErrorMode)}catch(s){a={type:"invalid",errors:[{message:s instanceof Error?s.message:String(s)}]}}finally{i===this._validationRunId&&this.isValidating.set(!1)}return i!==this._validationRunId?this.status.get().type==="valid":(this._fieldValidatorStatus=a,this.status.set(u(this)),this.status.get().type==="valid")})},onBlur(i){return this._callbacks.blur.push(i),()=>{const a=this._callbacks.blur.indexOf(i);a!==-1&&this._callbacks.blur.splice(a,1)}},blur(){const i=this.isTouched.get();this._validation!=null&&(this.isSubmitted.get()?this._validation.config.revalidateOn.includes("blur"):this._validation.config.validateOn.includes("blur")||this._validation.config.validateOn.includes("touched")&&!i)&&this.validate(),this.isTouched.set(!0);for(const a of this._callbacks.blur)a({wasTouched:i})},reset(){this.set(f.deepCopy(this.defaultValue),{listenerContext:{source:h}}),this._validationRunId++,this.isTouched.set(!1),this.isSubmitted.set(!1),this.isValidating.set(!1),this._formValidatorErrors=[],this._fieldValidatorStatus=this._validation==null?{type:"valid"}:{type:"unvalidated"},this.status.set(u(this))}}}})}const h="formFieldReset";function V(t){t.listen(({source:e})=>{e!==h&&t._validation!=null&&(t.isSubmitted.get()?t._validation.config.revalidateOn.includes("change"):t._validation.config.validateOn.includes("change")||t._validation.config.validateOn.includes("touched")&&t.isTouched.get())&&t.validate()})}function u(t){const e=t._fieldValidatorStatus.type==="invalid"?[...t._fieldValidatorStatus.errors,...t._formValidatorErrors]:t._formValidatorErrors;return e.length>0?{type:"invalid",errors:e}:t._fieldValidatorStatus}exports.createFormField=m,exports.formFieldResetSourceKey=h,exports.isFormField=S;