@formisch/qwik 0.1.0

package/lib/packages/core/dist/index.qwik.qwik.cjs

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const v = require("valibot");
+const core = require("@qwik.dev/core");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const v__namespace = /* @__PURE__ */ _interopNamespaceDefault(v);
+function createId() {
+  return Math.random().toString(36).slice(2);
+}
+function batch(fn) {
+  return fn();
+}
+function initializeFieldStore(internalFieldStore, schema, initialInput, path) {
+  if (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__namespace.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 = core.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 ?? (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(createId);
+        internalFieldStore.initialItems = core.createSignal(initialItems);
+        internalFieldStore.startItems = core.createSignal(initialItems);
+        internalFieldStore.items = core.createSignal(initialItems);
+        internalFieldStore.isTouched = core.createSignal(false);
+        internalFieldStore.isDirty = core.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 ?? (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 = core.createSignal(initialInput);
+        internalFieldStore.startInput = core.createSignal(initialInput);
+        internalFieldStore.input = core.createSignal(initialInput);
+        internalFieldStore.isTouched = core.createSignal(false);
+        internalFieldStore.isDirty = core.createSignal(false);
+      }
+    }
+  }
+}
+function copyItemState(fromInternalFieldStore, toInternalFieldStore) {
+  batch(() => {
+    core.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 ?? (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(createId);
+        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(() => {
+    core.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 ?? (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 ?? (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 = core.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 < core.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 = core.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(createId)
+        ];
+      }
+      for (let index = 0; index < items.length; index++) setFieldInput(internalFieldStore.children[index], input[index]);
+      internalFieldStore.isDirty.value = core.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 = core.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(createId);
+      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 < core.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, validate) {
+  const store = {};
+  initializeFieldStore(store, config.schema, config.initialInput, []);
+  store.validateOn = config.validateOn ?? "submit";
+  store.revalidateOn = config.revalidateOn ?? "input";
+  store.validate = validate;
+  store.isSubmitting = core.createSignal(false);
+  store.isSubmitted = core.createSignal(false);
+  store.isValidating = core.createSignal(false);
+  return store;
+}
+async function validateFormInput(internalFormStore, config) {
+  internalFormStore.validators++;
+  internalFormStore.isValidating.value = true;
+  const result = await internalFormStore.validate(core.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" ? core.untrack(() => internalFormStore.isSubmitted.value) : core.untrack(() => getFieldBool(internalFieldStore, "errors"))) ? internalFormStore.revalidateOn : internalFormStore.validateOn)) validateFormInput(internalFormStore);
+}
+const INTERNAL = "~internal";
+Object.defineProperty(exports, "createSignal", {
+  enumerable: true,
+  get: () => core.createSignal
+});
+Object.defineProperty(exports, "untrack", {
+  enumerable: true,
+  get: () => core.untrack
+});
+exports.INTERNAL = INTERNAL;
+exports.batch = batch;
+exports.copyItemState = copyItemState;
+exports.createFormStore = createFormStore;
+exports.createId = createId;
+exports.getElementInput = getElementInput;
+exports.getFieldBool = getFieldBool;
+exports.getFieldInput = getFieldInput;
+exports.getFieldStore = getFieldStore;
+exports.initializeFieldStore = initializeFieldStore;
+exports.resetItemState = resetItemState;
+exports.setFieldBool = setFieldBool;
+exports.setFieldInput = setFieldInput;
+exports.setInitialFieldInput = setInitialFieldInput;
+exports.swapItemState = swapItemState;
+exports.validateFormInput = validateFormInput;
+exports.validateIfRequired = validateIfRequired;
+exports.walkFieldStore = walkFieldStore;