jsonisch 0.1.0

package/dist/handle-submit-CD3WY9gW.js

@@ -0,0 +1,208 @@
+import { A as unwrapLeafInput, B as getFieldBool, L as untrack, M as batch, V as walkFieldStore, _ as resolveValueInput, b as dispatchReseedScope, c as isPresenceEqual, g as readOwn, j as createId, l as isSemanticEqual, m as containerPresence, n as validateFormInput, o as getFieldStoreChain, p as initializeFieldStore, t as internalOf, w as dispatchSyncInput } from "./form-ref-BEri3JKv.js";
+
+//#region src/core/field/reset-item-state.ts
+/**
+* Resets the state of a field store (signal values) deeply. Clears
+* `elements`, `errors`, `isTouched`, `isEdited` and `isDirty`, and sets
+* `startInput`, `input`, `startItems` and `items` to the new input value.
+* Keeps `initialInput` and `initialItems` unchanged for form reset.
+*
+* @param internalFormStore The form store providing the empty input config.
+* @param internalFieldStore The field store to reset.
+* @param input The new input value.
+* @param keepStart Whether to keep `startInput` and `startItems` as the
+* dirty baseline instead of resetting them to the new input. Used when a
+* field store is reused for an in-place edit (array shrink-then-regrow) so
+* its dirty state stays detectable against the original baseline.
+*/
+function resetItemState(internalFormStore, internalFieldStore, input, keepStart = false) {
+	batch(() => {
+		const elements = [];
+		if (internalFieldStore.elements === internalFieldStore.initialElements) internalFieldStore.initialElements = elements;
+		internalFieldStore.elements = elements;
+		internalFieldStore.validationErrors.value = null;
+		internalFieldStore.isTouched.value = false;
+		internalFieldStore.isEdited.value = false;
+		internalFieldStore.isDirty.value = false;
+		if (internalFieldStore.kind === "array" || internalFieldStore.kind === "object") {
+			const presence = containerPresence(internalFieldStore.isNullish, input);
+			if (!keepStart) internalFieldStore.startInput.value = presence;
+			internalFieldStore.input.value = presence;
+			if (internalFieldStore.kind === "array") if (Array.isArray(input)) {
+				const newItems = input.map(() => createId());
+				if (!keepStart) internalFieldStore.startItems.value = newItems;
+				internalFieldStore.items.value = newItems;
+				for (let index = 0; index < input.length; index++) if (internalFieldStore.children[index]) resetItemState(internalFormStore, internalFieldStore.children[index], input[index], keepStart);
+				else {
+					internalFieldStore.children[index] = {};
+					initializeFieldStore(internalFormStore, internalFieldStore.children[index], internalFieldStore.itemSchema, input[index], [...internalFieldStore.path, index]);
+				}
+			} else {
+				if (!keepStart) internalFieldStore.startItems.value = [];
+				internalFieldStore.items.value = [];
+			}
+			else {
+				for (const key in internalFieldStore.children) resetItemState(internalFormStore, internalFieldStore.children[key], readOwn(input, key), keepStart);
+				if (typeof internalFieldStore.path[internalFieldStore.path.length - 1] === "number") dispatchReseedScope(internalFormStore, internalFieldStore, input);
+			}
+		} else {
+			const valueInput = resolveValueInput(internalFormStore.emptyInput, internalFieldStore.schema, internalFieldStore.isNullish, unwrapLeafInput(internalFormStore, internalFieldStore.control, input));
+			if (!keepStart) internalFieldStore.startInput.value = valueInput;
+			internalFieldStore.input.value = valueInput;
+		}
+	});
+}
+
+//#endregion
+//#region src/core/field/set-field-input.ts
+/**
+* Recomputes a container's dirty flag from its presence sentinel (and, for
+* arrays, its item count) against the start baseline. Content changes live
+* on the children, not here.
+*/
+function computeContainerDirty(internalFieldStore) {
+	const presenceDirty = !isPresenceEqual(internalFieldStore.startInput.value, internalFieldStore.input.value);
+	if (internalFieldStore.kind === "array") return presenceDirty || internalFieldStore.startItems.value.length !== internalFieldStore.items.value.length;
+	return presenceDirty;
+}
+/**
+* Sets the input for a nested field store and all its children, updating
+* touched, edited and dirty states. Handles dynamic array resizing with
+* child-store reuse (a regrown index keeps its dirty baseline, so
+* shrink-then-regrow behaves exactly like a direct edit).
+*
+* @param internalFormStore The form store providing the empty input config.
+* @param internalFieldStore The field store to update.
+* @param input The new input value.
+*/
+function setNestedInput(internalFormStore, internalFieldStore, input) {
+	internalFieldStore.isTouched.value = true;
+	internalFieldStore.isEdited.value = true;
+	if (internalFieldStore.kind === "array") {
+		const arrayInput = Array.isArray(input) ? input : [];
+		const items = internalFieldStore.items.value;
+		const length = arrayInput.length;
+		if (length < items.length) internalFieldStore.items.value = items.slice(0, length);
+		else if (length > items.length) {
+			for (let index = items.length; index < length; index++) if (internalFieldStore.children[index]) resetItemState(internalFormStore, internalFieldStore.children[index], arrayInput[index], true);
+			else {
+				internalFieldStore.children[index] = {};
+				initializeFieldStore(internalFormStore, internalFieldStore.children[index], internalFieldStore.itemSchema, arrayInput[index], [...internalFieldStore.path, index]);
+			}
+			internalFieldStore.items.value = [...items, ...Array.from({ length: length - items.length }, () => createId())];
+		}
+		for (let index = 0; index < length; index++) setNestedInput(internalFormStore, internalFieldStore.children[index], arrayInput[index]);
+		internalFieldStore.input.value = input == null ? input : true;
+		internalFieldStore.isDirty.value = computeContainerDirty(internalFieldStore);
+	} else if (internalFieldStore.kind === "object") {
+		for (const key in internalFieldStore.children) setNestedInput(internalFormStore, internalFieldStore.children[key], readOwn(input, key));
+		internalFieldStore.input.value = input == null ? input : true;
+		internalFieldStore.isDirty.value = computeContainerDirty(internalFieldStore);
+	} else {
+		if (dispatchSyncInput(internalFormStore, internalFieldStore, input)) return;
+		internalFieldStore.input.value = input;
+		internalFieldStore.isDirty.value = !isSemanticEqual(input, internalFieldStore.startInput.value);
+	}
+}
+/**
+* Sets the input for the field at the specified path in the form store,
+* marking all parent containers along the way as present and recomputing
+* their presence dirtiness (a nullish container transitioned to present by
+* a nested set is a real change and must reach the dirty projections).
+*
+* @param internalFormStore The form store containing the field.
+* @param path The path to the field.
+* @param input The new input value.
+*/
+function setFieldInput(internalFormStore, path, input) {
+	batch(() => {
+		untrack(() => {
+			const chain = getFieldStoreChain(internalFormStore, path);
+			const target = chain[chain.length - 1];
+			for (let index = 1; index < chain.length - 1; index++) {
+				const ancestor = chain[index];
+				if (ancestor.kind === "value") continue;
+				ancestor.input.value = true;
+				ancestor.isDirty.value = computeContainerDirty(ancestor);
+			}
+			setNestedInput(internalFormStore, target, input);
+		});
+	});
+}
+
+//#endregion
+//#region src/core/form/validate-if-required.ts
+/**
+* Validates the form input if required by the configured modes: the form's
+* `validate` mode applies until the form is in the "already validated"
+* state — submitted (for `validate: "submit"`), or the triggering subtree
+* has errors (any other mode) — after which the `revalidate` mode takes
+* over. `validate: "initial"` forms always run in revalidate mode.
+*
+* @param internalFormStore The form store to validate.
+* @param internalFieldStore The field store that triggered validation.
+* @param validationMode The validation mode of the triggering event.
+*/
+function validateIfRequired(internalFormStore, internalFieldStore, validationMode) {
+	if (validationMode === (internalFormStore.validate === "initial" || (internalFormStore.validate === "submit" ? untrack(() => internalFormStore.isSubmitted.value) : untrack(() => getFieldBool(internalFieldStore, "errors"))) ? internalFormStore.revalidate : internalFormStore.validate)) validateFormInput(internalFormStore);
+}
+
+//#endregion
+//#region src/core/field/set-field-bool.ts
+/**
+* Sets the specified boolean property for the field store and all nested
+* children.
+*
+* @param internalFieldStore The field store to update.
+* @param type The boolean property type to set.
+* @param bool The boolean value to set.
+*/
+function setFieldBool(internalFieldStore, type, bool) {
+	batch(() => {
+		untrack(() => {
+			walkFieldStore(internalFieldStore, (fieldStore) => {
+				fieldStore[type].value = bool;
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/methods/handle-submit.ts
+/**
+* Creates a submit event handler for the form: prevents default browser
+* submission, marks every field touched (errors must be visible everywhere
+* after a submit attempt), validates the form input, and calls the provided
+* handler with the validated output if validation succeeds — an invalid
+* form blocks the handler and focuses the first erroring field. A handler
+* throw lands as a form-level (root) error. Re-entrant submits while
+* `isSubmitting` are ignored.
+*
+* @param form The form store to handle submission for.
+* @param handler The submit handler called with the validated output.
+*
+* @returns A submit event handler to attach to the form element.
+*/
+function handleSubmit(form, handler) {
+	return async (event) => {
+		event?.preventDefault();
+		const internalFormStore = internalOf(form);
+		if (untrack(() => internalFormStore.isSubmitting.value)) return;
+		batch(() => {
+			internalFormStore.isSubmitted.value = true;
+			internalFormStore.isSubmitting.value = true;
+			setFieldBool(internalFormStore, "isTouched", true);
+		});
+		try {
+			const result = validateFormInput(internalFormStore, { shouldFocus: true });
+			if (result.success) await handler(result.output, event);
+		} catch (error) {
+			internalFormStore.validationErrors.value = [error && typeof error === "object" && "message" in error && typeof error.message === "string" ? error.message : "An unknown error has occurred."];
+		} finally {
+			internalFormStore.isSubmitting.value = false;
+		}
+	};
+}
+
+//#endregion
+export { setFieldInput as a, computeContainerDirty as i, setFieldBool as n, resetItemState as o, validateIfRequired as r, handleSubmit as t };

package/dist/handle-submit-Dk7QW3_q.d.ts

@@ -0,0 +1,34 @@
+import { t as FormRef } from "./form-ref-D_xHSaqL.js";
+
+//#region src/methods/handle-submit.d.ts
+
+/**
+ * The minimal submit event shape the handler needs — structurally
+ * compatible with both the native `SubmitEvent` and React's synthetic form
+ * event.
+ */
+interface SubmitLikeEvent {
+  preventDefault: () => void;
+}
+/**
+ * The submit handler called with the validated form output when validation
+ * succeeds.
+ */
+type SubmitHandler = (output: Record<string, unknown>, event?: SubmitLikeEvent) => unknown | Promise<unknown>;
+/**
+ * Creates a submit event handler for the form: prevents default browser
+ * submission, marks every field touched (errors must be visible everywhere
+ * after a submit attempt), validates the form input, and calls the provided
+ * handler with the validated output if validation succeeds — an invalid
+ * form blocks the handler and focuses the first erroring field. A handler
+ * throw lands as a form-level (root) error. Re-entrant submits while
+ * `isSubmitting` are ignored.
+ *
+ * @param form The form store to handle submission for.
+ * @param handler The submit handler called with the validated output.
+ *
+ * @returns A submit event handler to attach to the form element.
+ */
+declare function handleSubmit(form: FormRef, handler: SubmitHandler): (event?: SubmitLikeEvent) => Promise<void>;
+//#endregion
+export { handleSubmit as n, SubmitHandler as t };