@regle/core 1.8.5 → 1.9.0-beta.1

package/dist/regle-core.js

@@ -67,7 +67,7 @@ function isObject(obj) {
 	if (obj && (obj instanceof Date || obj.constructor.name == "File" || obj.constructor.name == "FileList")) return false;
 	return typeof obj === "object" && obj !== null && !Array.isArray(obj);
 }
-function merge(obj1, ...objs) {
+function merge(_obj1, ..._objs) {
 	var args = [].slice.call(arguments);
 	var arg;
 	var i = args.length;
@@ -255,7 +255,7 @@ function mergeArrayGroupProperties(entries, property) {
 function unwrapRuleParameters(params) {
 	try {
 		return params.map((param) => toValue(param));
-	} catch (e) {
+	} catch {
 		return [];
 	}
 }
@@ -274,13 +274,9 @@ function createReactiveParams(params) {
 * Due to `function.length` not returning default parameters, it needed to parse the func.toString()
 */
 function getFunctionParametersLength(func) {
-	const funcStr = func.toString();
-	const cleanStr = funcStr.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-	const paramsMatch = cleanStr.match(/^(?:async\s*)?(?:function\b.*?\(|\((.*?)\)|(\w+))\s*=>|\((.*?)\)\s*=>|function.*?\((.*?)\)|\((.*?)\)/);
+	const paramsMatch = func.toString().replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").match(/^(?:async\s*)?(?:function\b.*?\(|\((.*?)\)|(\w+))\s*=>|\((.*?)\)\s*=>|function.*?\((.*?)\)|\((.*?)\)/);
 	if (!paramsMatch) return 0;
-	const paramsSection = paramsMatch[0] || paramsMatch[1] || paramsMatch[2] || paramsMatch[3] || paramsMatch[4] || "";
-	const paramList = paramsSection.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
-	return paramList.length;
+	return (paramsMatch[0] || paramsMatch[1] || paramsMatch[2] || paramsMatch[3] || paramsMatch[4] || "").split(",").map((p) => p.trim()).filter((p) => p.length > 0).length;
 }
 
 //#endregion
@@ -288,7 +284,7 @@ function getFunctionParametersLength(func) {
 function defineRuleProcessors(definition, ...params) {
 	const { validator, type, async } = definition;
 	const isAsync = async || type === InternalRuleType.Async || validator.constructor.name === "AsyncFunction";
-	const defaultProcessors = {
+	return markRaw({
 		validator(value, ...args) {
 			return definition.validator(value, ...unwrapRuleParameters(args.length ? args : params));
 		},
@@ -326,10 +322,7 @@ function defineRuleProcessors(definition, ...params) {
 			if (typeof rawResult === "object" && "$valid" in rawResult) return rawResult.$valid;
 			else if (typeof rawResult === "boolean") return rawResult;
 			return false;
-		}
-	};
-	const processors = markRaw({
-		...defaultProcessors,
+		},
 		type,
 		_validator: definition.validator,
 		_message: definition.message,
@@ -342,7 +335,6 @@ function defineRuleProcessors(definition, ...params) {
 		_params: createReactiveParams(params),
 		_brand: RegleRuleSymbol
 	});
-	return processors;
 }
 
 //#endregion
@@ -461,17 +453,14 @@ function useStorage() {
 	function checkRuleDeclEntry($path, newRules) {
 		const storedRulesDefs = ruleDeclStorage.value.get($path);
 		if (!storedRulesDefs) return void 0;
-		const storedRules = storedRulesDefs;
-		const isValidCache = areRulesChanged(newRules, storedRules);
-		if (!isValidCache) return { valid: false };
+		if (!areRulesChanged(newRules, storedRulesDefs)) return { valid: false };
 		return { valid: true };
 	}
 	function areRulesChanged(newRules, storedRules) {
 		const storedRulesKeys = Object.keys(storedRules);
 		const newRulesKeys = Object.keys(newRules);
 		if (newRulesKeys.length !== storedRulesKeys.length) return false;
-		const hasAllValidators = newRulesKeys.every((ruleKey) => storedRulesKeys.includes(ruleKey));
-		if (!hasAllValidators) return false;
+		if (!newRulesKeys.every((ruleKey) => storedRulesKeys.includes(ruleKey))) return false;
 		return newRulesKeys.every((ruleKey) => {
 			const newRuleElement = newRules[ruleKey];
 			const storedRuleElement = storedRules[ruleKey];
@@ -603,10 +592,7 @@ function uniqueIDNuxt() {
 */
 function randomId() {
 	if (typeof window === "undefined") return uniqueIDNuxt();
-	else {
-		const uint32 = window.crypto.getRandomValues(new Uint32Array(1))[0];
-		return uint32.toString(10);
-	}
+	else return window.crypto.getRandomValues(new Uint32Array(1))[0].toString(10);
 }
 
 //#endregion
@@ -640,7 +626,7 @@ function createGlobalState(stateFactory) {
 //#endregion
 //#region src/core/useRegle/guards/ruleDef.guards.ts
 function isNestedRulesDef(state, rules) {
-	return isRefObject(state) || isObject(rules.value) && !isEmpty(rules.value) && !Object.entries(rules.value).some(([key, rule]) => isRuleDef(rule) || typeof rule === "function");
+	return isRefObject(state) || isObject(rules.value) && !isEmpty(rules.value) && !Object.entries(rules.value).some(([_, rule]) => isRuleDef(rule) || typeof rule === "function");
 }
 function isCollectionRulesDef(rules, state, schemaMode = false) {
 	return !!rules.value && isObject(rules.value) && "$each" in rules.value || schemaMode && Array.isArray(state.value) && state.value.some(isObject) || Array.isArray(state.value) && state.value.some(isObject);
@@ -671,22 +657,19 @@ function isFieldStatus(rule) {
 //#endregion
 //#region src/core/useRegle/useErrors.ts
 function extractRulesIssues({ field, silent = false }) {
-	const issues = Object.entries(field.$rules ?? {}).map(([key, rule]) => {
+	const ruleIssues = Object.entries(field.$rules ?? {}).map(([key, rule]) => {
 		let message = "";
 		if (silent && !rule.$valid) message = rule.$message;
 		else if (!rule.$valid && field.$error && !rule.$validating) message = rule.$message;
 		else return null;
-		const issue = {
+		return {
 			$message: message,
 			$property: field.fieldName,
 			$rule: key,
 			$type: rule.$type,
 			...typeof rule.$metadata === "object" ? rule.$metadata : {}
 		};
-		return issue;
-	});
-	const filteredIssues = issues.filter((msg) => !!msg);
-	const ruleIssues = filteredIssues.reduce((acc, issue) => {
+	}).filter((msg) => !!msg).reduce((acc, issue) => {
 		if (typeof issue.$message === "string") acc.push(issue);
 		else acc.push(...issue.$message.map((msg) => ({
 			...issue,
@@ -726,8 +709,8 @@ function flatErrors(errors, options) {
 	if (Array.isArray(errors) && errors.every((err) => !isObject(err))) return errors;
 	else if (isCollectionError(errors)) {
 		const selfErrors = includePath ? errors.$self?.map((err) => ({
-			error: err,
-			path: ""
+			message: err,
+			path: []
 		})) ?? [] : errors.$self ?? [];
 		const eachErrors = errors.$each?.map((err) => iterateErrors(err, includePath)) ?? [];
 		return selfErrors?.concat(eachErrors.flat());
@@ -737,23 +720,23 @@ function iterateErrors(errors, includePath = false, _path) {
 	const path = includePath && !_path ? [] : _path;
 	if (Array.isArray(errors) && errors.every((err) => !isObject(err))) {
 		if (includePath) return errors.map((err) => ({
-			error: err,
-			path: path?.join(".") ?? ""
+			message: err,
+			path: path ?? []
 		}));
 		return errors;
 	} else if (isCollectionError(errors)) {
 		const selfErrors = path?.length ? errors.$self?.map((err) => ({
-			error: err,
-			path: path.join(".")
+			message: err,
+			path: path ?? []
 		})) ?? [] : errors.$self ?? [];
-		const eachErrors = errors.$each?.map((err, index) => iterateErrors(err, includePath, path?.concat(index.toString()))) ?? [];
+		const eachErrors = errors.$each?.map((err, index) => iterateErrors(err, includePath, path?.concat(index))) ?? [];
 		return selfErrors?.concat(eachErrors.flat());
 	} else return Object.entries(errors).map(([key, value]) => iterateErrors(value, includePath, path?.concat(key))).flat();
 }
 
 //#endregion
 //#region src/core/useRegle/root/createReactiveRuleStatus.ts
-function createReactiveRuleStatus({ customMessages, rule, ruleKey, state, path, cachePath, storage, $debounce, modifiers }) {
+function createReactiveRuleStatus({ customMessages, rule, ruleKey, state, path, cachePath, storage, modifiers }) {
 	let scope = effectScope();
 	let scopeState = {};
 	let $unwatchState;
@@ -868,7 +851,7 @@ function createReactiveRuleStatus({ customMessages, rule, ruleKey, state, path,
 				ruleResult = $valid$1;
 				$metadata.value = rest;
 			}
-		} catch (e) {
+		} catch {
 			ruleResult = false;
 		} finally {
 			$pending.value = false;
@@ -894,7 +877,7 @@ function createReactiveRuleStatus({ customMessages, rule, ruleKey, state, path,
 			}
 			$valid.value = ruleResult;
 			return ruleResult;
-		} catch (e) {
+		} catch {
 			return false;
 		} finally {
 			$validating.value = false;
@@ -928,6 +911,23 @@ function createReactiveRuleStatus({ customMessages, rule, ruleKey, state, path,
 	});
 }
 
+//#endregion
+//#region src/core/useRegle/root/standard-schemas.ts
+function createStandardSchema(validateFn) {
+	return { "~standard": {
+		version: 1,
+		vendor: "regle",
+		validate: async (value) => {
+			const { valid, data, errors } = await validateFn(value);
+			if (valid) return {
+				value: data,
+				issues: []
+			};
+			return { issues: flatErrors(errors, { includePath: true }) };
+		}
+	} };
+}
+
 //#endregion
 //#region src/core/useRegle/root/createReactiveFieldStatus.ts
 function createReactiveFieldStatus({ state, rulesDef, customMessages, path, cachePath, fieldName, storage, options, externalErrors, schemaErrors, schemaMode, onUnwatch, $isArray, initialState, originalState, shortcuts, onValidate }) {
@@ -950,7 +950,7 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, cach
 		const rules = rulesDef.value;
 		const entries = [];
 		for (const ruleKey in rules) {
-			if (ruleKey.startsWith("$")) continue;
+			if (ruleKey.startsWith("$") || ruleKey.startsWith("~")) continue;
 			const rule = rules[ruleKey];
 			if (!rule) continue;
 			const ruleRef = toRef(() => rule);
@@ -1102,7 +1102,7 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, cach
 				return false;
 			});
 			const $invalid = computed(() => {
-				if (schemaErrors?.value && !Array.isArray(schemaErrors?.value) && "$self" in schemaErrors?.value) return schemaErrors?.value.$self?.length > 0;
+				if (schemaErrors?.value && !Array.isArray(schemaErrors?.value) && "$self" in schemaErrors.value) return schemaErrors?.value.$self?.length > 0;
 				else if (externalErrors?.value?.length || schemaErrors?.value?.length) return true;
 				else if ($inactive.value) return false;
 				else return Object.values($rules.value).some((ruleResult) => !ruleResult.$valid || ruleResult.$maybePending);
@@ -1257,39 +1257,50 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, cach
 			if (!scopeState.$silent.value || scopeState.$rewardEarly.value && scopeState.$error.value) $commit();
 		} else if (runCommit) $commit();
 	}
-	async function $validate() {
+	async function $validate(forceValues) {
 		try {
+			if (forceValues) state.value = forceValues;
 			if (schemaMode) if (onValidate) {
 				$touch(false);
 				return onValidate();
 			} else return {
 				valid: false,
-				data: state.value
+				data: state.value,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
 			const data = state.value;
 			if (!scopeState.$dirty.value) scopeState.$dirty.value = true;
 			else if (!scopeState.$silent.value && scopeState.$dirty.value && !scopeState.$pending.value) return {
 				valid: !scopeState.$error.value,
-				data
+				data,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
 			if (schemaMode) return {
 				valid: !schemaErrors?.value?.length,
-				data
+				data,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
 			else if (isEmpty($rules.value)) return {
 				valid: true,
-				data
+				data,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
-			const results = await Promise.allSettled(Object.values($rules.value).map((rule) => rule.$parse()));
-			const validationResults = results.every((value) => value.status === "fulfilled" && value.value === true);
 			return {
-				valid: validationResults,
-				data
+				valid: (await Promise.allSettled(Object.values($rules.value).map((rule) => rule.$parse()))).every((value) => value.status === "fulfilled" && value.value === true),
+				data,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
 		} catch {
 			return {
 				valid: false,
-				data: state.value
+				data: state.value,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
 		}
 	}
@@ -1319,7 +1330,8 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, cach
 		$unwatch,
 		$watch,
 		$extractDirtyFields,
-		$clearExternalErrors
+		$clearExternalErrors,
+		...createStandardSchema($validate)
 	});
 }
 
@@ -1357,8 +1369,7 @@ function createCollectionElement({ $id, path, cachePath, index, options, storage
 		schemaMode
 	});
 	if ($status) {
-		const valueId = stateValue.value?.$id;
-		$status.$id = valueId ?? String($fieldId);
+		$status.$id = stateValue.value?.$id ?? String($fieldId);
 		storage.addArrayStatus($id, $status.$id, $status);
 	}
 	return $status;
@@ -1372,7 +1383,7 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 	let immediateScope = effectScope();
 	let immediateScopeState;
 	let collectionScopes = [];
-	if (!Array.isArray(state.value) && !rulesDef.value.$each) return void 0;
+	if (!Array.isArray(state.value) && !rulesDef.value.$each) return;
 	const $id = ref();
 	const $value = ref(state.value);
 	const $localOptions = ref({});
@@ -1381,13 +1392,12 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 	const $selfStatus = ref({});
 	const $eachStatus = storage.getCollectionsEntry(path);
 	immediateScopeState = immediateScope.run(() => {
-		const isPrimitiveArray = computed(() => {
+		return { isPrimitiveArray: computed(() => {
 			if (!state.value?.length) return false;
 			if (Array.isArray(state.value) && state.value.length) return state.value.every((s) => typeof s !== "object");
 			else if (rulesDef.value.$each && !(rulesDef.value.$each instanceof Function)) return Object.values(rulesDef.value.$each).every((rule) => isRuleDef(rule) || typeof rule === "function");
 			return false;
-		});
-		return { isPrimitiveArray };
+		}) };
 	});
 	createStatus();
 	$watch();
@@ -1701,24 +1711,27 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 		});
 		if (!fromParent) createStatus();
 	}
-	async function $validate() {
+	async function $validate(forceValues) {
+		if (forceValues) state.value = forceValues;
 		const data = state.value;
 		try {
-			const results = await Promise.allSettled([$selfStatus.value.$validate(), ...$eachStatus.value.map((status) => {
-				return status.$validate();
-			})]);
-			const validationResults = results.every((value) => {
-				if (value.status === "fulfilled") return value.value.valid === true;
-				else return false;
-			});
 			return {
-				valid: validationResults,
-				data
+				valid: (await Promise.allSettled([$selfStatus.value.$validate(forceValues), ...$eachStatus.value.map((status) => {
+					return status.$validate();
+				})])).every((value) => {
+					if (value.status === "fulfilled") return value.value.valid === true;
+					else return false;
+				}),
+				data,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
-		} catch (e) {
+		} catch {
 			return {
 				valid: false,
-				data
+				data,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
 		}
 	}
@@ -1755,7 +1768,8 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 		$touch,
 		$reset,
 		$extractDirtyFields,
-		$clearExternalErrors
+		$clearExternalErrors,
+		...createStandardSchema($validate)
 	});
 }
 
@@ -1944,8 +1958,7 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", cachePath, roo
 					if (commonArgs.schemaMode) return fields.every(([_, statusOrField]) => statusOrField.$correct);
 					return fields.every(([_, statusOrField]) => {
 						if (!isFieldStatus(statusOrField)) return statusOrField?.$correct;
-						const hasRequiredRule = "required" in statusOrField.$rules && statusOrField.$rules.required.$active;
-						return hasRequiredRule ? statusOrField.$correct : !statusOrField.$invalid && !statusOrField.$pending && !statusOrField.$isDebouncing;
+						return "required" in statusOrField.$rules && statusOrField.$rules.required.$active ? statusOrField.$correct : !statusOrField.$invalid && !statusOrField.$pending && !statusOrField.$isDebouncing;
 					});
 				}
 				return false;
@@ -1973,9 +1986,9 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", cachePath, roo
 				if ($silent.value) return !($invalid.value || $pending.value);
 				return $anyDirty.value && !($invalid.value || $pending.value);
 			});
-			const $localPending$1 = ref(false);
+			const $localPending = ref(false);
 			const $pending = computed(() => {
-				if ($localPending$1.value) return true;
+				if ($localPending.value) return true;
 				const fields = $fields.value;
 				for (const key in fields) if (fields[key]?.$pending) return true;
 				return false;
@@ -2076,7 +2089,7 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", cachePath, roo
 				$silentValue,
 				$edited,
 				$anyEdited,
-				$localPending: $localPending$1,
+				$localPending,
 				$autoDirty,
 				$silent,
 				$value
@@ -2103,7 +2116,7 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", cachePath, roo
 		if (!fromParent) if (options?.toOriginalState) {
 			state.value = cloneDeep({ ...originalState });
 			initialState.value = cloneDeep({ ...originalState });
-		} else if (options?.toInitialState) state.value = cloneDeep({ ...initialState.value ?? {} });
+		} else if (options?.toInitialState) state.value = cloneDeep({ ...initialState.value });
 		else if (options?.toState) {
 			let newInitialState;
 			if (typeof options?.toState === "function") newInitialState = options?.toState();
@@ -2120,7 +2133,7 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", cachePath, roo
 		for (const field of Object.values($fields.value)) field?.$touch(runCommit, withConditions);
 	}
 	function filterNullishFields(fields) {
-		return fields.filter(([key, value]) => {
+		return fields.filter(([_, value]) => {
 			if (isObject(value)) return !(value && typeof value === "object" && "_null" in value) && !isEmpty(value);
 			else if (Array.isArray(value)) return value.length;
 			else return true;
@@ -2133,35 +2146,40 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", cachePath, roo
 		if (filterNullishValues) dirtyFields = filterNullishFields(dirtyFields);
 		return Object.fromEntries(dirtyFields);
 	}
-	async function $validate() {
+	async function $validate(forceValues) {
 		try {
+			if (forceValues) state.value = forceValues;
 			if (commonArgs.schemaMode) if (commonArgs.onValidate) {
 				$touch(false);
 				scopeState.$localPending.value = true;
 				return commonArgs.onValidate();
 			} else return {
 				valid: false,
-				data: state.value
+				data: state.value,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
 			else {
 				const data = state.value;
-				const results = await Promise.allSettled(Object.values($fields.value).map((statusOrField) => statusOrField.$validate()));
-				const validationResults = results.every((value) => value.status === "fulfilled" && value?.value.valid === true);
 				return {
-					valid: validationResults,
-					data
+					valid: (await Promise.allSettled(Object.values($fields.value).map((statusOrField) => statusOrField.$validate()))).every((value) => value.status === "fulfilled" && value?.value.valid === true),
+					data,
+					errors: scopeState.$errors.value,
+					issues: scopeState.$issues.value
 				};
 			}
-		} catch (e) {
+		} catch {
 			return {
 				valid: false,
-				data: state.value
+				data: state.value,
+				errors: scopeState.$errors.value,
+				issues: scopeState.$issues.value
 			};
 		} finally {
 			scopeState.$localPending.value = false;
 		}
 	}
-	const { $shortcuts, $localPending,...restScopeState } = scopeState;
+	const { $shortcuts, $localPending: _$localPending,...restScopeState } = scopeState;
 	const fullStatus = reactive({
 		...restScopeState,
 		...$shortcuts,
@@ -2175,10 +2193,11 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", cachePath, roo
 		$unwatch,
 		$watch,
 		$clearExternalErrors,
-		$extractDirtyFields
+		$extractDirtyFields,
+		...createStandardSchema($validate)
 	});
 	watchEffect(() => {
-		for (const key of Object.keys(fullStatus).filter((key$1) => !key$1.startsWith("$"))) delete fullStatus[key];
+		for (const key of Object.keys(fullStatus).filter((key$1) => !key$1.startsWith("$") && !key$1.startsWith("~"))) delete fullStatus[key];
 		for (const field of Object.values($fields.value)) if (field?.$name) Object.assign(fullStatus, { [field.$name]: field });
 	});
 	return fullStatus;
@@ -2196,8 +2215,7 @@ function createReactiveChildrenStatus({ rulesDef,...properties }) {
 		...properties
 	});
 	else {
-		const scope = effectScope();
-		const scopeState = scope.run(() => {
+		const scopeState = effectScope().run(() => {
 			const fakeState = toRef(properties.state.value ? properties.state : ref({}));
 			watch(() => properties.state.value, (value) => {
 				fakeState.value = value;
@@ -2207,7 +2225,7 @@ function createReactiveChildrenStatus({ rulesDef,...properties }) {
 			}, { deep: true });
 			return { fakeState };
 		});
-		const { state,...restProperties } = properties;
+		const { state: _state,...restProperties } = properties;
 		return createReactiveNestedStatus({
 			rulesDef,
 			...restProperties,
@@ -2218,7 +2236,6 @@ function createReactiveChildrenStatus({ rulesDef,...properties }) {
 		rulesDef: isRef(rulesDef.value) ? rulesDef.value : rulesDef,
 		...properties
 	});
-	return void 0;
 }
 
 //#endregion
@@ -2291,6 +2308,32 @@ function useRootStorage({ initialState, originalState, options, scopeRules, stat
 	return reactive({ regle });
 }
 
+//#endregion
+//#region src/core/useRegle/shared.rootRegle.ts
+function createRootRegleLogic({ state, rulesFactory, options, globalOptions, customRules, shortcuts }) {
+	const definedRules = isRef(rulesFactory) ? rulesFactory : typeof rulesFactory === "function" ? void 0 : computed(() => rulesFactory);
+	const resolvedOptions = {
+		...globalOptions,
+		...options
+	};
+	const watchableRulesGetters = shallowRef(definedRules ?? {});
+	if (typeof rulesFactory === "function") watchEffect(() => {
+		watchableRulesGetters.value = rulesFactory(state);
+		triggerRef(watchableRulesGetters);
+	});
+	const initialState = ref(isObject(state.value) ? { ...cloneDeep(state.value) } : cloneDeep(state.value));
+	const originalState = isObject(state.value) ? { ...cloneDeep(state.value) } : cloneDeep(state.value);
+	return useRootStorage({
+		scopeRules: watchableRulesGetters,
+		state,
+		options: resolvedOptions,
+		initialState,
+		originalState,
+		customRules,
+		shortcuts
+	});
+}
+
 //#endregion
 //#region src/core/useRegle/useRegle.ts
 function createUseRegleComposable(customRules, options, shortcuts) {
@@ -2302,29 +2345,15 @@ function createUseRegleComposable(customRules, options, shortcuts) {
 		clearExternalErrorsOnChange: options?.clearExternalErrorsOnChange
 	};
 	function useRegle$1(state, rulesFactory, options$1) {
-		const definedRules = isRef(rulesFactory) ? rulesFactory : typeof rulesFactory === "function" ? void 0 : computed(() => rulesFactory);
-		const resolvedOptions = {
-			...globalOptions,
-			...options$1
-		};
 		const processedState = isRef(state) ? state : ref(state);
-		const watchableRulesGetters = shallowRef(definedRules ?? {});
-		if (typeof rulesFactory === "function") watchEffect(() => {
-			watchableRulesGetters.value = rulesFactory(processedState);
-			triggerRef(watchableRulesGetters);
-		});
-		const initialState = ref(isObject(processedState.value) ? { ...cloneDeep(processedState.value) } : cloneDeep(processedState.value));
-		const originalState = isObject(processedState.value) ? { ...cloneDeep(processedState.value) } : cloneDeep(processedState.value);
-		const regle = useRootStorage({
-			scopeRules: watchableRulesGetters,
+		return { r$: createRootRegleLogic({
 			state: processedState,
-			options: resolvedOptions,
-			initialState,
-			originalState,
+			rulesFactory,
+			options: options$1,
+			globalOptions,
 			customRules,
 			shortcuts
-		});
-		return { r$: regle.regle };
+		}).regle };
 	}
 	return useRegle$1;
 }
@@ -2366,6 +2395,60 @@ function createInferRuleHelper() {
 */
 const inferRules = createInferRuleHelper();
 
+//#endregion
+//#region src/core/useRegle/useRules.ts
+function createEmptyRuleState(rules) {
+	const result = {};
+	if (Object.entries(rules).some(([_, rule]) => isRuleDef(rule) || typeof rule === "function")) return null;
+	for (const key in rules) {
+		const item = rules[key];
+		if (!!item && isObject(item) && "$each" in item && item["$each"] && isObject(item["$each"])) result[key] = [createEmptyRuleState(item["$each"])];
+		else if (isObject(item) && !isEmpty(item) && !Object.entries(item).some(([_, rule]) => isRuleDef(rule) || typeof rule === "function")) result[key] = createEmptyRuleState(item);
+		else result[key] = null;
+	}
+	return result;
+}
+function createUseRulesComposable(customRules, options, shortcuts) {
+	const globalOptions = {
+		autoDirty: options?.autoDirty,
+		lazy: options?.lazy,
+		rewardEarly: options?.rewardEarly,
+		silent: options?.silent,
+		clearExternalErrorsOnChange: options?.clearExternalErrorsOnChange
+	};
+	function useRules$1(rulesFactory, options$1) {
+		const definedRules = isRef(rulesFactory) ? rulesFactory : typeof rulesFactory === "function" ? void 0 : computed(() => rulesFactory);
+		const processedState = ref(createEmptyRuleState(definedRules?.value));
+		return createRootRegleLogic({
+			state: processedState,
+			rulesFactory: definedRules,
+			options: options$1,
+			globalOptions,
+			customRules,
+			shortcuts
+		}).regle;
+	}
+	return useRules$1;
+}
+/**
+* useRules is a clone of useRegle, without the need to provide a state.
+*
+* It accepts the following inputs:
+*
+* @param rules - Your rules object
+* @param modifiers - Customize regle behaviour
+* 
+* ```ts
+* import { useRules } from '@regle/core';
+import { required } from '@regle/rules';
+
+const { r$ } = useRules({
+email: { required }
+})
+* ```
+*/
+const useRules = createUseRulesComposable();
+
 //#endregion
 //#region src/core/defineRegleConfig.ts
 /**
@@ -2382,15 +2465,22 @@ const inferRules = createInferRuleHelper();
 */
 function defineRegleConfig({ rules, modifiers, shortcuts }) {
 	const useRegle$1 = createUseRegleComposable(rules, modifiers, shortcuts);
+	const useRules$1 = createUseRulesComposable(rules, modifiers, shortcuts);
 	useRegle$1.__config = {
 		rules,
 		modifiers,
 		shortcuts
 	};
+	useRules$1.__config = {
+		rules,
+		modifiers,
+		shortcuts
+	};
 	const inferRules$1 = createInferRuleHelper();
 	return {
 		useRegle: useRegle$1,
-		inferRules: inferRules$1
+		inferRules: inferRules$1,
+		useRules: useRules$1
 	};
 }
 /**
@@ -2481,6 +2571,22 @@ function mergeRegles(regles, _scoped) {
 			return regle?.$pending;
 		});
 	});
+	const $issues = computed(() => {
+		if (scoped) return Object.entries(regles).map(([_, regle]) => {
+			return regle.$issues;
+		});
+		else return Object.fromEntries(Object.entries(regles).map(([key, regle]) => {
+			return [key, regle.$issues];
+		}));
+	});
+	const $silentIssues = computed(() => {
+		if (scoped) return Object.entries(regles).map(([_, regle]) => {
+			return regle.$silentIssues;
+		});
+		else return Object.fromEntries(Object.entries(regles).map(([key, regle]) => {
+			return [key, regle.$silentIssues];
+		}));
+	});
 	const $errors = computed(() => {
 		if (scoped) return Object.entries(regles).map(([_, regle]) => {
 			return regle.$errors;
@@ -2530,30 +2636,35 @@ function mergeRegles(regles, _scoped) {
 			regle.$clearExternalErrors();
 		});
 	}
-	async function $validate() {
+	async function $validate(forceValues) {
 		try {
+			if (forceValues) $value.value = forceValues;
 			const data = $value.value;
-			const results = await Promise.allSettled(Object.values(regles).map((regle) => {
-				return regle.$validate();
-			}));
-			const validationResults = results.every((value) => {
-				if (value.status === "fulfilled") return value.value.valid === true;
-				else return false;
-			});
 			return {
-				valid: validationResults,
-				data
+				valid: (await Promise.allSettled(Object.values(regles).map((regle) => {
+					return regle.$validate();
+				}))).every((value) => {
+					if (value.status === "fulfilled") return value.value.valid === true;
+					else return false;
+				}),
+				data,
+				errors: $errors.value,
+				issues: $issues.value
 			};
-		} catch (e) {
+		} catch {
 			return {
 				valid: false,
-				data: $value.value
+				data: $value.value,
+				errors: $errors.value,
+				issues: $issues.value
 			};
 		}
 	}
 	return reactive({
 		...!scoped && { $silentValue },
 		$errors,
+		$issues,
+		$silentIssues,
 		$silentErrors,
 		$instances,
 		$value,
@@ -2605,7 +2716,7 @@ function createUseCollectScope(instances, options) {
 function createUseScopedRegleComposable(instances, customUseRegle) {
 	const scopedUseRegle = customUseRegle ?? useRegle;
 	const useScopedRegle$1 = ((state, rulesFactory, options) => {
-		const { namespace, scopeKey,...restOptions } = options ?? {};
+		const { namespace, scopeKey: _scopeKey,...restOptions } = options ?? {};
 		scopedUseRegle.__config ??= {};
 		const computedNamespace = computed(() => toValue(namespace));
 		const $id = ref(`${Object.keys(instances.value).length + 1}-${randomId()}`);
@@ -2652,17 +2763,15 @@ function createUseScopedRegleComposable(instances, customUseRegle) {
 //#endregion
 //#region src/core/createScopedUseRegle/createScopedUseRegle.ts
 function createScopedUseRegle(options) {
-	const useInstances = options?.customStore ? () => {
+	const instances = (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();
+		return ref({ "~~global": {} });
+	}))();
 	const { useScopedRegle: useScopedRegle$1 } = createUseScopedRegleComposable(instances, options?.customUseRegle);
 	const { useCollectScope: useCollectScope$1 } = createUseCollectScope(instances, { asRecord: options?.asRecord });
 	return {
@@ -2696,7 +2805,7 @@ const { useCollectScope, useScopedRegle } = createScopedUseRegle();
 */
 function createVariant(root, discriminantKey, variants) {
 	const watchableRoot = computed(() => toValue(root)[discriminantKey]);
-	const computedRules = computed(() => {
+	return computed(() => {
 		const selectedVariant = variants.find((variant) => {
 			if (variant[discriminantKey] && "literal" in variant[discriminantKey]) {
 				const literalRule = variant[discriminantKey]["literal"];
@@ -2710,7 +2819,6 @@ function createVariant(root, discriminantKey, variants) {
 			else return {};
 		}
 	});
-	return computedRules;
 }
 /**
 * Narrow a nested variant field to a discriminated value
@@ -2781,4 +2889,4 @@ function refineRules(rules, refinement) {
 }
 
 //#endregion
-export { InternalRuleType, createRule, createScopedUseRegle, createVariant, defineRegleConfig, defineRules, extendRegleConfig, flatErrors, inferRules, mergeRegles, narrowVariant, refineRules, unwrapRuleParameters, useCollectScope, useRegle, useRootStorage, useScopedRegle, variantToRef };
+export { InternalRuleType, createRule, createScopedUseRegle, createVariant, defineRegleConfig, defineRules, extendRegleConfig, flatErrors, inferRules, mergeRegles, narrowVariant, refineRules, unwrapRuleParameters, useCollectScope, useRegle, useRootStorage, useRules, useScopedRegle, variantToRef };