@octanejs/formisch 0.0.1

package/src/core/framework/index.ts

@@ -0,0 +1,80 @@
+/*
+ * Vendored from Formisch 1.0.0-rc.0, commit
+ * 4c494fd8cf105efd04a4b179e9c090595a0bf041.
+ * This is the React-generated signal protocol with an Octane framework tag.
+ */
+import type { Signal } from '../types/signal/index.ts';
+
+export type Framework =
+	'angular' | 'octane' | 'preact' | 'qwik' | 'react' | 'solid' | 'svelte' | 'vue';
+
+export const framework: Framework = 'octane';
+
+// @__NO_SIDE_EFFECTS__
+export function createId(): string {
+	return Math.random().toString(36).slice(2);
+}
+
+export type Listener = [() => void, Set<Set<Listener>>];
+
+let listener: Listener | undefined;
+
+export function setListener(newListener: Listener | undefined): void {
+	listener = newListener;
+}
+
+let batchSubscribers: Set<Listener> | undefined;
+
+// @__NO_SIDE_EFFECTS__
+export function createSignal<T>(value: T): Signal<T> {
+	const subscribers = new Set<Listener>();
+	return {
+		get value() {
+			if (listener) {
+				subscribers.add(listener);
+				listener[1].add(subscribers);
+			}
+			return value;
+		},
+		set value(newValue: T) {
+			if (newValue !== value) {
+				value = newValue;
+				const localSubscribers: Listener[] = [];
+				for (const subscriber of subscribers) {
+					if (batchSubscribers) batchSubscribers.add(subscriber);
+					else localSubscribers.push(subscriber);
+					subscriber[1].delete(subscribers);
+				}
+				subscribers.clear();
+				for (const subscriber of localSubscribers) subscriber[0]();
+			}
+		},
+	};
+}
+
+let batchDepth = 0;
+
+export function batch<T>(fn: () => T): T {
+	batchDepth++;
+	batchSubscribers ??= new Set();
+	try {
+		return fn();
+	} finally {
+		batchDepth--;
+		if (batchDepth === 0) {
+			const subscribers = batchSubscribers;
+			batchSubscribers = undefined;
+			for (const subscriber of subscribers) subscriber[0]();
+		}
+	}
+}
+
+export function untrack<T>(fn: () => T): T {
+	const previousListener = listener;
+	listener = undefined;
+	try {
+		return fn();
+	} finally {
+		listener = previousListener;
+	}
+}

package/src/core/index.ts

@@ -0,0 +1,6 @@
+export * from './array/index.ts';
+export * from './field/index.ts';
+export * from './form/index.ts';
+export * from './framework/index.ts';
+export * from './types/index.ts';
+export * from './values.ts';

package/src/core/types/field/field.ts

@@ -0,0 +1,201 @@
+import type { Path } from '../path/index.ts';
+import type { Schema } from '../schema/index.ts';
+import type { Signal } from '../signal/index.ts';
+
+/**
+ * Field element type.
+ */
+export type FieldElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+
+/**
+ * Internal base store interface.
+ */
+export interface InternalBaseStore {
+	/**
+	 * The kind of field store.
+	 */
+	kind: 'array' | 'object' | 'value';
+	/**
+	 * The name of the field.
+	 */
+	name: string;
+	/**
+	 * The path to the field.
+	 */
+	path: Path;
+	/**
+	 * The schema of the field.
+	 */
+	schema: Schema;
+	/**
+	 * Whether the schema is wrapped in a nullish schema.
+	 *
+	 * Hint: This indicates whether a missing input should be represented as the
+	 * nullish value (`null`/`undefined`) instead of a present empty fallback
+	 * (`true` for arrays and objects, or the empty input for values). It keeps
+	 * resetting consistent with the initial state.
+	 */
+	isNullish: boolean;
+	/**
+	 * The initial elements of the field.
+	 *
+	 * Hint: This may look unused, but do not remove it. `copyItemState` and
+	 * `swapItemState` move the `elements` reference between field stores when
+	 * array items are inserted, moved, removed or swapped, and `reset` restores
+	 * each field's original element via `elements = initialElements`. Without it,
+	 * focus and file reset target the wrong element after a reorder followed by a
+	 * reset.
+	 */
+	initialElements: FieldElement[];
+	/**
+	 * The elements of the field.
+	 */
+	elements: FieldElement[];
+	/**
+	 * The errors of the field.
+	 */
+	errors: Signal<[string, ...string[]] | null>;
+	/**
+	 * The touched state of the field.
+	 */
+	isTouched: Signal<boolean>;
+	/**
+	 * The edited state of the field.
+	 *
+	 * Hint: Unlike `isTouched`, which is also set when a field is focused, this
+	 * is only set when the field's value is changed. Unlike `isDirty`, it stays
+	 * `true` even if the value is changed back to its initial value. It is only
+	 * reset when the field is reset.
+	 */
+	isEdited: Signal<boolean>;
+	/**
+	 * The dirty state of the field.
+	 */
+	isDirty: Signal<boolean>;
+}
+
+/**
+ * Internal array store interface.
+ */
+export interface InternalArrayStore extends InternalBaseStore {
+	/**
+	 * The kind of field store.
+	 */
+	kind: 'array';
+
+	/**
+	 * The children of the array field.
+	 */
+	children: InternalFieldStore[];
+
+	/**
+	 * The initial input of the array field.
+	 *
+	 * Hint: The initial input is used for resetting and may only be changed
+	 * during this process. It does not move when a field is moved.
+	 */
+	initialInput: Signal<true | null | undefined>;
+	/**
+	 * The start input of the array field.
+	 *
+	 * Hint: The start input is used to determine whether the field is dirty
+	 * and moves with it.
+	 */
+	startInput: Signal<true | null | undefined>;
+	/**
+	 * The input of the array field.
+	 *
+	 * Hint: The input indicates whether it is `null`, `undefined`, or found in
+	 * the children.
+	 */
+	input: Signal<true | null | undefined>;
+
+	/**
+	 * The initial items of the array field.
+	 *
+	 * Hint: The initial items are used for resetting and may only be changed
+	 * during this process. It does not move when a field is moved.
+	 */
+	initialItems: Signal<string[]>;
+	/**
+	 * The start items of the array field.
+	 *
+	 * Hint: The start items are used to determine whether the field is dirty
+	 * and moves with it.
+	 */
+	startItems: Signal<string[]>;
+	/**
+	 * The items of the array field.
+	 */
+	items: Signal<string[]>;
+}
+
+/**
+ * Internal object store interface.
+ */
+export interface InternalObjectStore extends InternalBaseStore {
+	/**
+	 * The kind of field store.
+	 */
+	kind: 'object';
+	/**
+	 * The children of the object field.
+	 */
+	children: Record<string, InternalFieldStore>;
+
+	/**
+	 * The initial input of the object field.
+	 *
+	 * Hint: The initial input is used for resetting and may only be changed
+	 * during this process. It does not move when a field is moved.
+	 */
+	initialInput: Signal<true | null | undefined>;
+	/**
+	 * The start input of the object field.
+	 *
+	 * Hint: The start input is used to determine whether the field is dirty
+	 * and moves with it.
+	 */
+	startInput: Signal<true | null | undefined>;
+	/**
+	 * The input of the object field.
+	 *
+	 * Hint: The input indicates whether it is `null`, `undefined`, or found in
+	 * the children.
+	 */
+	input: Signal<true | null | undefined>;
+}
+
+/**
+ * Internal value store interface.
+ */
+export interface InternalValueStore extends InternalBaseStore {
+	/**
+	 * The kind of field store.
+	 */
+	kind: 'value';
+
+	/**
+	 * The initial input of the value field.
+	 *
+	 * Hint: The initial input is used for resetting and may only be changed
+	 * during this process. It does not move when a field is moved.
+	 */
+	initialInput: Signal<unknown>;
+	/**
+	 * The start input of the value field.
+	 *
+	 * Hint: The start input is used to determine whether the field is dirty
+	 * and moves with it.
+	 */
+	startInput: Signal<unknown>;
+	/**
+	 * The input of the value field.
+	 */
+	input: Signal<unknown>;
+}
+
+/**
+ * Internal field store type.
+ */
+export type InternalFieldStore = InternalArrayStore | InternalObjectStore | InternalValueStore;

package/src/core/types/field/index.ts

@@ -0,0 +1 @@
+export * from './field.ts';

package/src/core/types/form/form.ts

@@ -0,0 +1,140 @@
+import type * as v from 'valibot';
+import type { INTERNAL } from '../../values.ts';
+import type { InternalObjectStore } from '../field/index.ts';
+import type { FormSchema } from '../schema/index.ts';
+import type { Signal } from '../signal/index.ts';
+import type { DeepPartial, MaybePromise } from '../utils/index.ts';
+
+/**
+ * Validation mode type.
+ */
+export type ValidationMode = 'initial' | 'touch' | 'input' | 'change' | 'blur' | 'submit';
+
+/**
+ * Empty input interface.
+ *
+ * Defines the value a required field of a given type starts at when no initial
+ * input is provided. Optional and nullable fields are not affected, as they
+ * accept `undefined`. Only required fields whose input is `undefined` fall back
+ * to these values.
+ */
+export interface EmptyInput {
+	/**
+	 * The empty input of a string field. Defaults to an empty string so that an
+	 * untouched field matches the DOM and validates with its own message instead
+	 * of a type mismatch. Set to `undefined` to opt out.
+	 */
+	readonly string?: string | undefined;
+	/**
+	 * The empty input of a number field. Defaults to `undefined`.
+	 */
+	readonly number?: number | undefined;
+	/**
+	 * The empty input of a boolean field. Defaults to `undefined`.
+	 */
+	readonly boolean?: boolean | undefined;
+	/**
+	 * The empty input of a date field. Defaults to `undefined`.
+	 */
+	readonly date?: Date | undefined;
+}
+
+/**
+ * Form config interface.
+ */
+export interface FormConfig<TSchema extends FormSchema = FormSchema> {
+	/**
+	 * The schema of the form.
+	 */
+	readonly schema: TSchema;
+	/**
+	 * The initial input of the form.
+	 */
+	readonly initialInput?: DeepPartial<v.InferInput<TSchema>> | undefined;
+	/**
+	 * The empty input of the form, keyed by field type. Merged on top of the
+	 * defaults, so `{ string: '' }` stays in effect unless overridden.
+	 */
+	readonly emptyInput?: EmptyInput | undefined;
+	/**
+	 * The validation mode of the form.
+	 */
+	readonly validate?: ValidationMode | undefined;
+	/**
+	 * The revalidation mode of the form.
+	 */
+	readonly revalidate?: Exclude<ValidationMode, 'initial'> | undefined;
+}
+
+/**
+ * Internal form store interface.
+ */
+export interface InternalFormStore<
+	TSchema extends FormSchema = FormSchema,
+> extends InternalObjectStore {
+	/**
+	 * The element of the form.
+	 */
+	element?: HTMLFormElement | undefined;
+
+	/**
+	 * The number of active validators.
+	 */
+	validators: number;
+	/**
+	 * The resolved empty input of the form, keyed by field type.
+	 */
+	emptyInput: EmptyInput;
+	/**
+	 * The validation mode of the form.
+	 */
+	validate: ValidationMode;
+	/**
+	 * The revalidation mode of the form.
+	 */
+	revalidate: Exclude<ValidationMode, 'initial'>;
+	/**
+	 * The parse function of the form.
+	 */
+	parse: (input: unknown) => Promise<v.SafeParseResult<TSchema>>;
+
+	/**
+	 * The submitting state of the form.
+	 */
+	isSubmitting: Signal<boolean>;
+	/**
+	 * The submitted state of the form.
+	 */
+	isSubmitted: Signal<boolean>;
+	/**
+	 * The validating state of the form.
+	 */
+	isValidating: Signal<boolean>;
+}
+
+/**
+ * Base form store interface.
+ */
+export interface BaseFormStore<TSchema extends FormSchema = FormSchema> {
+	/**
+	 * The internal form store.
+	 *
+	 * @internal
+	 */
+	readonly [INTERNAL]: InternalFormStore<TSchema>;
+}
+
+/**
+ * Submit handler type.
+ */
+export type SubmitHandler<TSchema extends FormSchema> = (
+	output: v.InferOutput<TSchema>,
+) => MaybePromise<unknown>;
+
+/**
+ * Submit event handler type.
+ */
+export type SubmitEventHandler<TSchema extends FormSchema> = (
+	output: v.InferOutput<TSchema>,
+	event: SubmitEvent,
+) => MaybePromise<unknown>;

package/src/core/types/form/index.ts

@@ -0,0 +1 @@
+export * from './form.ts';

package/src/core/types/index.ts

@@ -0,0 +1,6 @@
+export * from './field/index.ts';
+export * from './form/index.ts';
+export * from './path/index.ts';
+export * from './schema/index.ts';
+export * from './signal/index.ts';
+export * from './utils/index.ts';

package/src/core/types/path/index.ts

@@ -0,0 +1,10 @@
+export type {
+	DirtyPath,
+	FieldPath,
+	Path,
+	PathValue,
+	PathKey,
+	RequiredPath,
+	ValidArrayPath,
+	ValidPath,
+} from './path.ts';