@regle/core 0.0.5 → 0.0.7

package/dist/index.js

@@ -18,29 +18,47 @@ function createReactiveParams(params) {
     return 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,
@@ -61,7 +79,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);
       };
@@ -69,9 +87,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;
@@ -82,12 +101,132 @@ function createRule(definition) {
   }
   throw new Error("Validator must be a function");
 }
+function defineType(ruleName) {
+  return ruleName;
+}
 
 // src/core/useRegle/useRegle.ts
-import { computed as computed5, isRef as isRef2, shallowRef as shallowRef2, toRaw as toRaw2 } from "vue";
+import { computed as computed6, isRef as isRef2, ref as ref4, shallowRef as shallowRef2, toRaw } from "vue";
 
 // src/core/useRegle/useStateProperties/useStateProperties.ts
-import { reactive as reactive5 } from "vue";
+import { computed as computed5, reactive as reactive5, unref as unref3 } from "vue";
+
+// src/core/useStorage/useStorage.ts
+import { onScopeDispose, ref, 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 = ref({});
+      fieldsStorage.value.set($path, $fields);
+      return $fields;
+    }
+  }
+  function getCollectionsEntry($path) {
+    const existingEach = collectionsStorage.value.get($path);
+    if (existingEach) {
+      return existingEach;
+    } else {
+      const $each = 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 = ref(false);
+      const $valid = ref(true);
+      const $metadata = ref({});
+      ruleStatusStorage.value.set(path, { $pending, $valid, $metadata });
+      return { $pending, $valid, $metadata };
+    }
+  }
+  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
 import { computed } from "vue";
@@ -124,7 +263,7 @@ function isEmpty(value) {
 }
 
 // src/utils/composables.ts
-import { effectScope, getCurrentScope, onScopeDispose } from "vue";
+import { effectScope, getCurrentScope, onScopeDispose as onScopeDispose2 } from "vue";
 
 // src/core/useRegle/guards/ruleDef.guards.ts
 function isNestedRulesDef(state, rule) {
@@ -154,14 +293,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)) {
@@ -171,8 +315,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 [];
 }
@@ -192,8 +340,12 @@ 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, []];
     })
@@ -212,16 +364,14 @@ import { computed as computed4, effectScope as effectScope4, reactive as reactiv
 // src/core/useRegle/useStateProperties/createReactiveCollectionStatus.ts
 import { nextTick, reactive as reactive3, ref as ref3, toRef as toRef3, toRefs, watch as watch3 } from "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
-import {
-  computed as computed3,
-  effectScope as effectScope3,
-  reactive as reactive2,
-  ref as ref2,
-  toRef as toRef2,
-  unref as unref2,
-  watch as watch2
-} from "vue";
+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 as computed2, effectScope as effectScope2, reactive, watch } from "vue";
@@ -246,13 +396,18 @@ function createReactiveRuleStatus({
 }) {
   let scope = effectScope2();
   let scopeState;
-  const { $pending, $valid } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
+  const { $pending, $valid, $metadata } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
   function $watch() {
     scopeState = scope.run(() => {
+      const $defaultMetadata = computed2(() => ({
+        $invalid: !$valid.value,
+        $params: $params.value,
+        ...$metadata.value
+      }));
       const $active = computed2(() => {
         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;
           }
@@ -265,7 +420,7 @@ function createReactiveRuleStatus({
         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;
           }
@@ -273,7 +428,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;
             }
@@ -286,7 +441,7 @@ function createReactiveRuleStatus({
         return message;
       });
       const $type = computed2(() => {
-        if (isFormRuleDefinition(rule)) {
+        if (isFormRuleDefinition(rule) && rule.value.type) {
           return Object.values(InternalRuleType).includes(rule.value.type) ? ruleKey : rule.value.type;
         } else {
           return ruleKey;
@@ -330,7 +485,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 {
@@ -338,9 +499,19 @@ 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() {
@@ -365,13 +536,22 @@ function createReactiveFieldStatus({
   customMessages,
   path,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   let scope = effectScope3();
   let scopeState;
   const $dirty = ref2(false);
   const $anyDirty = computed3(() => $dirty.value);
   const triggerPunishment = ref2(false);
+  const $externalErrors = ref2([]);
+  function collectExternalErrors() {
+    if (externalErrors.value) {
+      $externalErrors.value = externalErrors.value;
+    }
+  }
+  collectExternalErrors();
+  const $unwatchExternalErrors = watch2(externalErrors, collectExternalErrors);
   function createReactiveRulesResult() {
     const declaredRules = rulesDef.value;
     const storeResult = storage.checkRuleDeclEntry(path, declaredRules);
@@ -417,6 +597,7 @@ function createReactiveFieldStatus({
     if (!unref2(options.lazy)) {
       $commit();
     }
+    $externalErrors.value = [];
   });
   function $unwatch() {
     if ($rules.value) {
@@ -430,6 +611,7 @@ function createReactiveFieldStatus({
     }
     $unwatchState();
     $unwatchValid();
+    $unwatchExternalErrors();
     scope.stop();
     scope = effectScope3();
   }
@@ -480,6 +662,7 @@ function createReactiveFieldStatus({
   });
   function $reset() {
     $dirty.value = false;
+    $externalErrors.value = [];
   }
   function $touch() {
     $dirty.value = true;
@@ -502,6 +685,9 @@ function createReactiveFieldStatus({
       return false;
     }
   }
+  function $clearExternalErrors() {
+    $externalErrors.value = [];
+  }
   return reactive2({
     $dirty,
     $anyDirty,
@@ -509,22 +695,18 @@ function createReactiveFieldStatus({
     $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,
@@ -533,7 +715,8 @@ function createCollectionElement({
   storage,
   value,
   customMessages,
-  rules
+  rules,
+  externalErrors
 }) {
   const $id = randomId();
   const $path = `${path}.${$id}`;
@@ -548,13 +731,15 @@ function createCollectionElement({
     });
   }
   const $state = toRefs(value);
+  const $externalErrors = toRef3(() => externalErrors.value?.[index]);
   const $status = createReactiveChildrenStatus({
     state: $state[index],
     rulesDef: toRef3(() => rules),
     customMessages,
     path: $path,
     storage,
-    options
+    options,
+    externalErrors: $externalErrors
   });
   if ($status) {
     $status.$id = value[index].$id ?? $id;
@@ -568,7 +753,8 @@ function createReactiveCollectionStatus({
   customMessages,
   path,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   if (Array.isArray(state.value) && !rulesDef.value.$each) {
     return null;
@@ -580,13 +766,28 @@ function createReactiveCollectionStatus({
   $watch();
   function createStatus() {
     const { $each, ...otherFields } = rulesDef.value;
+    const $externalErrorsField = toRef3(() => {
+      if (externalErrors.value) {
+        if (isExternalErrorCollection(externalErrors.value)) {
+          return externalErrors.value.$errors;
+        }
+      }
+    });
+    const $externalErrorsEach = toRef3(() => {
+      if (externalErrors.value) {
+        if (isExternalErrorCollection(externalErrors.value)) {
+          return externalErrors.value.$each;
+        }
+      }
+    });
     $fieldStatus.value = createReactiveFieldStatus({
       state,
       rulesDef: toRef3(() => otherFields),
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors: $externalErrorsField
     });
     if (Array.isArray(state.value) && $each) {
       $eachStatus.value = state.value.map((value, index) => {
@@ -602,7 +803,8 @@ function createReactiveCollectionStatus({
             value: state.value,
             index,
             options,
-            storage
+            storage,
+            externalErrors: $externalErrorsEach
           });
         }
       }).filter((f) => !!f);
@@ -626,6 +828,13 @@ function createReactiveCollectionStatus({
             $eachStatus.value[index].$unwatch();
           }
         } else {
+          const $externalErrorsEach = toRef3(() => {
+            if (externalErrors.value) {
+              if ("$each" in externalErrors.value) {
+                return externalErrors.value.$each;
+              }
+            }
+          });
           const newElement = createCollectionElement({
             value: state.value,
             rules: $each,
@@ -633,7 +842,8 @@ function createReactiveCollectionStatus({
             path,
             storage,
             options,
-            index
+            index,
+            externalErrors: $externalErrorsEach
           });
           if (newElement) {
             $eachStatus.value[index] = newElement;
@@ -712,7 +922,8 @@ function createReactiveNestedStatus({
   path = "",
   rootRules,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   let scope = effectScope4();
   let scopeState;
@@ -723,6 +934,7 @@ function createReactiveNestedStatus({
         if (statePropRules) {
           const stateRef = toRef4(state.value, statePropKey);
           const statePropRulesRef = toRef4(() => statePropRules);
+          const $externalErrors = toRef4(() => externalErrors.value?.[statePropKey]);
           return [
             statePropKey,
             createReactiveChildrenStatus({
@@ -731,7 +943,8 @@ function createReactiveNestedStatus({
               customMessages,
               path: path ? `${path}.${statePropKey}` : statePropKey,
               storage,
-              options
+              options,
+              externalErrors: $externalErrors
             })
           ];
         }
@@ -826,6 +1039,11 @@ function createReactiveNestedStatus({
     scope.stop();
     scope = effectScope4();
   }
+  function $clearExternalErrors() {
+    Object.entries($fields.value).forEach(([_, field]) => {
+      field.$clearExternalErrors();
+    });
+  }
   return reactive4({
     ...scopeState,
     $fields,
@@ -834,7 +1052,8 @@ function createReactiveNestedStatus({
     $touch,
     $validate,
     $unwatch,
-    $watch
+    $watch,
+    $clearExternalErrors
   });
 }
 function createReactiveChildrenStatus({
@@ -843,7 +1062,8 @@ function createReactiveChildrenStatus({
   customMessages,
   path,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   if (isCollectionRulesDef(rulesDef)) {
     return createReactiveCollectionStatus({
@@ -852,7 +1072,8 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   } else if (isNestedRulesDef(state, rulesDef) && isRefObject(state)) {
     return createReactiveNestedStatus({
@@ -861,7 +1082,8 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   } else if (isValidatorRulesDef(rulesDef)) {
     return createReactiveFieldStatus({
@@ -870,123 +1092,17 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   }
   return null;
 }
 
-// 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;
-    }
-  }
-  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 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 = 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,
-    deleteArrayStatus
-  };
-}
-
 // src/core/useRegle/useStateProperties/useStateProperties.ts
 function useStateProperties(scopeRules, state, options, customRules) {
   const storage = useStorage();
+  const externalErrors = computed5(() => unref3(options.$externalErrors));
   const $regle = reactive5(
     createReactiveNestedStatus({
       rootRules: scopeRules,
@@ -994,7 +1110,8 @@ function useStateProperties(scopeRules, state, options, customRules) {
       state,
       customMessages: customRules?.(),
       storage,
-      options
+      options,
+      externalErrors
     })
   );
   const errors = useErrors($regle);
@@ -1009,22 +1126,29 @@ function createUseRegleComposable(customRules, options) {
     rewardEarly: options?.rewardEarly ?? false
   };
   function useRegle2(state, rulesFactory, options2) {
-    const scopeRules = isRef2(rulesFactory) ? rulesFactory : computed5(rulesFactory);
+    const scopeRules = isRef2(rulesFactory) ? rulesFactory : computed6(rulesFactory);
     const resolvedOptions = {
       ...globalOptions,
       ...options2
     };
-    const initialState = shallowRef2(structuredClone(toRaw2(state.value)));
+    const processedState = ref4(state);
+    const initialState = shallowRef2(structuredClone(toRaw(processedState.value)));
     const { $regle, errors } = useStateProperties(
       scopeRules,
-      state,
+      processedState,
       resolvedOptions,
       customRules
     );
     function resetForm() {
-      state.value = toRaw2(initialState.value);
+      state.value = toRaw(initialState.value);
       $regle.$reset();
     }
+    const $valid = computed6(() => {
+      return $regle.$valid && $regle.$dirty && !$regle.$pending;
+    });
+    const $invalid = computed6(() => {
+      return $regle.$invalid && $regle.$dirty || $regle.$pending;
+    });
     async function validateForm() {
       $regle.$touch();
       const result = await $regle.$validate();
@@ -1034,19 +1158,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
 }) {
@@ -1056,6 +1182,8 @@ function defineRegleOptions({
 export {
   InternalRuleType,
   createRule,
-  defineRegleOptions,
-  unwrapRuleParameters
+  defineRegleConfig,
+  defineType,
+  unwrapRuleParameters,
+  useRegle
 };