@regle/core 1.4.0-beta.2 → 1.4.1-beta.1

package/dist/regle-core.js

@@ -211,8 +211,8 @@ function getFunctionParametersLength(func) {
 //#endregion
 //#region src/core/createRule/defineRuleProcessors.ts
 function defineRuleProcessors(definition, ...params) {
-	const { validator, type } = definition;
-	const isAsync = type === InternalRuleType.Async || validator.constructor.name === "AsyncFunction";
+	const { validator, type, async } = definition;
+	const isAsync = async || type === InternalRuleType.Async || validator.constructor.name === "AsyncFunction";
 	const defaultProcessors = {
 		validator(value, ...args) {
 			return definition.validator(value, ...unwrapRuleParameters(args.length ? args : params));
@@ -255,6 +255,7 @@ function defineRuleProcessors(definition, ...params) {
 	};
 	const processors = markRaw({
 		...defaultProcessors,
+		type,
 		_validator: definition.validator,
 		_message: definition.message,
 		_active: definition.active,
@@ -305,8 +306,11 @@ function defineRuleProcessors(definition, ...params) {
 function createRule(definition) {
 	if (typeof definition.validator === "function") {
 		let fakeParams = [];
-		const staticProcessors = defineRuleProcessors(definition, ...fakeParams);
 		const isAsync = definition.async ?? definition.validator.constructor.name === "AsyncFunction";
+		const staticProcessors = defineRuleProcessors({
+			...definition,
+			async: isAsync
+		}, ...fakeParams);
 		if (getFunctionParametersLength(definition.validator) > 1) {
 			const ruleFactory = function(...params) {
 				return defineRuleProcessors(definition, ...params);
@@ -577,28 +581,41 @@ function extractRulesIssues({ field, silent = false }) {
 			$message: message,
 			$property: field.fieldName,
 			$rule: key,
-			$type: rule.$type
+			$type: rule.$type,
+			...typeof rule.$metadata === "object" ? rule.$metadata : {}
 		};
 		return issue;
 	});
-	return issues.filter((msg) => !!msg).reduce((acc, issue) => {
-		if (typeof issue.$message === "string") return acc?.concat([issue]);
-		else return acc?.concat(issue.$message.map((msg) => ({
+	const filteredIssues = issues.filter((msg) => !!msg);
+	const ruleIssues = filteredIssues.reduce((acc, issue) => {
+		if (typeof issue.$message === "string") acc.push(issue);
+		else acc.push(...issue.$message.map((msg) => ({
 			...issue,
 			$message: msg
 		})));
-	}, []).concat(field.$error ? field.$externalErrors?.map((error) => ({
+		return acc;
+	}, []);
+	const externalIssues = field.$error && field.$externalErrors ? field.$externalErrors.map((error) => ({
 		$message: error,
 		$property: field.fieldName,
 		$rule: "external",
 		$type: void 0
-	})) ?? [] : []).concat(field.$error ? field.$schemaErrors ?? [] : []);
+	})) : [];
+	const schemaIssues = field.$error ? field.$schemaErrors ?? [] : [];
+	return [
+		...ruleIssues,
+		...externalIssues,
+		...schemaIssues
+	];
 }
 function extractRulesTooltips({ field }) {
-	return Object.entries(field.$rules ?? {}).map(([_, rule]) => rule.$tooltip).filter((tooltip) => !!tooltip).reduce((acc, value) => {
-		if (typeof value === "string") return acc?.concat([value]);
-		else return acc?.concat(value);
-	}, []);
+	const tooltips = [];
+	for (const rule of Object.values(field.$rules ?? {})) {
+		const tooltip = rule.$tooltip;
+		if (tooltip) if (typeof tooltip === "string") tooltips.push(tooltip);
+		else tooltips.push(...tooltip);
+	}
+	return tooltips;
 }
 function isCollectionError(errors) {
 	return isObject(errors) && "$each" in errors;
@@ -635,13 +652,13 @@ function iterateErrors(errors, includePath = false, _path) {
 
 //#endregion
 //#region src/core/useRegle/root/createReactiveRuleStatus.ts
-function createReactiveRuleStatus({ customMessages, rule, ruleKey, state, path, storage, $debounce, modifiers }) {
+function createReactiveRuleStatus({ customMessages, rule, ruleKey, state, path, cachePath, storage, $debounce, modifiers }) {
 	let scope = effectScope();
 	let scopeState = {};
 	let $unwatchState;
 	const $haveAsync = ref(false);
 	const $maybePending = ref(false);
-	const { $pending, $valid, $metadata, $validating } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
+	const { $pending, $valid, $metadata, $validating } = storage.trySetRuleStatusRef(`${cachePath}.${ruleKey}`);
 	function $watch() {
 		scope = effectScope();
 		scopeState = scope.run(() => {
@@ -811,70 +828,71 @@ function createReactiveRuleStatus({ customMessages, rule, ruleKey, state, path,
 
 //#endregion
 //#region src/core/useRegle/root/createReactiveFieldStatus.ts
-function createReactiveFieldStatus({ state, rulesDef, customMessages, path, fieldName, storage, options, externalErrors, schemaErrors, schemaMode, onUnwatch, $isArray, initialState, shortcuts, onValidate }) {
+function createReactiveFieldStatus({ state, rulesDef, customMessages, path, cachePath, fieldName, storage, options, externalErrors, schemaErrors, schemaMode, onUnwatch, $isArray, initialState, shortcuts, onValidate }) {
 	let scope = effectScope();
 	let scopeState;
 	let fieldScopes = [];
 	let $unwatchState;
-	let $unwatchValid;
 	let $unwatchDirty;
 	let $unwatchAsync;
 	let $unwatchRuleFieldValues;
 	let $commit = () => {};
 	function createReactiveRulesResult() {
 		const declaredRules = rulesDef.value;
-		const storeResult = storage.checkRuleDeclEntry(path, declaredRules);
-		$localOptions.value = Object.fromEntries(Object.entries(declaredRules).filter(([ruleKey]) => ruleKey.startsWith("$")));
+		const storeResult = storage.checkRuleDeclEntry(cachePath, declaredRules);
+		const options$1 = {};
+		for (const key in declaredRules) if (key.startsWith("$")) options$1[key] = declaredRules[key];
+		$localOptions.value = options$1;
 		$watch();
-		$rules.value = Object.fromEntries(Object.entries(rulesDef.value).filter(([ruleKey]) => !ruleKey.startsWith("$")).map(([ruleKey, rule]) => {
-			if (rule) {
-				const ruleRef = toRef(() => rule);
-				return [ruleKey, createReactiveRuleStatus({
-					modifiers: {
-						$silent: scopeState.$silent,
-						$rewardEarly: scopeState.$rewardEarly
-					},
-					customMessages,
-					rule: ruleRef,
-					ruleKey,
-					state,
-					path,
-					storage,
-					$debounce: $localOptions.value.$debounce
-				})];
-			}
-			return [];
-		}).filter((ruleDef) => !!ruleDef.length));
+		const rules = rulesDef.value;
+		const entries = [];
+		for (const ruleKey in rules) {
+			if (ruleKey.startsWith("$")) continue;
+			const rule = rules[ruleKey];
+			if (!rule) continue;
+			const ruleRef = toRef(() => rule);
+			entries.push([ruleKey, createReactiveRuleStatus({
+				modifiers: {
+					$silent: scopeState.$silent,
+					$rewardEarly: scopeState.$rewardEarly
+				},
+				customMessages,
+				rule: ruleRef,
+				ruleKey,
+				state,
+				path,
+				cachePath,
+				storage,
+				$debounce: $localOptions.value.$debounce
+			})]);
+		}
+		$rules.value = Object.fromEntries(entries);
 		scopeState.processShortcuts();
 		define$commit();
 		if (storeResult?.valid != null) {
-			scopeState.$dirty.value = storage.getDirtyState(path);
+			scopeState.$dirty.value = storage.getDirtyState(cachePath);
 			if (scopeState.$dirty.value && !scopeState.$silent.value || scopeState.$rewardEarly.value && scopeState.$error.value) $commit();
 		}
-		storage.addRuleDeclEntry(path, declaredRules);
+		storage.addRuleDeclEntry(cachePath, declaredRules);
 	}
 	function define$commit() {
 		$commit = scopeState.$debounce.value ? debounce($commitHandler, scopeState.$debounce.value ?? scopeState.$haveAnyAsyncRule ? 100 : 0) : $commitHandler;
 	}
 	function $unwatch() {
-		if ($rules.value) Object.entries($rules.value).forEach(([_, rule]) => {
-			rule.$unwatch();
-		});
+		if ($rules.value) for (const rule of Object.values($rules.value)) rule.$unwatch();
 		$unwatchDirty();
 		$unwatchRuleFieldValues?.();
-		if (scopeState.$dirty.value) storage.setDirtyEntry(path, scopeState.$dirty.value);
+		if (scopeState.$dirty.value) storage.setDirtyEntry(cachePath, scopeState.$dirty.value);
 		$unwatchState?.();
 		scope.stop();
 		scope = effectScope();
-		fieldScopes.forEach((s) => s.stop());
+		for (const s of fieldScopes) s.stop();
 		fieldScopes = [];
 		onUnwatch?.();
 		$unwatchAsync?.();
 	}
 	function $watch() {
-		if ($rules.value) Object.entries($rules.value).forEach(([_, rule]) => {
-			rule.$watch();
-		});
+		if ($rules.value) for (const rule of Object.values($rules.value)) rule.$watch();
 		scopeState = scope.run(() => {
 			const $dirty = ref(false);
 			const triggerPunishment = ref(false);
@@ -914,9 +932,8 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, fiel
 				return true;
 			});
 			const $validating$1 = computed(() => {
-				return Object.entries($rules.value).some(([key, ruleResult]) => {
-					return ruleResult.$validating;
-				});
+				for (const ruleResult of Object.values($rules.value)) if (ruleResult.$validating) return true;
+				return false;
 			});
 			const $silentValue = computed({
 				get: () => state.value,
@@ -982,34 +999,28 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, fiel
 			const $invalid = computed(() => {
 				if (externalErrors?.value?.length || schemaErrors?.value?.length) return true;
 				else if ($inactive.value) return false;
-				else if (!$rewardEarly$1.value || $rewardEarly$1.value) {
-					const result = Object.entries($rules.value).some(([_, ruleResult]) => {
-						return !(ruleResult.$valid && !ruleResult.$maybePending);
-					});
-					return result;
-				}
+				else if (!$rewardEarly$1.value || $rewardEarly$1.value) return Object.values($rules.value).some((ruleResult) => !ruleResult.$valid || ruleResult.$maybePending);
 				return false;
 			});
 			const $name = computed(() => fieldName);
 			const $inactive = computed(() => {
-				if (Object.keys(rulesDef.value).filter(([ruleKey]) => !ruleKey.startsWith("$")).length === 0 && !schemaMode) return true;
-				return false;
+				return !schemaMode && !Object.keys(rulesDef.value).some((key) => !key.startsWith("$"));
 			});
 			const $correct = computed(() => {
 				if (externalErrors?.value?.length) return false;
 				else if ($inactive.value) return false;
 				else if ($dirty.value && !isEmpty(state.value) && !$validating$1.value && !$pending.value) if (schemaMode) return !schemaErrors?.value?.length;
 				else {
-					const atLeastOneActiveRule = Object.values($rules.value).some((ruleResult) => ruleResult.$active);
-					if (atLeastOneActiveRule) return Object.values($rules.value).filter((ruleResult) => ruleResult.$active).every((ruleResult) => ruleResult.$valid);
-					else return false;
+					const rules = Object.values($rules.value);
+					for (const rule of rules) if (rule.$active) {
+						if (!rule.$valid) return false;
+					}
+					return rules.some((rule) => rule.$active);
 				}
 				return false;
 			});
 			const $haveAnyAsyncRule$1 = computed(() => {
-				return Object.entries($rules.value).some(([key, ruleResult]) => {
-					return ruleResult.$haveAsync;
-				});
+				return Object.values($rules.value).some((rule) => rule.$haveAsync);
 			});
 			function processShortcuts() {
 				if (shortcuts?.fields) Object.entries(shortcuts.fields).forEach(([key, value]) => {
@@ -1077,7 +1088,7 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, fiel
 		});
 		define$watchState();
 		$unwatchDirty = watch(scopeState.$dirty, (newDirty) => {
-			storage.setDirtyEntry(path, newDirty);
+			storage.setDirtyEntry(cachePath, newDirty);
 			Object.values($rules.value).forEach((rule) => {
 				rule.$fieldDirty = newDirty;
 			});
@@ -1118,7 +1129,7 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, fiel
 	function $reset(options$1, fromParent) {
 		$clearExternalErrors();
 		scopeState.$dirty.value = false;
-		storage.setDirtyEntry(path, false);
+		storage.setDirtyEntry(cachePath, false);
 		if (!fromParent) if (options$1?.toInitialState) state.value = cloneDeep(initialState.value);
 		else if (options$1?.toState) {
 			let newInitialState;
@@ -1128,12 +1139,8 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, fiel
 			state.value = cloneDeep(newInitialState);
 		} else initialState.value = isObject(state.value) ? cloneDeep(state.value) : Array.isArray(state.value) ? [...state.value] : state.value;
 		if (options$1?.clearExternalErrors) $clearExternalErrors();
-		if (!fromParent) Object.entries($rules.value).forEach(([_, rule]) => {
-			rule.$reset();
-		});
-		if (!scopeState.$lazy.value && !scopeState.$silent.value && !fromParent) Object.values($rules.value).forEach((rule) => {
-			return rule.$parse();
-		});
+		if (!fromParent) for (const rule of Object.values($rules.value)) rule.$reset();
+		if (!scopeState.$lazy.value && !scopeState.$silent.value && !fromParent) for (const rule of Object.values($rules.value)) rule.$parse();
 	}
 	function $touch(runCommit = true, withConditions = false) {
 		if (!scopeState.$dirty.value) scopeState.$dirty.value = true;
@@ -1164,13 +1171,8 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, fiel
 				valid: true,
 				data
 			};
-			const results = await Promise.allSettled(Object.entries($rules.value).map(([key, rule]) => {
-				return rule.$parse();
-			}));
-			const validationResults = results.every((value) => {
-				if (value.status === "fulfilled") return value.value === true;
-				else return false;
-			});
+			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
@@ -1198,6 +1200,7 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, fiel
 		$value: state,
 		$rules,
 		...$shortcuts,
+		$path: path,
 		$reset,
 		$touch,
 		$validate,
@@ -1210,16 +1213,17 @@ function createReactiveFieldStatus({ state, rulesDef, customMessages, path, fiel
 
 //#endregion
 //#region src/core/useRegle/root/collections/createReactiveCollectionElement.ts
-function createCollectionElement({ $id, path, index, options, storage, stateValue, customMessages, rules, externalErrors, schemaErrors, initialState, shortcuts, fieldName, schemaMode }) {
+function createCollectionElement({ $id, path, cachePath, index, options, storage, stateValue, customMessages, rules, externalErrors, schemaErrors, initialState, shortcuts, fieldName, schemaMode }) {
 	const $fieldId = rules.$key ? rules.$key : randomId();
-	let $path = `${path}.${String($fieldId)}`;
+	let $cachePath = `${path}.${String($fieldId)}`;
+	let $path = `${path}.${index}`;
 	if (typeof stateValue.value === "object" && stateValue.value != null) if (!stateValue.value.$id) Object.defineProperties(stateValue.value, { $id: {
 		value: $fieldId,
 		enumerable: false,
 		configurable: false,
 		writable: false
 	} });
-	else $path = `${path}.${stateValue.value.$id}`;
+	else $cachePath = `${path}.${stateValue.value.$id}`;
 	const $externalErrors = toRef(externalErrors?.value ?? [], index);
 	const $schemaErrors = computed(() => schemaErrors?.value?.[index]);
 	const $status = createReactiveChildrenStatus({
@@ -1227,6 +1231,7 @@ function createCollectionElement({ $id, path, index, options, storage, stateValu
 		rulesDef: toRef(() => rules),
 		customMessages,
 		path: $path,
+		cachePath: $cachePath,
 		storage,
 		options,
 		externalErrors: $externalErrors,
@@ -1294,6 +1299,7 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 			const element = createCollectionElement({
 				$id: $id.value,
 				path,
+				cachePath: path,
 				customMessages,
 				rules: unwrapped ?? {},
 				stateValue: toRef(() => value),
@@ -1316,6 +1322,7 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 			rulesDef,
 			customMessages,
 			path,
+			cachePath: path,
 			storage,
 			options,
 			externalErrors: toRef(externalErrors?.value ?? {}, `$self`),
@@ -1347,6 +1354,7 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 					const element = createCollectionElement({
 						$id: $id.value,
 						path,
+						cachePath: path,
 						customMessages,
 						rules: unwrapped ?? {},
 						stateValue: currentValue,
@@ -1437,6 +1445,12 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 					return statusOrField.$anyEdited;
 				});
 			});
+			const $issues = computed(() => {
+				return {
+					$self: $selfStatus.value.$issues,
+					$each: $eachStatus.value.map(($each) => $each.$issues)
+				};
+			});
 			const $errors = computed(() => {
 				return {
 					$self: $selfStatus.value.$errors,
@@ -1475,20 +1489,22 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 							result.value = value(reactive({
 								$dirty,
 								$error,
+								$path: path,
 								$silentValue,
 								$pending,
 								$invalid,
 								$correct,
 								$errors,
-								$ready,
 								$silentErrors,
+								$ready,
 								$anyDirty,
 								$name,
 								$each: $eachStatus,
 								$self: $selfStatus,
 								$value: state,
 								$edited,
-								$anyEdited
+								$anyEdited,
+								$issues
 							}));
 						});
 						return result;
@@ -1515,7 +1531,8 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 				$anyEdited,
 				$rewardEarly,
 				$silent,
-				$autoDirty
+				$autoDirty,
+				$issues
 			};
 		});
 		if (immediateScopeState.isPrimitiveArray.value && rulesDef.value.$each) console.warn(`${path} is a Array of primitives. Tracking can be lost when reassigning the Array. We advise to use an Array of objects instead`);
@@ -1599,6 +1616,7 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 		$self: $selfStatus,
 		...restScopeState,
 		...$shortcuts,
+		$path: path,
 		$each: $eachStatus,
 		$value: state,
 		$validate,
@@ -1613,7 +1631,7 @@ function createReactiveCollectionStatus({ state, rulesDef, customMessages, path,
 
 //#endregion
 //#region src/core/useRegle/root/createReactiveNestedStatus.ts
-function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, externalErrors, schemaErrors, rootSchemaErrors, validationGroups, initialState, fieldName,...commonArgs }) {
+function createReactiveNestedStatus({ rulesDef, state, path = "", cachePath, rootRules, externalErrors, schemaErrors, rootSchemaErrors, validationGroups, initialState, fieldName,...commonArgs }) {
 	let scope = effectScope();
 	let scopeState;
 	let nestedScopes = [];
@@ -1624,35 +1642,38 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 	let $unwatchGroups = null;
 	async function createReactiveFieldsStatus(watchSources = true) {
 		const mapOfRulesDef = Object.entries(rulesDef.value);
-		const scopedRulesStatus = Object.fromEntries(mapOfRulesDef.filter(([_, rule]) => !!rule).map(([statePropKey, statePropRules]) => {
-			if (statePropRules) {
-				const stateRef = toRef(state.value ?? {}, statePropKey);
-				const statePropRulesRef = toRef(() => statePropRules);
-				const $externalErrors = toRef(externalErrors?.value ?? {}, statePropKey);
-				const $schemaErrors = computed(() => schemaErrors?.value?.[statePropKey]);
-				const initialStateRef = toRef(initialState?.value ?? {}, statePropKey);
-				return [statePropKey, createReactiveChildrenStatus({
-					state: stateRef,
-					rulesDef: statePropRulesRef,
-					path: path ? `${path}.${statePropKey}` : statePropKey,
-					externalErrors: $externalErrors,
-					schemaErrors: $schemaErrors,
-					initialState: initialStateRef,
-					fieldName: statePropKey,
-					...commonArgs
-				})];
-			}
-			return [];
-		}));
+		const scopedRulesStatus = Object.fromEntries(mapOfRulesDef.reduce((acc, [statePropKey, statePropRules]) => {
+			if (!statePropRules) return acc;
+			const stateRef = toRef(state.value ?? {}, statePropKey);
+			const statePropRulesRef = toRef(() => statePropRules);
+			const $externalErrors = toRef(externalErrors?.value ?? {}, statePropKey);
+			const $schemaErrors = computed(() => schemaErrors?.value?.[statePropKey]);
+			const initialStateRef = toRef(initialState?.value ?? {}, statePropKey);
+			acc.push([statePropKey, createReactiveChildrenStatus({
+				state: stateRef,
+				rulesDef: statePropRulesRef,
+				path: path ? `${path}.${statePropKey}` : statePropKey,
+				cachePath: cachePath ? `${cachePath}.${statePropKey}` : statePropKey,
+				externalErrors: $externalErrors,
+				schemaErrors: $schemaErrors,
+				initialState: initialStateRef,
+				fieldName: statePropKey,
+				...commonArgs
+			})]);
+			return acc;
+		}, []));
 		const externalRulesStatus = Object.fromEntries(Object.entries(unref(externalErrors) ?? {}).filter(([key, errors]) => !(key in rulesDef.value) && !!errors).map(([key]) => {
 			const stateRef = toRef(state.value ?? {}, key);
 			const $externalErrors = toRef(externalErrors?.value ?? {}, key);
 			const $schemaErrors = computed(() => schemaErrors?.value?.[key]);
 			const initialStateRef = toRef(initialState?.value ?? {}, key);
+			const computedPath = path ? `${path}.${key}` : key;
+			const computedCachePath = cachePath ? `${cachePath}.${key}` : key;
 			return [key, createReactiveChildrenStatus({
 				state: stateRef,
 				rulesDef: computed(() => ({})),
-				path: path ? `${path}.${key}` : key,
+				path: computedPath,
+				cachePath: computedCachePath,
 				externalErrors: $externalErrors,
 				schemaErrors: $schemaErrors,
 				initialState: initialStateRef,
@@ -1661,14 +1682,18 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 			})];
 		}));
 		const schemasRulesStatus = Object.fromEntries(Object.entries(unref(schemaErrors) ?? {}).map(([key]) => {
+			const computedPath = path ? `${path}.${key}` : key;
+			const computedCachePath = cachePath ? `${cachePath}.${key}` : key;
 			const stateRef = toRef(state.value ?? {}, key);
 			const $externalErrors = toRef(externalErrors?.value ?? {}, key);
 			const $schemaErrors = computed(() => schemaErrors?.value?.[key]);
 			const initialStateRef = toRef(initialState?.value ?? {}, key);
+			const emptyRulesDef = computed(() => ({}));
 			return [key, createReactiveChildrenStatus({
 				state: stateRef,
-				rulesDef: computed(() => ({})),
-				path: path ? `${path}.${key}` : key,
+				rulesDef: emptyRulesDef,
+				path: computedPath,
+				cachePath: computedCachePath,
 				externalErrors: $externalErrors,
 				schemaErrors: $schemaErrors,
 				initialState: initialStateRef,
@@ -1685,6 +1710,7 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 				state: stateRef,
 				rulesDef: computed(() => ({})),
 				path: path ? `${path}.${key}` : key,
+				cachePath: cachePath ? `${cachePath}.${key}` : key,
 				externalErrors: $externalErrors,
 				schemaErrors: $schemaErrors,
 				initialState: initialStateRef,
@@ -1757,39 +1783,44 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 				}
 			});
 			const $dirty = computed(() => {
-				return !!Object.entries($fields.value).length && Object.entries($fields.value).every(([_, statusOrField]) => {
-					return statusOrField?.$dirty;
-				});
+				const fields = $fields.value;
+				const fieldKeys = Object.keys(fields);
+				if (!fieldKeys.length) return false;
+				for (const key of fieldKeys) if (!fields[key]?.$dirty) return false;
+				return true;
 			});
 			const $anyDirty = computed(() => {
-				return Object.entries($fields.value).some(([_, statusOrField]) => {
-					return statusOrField?.$anyDirty;
-				});
+				const fields = $fields.value;
+				for (const key in fields) if (fields[key]?.$anyDirty) return true;
+				return false;
 			});
 			const $invalid = computed(() => {
-				return !!Object.entries($fields.value).length && Object.entries($fields.value).some(([_, statusOrField]) => {
-					return statusOrField?.$invalid;
-				});
+				const fields = $fields.value;
+				const entries = Object.entries(fields);
+				if (!entries.length) return false;
+				for (const [_, statusOrField] of entries) if (statusOrField?.$invalid) return true;
+				return false;
 			});
 			const $correct = computed(() => {
-				const fields = Object.entries($fields.value).filter(([_, statusOrField]) => {
-					if (isFieldStatus(statusOrField)) return !statusOrField.$inactive;
-					return true;
-				});
-				if (fields.length) return fields.every(([_, statusOrField]) => {
-					if (commonArgs.schemaMode) return statusOrField.$correct;
-					else if (isFieldStatus(statusOrField)) {
-						if ("required" in statusOrField.$rules && statusOrField.$rules.required.$active) return statusOrField?.$correct;
-						return !statusOrField.$invalid && !statusOrField.$pending;
-					}
-					return statusOrField?.$correct;
-				});
+				const fields = Object.entries($fields.value).reduce((acc, [key, statusOrField]) => {
+					if (!isFieldStatus(statusOrField) || !statusOrField.$inactive) acc.push([key, statusOrField]);
+					return acc;
+				}, []);
+				if (fields.length) {
+					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;
+					});
+				}
 				return false;
 			});
 			const $error = computed(() => {
-				return !!Object.entries($fields.value).length && Object.entries($fields.value).some(([_, statusOrField]) => {
-					return statusOrField?.$error;
-				});
+				const fields = $fields.value;
+				if (!Object.keys(fields).length) return false;
+				for (const key in fields) if (fields[key]?.$error) return true;
+				return false;
 			});
 			const $rewardEarly = computed(() => {
 				if (unref(commonArgs.options.rewardEarly) != null) return unref(commonArgs.options.rewardEarly);
@@ -1810,29 +1841,34 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 			});
 			const $localPending$1 = ref(false);
 			const $pending = computed(() => {
-				return $localPending$1.value || Object.entries($fields.value).some(([key, statusOrField]) => {
-					return statusOrField?.$pending;
-				});
+				if ($localPending$1.value) return true;
+				const fields = $fields.value;
+				for (const key in fields) if (fields[key]?.$pending) return true;
+				return false;
+			});
+			const $issues = computed(() => {
+				const result = {};
+				for (const key in $fields.value) result[key] = $fields.value[key]?.$issues;
+				return result;
 			});
 			const $errors = computed(() => {
-				return Object.fromEntries(Object.entries($fields.value).map(([key, statusOrField]) => {
-					return [key, statusOrField?.$errors];
-				}));
+				const result = {};
+				for (const key in $fields.value) result[key] = $fields.value[key]?.$errors;
+				return result;
 			});
 			const $silentErrors = computed(() => {
-				return Object.fromEntries(Object.entries($fields.value).map(([key, statusOrField]) => {
-					return [key, statusOrField?.$silentErrors];
-				}));
+				const result = {};
+				for (const key in $fields.value) result[key] = $fields.value[key]?.$silentErrors;
+				return result;
 			});
 			const $edited = computed(() => {
-				return !!Object.entries($fields.value).length && Object.entries($fields.value).every(([_, statusOrField]) => {
-					return statusOrField?.$edited;
-				});
+				if (!Object.keys($fields.value).length) return false;
+				for (const key in $fields.value) if (!$fields.value[key]?.$edited) return false;
+				return true;
 			});
 			const $anyEdited = computed(() => {
-				return Object.entries($fields.value).some(([_, statusOrField]) => {
-					return statusOrField?.$anyEdited;
-				});
+				for (const key in $fields.value) if ($fields.value[key]?.$anyEdited) return true;
+				return false;
 			});
 			const $name = computed(() => fieldName);
 			function processShortcuts() {
@@ -1843,6 +1879,7 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 						watchEffect(() => {
 							result.value = value(reactive({
 								$dirty,
+								$path: path,
 								$value: state,
 								$silentValue,
 								$error,
@@ -1856,7 +1893,8 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 								$errors,
 								$fields,
 								$edited,
-								$anyEdited
+								$anyEdited,
+								$issues
 							}));
 						});
 						return result;
@@ -1892,6 +1930,7 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 				$correct,
 				$error,
 				$pending,
+				$issues,
 				$errors,
 				$silentErrors,
 				$ready,
@@ -1916,14 +1955,11 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 		$unwatchSchemaErrors?.();
 		nestedScopes = [];
 		scopeState = {};
-		if ($fields.value) Object.entries($fields.value).forEach(([_, field]) => {
-			field.$unwatch();
-		});
+		if ($fields.value) for (const field of Object.values($fields.value)) field.$unwatch();
 	}
 	function $clearExternalErrors() {
-		Object.entries($fields.value).forEach(([_, field]) => {
-			field.$clearExternalErrors();
-		});
+		const fields = $fields.value;
+		for (const field of Object.values(fields)) field.$clearExternalErrors();
 	}
 	function $reset(options, fromParent) {
 		$unwatchExternalErrors?.();
@@ -1936,17 +1972,13 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 			initialState.value = cloneDeep(newInitialState);
 			state.value = cloneDeep(newInitialState);
 		} else initialState.value = cloneDeep(state.value);
-		Object.values($fields.value).forEach((statusOrField) => {
-			statusOrField.$reset(options, true);
-		});
+		for (const field of Object.values($fields.value)) field.$reset(options, true);
 		if (options?.clearExternalErrors) $clearExternalErrors();
 		define$WatchExternalErrors();
 		if (!fromParent) createReactiveFieldsStatus();
 	}
 	function $touch(runCommit = true, withConditions = false) {
-		Object.values($fields.value).forEach((statusOrField) => {
-			statusOrField.$touch(runCommit, withConditions);
-		});
+		for (const field of Object.values($fields.value)) field.$touch(runCommit, withConditions);
 	}
 	function filterNullishFields(fields) {
 		return fields.filter(([key, value]) => {
@@ -1974,13 +2006,8 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 			};
 			else {
 				const data = state.value;
-				const results = await Promise.allSettled(Object.values($fields.value).map((statusOrField) => {
-					return statusOrField.$validate();
-				}));
-				const validationResults = results.every((value) => {
-					if (value.status === "fulfilled") return value.value.valid === true;
-					else return false;
-				});
+				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
@@ -1996,9 +2023,10 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 		}
 	}
 	const { $shortcuts, $localPending,...restScopeState } = scopeState;
-	return reactive({
+	const fullStatus = reactive({
 		...restScopeState,
 		...$shortcuts,
+		$path: path,
 		$fields,
 		$reset,
 		$touch,
@@ -2008,6 +2036,11 @@ function createReactiveNestedStatus({ rulesDef, state, path = "", rootRules, ext
 		$clearExternalErrors,
 		$extractDirtyFields
 	});
+	watchEffect(() => {
+		for (const key in Object.keys(fullStatus).filter((key$1) => !key$1.startsWith("$"))) delete fullStatus[key];
+		for (const field of Object.values($fields.value)) Object.assign(fullStatus, { [field.$name]: field });
+	});
+	return fullStatus;
 }
 /**
 * Main resolver divider, will distribute the logic depending on the type of the current value (primitive, object, array)
@@ -2065,6 +2098,7 @@ function useRootStorage({ initialState, options, scopeRules, state, customRules,
 		shortcuts,
 		fieldName: "root",
 		path: "",
+		cachePath: "",
 		schemaErrors,
 		rootSchemaErrors: schemaErrors,
 		schemaMode,
@@ -2081,6 +2115,7 @@ function useRootStorage({ initialState, options, scopeRules, state, customRules,
 		shortcuts,
 		fieldName: "root",
 		path: "",
+		cachePath: "",
 		schemaMode,
 		schemaErrors,
 		onValidate