@regle/core 0.4.5 → 0.4.6-beta.2

package/dist/regle-core.cjs

@@ -0,0 +1,1983 @@
+'use strict';
+
+var vue = require('vue');
+
+// src/types/rules/rule.internal.types.ts
+var InternalRuleType = /* @__PURE__ */ ((InternalRuleType2) => {
+  InternalRuleType2["Inline"] = "__inline";
+  InternalRuleType2["Async"] = "__async";
+  return InternalRuleType2;
+})(InternalRuleType || {});
+function mergeBooleanGroupProperties(entries, property) {
+  return entries.some((entry) => {
+    return entry[property];
+  });
+}
+function mergeArrayGroupProperties(entries, property) {
+  return entries.reduce((all, entry) => {
+    const fetchedProperty = entry[property] || [];
+    return all.concat(fetchedProperty);
+  }, []);
+}
+function unwrapRuleParameters(params) {
+  try {
+    return params.map((param) => {
+      if (param instanceof Function) {
+        try {
+          const result = param();
+          return result;
+        } catch (e) {
+          return null;
+        }
+      }
+      return vue.unref(param);
+    });
+  } catch (e) {
+    return [];
+  }
+}
+function createReactiveParams(params) {
+  return params.map((param) => {
+    if (param instanceof Function) {
+      return param;
+    } else if (vue.isRef(param)) {
+      return param;
+    }
+    return vue.toRef(() => param);
+  });
+}
+function getFunctionParametersLength(func) {
+  const funcStr = func.toString();
+  const cleanStr = funcStr.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  const paramsMatch = cleanStr.match(
+    /^(?:async\s*)?(?:function\b.*?\(|\((.*?)\)|(\w+))\s*=>|\((.*?)\)\s*=>|function.*?\((.*?)\)|\((.*?)\)/
+  );
+  if (!paramsMatch) return 0;
+  const paramsSection = paramsMatch[0] || paramsMatch[1] || paramsMatch[2] || paramsMatch[3] || paramsMatch[4] || "";
+  const paramList = paramsSection.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+  return paramList.length;
+}
+
+// src/core/createRule/defineRuleProcessors.ts
+function defineRuleProcessors(definition, ...params) {
+  const { validator, type } = definition;
+  const isAsync = type === "__async" /* Async */ || validator.constructor.name === "AsyncFunction";
+  const defaultProcessors = {
+    validator(value, ...args) {
+      return definition.validator(value, ...unwrapRuleParameters(args.length ? args : params));
+    },
+    message(metadata) {
+      if (typeof definition.message === "function") {
+        return definition.message({
+          ...metadata,
+          $params: unwrapRuleParameters(metadata?.$params?.length ? metadata.$params : params)
+        });
+      } else {
+        return definition.message;
+      }
+    },
+    active(metadata) {
+      if (typeof definition.active === "function") {
+        return definition.active({
+          ...metadata,
+          $params: unwrapRuleParameters(metadata?.$params?.length ? metadata.$params : params)
+        });
+      } else {
+        return definition.active ?? true;
+      }
+    },
+    tooltip(metadata) {
+      if (typeof definition.tooltip === "function") {
+        return definition.tooltip({
+          ...metadata,
+          $params: unwrapRuleParameters(metadata?.$params?.length ? metadata.$params : params)
+        });
+      } else {
+        return definition.tooltip ?? [];
+      }
+    },
+    exec(value) {
+      const validator2 = definition.validator(value, ...unwrapRuleParameters(params));
+      let rawResult;
+      if (validator2 instanceof Promise) {
+        return validator2.then((result) => {
+          rawResult = result;
+          if (typeof rawResult === "object" && "$valid" in rawResult) {
+            return rawResult.$valid;
+          } else if (typeof rawResult === "boolean") {
+            return rawResult;
+          }
+          return false;
+        });
+      } else {
+        rawResult = validator2;
+      }
+      if (typeof rawResult === "object" && "$valid" in rawResult) {
+        return rawResult.$valid;
+      } else if (typeof rawResult === "boolean") {
+        return rawResult;
+      }
+      return false;
+    }
+  };
+  const processors = {
+    ...defaultProcessors,
+    _validator: definition.validator,
+    _message: definition.message,
+    _active: definition.active,
+    _tooltip: definition.tooltip,
+    _type: definition.type,
+    _message_patched: false,
+    _tooltip_patched: false,
+    _async: isAsync,
+    _params: createReactiveParams(params)
+  };
+  return processors;
+}
+
+// src/core/createRule/createRule.ts
+function createRule(definition) {
+  if (typeof definition.validator === "function") {
+    let fakeParams = [];
+    const staticProcessors = defineRuleProcessors(definition, ...fakeParams);
+    const isAsync = definition.validator.constructor.name === "AsyncFunction";
+    if (getFunctionParametersLength(definition.validator) > 1) {
+      const ruleFactory = function(...params) {
+        return defineRuleProcessors(definition, ...params);
+      };
+      ruleFactory.validator = staticProcessors.validator;
+      ruleFactory.message = staticProcessors.message;
+      ruleFactory.active = staticProcessors.active;
+      ruleFactory.tooltip = staticProcessors.tooltip;
+      ruleFactory.type = staticProcessors.type;
+      ruleFactory.exec = staticProcessors.exec;
+      ruleFactory._validator = staticProcessors.validator;
+      ruleFactory._message = staticProcessors.message;
+      ruleFactory._active = staticProcessors.active;
+      ruleFactory._tooltip = staticProcessors.tooltip;
+      ruleFactory._type = definition.type;
+      ruleFactory._message_pacthed = false;
+      ruleFactory._tooltip_pacthed = false;
+      ruleFactory._async = isAsync;
+      return ruleFactory;
+    } else {
+      return staticProcessors;
+    }
+  }
+  throw new Error("Validator must be a function");
+}
+function isObject(obj) {
+  return typeof obj === "object" && obj !== null && !Array.isArray(obj);
+}
+function isRefObject(obj) {
+  return isObject(obj.value);
+}
+function cloneDeep(obj) {
+  let result = obj;
+  let type = {}.toString.call(obj).slice(8, -1);
+  if (type == "Set") {
+    result = new Set([...obj].map((value) => cloneDeep(value)));
+  }
+  if (type == "Map") {
+    result = new Map([...obj].map((kv) => [cloneDeep(kv[0]), cloneDeep(kv[1])]));
+  }
+  if (type == "Date") {
+    result = new Date(obj.getTime());
+  }
+  if (type == "RegExp") {
+    result = RegExp(obj.source, getRegExpFlags(obj));
+  }
+  if (type == "Array" || type == "Object") {
+    result = Array.isArray(obj) ? [] : {};
+    for (let key in obj) {
+      result[key] = cloneDeep(obj[key]);
+    }
+  }
+  return result;
+}
+function getRegExpFlags(regExp) {
+  if (typeof regExp.source.flags == "string") {
+    return regExp.source.flags;
+  } else {
+    let flags = [];
+    regExp.global && flags.push("g");
+    regExp.ignoreCase && flags.push("i");
+    regExp.multiline && flags.push("m");
+    regExp.sticky && flags.push("y");
+    regExp.unicode && flags.push("u");
+    return flags.join("");
+  }
+}
+function unwrapGetter(getter, value, index) {
+  if (getter instanceof Function) {
+    return getter(value, index ?? 0);
+  }
+  return getter;
+}
+
+// src/utils/debounce.ts
+function debounce(func, wait, immediate) {
+  let timeout;
+  const debouncedFn = (...args) => new Promise((resolve) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      timeout = void 0;
+      {
+        Promise.resolve(func.apply(this, [...args])).then(resolve);
+      }
+    }, wait);
+  });
+  debouncedFn.cancel = () => {
+    clearTimeout(timeout);
+    timeout = void 0;
+  };
+  return debouncedFn;
+}
+function versionCompare(current, other) {
+  const cp = String(current).split(".");
+  const op = String(other).split(".");
+  for (let depth = 0; depth < Math.min(cp.length, op.length); depth++) {
+    const cn = Number(cp[depth]);
+    const on = Number(op[depth]);
+    if (cn > on) return 1 /* GreaterThan */;
+    if (on > cn) return -1 /* LessThan */;
+    if (!isNaN(cn) && isNaN(on)) return 1 /* GreaterThan */;
+    if (isNaN(cn) && !isNaN(on)) return -1 /* LessThan */;
+  }
+  return 0 /* EqualTo */;
+}
+var isVueSuperiorOrEqualTo3dotFive = versionCompare(vue.version, "3.5.0") === -1 ? false : true;
+
+// src/utils/randomId.ts
+function uniqueIDNuxt() {
+  return Math.floor(Math.random() * Date.now()).toString();
+}
+function randomId() {
+  if (typeof window === "undefined") {
+    return uniqueIDNuxt();
+  } else {
+    const uint32 = window.crypto.getRandomValues(new Uint32Array(1))[0];
+    return uint32.toString(10);
+  }
+}
+function useStorage() {
+  const ruleDeclStorage = vue.shallowRef(/* @__PURE__ */ new Map());
+  const fieldsStorage = vue.shallowRef(/* @__PURE__ */ new Map());
+  const collectionsStorage = vue.shallowRef(/* @__PURE__ */ new Map());
+  const dirtyStorage = vue.shallowRef(/* @__PURE__ */ new Map());
+  const ruleStatusStorage = vue.shallowRef(/* @__PURE__ */ new Map());
+  const arrayStatusStorage = vue.shallowRef(/* @__PURE__ */ new Map());
+  function getFieldsEntry($path) {
+    const existingFields = fieldsStorage.value.get($path);
+    if (existingFields) {
+      return existingFields;
+    } else {
+      const $fields = vue.ref({});
+      fieldsStorage.value.set($path, $fields);
+      return $fields;
+    }
+  }
+  function getCollectionsEntry($path) {
+    const existingEach = collectionsStorage.value.get($path);
+    if (existingEach) {
+      return existingEach;
+    } else {
+      const $each = vue.ref([]);
+      collectionsStorage.value.set($path, $each);
+      return $each;
+    }
+  }
+  function addArrayStatus($arrayId, itemId, value) {
+    arrayStatusStorage.value.set(`${$arrayId}-${itemId}`, value);
+  }
+  function getArrayStatus($arrayId, itemId) {
+    return arrayStatusStorage.value.get(`${$arrayId}-${itemId}`);
+  }
+  function deleteArrayStatus($arrayId, itemId) {
+    if ($arrayId && itemId != null) {
+      arrayStatusStorage.value.delete(`${$arrayId}-${itemId}`);
+    }
+  }
+  function setDirtyEntry($path, dirty) {
+    dirtyStorage.value.set($path, dirty);
+  }
+  function getDirtyState(path) {
+    return dirtyStorage.value.get(path) ?? false;
+  }
+  function addRuleDeclEntry($path, options) {
+    ruleDeclStorage.value.set($path, options);
+  }
+  function checkRuleDeclEntry($path, newRules) {
+    const storedRulesDefs = ruleDeclStorage.value.get($path);
+    if (!storedRulesDefs) return void 0;
+    const storedRules = storedRulesDefs;
+    const isValidCache = areRulesChanged(newRules, storedRules);
+    if (!isValidCache) return { valid: false };
+    return { valid: true };
+  }
+  function areRulesChanged(newRules, storedRules) {
+    const storedRulesKeys = Object.keys(storedRules);
+    const newRulesKeys = Object.keys(newRules);
+    if (newRulesKeys.length !== storedRulesKeys.length) return false;
+    const hasAllValidators = newRulesKeys.every((ruleKey) => storedRulesKeys.includes(ruleKey));
+    if (!hasAllValidators) return false;
+    return newRulesKeys.every((ruleKey) => {
+      const newRuleElement = newRules[ruleKey];
+      const storedRuleElement = storedRules[ruleKey];
+      if (!storedRuleElement || !newRuleElement || typeof newRuleElement === "function" || typeof storedRuleElement === "function")
+        return false;
+      if (typeof newRuleElement === "number") {
+        return false;
+      } else if (typeof newRuleElement === "boolean") {
+        return false;
+      } else if (!newRuleElement._params) return true;
+      else {
+        return newRuleElement._params?.every((paramKey, index) => {
+          if (typeof storedRuleElement === "number" || typeof storedRuleElement === "boolean") {
+            return true;
+          } else {
+            const storedParams = unwrapRuleParameters(storedRuleElement._params);
+            const newParams = unwrapRuleParameters(newRuleElement._params);
+            return storedParams?.[index] === newParams?.[index];
+          }
+        });
+      }
+    });
+  }
+  function trySetRuleStatusRef(path) {
+    const ruleStatus = ruleStatusStorage.value.get(path);
+    if (ruleStatus) {
+      return ruleStatus;
+    } else {
+      const $pending = vue.ref(false);
+      const $valid = vue.ref(true);
+      const $metadata = vue.ref({});
+      const $validating = vue.ref(false);
+      ruleStatusStorage.value.set(path, { $pending, $valid, $metadata, $validating });
+      return { $pending, $valid, $metadata, $validating };
+    }
+  }
+  vue.onScopeDispose(() => {
+    ruleDeclStorage.value.clear();
+    fieldsStorage.value.clear();
+    collectionsStorage.value.clear();
+    dirtyStorage.value.clear();
+    ruleStatusStorage.value.clear();
+    arrayStatusStorage.value.clear();
+  });
+  return {
+    addRuleDeclEntry,
+    setDirtyEntry,
+    checkRuleDeclEntry,
+    getDirtyState,
+    trySetRuleStatusRef,
+    getFieldsEntry,
+    getCollectionsEntry,
+    getArrayStatus,
+    addArrayStatus,
+    deleteArrayStatus,
+    arrayStatusStorage
+  };
+}
+
+// ../shared/utils/isEmpty.ts
+function isEmpty(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (value instanceof Date) {
+    return isNaN(value.getTime());
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (typeof value === "object" && value != null) {
+    return Object.keys(value).length === 0;
+  }
+  return !String(value).length;
+}
+
+// src/core/useRegle/guards/ruleDef.guards.ts
+function isNestedRulesDef(state, rules) {
+  return isObject(state.value) && isObject(rules.value) && !Object.entries(rules.value).some((rule) => isRuleDef(rule));
+}
+function isCollectionRulesDef(rules, state) {
+  return !!rules.value && "$each" in rules.value || Array.isArray(state.value);
+}
+function isValidatorRulesDef(rules) {
+  return !!rules.value && isObject(rules.value);
+}
+function isRuleDef(rule) {
+  return isObject(rule) && "_validator" in rule;
+}
+function isFormRuleDefinition(rule) {
+  return !(typeof rule.value === "function");
+}
+
+// src/core/useRegle/guards/rule.status.guards.ts
+function isNestedRulesStatus(rule) {
+  return isObject(rule) && "$fields" in rule;
+}
+
+// src/core/useRegle/useErrors.ts
+function extractRulesErrors({
+  field,
+  silent = false
+}) {
+  return Object.entries(field.$rules ?? {}).map(([ruleKey, rule]) => {
+    if (silent) {
+      return rule.$message;
+    } else if (!rule.$valid && field.$dirty && !rule.$validating) {
+      return rule.$message;
+    }
+    return null;
+  }).filter((msg) => !!msg).reduce((acc, value) => {
+    if (typeof value === "string") {
+      return acc?.concat([value]);
+    } else {
+      return acc?.concat(value);
+    }
+  }, []).concat(field.$dirty ? field.$externalErrors ?? [] : []);
+}
+function extractRulesTooltips({ field }) {
+  return Object.entries(field.$rules ?? {}).map(([ruleKey, rule]) => rule.$tooltip).filter((tooltip) => !!tooltip).reduce((acc, value) => {
+    if (typeof value === "string") {
+      return acc?.concat([value]);
+    } else {
+      return acc?.concat(value);
+    }
+  }, []);
+}
+function createReactiveRuleStatus({
+  fieldProperties,
+  customMessages,
+  rule,
+  ruleKey,
+  state,
+  path,
+  storage,
+  $debounce,
+  modifiers
+}) {
+  let scope = vue.effectScope();
+  let scopeState = {};
+  let $unwatchState;
+  const $haveAsync = vue.ref(false);
+  const { $pending, $valid, $metadata, $validating } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
+  function $watch() {
+    scope = vue.effectScope();
+    scopeState = scope.run(() => {
+      const $defaultMetadata = vue.computed(() => ({
+        $value: state.value,
+        $error: fieldProperties.$error.value,
+        $dirty: fieldProperties.$dirty.value,
+        $pending: fieldProperties.$pending.value,
+        $valid: fieldProperties.$valid.value,
+        $invalid: fieldProperties.$invalid.value,
+        $rule: {
+          $valid: $valid.value,
+          $invalid: !$valid.value,
+          $pending: $pending.value
+        },
+        $params: $params.value,
+        ...$metadata.value
+      }));
+      const $active = vue.computed(() => {
+        if (isFormRuleDefinition(rule)) {
+          if (typeof rule.value.active === "function") {
+            return rule.value.active($defaultMetadata.value);
+          } else {
+            return !!rule.value.active;
+          }
+        } else {
+          return true;
+        }
+      });
+      function computeRuleProcessor(key) {
+        let result = "";
+        const customProcessor = customMessages ? customMessages[ruleKey]?.[key] : void 0;
+        if (customProcessor) {
+          if (typeof customProcessor === "function") {
+            result = customProcessor($defaultMetadata.value);
+          } else {
+            result = customProcessor;
+          }
+        }
+        if (isFormRuleDefinition(rule)) {
+          const patchedKey = `_${key}_patched`;
+          if (!(customProcessor && !rule.value[patchedKey])) {
+            if (typeof rule.value[key] === "function") {
+              result = rule.value[key]($defaultMetadata.value);
+            } else {
+              result = rule.value[key] ?? "";
+            }
+          }
+        }
+        return result;
+      }
+      const $message = vue.computed(() => {
+        let message = computeRuleProcessor("message");
+        if (isEmpty(message)) {
+          message = "This field is not valid";
+        }
+        return message;
+      });
+      const $tooltip = vue.computed(() => {
+        return computeRuleProcessor("tooltip");
+      });
+      const $type = vue.computed(() => {
+        if (isFormRuleDefinition(rule) && rule.value.type) {
+          return rule.value.type;
+        } else {
+          return ruleKey;
+        }
+      });
+      const $validator = vue.computed(() => {
+        if (isFormRuleDefinition(rule)) {
+          return rule.value.validator;
+        } else {
+          return rule.value;
+        }
+      });
+      const $params = vue.computed(() => {
+        if (typeof rule.value === "function") {
+          return [];
+        }
+        return unwrapRuleParameters(rule.value._params ?? []);
+      });
+      const $path = vue.computed(() => `${path}.${$type.value}`);
+      return {
+        $active,
+        $message,
+        $type,
+        $validator,
+        $params,
+        $path,
+        $tooltip
+      };
+    });
+    $unwatchState = vue.watch(scopeState?.$params, () => {
+      if (modifiers.$autoDirty.value || modifiers.$rewardEarly.value && fieldProperties.$error.value) {
+        $validate();
+      }
+    });
+  }
+  $watch();
+  function updatePendingState() {
+    $valid.value = true;
+    if (fieldProperties.$dirty.value) {
+      $pending.value = true;
+    }
+  }
+  async function computeAsyncResult() {
+    let ruleResult = false;
+    try {
+      const validator = scopeState.$validator.value;
+      const resultOrPromise = validator(state.value, ...scopeState.$params.value);
+      let cachedValue = state.value;
+      updatePendingState();
+      let validatorResult;
+      if (resultOrPromise instanceof Promise) {
+        validatorResult = await resultOrPromise;
+      } else {
+        validatorResult = resultOrPromise;
+      }
+      if (state.value !== cachedValue) {
+        return true;
+      }
+      if (typeof validatorResult === "boolean") {
+        ruleResult = validatorResult;
+      } else {
+        const { $valid: $valid2, ...rest } = validatorResult;
+        ruleResult = $valid2;
+        $metadata.value = rest;
+      }
+    } catch (e) {
+      ruleResult = false;
+    } finally {
+      $pending.value = false;
+    }
+    return ruleResult;
+  }
+  const $computeAsyncDebounce = debounce(computeAsyncResult, $debounce ?? 200);
+  async function $validate() {
+    try {
+      $validating.value = true;
+      let ruleResult = false;
+      if (isRuleDef(rule.value) && rule.value._async) {
+        ruleResult = await $computeAsyncDebounce();
+      } else {
+        const validator = scopeState.$validator.value;
+        const resultOrPromise = validator(state.value, ...scopeState.$params.value);
+        if (resultOrPromise instanceof Promise) {
+          console.warn(
+            'You used a async validator function on a non-async rule, please use "async await" or the "withAsync" helper'
+          );
+        } else {
+          if (resultOrPromise != null) {
+            if (typeof resultOrPromise === "boolean") {
+              ruleResult = resultOrPromise;
+            } else {
+              const { $valid: $valid2, ...rest } = resultOrPromise;
+              ruleResult = $valid2;
+              $metadata.value = rest;
+            }
+          }
+        }
+      }
+      $valid.value = ruleResult;
+      return ruleResult;
+    } catch (e) {
+      return false;
+    } finally {
+      $validating.value = false;
+    }
+  }
+  function $reset() {
+    $valid.value = true;
+    $metadata.value = {};
+    $pending.value = false;
+    $validating.value = false;
+    $watch();
+  }
+  function $unwatch() {
+    $unwatchState();
+    scope.stop();
+    scope = vue.effectScope();
+  }
+  return vue.reactive({
+    ...scopeState,
+    $pending,
+    $valid,
+    $metadata,
+    $haveAsync,
+    $validating,
+    $validate,
+    $unwatch,
+    $watch,
+    $reset
+  });
+}
+
+// src/core/useRegle/useStateProperties/createReactiveFieldStatus.ts
+function createReactiveFieldStatus({
+  state,
+  rulesDef,
+  customMessages,
+  path,
+  fieldName,
+  storage,
+  options,
+  externalErrors,
+  onUnwatch,
+  $isArray,
+  initialState,
+  shortcuts
+}) {
+  let scope = vue.effectScope();
+  let scopeState;
+  let fieldScopes = [];
+  let $unwatchState;
+  let $unwatchValid;
+  let $unwatchDirty;
+  let $unwatchAsync;
+  let $commit = () => {
+  };
+  function createReactiveRulesResult() {
+    const declaredRules = rulesDef.value;
+    const storeResult = storage.checkRuleDeclEntry(path, declaredRules);
+    $localOptions.value = Object.fromEntries(
+      Object.entries(declaredRules).filter(([ruleKey]) => ruleKey.startsWith("$"))
+    );
+    $watch();
+    $rules.value = Object.fromEntries(
+      Object.entries(rulesDef.value).filter(([ruleKey]) => !ruleKey.startsWith("$")).map(([ruleKey, rule]) => {
+        if (rule) {
+          const ruleRef = vue.toRef(() => rule);
+          return [
+            ruleKey,
+            createReactiveRuleStatus({
+              fieldProperties: {
+                $dirty: scopeState.$dirty,
+                $error: scopeState.$error,
+                $invalid: scopeState.$invalid,
+                $pending: scopeState.$pending,
+                $valid: scopeState.$valid
+              },
+              modifiers: {
+                $autoDirty: scopeState.$autoDirty,
+                $rewardEarly: scopeState.$rewardEarly
+              },
+              customMessages,
+              rule: ruleRef,
+              ruleKey,
+              state,
+              path,
+              storage,
+              $debounce: $localOptions.value.$debounce
+            })
+          ];
+        }
+        return [];
+      }).filter((ruleDef) => !!ruleDef.length)
+    );
+    scopeState.processShortcuts();
+    define$commit();
+    if (storeResult?.valid != null) {
+      scopeState.$dirty.value = storage.getDirtyState(path);
+      if (scopeState.$dirty.value) {
+        $commit();
+      }
+    }
+    storage.addRuleDeclEntry(path, declaredRules);
+  }
+  function define$commit() {
+    $commit = scopeState.$debounce.value ? debounce($commitHandler, scopeState.$debounce.value ?? scopeState.$haveAnyAsyncRule ? 100 : 0) : $commitHandler;
+  }
+  function $unwatch() {
+    if ($rules.value) {
+      Object.entries($rules.value).forEach(([_, rule]) => {
+        rule.$unwatch();
+      });
+    }
+    $unwatchDirty();
+    if (scopeState.$dirty.value) {
+      storage.setDirtyEntry(path, scopeState.$dirty.value);
+    }
+    $unwatchState?.();
+    $unwatchValid?.();
+    scope.stop();
+    scope = vue.effectScope();
+    fieldScopes.forEach((s) => s.stop());
+    fieldScopes = [];
+    onUnwatch?.();
+    $unwatchAsync?.();
+  }
+  function $watch() {
+    if ($rules.value) {
+      Object.entries($rules.value).forEach(([_, rule]) => {
+        rule.$watch();
+      });
+    }
+    scopeState = scope.run(() => {
+      const $dirty = vue.ref(false);
+      const triggerPunishment = vue.ref(false);
+      const $anyDirty = vue.computed(() => $dirty.value);
+      const $debounce2 = vue.computed(() => {
+        return $localOptions.value.$debounce;
+      });
+      const $lazy2 = vue.computed(() => {
+        if ($localOptions.value.$lazy != null) {
+          return $localOptions.value.$lazy;
+        }
+        return vue.unref(options.lazy);
+      });
+      const $rewardEarly2 = vue.computed(() => {
+        if ($autoDirty2.value === true) {
+          return false;
+        }
+        if ($localOptions.value.$rewardEarly != null) {
+          return $localOptions.value.$rewardEarly;
+        }
+        return vue.unref(options.rewardEarly);
+      });
+      const $clearExternalErrorsOnChange2 = vue.computed(() => {
+        if ($localOptions.value.$clearExternalErrorsOnChange != null) {
+          return $localOptions.value.$clearExternalErrorsOnChange;
+        }
+        return vue.unref(options.clearExternalErrorsOnChange);
+      });
+      const $autoDirty2 = vue.computed(() => {
+        if ($localOptions.value.$autoDirty != null) {
+          return $localOptions.value.$autoDirty;
+        }
+        return vue.unref(options.autoDirty);
+      });
+      const $validating2 = vue.computed(() => {
+        return Object.entries($rules.value).some(([key, ruleResult]) => {
+          return ruleResult.$validating;
+        });
+      });
+      const $error = vue.computed(() => {
+        return $invalid.value && !$pending.value && $dirty.value;
+      });
+      const $errors = vue.computed(() => {
+        if ($error.value) {
+          return extractRulesErrors({
+            field: {
+              $dirty: $dirty.value,
+              $externalErrors: externalErrors?.value,
+              $rules: $rules.value
+            }
+          });
+        }
+        return [];
+      });
+      const $tooltips = vue.computed(() => {
+        return extractRulesTooltips({
+          field: {
+            $rules: $rules.value
+          }
+        });
+      });
+      const $silentErrors = vue.computed(() => {
+        return extractRulesErrors({
+          field: {
+            $dirty: $dirty.value,
+            $externalErrors: externalErrors?.value,
+            $rules: $rules.value
+          },
+          silent: true
+        });
+      });
+      const $ready = vue.computed(() => {
+        return !($invalid.value || $pending.value);
+      });
+      const $pending = vue.computed(() => {
+        if (triggerPunishment.value || !$rewardEarly2.value) {
+          return Object.entries($rules.value).some(([key, ruleResult]) => {
+            return ruleResult.$pending;
+          });
+        }
+        return false;
+      });
+      const $invalid = vue.computed(() => {
+        if (externalErrors?.value?.length) {
+          return true;
+        } else if (isEmpty($rules.value)) {
+          return false;
+        } else if (!$rewardEarly2.value || $rewardEarly2.value && triggerPunishment.value) {
+          return Object.entries($rules.value).some(([key, ruleResult]) => {
+            return !ruleResult.$valid;
+          });
+        }
+        return false;
+      });
+      const $name = vue.computed(() => fieldName);
+      const $valid = vue.computed(() => {
+        if (externalErrors?.value?.length) {
+          return false;
+        } else if (isEmpty($rules.value)) {
+          return false;
+        } else if ($dirty.value && !isEmpty(state.value) && !$validating2.value) {
+          return Object.values($rules.value).every((ruleResult) => {
+            return ruleResult.$valid && ruleResult.$active;
+          });
+        }
+        return false;
+      });
+      const $haveAnyAsyncRule2 = vue.computed(() => {
+        return Object.entries($rules.value).some(([key, ruleResult]) => {
+          return ruleResult.$haveAsync;
+        });
+      });
+      function processShortcuts() {
+        if (shortcuts?.fields) {
+          Object.entries(shortcuts.fields).forEach(([key, value]) => {
+            const scope2 = vue.effectScope();
+            $shortcuts2[key] = scope2.run(() => {
+              const result = vue.ref();
+              vue.watchEffect(() => {
+                result.value = value(
+                  vue.reactive({
+                    $dirty,
+                    $externalErrors: externalErrors?.value ?? [],
+                    $value: state,
+                    $rules,
+                    $error,
+                    $pending,
+                    $invalid,
+                    $valid,
+                    $errors,
+                    $ready,
+                    $silentErrors,
+                    $anyDirty,
+                    $tooltips,
+                    $name
+                  })
+                );
+              });
+              return result;
+            });
+            fieldScopes.push(scope2);
+          });
+        }
+      }
+      const $shortcuts2 = {};
+      vue.watch($valid, (value) => {
+        if (value) {
+          triggerPunishment.value = false;
+        }
+      });
+      return {
+        $error,
+        $pending,
+        $invalid,
+        $valid,
+        $debounce: $debounce2,
+        $lazy: $lazy2,
+        $errors,
+        $ready,
+        $silentErrors,
+        $rewardEarly: $rewardEarly2,
+        $autoDirty: $autoDirty2,
+        $clearExternalErrorsOnChange: $clearExternalErrorsOnChange2,
+        $anyDirty,
+        $name,
+        $haveAnyAsyncRule: $haveAnyAsyncRule2,
+        $shortcuts: $shortcuts2,
+        $validating: $validating2,
+        $tooltips,
+        $dirty,
+        triggerPunishment,
+        processShortcuts
+      };
+    });
+    $unwatchState = vue.watch(
+      state,
+      () => {
+        if (scopeState.$autoDirty.value) {
+          if (!scopeState.$dirty.value) {
+            scopeState.$dirty.value = true;
+          }
+        }
+        if (rulesDef.value instanceof Function) {
+          createReactiveRulesResult();
+        }
+        if (scopeState.$autoDirty.value || scopeState.$rewardEarly.value && scopeState.$error.value) {
+          $commit();
+        }
+        if (scopeState.$rewardEarly.value !== true && scopeState.$clearExternalErrorsOnChange.value) {
+          $clearExternalErrors();
+        }
+      },
+      { deep: $isArray ? true : isVueSuperiorOrEqualTo3dotFive ? 1 : true }
+    );
+    $unwatchDirty = vue.watch(scopeState.$dirty, () => {
+      storage.setDirtyEntry(path, scopeState.$dirty.value);
+    });
+    $unwatchValid = vue.watch(scopeState.$valid, (valid) => {
+      if (scopeState.$rewardEarly.value && valid) {
+        scopeState.triggerPunishment.value = false;
+      }
+    });
+    $unwatchAsync = vue.watch(scopeState.$haveAnyAsyncRule, define$commit);
+  }
+  function $commitHandler() {
+    Object.values($rules.value).forEach((rule) => {
+      rule.$validate();
+    });
+  }
+  const $rules = vue.ref({});
+  const $localOptions = vue.ref({});
+  createReactiveRulesResult();
+  function $reset() {
+    $clearExternalErrors();
+    scopeState.$dirty.value = false;
+    storage.setDirtyEntry(path, false);
+    Object.entries($rules.value).forEach(([key, rule]) => {
+      rule.$reset();
+    });
+    if (!scopeState.$lazy.value && scopeState.$autoDirty.value) {
+      Object.values($rules.value).forEach((rule) => {
+        return rule.$validate();
+      });
+    }
+  }
+  function $touch(runCommit = true, withConditions = false) {
+    if (!scopeState.$dirty.value) {
+      scopeState.$dirty.value = true;
+    }
+    if (withConditions && runCommit) {
+      if (scopeState.$autoDirty.value || scopeState.$rewardEarly.value && scopeState.$error.value) {
+        $commit();
+      }
+    } else if (runCommit) {
+      $commit();
+    }
+  }
+  async function $validate() {
+    try {
+      const data = state.value;
+      scopeState.triggerPunishment.value = true;
+      if (!scopeState.$dirty.value) {
+        scopeState.$dirty.value = true;
+      } else if (scopeState.$autoDirty.value && scopeState.$dirty.value && !scopeState.$pending.value) {
+        return { result: !scopeState.$error.value, data };
+      }
+      if (isEmpty($rules.value)) {
+        return { result: true, data };
+      }
+      const results = await Promise.allSettled(
+        Object.entries($rules.value).map(([key, rule]) => {
+          return rule.$validate();
+        })
+      );
+      const validationResults = results.every((value) => {
+        if (value.status === "fulfilled") {
+          return value.value === true;
+        } else {
+          return false;
+        }
+      });
+      return { result: validationResults, data };
+    } catch (e) {
+      return { result: false, data: state.value };
+    }
+  }
+  function $resetAll() {
+    $unwatch();
+    state.value = cloneDeep(initialState);
+    $reset();
+  }
+  function $extractDirtyFields(filterNullishValues = true) {
+    if (scopeState.$dirty.value) {
+      return state.value;
+    }
+    if (filterNullishValues) {
+      return { _null: true };
+    }
+    return null;
+  }
+  function $clearExternalErrors() {
+    if (externalErrors?.value?.length) {
+      externalErrors.value = [];
+    }
+  }
+  if (!scopeState.$lazy.value && !scopeState.$dirty.value && scopeState.$autoDirty.value) {
+    $commit();
+  }
+  const {
+    $shortcuts,
+    $validating,
+    $autoDirty,
+    $rewardEarly,
+    $clearExternalErrorsOnChange,
+    $haveAnyAsyncRule,
+    $debounce,
+    $lazy,
+    ...restScope
+  } = scopeState;
+  return vue.reactive({
+    ...restScope,
+    $externalErrors: externalErrors,
+    $value: state,
+    $rules,
+    ...$shortcuts,
+    $reset,
+    $touch,
+    $validate,
+    $unwatch,
+    $watch,
+    $resetAll,
+    $extractDirtyFields,
+    $clearExternalErrors
+  });
+}
+function createCollectionElement({
+  $id,
+  path,
+  index,
+  options,
+  storage,
+  stateValue,
+  customMessages,
+  rules,
+  externalErrors,
+  initialState,
+  shortcuts,
+  fieldName
+}) {
+  const $fieldId = rules.$key ? rules.$key : randomId();
+  let $path = `${path}.${String($fieldId)}`;
+  if (typeof stateValue.value === "object" && stateValue.value != null) {
+    if (!stateValue.value.$id) {
+      Object.defineProperties(stateValue.value, {
+        $id: {
+          value: $fieldId,
+          enumerable: false,
+          configurable: false,
+          writable: false
+        }
+      });
+    } else {
+      $path = `${path}.${stateValue.value.$id}`;
+    }
+  }
+  const $status = createReactiveChildrenStatus({
+    state: stateValue,
+    rulesDef: vue.toRef(() => rules),
+    customMessages,
+    path: $path,
+    storage,
+    options,
+    externalErrors: vue.toRef(externalErrors?.value ?? [], index),
+    initialState: initialState?.[index],
+    shortcuts,
+    fieldName
+  });
+  if ($status) {
+    const valueId = stateValue.value?.$id;
+    $status.$id = valueId ?? String($fieldId);
+    storage.addArrayStatus($id, $status.$id, $status);
+  }
+  return $status;
+}
+
+// src/core/useRegle/useStateProperties/collections/createReactiveCollectionRoot.ts
+function createReactiveCollectionStatus({
+  state,
+  rulesDef,
+  customMessages,
+  path,
+  storage,
+  options,
+  externalErrors,
+  initialState,
+  shortcuts,
+  fieldName
+}) {
+  let scope = vue.effectScope();
+  let scopeState;
+  let immediateScope = vue.effectScope();
+  let immediateScopeState;
+  let collectionScopes = [];
+  if (!Array.isArray(state.value) && !rulesDef.value.$each) {
+    return null;
+  }
+  const $id = vue.ref();
+  const $value = vue.ref(state.value);
+  let $unwatchState;
+  const $fieldStatus = vue.ref({});
+  const $eachStatus = storage.getCollectionsEntry(path);
+  immediateScopeState = immediateScope.run(() => {
+    const isPrimitiveArray = vue.computed(() => {
+      if (Array.isArray(state.value) && state.value.length) {
+        return state.value.some((s) => typeof s !== "object");
+      } else if (rulesDef.value.$each && !(rulesDef.value.$each instanceof Function)) {
+        return Object.values(rulesDef.value.$each).every((rule) => isRuleDef(rule));
+      }
+      return false;
+    });
+    return {
+      isPrimitiveArray
+    };
+  });
+  createStatus();
+  $watch();
+  function createStatus() {
+    if (typeof state.value === "object") {
+      if (state.value != null && !state.value?.$id && state.value !== null) {
+        $id.value = randomId();
+        Object.defineProperties(state.value, {
+          $id: {
+            value: $id.value,
+            enumerable: false,
+            configurable: false,
+            writable: false
+          }
+        });
+      } else if (state.value?.$id) {
+        $id.value = state.value.$id;
+      }
+    }
+    if (immediateScopeState.isPrimitiveArray.value) {
+      return;
+    }
+    $value.value = $fieldStatus.value.$value;
+    if (Array.isArray(state.value)) {
+      $eachStatus.value = state.value.map((value, index) => {
+        const unwrapped$Each = unwrapGetter(
+          rulesDef.value.$each,
+          vue.toRef(() => value),
+          index
+        );
+        const element = createCollectionElement({
+          $id: $id.value,
+          path,
+          customMessages,
+          rules: unwrapped$Each ?? {},
+          stateValue: vue.toRef(() => value),
+          index,
+          options,
+          storage,
+          externalErrors: vue.toRef(externalErrors?.value ?? {}, `$each`),
+          initialState: initialState?.[index],
+          shortcuts,
+          fieldName
+        });
+        if (element) {
+          return element;
+        }
+        return null;
+      }).filter((each) => !!each);
+    } else {
+      $eachStatus.value = [];
+    }
+    $fieldStatus.value = createReactiveFieldStatus({
+      state,
+      rulesDef,
+      customMessages,
+      path,
+      storage,
+      options,
+      externalErrors: vue.toRef(externalErrors?.value ?? {}, `$self`),
+      $isArray: true,
+      initialState,
+      shortcuts,
+      fieldName
+    });
+  }
+  function updateStatus() {
+    if (Array.isArray(state.value)) {
+      const previousStatus = cloneDeep($eachStatus.value);
+      $eachStatus.value = state.value.map((value, index) => {
+        const currentValue = vue.toRef(() => value);
+        if (value.$id && $eachStatus.value.find((each) => each.$id === value.$id)) {
+          const existingStatus = storage.getArrayStatus($id.value, value.$id);
+          if (existingStatus) {
+            existingStatus.$value = currentValue;
+            return existingStatus;
+          }
+          return null;
+        } else {
+          const unwrapped$Each = unwrapGetter(rulesDef.value.$each, currentValue, index);
+          if (unwrapped$Each) {
+            const element = createCollectionElement({
+              $id: $id.value,
+              path,
+              customMessages,
+              rules: unwrapped$Each,
+              stateValue: currentValue,
+              index,
+              options,
+              storage,
+              externalErrors: vue.toRef(externalErrors?.value ?? {}, `$each`),
+              initialState: initialState?.[index],
+              shortcuts,
+              fieldName
+            });
+            if (element) {
+              return element;
+            }
+            return null;
+          }
+        }
+      }).filter((each) => !!each);
+      previousStatus.filter(($each) => !state.value.find((f) => $each.$id === f.$id)).forEach(($each, index) => {
+        storage.deleteArrayStatus($id.value, index.toString());
+      });
+    } else {
+      $eachStatus.value = [];
+    }
+  }
+  function $watch() {
+    $unwatchState = vue.watch(
+      state,
+      () => {
+        if (state.value != null && !Object.hasOwn(state.value, "$id")) {
+          createStatus();
+        } else {
+          updateStatus();
+        }
+      },
+      { deep: isVueSuperiorOrEqualTo3dotFive ? 1 : true, flush: "pre" }
+    );
+    scope = vue.effectScope();
+    scopeState = scope.run(() => {
+      const $dirty = vue.computed(() => {
+        return $fieldStatus.value.$dirty && $eachStatus.value.every((statusOrField) => {
+          return statusOrField.$dirty;
+        });
+      });
+      const $anyDirty = vue.computed(() => {
+        return $fieldStatus.value.$anyDirty || $eachStatus.value.some((statusOrField) => {
+          return statusOrField.$dirty;
+        });
+      });
+      const $invalid = vue.computed(() => {
+        return $fieldStatus.value.$invalid || $eachStatus.value.some((statusOrField) => {
+          return statusOrField.$invalid;
+        });
+      });
+      const $valid = vue.computed(() => {
+        return (isEmpty($fieldStatus.value.$rules) ? true : $fieldStatus.value.$valid) && $eachStatus.value.every((statusOrField) => {
+          return statusOrField.$valid;
+        });
+      });
+      const $error = vue.computed(() => {
+        return $fieldStatus.value.$error || $eachStatus.value.some((statusOrField) => {
+          return statusOrField.$error;
+        });
+      });
+      const $ready = vue.computed(() => {
+        return !($invalid.value || $pending.value);
+      });
+      const $pending = vue.computed(() => {
+        return $fieldStatus.value.$pending || $eachStatus.value.some((statusOrField) => {
+          return statusOrField.$pending;
+        });
+      });
+      const $errors = vue.computed(() => {
+        return {
+          $self: $fieldStatus.value.$errors,
+          $each: $eachStatus.value.map(($each) => $each.$errors)
+        };
+      });
+      const $silentErrors = vue.computed(() => {
+        return {
+          $self: $fieldStatus.value.$silentErrors,
+          $each: $eachStatus.value.map(($each) => $each.$silentErrors)
+        };
+      });
+      const $name = vue.computed(() => fieldName);
+      function processShortcuts() {
+        if (shortcuts?.collections) {
+          Object.entries(shortcuts?.collections).forEach(([key, value]) => {
+            const scope2 = vue.effectScope();
+            $shortcuts2[key] = scope2.run(() => {
+              const result = vue.ref();
+              vue.watchEffect(() => {
+                result.value = value(
+                  vue.reactive({
+                    $dirty,
+                    $error,
+                    $pending,
+                    $invalid,
+                    $valid,
+                    $errors,
+                    $ready,
+                    $silentErrors,
+                    $anyDirty,
+                    $name,
+                    $each: $eachStatus,
+                    $field: $fieldStatus,
+                    $value: state
+                  })
+                );
+              });
+              return result;
+            });
+            collectionScopes.push(scope2);
+          });
+        }
+      }
+      const $shortcuts2 = {};
+      processShortcuts();
+      return {
+        $dirty,
+        $anyDirty,
+        $invalid,
+        $valid,
+        $error,
+        $pending,
+        $errors,
+        $silentErrors,
+        $ready,
+        $name,
+        $shortcuts: $shortcuts2
+      };
+    });
+    if (immediateScopeState.isPrimitiveArray.value) {
+      console.warn(
+        `${path} is a Array of primitives. Tracking can be lost when reassigning the Array. We advise to use an Array of objects instead`
+      );
+      $unwatchState();
+    }
+  }
+  function $unwatch() {
+    if ($unwatchState) {
+      $unwatchState();
+    }
+    if ($fieldStatus.value) {
+      $fieldStatus.value.$unwatch();
+    }
+    if ($eachStatus.value) {
+      $eachStatus.value.forEach((element) => {
+        if ("$dirty" in element) {
+          element.$unwatch();
+        }
+      });
+    }
+    scope.stop();
+    scope = vue.effectScope();
+    immediateScope.stop();
+    immediateScope = vue.effectScope(true);
+    collectionScopes.forEach((s) => s.stop());
+    collectionScopes = [];
+  }
+  function $touch(runCommit = true, withConditions = false) {
+    $fieldStatus.value.$touch(runCommit, withConditions);
+    $eachStatus.value.forEach(($each) => {
+      $each.$touch(runCommit, withConditions);
+    });
+  }
+  function $reset() {
+    $fieldStatus.value.$reset();
+    $eachStatus.value.forEach(($each) => {
+      $each.$reset();
+    });
+  }
+  async function $validate() {
+    const data = state.value;
+    try {
+      const results = await Promise.allSettled([
+        $fieldStatus.value.$validate(),
+        ...$eachStatus.value.map((rule) => {
+          return rule.$validate();
+        })
+      ]);
+      const validationResults = results.every((value) => {
+        if (value.status === "fulfilled") {
+          return value.value.result === true;
+        } else {
+          return false;
+        }
+      });
+      return { result: validationResults, data };
+    } catch (e) {
+      return { result: false, data };
+    }
+  }
+  function $clearExternalErrors() {
+    $fieldStatus.value.$clearExternalErrors();
+    $eachStatus.value.forEach(($each) => {
+      $each.$clearExternalErrors();
+    });
+  }
+  function $extractDirtyFields(filterNullishValues = true) {
+    let dirtyFields = $eachStatus.value.map(($each) => {
+      if (isNestedRulesStatus($each)) {
+        return $each.$extractDirtyFields(filterNullishValues);
+      }
+    });
+    if (filterNullishValues) {
+      if (dirtyFields.every((value) => {
+        return isEmpty(value);
+      })) {
+        dirtyFields = [];
+      }
+    }
+    return dirtyFields;
+  }
+  function $resetAll() {
+    $unwatch();
+    state.value = cloneDeep(initialState);
+    $reset();
+  }
+  const { $shortcuts, ...restScopeState } = scopeState;
+  return vue.reactive({
+    $field: $fieldStatus,
+    ...restScopeState,
+    ...$shortcuts,
+    $each: $eachStatus,
+    $value: state,
+    $validate,
+    $unwatch,
+    $watch,
+    $touch,
+    $reset,
+    $resetAll,
+    $extractDirtyFields,
+    $clearExternalErrors
+  });
+}
+
+// src/core/useRegle/useStateProperties/createReactiveNestedStatus.ts
+function createReactiveNestedStatus({
+  rulesDef,
+  state,
+  path = "",
+  rootRules,
+  externalErrors,
+  validationGroups,
+  initialState,
+  fieldName,
+  ...commonArgs
+}) {
+  let scope = vue.effectScope();
+  let scopeState;
+  let nestedScopes = [];
+  let $unwatchRules = null;
+  let $unwatchExternalErrors = null;
+  let $unwatchState = null;
+  async function createReactiveFieldsStatus(watch6 = true) {
+    const mapOfRulesDef = Object.entries(rulesDef.value);
+    const scopedRulesStatus = Object.fromEntries(
+      mapOfRulesDef.filter(([_, rule]) => !!rule).map(([statePropKey, statePropRules]) => {
+        if (statePropRules) {
+          const stateRef = vue.toRef(state.value, statePropKey);
+          const statePropRulesRef = vue.toRef(() => statePropRules);
+          const $externalErrors = vue.toRef(externalErrors?.value ?? {}, statePropKey);
+          return [
+            statePropKey,
+            createReactiveChildrenStatus({
+              state: stateRef,
+              rulesDef: statePropRulesRef,
+              path: path ? `${path}.${statePropKey}` : statePropKey,
+              externalErrors: $externalErrors,
+              initialState: initialState?.[statePropKey],
+              fieldName: statePropKey,
+              ...commonArgs
+            })
+          ];
+        }
+        return [];
+      })
+    );
+    const externalRulesStatus = Object.fromEntries(
+      Object.entries(vue.unref(externalErrors) ?? {}).filter(([key, errors]) => !(key in rulesDef.value) && !!errors).map(([key]) => {
+        const stateRef = vue.toRef(state.value, key);
+        return [
+          key,
+          createReactiveChildrenStatus({
+            state: stateRef,
+            rulesDef: vue.computed(() => ({})),
+            path: path ? `${path}.${key}` : key,
+            externalErrors: vue.toRef(externalErrors?.value ?? {}, key),
+            initialState: initialState?.[key],
+            fieldName: key,
+            ...commonArgs
+          })
+        ];
+      })
+    );
+    const statesWithNoRules = Object.fromEntries(
+      Object.entries(state.value).filter(([key]) => !(key in rulesDef.value) && !(key in (externalRulesStatus.value ?? {}))).map(([key]) => {
+        const stateRef = vue.toRef(state.value, key);
+        return [
+          key,
+          createReactiveChildrenStatus({
+            state: stateRef,
+            rulesDef: vue.computed(() => ({})),
+            path: path ? `${path}.${key}` : key,
+            externalErrors: vue.toRef(externalErrors?.value ?? {}, key),
+            initialState: initialState?.[key],
+            fieldName: key,
+            ...commonArgs
+          })
+        ];
+      })
+    );
+    $fields.value = {
+      ...scopedRulesStatus,
+      ...externalRulesStatus,
+      ...statesWithNoRules
+    };
+    if (watch6) {
+      $watch();
+    }
+  }
+  const $fields = commonArgs.storage.getFieldsEntry(path);
+  createReactiveFieldsStatus();
+  function $reset() {
+    $unwatchExternalErrors?.();
+    Object.values($fields.value).forEach((statusOrField) => {
+      statusOrField.$reset();
+    });
+    define$WatchExternalErrors();
+  }
+  function $touch(runCommit = true, withConditions = false) {
+    Object.values($fields.value).forEach((statusOrField) => {
+      statusOrField.$touch(runCommit, withConditions);
+    });
+  }
+  function define$WatchExternalErrors() {
+    if (externalErrors?.value) {
+      $unwatchExternalErrors = vue.watch(
+        externalErrors,
+        () => {
+          $unwatch();
+          createReactiveFieldsStatus();
+        },
+        { deep: true }
+      );
+    }
+  }
+  function $watch() {
+    if (rootRules) {
+      $unwatchRules = vue.watch(
+        rootRules,
+        () => {
+          $unwatch();
+          createReactiveFieldsStatus();
+        },
+        { deep: true, flush: "post" }
+      );
+      define$WatchExternalErrors();
+    }
+    $unwatchState = vue.watch(
+      state,
+      () => {
+        $unwatch();
+        createReactiveFieldsStatus();
+        $touch(true, true);
+      },
+      { flush: "sync" }
+    );
+    scope = vue.effectScope();
+    scopeState = scope.run(() => {
+      const $dirty = vue.computed({
+        get: () => {
+          return !!Object.entries($fields.value).length && Object.entries($fields.value).every(([key, statusOrField]) => {
+            return statusOrField?.$dirty;
+          });
+        },
+        set() {
+        }
+      });
+      const $anyDirty = vue.computed({
+        get: () => {
+          return Object.entries($fields.value).some(([key, statusOrField]) => {
+            return statusOrField?.$dirty;
+          });
+        },
+        set() {
+        }
+      });
+      const $invalid = vue.computed({
+        get: () => {
+          return Object.entries($fields.value).some(([key, statusOrField]) => {
+            return statusOrField?.$invalid;
+          });
+        },
+        set() {
+        }
+      });
+      const $valid = vue.computed({
+        get: () => {
+          return Object.entries($fields.value).every(([key, statusOrField]) => {
+            return statusOrField?.$valid;
+          });
+        },
+        set() {
+        }
+      });
+      const $error = vue.computed({
+        get: () => {
+          return $anyDirty.value && !$pending.value && $invalid.value;
+        },
+        set() {
+        }
+      });
+      const $ready = vue.computed({
+        get: () => {
+          if (!vue.unref(commonArgs.options.autoDirty)) {
+            return !($invalid.value || $pending.value);
+          }
+          return $anyDirty.value && !($invalid.value || $pending.value);
+        },
+        set() {
+        }
+      });
+      const $pending = vue.computed({
+        get: () => {
+          return Object.entries($fields.value).some(([key, statusOrField]) => {
+            return statusOrField?.$pending;
+          });
+        },
+        set() {
+        }
+      });
+      const $errors = vue.computed({
+        get: () => {
+          return Object.fromEntries(
+            Object.entries($fields.value).map(([key, statusOrField]) => {
+              return [key, statusOrField?.$errors];
+            })
+          );
+        },
+        set() {
+        }
+      });
+      const $silentErrors = vue.computed({
+        get: () => {
+          return Object.fromEntries(
+            Object.entries($fields.value).map(([key, statusOrField]) => {
+              return [key, statusOrField?.$silentErrors];
+            })
+          );
+        },
+        set() {
+        }
+      });
+      const $name = vue.computed({
+        get: () => fieldName,
+        set() {
+        }
+      });
+      function processShortcuts() {
+        if (commonArgs.shortcuts?.nested) {
+          Object.entries(commonArgs.shortcuts.nested).forEach(([key, value]) => {
+            const scope2 = vue.effectScope();
+            $shortcuts2[key] = scope2.run(() => {
+              const result = vue.ref();
+              vue.watchEffect(() => {
+                result.value = value(
+                  vue.reactive({
+                    $dirty,
+                    $value: state,
+                    $error,
+                    $pending,
+                    $invalid,
+                    $valid,
+                    $ready,
+                    $anyDirty,
+                    $name,
+                    $silentErrors,
+                    $errors,
+                    $fields
+                  })
+                );
+              });
+              return result;
+            });
+            nestedScopes.push(scope2);
+          });
+        }
+      }
+      const $groups = vue.computed({
+        get: () => {
+          if (validationGroups) {
+            return Object.fromEntries(
+              Object.entries(validationGroups?.($fields.value) ?? {}).map(([key, entries]) => {
+                if (entries.length) {
+                  return [
+                    key,
+                    {
+                      ...Object.fromEntries(
+                        ["$invalid", "$error", "$pending", "$dirty", "$valid"].map((property) => [
+                          property,
+                          mergeBooleanGroupProperties(entries, property)
+                        ])
+                      ),
+                      ...Object.fromEntries(
+                        ["$errors", "$silentErrors"].map((property) => [
+                          property,
+                          mergeArrayGroupProperties(entries, property)
+                        ])
+                      )
+                    }
+                  ];
+                }
+                return [];
+              })
+            );
+          }
+          return {};
+        },
+        set() {
+        }
+      });
+      const $shortcuts2 = {};
+      processShortcuts();
+      return {
+        $dirty,
+        $anyDirty,
+        $invalid,
+        $valid,
+        $error,
+        $pending,
+        $errors,
+        $silentErrors,
+        $ready,
+        $name,
+        $shortcuts: $shortcuts2,
+        $groups
+      };
+    });
+  }
+  function $unwatch() {
+    $unwatchRules?.();
+    $unwatchExternalErrors?.();
+    $unwatchState?.();
+    nestedScopes.forEach((s) => s.stop());
+    nestedScopes = [];
+    scope.stop();
+    if ($fields.value) {
+      Object.entries($fields.value).forEach(([_, field]) => {
+        field.$unwatch();
+      });
+    }
+  }
+  function $clearExternalErrors() {
+    Object.entries($fields.value).forEach(([_, field]) => {
+      field.$clearExternalErrors();
+    });
+  }
+  async function $resetAll() {
+    $unwatch();
+    state.value = cloneDeep({ ...initialState ?? {} });
+    $reset();
+    createReactiveFieldsStatus();
+  }
+  function filterNullishFields(fields) {
+    return fields.filter(([key, value]) => {
+      if (isObject(value)) {
+        return !(value && typeof value === "object" && "_null" in value) && !isEmpty(value);
+      } else if (Array.isArray(value)) {
+        return value.length;
+      } else {
+        return true;
+      }
+    });
+  }
+  function $extractDirtyFields(filterNullishValues = true) {
+    let dirtyFields = Object.entries($fields.value).map(([key, field]) => {
+      return [key, field.$extractDirtyFields(filterNullishValues)];
+    });
+    if (filterNullishValues) {
+      dirtyFields = filterNullishFields(dirtyFields);
+    }
+    return Object.fromEntries(dirtyFields);
+  }
+  async function $validate() {
+    try {
+      const data = state.value;
+      const results = await Promise.allSettled(
+        Object.values($fields.value).map((statusOrField) => {
+          return statusOrField.$validate();
+        })
+      );
+      const validationResults = results.every((value) => {
+        if (value.status === "fulfilled") {
+          return value.value.result === true;
+        } else {
+          return false;
+        }
+      });
+      return { result: validationResults, data };
+    } catch (e) {
+      return { result: false, data: state.value };
+    }
+  }
+  const { $shortcuts, ...restScopeState } = scopeState;
+  return vue.reactive({
+    ...restScopeState,
+    ...$shortcuts,
+    $fields,
+    $value: state,
+    $resetAll,
+    $reset,
+    $touch,
+    $validate,
+    $unwatch,
+    $watch,
+    $clearExternalErrors,
+    $extractDirtyFields
+  });
+}
+function createReactiveChildrenStatus({
+  rulesDef,
+  externalErrors,
+  ...properties
+}) {
+  if (isCollectionRulesDef(rulesDef, properties.state)) {
+    return createReactiveCollectionStatus({
+      rulesDef,
+      externalErrors,
+      ...properties
+    });
+  } else if (isNestedRulesDef(properties.state, rulesDef) && isRefObject(properties.state)) {
+    return createReactiveNestedStatus({
+      rulesDef,
+      externalErrors,
+      ...properties
+    });
+  } else if (isValidatorRulesDef(rulesDef)) {
+    return createReactiveFieldStatus({
+      rulesDef,
+      externalErrors,
+      ...properties
+    });
+  }
+  return null;
+}
+
+// src/core/useRegle/useStateProperties/useStateProperties.ts
+function useStateProperties({
+  initialState,
+  options,
+  scopeRules,
+  state,
+  customRules,
+  shortcuts
+}) {
+  const storage = useStorage();
+  const regle = vue.ref();
+  regle.value = createReactiveNestedStatus({
+    rootRules: scopeRules,
+    rulesDef: scopeRules,
+    state,
+    customMessages: customRules?.(),
+    storage,
+    options,
+    externalErrors: options.externalErrors,
+    validationGroups: options.validationGroups,
+    initialState,
+    shortcuts,
+    fieldName: "root",
+    path: ""
+  });
+  vue.onScopeDispose(() => {
+    regle.value?.$unwatch();
+  });
+  return vue.reactive({ regle });
+}
+
+// src/core/useRegle/useRegle.ts
+function createUseRegleComposable(customRules, options, shortcuts) {
+  const globalOptions = {
+    autoDirty: options?.autoDirty ?? true,
+    lazy: options?.lazy ?? false,
+    rewardEarly: options?.rewardEarly ?? false,
+    clearExternalErrorsOnChange: options?.clearExternalErrorsOnChange ?? true
+  };
+  function useRegle2(state, rulesFactory, options2) {
+    const scopeRules = vue.isRef(rulesFactory) ? rulesFactory : vue.computed(typeof rulesFactory === "function" ? rulesFactory : () => rulesFactory);
+    const resolvedOptions = {
+      ...globalOptions,
+      ...options2
+    };
+    const processedState = vue.isRef(state) ? state : vue.ref(state);
+    const initialState = { ...cloneDeep(processedState.value) };
+    const regle = useStateProperties({
+      scopeRules,
+      state: processedState,
+      options: resolvedOptions,
+      initialState,
+      customRules,
+      shortcuts
+    });
+    return {
+      r$: regle.regle
+    };
+  }
+  return useRegle2;
+}
+var useRegle = createUseRegleComposable();
+function createInferRuleHelper() {
+  function inferRules2(state, rulesFactory) {
+    return rulesFactory;
+  }
+  return inferRules2;
+}
+var inferRules = createInferRuleHelper();
+
+// src/core/defineRegleConfig.ts
+function defineRegleConfig({
+  rules,
+  modifiers,
+  shortcuts
+}) {
+  const useRegle2 = createUseRegleComposable(rules, modifiers, shortcuts);
+  const inferRules2 = createInferRuleHelper();
+  return { useRegle: useRegle2, inferRules: inferRules2 };
+}
+
+exports.InternalRuleType = InternalRuleType;
+exports.createRule = createRule;
+exports.defineRegleConfig = defineRegleConfig;
+exports.inferRules = inferRules;
+exports.unwrapRuleParameters = unwrapRuleParameters;
+exports.useRegle = useRegle;