@formisch/react 0.4.4 → 0.4.6

package/dist/index.d.ts

@@ -3,13 +3,13 @@ import { ChangeEventHandler, FocusEventHandler, FormEvent, FormHTMLAttributes, R
 
 //#region ../../packages/core/dist/index.react.d.ts
 
-//#region src/types/schema.d.ts
+//#region src/types/schema/schema.d.ts
 /**
 * Schema type.
 */
 type Schema = v.GenericSchema | v.GenericSchemaAsync;
 //#endregion
-//#region src/types/signal.d.ts
+//#region src/types/signal/signal.d.ts
 /**
 * Signal interface.
 */
@@ -24,7 +24,7 @@ interface Signal<T> {
 */
 
 //#endregion
-//#region src/types/field.d.ts
+//#region src/types/field/field.d.ts
 /**
 * Field element type.
 */
@@ -184,7 +184,7 @@ interface InternalValueStore extends InternalBaseStore {
 */
 type InternalFieldStore = InternalArrayStore | InternalObjectStore | InternalValueStore;
 //#endregion
-//#region src/types/utils.d.ts
+//#region src/types/utils/utils.d.ts
 /**
 * Checks if a type is `any`.
 */
@@ -216,7 +216,7 @@ type PartialValues<TValue> = TValue extends readonly (infer TItem)[] ? number ex
 */
 declare const INTERNAL: "~internal";
 //#endregion
-//#region src/types/form.d.ts
+//#region src/types/form/form.d.ts
 /**
 * Validation mode type.
 */
@@ -291,7 +291,7 @@ interface BaseFormStore<TSchema extends Schema = Schema> {
   readonly [INTERNAL]: InternalFormStore<TSchema>;
 }
 //#endregion
-//#region src/types/form.react.d.ts
+//#region src/types/form/form.react.d.ts
 /**
 * Submit handler type.
 */
@@ -301,7 +301,7 @@ type SubmitHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>) =>
 */
 type SubmitEventHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>, event: FormEvent<HTMLFormElement>) => MaybePromise<unknown>;
 //#endregion
-//#region src/types/path.d.ts
+//#region src/types/path/path.d.ts
 /**
 * Path key type.
 */
@@ -315,42 +315,88 @@ type Path = readonly PathKey[];
 */
 type RequiredPath = readonly [PathKey, ...Path];
 /**
-* Extracts the exact keys of a tuple, array or object.
+* Extracts the exact keys of a tuple, array or object. Tuples return their
+* literal numeric indices, dynamic arrays return `number`, objects return
+* their `keyof` keys, and any other input returns `never`.
 */
-type KeyOf<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly unknown[] ? number extends TValue["length"] ? number : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? TIndex : never }[number] : TValue extends Record<string, unknown> ? keyof TValue & PathKey : never;
+type ExactKeysOf<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly unknown[] ? number extends TValue["length"] ? number : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? TIndex : never }[number] : TValue extends Record<PropertyKey, unknown> ? keyof TValue & PathKey : never;
 /**
-* Merges array and object unions into a single object.
+* Returns the flat object of all indexable properties of `TValue`. For object
+* unions, properties from every member are merged so that any single property
+* is accessible. For primitives and other non-indexable types, the result is
+* `{}`.
 *
-* Hint: This is necessary to make any property accessible. By default,
-* properties that do not exist in all union options are not accessible
-* and result in "any" when accessed.
+* Hint: This is necessary to make properties accessible across union members.
+* By default, properties that do not exist in all union options are not
+* accessible and result in "any" when accessed.
 */
-type MergeUnion<TValue> = { [TKey in KeyOf<TValue>]: TValue extends Record<TKey, infer TItem> ? TItem : never };
+type PropertiesOf<TValue> = { [TKey in ExactKeysOf<TValue>]: TValue extends Record<TKey, infer TItem> ? TItem : never };
 /**
 * Lazily evaluates only the first valid path segment based on the given value.
 */
-type LazyPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValidPath : TPathToCheck extends readonly [infer TFirstKey extends KeyOf<TValue>, ...infer TPathRest extends Path] ? LazyPath<Required<MergeUnion<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOf<TValue>> extends false ? readonly [...TValidPath, KeyOf<TValue>] : TValidPath;
+type LazyPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValidPath : TPathToCheck extends readonly [infer TFirstKey extends ExactKeysOf<TValue>, ...infer TPathRest extends Path] ? LazyPath<Required<PropertiesOf<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<ExactKeysOf<TValue>> extends false ? readonly [...TValidPath, ExactKeysOf<TValue>] : TValidPath;
 /**
 * Returns the path if valid, otherwise the first possible valid path based on
 * the given value.
 */
 type ValidPath<TValue, TPath extends RequiredPath> = TPath extends LazyPath<Required<TValue>, TPath> ? TPath : LazyPath<Required<TValue>, TPath>;
 /**
+* Detects whether the consuming project is configured with
+* `exactOptionalPropertyTypes: true`.
+*
+* Hint: If `false` the built-in `Required<T>` strips `| undefined` from
+* optional properties, so `Required<{ key?: undefined }>['key']` collapses
+* to `never` — under strict mode the same expression yields `undefined`.
+*/
+type IsExactOptionalProps = Required<{
+  key?: undefined;
+}>["key"] extends never ? false : true;
+/**
+* Like the built-in `Required<T>`, but preserves `| undefined` in two
+* places where `Required<T>` strips it:
+*
+* 1. Optional property values under `exactOptionalPropertyTypes: false`
+*    — without this, input typings for `v.optional`/`v.nullish` schemas
+*    narrow incorrectly (issue #15).
+* 2. Array/tuple element types — e.g. `(string | undefined)[]` stays
+*    `(string | undefined)[]` instead of becoming `string[]`. Arrays
+*    fall through unchanged because they only have a numeric index
+*    signature and don't structurally extend `Record<PropertyKey,
+*    unknown>` (which requires string keys).
+*/
+type ExactRequired<TValue> = TValue extends Record<PropertyKey, unknown> ? IsExactOptionalProps extends true ? Required<TValue> : { [TKey in keyof Required<TValue>]: TValue[TKey] } : TValue;
+/**
 * Extracts the value type at the given path.
 */
-type PathValue<TValue, TPath extends Path> = TPath extends readonly [infer TKey, ...infer TRest extends Path] ? TKey extends KeyOf<Required<TValue>> ? PathValue<MergeUnion<Required<TValue>>[TKey], TRest> : unknown : TValue;
+type PathValue<TValue, TPath extends Path> = TPath extends readonly [infer TKey, ...infer TRest extends Path] ? TKey extends ExactKeysOf<ExactRequired<TValue>> ? PathValue<PropertiesOf<ExactRequired<TValue>>[TKey], TRest> : unknown : TValue;
 /**
-* Checks if a value is an array or contains one.
+* Checks whether a value is an array or contains one anywhere in its shape.
+*
+* Hint: The inner conditionals (`TValue extends readonly unknown[]` and
+* `TValue extends Record<PropertyKey, unknown>`) distribute over union members,
+* so the inner expression returns the union of each member's result (e.g.
+* `true | false` when some members contain arrays and others don't).
+* Downstream code uses `IsOrHasArray<T> extends true`, but
+* `boolean extends true` is `false` — so we collapse the result via
+* `true extends ...`, which is `true` whenever at least one union member
+* contributed `true`.
 */
-type IsOrHasArray<TValue> = IsAny<TValue> extends true ? false : TValue extends readonly unknown[] ? true : TValue extends Record<string, unknown> ? true extends { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> }[keyof TValue] ? true : false : false;
+type IsOrHasArray<TValue> = true extends (IsAny<TValue> extends true ? false : TValue extends readonly unknown[] ? true : TValue extends Record<PropertyKey, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<TValue[TKey]> }[keyof TValue] : false) ? true : false;
 /**
 * Extracts the exact keys of a tuple, array or object that contain arrays.
 */
-type KeyOfArrayPath<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? IsOrHasArray<TItem> extends true ? number : never : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TIndex : never : never }[number] : TValue extends Record<string, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TKey : never }[keyof TValue] & PathKey : never;
+type ExactKeysOfArrayPath<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? IsOrHasArray<TItem> extends true ? number : never : { [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TIndex : never : never }[number] : TValue extends Record<PropertyKey, unknown> ? { [TKey in keyof TValue]: IsOrHasArray<NonNullable<TValue[TKey]>> extends true ? TKey : never }[keyof TValue] & PathKey : never;
+/**
+* Returns the flat object of indexable properties of `TValue` whose values
+* are or contain arrays. Mirrors `PropertiesOf` but keyed by
+* `ExactKeysOfArrayPath` so the lookup is provably valid for array-path
+* navigation in `LazyArrayPath`.
+*/
+type PropertiesOfArrayPath<TValue> = { [TKey in ExactKeysOfArrayPath<TValue>]: TValue extends Record<TKey, infer TItem> ? TItem : never };
 /**
 * Lazily evaluates only the first valid array path segment based on the given value.
 */
-type LazyArrayPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValue extends readonly unknown[] ? TValidPath : readonly [...TValidPath, KeyOfArrayPath<TValue>] : TPathToCheck extends readonly [infer TFirstKey extends KeyOfArrayPath<TValue>, ...infer TPathRest extends Path] ? LazyArrayPath<Required<MergeUnion<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOfArrayPath<TValue>> extends false ? readonly [...TValidPath, KeyOfArrayPath<TValue>] : never;
+type LazyArrayPath<TValue, TPathToCheck extends Path, TValidPath extends Path = readonly []> = TPathToCheck extends readonly [] ? TValue extends readonly unknown[] ? TValidPath : readonly [...TValidPath, ExactKeysOfArrayPath<TValue>] : TPathToCheck extends readonly [infer TFirstKey extends ExactKeysOfArrayPath<TValue>, ...infer TPathRest extends Path] ? LazyArrayPath<Required<PropertiesOfArrayPath<TValue>[TFirstKey]>, TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<ExactKeysOfArrayPath<TValue>> extends false ? readonly [...TValidPath, ExactKeysOfArrayPath<TValue>] : never;
 /**
 * Returns the path if valid, otherwise the first possible valid array path
 * based on the given value.

package/dist/index.js

@@ -162,7 +162,7 @@ function initializeFieldStore(internalFieldStore, schema, initialInput, path, nu
 			if (internalFieldStore.kind === "object") {
 				internalFieldStore.children ??= {};
 				for (const key in schema.entries) {
-					internalFieldStore.children[key] = {};
+					internalFieldStore.children[key] ??= {};
 					path.push(key);
 					initializeFieldStore(internalFieldStore.children[key], schema.entries[key], initialInput?.[key], path);
 					path.pop();
@@ -173,6 +173,7 @@ function initializeFieldStore(internalFieldStore, schema, initialInput, path, nu
 				internalFieldStore.input = /* @__PURE__ */ createSignal(objectInput);
 			}
 		} else {
+			if (internalFieldStore.kind && internalFieldStore.kind !== "value") throw new Error(`Store initialized as "${internalFieldStore.kind}" cannot be reinitialized as "value"`);
 			internalFieldStore.kind = "value";
 			if (internalFieldStore.kind === "value") {
 				internalFieldStore.initialInput = /* @__PURE__ */ createSignal(initialInput);
@@ -644,6 +645,7 @@ function focus(form, config) {
 function getAllErrors(form) {
 	let allErrors = null;
 	walkFieldStore(form[INTERNAL], (internalFieldStore) => {
+		if (internalFieldStore.kind === "array") internalFieldStore.items.value;
 		const errors = internalFieldStore.errors.value;
 		if (errors) if (allErrors) allErrors.push(...errors);
 		else allErrors = [...errors];
@@ -700,7 +702,15 @@ function insert(form, config) {
 		const newItems = [...items];
 		newItems.splice(insertIndex, 0, createId());
 		internalArrayStore.items.value = newItems;
-		for (let index = items.length; index > insertIndex; index--) copyItemState(internalArrayStore.children[index - 1], internalArrayStore.children[index]);
+		for (let index = items.length; index > insertIndex; index--) {
+			if (!internalArrayStore.children[index]) {
+				const path = JSON.parse(internalArrayStore.name);
+				internalArrayStore.children[index] = {};
+				path.push(index);
+				initializeFieldStore(internalArrayStore.children[index], internalArrayStore.schema.item, void 0, path);
+			}
+			copyItemState(internalArrayStore.children[index - 1], internalArrayStore.children[index]);
+		}
 		if (!internalArrayStore.children[insertIndex]) {
 			const path = JSON.parse(internalArrayStore.name);
 			internalArrayStore.children[insertIndex] = {};
@@ -785,7 +795,7 @@ function reset(form, config) {
 		untrack(() => {
 			const internalFormStore = form[INTERNAL];
 			const internalFieldStore = config?.path ? getFieldStore(internalFormStore, config.path) : internalFormStore;
-			if (config?.initialInput) setInitialFieldInput(internalFieldStore, config.initialInput);
+			if (config && "initialInput" in config) setInitialFieldInput(internalFieldStore, config.initialInput);
 			walkFieldStore(internalFieldStore, (internalFieldStore$1) => {
 				internalFieldStore$1.elements = internalFieldStore$1.initialElements;
 				if (!config?.keepErrors) internalFieldStore$1.errors.value = null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formisch/react",
-  "description": "The modular and type-safe form library for React",
-  "version": "0.4.4",
+  "description": "The lightweight, schema-first, and fully type-safe form library for React",
+  "version": "0.4.6",
   "license": "MIT",
   "author": "Fabian Hiller",
   "homepage": "https://formisch.dev",
@@ -34,6 +34,7 @@
   },
   "scripts": {
     "build": "tsdown",
+    "test": "vitest run --typecheck",
     "lint": "eslint \"src/**/*.ts*\" && tsc --noEmit",
     "lint.fix": "eslint \"src/**/*.ts*\" --fix",
     "format": "prettier --write ./src",
@@ -43,19 +44,25 @@
     "@formisch/core": "workspace:*",
     "@formisch/eslint-config": "workspace:*",
     "@formisch/methods": "workspace:*",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/jest-dom": "^6.6.0",
+    "@testing-library/react": "^16.3.0",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.5",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^5.1.1",
+    "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
+    "jsdom": "^26.1.0",
     "react": "^19.2.1",
     "react-dom": "^19.2.1",
     "tsdown": "^0.16.8",
     "typescript": "~5.9.3",
-    "vite": "^7.2.4"
+    "vite": "^7.2.4",
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "react": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",