@regle/core 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -22,8 +22,10 @@ var src_exports = {};
 __export(src_exports, {
   InternalRuleType: () => InternalRuleType,
   createRule: () => createRule,
-  defineRegleOptions: () => defineRegleOptions,
-  unwrapRuleParameters: () => unwrapRuleParameters
+  defineRegleConfig: () => defineRegleConfig,
+  defineType: () => defineType,
+  unwrapRuleParameters: () => unwrapRuleParameters,
+  useRegle: () => useRegle
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -47,29 +49,47 @@ function createReactiveParams(params) {
     return (0, import_vue.toRef)(() => param);
   });
 }
+function getFunctionParametersLength(func) {
+  const funcStr = func.toString();
+  const params = funcStr.slice(funcStr.indexOf("(") + 1, funcStr.indexOf(")")).split(",").map((param) => param.trim());
+  const defaults = params.filter((param) => param.includes("="));
+  return defaults.length + func.length;
+}
 
 // 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) {
+  const defaultProcessors = {
+    validator(value, ...args) {
+      return definition.validator(value, ...unwrapRuleParameters(args.length ? args : params));
+    },
+    message(value, metadata) {
       if (typeof definition.message === "function") {
-        return definition.message(value, ...args.length ? args : params);
+        return definition.message(value, {
+          ...metadata,
+          $params: unwrapRuleParameters(metadata.$params?.length ? metadata.$params : params)
+        });
       } else {
         return definition.message;
       }
     },
-    validator(value, ...args) {
-      return definition.validator(value, ...args.length ? args : params);
-    },
-    active(value, ...args) {
+    active(value, metadata) {
       if (typeof definition.active === "function") {
-        return definition.active(value, ...args.length ? args : params);
+        return definition.active(value, {
+          ...metadata,
+          $params: unwrapRuleParameters(metadata.$params?.length ? metadata.$params : params)
+        });
       } else {
         return definition.active ?? true;
       }
     },
+    exec(value) {
+      return definition.validator(value, ...unwrapRuleParameters(params));
+    }
+  };
+  const processors = {
+    ...defaultProcessors,
     ...properties,
     ...{
       _validator: definition.validator,
@@ -90,7 +110,7 @@ function createRule(definition) {
     let fakeParams = [];
     const staticProcessors = defineRuleProcessors(definition, ...fakeParams);
     const isAsync = definition.validator.constructor.name === "AsyncFunction";
-    if (definition.validator.length > 1) {
+    if (getFunctionParametersLength(definition.validator) > 1) {
       const ruleFactory = function(...params) {
         return defineRuleProcessors(definition, ...params);
       };
@@ -98,9 +118,10 @@ function createRule(definition) {
       ruleFactory.message = staticProcessors.message;
       ruleFactory.active = staticProcessors.active;
       ruleFactory.type = staticProcessors.type;
-      ruleFactory._validator = definition.validator;
-      ruleFactory._message = definition.message;
-      ruleFactory._active = definition.active;
+      ruleFactory.exec = staticProcessors.exec;
+      ruleFactory._validator = staticProcessors.validator;
+      ruleFactory._message = staticProcessors.message;
+      ruleFactory._active = staticProcessors.active;
       ruleFactory._type = definition.type;
       ruleFactory._patched = false;
       ruleFactory._async = isAsync;
@@ -111,6 +132,9 @@ function createRule(definition) {
   }
   throw new Error("Validator must be a function");
 }
+function defineType(ruleName) {
+  return ruleName;
+}
 
 // src/core/useRegle/useRegle.ts
 var import_vue10 = require("vue");
@@ -118,8 +142,125 @@ 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);
+      const $metadata = (0, import_vue2.ref)({});
+      ruleStatusStorage.value.set(path, { $pending, $valid, $metadata });
+      return { $pending, $valid, $metadata };
+    }
+  }
+  (0, import_vue2.onScopeDispose)(() => {
+    ruleDeclStorage.value.clear();
+    fieldsStorage.value.clear();
+    collectionsStorage.value.clear();
+    dirtyStorage.value.clear();
+    ruleStatusStorage.value.clear();
+    arrayStatusStorage.value.clear();
+  });
+  return {
+    addRuleDeclEntry,
+    setDirtyEntry,
+    checkRuleDeclEntry,
+    getDirtyState,
+    trySetRuleStatusRef,
+    getFieldsEntry,
+    getCollectionsEntry,
+    getArrayStatus,
+    addArrayStatus,
+    deleteArrayStatus
+  };
+}
+
 // 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 +294,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 +324,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 +346,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 +371,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,15 +425,20 @@ 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}`);
+  const { $pending, $valid, $metadata } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
   function $watch() {
     scopeState = scope.run(() => {
-      const $active = (0, import_vue4.computed)(() => {
+      const $defaultMetadata = (0, import_vue5.computed)(() => ({
+        $invalid: !$valid.value,
+        $params: $params.value,
+        ...$metadata.value
+      }));
+      const $active = (0, import_vue5.computed)(() => {
         if (isFormRuleDefinition(rule)) {
           if (typeof rule.value.active === "function") {
-            return rule.value.active(state.value, ...$params.value);
+            return rule.value.active(state.value, $defaultMetadata.value);
           } else {
             return rule.value.active;
           }
@@ -281,12 +446,12 @@ 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) {
           if (typeof customMessageRule === "function") {
-            message = customMessageRule(state.value, ...$params.value);
+            message = customMessageRule(state.value, $defaultMetadata.value);
           } else {
             message = customMessageRule;
           }
@@ -294,7 +459,7 @@ function createReactiveRuleStatus({
         if (isFormRuleDefinition(rule)) {
           if (!(customMessageRule && !rule.value._patched)) {
             if (typeof rule.value.message === "function") {
-              message = rule.value.message(state.value, ...$params.value);
+              message = rule.value.message(state.value, $defaultMetadata.value);
             } else {
               message = rule.value.message;
             }
@@ -306,27 +471,27 @@ function createReactiveRuleStatus({
         }
         return message;
       });
-      const $type = (0, import_vue4.computed)(() => {
-        if (isFormRuleDefinition(rule)) {
+      const $type = (0, import_vue5.computed)(() => {
+        if (isFormRuleDefinition(rule) && rule.value.type) {
           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 +503,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() {
@@ -351,7 +516,13 @@ function createReactiveRuleStatus({
           $valid.value = true;
           $pending.value = true;
           const promiseResult = await resultOrPromise;
-          ruleResult = promiseResult;
+          if (typeof promiseResult === "boolean") {
+            ruleResult = promiseResult;
+          } else {
+            const { $valid: $valid2, ...rest } = promiseResult;
+            ruleResult = $valid2;
+            $metadata.value = rest;
+          }
         } catch (e) {
           ruleResult = false;
         } finally {
@@ -359,17 +530,27 @@ function createReactiveRuleStatus({
         }
       }
     } else {
-      ruleResult = resultOrPromise;
+      if (resultOrPromise != null) {
+        if (typeof resultOrPromise === "boolean") {
+          ruleResult = resultOrPromise;
+        } else {
+          const { $valid: $valid2, ...rest } = resultOrPromise;
+          ruleResult = $valid2;
+          $metadata.value = rest;
+        }
+      }
     }
     $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 +567,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({
@@ -426,18 +616,19 @@ function createReactiveFieldStatus({
     }
     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 = [];
   });
   function $unwatch() {
     if ($rules.value) {
@@ -451,32 +642,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;
           });
@@ -492,15 +684,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;
@@ -523,29 +716,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,
@@ -554,7 +746,8 @@ function createCollectionElement({
   storage,
   value,
   customMessages,
-  rules
+  rules,
+  externalErrors
 }) {
   const $id = randomId();
   const $path = `${path}.${$id}`;
@@ -568,14 +761,16 @@ function createCollectionElement({
       }
     });
   }
-  const $state = (0, import_vue6.toRefs)(value);
+  const $state = (0, import_vue7.toRefs)(value);
+  const $externalErrors = (0, import_vue7.toRef)(() => externalErrors.value?.[index]);
   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
   });
   if ($status) {
     $status.$id = value[index].$id ?? $id;
@@ -589,25 +784,41 @@ 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) => {
@@ -623,7 +834,8 @@ function createReactiveCollectionStatus({
             value: state.value,
             index,
             options,
-            storage
+            storage,
+            externalErrors: $externalErrorsEach
           });
         }
       }).filter((f) => !!f);
@@ -647,6 +859,13 @@ function createReactiveCollectionStatus({
             $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,
@@ -654,7 +873,8 @@ function createReactiveCollectionStatus({
             path,
             storage,
             options,
-            index
+            index,
+            externalErrors: $externalErrorsEach
           });
           if (newElement) {
             $eachStatus.value[index] = newElement;
@@ -669,7 +889,7 @@ function createReactiveCollectionStatus({
         item.$unwatch();
       });
       $eachStatus.value.length = state.value.length;
-      (0, import_vue6.nextTick)($watch);
+      (0, import_vue7.nextTick)($watch);
     }
   }
   function $unwatch() {
@@ -686,7 +906,7 @@ function createReactiveCollectionStatus({
     }
   }
   function $watch() {
-    $unwatchState = (0, import_vue6.watch)(() => state.value.length, updateChildrenStatus, {
+    $unwatchState = (0, import_vue7.watch)(() => state.value.length, updateChildrenStatus, {
       flush: "sync"
     });
   }
@@ -714,7 +934,7 @@ function createReactiveCollectionStatus({
       return false;
     }
   }
-  return (0, import_vue6.reactive)({
+  return (0, import_vue7.reactive)({
     ...$fieldStatus.value,
     $each: $eachStatus,
     $validate,
@@ -733,17 +953,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({
@@ -752,7 +974,8 @@ function createReactiveNestedStatus({
               customMessages,
               path: path ? `${path}.${statePropKey}` : statePropKey,
               storage,
-              options
+              options,
+              externalErrors: $externalErrors
             })
           ];
         }
@@ -789,7 +1012,7 @@ function createReactiveNestedStatus({
   }
   function $watch() {
     if (rootRules) {
-      $unwatchFields = (0, import_vue7.watch)(
+      $unwatchFields = (0, import_vue8.watch)(
         rootRules,
         () => {
           $unwatch();
@@ -799,28 +1022,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;
         });
@@ -845,9 +1068,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,
@@ -855,7 +1083,8 @@ function createReactiveNestedStatus({
     $touch,
     $validate,
     $unwatch,
-    $watch
+    $watch,
+    $clearExternalErrors
   });
 }
 function createReactiveChildrenStatus({
@@ -864,7 +1093,8 @@ function createReactiveChildrenStatus({
   customMessages,
   path,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   if (isCollectionRulesDef(rulesDef)) {
     return createReactiveCollectionStatus({
@@ -873,7 +1103,8 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   } else if (isNestedRulesDef(state, rulesDef) && isRefObject(state)) {
     return createReactiveNestedStatus({
@@ -882,7 +1113,8 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   } else if (isValidatorRulesDef(rulesDef)) {
     return createReactiveFieldStatus({
@@ -891,123 +1123,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 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_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,
-    deleteArrayStatus
-  };
-}
-
 // 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,
@@ -1015,7 +1141,8 @@ function useStateProperties(scopeRules, state, options, customRules) {
       state,
       customMessages: customRules?.(),
       storage,
-      options
+      options,
+      externalErrors
     })
   );
   const errors = useErrors($regle);
@@ -1035,10 +1162,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
     );
@@ -1046,6 +1174,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();
@@ -1055,19 +1189,21 @@ function createUseRegleComposable(customRules, options) {
       return false;
     }
     return {
-      state,
+      $state: state,
       $regle,
-      errors,
+      $errors: errors,
       resetForm,
-      validateForm
+      validateForm,
+      $valid,
+      $invalid
     };
   }
   return useRegle2;
 }
 var useRegle = createUseRegleComposable();
 
-// src/core/defineRegleOptions.ts
-function defineRegleOptions({
+// src/core/defineRegleConfig.ts
+function defineRegleConfig({
   rules,
   options
 }) {
@@ -1078,6 +1214,8 @@ function defineRegleOptions({
 0 && (module.exports = {
   InternalRuleType,
   createRule,
-  defineRegleOptions,
-  unwrapRuleParameters
+  defineRegleConfig,
+  defineType,
+  unwrapRuleParameters,
+  useRegle
 });