@drfed/web 0.0.0-stage → 0.1.0-dev.561

package/.output/server/_ssr/dist-D6rgyh-L.mjs

@@ -0,0 +1,81 @@
+import { F as createContext, H as createUniqueId, J as onCleanup, N as createComponent, R as createRenderEffect, h as ssr, nt as useContext, u as escape, x as useAssets } from "../_libs/solid-js.mjs";
+//#region node_modules/.nitro/vite/services/ssr/_build/assets/dist-D6rgyh-L.js
+var MetaContext = createContext();
+var cascadingTags = ["title", "meta"];
+var titleTagProperties = [];
+var metaTagProperties = [
+	"name",
+	"http-equiv",
+	"content",
+	"charset",
+	"media"
+].concat(["property"]);
+var getTagKey = (tag, properties) => {
+	const tagProps = Object.fromEntries(Object.entries(tag.props).filter(([k]) => properties.includes(k)).sort());
+	if (Object.hasOwn(tagProps, "name") || Object.hasOwn(tagProps, "property")) {
+		tagProps.name = tagProps.name || tagProps.property;
+		delete tagProps.property;
+	}
+	return tag.tag + JSON.stringify(tagProps);
+};
+function initServerProvider() {
+	const tags = [];
+	useAssets(() => ssr(renderTags(tags)));
+	return {
+		addTag(tagDesc) {
+			if (cascadingTags.indexOf(tagDesc.tag) !== -1) {
+				const properties = tagDesc.tag === "title" ? titleTagProperties : metaTagProperties;
+				const tagDescKey = getTagKey(tagDesc, properties);
+				const index = tags.findIndex((prev) => prev.tag === tagDesc.tag && getTagKey(prev, properties) === tagDescKey);
+				if (index !== -1) tags.splice(index, 1);
+			}
+			tags.push(tagDesc);
+			return tags.length;
+		},
+		removeTag(tag, index) {}
+	};
+}
+var MetaProvider = (props) => {
+	const actions = initServerProvider();
+	return createComponent(MetaContext.Provider, {
+		value: actions,
+		get children() {
+			return props.children;
+		}
+	});
+};
+var MetaTag = (tag, props, setting) => {
+	useHead({
+		tag,
+		props,
+		setting,
+		id: createUniqueId(),
+		get name() {
+			return props.name || props.property;
+		}
+	});
+	return null;
+};
+function useHead(tagDesc) {
+	const c = useContext(MetaContext);
+	if (!c) throw new Error("<MetaProvider /> should be in the tree");
+	createRenderEffect(() => {
+		const index = c.addTag(tagDesc);
+		onCleanup(() => c.removeTag(tagDesc, index));
+	});
+}
+function renderTags(tags) {
+	return tags.map((tag) => {
+		const props = Object.keys(tag.props).map((k) => k === "children" ? "" : ` ${k}="${escape(tag.props[k], true)}"`).join("");
+		let children = tag.props.children;
+		if (Array.isArray(children)) children = children.join("");
+		if (tag.setting?.close) return `<${tag.tag} data-sm="${tag.id}"${props}>${tag.setting?.escape ? escape(children) : children || ""}</${tag.tag}>`;
+		return `<${tag.tag} data-sm="${tag.id}"${props}/>`;
+	}).join("");
+}
+var Title = (props) => MetaTag("title", props, {
+	escape: true,
+	close: true
+});
+//#endregion
+export { Title as n, MetaProvider as t };

package/.output/server/_ssr/dist-I7KRMRbA.mjs

@@ -0,0 +1,432 @@
+import { $ as splitProps, A as batch, H as createUniqueId, J as onCleanup, K as mergeProps, L as createMemo, V as createSignal, _ as ssrElement, tt as untrack } from "../_libs/solid-js.mjs";
+import { i as getDefault, v as safeParseAsync } from "../_libs/valibot.mjs";
+//#region node_modules/.nitro/vite/services/ssr/_build/assets/dist-I7KRMRbA.js
+var framework = "solid";
+// @__NO_SIDE_EFFECTS__
+function createSignal$1(initialValue) {
+	const [getSignal, setSignal] = createSignal(initialValue);
+	return {
+		get value() {
+			return getSignal();
+		},
+		set value(nextValue) {
+			setSignal(() => nextValue);
+		}
+	};
+}
+function initializeFieldStore(internalFormStore, internalFieldStore, schema, initialInput, path, nullish = false) {
+	if (framework === "qwik" && schema.type === "lazy" || schema.type === "object_with_rest" || schema.type === "record" || schema.type === "tuple_with_rest" || schema.type === "promise") throw new Error(`"${schema.type}" schema is not supported`);
+	else if (schema.type === "lazy") initializeFieldStore(internalFormStore, internalFieldStore, schema.getter(void 0), initialInput, path, nullish);
+	else if (schema.type === "exact_optional" || schema.type === "nullable" || schema.type === "nullish" || schema.type === "optional" || schema.type === "undefinedable") initializeFieldStore(internalFormStore, internalFieldStore, schema.wrapped, initialInput === void 0 ? getDefault(schema) : initialInput, path, true);
+	else if (schema.type === "non_nullable" || schema.type === "non_nullish" || schema.type === "non_optional") initializeFieldStore(internalFormStore, internalFieldStore, schema.wrapped, initialInput, path, nullish);
+	else if (schema.type === "intersect" || schema.type === "union" || schema.type === "variant") for (const schemaOption of schema.options) initializeFieldStore(internalFormStore, internalFieldStore, schemaOption, initialInput, path, nullish);
+	else {
+		internalFieldStore.schema = schema;
+		internalFieldStore.name = JSON.stringify(path);
+		internalFieldStore.path = path;
+		internalFieldStore.isNullish = nullish;
+		const initialElements = [];
+		internalFieldStore.initialElements = initialElements;
+		internalFieldStore.elements = initialElements;
+		internalFieldStore.errors = /* @__PURE__ */ createSignal$1(null);
+		internalFieldStore.isTouched = /* @__PURE__ */ createSignal$1(false);
+		internalFieldStore.isEdited = /* @__PURE__ */ createSignal$1(false);
+		internalFieldStore.isDirty = /* @__PURE__ */ createSignal$1(false);
+		if (schema.type === "array" || schema.type === "loose_tuple" || schema.type === "strict_tuple" || schema.type === "tuple") {
+			if (internalFieldStore.kind && internalFieldStore.kind !== "array") throw new Error(`Store initialized as "${internalFieldStore.kind}" cannot be reinitialized as "array"`);
+			internalFieldStore.kind = "array";
+			if (internalFieldStore.kind === "array") {
+				internalFieldStore.children ??= [];
+				if (schema.type === "array") {
+					if (initialInput) for (let index = 0; index < initialInput.length; index++) {
+						internalFieldStore.children[index] = {};
+						initializeFieldStore(internalFormStore, internalFieldStore.children[index], schema.item, initialInput[index], [...path, index]);
+					}
+				} else for (let index = 0; index < schema.items.length; index++) {
+					internalFieldStore.children[index] = {};
+					initializeFieldStore(internalFormStore, internalFieldStore.children[index], schema.items[index], initialInput?.[index], [...path, index]);
+				}
+				const arrayInput = nullish && initialInput == null ? initialInput : true;
+				internalFieldStore.initialInput = /* @__PURE__ */ createSignal$1(arrayInput);
+				internalFieldStore.startInput = /* @__PURE__ */ createSignal$1(arrayInput);
+				internalFieldStore.input = /* @__PURE__ */ createSignal$1(arrayInput);
+				const initialItems = internalFieldStore.children.map(createUniqueId);
+				internalFieldStore.initialItems = /* @__PURE__ */ createSignal$1(initialItems);
+				internalFieldStore.startItems = /* @__PURE__ */ createSignal$1(initialItems);
+				internalFieldStore.items = /* @__PURE__ */ createSignal$1(initialItems);
+			}
+		} else if (schema.type === "loose_object" || schema.type === "object" || schema.type === "strict_object") {
+			if (internalFieldStore.kind && internalFieldStore.kind !== "object") throw new Error(`Store initialized as "${internalFieldStore.kind}" cannot be reinitialized as "object"`);
+			internalFieldStore.kind = "object";
+			if (internalFieldStore.kind === "object") {
+				internalFieldStore.children ??= {};
+				for (const key in schema.entries) {
+					internalFieldStore.children[key] ??= {};
+					initializeFieldStore(internalFormStore, internalFieldStore.children[key], schema.entries[key], initialInput?.[key], [...path, key]);
+				}
+				const objectInput = nullish && initialInput == null ? initialInput : true;
+				internalFieldStore.initialInput = /* @__PURE__ */ createSignal$1(objectInput);
+				internalFieldStore.startInput = /* @__PURE__ */ createSignal$1(objectInput);
+				internalFieldStore.input = /* @__PURE__ */ createSignal$1(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") {
+				const valueInput = initialInput === void 0 && !nullish ? internalFormStore.emptyInput[schema.type] : initialInput;
+				internalFieldStore.initialInput = /* @__PURE__ */ createSignal$1(valueInput);
+				internalFieldStore.startInput = /* @__PURE__ */ createSignal$1(valueInput);
+				internalFieldStore.input = /* @__PURE__ */ createSignal$1(valueInput);
+			}
+		}
+	}
+}
+function resetItemState(internalFormStore, internalFieldStore, input, keepStart = false) {
+	batch(() => {
+		const elements = [];
+		if (internalFieldStore.elements === internalFieldStore.initialElements) internalFieldStore.initialElements = elements;
+		internalFieldStore.elements = elements;
+		internalFieldStore.errors.value = null;
+		internalFieldStore.isTouched.value = false;
+		internalFieldStore.isEdited.value = false;
+		internalFieldStore.isDirty.value = false;
+		if (internalFieldStore.kind === "array" || internalFieldStore.kind === "object") {
+			const objectInput = internalFieldStore.isNullish && input == null ? input : true;
+			if (!keepStart) internalFieldStore.startInput.value = objectInput;
+			internalFieldStore.input.value = objectInput;
+			if (internalFieldStore.kind === "array") {
+				const isTuple = internalFieldStore.schema.type !== "array";
+				if (input || isTuple) {
+					const length = isTuple ? internalFieldStore.children.length : input.length;
+					const newItems = Array.from({ length }, createUniqueId);
+					if (!keepStart) internalFieldStore.startItems.value = newItems;
+					internalFieldStore.items.value = newItems;
+					for (let index = 0; index < length; index++) {
+						const itemInput = input?.[index];
+						if (internalFieldStore.children[index]) resetItemState(internalFormStore, internalFieldStore.children[index], itemInput, keepStart);
+						else {
+							internalFieldStore.children[index] = {};
+							initializeFieldStore(internalFormStore, internalFieldStore.children[index], internalFieldStore.schema.item, itemInput, [...internalFieldStore.path, index]);
+						}
+					}
+				} else {
+					if (!keepStart) internalFieldStore.startItems.value = [];
+					internalFieldStore.items.value = [];
+				}
+			} else for (const key in internalFieldStore.children) resetItemState(internalFormStore, internalFieldStore.children[key], input?.[key], keepStart);
+		} else {
+			const valueInput = input === void 0 && !internalFieldStore.isNullish ? internalFormStore.emptyInput[internalFieldStore.schema.type] : input;
+			if (!keepStart) internalFieldStore.startInput.value = valueInput;
+			internalFieldStore.input.value = valueInput;
+		}
+	});
+}
+function focusFieldElement(internalFieldStore) {
+	for (const element of internalFieldStore.elements) {
+		element.focus();
+		if (element.getRootNode().activeElement === element) return true;
+	}
+	return false;
+}
+function walkFieldStore(internalFieldStore, callback) {
+	if (callback(internalFieldStore)) return true;
+	if (internalFieldStore.kind === "array") {
+		for (let index = 0; index < internalFieldStore.items.value.length; index++) if (walkFieldStore(internalFieldStore.children[index], callback)) return true;
+	} else if (internalFieldStore.kind === "object") {
+		for (const key in internalFieldStore.children) if (walkFieldStore(internalFieldStore.children[key], callback)) return true;
+	}
+	return false;
+}
+// @__NO_SIDE_EFFECTS__
+function getFieldBool(internalFieldStore, type) {
+	return walkFieldStore(internalFieldStore, (internalFieldStore$1) => Boolean(internalFieldStore$1[type].value));
+}
+// @__NO_SIDE_EFFECTS__
+function getFieldInput(internalFieldStore) {
+	if (internalFieldStore.kind === "array") {
+		if (internalFieldStore.input.value) {
+			const value = [];
+			for (let index = 0; index < internalFieldStore.items.value.length; index++) value[index] = /* @__PURE__ */ getFieldInput(internalFieldStore.children[index]);
+			return value;
+		}
+		return internalFieldStore.input.value;
+	}
+	if (internalFieldStore.kind === "object") {
+		if (internalFieldStore.input.value) {
+			const value = {};
+			for (const key in internalFieldStore.children) value[key] = /* @__PURE__ */ getFieldInput(internalFieldStore.children[key]);
+			return value;
+		}
+		return internalFieldStore.input.value;
+	}
+	return internalFieldStore.input.value;
+}
+// @__NO_SIDE_EFFECTS__
+function getElementInput(element, internalFieldStore) {
+	if (element.options && internalFieldStore.kind === "array") return [...element.options].filter((option) => option.selected && !option.disabled).map((option) => option.value);
+	if (element.type === "checkbox") {
+		if (internalFieldStore.kind === "array") return Array.from(document.getElementsByName(element.name)).filter((option) => option.checked && !option.disabled && option.form === element.form).map((option) => option.value);
+		return element.checked;
+	}
+	if (element.type === "radio") {
+		if (element.checked) return element.value;
+		return untrack(() => /* @__PURE__ */ getFieldInput(internalFieldStore));
+	}
+	if (element.type === "file") {
+		if (internalFieldStore.kind === "array") return [...element.files];
+		return element.files[0];
+	}
+	return element.value;
+}
+// @__NO_SIDE_EFFECTS__
+function getFieldStore(internalFormStore, path) {
+	let internalFieldStore = internalFormStore;
+	for (const key of path) {
+		if (internalFieldStore.kind === "array" && untrack(() => internalFieldStore.items.value)[key] === void 0) return;
+		internalFieldStore = internalFieldStore.children[key];
+	}
+	return internalFieldStore;
+}
+function setFieldBool(internalFieldStore, type, bool) {
+	batch(() => {
+		untrack(() => {
+			walkFieldStore(internalFieldStore, (internalFieldStore$1) => {
+				internalFieldStore$1[type].value = bool;
+			});
+		});
+	});
+}
+function setNestedInput(internalFormStore, internalFieldStore, input) {
+	internalFieldStore.isTouched.value = true;
+	internalFieldStore.isEdited.value = true;
+	if (internalFieldStore.kind === "array") {
+		const arrayInput = input ?? [];
+		const items = internalFieldStore.items.value;
+		const length = internalFieldStore.schema.type === "array" ? arrayInput.length : internalFieldStore.children.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.schema.item, arrayInput[index], [...internalFieldStore.path, index]);
+			}
+			internalFieldStore.items.value = [...items, ...Array.from({ length: length - items.length }, createUniqueId)];
+		}
+		for (let index = 0; index < length; index++) setNestedInput(internalFormStore, internalFieldStore.children[index], arrayInput[index]);
+		internalFieldStore.input.value = input == null ? input : true;
+		internalFieldStore.isDirty.value = internalFieldStore.startInput.value !== internalFieldStore.input.value || internalFieldStore.startItems.value.length !== internalFieldStore.items.value.length;
+	} else if (internalFieldStore.kind === "object") {
+		for (const key in internalFieldStore.children) setNestedInput(internalFormStore, internalFieldStore.children[key], input?.[key]);
+		internalFieldStore.input.value = input == null ? input : true;
+		internalFieldStore.isDirty.value = internalFieldStore.startInput.value !== internalFieldStore.input.value;
+	} else {
+		internalFieldStore.input.value = input;
+		const startInput = internalFieldStore.startInput.value;
+		internalFieldStore.isDirty.value = startInput !== input && (startInput != null || input !== "" && !Number.isNaN(input));
+	}
+}
+function setFieldInput(internalFormStore, path, input) {
+	batch(() => {
+		untrack(() => {
+			let internalFieldStore = internalFormStore;
+			for (let index = 0; index < path.length; index++) {
+				internalFieldStore = internalFieldStore.children[path[index]];
+				if (index < path.length - 1) {
+					internalFieldStore.input.value = true;
+					internalFieldStore.isDirty.value = internalFieldStore.startInput.value !== internalFieldStore.input.value || internalFieldStore.kind === "array" && internalFieldStore.startItems.value.join() !== internalFieldStore.items.value.join();
+				}
+			}
+			setNestedInput(internalFormStore, internalFieldStore, input);
+		});
+	});
+}
+var DEFAULT_EMPTY_INPUT = { string: "" };
+// @__NO_SIDE_EFFECTS__
+function createFormStore(config, parse) {
+	const store = {};
+	store.emptyInput = {
+		...DEFAULT_EMPTY_INPUT,
+		...config.emptyInput
+	};
+	store.validationId = 0;
+	store.validate = config.validate ?? "submit";
+	store.revalidate = config.revalidate ?? "input";
+	store.parse = parse;
+	store.isSubmitting = /* @__PURE__ */ createSignal$1(false);
+	store.isSubmitted = /* @__PURE__ */ createSignal$1(false);
+	store.isValidating = /* @__PURE__ */ createSignal$1(false);
+	initializeFieldStore(store, store, config.schema, config.initialInput, []);
+	return store;
+}
+async function validateFormInput(internalFormStore, config) {
+	const validationId = ++internalFormStore.validationId;
+	internalFormStore.isValidating.value = true;
+	try {
+		const result = await internalFormStore.parse(untrack(() => /* @__PURE__ */ getFieldInput(internalFormStore)));
+		if (internalFormStore.validationId !== validationId) return result;
+		let rootErrors;
+		let nestedErrors;
+		if (result.issues) {
+			nestedErrors = {};
+			for (const issue of result.issues) if (issue.path) {
+				const path = [];
+				for (const pathItem of issue.path) {
+					const key = pathItem.key;
+					const keyType = typeof key;
+					const itemType = pathItem.type;
+					if (keyType !== "string" && keyType !== "number" || itemType === "map" || itemType === "set") break;
+					path.push(key);
+				}
+				const name = JSON.stringify(path);
+				const fieldErrors = nestedErrors[name];
+				if (fieldErrors) fieldErrors.push(issue.message);
+				else nestedErrors[name] = [issue.message];
+			} else if (rootErrors) rootErrors.push(issue.message);
+			else rootErrors = [issue.message];
+		}
+		let shouldFocus = config?.shouldFocus ?? false;
+		batch(() => {
+			untrack(() => {
+				walkFieldStore(internalFormStore, (internalFieldStore) => {
+					if (internalFieldStore.path.length === 0) internalFieldStore.errors.value = rootErrors ?? null;
+					else {
+						const fieldErrors = nestedErrors?.[internalFieldStore.name] ?? null;
+						internalFieldStore.errors.value = fieldErrors;
+						if (shouldFocus && fieldErrors && focusFieldElement(internalFieldStore)) shouldFocus = false;
+					}
+				});
+			});
+			if (internalFormStore.validationId === validationId) internalFormStore.isValidating.value = false;
+		});
+		return result;
+	} catch (error) {
+		if (internalFormStore.validationId === validationId) internalFormStore.isValidating.value = false;
+		throw error;
+	}
+}
+function validateIfRequired(internalFormStore, internalFieldStore, validationMode) {
+	if (validationMode === (internalFormStore.validate === "initial" || (internalFormStore.validate === "submit" ? untrack(() => internalFormStore.isSubmitted.value) : untrack(() => /* @__PURE__ */ getFieldBool(internalFieldStore, "errors"))) ? internalFormStore.revalidate : internalFormStore.validate)) validateFormInput(internalFormStore);
+}
+var INTERNAL = "~internal";
+// @__NO_SIDE_EFFECTS__
+function createForm(config) {
+	const internalFormStore = /* @__PURE__ */ createFormStore(config, (input) => safeParseAsync(config.schema, input));
+	const getIsTouched = createMemo(() => /* @__PURE__ */ getFieldBool(internalFormStore, "isTouched"));
+	const getIsEdited = createMemo(() => /* @__PURE__ */ getFieldBool(internalFormStore, "isEdited"));
+	const getIsDirty = createMemo(() => /* @__PURE__ */ getFieldBool(internalFormStore, "isDirty"));
+	const getIsValid = createMemo(() => !/* @__PURE__ */ getFieldBool(internalFormStore, "errors"));
+	const form = {
+		[INTERNAL]: internalFormStore,
+		get isSubmitting() {
+			return internalFormStore.isSubmitting.value;
+		},
+		get isSubmitted() {
+			return internalFormStore.isSubmitted.value;
+		},
+		get isValidating() {
+			return internalFormStore.isValidating.value;
+		},
+		get isTouched() {
+			return getIsTouched();
+		},
+		get isEdited() {
+			return getIsEdited();
+		},
+		get isDirty() {
+			return getIsDirty();
+		},
+		get isValid() {
+			return getIsValid();
+		},
+		get errors() {
+			return internalFormStore.errors.value;
+		}
+	};
+	if (config.validate === "initial") validateFormInput(form[INTERNAL]);
+	return form;
+}
+function unwrap(value) {
+	if (typeof value === "function") return value();
+	return value;
+}
+// @__NO_SIDE_EFFECTS__
+function useField(form, config) {
+	const getPath = createMemo(() => unwrap(config).path);
+	const getInternalFormStore = createMemo(() => unwrap(form)[INTERNAL]);
+	const getInternalFieldStore = createMemo(() => /* @__PURE__ */ getFieldStore(getInternalFormStore(), getPath()));
+	const getInput2 = createMemo(() => /* @__PURE__ */ getFieldInput(getInternalFieldStore()));
+	const getIsTouched = createMemo(() => /* @__PURE__ */ getFieldBool(getInternalFieldStore(), "isTouched"));
+	const getIsEdited = createMemo(() => /* @__PURE__ */ getFieldBool(getInternalFieldStore(), "isEdited"));
+	const getIsDirty = createMemo(() => /* @__PURE__ */ getFieldBool(getInternalFieldStore(), "isDirty"));
+	const getIsValid = createMemo(() => !/* @__PURE__ */ getFieldBool(getInternalFieldStore(), "errors"));
+	return {
+		get path() {
+			return getPath();
+		},
+		get input() {
+			return getInput2();
+		},
+		get errors() {
+			return getInternalFieldStore().errors.value;
+		},
+		get isTouched() {
+			return getIsTouched();
+		},
+		get isEdited() {
+			return getIsEdited();
+		},
+		get isDirty() {
+			return getIsDirty();
+		},
+		get isValid() {
+			return getIsValid();
+		},
+		onInput(value) {
+			setFieldInput(getInternalFormStore(), getPath(), value);
+			validateIfRequired(getInternalFormStore(), getInternalFieldStore(), "input");
+		},
+		props: {
+			get name() {
+				return getInternalFieldStore().name;
+			},
+			autofocus: !!getInternalFieldStore().errors.value,
+			ref: (element) => {
+				const internalFieldStore = getInternalFieldStore();
+				if (!internalFieldStore.elements.includes(element)) internalFieldStore.elements.push(element);
+				onCleanup(() => {
+					const elements = internalFieldStore.elements.filter((el) => el !== element);
+					if (internalFieldStore.elements === internalFieldStore.initialElements) internalFieldStore.initialElements = elements;
+					else internalFieldStore.initialElements = internalFieldStore.initialElements.filter((el) => el !== element);
+					internalFieldStore.elements = elements;
+				});
+			},
+			onFocus() {
+				setFieldBool(getInternalFieldStore(), "isTouched", true);
+				validateIfRequired(getInternalFormStore(), getInternalFieldStore(), "touch");
+			},
+			onInput(event) {
+				const internalFieldStore = getInternalFieldStore();
+				setFieldInput(getInternalFormStore(), getPath(), /* @__PURE__ */ getElementInput(event.currentTarget, internalFieldStore));
+				validateIfRequired(getInternalFormStore(), internalFieldStore, "input");
+			},
+			onChange() {
+				validateIfRequired(getInternalFormStore(), getInternalFieldStore(), "change");
+			},
+			onBlur() {
+				validateIfRequired(getInternalFormStore(), getInternalFieldStore(), "blur");
+			}
+		}
+	};
+}
+// @__NO_SIDE_EFFECTS__
+function Field(props) {
+	const field = /* @__PURE__ */ useField(() => props.of, () => ({ path: props.path }));
+	return props.children(field);
+}
+// @__NO_SIDE_EFFECTS__
+function Form(props) {
+	const [, other] = splitProps(props, ["of", "onSubmit"]);
+	return ssrElement("form", mergeProps(other, { novalidate: true }), void 0, true);
+}
+//#endregion
+export { Form as n, createForm as r, Field as t };