nuxt-ui-tools 0.1.2 → 1.0.0

package/dist/runtime/form/composables/use-form-validation.js

@@ -1,106 +1,1063 @@
-import { computed, ref } from "vue";
+import { useRegle } from "@regle/core";
+import { withAsync, withMessage } from "@regle/rules";
+import { computed, nextTick, reactive, ref, unref, watch } from "vue";
+import { calendarSeedFromValue, isDateFamilyRange } from "../fields/date-family/utils.js";
+import { resolveFieldDependencies } from "../utils/dependencies.js";
+import { createFormFieldInstance } from "../utils/field-instance.js";
+import { getPathValue, isRecord, pathSegments } from "../utils/path.js";
+import {
+  isBoolean,
+  isFunction,
+  isNumber,
+  isObject,
+  isString,
+  isUndefined
+} from "../utils/predicate.js";
 import {
-  collectFormFieldsPaths,
   fieldPath,
-  validateFormFields,
-  validateFormState
+  getArrayItemFields,
+  getMatrixRows,
+  getPrimitiveArrayItemField,
+  isArrayField,
+  isEmptyValue,
+  isFlatPassthroughField,
+  isObjectContainerField,
+  isPrimitiveArrayField,
+  resolveRequired,
+  resolveRequiredMessage,
+  shouldRenderField
 } from "../utils/state.js";
+import { resolveFormBoundaryText } from "../utils/text.js";
 export function useFormValidation(params) {
-  const validationErrors = ref([]);
   const customErrors = ref([]);
   const touchedPaths = ref([]);
+  const pendingPaths = ref(/* @__PURE__ */ new Map());
+  const dynamicMessages = ref(/* @__PURE__ */ new Map());
+  const validatedMessages = ref(/* @__PURE__ */ new Map());
   const validationRuns = /* @__PURE__ */ new Map();
+  const regle = useRegle(
+    params.state,
+    () => buildRegleRules({
+      apiFactory: params.apiFactory,
+      context: params.context,
+      dynamicMessages,
+      getDateMaxMessage: params.getDateMaxMessage,
+      getDateMinMessage: params.getDateMinMessage,
+      getRequiredMessage: params.getRequiredMessage,
+      getUniqueMessage: params.getUniqueMessage,
+      includeAsync: true,
+      mode: params.getValidationMode(),
+      schema: params.schema(),
+      state: params.state
+    }),
+    { autoDirty: false, debounce: 0, lazy: true }
+  );
+  const syncRegle = useRegle(
+    params.state,
+    () => buildRegleRules({
+      apiFactory: params.apiFactory,
+      context: params.context,
+      dynamicMessages,
+      getDateMaxMessage: params.getDateMaxMessage,
+      getDateMinMessage: params.getDateMinMessage,
+      getRequiredMessage: params.getRequiredMessage,
+      getUniqueMessage: params.getUniqueMessage,
+      includeAsync: false,
+      mode: params.getValidationMode(),
+      schema: params.schema(),
+      state: params.state
+    }),
+    { autoDirty: false, debounce: 0, lazy: true }
+  );
+  const itemsMirror = reactive({});
+  const itemsRegle = useRegle(
+    itemsMirror,
+    () => buildPrimitiveItemRules({
+      apiFactory: params.apiFactory,
+      context: params.context,
+      dynamicMessages,
+      getDateMaxMessage: params.getDateMaxMessage,
+      getDateMinMessage: params.getDateMinMessage,
+      getRequiredMessage: params.getRequiredMessage,
+      getUniqueMessage: params.getUniqueMessage,
+      includeAsync: true,
+      mode: params.getValidationMode(),
+      schema: params.schema(),
+      state: params.state
+    }),
+    { autoDirty: false, debounce: 0, lazy: true }
+  );
+  const itemsSyncRegle = useRegle(
+    itemsMirror,
+    () => buildPrimitiveItemRules({
+      apiFactory: params.apiFactory,
+      context: params.context,
+      dynamicMessages,
+      getDateMaxMessage: params.getDateMaxMessage,
+      getDateMinMessage: params.getDateMinMessage,
+      getRequiredMessage: params.getRequiredMessage,
+      getUniqueMessage: params.getUniqueMessage,
+      includeAsync: false,
+      mode: params.getValidationMode(),
+      schema: params.schema(),
+      state: params.state
+    }),
+    { autoDirty: false, debounce: 0, lazy: true }
+  );
+  watch(
+    () => collectPrimitiveArraysForSchema(params.schema(), params.state).map((target) => ({
+      items: getPathValue(params.state, target.path),
+      key: target.key
+    })),
+    syncItemsMirror,
+    { deep: true, flush: "sync", immediate: true }
+  );
+  function syncItemsMirror(targets) {
+    const keys = new Set(targets.map((target) => target.key));
+    for (const key of Object.keys(itemsMirror)) {
+      if (!keys.has(key)) {
+        Reflect.deleteProperty(itemsMirror, key);
+      }
+    }
+    for (const target of targets) {
+      const items = Array.isArray(target.items) ? target.items : [];
+      if (!Array.isArray(itemsMirror[target.key])) {
+        itemsMirror[target.key] = [];
+      }
+      const holders = itemsMirror[target.key];
+      if (!Array.isArray(holders)) {
+        continue;
+      }
+      for (const [index, item] of items.entries()) {
+        const holder = holders[index];
+        if (isRecord(holder)) {
+          holder.value = item;
+        } else {
+          holders[index] = { value: item };
+        }
+      }
+      if (holders.length > items.length) {
+        holders.splice(items.length);
+      }
+    }
+  }
+  function resetRegleRoots() {
+    regle.r$.$reset();
+    syncRegle.r$.$reset();
+    itemsRegle.r$.$reset();
+    itemsSyncRegle.r$.$reset();
+  }
+  const validationErrors = computed(
+    () => collectFormFieldsPathsForSchema(params.schema(), params.state).flatMap((path) => {
+      if (!touchedPaths.value.includes(path)) {
+        return [];
+      }
+      return resolveFieldErrors(path).map((message) => ({ message, path }));
+    })
+  );
   const errors = computed(() => [...validationErrors.value, ...customErrors.value]);
   async function validate() {
-    validationErrors.value = await validateFormState(
-      params.schema(),
-      params.state,
-      params.context,
-      params.apiFactory,
-      params.getValidationMode()
+    const run = nextValidationRun(validationRuns, "$form");
+    if (params.getValidationMode() === false) {
+      resetRegleRoots();
+      return true;
+    }
+    resetRegleRoots();
+    const paths = collectFormFieldsPathsForSchema(params.schema(), params.state);
+    clearDynamicMessages(paths);
+    clearValidatedMessages(paths);
+    const prepared = prepareReglePaths(
+      { items: itemsRegle.r$, main: regle.r$ },
+      { items: itemsSyncRegle.r$, main: syncRegle.r$ },
+      paths,
+      params.state
     );
-    touchErrorPaths(validationErrors.value);
-    return errors.value.length === 0;
+    const potentialAsyncPaths = prepared.regleStatuses.filter(({ status }) => hasAsyncRegleRule(status)).map(({ fieldPath: currentPath }) => currentPath);
+    const pendingToken = `form:${run}`;
+    addPendingPaths(pendingPaths, potentialAsyncPaths, pendingToken);
+    let asyncPaths = [];
+    let asyncValid = true;
+    try {
+      const syncResult = await validateSyncRegleStatuses(prepared.syncStatuses);
+      prepared.syncResults = syncResult.results;
+      storeValidatedMessages(prepared.syncStatuses);
+      touchPaths(paths);
+      asyncPaths = prepared.regleStatuses.filter(
+        ({ path, status }) => prepared.syncResults.get(path) !== false && hasAsyncRegleRule(status)
+      ).map(({ fieldPath: currentPath }) => currentPath);
+      removePendingPaths(
+        pendingPaths,
+        potentialAsyncPaths.filter((path) => !asyncPaths.includes(path)),
+        pendingToken
+      );
+      const nextAsyncStatuses = prepared.regleStatuses.filter(
+        ({ path }) => prepared.syncResults.get(path) !== false
+      );
+      asyncValid = await validateRegleStatuses(nextAsyncStatuses.map(({ status }) => status));
+      storeValidatedMessages(nextAsyncStatuses);
+      if (validationRuns.get("$form") !== run) {
+        return asyncValid;
+      }
+      return syncResult.valid && asyncValid && !hasBlockingErrors(paths);
+    } finally {
+      removePendingPaths(pendingPaths, potentialAsyncPaths, pendingToken);
+    }
   }
   async function validateFields(fields, parentPath) {
-    const key = scopeKey(fields, parentPath);
-    const run = (validationRuns.get(key) ?? 0) + 1;
-    validationRuns.set(key, run);
-    const nextErrors = await validateFormFields({
+    const paths = collectFormFieldsPathsForFields(
       fields,
-      state: params.state,
-      ctx: params.context,
-      apiFactory: params.apiFactory,
-      parentPath,
-      mode: params.getValidationMode()
-    });
-    if (validationRuns.get(key) !== run) return nextErrors.length === 0;
-    const fieldKeys = collectFormFieldsPaths(fields, parentPath);
-    touchPaths(fieldKeys);
-    const retained = validationErrors.value.filter(
-      (error) => !fieldKeys.some(
-        (fieldKey) => error.path === fieldKey || error.path.startsWith(`${fieldKey}.`)
-      )
+      params.state,
+      parentPath
     );
-    validationErrors.value = [...retained, ...nextErrors];
-    return nextErrors.length === 0;
+    const scope = paths.join("|") || parentPath.join(".") || "$fields";
+    const run = nextValidationRun(validationRuns, scope);
+    if (params.getValidationMode() === false) {
+      return true;
+    }
+    clearDynamicMessages(paths);
+    clearValidatedMessages(paths);
+    const prepared = prepareReglePaths(
+      { items: itemsRegle.r$, main: regle.r$ },
+      { items: itemsSyncRegle.r$, main: syncRegle.r$ },
+      paths,
+      params.state
+    );
+    const potentialAsyncPaths = prepared.regleStatuses.filter(({ status }) => hasAsyncRegleRule(status)).map(({ fieldPath: currentPath }) => currentPath);
+    const pendingToken = `scope:${scope}:${run}`;
+    addPendingPaths(pendingPaths, potentialAsyncPaths, pendingToken);
+    let asyncPaths = [];
+    let asyncValid = true;
+    try {
+      const syncResult = await validateSyncRegleStatuses(prepared.syncStatuses);
+      prepared.syncResults = syncResult.results;
+      storeValidatedMessages(prepared.syncStatuses);
+      touchPaths(paths);
+      asyncPaths = prepared.regleStatuses.filter(
+        ({ path, status }) => prepared.syncResults.get(path) !== false && hasAsyncRegleRule(status)
+      ).map(({ fieldPath: currentPath }) => currentPath);
+      removePendingPaths(
+        pendingPaths,
+        potentialAsyncPaths.filter((path) => !asyncPaths.includes(path)),
+        pendingToken
+      );
+      const nextAsyncStatuses = prepared.regleStatuses.filter(
+        ({ path }) => prepared.syncResults.get(path) !== false
+      );
+      asyncValid = await validateRegleStatuses(nextAsyncStatuses.map(({ status }) => status));
+      storeValidatedMessages(nextAsyncStatuses);
+      if (validationRuns.get(scope) !== run) {
+        return !validationErrors.value.some(
+          (error) => paths.some((path) => isScopedPath(error.path, path))
+        );
+      }
+      return syncResult.valid && asyncValid && !hasBlockingErrors(paths);
+    } finally {
+      removePendingPaths(pendingPaths, potentialAsyncPaths, pendingToken);
+    }
   }
   function getFieldError(path) {
     const key = path.join(".");
     const customError = customErrors.value.find((error) => error.path === key);
-    if (customError) return customError.message;
-    if (!touchedPaths.value.includes(key)) return void 0;
-    return validationErrors.value.find((error) => error.path === key)?.message;
+    if (customError) {
+      return customError.message;
+    }
+    if (!touchedPaths.value.includes(key)) {
+      return;
+    }
+    return resolveFieldErrors(key)[0];
   }
-  function setError(path, message) {
+  function setError(path, message, options) {
     const key = path.join(".");
     customErrors.value = [
       ...customErrors.value.filter((error) => error.path !== key),
-      { path: key, message }
+      { blocking: options?.blocking === true, message, path: key }
     ];
   }
+  function hasBlockingErrors(paths) {
+    return customErrors.value.some(
+      (error) => error.blocking === true && paths.some((path) => isScopedPath(error.path, path))
+    );
+  }
   function clearError(path) {
     if (!path) {
-      validationErrors.value = [];
       customErrors.value = [];
       touchedPaths.value = [];
+      dynamicMessages.value = /* @__PURE__ */ new Map();
+      validatedMessages.value = /* @__PURE__ */ new Map();
+      resetRegleRoots();
       return;
     }
     const key = path.join(".");
-    validationErrors.value = validationErrors.value.filter((error) => error.path !== key);
-    customErrors.value = customErrors.value.filter((error) => error.path !== key);
+    customErrors.value = customErrors.value.filter(
+      (error) => error.path !== key && !error.path.startsWith(`${key}.`)
+    );
+    touchedPaths.value = touchedPaths.value.filter(
+      (touchedPath) => touchedPath !== key && !touchedPath.startsWith(`${key}.`)
+    );
+    dynamicMessages.value = new Map(
+      [...dynamicMessages.value.entries()].filter(
+        ([messageKey]) => !messageKey.startsWith(`${key}:`)
+      )
+    );
+    validatedMessages.value = new Map(
+      [...validatedMessages.value.entries()].filter(
+        ([messagePath]) => messagePath !== key && !messagePath.startsWith(`${key}.`)
+      )
+    );
+  }
+  function clearValidationState() {
+    customErrors.value = [];
+    touchedPaths.value = [];
+    dynamicMessages.value = /* @__PURE__ */ new Map();
+    validatedMessages.value = /* @__PURE__ */ new Map();
+    resetRegleRoots();
+  }
+  function clearDynamicMessages(paths) {
+    dynamicMessages.value = new Map(
+      [...dynamicMessages.value.entries()].filter(
+        ([messageKey]) => !paths.some((path) => messageKey.startsWith(`${path}:`))
+      )
+    );
+  }
+  function clearValidatedMessages(paths) {
+    if (!paths.length) {
+      return;
+    }
+    validatedMessages.value = new Map(
+      [...validatedMessages.value.entries()].filter(([path]) => !paths.includes(path))
+    );
+  }
+  function storeValidatedMessages(statuses) {
+    const next = new Map(validatedMessages.value);
+    for (const { fieldPath: path, status } of statuses) {
+      next.set(path, resolveRegleStatusErrors(status));
+    }
+    validatedMessages.value = next;
+  }
+  function resolveFieldErrors(path) {
+    return validatedMessages.value.get(path) ?? [];
   }
   function markTouched(path) {
     touchPaths([path.join(".")]);
   }
-  function markAllTouched(paths) {
-    touchPaths(paths);
-  }
   function isTouched(path) {
+    return touchedPaths.value.includes(path.join("."));
+  }
+  function isPending(path) {
     const key = path.join(".");
-    return touchedPaths.value.includes(key);
+    if (pendingPaths.value.get(key)?.size) {
+      return true;
+    }
+    const status = resolveRegleStatus(regle.r$, toReglePath(path.join("."), params.state)) ?? resolvePrimitiveItemStatus(itemsRegle.r$, path.join("."));
+    if (!isPendingRegleStatus(status)) {
+      return false;
+    }
+    return readBooleanProperty(status, "$pending") || hasPendingRegleRule(readReactiveProperty(status, "$rules"));
   }
   function touchPaths(paths) {
     touchedPaths.value = unique([...touchedPaths.value, ...paths.filter(Boolean)]);
   }
-  function touchErrorPaths(nextErrors) {
-    touchPaths(nextErrors.map((error) => error.path));
-  }
   return {
+    clearError,
+    clearValidationState,
     errors,
-    validate,
-    validateFields,
     getFieldError,
-    setError,
-    clearError,
+    isPending,
+    isTouched,
     markTouched,
-    markAllTouched,
-    isTouched
+    setError,
+    validate,
+    validateFields,
+    validationErrors
   };
 }
-function scopeKey(fields, parentPath) {
-  return fields.map((field) => fieldPath(parentPath, field).join(".")).join("|") || parentPath.join(".") || "$form";
+function buildRegleRules(params) {
+  const rules = {};
+  if (isSteppedSchemaForRules(params.schema)) {
+    for (const step of getSchemaStepsForRules(params.schema)) {
+      const stepRules = buildFieldRules({
+        ...params,
+        fields: step.fields,
+        parentPath: step.root ? [step.root] : []
+      });
+      for (const [key, value] of Object.entries(stepRules)) {
+        if (value === void 0) {
+          continue;
+        }
+        setRegleRuleNode(rules, step.root ? `${step.root}.${key}` : key, value);
+      }
+    }
+    return rules;
+  }
+  return buildFieldRules({
+    ...params,
+    fields: getSchemaFieldsForRules(params.schema),
+    parentPath: []
+  });
+}
+function buildFieldRules(params) {
+  const rules = {};
+  for (const field of params.fields) {
+    if (field.ignore === true) {
+      continue;
+    }
+    const fieldInstance = createFormFieldInstance(field);
+    if (fieldInstance.state.is("stateless")) {
+      continue;
+    }
+    if (isFlatPassthroughField(field)) {
+      const childRules = buildFieldRules({ ...params, fields: getChildFieldsForRules(field) });
+      for (const [key, value] of Object.entries(childRules)) {
+        if (value !== void 0) {
+          setRegleRuleNode(rules, key, value);
+        }
+      }
+      continue;
+    }
+    const path = fieldPath(params.parentPath, field);
+    const api = params.apiFactory(path, field);
+    const callbackParams = {
+      api,
+      ctx: params.context,
+      deps: resolveFieldDependencies({
+        field,
+        parentPath: params.parentPath,
+        state: params.state
+      })
+    };
+    if (!shouldRenderField(field, callbackParams)) {
+      continue;
+    }
+    if (isObjectContainerField(field)) {
+      setRegleRuleNode(
+        rules,
+        field.key,
+        buildFieldRules({
+          ...params,
+          fields: getChildFieldsForRules(field),
+          parentPath: path
+        })
+      );
+      continue;
+    }
+    if (fieldInstance.type.is("matrix")) {
+      const matrixRules = {};
+      for (const row of getMatrixRows(field)) {
+        matrixRules[row] = buildFieldRules({
+          ...params,
+          fields: getChildFieldsForRules(field),
+          parentPath: [...path, row]
+        });
+      }
+      setRegleRuleNode(rules, field.key, matrixRules);
+      continue;
+    }
+    if (isPrimitiveArrayField(field)) {
+      setRegleRuleNode(rules, field.key, buildLeafRules({ ...params, callbackParams, field, path }));
+      continue;
+    }
+    if (isArrayField(field)) {
+      setRegleRuleNode(rules, field.key, {
+        $each: (item, index) => {
+          const itemValue = isRecord(item.value) ? item.value : {};
+          return buildFieldRules({
+            ...params,
+            fields: getArrayItemFields(field, itemValue),
+            parentPath: [...path, String(index)]
+          });
+        }
+      });
+      continue;
+    }
+    const fieldRules = buildLeafRules({ ...params, callbackParams, field, path });
+    if (Object.keys(fieldRules).length) {
+      setRegleRuleNode(rules, field.key, fieldRules);
+    }
+  }
+  return rules;
+}
+function setRegleRuleNode(target, key, value) {
+  const segments = pathSegments(key);
+  const leaf = segments.pop();
+  if (!leaf) {
+    return;
+  }
+  let current = target;
+  for (const segment of segments) {
+    const existing = current[segment];
+    if (isRegleRuleTreeNode(existing)) {
+      current = existing;
+      continue;
+    }
+    const branch = {};
+    current[segment] = branch;
+    current = branch;
+  }
+  current[leaf] = value;
+}
+function isRegleRuleTreeNode(value) {
+  return isRecord(value) && !("$each" in value);
+}
+function buildLeafRules(params) {
+  const output = {};
+  const validation = Object.getOwnPropertyDescriptor(params.field, "validation")?.value;
+  const key = params.path.join(".");
+  if (params.mode !== "rules" && resolveRequired(params.field, params.callbackParams)) {
+    output.required = withMessage(
+      (value) => !isEmptyValue(value),
+      resolveRequiredMessage(params.field, params.getRequiredMessage?.())
+    );
+  }
+  if (params.mode === "required") {
+    return output;
+  }
+  applyDateBoundsRules(output, params);
+  const authoredValidators = "validators" in params.field ? params.field.validators : void 0;
+  let validators;
+  if (isValidatorMap(authoredValidators)) {
+    validators = authoredValidators;
+  } else if (isFunction(authoredValidators)) {
+    validators = authoredValidators(params.callbackParams);
+  }
+  if (validators) {
+    for (const name in validators) {
+      const rule = validators[name];
+      if (rule) {
+        output[name] = rule;
+      }
+    }
+  }
+  const authoredRules = isRecord(validation) ? Object.getOwnPropertyDescriptor(validation, "rules")?.value : void 0;
+  if (!Array.isArray(authoredRules)) {
+    return output;
+  }
+  authoredRules.forEach((rule, index) => {
+    if (!isRecord(rule)) {
+      return;
+    }
+    const validate = Object.getOwnPropertyDescriptor(rule, "validate")?.value;
+    if (!isFunction(validate)) {
+      return;
+    }
+    if (!params.includeAsync && isAsyncFunction(validate)) {
+      return;
+    }
+    const ruleName = resolveRuleName(rule, index);
+    const messageKey = `${key}:${ruleName}`;
+    function message() {
+      return params.dynamicMessages.value.get(messageKey) ?? resolveRuleMessage(rule, params.field);
+    }
+    if (isAsyncFunction(validate)) {
+      output[ruleName] = withMessage(
+        withAsync(
+          async () => resolveRuleResult(
+            await validate({ ...params.callbackParams, api: params.callbackParams.api }),
+            messageKey,
+            params.dynamicMessages
+          )
+        ),
+        message
+      );
+    } else {
+      output[ruleName] = withMessage(
+        () => resolveRuleResult(
+          validate({ ...params.callbackParams, api: params.callbackParams.api }),
+          messageKey,
+          params.dynamicMessages
+        ),
+        message
+      );
+    }
+  });
+  return output;
+}
+function isValidatorMap(value) {
+  return isObject(value);
+}
+function resolveRuleResult(result, messageKey, dynamicMessages) {
+  if (isString(result)) {
+    setDynamicMessage(dynamicMessages, messageKey, result);
+    return false;
+  }
+  clearDynamicMessage(dynamicMessages, messageKey);
+  return result === true || result === null || isUndefined(result);
+}
+function isAsyncFunction(value) {
+  return Object.getPrototypeOf(value)?.constructor?.name === "AsyncFunction";
+}
+function setDynamicMessage(messages, key, value) {
+  const next = new Map(messages.value);
+  next.set(key, value);
+  messages.value = next;
+}
+function clearDynamicMessage(messages, key) {
+  if (!messages.value.has(key)) {
+    return;
+  }
+  const next = new Map(messages.value);
+  next.delete(key);
+  messages.value = next;
+}
+function resolveRuleName(rule, index) {
+  const name = Object.getOwnPropertyDescriptor(rule, "name")?.value;
+  return isString(name) && name.length ? name : `rule-${index + 1}`;
+}
+function resolveRuleMessage(rule, field) {
+  const message = Object.getOwnPropertyDescriptor(rule, "message")?.value;
+  if (isFunction(message)) {
+    return String(message());
+  }
+  if (isString(message) || isNumber(message)) {
+    return String(message);
+  }
+  const name = Object.getOwnPropertyDescriptor(rule, "name")?.value;
+  return isString(name) ? `Invalid value for ${name}.` : `Invalid value for ${field.key}.`;
+}
+function resolveRegleStatusErrors(status) {
+  const errors = readReactiveProperty(status, "$errors");
+  return Array.isArray(errors) ? errors.map(String) : [];
+}
+function toReglePath(path, state) {
+  const reglePath = [];
+  let current = state;
+  for (const segment of pathSegments(path)) {
+    if (Array.isArray(current) && /^\d+$/u.test(segment)) {
+      reglePath.push("$each");
+    }
+    reglePath.push(segment);
+    current = Array.isArray(current) ? current[Number(segment)] : isRecord(current) ? current[segment] : void 0;
+  }
+  return reglePath.join(".");
+}
+function collectFormFieldsPathsForSchema(schema, state) {
+  if (isSteppedSchemaForRules(schema)) {
+    return getSchemaStepsForRules(schema).flatMap(
+      (step) => collectFormFieldsPathsForFields(step.fields, state, step.root ? [step.root] : [])
+    );
+  }
+  return collectFormFieldsPathsForFields(getSchemaFieldsForRules(schema), state, []);
+}
+function collectFormFieldsPathsForFields(fields, state, parentPath) {
+  return fields.flatMap((field) => {
+    if (field.ignore === true) {
+      return [];
+    }
+    const fieldInstance = createFormFieldInstance(field);
+    if (fieldInstance.state.is("stateless")) {
+      return [];
+    }
+    if (isFlatPassthroughField(field)) {
+      return collectFormFieldsPathsForFields(getChildFieldsForRules(field), state, parentPath);
+    }
+    const path = fieldPath(parentPath, field);
+    if (isObjectContainerField(field)) {
+      return collectFormFieldsPathsForFields(getChildFieldsForRules(field), state, path);
+    }
+    if (fieldInstance.type.is("matrix")) {
+      return getMatrixRows(field).flatMap(
+        (row) => collectFormFieldsPathsForFields(getChildFieldsForRules(field), state, [...path, row])
+      );
+    }
+    if (isPrimitiveArrayField(field)) {
+      const value = getPathValue(state, path);
+      const itemPaths = Array.isArray(value) ? value.map((_item, index) => [...path, String(index)].join(".")) : [];
+      return [path.join("."), ...itemPaths];
+    }
+    if (isArrayField(field)) {
+      const value = getPathValue(state, path);
+      if (!Array.isArray(value)) {
+        return [];
+      }
+      return value.flatMap(
+        (item, index) => collectFormFieldsPathsForFields(
+          getArrayItemFields(field, isRecord(item) ? item : {}),
+          state,
+          [...path, String(index)]
+        )
+      );
+    }
+    return [path.join(".")];
+  });
+}
+function isScopedPath(path, scope) {
+  return path === scope || path.startsWith(`${scope}.`);
+}
+function getSchemaFieldsForRules(schema) {
+  if (!isRecord(schema)) {
+    return [];
+  }
+  const fields = Object.getOwnPropertyDescriptor(schema, "fields")?.value;
+  return Array.isArray(fields) ? fields.filter(isFormFieldForRules) : [];
+}
+function getSchemaStepsForRules(schema) {
+  if (!isRecord(schema)) {
+    return [];
+  }
+  const steps = Object.getOwnPropertyDescriptor(schema, "steps")?.value;
+  if (!Array.isArray(steps)) {
+    return [];
+  }
+  return steps.flatMap((step) => {
+    if (!isRecord(step)) {
+      return [];
+    }
+    const fields = Object.getOwnPropertyDescriptor(step, "fields")?.value;
+    if (!Array.isArray(fields)) {
+      return [];
+    }
+    const root = Object.getOwnPropertyDescriptor(step, "root")?.value;
+    return [
+      {
+        fields: fields.filter(isFormFieldForRules),
+        root: isString(root) ? root : void 0
+      }
+    ];
+  });
+}
+function isSteppedSchemaForRules(schema) {
+  return getSchemaStepsForRules(schema).length > 0;
+}
+function getChildFieldsForRules(field) {
+  const tabs = Object.getOwnPropertyDescriptor(field, "tabs")?.value;
+  if (Array.isArray(tabs)) {
+    return tabs.flatMap((tab) => {
+      const fields2 = isRecord(tab) ? tab.fields : void 0;
+      return Array.isArray(fields2) ? fields2.filter(isFormFieldForRules) : [];
+    });
+  }
+  const fields = Object.getOwnPropertyDescriptor(field, "fields")?.value;
+  return Array.isArray(fields) ? fields.filter(isFormFieldForRules) : [];
+}
+function isFormFieldForRules(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return isString(value.key) && isString(value.type);
+}
+function mirrorKey(path) {
+  return path.join("/");
+}
+function resolvePrimitiveItemStatus(root, path) {
+  const segments = pathSegments(path);
+  const index = segments.at(-1);
+  if (index === void 0 || !/^\d+$/u.test(index)) {
+    return void 0;
+  }
+  const key = mirrorKey(segments.slice(0, -1));
+  if (resolveRegleStatus(root, key) === void 0) {
+    return void 0;
+  }
+  return resolveRegleStatus(root, `${key}.$each.${index}.value`);
+}
+function collectPrimitiveArraysForSchema(schema, state) {
+  if (isSteppedSchemaForRules(schema)) {
+    return getSchemaStepsForRules(schema).flatMap(
+      (step) => collectPrimitiveArraysForFields(step.fields, state, step.root ? [step.root] : [])
+    );
+  }
+  return collectPrimitiveArraysForFields(getSchemaFieldsForRules(schema), state, []);
+}
+function collectPrimitiveArraysForFields(fields, state, parentPath) {
+  return fields.flatMap((field) => {
+    if (field.ignore === true) {
+      return [];
+    }
+    const fieldInstance = createFormFieldInstance(field);
+    if (fieldInstance.state.is("stateless")) {
+      return [];
+    }
+    if (isFlatPassthroughField(field)) {
+      return collectPrimitiveArraysForFields(getChildFieldsForRules(field), state, parentPath);
+    }
+    const path = fieldPath(parentPath, field);
+    if (isObjectContainerField(field)) {
+      return collectPrimitiveArraysForFields(getChildFieldsForRules(field), state, path);
+    }
+    if (fieldInstance.type.is("matrix")) {
+      return getMatrixRows(field).flatMap(
+        (row) => collectPrimitiveArraysForFields(getChildFieldsForRules(field), state, [...path, row])
+      );
+    }
+    if (isPrimitiveArrayField(field)) {
+      return [{ field, key: mirrorKey(path), path }];
+    }
+    if (isArrayField(field)) {
+      const value = getPathValue(state, path);
+      if (!Array.isArray(value)) {
+        return [];
+      }
+      return value.flatMap(
+        (item, index) => collectPrimitiveArraysForFields(
+          getArrayItemFields(field, isRecord(item) ? item : {}),
+          state,
+          [...path, String(index)]
+        )
+      );
+    }
+    return [];
+  });
+}
+function buildPrimitiveItemRules(params) {
+  const rules = {};
+  for (const target of collectPrimitiveArraysForSchema(params.schema, params.state)) {
+    const deps = resolveFieldDependencies({
+      field: target.field,
+      parentPath: target.path.slice(0, -1),
+      state: params.state
+    });
+    const collection = {
+      $each: (_item, index) => {
+        const itemField = getPrimitiveArrayItemField(target.field, index);
+        if (!itemField) {
+          return {};
+        }
+        const itemPath = [...target.path, String(index)];
+        const itemRules = buildLeafRules({
+          ...params,
+          callbackParams: {
+            api: params.apiFactory(itemPath, itemField),
+            ctx: params.context,
+            deps
+          },
+          field: itemField,
+          path: itemPath
+        });
+        if (params.mode !== "required" && isUniqueArrayField(target.field)) {
+          itemRules.unique = withMessage(
+            (value) => countArrayValue(getPathValue(params.state, target.path), value) <= 1,
+            resolveUniqueMessage(target.field, params.getUniqueMessage?.())
+          );
+        }
+        return { value: itemRules };
+      }
+    };
+    rules[target.key] = collection;
+  }
+  return rules;
+}
+const DATE_VALIDATION_TYPES = /* @__PURE__ */ new Set([
+  "date",
+  "datetime",
+  "daterange",
+  "monthrange",
+  "datetimerange",
+  "month",
+  "year"
+]);
+function isDateFamilyField(field) {
+  const type = Object.getOwnPropertyDescriptor(field, "type")?.value;
+  return isString(type) && DATE_VALIDATION_TYPES.has(type);
+}
+function applyDateBoundsRules(output, params) {
+  if (!isDateFamilyField(params.field)) {
+    return;
+  }
+  const dateField = params.field;
+  const bounds = resolveDateFieldBounds(dateField, params.callbackParams);
+  if (bounds.min !== void 0) {
+    output.dateMin = withMessage(
+      (value) => isWithinDateMin(value, bounds.min, dateField.type),
+      params.getDateMinMessage?.(bounds.minLabel ?? "") ?? `Must be on or after ${bounds.minLabel}`
+    );
+  }
+  if (bounds.max !== void 0) {
+    output.dateMax = withMessage(
+      (value) => isWithinDateMax(value, bounds.max, dateField.type),
+      params.getDateMaxMessage?.(bounds.maxLabel ?? "") ?? `Must be on or before ${bounds.maxLabel}`
+    );
+  }
+}
+function resolveDateFieldBounds(field, callbackParams) {
+  const rawProps = Object.getOwnPropertyDescriptor(field, "props")?.value;
+  const resolved = isFunction(rawProps) ? rawProps(callbackParams) : rawProps;
+  const propsRecord = isRecord(resolved) ? resolved : {};
+  if (field.type === "year") {
+    const min2 = isNumber(propsRecord.min) ? propsRecord.min : void 0;
+    const max2 = isNumber(propsRecord.max) ? propsRecord.max : void 0;
+    return {
+      max: max2,
+      maxLabel: max2 === void 0 ? void 0 : String(max2),
+      min: min2,
+      minLabel: min2 === void 0 ? void 0 : String(min2)
+    };
+  }
+  const minSeed = isDateSeedValue(propsRecord.min) ? propsRecord.min : null;
+  const maxSeed = isDateSeedValue(propsRecord.max) ? propsRecord.max : null;
+  const min = calendarSeedFromValue(minSeed, field.type) || void 0;
+  const max = calendarSeedFromValue(maxSeed, field.type) || void 0;
+  return { max, maxLabel: max, min, minLabel: min };
+}
+function isDateSeedValue(value) {
+  return value instanceof Date || isString(value) || isNumber(value) || value === null || value === void 0;
+}
+function dateFieldBoundValue(value, type, edge) {
+  if (!isDateFamilyRange(type)) {
+    return value;
+  }
+  return Array.isArray(value) ? value[edge === "start" ? 0 : 1] : void 0;
+}
+function isWithinDateMin(value, min, type) {
+  if (min === void 0) {
+    return true;
+  }
+  const bound = dateFieldBoundValue(value, type, "start");
+  if (isEmptyValue(bound)) {
+    return true;
+  }
+  if (isNumber(min)) {
+    const numeric = isString(bound) ? Number(bound) : Number.NaN;
+    return Number.isNaN(numeric) || numeric >= min;
+  }
+  const canonical = calendarSeedFromValue(isDateSeedValue(bound) ? bound : null, type);
+  return !canonical || canonical >= min;
+}
+function isWithinDateMax(value, max, type) {
+  if (max === void 0) {
+    return true;
+  }
+  const bound = dateFieldBoundValue(value, type, "end");
+  if (isEmptyValue(bound)) {
+    return true;
+  }
+  if (isNumber(max)) {
+    const numeric = isString(bound) ? Number(bound) : Number.NaN;
+    return Number.isNaN(numeric) || numeric <= max;
+  }
+  const canonical = calendarSeedFromValue(isDateSeedValue(bound) ? bound : null, type);
+  return !canonical || canonical <= max;
+}
+function isUniqueArrayField(field) {
+  return Object.getOwnPropertyDescriptor(field, "unique")?.value === true;
+}
+function resolveUniqueMessage(field, fallback) {
+  const message = Object.getOwnPropertyDescriptor(field, "uniqueMessage")?.value;
+  return resolveFormBoundaryText(message) ?? fallback ?? "This value is already in the list";
+}
+function sameArrayValue(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (!isRecord(left) && !Array.isArray(left)) {
+    return false;
+  }
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function countArrayValue(values, value) {
+  if (!Array.isArray(values) || isEmptyValue(value)) {
+    return 0;
+  }
+  return values.filter((candidate) => sameArrayValue(candidate, value)).length;
 }
 function unique(values) {
   return [...new Set(values)];
 }
+function nextValidationRun(runs, key) {
+  const run = (runs.get(key) ?? 0) + 1;
+  runs.set(key, run);
+  return run;
+}
+function addPendingPaths(pendingPaths, paths, token) {
+  if (!paths.length) {
+    return;
+  }
+  const next = new Map(pendingPaths.value);
+  for (const path of paths) {
+    const tokens = new Set(next.get(path) ?? []);
+    tokens.add(token);
+    next.set(path, tokens);
+  }
+  pendingPaths.value = next;
+}
+function removePendingPaths(pendingPaths, paths, token) {
+  if (!paths.length) {
+    return;
+  }
+  const next = new Map(pendingPaths.value);
+  for (const path of paths) {
+    const tokens = new Set(next.get(path) ?? []);
+    tokens.delete(token);
+    if (tokens.size) {
+      next.set(path, tokens);
+    } else {
+      next.delete(path);
+    }
+  }
+  pendingPaths.value = next;
+}
+function hasAsyncRegleRule(status) {
+  const rules = readReactiveProperty(status, "$rules");
+  if (!isRecord(rules)) {
+    return false;
+  }
+  return Object.values(rules).some((rule) => readBooleanProperty(rule, "$haveAsync"));
+}
+function prepareReglePaths(regle, syncRegle, paths, state) {
+  const regleStatuses = collectRegleStatuses(regle, paths, state);
+  const syncStatuses = collectRegleStatuses(syncRegle, paths, state);
+  regleStatuses.forEach(({ status }) => status.$reset());
+  syncStatuses.forEach(({ status }) => status.$reset());
+  return {
+    regleStatuses,
+    syncResults: /* @__PURE__ */ new Map(),
+    syncStatuses
+  };
+}
+async function validateSyncRegleStatuses(statuses) {
+  const validations = statuses.map(({ status }) => status.$validateWithoutRaceconditions());
+  await Promise.all(validations);
+  const results = statuses.map(
+    ({ path, status }) => [path, !readBooleanProperty(status, "$invalid")]
+  );
+  return { results: new Map(results), valid: results.every(([, valid]) => valid) };
+}
+function collectRegleStatuses(regle, paths, state) {
+  return unique(paths).flatMap((candidatePath) => {
+    const path = toReglePath(candidatePath, state);
+    const status = resolveRegleStatus(regle.main, path) ?? resolvePrimitiveItemStatus(regle.items, candidatePath);
+    return isValidatableRegleStatus(status) ? [{ fieldPath: candidatePath, path, status }] : [];
+  });
+}
+async function validateRegleStatuses(statuses) {
+  if (!statuses.length) {
+    return true;
+  }
+  statuses.forEach((status) => status.$touch(false));
+  await nextTick();
+  const validations = statuses.map((status) => status.$validateWithoutRaceconditions());
+  await Promise.all(validations);
+  return statuses.every((status) => !readBooleanProperty(status, "$invalid"));
+}
+function resolveRegleStatus(regle, path) {
+  return pathSegments(path).reduce((current, segment) => {
+    if (Array.isArray(current)) {
+      return current[Number(segment)];
+    }
+    if (!isObject(current)) {
+      return;
+    }
+    return current[segment];
+  }, regle);
+}
+function isValidatableRegleStatus(value) {
+  return isObject(value) && value !== null && isBoolean(readReactiveProperty(value, "$invalid")) && isFunction(readReactiveProperty(value, "$reset")) && isFunction(readReactiveProperty(value, "$validate")) && isFunction(readReactiveProperty(value, "$validateWithoutRaceconditions"));
+}
+function isPendingRegleStatus(value) {
+  return isObject(value) && value !== null && isBoolean(readReactiveProperty(value, "$pending")) && isObject(readReactiveProperty(value, "$rules"));
+}
+function hasPendingRegleRule(value) {
+  if (!isObject(value) || value === null) {
+    return false;
+  }
+  return Object.values(value).some(
+    (rule) => readBooleanProperty(rule, "$pending") || readBooleanProperty(rule, "$validating") || readBooleanProperty(rule, "$maybePending")
+  );
+}
+function readBooleanProperty(value, key) {
+  return readReactiveProperty(value, key) === true;
+}
+function readReactiveProperty(value, key) {
+  if (!isRecord(value)) {
+    return;
+  }
+  return unref(Object.getOwnPropertyDescriptor(value, key)?.value);
+}