@regle/core 0.7.4-beta.3 → 0.7.5

package/dist/regle-core.mjs

@@ -1,4 +1,4 @@
-import { toValue, version, ref, getCurrentScope, onScopeDispose, reactive, computed, shallowRef, effectScope, isRef, toRef, unref, watch, watchEffect } from 'vue';
+import { toValue, version, ref, getCurrentScope, onScopeDispose, reactive, computed, shallowRef, effectScope, isRef, toRef, unref, watch, getCurrentInstance, onMounted, watchEffect } from 'vue';
 
 // ../shared/utils/isEmpty.ts
 function isEmpty(value, considerEmptyArrayInvalid = true) {
@@ -69,28 +69,6 @@ function isObject(obj) {
   return typeof obj === "object" && obj !== null && !Array.isArray(obj);
 }
 
-// ../shared/utils/isDate.ts
-function isDate(value) {
-  if (isEmpty(value)) {
-    return false;
-  }
-  try {
-    let possibleDate = null;
-    if (value instanceof Date) {
-      possibleDate = value;
-    } else if (typeof value === "string") {
-      const date = new Date(value);
-      if (date.toString() === "Invalid Date") {
-        return false;
-      }
-      possibleDate = date;
-    }
-    return !!possibleDate;
-  } catch (e) {
-    return false;
-  }
-}
-
 // ../shared/utils/toDate.ts
 function toDate(argument) {
   const argStr = Object.prototype.toString.call(argument);
@@ -442,6 +420,25 @@ function randomId() {
     return uint32.toString(10);
   }
 }
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+function createGlobalState(stateFactory) {
+  let initialized = false;
+  let state;
+  const scope = effectScope(true);
+  return (...args) => {
+    if (!initialized) {
+      state = scope.run(() => stateFactory(...args));
+      initialized = true;
+    }
+    return state;
+  };
+}
 
 // src/core/useRegle/guards/ruleDef.guards.ts
 function isNestedRulesDef(state, rules) {
@@ -474,7 +471,7 @@ function extractRulesErrors({
   silent = false
 }) {
   return Object.entries(field.$rules ?? {}).map(([_, rule]) => {
-    if (silent) {
+    if (silent && !rule.$valid) {
       return rule.$message;
     } else if (!rule.$valid && field.$error && !rule.$validating) {
       return rule.$message;
@@ -874,27 +871,27 @@ function createReactiveFieldStatus({
       const $errors = computed(() => {
         return extractRulesErrors({
           field: {
+            $rules: $rules.value,
             $error: $error.value,
             $externalErrors: externalErrors?.value,
-            $schemaErrors: schemaErrors?.value,
-            $rules: $rules.value
+            $schemaErrors: schemaErrors?.value
           }
         });
       });
       const $silentErrors = computed(() => {
         return extractRulesErrors({
           field: {
-            $error: true,
+            $rules: $rules.value,
+            $error: $error.value,
             $externalErrors: externalErrors?.value,
-            $schemaErrors: schemaErrors?.value,
-            $rules: $rules.value
+            $schemaErrors: schemaErrors?.value
           },
           silent: true
         });
       });
       const $edited = computed(() => {
         if ($dirty.value) {
-          if (isDate(initialState.value) && isDate(state.value)) {
+          if (initialState.value instanceof Date && state.value instanceof Date) {
             return toDate(initialState.value).getDate() !== toDate(state.value).getDate();
           }
           if (initialState.value == null) {
@@ -2256,10 +2253,18 @@ function defineRegleConfig({
 function mergeRegles(regles, _scoped) {
   const scoped = _scoped == null ? false : _scoped;
   const $value = computed({
-    get: () => Object.fromEntries(Object.entries(regles).map(([key, r]) => [key, r.$value])),
+    get: () => {
+      if (scoped) {
+        return Object.values(regles).map((r) => r.$value);
+      } else {
+        return Object.fromEntries(Object.entries(regles).map(([key, r]) => [key, r.$value]));
+      }
+    },
     set: (value) => {
-      if (typeof value === "object") {
-        Object.entries(value).forEach(([key, newValue]) => regles[key].$value = newValue);
+      if (!scoped) {
+        if (typeof value === "object") {
+          Object.entries(value).forEach(([key, newValue]) => regles[key].$value = newValue);
+        }
       }
     }
   });
@@ -2272,7 +2277,8 @@ function mergeRegles(regles, _scoped) {
     }
   });
   const $dirty = computed(() => {
-    return Object.entries(regles).every(([_, regle]) => {
+    const entries = Object.entries(regles);
+    return !!entries.length && entries.every(([_, regle]) => {
       return regle?.$dirty;
     });
   });
@@ -2287,8 +2293,9 @@ function mergeRegles(regles, _scoped) {
     });
   });
   const $valid = computed(() => {
-    return Object.entries(regles).every(([_, regle]) => {
-      return regle?.$invalid;
+    const entries = Object.entries(regles);
+    return !!entries.length && entries.every(([_, regle]) => {
+      return regle?.$valid;
     });
   });
   const $error = computed(() => {
@@ -2297,7 +2304,8 @@ function mergeRegles(regles, _scoped) {
     });
   });
   const $ready = computed(() => {
-    return Object.entries(regles).every(([_, regle]) => {
+    const entries = Object.entries(regles);
+    return !!entries.length && entries.every(([_, regle]) => {
       return regle?.$ready;
     });
   });
@@ -2307,21 +2315,34 @@ function mergeRegles(regles, _scoped) {
     });
   });
   const $errors = computed(() => {
-    return Object.fromEntries(
-      Object.entries(regles).map(([key, regle]) => {
-        return [key, regle.$errors];
-      })
-    );
+    if (scoped) {
+      return Object.entries(regles).map(([_, regle]) => {
+        return regle.$errors;
+      });
+    } else {
+      return Object.fromEntries(
+        Object.entries(regles).map(([key, regle]) => {
+          return [key, regle.$errors];
+        })
+      );
+    }
   });
   const $silentErrors = computed(() => {
-    return Object.fromEntries(
-      Object.entries(regles).map(([key, regle]) => {
-        return [key, regle.$silentErrors];
-      })
-    );
+    if (scoped) {
+      return Object.entries(regles).map(([_, regle]) => {
+        return regle.$silentErrors;
+      });
+    } else {
+      return Object.fromEntries(
+        Object.entries(regles).map(([key, regle]) => {
+          return [key, regle.$silentErrors];
+        })
+      );
+    }
   });
   const $edited = computed(() => {
-    return Object.entries(regles).every(([_, regle]) => {
+    const entries = Object.entries(regles);
+    return !!entries.length && entries.every(([_, regle]) => {
       return regle?.$edited;
     });
   });
@@ -2331,7 +2352,11 @@ function mergeRegles(regles, _scoped) {
     });
   });
   const $instances = computed(() => {
-    return regles;
+    if (scoped) {
+      return Object.values(regles);
+    } else {
+      return regles;
+    }
   });
   function $reset() {
     Object.values(regles).forEach((regle) => {
@@ -2378,12 +2403,12 @@ function mergeRegles(regles, _scoped) {
   }
   return reactive({
     ...!scoped && {
-      $instances,
-      $value,
-      $silentValue,
-      $errors,
-      $silentErrors
+      $silentValue
     },
+    $errors,
+    $silentErrors,
+    $instances,
+    $value,
     $dirty,
     $anyDirty,
     $invalid,
@@ -2401,42 +2426,112 @@ function mergeRegles(regles, _scoped) {
     $clearExternalErrors
   });
 }
-function createUseCollectScopedValidations(instances) {
-  function useCollectScopedValidations() {
-    const r$ = ref(mergeRegles(instances.value, true));
+function createUseCollectScope(instances) {
+  function useCollectScope(namespace) {
+    const computedNamespace = computed(() => toValue(namespace));
+    setEmptyNamespace();
+    const r$ = ref(collectRegles(instances.value));
     const regle = reactive({ r$ });
-    watch(instances, (newInstances) => {
-      r$.value = mergeRegles(newInstances, true);
-    });
+    function setEmptyNamespace() {
+      if (computedNamespace.value && !instances.value[computedNamespace.value]) {
+        instances.value[computedNamespace.value] = {};
+      }
+    }
+    watch(computedNamespace, setEmptyNamespace);
+    watch(
+      instances,
+      (newInstances) => {
+        r$.value = collectRegles(newInstances);
+      },
+      { deep: true }
+    );
+    function collectRegles(r$Instances) {
+      if (computedNamespace.value) {
+        const namespaceInstances = r$Instances[computedNamespace.value] ?? {};
+        return mergeRegles(namespaceInstances, true);
+      } else {
+        return mergeRegles(r$Instances["~~global"] ?? {}, true);
+      }
+    }
     return { r$: regle.r$ };
   }
-  return { useCollectScopedValidations };
+  return { useCollectScope };
 }
-function createUseScopedRegleComposable(customUseRegle) {
+function createUseScopedRegleComposable(instances, customUseRegle) {
   const scopedUseRegle = customUseRegle ?? useRegle;
-  const instances = ref({});
   const useScopedRegle = (state, rulesFactory, options) => {
-    const $id = randomId();
-    const { r$ } = scopedUseRegle(state, rulesFactory, options);
-    instances.value[$id] = r$;
-    onScopeDispose(() => {
-      delete instances.value[$id];
+    const { namespace, ...restOptions } = options ?? {};
+    const computedNamespace = computed(() => toValue(namespace));
+    const $id = ref(`${Object.keys(instances.value).length + 1}-${randomId()}`);
+    const instanceName = computed(() => {
+      return `instance-${$id.value}`;
+    });
+    const { r$ } = scopedUseRegle(state, rulesFactory, restOptions);
+    register();
+    tryOnScopeDispose(dispose);
+    watch(computedNamespace, (newName, oldName) => {
+      dispose(oldName);
+      register();
     });
-    function $dispose() {
-      delete instances.value[$id];
+    if (getCurrentInstance()) {
+      onMounted(() => {
+        const currentInstance = getCurrentInstance();
+        if (typeof window !== "undefined" && currentInstance?.proxy?.$el?.parentElement) {
+          if (document.documentElement && !document.documentElement.contains(currentInstance?.proxy?.$el?.parentElement)) {
+            dispose();
+          }
+        }
+      });
+    }
+    function dispose(oldName) {
+      const nameToClean = oldName ?? computedNamespace.value;
+      if (nameToClean) {
+        if (instances.value[nameToClean]) {
+          delete instances.value[nameToClean][instanceName.value];
+        }
+      } else if (instances.value["~~global"][instanceName.value]) {
+        delete instances.value["~~global"][instanceName.value];
+      }
     }
-    return { r$, $dispose };
+    function register() {
+      if (computedNamespace.value) {
+        if (!instances.value[computedNamespace.value]) {
+          instances.value[computedNamespace.value] = {};
+        }
+        instances.value[computedNamespace.value][instanceName.value] = r$;
+      } else {
+        if (!instances.value["~~global"]) {
+          instances.value["~~global"] = {};
+        }
+        instances.value["~~global"][instanceName.value] = r$;
+      }
+    }
+    return { r$, dispose, register };
   };
-  return { useScopedRegle, instances };
+  return { useScopedRegle };
 }
 
 // src/core/createScopedUseRegle/createScopedUseRegle.ts
-function createScopedUseRegle(customUseRegle) {
-  const { instances, useScopedRegle } = createUseScopedRegleComposable(customUseRegle);
-  const { useCollectScopedValidations } = createUseCollectScopedValidations(instances);
+function createScopedUseRegle(options) {
+  const useInstances = options?.customStore ? () => {
+    if (options.customStore) {
+      if (!options.customStore?.value["~~global"]) {
+        options.customStore.value["~~global"] = {};
+      } else if (options.customStore?.value) {
+        options.customStore.value = { "~~global": {} };
+      }
+    }
+    return options.customStore;
+  } : createGlobalState(() => {
+    const $inst = ref({ "~~global": {} });
+    return $inst;
+  });
+  const instances = useInstances();
+  const { useScopedRegle } = createUseScopedRegleComposable(instances, options?.customUseRegle);
+  const { useCollectScope } = createUseCollectScope(instances);
   return {
     useScopedRegle,
-    useCollectScopedValidations
+    useCollectScope
   };
 }
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@regle/core",
-  "version": "0.7.4-beta.3",
+  "version": "0.7.5",
   "description": "Type safe form validation library for Vue 3",
   "peerDependencies": {
-    "vue": ">=3.3.0",
-    "pinia": ">=2.2.5"
+    "pinia": ">=2.2.5",
+    "vue": ">=3.3.0"
   },
   "peerDependenciesMeta": {
     "pinia": {
@@ -13,12 +13,12 @@
   },
   "devDependencies": {
     "@total-typescript/ts-reset": "0.6.1",
-    "@types/node": "22.10.5",
-    "@typescript-eslint/eslint-plugin": "8.19.1",
-    "@typescript-eslint/parser": "8.19.1",
+    "@types/node": "22.10.7",
+    "@typescript-eslint/eslint-plugin": "8.21.0",
+    "@typescript-eslint/parser": "8.21.0",
     "@vue/test-utils": "2.4.6",
-    "bumpp": "9.10.0",
-    "changelogithub": "0.13.11",
+    "bumpp": "9.10.2",
+    "changelogithub": "13.12.1",
     "cross-env": "7.0.3",
     "eslint": "9.15.0",
     "eslint-config-prettier": "9.1.0",
@@ -26,7 +26,7 @@
     "expect-type": "1.1.0",
     "prettier": "3.3.3",
     "tsup": "8.3.5",
-    "type-fest": "4.32.0",
+    "type-fest": "4.33.0",
     "typescript": "5.6.3",
     "vitest": "2.1.8",
     "vue": "3.5.13",