@regle/core 0.7.4-beta.3 → 0.7.4

package/dist/regle-core.cjs

@@ -444,6 +444,25 @@ function randomId() {
     return uint32.toString(10);
   }
 }
+function tryOnScopeDispose(fn) {
+  if (vue.getCurrentScope()) {
+    vue.onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+function createGlobalState(stateFactory) {
+  let initialized = false;
+  let state;
+  const scope = vue.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) {
@@ -476,7 +495,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;
@@ -876,20 +895,20 @@ function createReactiveFieldStatus({
       const $errors = vue.computed(() => {
         return extractRulesErrors({
           field: {
+            $rules: $rules.value,
             $error: $error.value,
             $externalErrors: externalErrors?.value,
-            $schemaErrors: schemaErrors?.value,
-            $rules: $rules.value
+            $schemaErrors: schemaErrors?.value
           }
         });
       });
       const $silentErrors = vue.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
         });
@@ -2258,10 +2277,18 @@ function defineRegleConfig({
 function mergeRegles(regles, _scoped) {
   const scoped = _scoped == null ? false : _scoped;
   const $value = vue.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);
+        }
       }
     }
   });
@@ -2274,7 +2301,8 @@ function mergeRegles(regles, _scoped) {
     }
   });
   const $dirty = vue.computed(() => {
-    return Object.entries(regles).every(([_, regle]) => {
+    const entries = Object.entries(regles);
+    return !!entries.length && entries.every(([_, regle]) => {
       return regle?.$dirty;
     });
   });
@@ -2289,8 +2317,9 @@ function mergeRegles(regles, _scoped) {
     });
   });
   const $valid = vue.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 = vue.computed(() => {
@@ -2299,7 +2328,8 @@ function mergeRegles(regles, _scoped) {
     });
   });
   const $ready = vue.computed(() => {
-    return Object.entries(regles).every(([_, regle]) => {
+    const entries = Object.entries(regles);
+    return !!entries.length && entries.every(([_, regle]) => {
       return regle?.$ready;
     });
   });
@@ -2309,21 +2339,34 @@ function mergeRegles(regles, _scoped) {
     });
   });
   const $errors = vue.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 = vue.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 = vue.computed(() => {
-    return Object.entries(regles).every(([_, regle]) => {
+    const entries = Object.entries(regles);
+    return !!entries.length && entries.every(([_, regle]) => {
       return regle?.$edited;
     });
   });
@@ -2333,7 +2376,11 @@ function mergeRegles(regles, _scoped) {
     });
   });
   const $instances = vue.computed(() => {
-    return regles;
+    if (scoped) {
+      return Object.values(regles);
+    } else {
+      return regles;
+    }
   });
   function $reset() {
     Object.values(regles).forEach((regle) => {
@@ -2380,12 +2427,12 @@ function mergeRegles(regles, _scoped) {
   }
   return vue.reactive({
     ...!scoped && {
-      $instances,
-      $value,
-      $silentValue,
-      $errors,
-      $silentErrors
+      $silentValue
     },
+    $errors,
+    $silentErrors,
+    $instances,
+    $value,
     $dirty,
     $anyDirty,
     $invalid,
@@ -2403,42 +2450,112 @@ function mergeRegles(regles, _scoped) {
     $clearExternalErrors
   });
 }
-function createUseCollectScopedValidations(instances) {
-  function useCollectScopedValidations() {
-    const r$ = vue.ref(mergeRegles(instances.value, true));
+function createUseCollectScope(instances) {
+  function useCollectScope(namespace) {
+    const computedNamespace = vue.computed(() => vue.toValue(namespace));
+    setEmptyNamespace();
+    const r$ = vue.ref(collectRegles(instances.value));
     const regle = vue.reactive({ r$ });
-    vue.watch(instances, (newInstances) => {
-      r$.value = mergeRegles(newInstances, true);
-    });
+    function setEmptyNamespace() {
+      if (computedNamespace.value && !instances.value[computedNamespace.value]) {
+        instances.value[computedNamespace.value] = {};
+      }
+    }
+    vue.watch(computedNamespace, setEmptyNamespace);
+    vue.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 = vue.ref({});
   const useScopedRegle = (state, rulesFactory, options) => {
-    const $id = randomId();
-    const { r$ } = scopedUseRegle(state, rulesFactory, options);
-    instances.value[$id] = r$;
-    vue.onScopeDispose(() => {
-      delete instances.value[$id];
+    const { namespace, ...restOptions } = options ?? {};
+    const computedNamespace = vue.computed(() => vue.toValue(namespace));
+    const $id = vue.ref(`${Object.keys(instances.value).length + 1}-${randomId()}`);
+    const instanceName = vue.computed(() => {
+      return `instance-${$id.value}`;
+    });
+    const { r$ } = scopedUseRegle(state, rulesFactory, restOptions);
+    register();
+    tryOnScopeDispose(dispose);
+    vue.watch(computedNamespace, (newName, oldName) => {
+      dispose(oldName);
+      register();
     });
-    function $dispose() {
-      delete instances.value[$id];
+    if (vue.getCurrentInstance()) {
+      vue.onMounted(() => {
+        const currentInstance = vue.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];
+      }
+    }
+    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 };
+    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 = vue.ref({ "~~global": {} });
+    return $inst;
+  });
+  const instances = useInstances();
+  const { useScopedRegle } = createUseScopedRegleComposable(instances, options?.customUseRegle);
+  const { useCollectScope } = createUseCollectScope(instances);
   return {
     useScopedRegle,
-    useCollectScopedValidations
+    useCollectScope
   };
 }
 

package/dist/regle-core.d.cts

@@ -45,6 +45,68 @@ declare global {
 	}
 }
 
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+```
+
+@category Type
+*/
+type UnionToIntersection$1<Union> = (
+	// `extends unknown` is always going to be the case and is used to convert the
+	// `Union` into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	Union extends unknown
+		// The union type is used as the only argument to a function since the union
+		// of function arguments is an intersection.
+		? (distributedUnion: Union) => void
+		// This won't happen.
+		: never
+		// Infer the `Intersection` type since TypeScript represents the positional
+		// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void)
+	// The `& Union` is to allow indexing by the resulting type
+	? Intersection & Union
+	: never;
+
 declare const emptyObjectSymbol: unique symbol;
 
 /**
@@ -353,68 +415,6 @@ type RequiredObjectDeep<ObjectType extends object> = {
 	[KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]>
 };
 
-/**
-Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
-
-type Intersection = UnionToIntersection<Union>;
-//=> {the(): void; great(arg: string): void; escape: boolean};
-```
-
-A more applicable example which could make its way into your library code follows.
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-class CommandOne {
-	commands: {
-		a1: () => undefined,
-		b1: () => undefined,
-	}
-}
-
-class CommandTwo {
-	commands: {
-		a2: (argA: string) => undefined,
-		b2: (argB: string) => undefined,
-	}
-}
-
-const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
-type Union = typeof union;
-//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
-
-type Intersection = UnionToIntersection<Union>;
-//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
-```
-
-@category Type
-*/
-type UnionToIntersection$1<Union> = (
-	// `extends unknown` is always going to be the case and is used to convert the
-	// `Union` into a [distributive conditional
-	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	Union extends unknown
-		// The union type is used as the only argument to a function since the union
-		// of function arguments is an intersection.
-		? (distributedUnion: Union) => void
-		// This won't happen.
-		: never
-		// Infer the `Intersection` type since TypeScript represents the positional
-		// arguments of unions of functions as an intersection of the union.
-) extends ((mergedIntersection: infer Intersection) => void)
-	// The `& Union` is to allow indexing by the resulting type
-	? Intersection & Union
-	: never;
-
 /**
 Returns the last element of a union type.
 
@@ -569,7 +569,7 @@ type IsPropertyOutputRequired<TState, TRule extends RegleFormPropertyType<any, a
 ] extends [TState] ? unknown : NonNullable<TState> extends Array<any> ? TRule extends RegleCollectionRuleDecl<any, any> ? ArrayHaveAtLeastOneRequiredField<NonNullable<TState>, TRule> extends false ? false : true : false : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState> extends true ? ObjectHaveAtLeastOneRequiredField<NonNullable<TState> extends Record<string, any> ? NonNullable<TState> : {}, TRule> extends false ? false : true : TRule extends RegleRuleDecl<any, any> ? FieldHaveRequiredRule<TRule> extends false ? false : true : false : false;
 type SafeFieldProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends RegleRuleDecl<any, any> ? unknown extends TRule['required'] ? Maybe<TState> : TRule['required'] extends undefined ? never : TRule['required'] extends RegleRuleDefinition<any, infer Params, any, any, any> ? Params extends never[] ? Maybe<TState> : Maybe<TState> : Maybe<TState> : Maybe<TState>;
 
-type useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}> = <TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TValid = isDeepExact<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>> extends true ? {} : MismatchInfo<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>>>(state: MaybeRef<TState> | DeepReactiveState<TState>, rulesFactory: MaybeRefOrGetter<TRules>, options?: Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Unwrap<TState>, TRules, TValidationGroups>) => Regle<Unwrap<TState>, TRules, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
+type useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}, TAdditionalOptions extends Record<string, any> = {}> = <TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TValid = isDeepExact<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>> extends true ? {} : MismatchInfo<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>>>(state: MaybeRef<TState> | DeepReactiveState<TState>, rulesFactory: MaybeRefOrGetter<TRules>, options?: Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Unwrap<TState>, TRules, TValidationGroups> & TAdditionalOptions) => Regle<Unwrap<TState>, TRules, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
 /**
  * useRegle serves as the foundation for validation logic.
  *
@@ -589,7 +589,7 @@ type useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortcuts e
  * ```
  * Docs: {@link https://reglejs.dev/core-concepts/}
  */
-declare const useRegle: useRegleFn<Partial<AllRulesDeclarations>, RegleShortcutDefinition<any>, {}>;
+declare const useRegle: useRegleFn<Partial<AllRulesDeclarations>, RegleShortcutDefinition<any>, {}, {}>;
 
 interface inferRulesFn<TCustomRules extends Partial<AllRulesDeclarations>> {
     <TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TValid = isDeepExact<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>> extends true ? {} : MismatchInfo<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>>>(state: MaybeRef<TState> | DeepReactiveState<TState> | undefined, rulesFactory: TRules): NoInferLegacy<TRules>;
@@ -1408,12 +1408,16 @@ type SuperCompatibleRegleRoot = SuperCompatibleRegleStatus & {
         [x: string]: RegleValidationGroupOutput;
     };
 };
+type ScopedInstancesRecord = Record<string, Record<string, SuperCompatibleRegleRoot>> & {
+    '~~global': Record<string, SuperCompatibleRegleRoot>;
+};
+type ScopedInstancesRecordLike = Partial<ScopedInstancesRecord>;
 interface SuperCompatibleRegleStatus extends RegleCommonStatus {
     $fields: {
         [x: string]: unknown;
     };
-    readonly $errors: Record<string, $InternalRegleErrors>;
-    readonly $silentErrors: Record<string, $InternalRegleErrors>;
+    readonly $errors: Record<string, RegleValidationErrors<any>>;
+    readonly $silentErrors: Record<string, RegleValidationErrors<any>>;
     $extractDirtyFields: (filterNullishValues?: boolean) => Record<string, any>;
     $validate: () => Promise<$InternalRegleResult>;
 }
@@ -1704,7 +1708,7 @@ declare function unwrapRuleParameters<TParams extends any[]>(params: MaybeRefOrG
  * - a `useRegle` composable that can typecheck your custom rules
  * - an `inferRules` helper that can typecheck your custom rules
  */
-declare function defineRegleConfig<TShortcuts extends RegleShortcutDefinition<TCustomRules>, TCustomRules extends Partial<AllRulesDeclarations> = EmptyObject>({ rules, modifiers, shortcuts, }: {
+declare function defineRegleConfig<TShortcuts extends RegleShortcutDefinition<TCustomRules>, TCustomRules extends Partial<AllRulesDeclarations>>({ rules, modifiers, shortcuts, }: {
     rules?: () => TCustomRules;
     modifiers?: RegleBehaviourOptions;
     shortcuts?: TShortcuts;
@@ -1739,7 +1743,16 @@ type MergedRegles<TRegles extends Record<string, SuperCompatibleRegleRoot>, TVal
     /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
     $validate: () => Promise<MergedReglesResult<TRegles>>;
 };
-type MergedScopedRegles<TValue extends Record<string, any> = Record<string, unknown>> = Omit<MergedRegles<Record<string, SuperCompatibleRegleRoot>, TValue>, '$instances' | '$errors' | '$silentErrors' | '$value' | '$silentValue'>;
+type MergedScopedRegles<TValue extends Record<string, unknown>[] = Record<string, unknown>[]> = Omit<MergedRegles<Record<string, SuperCompatibleRegleRoot>, TValue>, '$instances' | '$errors' | '$silentErrors' | '$value' | '$silentValue'> & {
+    /** Array of scoped Regles instances  */
+    readonly $instances: SuperCompatibleRegleRoot[];
+    /** Collection of all registered Regles instances values */
+    readonly $value: TValue;
+    /** Collection of all registered Regles instances errors */
+    readonly $errors: RegleValidationErrors<Record<string, unknown>>[];
+    /** Collection of all registered Regles instances silent errors */
+    readonly $silentErrors: RegleValidationErrors<Record<string, unknown>>[];
+};
 type MergedReglesResult<TRegles extends Record<string, SuperCompatibleRegleRoot>> = {
     result: false;
     data: {
@@ -1758,12 +1771,18 @@ type MergedReglesResult<TRegles extends Record<string, SuperCompatibleRegleRoot>
 declare function mergeRegles<TRegles extends Record<string, SuperCompatibleRegleRoot>, TScoped extends boolean = false>(regles: TRegles, _scoped?: TScoped): TScoped extends false ? MergedRegles<TRegles> : MergedScopedRegles;
 
 declare function createScopedUseRegle<TCustomRegle extends useRegleFn<any, any> = useRegleFn<Partial<AllRulesDeclarations>>, TReturnedRegle extends useRegleFn<any, any> = TCustomRegle extends useRegleFn<infer A, infer B> ? useRegleFn<A, B, {
-    $dispose: () => void;
-}> : useRegleFn<Partial<AllRulesDeclarations>>>(customUseRegle?: TCustomRegle): {
+    dispose: () => void;
+    register: () => void;
+}, {
+    namespace?: MaybeRefOrGetter<string>;
+}> : useRegleFn<Partial<AllRulesDeclarations>>>(options?: {
+    customUseRegle?: TCustomRegle;
+    customStore?: Ref<ScopedInstancesRecordLike>;
+}): {
     useScopedRegle: TReturnedRegle;
-    useCollectScopedValidations<TValue extends Record<string, any> = Record<string, unknown>>(): {
+    useCollectScope<TValue extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: MaybeRefOrGetter<string>): {
         r$: MergedScopedRegles<TValue>;
     };
 };
 
-export { type $InternalRegleStatus, type AllRulesDeclarations, type DeepMaybeRef, type DeepReactiveState, type FormRuleDeclaration, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InferRegleStatusType, type InlineRuleDeclaration, InternalRuleType, type JoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MergedRegles, type MismatchInfo, type NoInferLegacy, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleShortcutDefinition, type RegleStatus, type RegleUniversalParams, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type ResolvedRegleBehaviourOptions, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, createRule, createScopedUseRegle, defineRegleConfig, inferRules, mergeRegles, unwrapRuleParameters, useRegle, useRootStorage };
+export { type $InternalRegleStatus, type AllRulesDeclarations, type DeepMaybeRef, type DeepReactiveState, type FormRuleDeclaration, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InferRegleStatusType, type InlineRuleDeclaration, InternalRuleType, type JoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MergedRegles, type MismatchInfo, type NoInferLegacy, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleShortcutDefinition, type RegleStatus, type RegleUniversalParams, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegleRoot, type SuperCompatibleRegleStatus, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, createRule, createScopedUseRegle, defineRegleConfig, inferRules, mergeRegles, unwrapRuleParameters, useRegle, useRootStorage };