@regle/core 0.0.3 → 0.0.4-beta.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/core/createRule/unwrapRuleParameters.ts
-import { unref } from "vue";
+import { isRef, toRef, unref } from "vue";
 function unwrapRuleParameters(params) {
   return params.map((param) => {
     if (param instanceof Function) {
@@ -8,6 +8,16 @@ function unwrapRuleParameters(params) {
     return unref(param);
   });
 }
+function createReactiveParams(params) {
+  return params.map((param) => {
+    if (param instanceof Function) {
+      return param;
+    } else if (isRef(param)) {
+      return param;
+    }
+    return toRef(() => param);
+  });
+}
 
 // src/core/createRule/defineRuleProcessors.ts
 function defineRuleProcessors(definition, ...params) {
@@ -15,26 +25,17 @@ function defineRuleProcessors(definition, ...params) {
   const processors = {
     message(value, ...args) {
       if (typeof definition.message === "function") {
-        return definition.message(
-          value,
-          ...unwrapRuleParameters(args.length ? args : params)
-        );
+        return definition.message(value, ...args.length ? args : params);
       } else {
         return definition.message;
       }
     },
     validator(value, ...args) {
-      return definition.validator(
-        value,
-        ...unwrapRuleParameters(args.length ? args : params)
-      );
+      return definition.validator(value, ...args.length ? args : params);
     },
     active(value, ...args) {
       if (typeof definition.active === "function") {
-        return definition.active(
-          value,
-          ...unwrapRuleParameters(args.length ? args : params)
-        );
+        return definition.active(value, ...args.length ? args : params);
       } else {
         return definition.active ?? true;
       }
@@ -46,7 +47,7 @@ function defineRuleProcessors(definition, ...params) {
       _active: definition.active,
       _type: definition.type,
       _patched: false,
-      _params: params
+      _params: createReactiveParams(params)
     }
   };
   return processors;
@@ -79,18 +80,21 @@ function createRule(definition) {
 }
 
 // src/core/useRegle/useRegle.ts
-import { computed as computed4, isRef, shallowRef, toRaw } from "vue";
+import { computed as computed5, isRef as isRef2, shallowRef as shallowRef2, toRaw } from "vue";
 
 // src/core/useRegle/useStateProperties/useStateProperties.ts
-import { ref as ref3 } from "vue";
+import { reactive as reactive5 } from "vue";
 
-// src/core/useRegle/useStateProperties/createReactiveStatus.ts
-import { computed as computed2, reactive as reactive2, ref as ref2, toRef, toRefs, watch as watch2 } from "vue";
+// src/core/useRegle/useErrors.ts
+import { computed } from "vue";
 
 // src/utils/object.utils.ts
 function isObject(obj) {
   return typeof obj === "object" && obj !== null && !Array.isArray(obj);
 }
+function isRefObject(obj) {
+  return isObject(obj.value);
+}
 
 // src/utils/isEmpty.ts
 function isEmpty(value) {
@@ -115,6 +119,9 @@ function isEmpty(value) {
   return !String(value).trim().length;
 }
 
+// src/utils/composables.ts
+import { effectScope, getCurrentScope, onScopeDispose } from "vue";
+
 // src/core/useRegle/guards/ruleDef.guards.ts
 function isNestedRulesDef(state, rule) {
   return isObject(state.value) && isObject(rule.value) && !Object.entries(rule.value).some((rule2) => isRuleDef(rule2));
@@ -131,9 +138,6 @@ function isRuleDef(rule) {
 function isFormRuleDefinition(rule) {
   return !(typeof rule.value === "function");
 }
-function isFormInline(rule) {
-  return typeof rule.value === "function";
-}
 
 // src/core/useRegle/guards/rule.status.guards.ts
 function isNestedRulesStatus(rule) {
@@ -146,8 +150,72 @@ function isFieldStatus(rule) {
   return !!rule && "$rules" in rule;
 }
 
+// src/core/useRegle/useErrors.ts
+function extractRulesErrors(rules) {
+  return Object.entries(rules).map(([ruleKey, rule]) => {
+    if (!rule.$valid) {
+      return rule.$message;
+    }
+    return null;
+  }).filter((msg) => !!msg);
+}
+function processFieldErrors(fieldStatus) {
+  if (isNestedRulesStatus(fieldStatus)) {
+    return extractNestedErrors(fieldStatus.$fields);
+  } else if (isCollectionRulesStatus(fieldStatus)) {
+    return {
+      $errors: fieldStatus.$rules ? extractRulesErrors(fieldStatus.$rules) : [],
+      $each: fieldStatus.$each.map(processFieldErrors)
+    };
+  } else if (isFieldStatus(fieldStatus) && fieldStatus.$error) {
+    return extractRulesErrors(fieldStatus.$rules);
+  }
+  return [];
+}
+function extractCollectionError(field) {
+  return field.$each.map(processFieldErrors);
+}
+function extractNestedErrors(fields) {
+  return Object.fromEntries(
+    Object.entries(fields).map(([fieldKey, fieldStatus]) => {
+      if (isNestedRulesStatus(fieldStatus)) {
+        return [fieldKey, extractNestedErrors(fieldStatus.$fields)];
+      } else if (isCollectionRulesStatus(fieldStatus)) {
+        return [
+          fieldKey,
+          {
+            ...fieldStatus.$rules && { $errors: extractRulesErrors(fieldStatus.$rules) },
+            $each: extractCollectionError(fieldStatus)
+          }
+        ];
+      } else if (isFieldStatus(fieldStatus) && fieldStatus.$error) {
+        return [fieldKey, extractRulesErrors(fieldStatus.$rules)];
+      }
+      return [fieldKey, []];
+    })
+  );
+}
+function useErrors($regle) {
+  const errors = computed(() => {
+    return extractNestedErrors($regle.$fields);
+  });
+  return errors;
+}
+
+// src/core/useRegle/useStateProperties/createReactiveNestedStatus.ts
+import {
+  computed as computed4,
+  effectScope as effectScope4,
+  reactive as reactive4,
+  toRef as toRef4,
+  watch as watch4
+} from "vue";
+
+// src/core/useRegle/useStateProperties/createReactiveFieldStatus.ts
+import { computed as computed3, effectScope as effectScope3, reactive as reactive2, ref as ref2, toRef as toRef2, watch as watch2 } from "vue";
+
 // src/core/useRegle/useStateProperties/createReactiveRuleStatus.ts
-import { computed, reactive, ref, watch } from "vue";
+import { computed as computed2, effectScope as effectScope2, reactive, watch } from "vue";
 
 // src/types/rules/rule.internal.types.ts
 var InternalRuleType = /* @__PURE__ */ ((InternalRuleType2) => {
@@ -162,311 +230,595 @@ function createReactiveRuleStatus({
   customMessages,
   rule,
   ruleKey,
-  state
+  state,
+  path,
+  storage
 }) {
-  const $pending = ref(false);
-  const $valid = ref(true);
-  const $active = computed(() => {
-    if (isFormInline(rule)) {
-      return true;
-    } else {
-      if (typeof rule.value.active === "function") {
-        return rule.value.active(state.value, ...$params.value);
-      } else {
-        return rule.value.active;
-      }
-    }
-  });
-  const $message = computed(() => {
-    let message = "";
-    const customMessageRule = customMessages[ruleKey]?.message;
-    if (customMessageRule) {
-      if (typeof customMessageRule === "function") {
-        message = customMessageRule(state.value, ...$params.value);
-      } else {
-        message = customMessageRule;
-      }
-    }
-    if (isFormRuleDefinition(rule)) {
-      if (!(customMessageRule && !rule.value._patched)) {
-        if (typeof rule.value.message === "function") {
-          message = rule.value.message(state.value, ...$params.value);
+  let scope = effectScope2();
+  let scopeState;
+  const { $pending, $valid } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
+  function $watch() {
+    scopeState = scope.run(() => {
+      const $active = computed2(() => {
+        if (isFormRuleDefinition(rule)) {
+          if (typeof rule.value.active === "function") {
+            return rule.value.active(state.value, ...$params.value);
+          } else {
+            return rule.value.active;
+          }
         } else {
-          message = rule.value.message;
+          return true;
         }
-      }
-    }
-    if (isEmpty(message)) {
-      message = "Error";
-      console.warn(`No error message defined for ${ruleKey}`);
-    }
-    return message;
-  });
-  const $type = computed(() => {
-    if (isFormInline(rule)) {
-      return ruleKey;
-    } else {
-      return Object.values(InternalRuleType).includes(rule.value.type) ? ruleKey : rule.value.type;
-    }
-  });
-  const $validator = computed(
-    () => {
-      if (isFormInline(rule)) {
-        return rule.value;
-      } else {
-        return rule.value.validator;
-      }
-    }
-  );
-  const $params = computed(() => {
-    if (typeof rule.value === "function") {
-      return [];
-    }
-    return unwrapRuleParameters(rule.value._params ?? []);
-  });
-  watch(
-    [state, $dirty, $params],
-    async () => {
-      const validator = $validator.value;
-      let ruleResult = false;
-      const resultOrPromise = validator(state.value, ...$params.value);
-      if (resultOrPromise instanceof Promise) {
-        if ($dirty.value) {
-          try {
-            $valid.value = true;
-            $pending.value = true;
-            const promiseResult = await resultOrPromise;
-            ruleResult = promiseResult;
-          } catch (e) {
-            ruleResult = false;
-          } finally {
-            $pending.value = false;
+      });
+      const $message = computed2(() => {
+        let message = "";
+        const customMessageRule = customMessages[ruleKey]?.message;
+        if (customMessageRule) {
+          if (typeof customMessageRule === "function") {
+            message = customMessageRule(state.value, ...$params.value);
+          } else {
+            message = customMessageRule;
           }
         }
-      } else {
-        ruleResult = resultOrPromise;
+        if (isFormRuleDefinition(rule)) {
+          if (!(customMessageRule && !rule.value._patched)) {
+            if (typeof rule.value.message === "function") {
+              message = rule.value.message(state.value, ...$params.value);
+            } else {
+              message = rule.value.message;
+            }
+          }
+        }
+        if (isEmpty(message)) {
+          message = "Error";
+          console.warn(`No error message defined for ${ruleKey}`);
+        }
+        return message;
+      });
+      const $type = computed2(() => {
+        if (isFormRuleDefinition(rule)) {
+          return Object.values(InternalRuleType).includes(rule.value.type) ? ruleKey : rule.value.type;
+        } else {
+          return ruleKey;
+        }
+      });
+      const $validator = computed2(() => {
+        if (isFormRuleDefinition(rule)) {
+          return rule.value.validator;
+        } else {
+          return rule.value;
+        }
+      });
+      const $params = computed2(() => {
+        if (typeof rule.value === "function") {
+          return [];
+        }
+        return unwrapRuleParameters(rule.value._params ?? []);
+      });
+      const $path = computed2(() => `${path}.${$type.value}`);
+      return {
+        $active,
+        $message,
+        $type,
+        $validator,
+        $params,
+        $path
+      };
+    });
+    $validate();
+  }
+  $watch();
+  const $unwatchState = watch(scopeState.$params, $validate, {
+    deep: true
+  });
+  async function $validate() {
+    const validator = scopeState.$validator.value;
+    let ruleResult = false;
+    const resultOrPromise = validator(state.value, ...scopeState.$params.value);
+    if (resultOrPromise instanceof Promise) {
+      if ($dirty.value && !$pending.value) {
+        try {
+          $valid.value = true;
+          $pending.value = true;
+          const promiseResult = await resultOrPromise;
+          ruleResult = promiseResult;
+        } catch (e) {
+          ruleResult = false;
+        } finally {
+          $pending.value = false;
+        }
       }
-      $valid.value = ruleResult;
-    },
-    { immediate: true, deep: true }
-  );
+    } else {
+      ruleResult = resultOrPromise;
+    }
+    $valid.value = ruleResult;
+    return ruleResult;
+  }
+  function $unwatch() {
+    $unwatchState();
+    scope.stop();
+    scope = effectScope2();
+    scopeState = null;
+  }
   return reactive({
-    $message,
-    $active,
+    ...scopeState,
     $pending,
-    $type,
     $valid,
-    $validator,
-    ...$params.value.length && { $params }
+    $validate,
+    $unwatch,
+    $watch
   });
 }
 
-// src/core/useRegle/useStateProperties/createReactiveStatus.ts
-function createReactiveNestedStatus(scopeRules, state, customRules) {
-  const $fields = reactive2(
-    Object.fromEntries(
-      Object.entries(scopeRules.value).map(([statePropKey, statePropRules]) => {
-        if (statePropRules) {
-          const stateRef = toRef(state.value, statePropKey);
-          const statePropRulesRef = toRef(() => statePropRules);
+// src/core/useRegle/useStateProperties/createReactiveFieldStatus.ts
+function createReactiveFieldStatus({
+  state,
+  rulesDef,
+  customMessages,
+  path,
+  storage
+}) {
+  let scope = effectScope3();
+  let scopeState;
+  const $dirty = ref2(false);
+  const $anyDirty = computed3(() => $dirty.value);
+  function createReactiveRulesResult() {
+    const declaredRules = rulesDef.value;
+    const storeResult = storage.checkRuleDeclEntry(path, declaredRules);
+    $rules.value = Object.fromEntries(
+      Object.entries(declaredRules).map(([ruleKey, rule]) => {
+        if (rule) {
+          const ruleRef = toRef2(() => rule);
           return [
-            statePropKey,
-            createReactiveFieldStatus(stateRef, statePropRulesRef, customRules)
+            ruleKey,
+            createReactiveRuleStatus({
+              $dirty,
+              customMessages,
+              rule: ruleRef,
+              ruleKey,
+              state,
+              path,
+              storage
+            })
           ];
         }
         return [];
-      }).filter(
-        (rule) => !!rule.length && rule[1] != null
-      )
-    )
-  );
-  const $dirty = computed2(() => {
-    return Object.entries($fields).every(([key, statusOrField]) => {
-      return statusOrField.$dirty;
-    });
-  });
-  const $anyDirty = computed2(() => {
-    return Object.entries($fields).some(([key, statusOrField]) => {
-      return statusOrField.$dirty;
-    });
-  });
-  const $invalid = computed2(() => {
-    return Object.entries($fields).some(([key, statusOrField]) => {
-      return statusOrField.$invalid;
-    });
+      }).filter((ruleDef) => !!ruleDef.length)
+    );
+    $watch();
+    if (storeResult?.valid != null) {
+      $dirty.value = storage.getDirtyState(path);
+    }
+    storage.addRuleDeclEntry(path, declaredRules);
+  }
+  const $unwatchDirty = watch2($dirty, () => {
+    storage.setDirtyEntry(path, $dirty.value);
   });
-  const $error = computed2(() => {
-    return Object.entries($fields).some(([key, statusOrField]) => {
-      return statusOrField.$error;
-    });
+  const $unwatchState = watch2(state, () => {
+    if (!$dirty.value) {
+      $dirty.value = true;
+    }
+    $validate();
   });
-  const $pending = computed2(() => {
-    return Object.entries($fields).some(([key, statusOrField]) => {
-      return statusOrField.$pending;
+  function $unwatch() {
+    if ($rules.value) {
+      Object.entries($rules.value).forEach(([_, rule]) => {
+        rule.$unwatch();
+      });
+    }
+    $unwatchDirty();
+    if ($dirty.value) {
+      storage.setDirtyEntry(path, $dirty.value);
+    }
+    $unwatchState();
+    scope.stop();
+    scope = effectScope3();
+    scopeState = null;
+  }
+  function $watch() {
+    scopeState = scope.run(() => {
+      const $error = computed3(() => {
+        return $invalid.value && !$pending.value && $dirty.value;
+      });
+      const $pending = computed3(() => {
+        return Object.entries($rules.value).some(([key, rule]) => {
+          return rule.$pending;
+        });
+      });
+      const $invalid = computed3(() => {
+        return Object.entries($rules.value).some(([key, ruleResult]) => {
+          return !ruleResult.$valid;
+        });
+      });
+      const $valid = computed3(() => !$invalid.value);
+      return {
+        $error,
+        $pending,
+        $invalid,
+        $valid
+      };
     });
-  });
+  }
+  const $rules = ref2();
+  createReactiveRulesResult();
   function $reset() {
-    Object.entries($fields).forEach(([key, statusOrField]) => {
-      statusOrField.$reset();
-    });
+    $dirty.value = false;
   }
   function $touch() {
-    Object.entries($fields).forEach(([key, statusOrField]) => {
-      statusOrField.$touch();
-    });
+    $dirty.value = true;
+    $validate();
+  }
+  async function $validate() {
+    try {
+      const results = await Promise.all(
+        Object.entries($rules.value).map(([key, rule]) => {
+          return rule.$validate();
+        })
+      );
+      return results.every((value) => !!value);
+    } catch (e) {
+      return false;
+    }
   }
-  const $valid = computed2(() => !$invalid.value);
   return reactive2({
     $dirty,
     $anyDirty,
-    $invalid,
-    $valid,
-    $error,
-    $pending,
+    $invalid: scopeState.$invalid,
+    $error: scopeState.$error,
+    $pending: scopeState.$pending,
+    $valid: scopeState.$valid,
     $value: state,
-    $fields,
+    $rules,
     $reset,
-    $touch
+    $touch,
+    $validate,
+    $unwatch,
+    $watch
   });
 }
-function createReactiveFieldStatus(state, rulesDef, customRules) {
-  if (isCollectionRulesDef(rulesDef)) {
-    const { $each, ...otherFields } = toRefs(reactive2(rulesDef.value));
-    if (Array.isArray(state.value) && $each?.value) {
-      const values = toRefs(state.value);
-      return reactive2({
-        ...!isEmpty(otherFields) && createReactiveFieldStatus(state, toRef(reactive2(otherFields)), customRules),
-        $each: values.map((value) => {
-          return createReactiveFieldStatus(value, $each, customRules);
-        }).filter((f) => !!f)
+
+// src/core/useRegle/useStateProperties/createReactiveCollectionStatus.ts
+import { reactive as reactive3, ref as ref3, toRef as toRef3, watch as watch3 } from "vue";
+function createReactiveCollectionStatus({
+  state,
+  rulesDef,
+  customMessages,
+  path,
+  storage
+}) {
+  if (Array.isArray(state.value) && !rulesDef.value.$each) {
+    return null;
+  }
+  let $unwatchState = null;
+  const $fieldStatus = ref3({});
+  const $eachStatus = storage.getCollectionsEntry(path);
+  createStatus();
+  $watch();
+  function createStatus() {
+    const { $each, ...otherFields } = rulesDef.value;
+    $fieldStatus.value = createReactiveFieldStatus({
+      state,
+      rulesDef: toRef3(() => otherFields),
+      customMessages,
+      path,
+      storage
+    });
+    if (Array.isArray(state.value) && $each) {
+      $eachStatus.value = state.value.map((value, index) => {
+        const $path = `${path}.${index}`;
+        return createReactiveChildrenStatus({
+          state: toRef3(() => value),
+          rulesDef: toRef3(() => $each),
+          customMessages,
+          path: $path,
+          storage
+        });
+      }).filter((f) => !!f);
+    } else {
+      $eachStatus.value = [];
+    }
+  }
+  function $unwatch() {
+    if ($unwatchState) {
+      $unwatchState();
+    }
+    if ($fieldStatus.value) {
+      $fieldStatus.value.$unwatch();
+    }
+    if ($eachStatus.value) {
+      $eachStatus.value.forEach((element) => {
+        element.$unwatch();
       });
     }
-    return null;
-  } else if (isNestedRulesDef(state, rulesDef)) {
-    return createReactiveNestedStatus(rulesDef, state, customRules);
-  } else if (isValidatorRulesDef(rulesDef)) {
-    let $reset2 = function() {
-      $dirty.value = false;
-    }, $touch2 = function() {
-      $dirty.value = true;
-    };
-    var $reset = $reset2, $touch = $touch2;
-    const customMessages = customRules();
-    const $dirty = ref2(false);
-    const $anyDirty = computed2(() => $dirty.value);
-    const $rules = reactive2(
-      Object.fromEntries(
-        Object.entries(rulesDef.value).map(([ruleKey, rule]) => {
-          if (rule) {
-            const ruleRef = toRef(() => rule);
-            return [
-              ruleKey,
-              createReactiveRuleStatus({
-                $dirty,
-                customMessages,
-                rule: ruleRef,
-                ruleKey,
-                state
-              })
-            ];
-          }
-          return [];
-        }).filter((ruleDef) => !!ruleDef.length)
+  }
+  function $watch() {
+    $unwatchState = watch3(
+      state,
+      () => {
+        createStatus();
+      },
+      { deep: true, flush: "sync" }
+    );
+  }
+  return reactive3({
+    ...$fieldStatus.value,
+    $each: $eachStatus,
+    $unwatch,
+    $watch
+  });
+}
+
+// src/core/useRegle/useStateProperties/createReactiveNestedStatus.ts
+function createReactiveNestedStatus({
+  scopeRules,
+  state,
+  customMessages,
+  path = "",
+  rootRules,
+  storage
+}) {
+  let scope = effectScope4();
+  let scopeState;
+  let $unwatchFields;
+  function createReactiveFieldsStatus() {
+    $fields.value = Object.fromEntries(
+      Object.entries(scopeRules.value).map(([statePropKey, statePropRules]) => {
+        if (statePropRules) {
+          const stateRef = toRef4(state.value, statePropKey);
+          const statePropRulesRef = toRef4(() => statePropRules);
+          return [
+            statePropKey,
+            createReactiveChildrenStatus({
+              state: stateRef,
+              rulesDef: statePropRulesRef,
+              customMessages,
+              path: path ? `${path}.${statePropKey}` : statePropKey,
+              storage
+            })
+          ];
+        }
+        return [];
+      }).filter(
+        (rule) => !!rule.length && rule[1] != null
       )
     );
-    const $error = computed2(() => {
-      return $invalid.value && !$pending.value && $dirty.value;
+    $watch();
+  }
+  const $fields = storage.getFieldsEntry(path);
+  createReactiveFieldsStatus();
+  function $reset() {
+    Object.entries($fields.value).forEach(([_, statusOrField]) => {
+      statusOrField.$reset();
     });
-    const $pending = computed2(() => {
-      return Object.entries($rules).some(([key, rule]) => {
-        return rule.$pending;
+  }
+  function $touch() {
+    Object.entries($fields.value).forEach(([_, statusOrField]) => {
+      statusOrField.$touch();
+    });
+  }
+  async function $validate() {
+    try {
+      const results = await Promise.all(
+        Object.entries($fields.value).map(([_, statusOrField]) => {
+          return statusOrField.$validate();
+        })
+      );
+      return results.every((value) => !!value);
+    } catch (e) {
+      return false;
+    }
+  }
+  function $watch() {
+    if (rootRules) {
+      $unwatchFields = watch4(
+        rootRules,
+        () => {
+          $unwatch();
+          createReactiveFieldsStatus();
+        },
+        { deep: true, flush: "post" }
+      );
+    }
+    scopeState = scope.run(() => {
+      const $dirty = computed4(() => {
+        return Object.entries($fields.value).every(([key, statusOrField]) => {
+          return statusOrField.$dirty;
+        });
+      });
+      const $anyDirty = computed4(() => {
+        return Object.entries($fields.value).some(([key, statusOrField]) => {
+          return statusOrField.$dirty;
+        });
+      });
+      const $invalid = computed4(() => {
+        return Object.entries($fields.value).some(([key, statusOrField]) => {
+          return statusOrField.$invalid;
+        });
+      });
+      const $valid = computed4(() => !$invalid.value);
+      const $error = computed4(() => {
+        return Object.entries($fields.value).some(([key, statusOrField]) => {
+          return statusOrField.$error;
+        });
+      });
+      const $pending = computed4(() => {
+        return Object.entries($fields.value).some(([key, statusOrField]) => {
+          return statusOrField.$pending;
+        });
       });
+      return {
+        $dirty,
+        $anyDirty,
+        $invalid,
+        $valid,
+        $error,
+        $pending
+      };
     });
-    const $invalid = computed2(() => {
-      return Object.entries($rules).some(([key, ruleResult]) => {
-        return !ruleResult.$valid;
+  }
+  function $unwatch() {
+    if ($fields.value) {
+      Object.entries($fields.value).forEach(([_, field]) => {
+        field.$unwatch();
       });
+    }
+    if ($unwatchFields) {
+      $unwatchFields();
+    }
+    scope.stop();
+    scope = effectScope4();
+    scopeState = null;
+  }
+  return reactive4({
+    ...scopeState,
+    $fields,
+    $reset,
+    $touch,
+    $validate,
+    $unwatch,
+    $watch
+  });
+}
+function createReactiveChildrenStatus({
+  state,
+  rulesDef,
+  customMessages,
+  path,
+  storage
+}) {
+  if (isCollectionRulesDef(rulesDef)) {
+    return createReactiveCollectionStatus({
+      state,
+      rulesDef,
+      customMessages,
+      path,
+      storage
     });
-    const $valid = computed2(() => !$invalid.value);
-    watch2(state, () => {
-      console.log(state);
-      if (!$dirty.value) {
-        $dirty.value = true;
-      }
+  } else if (isNestedRulesDef(state, rulesDef) && isRefObject(state)) {
+    return createReactiveNestedStatus({
+      scopeRules: rulesDef,
+      state,
+      customMessages,
+      path,
+      storage
     });
-    console.log(state);
-    return reactive2({
-      $dirty,
-      $anyDirty,
-      $invalid,
-      $error,
-      $pending,
-      $valid,
-      $reset: $reset2,
-      $touch: $touch2,
-      $value: state,
-      $rules
+  } else if (isValidatorRulesDef(rulesDef)) {
+    return createReactiveFieldStatus({
+      state,
+      rulesDef,
+      customMessages,
+      path,
+      storage
     });
   }
   return null;
 }
 
-// src/core/useRegle/useErrors.ts
-import { computed as computed3 } from "vue";
-function extractRulesErrors(rules) {
-  return Object.entries(rules).map(([ruleKey, rule]) => {
-    if (!rule.$valid) {
-      return rule.$message;
+// src/core/useStorage/useStorage.ts
+import { ref as ref5, shallowRef } from "vue";
+function useStorage() {
+  const ruleDeclStorage = shallowRef(/* @__PURE__ */ new Map());
+  const fieldsStorage = shallowRef(
+    /* @__PURE__ */ new Map()
+  );
+  const collectionsStorage = shallowRef(/* @__PURE__ */ new Map());
+  const dirtyStorage = shallowRef(/* @__PURE__ */ new Map());
+  const ruleStatusStorage = shallowRef(/* @__PURE__ */ new Map());
+  function getFieldsEntry($path) {
+    const existingFields = fieldsStorage.value.get($path);
+    if (existingFields) {
+      return existingFields;
+    } else {
+      const $fields = ref5({});
+      fieldsStorage.value.set($path, $fields);
+      return $fields;
     }
-    return null;
-  }).filter((msg) => !!msg);
-}
-function processFieldErrors(fieldStatus) {
-  if (isNestedRulesStatus(fieldStatus)) {
-    return extractNestedErrors(fieldStatus.$fields);
-  } else if (isCollectionRulesStatus(fieldStatus)) {
-    return {
-      $errors: fieldStatus.$error ? extractRulesErrors(fieldStatus.$rules) : [],
-      $each: fieldStatus.$each.map(processFieldErrors)
-    };
-  } else if (isFieldStatus(fieldStatus) && fieldStatus.$error) {
-    return extractRulesErrors(fieldStatus.$rules);
   }
-  return [];
-}
-function extractCollectionError(field) {
-  return field.$each.map(processFieldErrors);
-}
-function extractNestedErrors(fields) {
-  return Object.fromEntries(
-    Object.entries(fields).map(([fieldKey, fieldStatus]) => {
-      if (isNestedRulesStatus(fieldStatus)) {
-        return [fieldKey, extractNestedErrors(fieldStatus.$fields)];
-      } else if (isCollectionRulesStatus(fieldStatus)) {
-        return [
-          fieldKey,
-          {
-            ...fieldStatus.$rules && { $errors: extractRulesErrors(fieldStatus.$rules) },
-            $each: extractCollectionError(fieldStatus)
-          }
-        ];
-      } else if (isFieldStatus(fieldStatus) && fieldStatus.$error) {
-        return [fieldKey, extractRulesErrors(fieldStatus.$rules)];
-      }
-      return [fieldKey, []];
-    })
-  );
-}
-function useErrors($regle) {
-  const errors = computed3(() => {
-    return extractNestedErrors($regle.value.$fields);
-  });
-  return errors;
+  function getCollectionsEntry($path) {
+    const existingEach = collectionsStorage.value.get($path);
+    if (existingEach) {
+      return existingEach;
+    } else {
+      const $each = ref5([]);
+      collectionsStorage.value.set($path, $each);
+      return $each;
+    }
+  }
+  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 (!newRuleElement._params)
+        return true;
+      return newRuleElement._params?.every((paramKey, index) => {
+        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 = ref5(false);
+      const $valid = ref5(true);
+      ruleStatusStorage.value.set(path, { $pending, $valid });
+      return { $pending, $valid };
+    }
+  }
+  return {
+    addRuleDeclEntry,
+    setDirtyEntry,
+    checkRuleDeclEntry,
+    getDirtyState,
+    trySetRuleStatusRef,
+    getFieldsEntry,
+    getCollectionsEntry
+  };
 }
 
 // src/core/useRegle/useStateProperties/useStateProperties.ts
 function useStateProperties(scopeRules, state, customRules) {
-  const $regle = ref3(createReactiveNestedStatus(scopeRules, state, customRules));
+  const storage = useStorage();
+  const $regle = reactive5(
+    createReactiveNestedStatus({
+      rootRules: scopeRules,
+      scopeRules,
+      state,
+      customMessages: customRules(),
+      storage
+    })
+  );
   const errors = useErrors($regle);
   return { $regle, errors };
 }
@@ -474,17 +826,27 @@ function useStateProperties(scopeRules, state, customRules) {
 // src/core/useRegle/useRegle.ts
 function createUseRegleComposable(customRules) {
   function useRegle(state, rulesFactory) {
-    const scopeRules = isRef(rulesFactory) ? rulesFactory : computed4(rulesFactory);
-    const initialState = shallowRef(structuredClone(toRaw(state.value)));
+    const scopeRules = isRef2(rulesFactory) ? rulesFactory : computed5(rulesFactory);
+    const initialState = shallowRef2(structuredClone(toRaw(state.value)));
     const { $regle, errors } = useStateProperties(
       scopeRules,
       state,
       customRules
     );
+    function resetForm() {
+      state.value = toRaw(initialState.value);
+      $regle.$reset();
+    }
+    async function validateForm() {
+      $regle.$touch();
+      return await $regle.$validate();
+    }
     return {
       state,
       $regle,
-      errors
+      errors,
+      resetForm,
+      validateForm
     };
   }
   return useRegle;