@regle/core 0.0.5-beta.0 → 0.0.6

package/dist/index.js

@@ -84,10 +84,118 @@ function createRule(definition) {
 }
 
 // src/core/useRegle/useRegle.ts
-import { computed as computed5, isRef as isRef2, shallowRef as shallowRef2, toRaw } from "vue";
+import { computed as computed7, 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 computed6, reactive as reactive5, unref as unref3 } from "vue";
+
+// src/core/useStorage/useStorage.ts
+import { 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);
+      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
 import { computed } from "vue";
@@ -154,14 +262,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 +284,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 +309,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, []];
     })
@@ -207,21 +328,19 @@ function useErrors($regle) {
 }
 
 // src/core/useRegle/useStateProperties/createReactiveNestedStatus.ts
-import { computed as computed4, effectScope as effectScope4, reactive as reactive4, toRef as toRef4, watch as watch4 } from "vue";
+import { computed as computed5, effectScope as effectScope4, reactive as reactive4, toRef as toRef4, watch as watch4 } from "vue";
 
 // src/core/useRegle/useStateProperties/createReactiveCollectionStatus.ts
-import { reactive as reactive3, ref as ref3, toRef as toRef3, toRefs, watch as watch3 } from "vue";
+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";
@@ -341,6 +460,8 @@ function createReactiveRuleStatus({
       ruleResult = resultOrPromise;
     }
     $valid.value = ruleResult;
+    if (options.$externalErrors) {
+    }
     return ruleResult;
   }
   function $unwatch() {
@@ -365,13 +486,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);
@@ -399,6 +529,9 @@ function createReactiveFieldStatus({
     $watch();
     if (storeResult?.valid != null) {
       $dirty.value = storage.getDirtyState(path);
+      if ($dirty.value) {
+        $commit();
+      }
     }
     storage.addRuleDeclEntry(path, declaredRules);
   }
@@ -414,6 +547,8 @@ function createReactiveFieldStatus({
     if (!unref2(options.lazy)) {
       $commit();
     }
+    $externalErrors.value = [];
+    console.log($externalErrors.value);
   });
   function $unwatch() {
     if ($rules.value) {
@@ -427,6 +562,7 @@ function createReactiveFieldStatus({
     }
     $unwatchState();
     $unwatchValid();
+    $unwatchExternalErrors();
     scope.stop();
     scope = effectScope3();
   }
@@ -477,6 +613,7 @@ function createReactiveFieldStatus({
   });
   function $reset() {
     $dirty.value = false;
+    $externalErrors.value = [];
   }
   function $touch() {
     $dirty.value = true;
@@ -499,6 +636,9 @@ function createReactiveFieldStatus({
       return false;
     }
   }
+  function $clearExternalErrors() {
+    $externalErrors.value = [];
+  }
   return reactive2({
     $dirty,
     $anyDirty,
@@ -506,22 +646,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,
@@ -530,25 +666,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 = toRefs(value);
+  const $externalErrors = toRefs(externalErrors.value ?? reactive3([void 0]));
   const $status = createReactiveChildrenStatus({
     state: $state[index],
     rulesDef: toRef3(() => rules),
     customMessages,
     path: $path,
     storage,
-    options
+    options,
+    externalErrors: $externalErrors?.[index]
   });
   if ($status) {
     $status.$id = value[index].$id ?? $id;
@@ -562,7 +704,8 @@ function createReactiveCollectionStatus({
   customMessages,
   path,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   if (Array.isArray(state.value) && !rulesDef.value.$each) {
     return null;
@@ -574,39 +717,75 @@ 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) => {
-        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 = toRef3(() => {
+            if (externalErrors.value) {
+              if ("$each" in externalErrors.value) {
+                return externalErrors.value.$each;
+              }
+            }
+          });
           const newElement = createCollectionElement({
             value: state.value,
             rules: $each,
@@ -614,19 +793,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;
+      nextTick($watch);
     }
   }
   function $unwatch() {
@@ -643,13 +826,9 @@ function createReactiveCollectionStatus({
     }
   }
   function $watch() {
-    $unwatchState = watch3(
-      state,
-      () => {
-        updateChildrenStatus();
-      },
-      { deep: true, flush: "sync" }
-    );
+    $unwatchState = watch3(() => state.value.length, updateChildrenStatus, {
+      flush: "sync"
+    });
   }
   function $touch() {
     $fieldStatus.value.$touch();
@@ -694,7 +873,8 @@ function createReactiveNestedStatus({
   path = "",
   rootRules,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   let scope = effectScope4();
   let scopeState;
@@ -705,6 +885,7 @@ function createReactiveNestedStatus({
         if (statePropRules) {
           const stateRef = toRef4(state.value, statePropKey);
           const statePropRulesRef = toRef4(() => statePropRules);
+          const $externalErrors = toRef4(() => externalErrors.value?.[statePropKey]);
           return [
             statePropKey,
             createReactiveChildrenStatus({
@@ -713,7 +894,8 @@ function createReactiveNestedStatus({
               customMessages,
               path: path ? `${path}.${statePropKey}` : statePropKey,
               storage,
-              options
+              options,
+              externalErrors: $externalErrors
             })
           ];
         }
@@ -760,28 +942,28 @@ function createReactiveNestedStatus({
       );
     }
     scopeState = scope.run(() => {
-      const $dirty = computed4(() => {
+      const $dirty = computed5(() => {
         return Object.entries($fields.value).every(([key, statusOrField]) => {
           return statusOrField.$dirty;
         });
       });
-      const $anyDirty = computed4(() => {
+      const $anyDirty = computed5(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$dirty;
         });
       });
-      const $invalid = computed4(() => {
+      const $invalid = computed5(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$invalid;
         });
       });
-      const $valid = computed4(() => !$invalid.value);
-      const $error = computed4(() => {
+      const $valid = computed5(() => !$invalid.value);
+      const $error = computed5(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$error;
         });
       });
-      const $pending = computed4(() => {
+      const $pending = computed5(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$pending;
         });
@@ -808,6 +990,11 @@ function createReactiveNestedStatus({
     scope.stop();
     scope = effectScope4();
   }
+  function $clearExternalErrors() {
+    Object.entries($fields.value).forEach(([_, field]) => {
+      field.$clearExternalErrors();
+    });
+  }
   return reactive4({
     ...scopeState,
     $fields,
@@ -816,7 +1003,8 @@ function createReactiveNestedStatus({
     $touch,
     $validate,
     $unwatch,
-    $watch
+    $watch,
+    $clearExternalErrors
   });
 }
 function createReactiveChildrenStatus({
@@ -825,7 +1013,8 @@ function createReactiveChildrenStatus({
   customMessages,
   path,
   storage,
-  options
+  options,
+  externalErrors
 }) {
   if (isCollectionRulesDef(rulesDef)) {
     return createReactiveCollectionStatus({
@@ -834,7 +1023,8 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   } else if (isNestedRulesDef(state, rulesDef) && isRefObject(state)) {
     return createReactiveNestedStatus({
@@ -843,7 +1033,8 @@ function createReactiveChildrenStatus({
       customMessages,
       path,
       storage,
-      options
+      options,
+      externalErrors
     });
   } else if (isValidatorRulesDef(rulesDef)) {
     return createReactiveFieldStatus({
@@ -852,117 +1043,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 setDirtyEntry($path, dirty) {
-    dirtyStorage.value.set($path, dirty);
-  }
-  function getDirtyState(path) {
-    return dirtyStorage.value.get(path) ?? false;
-  }
-  function addRuleDeclEntry($path, options) {
-    ruleDeclStorage.value.set($path, options);
-  }
-  function checkRuleDeclEntry($path, newRules) {
-    const storedRulesDefs = ruleDeclStorage.value.get($path);
-    if (!storedRulesDefs)
-      return void 0;
-    const storedRules = storedRulesDefs;
-    const isValidCache = areRulesChanged(newRules, storedRules);
-    if (!isValidCache)
-      return { valid: false };
-    return { valid: true };
-  }
-  function areRulesChanged(newRules, storedRules) {
-    const storedRulesKeys = Object.keys(storedRules);
-    const newRulesKeys = Object.keys(newRules);
-    if (newRulesKeys.length !== storedRulesKeys.length)
-      return false;
-    const hasAllValidators = newRulesKeys.every((ruleKey) => storedRulesKeys.includes(ruleKey));
-    if (!hasAllValidators)
-      return false;
-    return newRulesKeys.every((ruleKey) => {
-      const newRuleElement = newRules[ruleKey];
-      const storedRuleElement = storedRules[ruleKey];
-      if (!storedRuleElement || !newRuleElement || typeof newRuleElement === "function" || typeof storedRuleElement === "function")
-        return false;
-      if (!newRuleElement._params)
-        return true;
-      return newRuleElement._params?.every((paramKey, index) => {
-        const storedParams = unwrapRuleParameters(storedRuleElement._params);
-        const newParams = unwrapRuleParameters(newRuleElement._params);
-        return storedParams?.[index] === newParams?.[index];
-      });
-    });
-  }
-  function trySetRuleStatusRef(path) {
-    const ruleStatus = ruleStatusStorage.value.get(path);
-    if (ruleStatus) {
-      return ruleStatus;
-    } else {
-      const $pending = ref4(false);
-      const $valid = ref4(true);
-      ruleStatusStorage.value.set(path, { $pending, $valid });
-      return { $pending, $valid };
-    }
-  }
-  return {
-    addRuleDeclEntry,
-    setDirtyEntry,
-    checkRuleDeclEntry,
-    getDirtyState,
-    trySetRuleStatusRef,
-    getFieldsEntry,
-    getCollectionsEntry,
-    getArrayStatus,
-    addArrayStatus
-  };
-}
-
 // src/core/useRegle/useStateProperties/useStateProperties.ts
 function useStateProperties(scopeRules, state, options, customRules) {
   const storage = useStorage();
+  const externalErrors = computed6(() => unref3(options.$externalErrors));
   const $regle = reactive5(
     createReactiveNestedStatus({
       rootRules: scopeRules,
@@ -970,7 +1061,8 @@ function useStateProperties(scopeRules, state, options, customRules) {
       state,
       customMessages: customRules?.(),
       storage,
-      options
+      options,
+      externalErrors
     })
   );
   const errors = useErrors($regle);
@@ -985,15 +1077,16 @@ 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 : computed7(rulesFactory);
     const resolvedOptions = {
       ...globalOptions,
       ...options2
     };
-    const initialState = shallowRef2(structuredClone(toRaw(state.value)));
+    const processedState = ref4(state);
+    const initialState = shallowRef2(structuredClone(toRaw(processedState.value)));
     const { $regle, errors } = useStateProperties(
       scopeRules,
-      state,
+      processedState,
       resolvedOptions,
       customRules
     );
@@ -1001,6 +1094,12 @@ function createUseRegleComposable(customRules, options) {
       state.value = toRaw(initialState.value);
       $regle.$reset();
     }
+    const $valid = computed7(() => {
+      return $regle.$valid && $regle.$dirty && !$regle.$pending;
+    });
+    const $invalid = computed7(() => {
+      return $regle.$invalid && $regle.$dirty || $regle.$pending;
+    });
     async function validateForm() {
       $regle.$touch();
       const result = await $regle.$validate();
@@ -1010,11 +1109,13 @@ function createUseRegleComposable(customRules, options) {
       return false;
     }
     return {
-      state,
+      $state: state,
       $regle,
-      errors,
+      $errors: errors,
       resetForm,
-      validateForm
+      validateForm,
+      $valid,
+      $invalid
     };
   }
   return useRegle2;