Oxform CoreCopy Anchor Link

@oxform/core exposes forms independently of a UI framework. Its values, status, validation, reset, and array contracts also apply to React and Solid bindings.

FormCopy Anchor Link

createForm(options) and new FormApi(options)Copy Anchor Link

Create a form from a Standard Schema validator and matching initial values. createForm infers issue levels from checks keys; direct class construction permits explicit value and level generics.

import { createForm, formOptions } from '@oxform/core';
import { z } from 'zod';

const options = formOptions({
  schema: z.object({ email: z.string(), tags: z.array(z.string()) }),
  defaultValues: { email: '', tags: ['alpha'] },
});
const form = createForm(options);

form.field.change('email', 'ada@example.com');
form.array.append('tags', 'beta');

Direct constructors expose the same core APIs. Supply class generics when you need precise value types; the factories infer them from the schema and field path.

import { ArrayFieldApi, FieldApi, FormApi } from '@oxform/core';
import { z } from 'zod';

const schema = z.object({ email: z.string(), tags: z.array(z.string()) });
const form = new FormApi<z.input<typeof schema>>({
  schema,
  defaultValues: { email: '', tags: [] },
});
const email = new FieldApi<string>({ form, name: 'email' });
const tags = new ArrayFieldApi<string[]>({ form, name: 'tags' });

email.change('ada@example.com');
tags.append('customer');

formOptions(options)Copy Anchor Link

Returns the supplied configuration, preserving inferred value and issue-level types. It does not create form state or run validation. Both @oxform/react and @oxform/solid re-export it.

Properties and MethodsCopy Anchor Link

The form reference describes each option, reset flag, and submit transition. The validation guide covers events, field scopes, replacement, and asynchronous results. Core reads are snapshots; subscribe through store.subscribe or createEffect to observe changes.

FieldCopy Anchor Link

createField({ form, name }) and new FieldApi(options)Copy Anchor Link

Return an API bound to one path. Prefer the factory for path-to-value and issue-level inference.

import { createField, createForm } from '@oxform/core';
import { z } from 'zod';

const form = createForm({ schema: z.object({ email: z.string() }), defaultValues: { email: '' } });
const email = createField({ form, name: 'email' });

email.change(current => current.trim());
email.focus({ should: { validate: false } });
email.blur();
email.get();
email.issues();
email.setIssues({ error: [{ level: 'error', issue: { message: 'Already registered' } }] });
email.reset();

The bound API exposes options, id, value, state, and store properties. Its methods are get, change, focus, blur, register, unregister, issues, setIssues, and reset. It exposes '~mount' and '~update' for adapters. It does not expose framework input props.

form.fieldCopy Anchor Link

Bound methods have the same behavior with the name argument omitted. For status use field.state.status; for registration call field.register(element). See the field reference for change flags, issue modes, and reset limitations.

Array FieldCopy Anchor Link

createArrayField({ form, name }) and new ArrayFieldApi(options)Copy Anchor Link

Return an API bound to an array-valued path. The factory infers its array value, item value, and issue levels.

import { createArrayField, createForm } from '@oxform/core';
import { z } from 'zod';

const form = createForm({ schema: z.object({ tags: z.array(z.string()) }), defaultValues: { tags: ['alpha'] } });
const tags = createArrayField({ form, name: 'tags' });

tags.append('beta');
tags.prepend('first');
tags.insert(1, 'middle');
tags.swap(0, 1);
tags.move(0, 2);
tags.update(0, current => current.toUpperCase());
tags.remove(0);
tags.replace(['alpha']);
tags.get();
tags.ids;

Properties are options, store, state, and ids. It also exposes '~mount' and '~update'. Read array values with get() or state.value; there is no value shortcut.

form.array exposes the same mutations with the path as the first argument, for example form.array.insert('tags', 0, 'alpha'). Read values through form.field.get('tags'). See the array reference for item identity, index normalization, updater behavior, and validation exceptions.

EffectCopy Anchor Link

createEffect(api, selector, callback)Copy Anchor Link

Observes selected form, field, or array state. It skips the initial value and invokes the callback only when the selection changes by deep equality. Returns a subscription with unsubscribe(). Async callbacks may overlap.

import { createEffect, createForm } from '@oxform/core';
import { z } from 'zod';

const form = createForm({ schema: z.object({ email: z.string() }), defaultValues: { email: '' } });
const subscription = createEffect(
  form,
  state => state.values.email,
  email => {
    console.info(email);
  },
);

form.field.change('email', 'ada@example.com');
subscription.unsubscribe();

Public TypesCopy Anchor Link

See TypeScript for schema-derived paths and values. React re-exports many core types, but the core class constructors and factories are runtime imports from @oxform/core.

SignaturesCopy Anchor Link