@optique/core 0.10.0-dev.293 → 0.10.0-dev.295

package/dist/constructs.cjs

@@ -541,32 +541,145 @@ async function* suggestObjectAsync(context, prefix, parserPairs) {
 * @returns The field states with deferred states resolved to their actual values
 * @internal
 */
+/**
+* Recursively collects dependency values from DependencySourceState objects
+* found anywhere in the state tree.
+*/
+function collectDependencies(state, registry) {
+	if (state === null || state === void 0) return;
+	if (require_dependency.isDependencySourceState(state)) {
+		const depId = state[require_dependency.DependencyId];
+		const result = state.result;
+		if (result.success) registry.set(depId, result.value);
+		return;
+	}
+	if (Array.isArray(state)) {
+		for (const item of state) collectDependencies(item, registry);
+		return;
+	}
+	if (typeof state === "object" && !require_dependency.isDeferredParseState(state)) for (const key of Reflect.ownKeys(state)) collectDependencies(state[key], registry);
+}
+/**
+* Checks if a value is a plain object (created with `{}` or `Object.create(null)`).
+* Class instances like `Temporal.PlainDate`, `URL`, `Date`, etc. return false.
+* This is used to determine whether to recursively traverse an object when
+* resolving deferred parse states - we only want to traverse plain objects
+* that are part of the parser state structure, not user values.
+*/
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Recursively resolves DeferredParseState objects found anywhere in the state tree.
+* Returns the resolved state (sync version).
+*
+* Only traverses:
+* - DeferredParseState (to resolve it)
+* - DependencySourceState (skipped, kept as-is)
+* - Arrays (to find nested deferred states)
+* - Plain objects (to find nested deferred states in parser state structures)
+*
+* Does NOT traverse class instances (e.g., Temporal.PlainDate, URL) since these
+* are user values that should be preserved as-is.
+*/
+function resolveDeferred(state, registry) {
+	if (state === null || state === void 0) return state;
+	if (require_dependency.isDeferredParseState(state)) {
+		const deferredState = state;
+		const parser = deferredState.parser;
+		const depIds = deferredState.dependencyIds;
+		if (depIds && depIds.length > 0) {
+			const dependencyValues = [];
+			let allDepsAvailable = true;
+			for (const depId$1 of depIds) if (registry.has(depId$1)) dependencyValues.push(registry.get(depId$1));
+			else {
+				allDepsAvailable = false;
+				break;
+			}
+			if (allDepsAvailable) {
+				const reParseResult = parser[require_dependency.ParseWithDependency](deferredState.rawInput, dependencyValues);
+				if (reParseResult instanceof Promise) return deferredState.preliminaryResult;
+				return reParseResult;
+			}
+			return deferredState.preliminaryResult;
+		}
+		const depId = deferredState.dependencyId;
+		if (registry.has(depId)) {
+			const dependencyValue = registry.get(depId);
+			const reParseResult = parser[require_dependency.ParseWithDependency](deferredState.rawInput, dependencyValue);
+			if (reParseResult instanceof Promise) return deferredState.preliminaryResult;
+			return reParseResult;
+		}
+		return deferredState.preliminaryResult;
+	}
+	if (require_dependency.isDependencySourceState(state)) return state;
+	if (Array.isArray(state)) return state.map((item) => resolveDeferred(item, registry));
+	if (isPlainObject(state)) {
+		const resolved = {};
+		for (const key of Reflect.ownKeys(state)) resolved[key] = resolveDeferred(state[key], registry);
+		return resolved;
+	}
+	return state;
+}
 function resolveDeferredParseStates(fieldStates) {
 	const registry = new require_dependency.DependencyRegistry();
-	for (const key of Reflect.ownKeys(fieldStates)) {
-		const fieldState = fieldStates[key];
-		if (require_dependency.isDependencySourceState(fieldState)) {
-			const depId = fieldState[require_dependency.DependencyId];
-			const result = fieldState.result;
-			if (result.success) registry.set(depId, result.value);
+	collectDependencies(fieldStates, registry);
+	return resolveDeferred(fieldStates, registry);
+}
+/**
+* Recursively resolves DeferredParseState objects found anywhere in the state tree.
+* Returns the resolved state (async version).
+*
+* Only traverses:
+* - DeferredParseState (to resolve it)
+* - DependencySourceState (skipped, kept as-is)
+* - Arrays (to find nested deferred states)
+* - Plain objects (to find nested deferred states in parser state structures)
+*
+* Does NOT traverse class instances (e.g., Temporal.PlainDate, URL) since these
+* are user values that should be preserved as-is.
+*/
+async function resolveDeferredAsync(state, registry) {
+	if (state === null || state === void 0) return state;
+	if (require_dependency.isDeferredParseState(state)) {
+		const deferredState = state;
+		const parser = deferredState.parser;
+		const depIds = deferredState.dependencyIds;
+		if (depIds && depIds.length > 0) {
+			const dependencyValues = [];
+			let allDepsAvailable = true;
+			for (const depId$1 of depIds) if (registry.has(depId$1)) dependencyValues.push(registry.get(depId$1));
+			else {
+				allDepsAvailable = false;
+				break;
+			}
+			if (allDepsAvailable) {
+				const reParseResult = parser[require_dependency.ParseWithDependency](deferredState.rawInput, dependencyValues);
+				return Promise.resolve(reParseResult);
+			}
+			return deferredState.preliminaryResult;
 		}
-	}
-	const resolvedStates = { ...fieldStates };
-	for (const key of Reflect.ownKeys(fieldStates)) {
-		const fieldState = fieldStates[key];
-		if (require_dependency.isDeferredParseState(fieldState)) {
-			const deferredState = fieldState;
-			const depId = deferredState.dependencyId;
-			if (registry.has(depId)) {
-				const dependencyValue = registry.get(depId);
-				const parser = deferredState.parser;
-				const reParseResult = parser[require_dependency.ParseWithDependency](deferredState.rawInput, dependencyValue);
-				if (reParseResult instanceof Promise) resolvedStates[key] = deferredState.preliminaryResult;
-				else resolvedStates[key] = reParseResult;
-			} else resolvedStates[key] = deferredState.preliminaryResult;
+		const depId = deferredState.dependencyId;
+		if (registry.has(depId)) {
+			const dependencyValue = registry.get(depId);
+			const reParseResult = parser[require_dependency.ParseWithDependency](deferredState.rawInput, dependencyValue);
+			return Promise.resolve(reParseResult);
 		}
+		return deferredState.preliminaryResult;
+	}
+	if (require_dependency.isDependencySourceState(state)) return state;
+	if (Array.isArray(state)) return Promise.all(state.map((item) => resolveDeferredAsync(item, registry)));
+	if (isPlainObject(state)) {
+		const resolved = {};
+		const keys = Reflect.ownKeys(state);
+		await Promise.all(keys.map(async (key) => {
+			resolved[key] = await resolveDeferredAsync(state[key], registry);
+		}));
+		return resolved;
 	}
-	return resolvedStates;
+	return state;
 }
 /**
 * Async version of resolveDeferredParseStates for async parsers.
@@ -574,29 +687,8 @@ function resolveDeferredParseStates(fieldStates) {
 */
 async function resolveDeferredParseStatesAsync(fieldStates) {
 	const registry = new require_dependency.DependencyRegistry();
-	for (const key of Reflect.ownKeys(fieldStates)) {
-		const fieldState = fieldStates[key];
-		if (require_dependency.isDependencySourceState(fieldState)) {
-			const depId = fieldState[require_dependency.DependencyId];
-			const result = fieldState.result;
-			if (result.success) registry.set(depId, result.value);
-		}
-	}
-	const resolvedStates = { ...fieldStates };
-	for (const key of Reflect.ownKeys(fieldStates)) {
-		const fieldState = fieldStates[key];
-		if (require_dependency.isDeferredParseState(fieldState)) {
-			const deferredState = fieldState;
-			const depId = deferredState.dependencyId;
-			if (registry.has(depId)) {
-				const dependencyValue = registry.get(depId);
-				const parser = deferredState.parser;
-				const reParseResult = parser[require_dependency.ParseWithDependency](deferredState.rawInput, dependencyValue);
-				resolvedStates[key] = await Promise.resolve(reParseResult);
-			} else resolvedStates[key] = deferredState.preliminaryResult;
-		}
-	}
-	return resolvedStates;
+	collectDependencies(fieldStates, registry);
+	return await resolveDeferredAsync(fieldStates, registry);
 }
 function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 	const label = typeof labelOrParsers === "string" ? labelOrParsers : void 0;
@@ -756,12 +848,45 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 			return parseSync(context);
 		},
 		complete(state) {
-			const resolvedState = isAsync ? state : resolveDeferredParseStates(state);
 			if (!isAsync) {
+				const preCompletedState = {};
+				for (const field of parserKeys) {
+					const fieldKey = field;
+					const fieldState = state[fieldKey];
+					const fieldParser = parsers[field];
+					if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) {
+						const completed = fieldParser.complete(fieldState);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) {
+						const completed = fieldParser.complete([fieldParser.initialState]);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
+						const pendingState = fieldParser[require_dependency.WrappedDependencySourceMarker];
+						const completed = fieldParser.complete([pendingState]);
+						preCompletedState[fieldKey] = completed;
+					} else preCompletedState[fieldKey] = fieldState;
+				}
+				const resolvedState = resolveDeferredParseStates(preCompletedState);
 				const result = {};
 				for (const field of parserKeys) {
-					const valueResult = parsers[field].complete(resolvedState[field]);
-					if (valueResult.success) result[field] = valueResult.value;
+					const fieldKey = field;
+					const fieldResolvedState = resolvedState[fieldKey];
+					const fieldParser = parsers[field];
+					const originalFieldState = state[fieldKey];
+					const wasPreCompletedCase1 = Array.isArray(originalFieldState) && originalFieldState.length === 1 && require_dependency.isPendingDependencySourceState(originalFieldState[0]);
+					const wasPreCompletedCase2 = originalFieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState);
+					const wasPreCompletedCase3 = originalFieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser);
+					if (require_dependency.isDependencySourceState(fieldResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
+						const depResult = fieldResolvedState.result;
+						if (depResult.success) result[fieldKey] = depResult.value;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = fieldParser.complete(fieldResolvedState);
+					if (valueResult.success) result[fieldKey] = valueResult.value;
 					else return {
 						success: false,
 						error: valueResult.error
@@ -773,11 +898,44 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				};
 			}
 			return (async () => {
-				const resolvedState$1 = await resolveDeferredParseStatesAsync(state);
+				const preCompletedState = {};
+				for (const field of parserKeys) {
+					const fieldKey = field;
+					const fieldState = state[fieldKey];
+					const fieldParser = parsers[field];
+					if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) {
+						const completed = await fieldParser.complete(fieldState);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) {
+						const completed = await fieldParser.complete([fieldParser.initialState]);
+						preCompletedState[fieldKey] = completed;
+					} else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
+						const pendingState = fieldParser[require_dependency.WrappedDependencySourceMarker];
+						const completed = await fieldParser.complete([pendingState]);
+						preCompletedState[fieldKey] = completed;
+					} else preCompletedState[fieldKey] = fieldState;
+				}
+				const resolvedState = await resolveDeferredParseStatesAsync(preCompletedState);
 				const result = {};
 				for (const field of parserKeys) {
-					const valueResult = await parsers[field].complete(resolvedState$1[field]);
-					if (valueResult.success) result[field] = valueResult.value;
+					const fieldKey = field;
+					const fieldResolvedState = resolvedState[fieldKey];
+					const fieldParser = parsers[field];
+					const originalFieldState = state[fieldKey];
+					const wasPreCompletedCase1 = Array.isArray(originalFieldState) && originalFieldState.length === 1 && require_dependency.isPendingDependencySourceState(originalFieldState[0]);
+					const wasPreCompletedCase2 = originalFieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState);
+					const wasPreCompletedCase3 = originalFieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser);
+					if (require_dependency.isDependencySourceState(fieldResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
+						const depResult = fieldResolvedState.result;
+						if (depResult.success) result[fieldKey] = depResult.value;
+						else return {
+							success: false,
+							error: depResult.error
+						};
+						continue;
+					}
+					const valueResult = await fieldParser.complete(fieldResolvedState);
+					if (valueResult.success) result[fieldKey] = valueResult.value;
 					else return {
 						success: false,
 						error: valueResult.error
@@ -1220,15 +1378,15 @@ function merge(...args) {
 			return parseSync(context);
 		},
 		complete(state) {
-			const extractCompleteState = (parser, index) => {
+			const extractCompleteState = (parser, resolvedState, index) => {
 				if (parser.initialState === void 0) {
 					const key = `__parser_${index}`;
-					if (state && typeof state === "object" && key in state) return state[key];
+					if (resolvedState && typeof resolvedState === "object" && key in resolvedState) return resolvedState[key];
 					return void 0;
 				} else if (parser.initialState && typeof parser.initialState === "object") {
-					if (state && typeof state === "object") {
+					if (resolvedState && typeof resolvedState === "object") {
 						const extractedState = {};
-						for (const field in parser.initialState) extractedState[field] = field in state ? state[field] : parser.initialState[field];
+						for (const field in parser.initialState) extractedState[field] = field in resolvedState ? resolvedState[field] : parser.initialState[field];
 						return extractedState;
 					}
 					return parser.initialState;
@@ -1236,10 +1394,11 @@ function merge(...args) {
 				return parser.initialState;
 			};
 			if (!isAsync) {
+				const resolvedState = resolveDeferredParseStates(state);
 				const object$1 = {};
 				for (let i = 0; i < syncParsers.length; i++) {
 					const parser = syncParsers[i];
-					const parserState = extractCompleteState(parser, i);
+					const parserState = extractCompleteState(parser, resolvedState, i);
 					const result = parser.complete(parserState);
 					if (!result.success) return result;
 					for (const field in result.value) object$1[field] = result.value[field];
@@ -1250,10 +1409,11 @@ function merge(...args) {
 				};
 			}
 			return (async () => {
+				const resolvedState = await resolveDeferredParseStatesAsync(state);
 				const object$1 = {};
 				for (let i = 0; i < parsers.length; i++) {
 					const parser = parsers[i];
-					const parserState = extractCompleteState(parser, i);
+					const parserState = extractCompleteState(parser, resolvedState, i);
 					const result = await parser.complete(parserState);
 					if (!result.success) return result;
 					for (const field in result.value) object$1[field] = result.value[field];
@@ -1482,11 +1642,14 @@ function concat(...parsers) {
 		};
 	};
 	const completeSync = (state) => {
-		const results = [];
 		const stateArray = state;
+		const combinedState = {};
+		for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
+		const resolvedCombinedState = resolveDeferredParseStates(combinedState);
+		const results = [];
 		for (let i = 0; i < syncParsers.length; i++) {
 			const parser = syncParsers[i];
-			const parserState = stateArray[i];
+			const parserState = resolvedCombinedState[i];
 			const result = parser.complete(parserState);
 			if (!result.success) return result;
 			if (Array.isArray(result.value)) results.push(...result.value);
@@ -1498,11 +1661,14 @@ function concat(...parsers) {
 		};
 	};
 	const completeAsync = async (state) => {
-		const results = [];
 		const stateArray = state;
+		const combinedState = {};
+		for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
+		const resolvedCombinedState = await resolveDeferredParseStatesAsync(combinedState);
+		const results = [];
 		for (let i = 0; i < parsers.length; i++) {
 			const parser = parsers[i];
-			const parserState = stateArray[i];
+			const parserState = resolvedCombinedState[i];
 			const result = await parser.complete(parserState);
 			if (!result.success) return result;
 			if (Array.isArray(result.value)) results.push(...result.value);