@regle/core 0.0.6 → 0.0.8

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,15 +101,18 @@ function createRule(definition) {
   }
   throw new Error("Validator must be a function");
 }
+function defineType(ruleName) {
+  return ruleName;
+}
 
 // src/core/useRegle/useRegle.ts
-import { computed as computed7, isRef as isRef2, ref as ref4, shallowRef as shallowRef2, toRaw } 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 { computed as computed6, reactive as reactive5, unref as unref3 } from "vue";
+import { computed as computed5, reactive as reactive5, unref as unref3 } from "vue";
 
 // src/core/useStorage/useStorage.ts
-import { ref, shallowRef } from "vue";
+import { onScopeDispose, ref, shallowRef } from "vue";
 function useStorage() {
   const ruleDeclStorage = shallowRef(/* @__PURE__ */ new Map());
   const fieldsStorage = shallowRef(
@@ -179,10 +201,20 @@ function useStorage() {
     } else {
       const $pending = ref(false);
       const $valid = ref(true);
-      ruleStatusStorage.value.set(path, { $pending, $valid });
-      return { $pending, $valid };
+      const $metadata = ref({});
+      const $validating = ref(false);
+      ruleStatusStorage.value.set(path, { $pending, $valid, $metadata, $validating });
+      return { $pending, $valid, $metadata, $validating };
     }
   }
+  onScopeDispose(() => {
+    ruleDeclStorage.value.clear();
+    fieldsStorage.value.clear();
+    collectionsStorage.value.clear();
+    dirtyStorage.value.clear();
+    ruleStatusStorage.value.clear();
+    arrayStatusStorage.value.clear();
+  });
   return {
     addRuleDeclEntry,
     setDirtyEntry,
@@ -232,7 +264,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) {
@@ -274,7 +306,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)) {
@@ -328,7 +366,7 @@ function useErrors($regle) {
 }
 
 // src/core/useRegle/useStateProperties/createReactiveNestedStatus.ts
-import { computed as computed5, effectScope as effectScope4, reactive as reactive4, toRef as toRef4, watch as watch4 } from "vue";
+import { computed as computed4, effectScope as effectScope4, reactive as reactive4, toRef as toRef4, watch as watch4 } from "vue";
 
 // src/core/useRegle/useStateProperties/createReactiveCollectionStatus.ts
 import { nextTick, reactive as reactive3, ref as ref3, toRef as toRef3, toRefs, watch as watch3 } from "vue";
@@ -365,13 +403,20 @@ function createReactiveRuleStatus({
 }) {
   let scope = effectScope2();
   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 = 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;
           }
@@ -381,31 +426,33 @@ function createReactiveRuleStatus({
       });
       const $message = computed2(() => {
         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 = 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;
@@ -440,29 +487,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();
@@ -548,7 +614,6 @@ function createReactiveFieldStatus({
       $commit();
     }
     $externalErrors.value = [];
-    console.log($externalErrors.value);
   });
   function $unwatch() {
     if ($rules.value) {
@@ -682,7 +747,7 @@ function createCollectionElement({
     });
   }
   const $state = toRefs(value);
-  const $externalErrors = toRefs(externalErrors.value ?? reactive3([void 0]));
+  const $externalErrors = toRef3(() => externalErrors.value?.[index]);
   const $status = createReactiveChildrenStatus({
     state: $state[index],
     rulesDef: toRef3(() => rules),
@@ -690,7 +755,7 @@ function createCollectionElement({
     path: $path,
     storage,
     options,
-    externalErrors: $externalErrors?.[index]
+    externalErrors: $externalErrors
   });
   if ($status) {
     $status.$id = value[index].$id ?? $id;
@@ -942,28 +1007,28 @@ function createReactiveNestedStatus({
       );
     }
     scopeState = scope.run(() => {
-      const $dirty = computed5(() => {
+      const $dirty = computed4(() => {
         return Object.entries($fields.value).every(([key, statusOrField]) => {
           return statusOrField.$dirty;
         });
       });
-      const $anyDirty = computed5(() => {
+      const $anyDirty = computed4(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$dirty;
         });
       });
-      const $invalid = computed5(() => {
+      const $invalid = computed4(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$invalid;
         });
       });
-      const $valid = computed5(() => !$invalid.value);
-      const $error = computed5(() => {
+      const $valid = computed4(() => !$invalid.value);
+      const $error = computed4(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$error;
         });
       });
-      const $pending = computed5(() => {
+      const $pending = computed4(() => {
         return Object.entries($fields.value).some(([key, statusOrField]) => {
           return statusOrField.$pending;
         });
@@ -1053,7 +1118,7 @@ function createReactiveChildrenStatus({
 // src/core/useRegle/useStateProperties/useStateProperties.ts
 function useStateProperties(scopeRules, state, options, customRules) {
   const storage = useStorage();
-  const externalErrors = computed6(() => unref3(options.$externalErrors));
+  const externalErrors = computed5(() => unref3(options.$externalErrors));
   const $regle = reactive5(
     createReactiveNestedStatus({
       rootRules: scopeRules,
@@ -1077,7 +1142,7 @@ function createUseRegleComposable(customRules, options) {
     rewardEarly: options?.rewardEarly ?? false
   };
   function useRegle2(state, rulesFactory, options2) {
-    const scopeRules = isRef2(rulesFactory) ? rulesFactory : computed7(rulesFactory);
+    const scopeRules = isRef2(rulesFactory) ? rulesFactory : computed6(rulesFactory);
     const resolvedOptions = {
       ...globalOptions,
       ...options2
@@ -1094,10 +1159,10 @@ function createUseRegleComposable(customRules, options) {
       state.value = toRaw(initialState.value);
       $regle.$reset();
     }
-    const $valid = computed7(() => {
+    const $valid = computed6(() => {
       return $regle.$valid && $regle.$dirty && !$regle.$pending;
     });
-    const $invalid = computed7(() => {
+    const $invalid = computed6(() => {
       return $regle.$invalid && $regle.$dirty || $regle.$pending;
     });
     async function validateForm() {
@@ -1122,8 +1187,8 @@ function createUseRegleComposable(customRules, options) {
 }
 var useRegle = createUseRegleComposable();
 
-// src/core/defineRegleOptions.ts
-function defineRegleOptions({
+// src/core/defineRegleConfig.ts
+function defineRegleConfig({
   rules,
   options
 }) {
@@ -1133,6 +1198,8 @@ function defineRegleOptions({
 export {
   InternalRuleType,
   createRule,
-  defineRegleOptions,
-  unwrapRuleParameters
+  defineRegleConfig,
+  defineType,
+  unwrapRuleParameters,
+  useRegle
 };

package/package.json

@@ -1,34 +1,36 @@
 {
   "name": "@regle/core",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Vue form validator",
   "scripts": {
     "lint": "eslint --ext .ts --ext .vue .",
     "typecheck": "tsc --noEmit",
     "release": "npm publish",
     "build": "tsup",
-    "dev": "tsup --config=tsup.dev.ts --watch"
+    "build:local": "tsup --clean false",
+    "dev": "tsup --config=tsup.dev.ts --watch",
+    "test": "echo 'no tests'"
   },
   "devDependencies": {
+    "@total-typescript/ts-reset": "0.5.1",
+    "@types/node": "20.11.5",
     "@types/prettier": "3.0.0",
-    "@typescript-eslint/eslint-plugin": "6.7.4",
-    "@typescript-eslint/parser": "6.7.4",
-    "@types/node": "20.8.3",
-    "@vue/test-utils": "2.4.1",
-    "bumpp": "9.2.0",
-    "changelogithub": "0.13.0",
+    "@typescript-eslint/eslint-plugin": "6.19.0",
+    "@typescript-eslint/parser": "6.19.0",
+    "@vue/test-utils": "2.4.3",
+    "bumpp": "9.3.0",
+    "changelogithub": "0.13.3",
     "cross-env": "7.0.3",
-    "eslint": "8.50.0",
-    "eslint-config-prettier": "9.0.0",
-    "eslint-plugin-vue": "9.17.0",
-    "prettier": "3.0.3",
-    "typescript": "5.2.2",
-    "vue": "3.3.4",
-    "vue-eslint-parser": "9.3.1",
-    "vue-tsc": "1.8.15",
-    "tsup": "7.2.0",
-    "@total-typescript/ts-reset": "0.5.1",
-    "type-fest": "4.4.0"
+    "eslint": "8.56.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-vue": "9.20.1",
+    "prettier": "3.2.4",
+    "tsup": "8.0.1",
+    "type-fest": "4.9.0",
+    "typescript": "5.3.3",
+    "vue": "3.4.14",
+    "vue-eslint-parser": "9.4.0",
+    "vue-tsc": "1.8.27"
   },
   "type": "module",
   "exports": {