@regle/core 0.0.6 → 0.0.8

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");
@@ -208,10 +232,20 @@ function useStorage() {
     } else {
       const $pending = (0, import_vue2.ref)(false);
       const $valid = (0, import_vue2.ref)(true);
-      ruleStatusStorage.value.set(path, { $pending, $valid });
-      return { $pending, $valid };
+      const $metadata = (0, import_vue2.ref)({});
+      const $validating = (0, import_vue2.ref)(false);
+      ruleStatusStorage.value.set(path, { $pending, $valid, $metadata, $validating });
+      return { $pending, $valid, $metadata, $validating };
     }
   }
+  (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,
@@ -303,7 +337,13 @@ function extractRulesErrors(rules, externalErrors) {
       return rule.$message;
     }
     return null;
-  }).filter((msg) => !!msg).concat(externalErrors ?? []);
+  }).filter((msg) => !!msg).reduce((acc, value) => {
+    if (typeof value === "string") {
+      return acc?.concat([value]);
+    } else {
+      return acc?.concat(value);
+    }
+  }, []).concat(externalErrors ?? []);
 }
 function processFieldErrors(fieldStatus) {
   if (isNestedRulesStatus(fieldStatus)) {
@@ -394,13 +434,20 @@ function createReactiveRuleStatus({
 }) {
   let scope = (0, import_vue5.effectScope)();
   let scopeState;
-  const { $pending, $valid } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
+  const { $pending, $valid, $metadata, $validating } = storage.trySetRuleStatusRef(
+    `${path}.${ruleKey}`
+  );
   function $watch() {
     scopeState = scope.run(() => {
+      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;
           }
@@ -410,31 +457,33 @@ function createReactiveRuleStatus({
       });
       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);
-          } else {
-            message = customMessageRule;
-          }
-        }
-        if (isFormRuleDefinition(rule)) {
-          if (!(customMessageRule && !rule.value._patched)) {
-            if (typeof rule.value.message === "function") {
-              message = rule.value.message(state.value, ...$params.value);
+        if ($dirty.value && !$validating.value) {
+          const customMessageRule = customMessages ? customMessages[ruleKey]?.message : void 0;
+          if (customMessageRule) {
+            if (typeof customMessageRule === "function") {
+              message = customMessageRule(state.value, $defaultMetadata.value);
             } else {
-              message = rule.value.message;
+              message = customMessageRule;
             }
           }
-        }
-        if (isEmpty(message)) {
-          message = "Error";
-          console.warn(`No error message defined for ${ruleKey}`);
+          if (isFormRuleDefinition(rule)) {
+            if (!(customMessageRule && !rule.value._patched)) {
+              if (typeof rule.value.message === "function") {
+                message = rule.value.message(state.value, $defaultMetadata.value);
+              } else {
+                message = rule.value.message;
+              }
+            }
+          }
+          if (isEmpty(message)) {
+            message = "Error";
+            console.warn(`No error message defined for ${ruleKey}`);
+          }
         }
         return message;
       });
       const $type = (0, import_vue5.computed)(() => {
-        if (isFormRuleDefinition(rule)) {
+        if (isFormRuleDefinition(rule) && rule.value.type) {
           return Object.values(InternalRuleType).includes(rule.value.type) ? ruleKey : rule.value.type;
         } else {
           return ruleKey;
@@ -469,29 +518,48 @@ function createReactiveRuleStatus({
     deep: true
   });
   async function $validate() {
-    const validator = scopeState.$validator.value;
-    let ruleResult = false;
-    const resultOrPromise = validator(state.value, ...scopeState.$params.value);
-    if (resultOrPromise instanceof Promise) {
-      if ($dirty.value && !$pending.value) {
-        try {
-          $valid.value = true;
-          $pending.value = true;
-          const promiseResult = await resultOrPromise;
-          ruleResult = promiseResult;
-        } catch (e) {
-          ruleResult = false;
-        } finally {
-          $pending.value = false;
+    try {
+      $validating.value = true;
+      const validator = scopeState.$validator.value;
+      let ruleResult = false;
+      const resultOrPromise = validator(state.value, ...scopeState.$params.value);
+      if (resultOrPromise instanceof Promise) {
+        if ($dirty.value && !$pending.value) {
+          try {
+            $valid.value = true;
+            $pending.value = true;
+            const promiseResult = await resultOrPromise;
+            if (typeof promiseResult === "boolean") {
+              ruleResult = promiseResult;
+            } else {
+              const { $valid: $valid2, ...rest } = promiseResult;
+              ruleResult = $valid2;
+              $metadata.value = rest;
+            }
+          } catch (e) {
+            ruleResult = false;
+          } finally {
+            $pending.value = false;
+          }
+        }
+      } else {
+        if (resultOrPromise != null) {
+          if (typeof resultOrPromise === "boolean") {
+            ruleResult = resultOrPromise;
+          } else {
+            const { $valid: $valid2, ...rest } = resultOrPromise;
+            ruleResult = $valid2;
+            $metadata.value = rest;
+          }
         }
       }
-    } else {
-      ruleResult = resultOrPromise;
-    }
-    $valid.value = ruleResult;
-    if (options.$externalErrors) {
+      $valid.value = ruleResult;
+      if (options.$externalErrors) {
+      }
+      return ruleResult;
+    } finally {
+      $validating.value = false;
     }
-    return ruleResult;
   }
   function $unwatch() {
     $unwatchState();
@@ -577,7 +645,6 @@ function createReactiveFieldStatus({
       $commit();
     }
     $externalErrors.value = [];
-    console.log($externalErrors.value);
   });
   function $unwatch() {
     if ($rules.value) {
@@ -711,7 +778,7 @@ function createCollectionElement({
     });
   }
   const $state = (0, import_vue7.toRefs)(value);
-  const $externalErrors = (0, import_vue7.toRefs)(externalErrors.value ?? (0, import_vue7.reactive)([void 0]));
+  const $externalErrors = (0, import_vue7.toRef)(() => externalErrors.value?.[index]);
   const $status = createReactiveChildrenStatus({
     state: $state[index],
     rulesDef: (0, import_vue7.toRef)(() => rules),
@@ -719,7 +786,7 @@ function createCollectionElement({
     path: $path,
     storage,
     options,
-    externalErrors: $externalErrors?.[index]
+    externalErrors: $externalErrors
   });
   if ($status) {
     $status.$id = value[index].$id ?? $id;
@@ -1151,8 +1218,8 @@ function createUseRegleComposable(customRules, options) {
 }
 var useRegle = createUseRegleComposable();
 
-// src/core/defineRegleOptions.ts
-function defineRegleOptions({
+// src/core/defineRegleConfig.ts
+function defineRegleConfig({
   rules,
   options
 }) {
@@ -1163,6 +1230,8 @@ function defineRegleOptions({
 0 && (module.exports = {
   InternalRuleType,
   createRule,
-  defineRegleOptions,
-  unwrapRuleParameters
+  defineRegleConfig,
+  defineType,
+  unwrapRuleParameters,
+  useRegle
 });