@formisch/solid 0.1.0

package/dist/index.js

@@ -0,0 +1,696 @@
+import * as v from 'valibot';
+import { untrack, batch, createUniqueId, createMemo, onCleanup, splitProps, createSignal as createSignal$1 } from 'solid-js';
+import { memo, template, use, spread, mergeProps } from 'solid-js/web';
+
+// ../../packages/core/dist/index.solid.js
+var framework = "solid";
+function createSignal(initialValue) {
+  const [getSignal, setSignal] = createSignal$1(initialValue);
+  return {
+    get value() {
+      return getSignal();
+    },
+    set value(nextValue) {
+      setSignal(() => nextValue);
+    }
+  };
+}
+function initializeFieldStore(internalFieldStore, schema, initialInput, path) {
+  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(internalFieldStore, schema.getter(void 0), initialInput, path);
+  else if (schema.type === "exact_optional" || schema.type === "non_nullable" || schema.type === "non_nullish" || schema.type === "non_optional" || schema.type === "nullable" || schema.type === "nullish" || schema.type === "optional" || schema.type === "undefinedable") initializeFieldStore(internalFieldStore, schema.wrapped, initialInput ?? v.getDefault(schema), path);
+  else if (schema.type === "intersect" || schema.type === "union" || schema.type === "variant") for (const schemaOption of schema.options) initializeFieldStore(internalFieldStore, schemaOption, initialInput, path);
+  else {
+    internalFieldStore.schema = schema;
+    internalFieldStore.name = JSON.stringify(path);
+    internalFieldStore.elements = [];
+    internalFieldStore.errors = createSignal(null);
+    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] = {};
+            path.push(index);
+            initializeFieldStore(internalFieldStore.children[index], schema.item, initialInput[index], path);
+            path.pop();
+          }
+        } else for (let index = 0; index < schema.items; index++) {
+          internalFieldStore.children[index] = {};
+          path.push(index);
+          initializeFieldStore(internalFieldStore.children[index], schema.items[index], initialInput && initialInput[index], path);
+          path.pop();
+        }
+        const initialItems = internalFieldStore.children.map(createUniqueId);
+        internalFieldStore.initialItems = createSignal(initialItems);
+        internalFieldStore.startItems = createSignal(initialItems);
+        internalFieldStore.items = createSignal(initialItems);
+        internalFieldStore.isTouched = createSignal(false);
+        internalFieldStore.isDirty = createSignal(false);
+      }
+    } 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] = {};
+          path.push(key);
+          initializeFieldStore(internalFieldStore.children[key], schema.entries[key], initialInput && initialInput[key], path);
+          path.pop();
+        }
+      }
+    } else {
+      internalFieldStore.kind = "value";
+      if (internalFieldStore.kind === "value") {
+        internalFieldStore.initialInput = createSignal(initialInput);
+        internalFieldStore.startInput = createSignal(initialInput);
+        internalFieldStore.input = createSignal(initialInput);
+        internalFieldStore.isTouched = createSignal(false);
+        internalFieldStore.isDirty = createSignal(false);
+      }
+    }
+  }
+}
+function copyItemState(fromInternalFieldStore, toInternalFieldStore) {
+  batch(() => {
+    untrack(() => {
+      if (fromInternalFieldStore.kind === "array" && toInternalFieldStore.kind === "array") {
+        const fromItems = fromInternalFieldStore.items.value;
+        toInternalFieldStore.isTouched.value = fromInternalFieldStore.isTouched.value;
+        toInternalFieldStore.isDirty.value = fromInternalFieldStore.isDirty.value;
+        toInternalFieldStore.startItems.value = fromInternalFieldStore.startItems.value;
+        toInternalFieldStore.items.value = fromItems;
+        let path;
+        for (let index = 0; index < fromItems.length; index++) {
+          if (!toInternalFieldStore.children[index]) {
+            path ??= JSON.parse(toInternalFieldStore.name);
+            toInternalFieldStore.children[index] = {};
+            path.push(index);
+            initializeFieldStore(toInternalFieldStore.children[index], toInternalFieldStore.schema.item, void 0, path);
+            path.pop();
+          }
+          copyItemState(fromInternalFieldStore.children[index], toInternalFieldStore.children[index]);
+        }
+      } else if (fromInternalFieldStore.kind === "object" && toInternalFieldStore.kind === "object") for (const key in fromInternalFieldStore.children) copyItemState(fromInternalFieldStore.children[key], toInternalFieldStore.children[key]);
+      else if (fromInternalFieldStore.kind === "value" && toInternalFieldStore.kind === "value") {
+        toInternalFieldStore.isTouched.value = fromInternalFieldStore.isTouched.value;
+        toInternalFieldStore.isDirty.value = fromInternalFieldStore.isDirty.value;
+        toInternalFieldStore.startInput.value = fromInternalFieldStore.startInput.value;
+        toInternalFieldStore.input.value = fromInternalFieldStore.input.value;
+      }
+    });
+  });
+}
+function resetItemState(internalFieldStore, initialInput) {
+  batch(() => {
+    if (internalFieldStore.kind === "array") {
+      internalFieldStore.isTouched.value = false;
+      internalFieldStore.isDirty.value = false;
+      if (initialInput) {
+        const newItems = initialInput.map(createUniqueId);
+        internalFieldStore.startItems.value = newItems;
+        internalFieldStore.items.value = newItems;
+        for (let index = 0; index < initialInput.length; index++) if (internalFieldStore.children[index]) resetItemState(internalFieldStore.children[index], initialInput[index]);
+      } else {
+        internalFieldStore.startItems.value = [];
+        internalFieldStore.items.value = [];
+      }
+    } else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) resetItemState(internalFieldStore.children[key], initialInput?.[key]);
+    else {
+      internalFieldStore.isTouched.value = false;
+      internalFieldStore.isDirty.value = false;
+      internalFieldStore.startInput.value = initialInput;
+      internalFieldStore.input.value = initialInput;
+    }
+  });
+}
+function swapItemState(firstInternalFieldStore, secondInternalFieldStore) {
+  batch(() => {
+    untrack(() => {
+      if (firstInternalFieldStore.kind === "array" && secondInternalFieldStore.kind === "array") {
+        const firstItems = firstInternalFieldStore.items.value;
+        const secondItems = secondInternalFieldStore.items.value;
+        const tempIsTouched = firstInternalFieldStore.isTouched.value;
+        firstInternalFieldStore.isTouched.value = secondInternalFieldStore.isTouched.value;
+        secondInternalFieldStore.isTouched.value = tempIsTouched;
+        const tempIsDirty = firstInternalFieldStore.isDirty.value;
+        firstInternalFieldStore.isDirty.value = secondInternalFieldStore.isDirty.value;
+        secondInternalFieldStore.isDirty.value = tempIsDirty;
+        const tempStartItems = firstInternalFieldStore.startItems.value;
+        firstInternalFieldStore.startItems.value = secondInternalFieldStore.startItems.value;
+        secondInternalFieldStore.startItems.value = tempStartItems;
+        firstInternalFieldStore.items.value = secondItems;
+        secondInternalFieldStore.items.value = firstItems;
+        const maxLength = Math.max(firstItems.length, secondItems.length);
+        let firstPath;
+        let secondPath;
+        for (let index = 0; index < maxLength; index++) {
+          if (!firstInternalFieldStore.children[index]) {
+            firstPath ??= JSON.parse(firstInternalFieldStore.name);
+            firstInternalFieldStore.children[index] = {};
+            firstPath.push(index);
+            initializeFieldStore(firstInternalFieldStore.children[index], firstInternalFieldStore.schema.item, void 0, firstPath);
+            firstPath.pop();
+          }
+          if (!secondInternalFieldStore.children[index]) {
+            secondPath ??= JSON.parse(secondInternalFieldStore.name);
+            secondInternalFieldStore.children[index] = {};
+            secondPath.push(index);
+            initializeFieldStore(secondInternalFieldStore.children[index], secondInternalFieldStore.schema.item, void 0, secondPath);
+            secondPath.pop();
+          }
+          swapItemState(firstInternalFieldStore.children[index], secondInternalFieldStore.children[index]);
+        }
+      } else if (firstInternalFieldStore.kind === "object" && secondInternalFieldStore.kind === "object") for (const key in firstInternalFieldStore.children) swapItemState(firstInternalFieldStore.children[key], secondInternalFieldStore.children[key]);
+      else if (firstInternalFieldStore.kind === "value" && secondInternalFieldStore.kind === "value") {
+        const tempIsTouched = firstInternalFieldStore.isTouched.value;
+        firstInternalFieldStore.isTouched.value = secondInternalFieldStore.isTouched.value;
+        secondInternalFieldStore.isTouched.value = tempIsTouched;
+        const tempIsDirty = firstInternalFieldStore.isDirty.value;
+        firstInternalFieldStore.isDirty.value = secondInternalFieldStore.isDirty.value;
+        secondInternalFieldStore.isDirty.value = tempIsDirty;
+        const tempStartInput = firstInternalFieldStore.startInput.value;
+        firstInternalFieldStore.startInput.value = secondInternalFieldStore.startInput.value;
+        secondInternalFieldStore.startInput.value = tempStartInput;
+        const tempInput = firstInternalFieldStore.input.value;
+        firstInternalFieldStore.input.value = secondInternalFieldStore.input.value;
+        secondInternalFieldStore.input.value = tempInput;
+      }
+    });
+  });
+}
+function getFieldInput(internalFieldStore) {
+  if (internalFieldStore.kind === "array") {
+    const value = [];
+    for (let index = 0; index < internalFieldStore.items.value.length; index++) value[index] = getFieldInput(internalFieldStore.children[index]);
+    return value;
+  }
+  if (internalFieldStore.kind === "object") {
+    const value = {};
+    for (const key in internalFieldStore.children) value[key] = getFieldInput(internalFieldStore.children[key]);
+    return value;
+  }
+  return internalFieldStore.input.value;
+}
+function getElementInput(element, internalFieldStore) {
+  if (element.options && element.multiple) return [...element.options].filter((option) => option.selected && !option.disabled).map((option) => option.value);
+  if (element.type === "checkbox") {
+    const options = document.getElementsByName(element.name);
+    if (options.length > 1) return [...options].filter((option) => option.checked).map((option) => option.value);
+    return element.checked;
+  }
+  if (element.type === "radio") {
+    const prevValue = untrack(() => getFieldInput(internalFieldStore));
+    if (element.checked) return [...prevValue, element.value];
+    return prevValue.filter((value) => value !== element.value);
+  }
+  if (element.type === "file") {
+    if (element.multiple) return [...element.files];
+    return element.files[0];
+  }
+  return element.value;
+}
+function getFieldBool(internalFieldStore, type) {
+  if (internalFieldStore.kind === "array") {
+    if (internalFieldStore[type].value) return true;
+    for (let index = 0; index < internalFieldStore.items.value.length; index++) if (getFieldBool(internalFieldStore.children[index], type)) return true;
+    return false;
+  }
+  if (internalFieldStore.kind == "object") {
+    if (type === "errors" && internalFieldStore[type].value) return true;
+    for (const key in internalFieldStore.children) if (getFieldBool(internalFieldStore.children[key], type)) return true;
+    return false;
+  }
+  return !!internalFieldStore[type].value;
+}
+function getFieldStore(internalFormStore, path) {
+  let internalFieldStore = internalFormStore;
+  for (const key of path) internalFieldStore = internalFieldStore.children[key];
+  return internalFieldStore;
+}
+function setFieldBool(internalFieldStore, type, bool) {
+  batch(() => {
+    if (internalFieldStore.kind === "array") {
+      internalFieldStore[type].value = bool;
+      for (let index = 0; index < untrack(() => internalFieldStore.items.value).length; index++) setFieldBool(internalFieldStore.children[index], type, bool);
+    } else if (internalFieldStore.kind == "object") for (const key in internalFieldStore.children) setFieldBool(internalFieldStore.children[key], type, bool);
+    else internalFieldStore[type].value = bool;
+  });
+}
+function setFieldInput(internalFieldStore, input) {
+  batch(() => {
+    if (internalFieldStore.kind === "array") {
+      const items = untrack(() => internalFieldStore.items.value);
+      if (input.length < items.length) internalFieldStore.items.value = items.slice(0, input.length);
+      else if (input.length > items.length) {
+        if (input.length > internalFieldStore.children.length) {
+          const path = JSON.parse(internalFieldStore.name);
+          for (let index = internalFieldStore.children.length; index < input.length; index++) {
+            internalFieldStore.children[index] = {};
+            path.push(index);
+            initializeFieldStore(internalFieldStore.children[index], internalFieldStore.schema.item, input[index], path);
+            path.pop();
+          }
+        }
+        internalFieldStore.items.value = [...items, ...input.slice(items.length).map(createUniqueId)];
+      }
+      for (let index = 0; index < items.length; index++) setFieldInput(internalFieldStore.children[index], input[index]);
+      internalFieldStore.isDirty.value = untrack(() => internalFieldStore.startItems.value).length !== items.length;
+    } else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) setFieldInput(internalFieldStore.children[key], input[key]);
+    else {
+      internalFieldStore.input.value = input;
+      const startInput = untrack(() => internalFieldStore.startInput.value);
+      internalFieldStore.isDirty.value = startInput !== input && (startInput !== void 0 || input !== "" && !Number.isNaN(input));
+    }
+  });
+}
+function setInitialFieldInput(internalFieldStore, initialInput) {
+  batch(() => {
+    if (internalFieldStore.kind === "array") {
+      if (initialInput.length > internalFieldStore.children.length) {
+        const path = JSON.parse(internalFieldStore.name);
+        for (let index = internalFieldStore.children.length; index < initialInput.length; index++) {
+          internalFieldStore.children[index] = {};
+          path.push(index);
+          initializeFieldStore(internalFieldStore.children[index], internalFieldStore.schema.item, initialInput[index], path);
+          path.pop();
+        }
+      }
+      internalFieldStore.initialItems.value = initialInput.map(createUniqueId);
+      for (let index = 0; index < internalFieldStore.children.length; index++) setInitialFieldInput(internalFieldStore.children[index], initialInput?.[index]);
+    } else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) setInitialFieldInput(internalFieldStore.children[key], initialInput?.[key]);
+    else internalFieldStore.initialInput.value = initialInput;
+  });
+}
+function walkFieldStore(internalFieldStore, callback) {
+  callback(internalFieldStore);
+  if (internalFieldStore.kind === "array") for (let index = 0; index < untrack(() => internalFieldStore.items.value).length; index++) walkFieldStore(internalFieldStore.children[index], callback);
+  else if (internalFieldStore.kind === "object") for (const key in internalFieldStore.children) walkFieldStore(internalFieldStore.children[key], callback);
+}
+function createFormStore(config, validate2) {
+  const store = {};
+  initializeFieldStore(store, config.schema, config.initialInput, []);
+  store.validateOn = config.validateOn ?? "submit";
+  store.revalidateOn = config.revalidateOn ?? "input";
+  store.validate = validate2;
+  store.isSubmitting = createSignal(false);
+  store.isSubmitted = createSignal(false);
+  store.isValidating = createSignal(false);
+  return store;
+}
+async function validateFormInput(internalFormStore, config) {
+  internalFormStore.validators++;
+  internalFormStore.isValidating.value = true;
+  const result = await internalFormStore.validate(untrack(() => getFieldInput(internalFormStore)));
+  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(() => {
+    walkFieldStore(internalFormStore, (internalFieldStore) => {
+      if (internalFieldStore.name === "[]") internalFieldStore.errors.value = rootErrors ?? null;
+      else {
+        const fieldErrors = nestedErrors?.[internalFieldStore.name] ?? null;
+        internalFieldStore.errors.value = fieldErrors;
+        if (shouldFocus && fieldErrors) {
+          internalFieldStore.elements[0]?.focus();
+          shouldFocus = false;
+        }
+      }
+    });
+    internalFormStore.validators--;
+    internalFormStore.isValidating.value = internalFormStore.validators > 0;
+  });
+  return result;
+}
+function validateIfRequired(internalFormStore, internalFieldStore, validationModes) {
+  if (validationModes === (internalFormStore.validateOn === "initial" || (internalFormStore.validateOn === "submit" ? untrack(() => internalFormStore.isSubmitted.value) : untrack(() => getFieldBool(internalFieldStore, "errors"))) ? internalFormStore.revalidateOn : internalFormStore.validateOn)) validateFormInput(internalFormStore);
+}
+var INTERNAL = "~internal";
+
+// ../../packages/methods/dist/index.solid.js
+function focus(config) {
+  getFieldStore(config.form[INTERNAL], config.path).elements[0]?.focus();
+}
+function getAllErrors(form) {
+  let allErrors = null;
+  walkFieldStore(form[INTERNAL], (internalFieldStore) => {
+    const errors = internalFieldStore.errors.value;
+    if (errors) if (allErrors) allErrors.push(...errors);
+    else allErrors = [...errors];
+  });
+  return allErrors;
+}
+function getErrors(form, config) {
+  return (config?.path ? getFieldStore(form[INTERNAL], config.path) : form[INTERNAL]).errors.value;
+}
+function getInput(form, config) {
+  return getFieldInput(config?.path ? getFieldStore(form[INTERNAL], config.path) : form[INTERNAL]);
+}
+function insert(form, config) {
+  const internalFormStore = form[INTERNAL];
+  const internalArrayStore = getFieldStore(internalFormStore, config.path);
+  const items = untrack(() => internalArrayStore.items.value);
+  const insertIndex = config.at === void 0 ? items.length : config.at;
+  if (insertIndex >= 0 && insertIndex <= items.length) batch(() => {
+    const newItems = [...items];
+    newItems.splice(insertIndex, 0, createUniqueId());
+    internalArrayStore.items.value = newItems;
+    for (let index = items.length; index > insertIndex; index--) copyItemState(internalArrayStore.children[index - 1], internalArrayStore.children[index]);
+    if (!internalArrayStore.children[insertIndex]) {
+      const path = JSON.parse(internalArrayStore.name);
+      internalArrayStore.children[insertIndex] = {};
+      path.push(insertIndex);
+      initializeFieldStore(internalArrayStore.children[insertIndex], internalArrayStore.schema.item, config.initialInput, path);
+    } else resetItemState(internalArrayStore.children[insertIndex], config.initialInput);
+    internalArrayStore.isTouched.value = true;
+    internalArrayStore.isDirty.value = true;
+    validateIfRequired(internalFormStore, internalArrayStore, "input");
+  });
+}
+function move(form, config) {
+  const internalFormStore = form[INTERNAL];
+  const internalArrayStore = getFieldStore(internalFormStore, config.path);
+  const items = untrack(() => internalArrayStore.items.value);
+  if (config.from >= 0 && config.from <= items.length - 1 && config.to >= 0 && config.to <= items.length - 1 && config.from !== config.to) batch(() => {
+    const newItems = [...items];
+    newItems.splice(config.to, 0, newItems.splice(config.from, 1)[0]);
+    internalArrayStore.items.value = newItems;
+    const tempInternalFieldStore = {};
+    initializeFieldStore(tempInternalFieldStore, internalArrayStore.schema.item, void 0, []);
+    copyItemState(internalArrayStore.children[config.from < config.to ? config.from : config.to], tempInternalFieldStore);
+    if (config.from < config.to) for (let index = config.from; index < config.to; index++) copyItemState(internalArrayStore.children[index + 1], internalArrayStore.children[index]);
+    else for (let index = config.from; index > config.to; index--) copyItemState(internalArrayStore.children[index - 1], internalArrayStore.children[index]);
+    copyItemState(tempInternalFieldStore, internalArrayStore.children[config.from < config.to ? config.to : config.from]);
+    internalArrayStore.isTouched.value = true;
+    internalArrayStore.isDirty.value = internalArrayStore.startItems.value.join() !== newItems.join();
+    validateIfRequired(internalFormStore, internalArrayStore, "input");
+  });
+}
+function remove(form, config) {
+  const internalFormStore = form[INTERNAL];
+  const internalArrayStore = getFieldStore(internalFormStore, config.path);
+  const items = untrack(() => internalArrayStore.items.value);
+  if (config.at >= 0 && config.at <= items.length - 1) batch(() => {
+    const newItems = [...items];
+    newItems.splice(config.at, 1);
+    internalArrayStore.items.value = newItems;
+    for (let index = config.at; index < items.length - 1; index++) copyItemState(internalArrayStore.children[index + 1], internalArrayStore.children[index]);
+    internalArrayStore.isTouched.value = true;
+    internalArrayStore.isDirty.value = internalArrayStore.startItems.value.join() !== newItems.join();
+    validateIfRequired(internalFormStore, internalArrayStore, "input");
+  });
+}
+function replace(form, config) {
+  const internalFormStore = form[INTERNAL];
+  const internalArrayStore = getFieldStore(internalFormStore, config.path);
+  const items = untrack(() => internalArrayStore.items.value);
+  if (config.at >= 0 && config.at <= items.length - 1) batch(() => {
+    const newItems = [...items];
+    newItems[config.at] = createUniqueId();
+    internalArrayStore.items.value = newItems;
+    resetItemState(internalArrayStore.children[config.at], config.initialInput);
+    internalArrayStore.isTouched.value = true;
+    internalArrayStore.isDirty.value = true;
+    validateIfRequired(internalFormStore, internalArrayStore, "input");
+  });
+}
+function reset(form, config) {
+  batch(() => {
+    untrack(() => {
+      const internalFormStore = form[INTERNAL];
+      const internalFieldStore = config?.path ? getFieldStore(internalFormStore, config.path) : internalFormStore;
+      if (config?.initialInput) setInitialFieldInput(internalFieldStore, config.initialInput);
+      walkFieldStore(internalFieldStore, (internalFieldStore$1) => {
+        if (!config?.keepErrors) internalFieldStore$1.errors.value = null;
+        if (internalFieldStore$1.kind === "array") {
+          internalFieldStore$1.startItems.value = internalFieldStore$1.initialItems.value;
+          if (!config?.keepInput || internalFieldStore$1.startItems.value.length === internalFieldStore$1.items.value.length) internalFieldStore$1.items.value = internalFieldStore$1.initialItems.value;
+          if (!config?.keepTouched) internalFieldStore$1.isTouched.value = false;
+          internalFieldStore$1.isDirty.value = internalFieldStore$1.startItems.value !== internalFieldStore$1.items.value;
+        } else if (internalFieldStore$1.kind === "value") {
+          internalFieldStore$1.startInput.value = internalFieldStore$1.initialInput.value;
+          if (!config?.keepInput) internalFieldStore$1.input.value = internalFieldStore$1.initialInput.value;
+          if (!config?.keepTouched) internalFieldStore$1.isTouched.value = false;
+          internalFieldStore$1.isDirty.value = internalFieldStore$1.startInput.value !== internalFieldStore$1.input.value;
+          for (const element of internalFieldStore$1.elements) if (element.type === "file") element.value = "";
+        }
+      });
+      if (!config?.path) {
+        if (!config?.keepSubmitted) internalFormStore.isSubmitted.value = false;
+        if (internalFormStore.validateOn === "initial") validateFormInput(internalFormStore);
+      }
+    });
+  });
+}
+function setErrors(form, config) {
+  (config.path ? getFieldStore(form[INTERNAL], config.path) : form[INTERNAL]).errors.value = config.errors;
+}
+function setInput(form, config) {
+  batch(() => {
+    const internalFormStore = form[INTERNAL];
+    const internalFieldStore = config.path ? getFieldStore(internalFormStore, config.path) : internalFormStore;
+    setFieldBool(internalFieldStore, "isTouched", true);
+    setFieldInput(internalFieldStore, config.input);
+    validateIfRequired(internalFormStore, internalFieldStore, "input");
+  });
+}
+function submit(form) {
+  form[INTERNAL].element?.requestSubmit();
+}
+function swap(form, config) {
+  const internalFormStore = form[INTERNAL];
+  const internalArrayStore = getFieldStore(internalFormStore, config.path);
+  const items = untrack(() => internalArrayStore.items.value);
+  if (config.at >= 0 && config.at <= items.length - 1 && config.and >= 0 && config.and <= items.length - 1 && config.at !== config.and) batch(() => {
+    const newItems = [...items];
+    const tempItemId = newItems[config.at];
+    newItems[config.at] = newItems[config.and];
+    newItems[config.and] = tempItemId;
+    internalArrayStore.items.value = newItems;
+    swapItemState(internalArrayStore.children[config.at], internalArrayStore.children[config.and]);
+    internalArrayStore.isTouched.value = true;
+    internalArrayStore.isDirty.value = internalArrayStore.startItems.value.join() !== newItems.join();
+    validateIfRequired(internalFormStore, internalArrayStore, "input");
+  });
+}
+function validate(form, config) {
+  return validateFormInput(form[INTERNAL], config);
+}
+function createForm(config) {
+  const internalFormStore = createFormStore(
+    config,
+    async (input) => v.safeParseAsync(config.schema, input)
+  );
+  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 getFieldBool(internalFormStore, "isTouched");
+    },
+    get isDirty() {
+      return getFieldBool(internalFormStore, "isDirty");
+    },
+    get isValid() {
+      return !getFieldBool(internalFormStore, "errors");
+    },
+    get errors() {
+      return internalFormStore.errors.value;
+    }
+  };
+  if (config.validateOn === "initial") {
+    validateFormInput(form[INTERNAL]);
+  }
+  return form;
+}
+
+// src/utils/unwrap/unwrap.ts
+function unwrap(value) {
+  if (typeof value === "function") {
+    return value();
+  }
+  return value;
+}
+
+// src/primitives/useField/useField.ts
+function useField(form, config) {
+  const getInternalFormStore = createMemo(() => unwrap(form)[INTERNAL]);
+  const getInternalFieldStore = createMemo(
+    () => getFieldStore(getInternalFormStore(), unwrap(config).path)
+  );
+  return {
+    get path() {
+      return unwrap(config).path;
+    },
+    get input() {
+      return getFieldInput(getInternalFieldStore());
+    },
+    get errors() {
+      return getInternalFieldStore().errors.value;
+    },
+    get isTouched() {
+      return getFieldBool(getInternalFieldStore(), "isTouched");
+    },
+    get isDirty() {
+      return getFieldBool(getInternalFieldStore(), "isDirty");
+    },
+    get isValid() {
+      return !getFieldBool(getInternalFieldStore(), "errors");
+    },
+    props: {
+      get name() {
+        return getInternalFieldStore().name;
+      },
+      // eslint-disable-next-line solid/reactivity
+      autofocus: !!getInternalFieldStore().errors.value,
+      ref: (element) => {
+        const internalFieldStore = getInternalFieldStore();
+        internalFieldStore.elements.push(element);
+        onCleanup(() => {
+          internalFieldStore.elements = internalFieldStore.elements.filter(
+            (el) => el !== element
+          );
+        });
+      },
+      onFocus() {
+        setFieldBool(getInternalFieldStore(), "isTouched", true);
+        validateIfRequired(
+          getInternalFormStore(),
+          getInternalFieldStore(),
+          "touch"
+        );
+      },
+      onInput(event) {
+        const internalFieldStore = getInternalFieldStore();
+        const nextValue = getElementInput(
+          event.currentTarget,
+          internalFieldStore
+        );
+        setFieldInput(internalFieldStore, nextValue);
+        validateIfRequired(getInternalFormStore(), internalFieldStore, "input");
+      },
+      onChange() {
+        validateIfRequired(
+          getInternalFormStore(),
+          getInternalFieldStore(),
+          "change"
+        );
+      },
+      onBlur() {
+        validateIfRequired(
+          getInternalFormStore(),
+          getInternalFieldStore(),
+          "blur"
+        );
+      }
+    }
+  };
+}
+function useFieldArray(form, config) {
+  const getInternalFieldStore = createMemo(
+    () => getFieldStore(
+      unwrap(form)[INTERNAL],
+      unwrap(config).path
+    )
+  );
+  return {
+    get path() {
+      return unwrap(config).path;
+    },
+    get items() {
+      return getInternalFieldStore().items.value;
+    },
+    get errors() {
+      return getInternalFieldStore().errors.value;
+    },
+    get isTouched() {
+      return getFieldBool(getInternalFieldStore(), "isTouched");
+    },
+    get isDirty() {
+      return getFieldBool(getInternalFieldStore(), "isDirty");
+    },
+    get isValid() {
+      return !getFieldBool(getInternalFieldStore(), "errors");
+    }
+  };
+}
+
+// src/components/Field/Field.tsx
+function Field(props) {
+  const field = useField(() => props.of, {
+    get path() {
+      return props.path;
+    }
+  });
+  return memo(() => props.render(field));
+}
+function FieldArray(props) {
+  const field = useFieldArray(() => props.of, {
+    get path() {
+      return props.path;
+    }
+  });
+  return memo(() => props.render(field));
+}
+var _tmpl$ = /* @__PURE__ */ template(`<form>`);
+function Form(props) {
+  const [, other] = splitProps(props, ["of", "onSubmit"]);
+  return (() => {
+    var _el$ = _tmpl$();
+    use((element) => {
+      props.of[INTERNAL].element = element;
+    }, _el$);
+    spread(_el$, mergeProps(other, {
+      "novalidate": true,
+      "onSubmit": async (event) => {
+        event.preventDefault();
+        const internalFormStore = props.of[INTERNAL];
+        internalFormStore.isSubmitted.value = true;
+        internalFormStore.isSubmitting.value = true;
+        try {
+          const result = await validateFormInput(internalFormStore, {
+            shouldFocus: true
+          });
+          if (result.success) {
+            await props.onSubmit(result.output, event);
+          }
+        } catch (error) {
+          internalFormStore.errors.value = [error instanceof Error ? error.message : "An unknown error has occurred."];
+        } finally {
+          internalFormStore.isSubmitting.value = false;
+        }
+      }
+    }), false, false);
+    return _el$;
+  })();
+}
+
+export { Field, FieldArray, Form, createForm, focus, getAllErrors, getErrors, getInput, insert, move, remove, replace, reset, setErrors, setInput, submit, swap, useField, useFieldArray, validate };