@regle/core 0.0.5-beta.0 → 0.0.6

package/dist/index.cjs

@@ -118,8 +118,116 @@ var import_vue10 = require("vue");
 // src/core/useRegle/useStateProperties/useStateProperties.ts
 var import_vue9 = require("vue");
 
+// src/core/useStorage/useStorage.ts
+var import_vue2 = require("vue");
+function useStorage() {
+  const ruleDeclStorage = (0, import_vue2.shallowRef)(/* @__PURE__ */ new Map());
+  const fieldsStorage = (0, import_vue2.shallowRef)(
+    /* @__PURE__ */ new Map()
+  );
+  const collectionsStorage = (0, import_vue2.shallowRef)(/* @__PURE__ */ new Map());
+  const dirtyStorage = (0, import_vue2.shallowRef)(/* @__PURE__ */ new Map());
+  const ruleStatusStorage = (0, import_vue2.shallowRef)(/* @__PURE__ */ new Map());
+  const arrayStatusStorage = (0, import_vue2.shallowRef)(/* @__PURE__ */ new Map());
+  function getFieldsEntry($path) {
+    const existingFields = fieldsStorage.value.get($path);
+    if (existingFields) {
+      return existingFields;
+    } else {
+      const $fields = (0, import_vue2.ref)({});
+      fieldsStorage.value.set($path, $fields);
+      return $fields;
+    }
+  }
+  function getCollectionsEntry($path) {
+    const existingEach = collectionsStorage.value.get($path);
+    if (existingEach) {
+      return existingEach;
+    } else {
+      const $each = (0, import_vue2.ref)([]);
+      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 deleteArrayStatus($id) {
+    if ($id) {
+      arrayStatusStorage.value.delete($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 = (0, import_vue2.ref)(false);
+      const $valid = (0, import_vue2.ref)(true);
+      ruleStatusStorage.value.set(path, { $pending, $valid });
+      return { $pending, $valid };
+    }
+  }
+  return {
+    addRuleDeclEntry,
+    setDirtyEntry,
+    checkRuleDeclEntry,
+    getDirtyState,
+    trySetRuleStatusRef,
+    getFieldsEntry,
+    getCollectionsEntry,
+    getArrayStatus,
+    addArrayStatus,
+    deleteArrayStatus
+  };
+}
+
 // src/core/useRegle/useErrors.ts
-var import_vue3 = require("vue");
+var import_vue4 = require("vue");
 
 // src/utils/object.utils.ts
 function isObject(obj) {
@@ -153,7 +261,7 @@ function isEmpty(value) {
 }
 
 // src/utils/composables.ts
-var import_vue2 = require("vue");
+var import_vue3 = require("vue");
 
 // src/core/useRegle/guards/ruleDef.guards.ts
 function isNestedRulesDef(state, rule) {
@@ -183,14 +291,19 @@ function isFieldStatus(rule) {
   return !!rule && "$rules" in rule;
 }
 
+// src/core/useRegle/guards/rule.errors.guards.ts
+function isExternalErrorCollection(value) {
+  return "$each" in value || "$errors" in value;
+}
+
 // src/core/useRegle/useErrors.ts
-function extractRulesErrors(rules) {
+function extractRulesErrors(rules, externalErrors) {
   return Object.entries(rules).map(([ruleKey, rule]) => {
     if (!rule.$valid) {
       return rule.$message;
     }
     return null;
-  }).filter((msg) => !!msg);
+  }).filter((msg) => !!msg).concat(externalErrors ?? []);
 }
 function processFieldErrors(fieldStatus) {
   if (isNestedRulesStatus(fieldStatus)) {
@@ -200,8 +313,12 @@ function processFieldErrors(fieldStatus) {
       $errors: fieldStatus.$rules ? extractRulesErrors(fieldStatus.$rules) : [],
       $each: fieldStatus.$each.map(processFieldErrors)
     };
-  } else if (isFieldStatus(fieldStatus) && fieldStatus.$error) {
-    return extractRulesErrors(fieldStatus.$rules);
+  } else if (isFieldStatus(fieldStatus)) {
+    if (fieldStatus.$error) {
+      return extractRulesErrors(fieldStatus.$rules, fieldStatus.$externalErrors);
+    } else {
+      return fieldStatus.$externalErrors ?? [];
+    }
   }
   return [];
 }
@@ -221,31 +338,41 @@ function extractNestedErrors(fields) {
             $each: extractCollectionError(fieldStatus)
           }
         ];
-      } else if (isFieldStatus(fieldStatus) && fieldStatus.$error) {
-        return [fieldKey, extractRulesErrors(fieldStatus.$rules)];
+      } else if (isFieldStatus(fieldStatus)) {
+        if (fieldStatus.$error) {
+          return [fieldKey, extractRulesErrors(fieldStatus.$rules, fieldStatus.$externalErrors)];
+        } else {
+          return [fieldKey, fieldStatus.$externalErrors ?? []];
+        }
       }
       return [fieldKey, []];
     })
   );
 }
 function useErrors($regle) {
-  const errors = (0, import_vue3.computed)(() => {
+  const errors = (0, import_vue4.computed)(() => {
     return extractNestedErrors($regle.$fields);
   });
   return errors;
 }
 
 // src/core/useRegle/useStateProperties/createReactiveNestedStatus.ts
-var import_vue7 = require("vue");
+var import_vue8 = require("vue");
 
 // src/core/useRegle/useStateProperties/createReactiveCollectionStatus.ts
-var import_vue6 = require("vue");
+var import_vue7 = require("vue");
+
+// src/utils/randomId.ts
+function randomId() {
+  const uint32 = window.crypto.getRandomValues(new Uint32Array(1))[0];
+  return uint32.toString(8);
+}
 
 // src/core/useRegle/useStateProperties/createReactiveFieldStatus.ts
-var import_vue5 = require("vue");
+var import_vue6 = require("vue");
 
 // src/core/useRegle/useStateProperties/createReactiveRuleStatus.ts
-var import_vue4 = require("vue");
+var import_vue5 = require("vue");
 
 // src/types/rules/rule.internal.types.ts
 var InternalRuleType = /* @__PURE__ */ ((InternalRuleType2) => {
@@ -265,12 +392,12 @@ function createReactiveRuleStatus({
   storage,
   options
 }) {
-  let scope = (0, import_vue4.effectScope)();
+  let scope = (0, import_vue5.effectScope)();
   let scopeState;
   const { $pending, $valid } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
   function $watch() {
     scopeState = scope.run(() => {
-      const $active = (0, import_vue4.computed)(() => {
+      const $active = (0, import_vue5.computed)(() => {
         if (isFormRuleDefinition(rule)) {
           if (typeof rule.value.active === "function") {
             return rule.value.active(state.value, ...$params.value);
@@ -281,7 +408,7 @@ function createReactiveRuleStatus({
           return true;
         }
       });
-      const $message = (0, import_vue4.computed)(() => {
+      const $message = (0, import_vue5.computed)(() => {
         let message = "";
         const customMessageRule = customMessages ? customMessages[ruleKey]?.message : void 0;
         if (customMessageRule) {
@@ -306,27 +433,27 @@ function createReactiveRuleStatus({
         }
         return message;
       });
-      const $type = (0, import_vue4.computed)(() => {
+      const $type = (0, import_vue5.computed)(() => {
         if (isFormRuleDefinition(rule)) {
           return Object.values(InternalRuleType).includes(rule.value.type) ? ruleKey : rule.value.type;
         } else {
           return ruleKey;
         }
       });
-      const $validator = (0, import_vue4.computed)(() => {
+      const $validator = (0, import_vue5.computed)(() => {
         if (isFormRuleDefinition(rule)) {
           return rule.value.validator;
         } else {
           return rule.value;
         }
       });
-      const $params = (0, import_vue4.computed)(() => {
+      const $params = (0, import_vue5.computed)(() => {
         if (typeof rule.value === "function") {
           return [];
         }
         return unwrapRuleParameters(rule.value._params ?? []);
       });
-      const $path = (0, import_vue4.computed)(() => `${path}.${$type.value}`);
+      const $path = (0, import_vue5.computed)(() => `${path}.${$type.value}`);
       return {
         $active,
         $message,
@@ -338,7 +465,7 @@ function createReactiveRuleStatus({
     });
   }
   $watch();
-  const $unwatchState = (0, import_vue4.watch)(scopeState.$params, $validate, {
+  const $unwatchState = (0, import_vue5.watch)(scopeState.$params, $validate, {
     deep: true
   });
   async function $validate() {
@@ -362,14 +489,16 @@ function createReactiveRuleStatus({
       ruleResult = resultOrPromise;
     }
     $valid.value = ruleResult;
+    if (options.$externalErrors) {
+    }
     return ruleResult;
   }
   function $unwatch() {
     $unwatchState();
     scope.stop();
-    scope = (0, import_vue4.effectScope)();
+    scope = (0, import_vue5.effectScope)();
   }
-  return (0, import_vue4.reactive)({
+  return (0, import_vue5.reactive)({
     ...scopeState,
     $pending,
     $valid,
@@ -386,20 +515,29 @@ function createReactiveFieldStatus({
   customMessages,
   path,
   storage,
-  options
+  options,
+  externalErrors
 }) {
-  let scope = (0, import_vue5.effectScope)();
+  let scope = (0, import_vue6.effectScope)();
   let scopeState;
-  const $dirty = (0, import_vue5.ref)(false);
-  const $anyDirty = (0, import_vue5.computed)(() => $dirty.value);
-  const triggerPunishment = (0, import_vue5.ref)(false);
+  const $dirty = (0, import_vue6.ref)(false);
+  const $anyDirty = (0, import_vue6.computed)(() => $dirty.value);
+  const triggerPunishment = (0, import_vue6.ref)(false);
+  const $externalErrors = (0, import_vue6.ref)([]);
+  function collectExternalErrors() {
+    if (externalErrors.value) {
+      $externalErrors.value = externalErrors.value;
+    }
+  }
+  collectExternalErrors();
+  const $unwatchExternalErrors = (0, import_vue6.watch)(externalErrors, collectExternalErrors);
   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 = (0, import_vue5.toRef)(() => rule);
+          const ruleRef = (0, import_vue6.toRef)(() => rule);
           return [
             ruleKey,
             createReactiveRuleStatus({
@@ -420,21 +558,26 @@ function createReactiveFieldStatus({
     $watch();
     if (storeResult?.valid != null) {
       $dirty.value = storage.getDirtyState(path);
+      if ($dirty.value) {
+        $commit();
+      }
     }
     storage.addRuleDeclEntry(path, declaredRules);
   }
-  const $unwatchDirty = (0, import_vue5.watch)($dirty, () => {
+  const $unwatchDirty = (0, import_vue6.watch)($dirty, () => {
     storage.setDirtyEntry(path, $dirty.value);
   });
-  const $unwatchState = (0, import_vue5.watch)(state, () => {
-    if ((0, import_vue5.unref)(options.autoDirty)) {
+  const $unwatchState = (0, import_vue6.watch)(state, () => {
+    if ((0, import_vue6.unref)(options.autoDirty)) {
       if (!$dirty.value) {
         $dirty.value = true;
       }
     }
-    if (!(0, import_vue5.unref)(options.lazy)) {
+    if (!(0, import_vue6.unref)(options.lazy)) {
       $commit();
     }
+    $externalErrors.value = [];
+    console.log($externalErrors.value);
   });
   function $unwatch() {
     if ($rules.value) {
@@ -448,32 +591,33 @@ function createReactiveFieldStatus({
     }
     $unwatchState();
     $unwatchValid();
+    $unwatchExternalErrors();
     scope.stop();
-    scope = (0, import_vue5.effectScope)();
+    scope = (0, import_vue6.effectScope)();
   }
   function $watch() {
     scopeState = scope.run(() => {
-      const $error = (0, import_vue5.computed)(() => {
+      const $error = (0, import_vue6.computed)(() => {
         return $invalid.value && !$pending.value && $dirty.value;
       });
-      const $pending = (0, import_vue5.computed)(() => {
-        if (triggerPunishment.value || !(0, import_vue5.unref)(options.rewardEarly)) {
+      const $pending = (0, import_vue6.computed)(() => {
+        if (triggerPunishment.value || !(0, import_vue6.unref)(options.rewardEarly)) {
           return Object.entries($rules.value).some(([key, ruleResult]) => {
             return ruleResult.$pending;
           });
         }
         return false;
       });
-      const $invalid = (0, import_vue5.computed)(() => {
-        if (triggerPunishment.value || !(0, import_vue5.unref)(options.rewardEarly)) {
+      const $invalid = (0, import_vue6.computed)(() => {
+        if (triggerPunishment.value || !(0, import_vue6.unref)(options.rewardEarly)) {
           return Object.entries($rules.value).some(([key, ruleResult]) => {
             return !ruleResult.$valid;
           });
         }
         return false;
       });
-      const $valid = (0, import_vue5.computed)(() => {
-        if ((0, import_vue5.unref)(options.rewardEarly)) {
+      const $valid = (0, import_vue6.computed)(() => {
+        if ((0, import_vue6.unref)(options.rewardEarly)) {
           return Object.entries($rules.value).every(([key, ruleResult]) => {
             return ruleResult.$valid;
           });
@@ -489,15 +633,16 @@ function createReactiveFieldStatus({
       };
     });
   }
-  const $rules = (0, import_vue5.ref)();
+  const $rules = (0, import_vue6.ref)();
   createReactiveRulesResult();
-  const $unwatchValid = (0, import_vue5.watch)(scopeState.$valid, (valid) => {
-    if ((0, import_vue5.unref)(options.rewardEarly) && valid) {
+  const $unwatchValid = (0, import_vue6.watch)(scopeState.$valid, (valid) => {
+    if ((0, import_vue6.unref)(options.rewardEarly) && valid) {
       triggerPunishment.value = false;
     }
   });
   function $reset() {
     $dirty.value = false;
+    $externalErrors.value = [];
   }
   function $touch() {
     $dirty.value = true;
@@ -520,29 +665,28 @@ function createReactiveFieldStatus({
       return false;
     }
   }
-  return (0, import_vue5.reactive)({
+  function $clearExternalErrors() {
+    $externalErrors.value = [];
+  }
+  return (0, import_vue6.reactive)({
     $dirty,
     $anyDirty,
     $invalid: scopeState.$invalid,
     $error: scopeState.$error,
     $pending: scopeState.$pending,
     $valid: scopeState.$valid,
+    $externalErrors,
     $value: state,
     $rules,
     $reset,
     $touch,
     $validate,
     $unwatch,
-    $watch
+    $watch,
+    $clearExternalErrors
   });
 }
 
-// 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,
@@ -551,25 +695,31 @@ function createCollectionElement({
   storage,
   value,
   customMessages,
-  rules
+  rules,
+  externalErrors
 }) {
-  const $path = `${path}.${index}`;
   const $id = randomId();
+  const $path = `${path}.${$id}`;
   if (!value[index].$id) {
     Object.defineProperties(value[index], {
       $id: {
-        value: $id
+        value: $id,
+        enumerable: false,
+        configurable: false,
+        writable: false
       }
     });
   }
-  const $state = (0, import_vue6.toRefs)(value);
+  const $state = (0, import_vue7.toRefs)(value);
+  const $externalErrors = (0, import_vue7.toRefs)(externalErrors.value ?? (0, import_vue7.reactive)([void 0]));
   const $status = createReactiveChildrenStatus({
     state: $state[index],
-    rulesDef: (0, import_vue6.toRef)(() => rules),
+    rulesDef: (0, import_vue7.toRef)(() => rules),
     customMessages,
     path: $path,
     storage,
-    options
+    options,
+    externalErrors: $externalErrors?.[index]
   });
   if ($status) {
     $status.$id = value[index].$id ?? $id;
@@ -583,51 +733,88 @@ function createReactiveCollectionStatus({
   customMessages,
   path,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   if (Array.isArray(state.value) && !rulesDef.value.$each) {
     return null;
   }
   let $unwatchState = null;
-  const $fieldStatus = (0, import_vue6.ref)({});
+  const $fieldStatus = (0, import_vue7.ref)({});
   const $eachStatus = storage.getCollectionsEntry(path);
   createStatus();
   $watch();
   function createStatus() {
     const { $each, ...otherFields } = rulesDef.value;
+    const $externalErrorsField = (0, import_vue7.toRef)(() => {
+      if (externalErrors.value) {
+        if (isExternalErrorCollection(externalErrors.value)) {
+          return externalErrors.value.$errors;
+        }
+      }
+    });
+    const $externalErrorsEach = (0, import_vue7.toRef)(() => {
+      if (externalErrors.value) {
+        if (isExternalErrorCollection(externalErrors.value)) {
+          return externalErrors.value.$each;
+        }
+      }
+    });
     $fieldStatus.value = createReactiveFieldStatus({
       state,
-      rulesDef: (0, import_vue6.toRef)(() => otherFields),
+      rulesDef: (0, import_vue7.toRef)(() => otherFields),
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors: $externalErrorsField
     });
     if (Array.isArray(state.value) && $each) {
       $eachStatus.value = state.value.map((value, index) => {
-        return createCollectionElement({
-          path,
-          rules: $each,
-          value: state.value,
-          index,
-          options,
-          storage
-        });
+        if (value.$id) {
+          const previousStatus = storage.getArrayStatus(value.$id);
+          if (previousStatus) {
+            return previousStatus;
+          }
+        } else {
+          return createCollectionElement({
+            path,
+            rules: $each,
+            value: state.value,
+            index,
+            options,
+            storage,
+            externalErrors: $externalErrorsEach
+          });
+        }
       }).filter((f) => !!f);
     } else {
       $eachStatus.value = [];
     }
   }
-  function updateChildrenStatus() {
+  async function updateChildrenStatus() {
     const { $each } = rulesDef.value;
     if (Array.isArray(state.value) && $eachStatus.value && $each) {
+      $unwatchState?.();
       state.value.forEach((value, index) => {
         if (value.$id) {
+          if (Array.isArray(state.value) && !state.value.find((val) => val.$id === $eachStatus.value[index].$id)) {
+            $eachStatus.value[index].$unwatch();
+          }
           const previousStatus = storage.getArrayStatus(value.$id);
           if (previousStatus) {
             $eachStatus.value[index] = previousStatus;
+          } else {
+            $eachStatus.value[index].$unwatch();
           }
         } else {
+          const $externalErrorsEach = (0, import_vue7.toRef)(() => {
+            if (externalErrors.value) {
+              if ("$each" in externalErrors.value) {
+                return externalErrors.value.$each;
+              }
+            }
+          });
           const newElement = createCollectionElement({
             value: state.value,
             rules: $each,
@@ -635,19 +822,23 @@ function createReactiveCollectionStatus({
             path,
             storage,
             options,
-            index
+            index,
+            externalErrors: $externalErrorsEach
           });
           if (newElement) {
             $eachStatus.value[index] = newElement;
           }
         }
       });
-    }
-    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());
+      deletedItems.forEach((item) => {
+        storage.deleteArrayStatus(item.$id);
+        item.$unwatch();
+      });
+      $eachStatus.value.length = state.value.length;
+      (0, import_vue7.nextTick)($watch);
     }
   }
   function $unwatch() {
@@ -664,13 +855,9 @@ function createReactiveCollectionStatus({
     }
   }
   function $watch() {
-    $unwatchState = (0, import_vue6.watch)(
-      state,
-      () => {
-        updateChildrenStatus();
-      },
-      { deep: true, flush: "sync" }
-    );
+    $unwatchState = (0, import_vue7.watch)(() => state.value.length, updateChildrenStatus, {
+      flush: "sync"
+    });
   }
   function $touch() {
     $fieldStatus.value.$touch();
@@ -696,7 +883,7 @@ function createReactiveCollectionStatus({
       return false;
     }
   }
-  return (0, import_vue6.reactive)({
+  return (0, import_vue7.reactive)({
     ...$fieldStatus.value,
     $each: $eachStatus,
     $validate,
@@ -715,17 +902,19 @@ function createReactiveNestedStatus({
   path = "",
   rootRules,
   storage,
-  options
+  options,
+  externalErrors
 }) {
-  let scope = (0, import_vue7.effectScope)();
+  let scope = (0, import_vue8.effectScope)();
   let scopeState;
   let $unwatchFields;
   function createReactiveFieldsStatus() {
     $fields.value = Object.fromEntries(
       Object.entries(scopeRules.value).map(([statePropKey, statePropRules]) => {
         if (statePropRules) {
-          const stateRef = (0, import_vue7.toRef)(state.value, statePropKey);
-          const statePropRulesRef = (0, import_vue7.toRef)(() => statePropRules);
+          const stateRef = (0, import_vue8.toRef)(state.value, statePropKey);
+          const statePropRulesRef = (0, import_vue8.toRef)(() => statePropRules);
+          const $externalErrors = (0, import_vue8.toRef)(() => externalErrors.value?.[statePropKey]);
           return [
             statePropKey,
             createReactiveChildrenStatus({
@@ -734,7 +923,8 @@ function createReactiveNestedStatus({
               customMessages,
               path: path ? `${path}.${statePropKey}` : statePropKey,
               storage,
-              options
+              options,
+              externalErrors: $externalErrors
             })
           ];
         }
@@ -771,7 +961,7 @@ function createReactiveNestedStatus({
   }
   function $watch() {
     if (rootRules) {
-      $unwatchFields = (0, import_vue7.watch)(
+      $unwatchFields = (0, import_vue8.watch)(
         rootRules,
         () => {
           $unwatch();
@@ -781,28 +971,28 @@ function createReactiveNestedStatus({
       );
     }
     scopeState = scope.run(() => {
-      const $dirty = (0, import_vue7.computed)(() => {
+      const $dirty = (0, import_vue8.computed)(() => {
         return Object.entries($fields.value).every(([key, statusOrField]) => {
           return statusOrField.$dirty;
         });
       });
-      const $anyDirty = (0, import_vue7.computed)(() => {
+      const $anyDirty = (0, import_vue8.computed)(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$dirty;
         });
       });
-      const $invalid = (0, import_vue7.computed)(() => {
+      const $invalid = (0, import_vue8.computed)(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$invalid;
         });
       });
-      const $valid = (0, import_vue7.computed)(() => !$invalid.value);
-      const $error = (0, import_vue7.computed)(() => {
+      const $valid = (0, import_vue8.computed)(() => !$invalid.value);
+      const $error = (0, import_vue8.computed)(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$error;
         });
       });
-      const $pending = (0, import_vue7.computed)(() => {
+      const $pending = (0, import_vue8.computed)(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$pending;
         });
@@ -827,9 +1017,14 @@ function createReactiveNestedStatus({
       $unwatchFields();
     }
     scope.stop();
-    scope = (0, import_vue7.effectScope)();
+    scope = (0, import_vue8.effectScope)();
   }
-  return (0, import_vue7.reactive)({
+  function $clearExternalErrors() {
+    Object.entries($fields.value).forEach(([_, field]) => {
+      field.$clearExternalErrors();
+    });
+  }
+  return (0, import_vue8.reactive)({
     ...scopeState,
     $fields,
     $value: state,
@@ -837,7 +1032,8 @@ function createReactiveNestedStatus({
     $touch,
     $validate,
     $unwatch,
-    $watch
+    $watch,
+    $clearExternalErrors
   });
 }
 function createReactiveChildrenStatus({
@@ -846,7 +1042,8 @@ function createReactiveChildrenStatus({
   customMessages,
   path,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   if (isCollectionRulesDef(rulesDef)) {
     return createReactiveCollectionStatus({
@@ -855,7 +1052,8 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   } else if (isNestedRulesDef(state, rulesDef) && isRefObject(state)) {
     return createReactiveNestedStatus({
@@ -864,7 +1062,8 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   } else if (isValidatorRulesDef(rulesDef)) {
     return createReactiveFieldStatus({
@@ -873,117 +1072,17 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   }
   return null;
 }
 
-// src/core/useStorage/useStorage.ts
-var import_vue8 = require("vue");
-function useStorage() {
-  const ruleDeclStorage = (0, import_vue8.shallowRef)(/* @__PURE__ */ new Map());
-  const fieldsStorage = (0, import_vue8.shallowRef)(
-    /* @__PURE__ */ new Map()
-  );
-  const collectionsStorage = (0, import_vue8.shallowRef)(/* @__PURE__ */ new Map());
-  const dirtyStorage = (0, import_vue8.shallowRef)(/* @__PURE__ */ new Map());
-  const ruleStatusStorage = (0, import_vue8.shallowRef)(/* @__PURE__ */ new Map());
-  const arrayStatusStorage = (0, import_vue8.shallowRef)(/* @__PURE__ */ new Map());
-  function getFieldsEntry($path) {
-    const existingFields = fieldsStorage.value.get($path);
-    if (existingFields) {
-      return existingFields;
-    } else {
-      const $fields = (0, import_vue8.ref)({});
-      fieldsStorage.value.set($path, $fields);
-      return $fields;
-    }
-  }
-  function getCollectionsEntry($path) {
-    const existingEach = collectionsStorage.value.get($path);
-    if (existingEach) {
-      return existingEach;
-    } else {
-      const $each = (0, import_vue8.ref)([]);
-      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 = (0, import_vue8.ref)(false);
-      const $valid = (0, import_vue8.ref)(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, options, customRules) {
   const storage = useStorage();
+  const externalErrors = (0, import_vue9.computed)(() => (0, import_vue9.unref)(options.$externalErrors));
   const $regle = (0, import_vue9.reactive)(
     createReactiveNestedStatus({
       rootRules: scopeRules,
@@ -991,7 +1090,8 @@ function useStateProperties(scopeRules, state, options, customRules) {
       state,
       customMessages: customRules?.(),
       storage,
-      options
+      options,
+      externalErrors
     })
   );
   const errors = useErrors($regle);
@@ -1011,10 +1111,11 @@ function createUseRegleComposable(customRules, options) {
       ...globalOptions,
       ...options2
     };
-    const initialState = (0, import_vue10.shallowRef)(structuredClone((0, import_vue10.toRaw)(state.value)));
+    const processedState = (0, import_vue10.ref)(state);
+    const initialState = (0, import_vue10.shallowRef)(structuredClone((0, import_vue10.toRaw)(processedState.value)));
     const { $regle, errors } = useStateProperties(
       scopeRules,
-      state,
+      processedState,
       resolvedOptions,
       customRules
     );
@@ -1022,6 +1123,12 @@ function createUseRegleComposable(customRules, options) {
       state.value = (0, import_vue10.toRaw)(initialState.value);
       $regle.$reset();
     }
+    const $valid = (0, import_vue10.computed)(() => {
+      return $regle.$valid && $regle.$dirty && !$regle.$pending;
+    });
+    const $invalid = (0, import_vue10.computed)(() => {
+      return $regle.$invalid && $regle.$dirty || $regle.$pending;
+    });
     async function validateForm() {
       $regle.$touch();
       const result = await $regle.$validate();
@@ -1031,11 +1138,13 @@ function createUseRegleComposable(customRules, options) {
       return false;
     }
     return {
-      state,
+      $state: state,
       $regle,
-      errors,
+      $errors: errors,
       resetForm,
-      validateForm
+      validateForm,
+      $valid,
+      $invalid
     };
   }
   return useRegle2;