@formisch/preact 0.9.5 → 0.9.6

package/dist/index.d.ts

@@ -4,20 +4,20 @@ import { JSX } from "preact";
 
 //#region ../../packages/core/dist/index.preact.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
 
 /**
 * Batch interface.
 */
 
 //#endregion
-//#region src/types/field.d.ts
+//#region src/types/field/field.d.ts
 /**
 * Field element type.
 */
@@ -183,7 +183,7 @@ type InternalFieldStore = InternalArrayStore | InternalObjectStore | InternalVal
 */
 declare const INTERNAL: "~internal";
 //#endregion
-//#region src/types/utils.d.ts
+//#region src/types/utils/utils.d.ts
 /**
 * Checks if a type is `any`.
 */
@@ -209,7 +209,7 @@ type DeepPartial<TValue> = TValue extends Record<PropertyKey, unknown> | readonl
 */
 type PartialValues<TValue> = TValue extends readonly (infer TItem)[] ? number extends TValue["length"] ? (TItem extends Record<PropertyKey, unknown> | readonly unknown[] ? { [TKey in keyof TItem]: PartialValues<TItem[TKey]> } : TItem)[] : { [TKey in keyof TValue]: PartialValues<TValue[TKey]> } : TValue extends Record<PropertyKey, unknown> ? { [TKey in keyof TValue]: PartialValues<TValue[TKey]> } : TValue | undefined;
 //#endregion
-//#region src/types/form.d.ts
+//#region src/types/form/form.d.ts
 /**
 * Validation mode type.
 */
@@ -292,7 +292,7 @@ type SubmitHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>) =>
 */
 type SubmitEventHandler<TSchema extends Schema> = (output: v.InferOutput<TSchema>, event: SubmitEvent) => MaybePromise<unknown>;
 //#endregion
-//#region src/types/path.d.ts
+//#region src/types/path/path.d.ts
 /**
 * Path key type.
 */
@@ -306,42 +306,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

@@ -76,7 +76,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();
@@ -87,6 +87,7 @@ function initializeFieldStore(internalFieldStore, schema, initialInput, path, nu
 				internalFieldStore.input = 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 = createSignal(initialInput);
@@ -704,7 +705,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/preact",
-  "description": "The modular and type-safe form library for Preact",
-  "version": "0.9.5",
+  "description": "The lightweight, schema-first, and fully type-safe form library for Preact",
+  "version": "0.9.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",
@@ -45,13 +46,18 @@
     "@formisch/methods": "workspace:*",
     "@preact/preset-vite": "^2.9.3",
     "@preact/signals": "^2.2.1",
+    "@testing-library/jest-dom": "^6.6.0",
+    "@testing-library/preact": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.31.0",
     "eslint-config-preact": "^2.0.0",
+    "jsdom": "^26.1.0",
     "preact": "^10.25.3",
     "tsdown": "^0.16.8",
     "typescript": "^5.8.3",
     "valibot": "^1.2.0",
-    "vite": "^6.0.4"
+    "vite": "^6.0.4",
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "@preact/signals": "^2.0.0",