@regle/core 0.0.3 → 0.0.5-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,33 +8,35 @@ 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) {
   const { message, validator, active, ...properties } = definition;
+  const isAsync = validator.constructor.name === "AsyncFunction";
   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 +48,8 @@ function defineRuleProcessors(definition, ...params) {
       _active: definition.active,
       _type: definition.type,
       _patched: false,
-      _params: params
+      _async: isAsync,
+      _params: createReactiveParams(params)
     }
   };
   return processors;
@@ -57,6 +60,7 @@ function createRule(definition) {
   if (typeof definition.validator === "function") {
     let fakeParams = [];
     const staticProcessors = defineRuleProcessors(definition, ...fakeParams);
+    const isAsync = definition.validator.constructor.name === "AsyncFunction";
     if (definition.validator.length > 1) {
       const ruleFactory = function(...params) {
         return defineRuleProcessors(definition, ...params);
@@ -70,6 +74,7 @@ function createRule(definition) {
       ruleFactory._active = definition.active;
       ruleFactory._type = definition.type;
       ruleFactory._patched = false;
+      ruleFactory._async = isAsync;
       return ruleFactory;
     } else {
       return staticProcessors;
@@ -79,18 +84,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 +123,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 +142,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 +154,77 @@ 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/createReactiveCollectionStatus.ts
+import { reactive as reactive3, ref as ref3, toRef as toRef3, toRefs, watch as watch3 } from "vue";
+
+// src/core/useRegle/useStateProperties/createReactiveFieldStatus.ts
+import {
+  computed as computed3,
+  effectScope as effectScope3,
+  reactive as reactive2,
+  ref as ref2,
+  toRef as toRef2,
+  unref as unref2,
+  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,343 +239,799 @@ function createReactiveRuleStatus({
   customMessages,
   rule,
   ruleKey,
-  state
+  state,
+  path,
+  storage,
+  options
 }) {
-  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;
+  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 {
+          return true;
+        }
+      });
+      const $message = computed2(() => {
+        let message = "";
+        const customMessageRule = customMessages ? customMessages[ruleKey]?.message : void 0;
+        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);
+            } 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
+      };
+    });
+  }
+  $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;
+        }
       }
+    } else {
+      ruleResult = resultOrPromise;
     }
+    $valid.value = ruleResult;
+    return ruleResult;
+  }
+  function $unwatch() {
+    $unwatchState();
+    scope.stop();
+    scope = effectScope2();
+  }
+  return reactive({
+    ...scopeState,
+    $pending,
+    $valid,
+    $validate,
+    $unwatch,
+    $watch
   });
-  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;
+}
+
+// src/core/useRegle/useStateProperties/createReactiveFieldStatus.ts
+function createReactiveFieldStatus({
+  state,
+  rulesDef,
+  customMessages,
+  path,
+  storage,
+  options
+}) {
+  let scope = effectScope3();
+  let scopeState;
+  const $dirty = ref2(false);
+  const $anyDirty = computed3(() => $dirty.value);
+  const triggerPunishment = ref2(false);
+  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 [
+            ruleKey,
+            createReactiveRuleStatus({
+              $dirty,
+              customMessages,
+              rule: ruleRef,
+              ruleKey,
+              state,
+              path,
+              storage,
+              options
+            })
+          ];
+        }
+        return [];
+      }).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 $unwatchState = watch2(state, () => {
+    if (unref2(options.autoDirty)) {
+      if (!$dirty.value) {
+        $dirty.value = true;
       }
     }
-    if (isFormRuleDefinition(rule)) {
-      if (!(customMessageRule && !rule.value._patched)) {
-        if (typeof rule.value.message === "function") {
-          message = rule.value.message(state.value, ...$params.value);
+    if (!unref2(options.lazy)) {
+      $commit();
+    }
+  });
+  function $unwatch() {
+    if ($rules.value) {
+      Object.entries($rules.value).forEach(([_, rule]) => {
+        rule.$unwatch();
+      });
+    }
+    $unwatchDirty();
+    if ($dirty.value) {
+      storage.setDirtyEntry(path, $dirty.value);
+    }
+    $unwatchState();
+    $unwatchValid();
+    scope.stop();
+    scope = effectScope3();
+  }
+  function $watch() {
+    scopeState = scope.run(() => {
+      const $error = computed3(() => {
+        return $invalid.value && !$pending.value && $dirty.value;
+      });
+      const $pending = computed3(() => {
+        if (triggerPunishment.value || !unref2(options.rewardEarly)) {
+          return Object.entries($rules.value).some(([key, ruleResult]) => {
+            return ruleResult.$pending;
+          });
+        }
+        return false;
+      });
+      const $invalid = computed3(() => {
+        if (triggerPunishment.value || !unref2(options.rewardEarly)) {
+          return Object.entries($rules.value).some(([key, ruleResult]) => {
+            return !ruleResult.$valid;
+          });
+        }
+        return false;
+      });
+      const $valid = computed3(() => {
+        if (unref2(options.rewardEarly)) {
+          return Object.entries($rules.value).every(([key, ruleResult]) => {
+            return ruleResult.$valid;
+          });
         } else {
-          message = rule.value.message;
+          return !$invalid.value;
         }
-      }
-    }
-    if (isEmpty(message)) {
-      message = "Error";
-      console.warn(`No error message defined for ${ruleKey}`);
+      });
+      return {
+        $error,
+        $pending,
+        $invalid,
+        $valid
+      };
+    });
+  }
+  const $rules = ref2();
+  createReactiveRulesResult();
+  const $unwatchValid = watch2(scopeState.$valid, (valid) => {
+    if (unref2(options.rewardEarly) && valid) {
+      triggerPunishment.value = false;
     }
-    return message;
   });
-  const $type = computed(() => {
-    if (isFormInline(rule)) {
-      return ruleKey;
-    } else {
-      return Object.values(InternalRuleType).includes(rule.value.type) ? ruleKey : rule.value.type;
+  function $reset() {
+    $dirty.value = false;
+  }
+  function $touch() {
+    $dirty.value = true;
+  }
+  function $commit() {
+    Object.entries($rules.value).map(([key, rule]) => {
+      return rule.$validate();
+    });
+  }
+  async function $validate() {
+    try {
+      triggerPunishment.value = true;
+      const results = await Promise.all(
+        Object.entries($rules.value).map(([key, rule]) => {
+          return rule.$validate();
+        })
+      );
+      return results.every((value) => !!value);
+    } catch (e) {
+      return false;
     }
+  }
+  return reactive2({
+    $dirty,
+    $anyDirty,
+    $invalid: scopeState.$invalid,
+    $error: scopeState.$error,
+    $pending: scopeState.$pending,
+    $valid: scopeState.$valid,
+    $value: state,
+    $rules,
+    $reset,
+    $touch,
+    $validate,
+    $unwatch,
+    $watch
   });
-  const $validator = computed(
-    () => {
-      if (isFormInline(rule)) {
-        return rule.value;
-      } else {
-        return rule.value.validator;
+}
+
+// src/utils/randomId.ts
+function randomId() {
+  const uint32 = window.crypto.getRandomValues(new Uint32Array(1))[0];
+  return uint32.toString(8);
+}
+
+// src/core/useRegle/useStateProperties/createReactiveCollectionStatus.ts
+function createCollectionElement({
+  path,
+  index,
+  options,
+  storage,
+  value,
+  customMessages,
+  rules
+}) {
+  const $path = `${path}.${index}`;
+  const $id = randomId();
+  if (!value[index].$id) {
+    Object.defineProperties(value[index], {
+      $id: {
+        value: $id
       }
-    }
-  );
-  const $params = computed(() => {
-    if (typeof rule.value === "function") {
-      return [];
-    }
-    return unwrapRuleParameters(rule.value._params ?? []);
+    });
+  }
+  const $state = toRefs(value);
+  const $status = createReactiveChildrenStatus({
+    state: $state[index],
+    rulesDef: toRef3(() => rules),
+    customMessages,
+    path: $path,
+    storage,
+    options
   });
-  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;
+  if ($status) {
+    $status.$id = value[index].$id ?? $id;
+    storage.addArrayStatus($status.$id, $status);
+  }
+  return $status;
+}
+function createReactiveCollectionStatus({
+  state,
+  rulesDef,
+  customMessages,
+  path,
+  storage,
+  options
+}) {
+  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,
+      options
+    });
+    if (Array.isArray(state.value) && $each) {
+      $eachStatus.value = state.value.map((value, index) => {
+        return createCollectionElement({
+          path,
+          rules: $each,
+          value: state.value,
+          index,
+          options,
+          storage
+        });
+      }).filter((f) => !!f);
+    } else {
+      $eachStatus.value = [];
+    }
+  }
+  function updateChildrenStatus() {
+    const { $each } = rulesDef.value;
+    if (Array.isArray(state.value) && $eachStatus.value && $each) {
+      state.value.forEach((value, index) => {
+        if (value.$id) {
+          const previousStatus = storage.getArrayStatus(value.$id);
+          if (previousStatus) {
+            $eachStatus.value[index] = previousStatus;
+          }
+        } else {
+          const newElement = createCollectionElement({
+            value: state.value,
+            rules: $each,
+            customMessages,
+            path,
+            storage,
+            options,
+            index
+          });
+          if (newElement) {
+            $eachStatus.value[index] = newElement;
           }
         }
-      } else {
-        ruleResult = resultOrPromise;
-      }
-      $valid.value = ruleResult;
-    },
-    { immediate: true, deep: true }
-  );
-  return reactive({
-    $message,
-    $active,
-    $pending,
-    $type,
-    $valid,
-    $validator,
-    ...$params.value.length && { $params }
+      });
+    }
+    if ($eachStatus.value) {
+      const deletedItems = $eachStatus.value.filter(($each2) => {
+        return Array.isArray(state.value) && !state.value.find((val) => val.$id === $each2.$id);
+      });
+      deletedItems.forEach((item) => item.$unwatch());
+    }
+  }
+  function $unwatch() {
+    if ($unwatchState) {
+      $unwatchState();
+    }
+    if ($fieldStatus.value) {
+      $fieldStatus.value.$unwatch();
+    }
+    if ($eachStatus.value) {
+      $eachStatus.value.forEach((element) => {
+        element.$unwatch();
+      });
+    }
+  }
+  function $watch() {
+    $unwatchState = watch3(
+      state,
+      () => {
+        updateChildrenStatus();
+      },
+      { deep: true, flush: "sync" }
+    );
+  }
+  function $touch() {
+    $fieldStatus.value.$touch();
+    $eachStatus.value.forEach(($each) => {
+      $each.$touch();
+    });
+  }
+  function $reset() {
+    $fieldStatus.value.$reset();
+    $eachStatus.value.forEach(($each) => {
+      $each.$reset();
+    });
+  }
+  async function $validate() {
+    try {
+      const results = await Promise.all(
+        $eachStatus.value.map((rule) => {
+          return rule.$validate();
+        })
+      );
+      return results.every((value) => !!value);
+    } catch (e) {
+      return false;
+    }
+  }
+  return reactive3({
+    ...$fieldStatus.value,
+    $each: $eachStatus,
+    $validate,
+    $unwatch,
+    $watch,
+    $touch,
+    $reset
   });
 }
 
-// src/core/useRegle/useStateProperties/createReactiveStatus.ts
-function createReactiveNestedStatus(scopeRules, state, customRules) {
-  const $fields = reactive2(
-    Object.fromEntries(
+// src/core/useRegle/useStateProperties/createReactiveNestedStatus.ts
+function createReactiveNestedStatus({
+  scopeRules,
+  state,
+  customMessages,
+  path = "",
+  rootRules,
+  storage,
+  options
+}) {
+  let scope = effectScope4();
+  let scopeState;
+  let $unwatchFields;
+  function createReactiveFieldsStatus() {
+    $fields.value = Object.fromEntries(
       Object.entries(scopeRules.value).map(([statePropKey, statePropRules]) => {
         if (statePropRules) {
-          const stateRef = toRef(state.value, statePropKey);
-          const statePropRulesRef = toRef(() => statePropRules);
+          const stateRef = toRef4(state.value, statePropKey);
+          const statePropRulesRef = toRef4(() => statePropRules);
           return [
             statePropKey,
-            createReactiveFieldStatus(stateRef, statePropRulesRef, customRules)
+            createReactiveChildrenStatus({
+              state: stateRef,
+              rulesDef: statePropRulesRef,
+              customMessages,
+              path: path ? `${path}.${statePropKey}` : statePropKey,
+              storage,
+              options
+            })
           ];
         }
         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;
-    });
-  });
-  const $error = computed2(() => {
-    return Object.entries($fields).some(([key, statusOrField]) => {
-      return statusOrField.$error;
-    });
-  });
-  const $pending = computed2(() => {
-    return Object.entries($fields).some(([key, statusOrField]) => {
-      return statusOrField.$pending;
-    });
-  });
+    );
+    $watch();
+  }
+  const $fields = storage.getFieldsEntry(path);
+  createReactiveFieldsStatus();
   function $reset() {
-    Object.entries($fields).forEach(([key, statusOrField]) => {
+    Object.entries($fields.value).forEach(([_, statusOrField]) => {
       statusOrField.$reset();
     });
   }
   function $touch() {
-    Object.entries($fields).forEach(([key, statusOrField]) => {
+    Object.entries($fields.value).forEach(([_, statusOrField]) => {
       statusOrField.$touch();
     });
   }
-  const $valid = computed2(() => !$invalid.value);
-  return reactive2({
-    $dirty,
-    $anyDirty,
-    $invalid,
-    $valid,
-    $error,
-    $pending,
-    $value: state,
+  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
+      };
+    });
+  }
+  function $unwatch() {
+    if ($fields.value) {
+      Object.entries($fields.value).forEach(([_, field]) => {
+        field.$unwatch();
+      });
+    }
+    if ($unwatchFields) {
+      $unwatchFields();
+    }
+    scope.stop();
+    scope = effectScope4();
+  }
+  return reactive4({
+    ...scopeState,
     $fields,
+    $value: state,
     $reset,
-    $touch
+    $touch,
+    $validate,
+    $unwatch,
+    $watch
   });
 }
-function createReactiveFieldStatus(state, rulesDef, customRules) {
+function createReactiveChildrenStatus({
+  state,
+  rulesDef,
+  customMessages,
+  path,
+  storage,
+  options
+}) {
   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)
-      });
-    }
-    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)
-      )
-    );
-    const $error = computed2(() => {
-      return $invalid.value && !$pending.value && $dirty.value;
-    });
-    const $pending = computed2(() => {
-      return Object.entries($rules).some(([key, rule]) => {
-        return rule.$pending;
-      });
-    });
-    const $invalid = computed2(() => {
-      return Object.entries($rules).some(([key, ruleResult]) => {
-        return !ruleResult.$valid;
-      });
+    return createReactiveCollectionStatus({
+      state,
+      rulesDef,
+      customMessages,
+      path,
+      storage,
+      options
     });
-    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,
+      options
     });
-    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,
+      options
     });
   }
   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 ref4, 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());
+  const arrayStatusStorage = shallowRef(/* @__PURE__ */ new Map());
+  function getFieldsEntry($path) {
+    const existingFields = fieldsStorage.value.get($path);
+    if (existingFields) {
+      return existingFields;
+    } else {
+      const $fields = ref4({});
+      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 = ref4([]);
+      collectionsStorage.value.set($path, $each);
+      return $each;
+    }
+  }
+  function addArrayStatus($id, value) {
+    arrayStatusStorage.value.set($id, value);
+  }
+  function getArrayStatus($id) {
+    return arrayStatusStorage.value.get($id);
+  }
+  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 = ref4(false);
+      const $valid = ref4(true);
+      ruleStatusStorage.value.set(path, { $pending, $valid });
+      return { $pending, $valid };
+    }
+  }
+  return {
+    addRuleDeclEntry,
+    setDirtyEntry,
+    checkRuleDeclEntry,
+    getDirtyState,
+    trySetRuleStatusRef,
+    getFieldsEntry,
+    getCollectionsEntry,
+    getArrayStatus,
+    addArrayStatus
+  };
 }
 
 // src/core/useRegle/useStateProperties/useStateProperties.ts
-function useStateProperties(scopeRules, state, customRules) {
-  const $regle = ref3(createReactiveNestedStatus(scopeRules, state, customRules));
+function useStateProperties(scopeRules, state, options, customRules) {
+  const storage = useStorage();
+  const $regle = reactive5(
+    createReactiveNestedStatus({
+      rootRules: scopeRules,
+      scopeRules,
+      state,
+      customMessages: customRules?.(),
+      storage,
+      options
+    })
+  );
   const errors = useErrors($regle);
   return { $regle, errors };
 }
 
 // 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)));
+function createUseRegleComposable(customRules, options) {
+  const globalOptions = {
+    autoDirty: options?.autoDirty ?? true,
+    lazy: options?.lazy ?? false,
+    rewardEarly: options?.rewardEarly ?? false
+  };
+  function useRegle2(state, rulesFactory, options2) {
+    const scopeRules = isRef2(rulesFactory) ? rulesFactory : computed5(rulesFactory);
+    const resolvedOptions = {
+      ...globalOptions,
+      ...options2
+    };
+    const initialState = shallowRef2(structuredClone(toRaw(state.value)));
     const { $regle, errors } = useStateProperties(
       scopeRules,
       state,
+      resolvedOptions,
       customRules
     );
+    function resetForm() {
+      state.value = toRaw(initialState.value);
+      $regle.$reset();
+    }
+    async function validateForm() {
+      $regle.$touch();
+      const result = await $regle.$validate();
+      if (result) {
+        return state.value;
+      }
+      return false;
+    }
     return {
       state,
       $regle,
-      errors
+      errors,
+      resetForm,
+      validateForm
     };
   }
-  return useRegle;
+  return useRegle2;
 }
+var useRegle = createUseRegleComposable();
 
-// src/core/defineCustomValidators.ts
-function defineCustomValidators(customRules) {
-  const useRegle = createUseRegleComposable(customRules);
-  return {
-    useRegle
-  };
+// src/core/defineRegleOptions.ts
+function defineRegleOptions({
+  rules,
+  options
+}) {
+  const useRegle2 = createUseRegleComposable(rules, options);
+  return useRegle2;
 }
 export {
   InternalRuleType,
   createRule,
-  defineCustomValidators
+  defineRegleOptions,
+  unwrapRuleParameters
 };