@regle/core 0.6.1-beta.1 → 0.7.0

package/dist/regle-core.cjs

@@ -4,7 +4,7 @@ var vue = require('vue');
 
 // ../shared/utils/isEmpty.ts
 function isEmpty(value) {
-  if (value === void 0 || value === null) {
+  if (value === undefined || value === null) {
     return true;
   }
   if (value instanceof Date) {
@@ -310,7 +310,7 @@ function useStorage() {
   }
   function checkRuleDeclEntry($path, newRules) {
     const storedRulesDefs = ruleDeclStorage.value.get($path);
-    if (!storedRulesDefs) return void 0;
+    if (!storedRulesDefs) return undefined;
     const storedRules = storedRulesDefs;
     const isValidCache = areRulesChanged(newRules, storedRules);
     if (!isValidCache) return { valid: false };
@@ -405,7 +405,7 @@ function debounce(func, wait, immediate) {
   const debouncedFn = (...args) => new Promise((resolve) => {
     clearTimeout(timeout);
     timeout = setTimeout(() => {
-      timeout = void 0;
+      timeout = undefined;
       {
         Promise.resolve(func.apply(this, [...args])).then(resolve);
       }
@@ -413,7 +413,7 @@ function debounce(func, wait, immediate) {
   });
   debouncedFn.cancel = () => {
     clearTimeout(timeout);
-    timeout = void 0;
+    timeout = undefined;
   };
   return debouncedFn;
 }
@@ -475,10 +475,10 @@ function extractRulesErrors({
   field,
   silent = false
 }) {
-  return Object.entries(field.$rules ?? {}).map(([ruleKey, rule]) => {
+  return Object.entries(field.$rules ?? {}).map(([_, rule]) => {
     if (silent) {
       return rule.$message;
-    } else if (!rule.$valid && field.$dirty && !rule.$validating) {
+    } else if (!rule.$valid && field.$error && !rule.$validating) {
       return rule.$message;
     }
     return null;
@@ -488,10 +488,10 @@ function extractRulesErrors({
     } else {
       return acc?.concat(value);
     }
-  }, []).concat(field.$dirty ? field.$externalErrors ?? [] : []);
+  }, []).concat(field.$error ? field.$externalErrors ?? [] : []).concat(field.$error ? field.$schemaErrors ?? [] : []);
 }
 function extractRulesTooltips({ field }) {
-  return Object.entries(field.$rules ?? {}).map(([ruleKey, rule]) => rule.$tooltip).filter((tooltip) => !!tooltip).reduce((acc, value) => {
+  return Object.entries(field.$rules ?? {}).map(([_, rule]) => rule.$tooltip).filter((tooltip) => !!tooltip).reduce((acc, value) => {
     if (typeof value === "string") {
       return acc?.concat([value]);
     } else {
@@ -546,7 +546,7 @@ function createReactiveRuleStatus({
       });
       function computeRuleProcessor(key) {
         let result = "";
-        const customProcessor = customMessages ? customMessages[ruleKey]?.[key] : void 0;
+        const customProcessor = customMessages ? customMessages[ruleKey]?.[key] : undefined;
         if (customProcessor) {
           if (typeof customProcessor === "function") {
             result = customProcessor($defaultMetadata.value);
@@ -720,6 +720,8 @@ function createReactiveFieldStatus({
   storage,
   options,
   externalErrors,
+  schemaErrors,
+  schemaMode,
   onUnwatch,
   $isArray,
   initialState,
@@ -812,7 +814,7 @@ function createReactiveFieldStatus({
     }
     scopeState = scope.run(() => {
       const $dirty = vue.ref(false);
-      const triggerPunishment = vue.ref(false);
+      const triggerPunishment2 = vue.ref(false);
       const $anyDirty = vue.computed(() => $dirty.value);
       const $debounce2 = vue.computed(() => {
         return $localOptions.value.$debounce;
@@ -868,16 +870,25 @@ function createReactiveFieldStatus({
         return $invalid.value && !$pending.value && $dirty.value;
       });
       const $errors = vue.computed(() => {
-        if ($error.value) {
-          return extractRulesErrors({
-            field: {
-              $dirty: $dirty.value,
-              $externalErrors: externalErrors?.value,
-              $rules: $rules.value
-            }
-          });
-        }
-        return [];
+        return extractRulesErrors({
+          field: {
+            $error: $error.value,
+            $externalErrors: externalErrors?.value,
+            $schemaErrors: schemaErrors?.value,
+            $rules: $rules.value
+          }
+        });
+      });
+      const $silentErrors = vue.computed(() => {
+        return extractRulesErrors({
+          field: {
+            $error: true,
+            $externalErrors: externalErrors?.value,
+            $schemaErrors: schemaErrors?.value,
+            $rules: $rules.value
+          },
+          silent: true
+        });
       });
       const $edited = vue.computed(() => {
         if ($dirty.value) {
@@ -902,16 +913,6 @@ function createReactiveFieldStatus({
           }
         });
       });
-      const $silentErrors = vue.computed(() => {
-        return extractRulesErrors({
-          field: {
-            $dirty: $dirty.value,
-            $externalErrors: externalErrors?.value,
-            $rules: $rules.value
-          },
-          silent: true
-        });
-      });
       const $ready = vue.computed(() => {
         if (!$autoDirty2.value) {
           return !($invalid.value || $pending.value);
@@ -919,7 +920,7 @@ function createReactiveFieldStatus({
         return $anyDirty.value && !($invalid.value || $pending.value);
       });
       const $pending = vue.computed(() => {
-        if (triggerPunishment.value || !$rewardEarly2.value) {
+        if (triggerPunishment2.value || !$rewardEarly2.value) {
           return Object.entries($rules.value).some(([key, ruleResult]) => {
             return ruleResult.$pending;
           });
@@ -927,11 +928,11 @@ function createReactiveFieldStatus({
         return false;
       });
       const $invalid = vue.computed(() => {
-        if (externalErrors?.value?.length) {
+        if (externalErrors?.value?.length || schemaErrors?.value?.length) {
           return true;
-        } else if (isEmpty($rules.value)) {
+        } else if ($inactive.value) {
           return false;
-        } else if (!$rewardEarly2.value || $rewardEarly2.value && triggerPunishment.value) {
+        } else if (!$rewardEarly2.value || $rewardEarly2.value && triggerPunishment2.value) {
           return Object.entries($rules.value).some(([_, ruleResult]) => {
             return !ruleResult.$valid;
           });
@@ -940,7 +941,7 @@ function createReactiveFieldStatus({
       });
       const $name = vue.computed(() => fieldName);
       const $inactive = vue.computed(() => {
-        if (isEmpty($rules.value)) {
+        if (isEmpty($rules.value) && !schemaMode) {
           return true;
         }
         return false;
@@ -951,9 +952,13 @@ function createReactiveFieldStatus({
         } else if ($inactive.value) {
           return false;
         } else if ($dirty.value && !isEmpty(state.value) && !$validating2.value) {
-          return Object.values($rules.value).every((ruleResult) => {
-            return ruleResult.$valid && ruleResult.$active;
-          });
+          if (schemaMode) {
+            return !schemaErrors?.value?.length;
+          } else {
+            return Object.values($rules.value).every((ruleResult) => {
+              return ruleResult.$valid && ruleResult.$active;
+            });
+          }
         }
         return false;
       });
@@ -1001,7 +1006,7 @@ function createReactiveFieldStatus({
       const $shortcuts2 = {};
       vue.watch($invalid, (value) => {
         if (!value) {
-          triggerPunishment.value = false;
+          triggerPunishment2.value = false;
         }
       });
       return {
@@ -1026,7 +1031,7 @@ function createReactiveFieldStatus({
         $validating: $validating2,
         $tooltips,
         $dirty,
-        triggerPunishment,
+        triggerPunishment: triggerPunishment2,
         processShortcuts,
         $silentValue,
         $inactive
@@ -1109,7 +1114,9 @@ function createReactiveFieldStatus({
       } else if (scopeState.$autoDirty.value && scopeState.$dirty.value && !scopeState.$pending.value) {
         return { result: !scopeState.$error.value, data };
       }
-      if (isEmpty($rules.value)) {
+      if (schemaMode) {
+        return { result: !schemaErrors?.value?.length, data };
+      } else if (isEmpty($rules.value)) {
         return { result: true, data };
       }
       const results = await Promise.allSettled(
@@ -1160,6 +1167,7 @@ function createReactiveFieldStatus({
     $haveAnyAsyncRule,
     $debounce,
     $lazy,
+    triggerPunishment,
     ...restScope
   } = scopeState;
   return vue.reactive({
@@ -1188,9 +1196,11 @@ function createCollectionElement({
   customMessages,
   rules,
   externalErrors,
+  schemaErrors,
   initialState,
   shortcuts,
-  fieldName
+  fieldName,
+  schemaMode
 }) {
   const $fieldId = rules.$key ? rules.$key : randomId();
   let $path = `${path}.${String($fieldId)}`;
@@ -1208,6 +1218,8 @@ function createCollectionElement({
       $path = `${path}.${stateValue.value.$id}`;
     }
   }
+  const $externalErrors = vue.toRef(externalErrors?.value ?? [], index);
+  const $schemaErrors = vue.computed(() => schemaErrors?.value?.[index]);
   const $status = createReactiveChildrenStatus({
     state: stateValue,
     rulesDef: vue.toRef(() => rules),
@@ -1215,10 +1227,12 @@ function createCollectionElement({
     path: $path,
     storage,
     options,
-    externalErrors: vue.toRef(externalErrors?.value ?? [], index),
+    externalErrors: $externalErrors,
+    schemaErrors: $schemaErrors,
     initialState,
     shortcuts,
-    fieldName
+    fieldName,
+    schemaMode
   });
   if ($status) {
     const valueId = stateValue.value?.$id;
@@ -1237,6 +1251,8 @@ function createReactiveCollectionStatus({
   storage,
   options,
   externalErrors,
+  schemaErrors,
+  schemaMode,
   initialState,
   shortcuts,
   fieldName
@@ -1247,7 +1263,7 @@ function createReactiveCollectionStatus({
   let immediateScopeState;
   let collectionScopes = [];
   if (!Array.isArray(state.value) && !rulesDef.value.$each) {
-    return void 0;
+    return undefined;
   }
   const $id = vue.ref();
   const $value = vue.ref(state.value);
@@ -1300,6 +1316,8 @@ function createReactiveCollectionStatus({
           collectionScopes.push(scope2);
         }
         const initialStateRef = vue.toRef(initialState.value ?? [], index);
+        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, `$each`);
+        const $schemaErrors = vue.computed(() => schemaErrors?.value?.$each);
         const element = createCollectionElement({
           $id: $id.value,
           path,
@@ -1309,10 +1327,12 @@ function createReactiveCollectionStatus({
           index,
           options,
           storage,
-          externalErrors: vue.toRef(externalErrors?.value ?? {}, `$each`),
+          externalErrors: $externalErrors,
+          schemaErrors: $schemaErrors,
           initialState: initialStateRef,
           shortcuts,
-          fieldName
+          fieldName,
+          schemaMode
         });
         if (element) {
           return element;
@@ -1330,10 +1350,12 @@ function createReactiveCollectionStatus({
       storage,
       options,
       externalErrors: vue.toRef(externalErrors?.value ?? {}, `$self`),
+      schemaErrors: vue.computed(() => schemaErrors?.value?.$self),
       $isArray: true,
       initialState,
       shortcuts,
-      fieldName
+      fieldName,
+      schemaMode
     });
   }
   function updateStatus() {
@@ -1353,29 +1375,31 @@ function createReactiveCollectionStatus({
           if (scope2) {
             collectionScopes.push(scope2);
           }
-          if (unwrapped) {
-            const element = createCollectionElement({
-              $id: $id.value,
-              path,
-              customMessages,
-              rules: unwrapped,
-              stateValue: currentValue,
-              index,
-              options,
-              storage,
-              externalErrors: vue.toRef(externalErrors?.value ?? {}, `$each`),
-              initialState: vue.toRef(initialState.value ?? [], index),
-              shortcuts,
-              fieldName
-            });
-            if (element) {
-              return element;
-            }
-            return null;
+          const $externalErrors = vue.toRef(externalErrors?.value ?? {}, `$each`);
+          const $schemaErrors = vue.computed(() => schemaErrors?.value?.$each ?? []);
+          const element = createCollectionElement({
+            $id: $id.value,
+            path,
+            customMessages,
+            rules: unwrapped ?? {},
+            stateValue: currentValue,
+            index,
+            options,
+            storage,
+            externalErrors: $externalErrors,
+            schemaErrors: $schemaErrors,
+            initialState: vue.toRef(initialState.value ?? [], index),
+            shortcuts,
+            fieldName,
+            schemaMode
+          });
+          if (element) {
+            return element;
           }
+          return null;
         }
       }).filter((each) => !!each);
-      previousStatus.filter(($each) => !state.value.find((f) => $each.$id === f.$id)).forEach(($each, index) => {
+      previousStatus.filter(($each) => !state.value?.find((f) => $each.$id === f.$id)).forEach((_, index) => {
         storage.deleteArrayStatus($id.value, index.toString());
       });
     } else {
@@ -1628,6 +1652,8 @@ function createReactiveNestedStatus({
   path = "",
   rootRules,
   externalErrors,
+  schemaErrors,
+  rootSchemaErrors,
   validationGroups,
   initialState,
   fieldName,
@@ -1637,6 +1663,7 @@ function createReactiveNestedStatus({
   let scopeState;
   let nestedScopes = [];
   let $unwatchRules = null;
+  let $unwatchSchemaErrors = null;
   let $unwatchExternalErrors = null;
   let $unwatchState = null;
   async function createReactiveFieldsStatus(watchSources = true) {
@@ -1647,6 +1674,7 @@ function createReactiveNestedStatus({
           const stateRef = vue.toRef(state.value ?? {}, statePropKey);
           const statePropRulesRef = vue.toRef(() => statePropRules);
           const $externalErrors = vue.toRef(externalErrors?.value ?? {}, statePropKey);
+          const $schemaErrors = vue.computed(() => schemaErrors?.value?.[statePropKey]);
           const initialStateRef = vue.toRef(initialState?.value ?? {}, statePropKey);
           return [
             statePropKey,
@@ -1655,6 +1683,7 @@ function createReactiveNestedStatus({
               rulesDef: statePropRulesRef,
               path: path ? `${path}.${statePropKey}` : statePropKey,
               externalErrors: $externalErrors,
+              schemaErrors: $schemaErrors,
               initialState: initialStateRef,
               fieldName: statePropKey,
               ...commonArgs
@@ -1667,6 +1696,8 @@ function createReactiveNestedStatus({
     const externalRulesStatus = Object.fromEntries(
       Object.entries(vue.unref(externalErrors) ?? {}).filter(([key, errors]) => !(key in rulesDef.value) && !!errors).map(([key]) => {
         const stateRef = vue.toRef(state.value ?? {}, key);
+        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, key);
+        const $schemaErrors = vue.computed(() => schemaErrors?.value?.[key]);
         const initialStateRef = vue.toRef(initialState?.value ?? {}, key);
         return [
           key,
@@ -1674,7 +1705,29 @@ function createReactiveNestedStatus({
             state: stateRef,
             rulesDef: vue.computed(() => ({})),
             path: path ? `${path}.${key}` : key,
-            externalErrors: vue.toRef(externalErrors?.value ?? {}, key),
+            externalErrors: $externalErrors,
+            schemaErrors: $schemaErrors,
+            initialState: initialStateRef,
+            fieldName: key,
+            ...commonArgs
+          })
+        ];
+      })
+    );
+    const schemasRulesStatus = Object.fromEntries(
+      Object.entries(vue.unref(schemaErrors) ?? {}).map(([key]) => {
+        const stateRef = vue.toRef(state.value ?? {}, key);
+        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, key);
+        const $schemaErrors = vue.computed(() => schemaErrors?.value?.[key]);
+        const initialStateRef = vue.toRef(initialState?.value ?? {}, key);
+        return [
+          key,
+          createReactiveChildrenStatus({
+            state: stateRef,
+            rulesDef: vue.computed(() => ({})),
+            path: path ? `${path}.${key}` : key,
+            externalErrors: $externalErrors,
+            schemaErrors: $schemaErrors,
             initialState: initialStateRef,
             fieldName: key,
             ...commonArgs
@@ -1683,8 +1736,12 @@ function createReactiveNestedStatus({
       })
     );
     const statesWithNoRules = Object.fromEntries(
-      Object.entries(state.value ?? {}).filter(([key]) => !(key in rulesDef.value) && !(key in (externalRulesStatus.value ?? {}))).map(([key]) => {
+      Object.entries(state.value ?? {}).filter(
+        ([key]) => !(key in rulesDef.value) && !(key in (externalRulesStatus ?? {})) && !(key in (schemasRulesStatus ?? {}))
+      ).map(([key]) => {
         const stateRef = vue.toRef(state.value ?? {}, key);
+        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, key);
+        const $schemaErrors = vue.computed(() => schemaErrors?.value?.[key]);
         const initialStateRef = vue.toRef(initialState?.value ?? {}, key);
         return [
           key,
@@ -1692,7 +1749,8 @@ function createReactiveNestedStatus({
             state: stateRef,
             rulesDef: vue.computed(() => ({})),
             path: path ? `${path}.${key}` : key,
-            externalErrors: vue.toRef(externalErrors?.value ?? {}, key),
+            externalErrors: $externalErrors,
+            schemaErrors: $schemaErrors,
             initialState: initialStateRef,
             fieldName: key,
             ...commonArgs
@@ -1703,6 +1761,7 @@ function createReactiveNestedStatus({
     $fields.value = {
       ...scopedRulesStatus,
       ...externalRulesStatus,
+      ...schemasRulesStatus,
       ...statesWithNoRules
     };
     if (watchSources) {
@@ -1725,7 +1784,7 @@ function createReactiveNestedStatus({
     });
   }
   function define$WatchExternalErrors() {
-    if (externalErrors?.value) {
+    if (externalErrors) {
       $unwatchExternalErrors = vue.watch(
         externalErrors,
         () => {
@@ -1760,6 +1819,17 @@ function createReactiveNestedStatus({
       );
       define$WatchExternalErrors();
     }
+    if (rootSchemaErrors) {
+      $unwatchSchemaErrors?.();
+      $unwatchSchemaErrors = vue.watch(
+        rootSchemaErrors,
+        () => {
+          $unwatch();
+          createReactiveFieldsStatus();
+        },
+        { deep: true, flush: "post" }
+      );
+    }
     define$watchState();
     scope = vue.effectScope();
     scopeState = scope.run(() => {
@@ -1821,8 +1891,9 @@ function createReactiveNestedStatus({
         }
         return $anyDirty.value && !($invalid.value || $pending.value);
       });
+      const $localPending2 = vue.ref(false);
       const $pending = vue.computed(() => {
-        return Object.entries($fields.value).some(([key, statusOrField]) => {
+        return $localPending2.value || Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField?.$pending;
         });
       });
@@ -1934,7 +2005,8 @@ function createReactiveNestedStatus({
         $groups,
         $silentValue,
         $edited,
-        $anyEdited
+        $anyEdited,
+        $localPending: $localPending2
       };
     });
   }
@@ -1984,25 +2056,37 @@ function createReactiveNestedStatus({
   }
   async function $validate() {
     try {
-      const data = state.value;
-      const results = await Promise.allSettled(
-        Object.values($fields.value).map((statusOrField) => {
-          return statusOrField.$validate();
-        })
-      );
-      const validationResults = results.every((value) => {
-        if (value.status === "fulfilled") {
-          return value.value.result === true;
+      if (commonArgs.schemaMode) {
+        if (commonArgs.onValidate) {
+          $touch(false);
+          scopeState.$localPending.value = true;
+          return commonArgs.onValidate();
         } else {
-          return false;
+          return { result: false, data: state.value };
         }
-      });
-      return { result: validationResults, data };
+      } else {
+        const data = state.value;
+        const results = await Promise.allSettled(
+          Object.values($fields.value).map((statusOrField) => {
+            return statusOrField.$validate();
+          })
+        );
+        const validationResults = results.every((value) => {
+          if (value.status === "fulfilled") {
+            return value.value.result === true;
+          } else {
+            return false;
+          }
+        });
+        return { result: validationResults, data };
+      }
     } catch (e) {
       return { result: false, data: state.value };
+    } finally {
+      scopeState.$localPending.value = false;
     }
   }
-  const { $shortcuts, ...restScopeState } = scopeState;
+  const { $shortcuts, $localPending, ...restScopeState } = scopeState;
   return vue.reactive({
     ...restScopeState,
     ...$shortcuts,
@@ -2020,48 +2104,53 @@ function createReactiveNestedStatus({
 }
 function createReactiveChildrenStatus({
   rulesDef,
-  externalErrors,
   ...properties
 }) {
   if (isCollectionRulesDef(rulesDef, properties.state)) {
     return createReactiveCollectionStatus({
       rulesDef,
-      externalErrors,
       ...properties
     });
   } else if (isNestedRulesDef(properties.state, rulesDef)) {
     if (isRefObject(properties.state)) {
       return createReactiveNestedStatus({
         rulesDef,
-        externalErrors,
         ...properties
       });
     } else {
-      const fakeState = vue.ref({});
-      const unwatchState = vue.watch(
-        fakeState,
-        (value) => {
-          unwatchState();
-          properties.state.value = value;
-        },
-        { deep: true }
-      );
+      const scope = vue.effectScope();
+      const scopeState = scope.run(() => {
+        const fakeState = vue.toRef(properties.state.value ? properties.state : vue.ref({}));
+        vue.watch(
+          () => properties.state.value,
+          (value) => {
+            fakeState.value = value;
+          },
+          { deep: true }
+        );
+        vue.watch(
+          fakeState,
+          (value) => {
+            properties.state.value = value;
+          },
+          { deep: true }
+        );
+        return { fakeState };
+      });
       const { state, ...restProperties } = properties;
       return createReactiveNestedStatus({
         rulesDef,
-        externalErrors,
         ...restProperties,
-        state: fakeState
+        state: scopeState.fakeState
       });
     }
   } else if (isValidatorRulesDef(rulesDef)) {
     return createReactiveFieldStatus({
       rulesDef,
-      externalErrors,
       ...properties
     });
   }
-  return void 0;
+  return undefined;
 }
 
 // src/core/useRegle/root/useRootStorage.ts
@@ -2071,7 +2160,10 @@ function useRootStorage({
   scopeRules,
   state,
   customRules,
-  shortcuts
+  shortcuts,
+  schemaErrors,
+  schemaMode = false,
+  onValidate
 }) {
   const storage = useStorage();
   const regle = vue.ref();
@@ -2087,7 +2179,11 @@ function useRootStorage({
     initialState,
     shortcuts,
     fieldName: "root",
-    path: ""
+    path: "",
+    schemaErrors,
+    rootSchemaErrors: schemaErrors,
+    schemaMode,
+    onValidate
   });
   if (vue.getCurrentScope()) {
     vue.onScopeDispose(() => {