@optique/core 1.1.0-dev.1998 → 1.1.0-dev.2053

package/dist/constructs.cjs

@@ -493,7 +493,8 @@ function generateNoMatchError(context) {
 	else if (hasCommands && hasOptions && !hasArguments) return require_message.message`No matching option or command found.`;
 	else if (hasArguments && hasOptions && !hasCommands) return require_message.message`No matching option or argument found.`;
 	else if (hasArguments && hasCommands && !hasOptions) return require_message.message`No matching command or argument found.`;
-	else return require_message.message`No matching option, command, or argument found.`;
+	else if (hasOptions && hasCommands && hasArguments) return require_message.message`No matching option, command, or argument found.`;
+	else return require_message.message`No value provided.`;
 }
 function normalizeExclusiveState(state) {
 	if (!Array.isArray(state) || state.length !== 2 || typeof state[0] !== "number") return void 0;
@@ -1847,11 +1848,16 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				trace: void 0,
 				phase: "parse"
 			};
+			let probeError;
 			for (const [field, parser] of parserPairs) {
 				const fieldState = getFieldState(field, parser);
 				const completeResult = parser.complete(fieldState, require_execution_context.withChildExecPath(probeExec, field));
 				if (!completeResult.success) {
 					allCanComplete = false;
+					probeError = {
+						consumed: 0,
+						error: completeResult.error
+					};
 					break;
 				}
 			}
@@ -1860,6 +1866,10 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				next: currentContext,
 				consumed: []
 			};
+			if (probeError !== void 0 && options.errors?.endOfInput === void 0 && !noMatchContext.hasOptions && !noMatchContext.hasCommands && !noMatchContext.hasArguments) return {
+				...probeError,
+				success: false
+			};
 		}
 		return {
 			...error,
@@ -1945,11 +1955,16 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				trace: void 0,
 				phase: "parse"
 			};
+			let probeError;
 			for (const [field, parser] of parserPairs) {
 				const fieldState = getFieldState(field, parser);
 				const completeResult = await parser.complete(fieldState, require_execution_context.withChildExecPath(probeExec, field));
 				if (!completeResult.success) {
 					allCanComplete = false;
+					probeError = {
+						consumed: 0,
+						error: completeResult.error
+					};
 					break;
 				}
 			}
@@ -1958,6 +1973,10 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				next: currentContext,
 				consumed: []
 			};
+			if (probeError !== void 0 && options.errors?.endOfInput === void 0 && !noMatchContext.hasOptions && !noMatchContext.hasCommands && !noMatchContext.hasArguments) return {
+				...probeError,
+				success: false
+			};
 		}
 		return {
 			...error,

package/dist/constructs.js

@@ -493,7 +493,8 @@ function generateNoMatchError(context) {
 	else if (hasCommands && hasOptions && !hasArguments) return message`No matching option or command found.`;
 	else if (hasArguments && hasOptions && !hasCommands) return message`No matching option or argument found.`;
 	else if (hasArguments && hasCommands && !hasOptions) return message`No matching command or argument found.`;
-	else return message`No matching option, command, or argument found.`;
+	else if (hasOptions && hasCommands && hasArguments) return message`No matching option, command, or argument found.`;
+	else return message`No value provided.`;
 }
 function normalizeExclusiveState(state) {
 	if (!Array.isArray(state) || state.length !== 2 || typeof state[0] !== "number") return void 0;
@@ -1847,11 +1848,16 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				trace: void 0,
 				phase: "parse"
 			};
+			let probeError;
 			for (const [field, parser] of parserPairs) {
 				const fieldState = getFieldState(field, parser);
 				const completeResult = parser.complete(fieldState, withChildExecPath(probeExec, field));
 				if (!completeResult.success) {
 					allCanComplete = false;
+					probeError = {
+						consumed: 0,
+						error: completeResult.error
+					};
 					break;
 				}
 			}
@@ -1860,6 +1866,10 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				next: currentContext,
 				consumed: []
 			};
+			if (probeError !== void 0 && options.errors?.endOfInput === void 0 && !noMatchContext.hasOptions && !noMatchContext.hasCommands && !noMatchContext.hasArguments) return {
+				...probeError,
+				success: false
+			};
 		}
 		return {
 			...error,
@@ -1945,11 +1955,16 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				trace: void 0,
 				phase: "parse"
 			};
+			let probeError;
 			for (const [field, parser] of parserPairs) {
 				const fieldState = getFieldState(field, parser);
 				const completeResult = await parser.complete(fieldState, withChildExecPath(probeExec, field));
 				if (!completeResult.success) {
 					allCanComplete = false;
+					probeError = {
+						consumed: 0,
+						error: completeResult.error
+					};
 					break;
 				}
 			}
@@ -1958,6 +1973,10 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				next: currentContext,
 				consumed: []
 			};
+			if (probeError !== void 0 && options.errors?.endOfInput === void 0 && !noMatchContext.hasOptions && !noMatchContext.hasCommands && !noMatchContext.hasArguments) return {
+				...probeError,
+				success: false
+			};
 		}
 		return {
 			...error,

package/dist/dependency-runtime.cjs

@@ -485,6 +485,18 @@ function resolveSingleDeferred(deferred, runtime) {
 	if (isPromiseLike(result)) throw new TypeError("resolveStateWithRuntime() received an async parseWithDependency() result. Use resolveStateWithRuntimeAsync() instead.");
 	return result;
 }
+function resolveSingleDeferredAsync(deferred, runtime) {
+	const isMultiDep = deferred.dependencyIds != null && deferred.dependencyIds.length > 0;
+	const depIds = isMultiDep ? deferred.dependencyIds : [deferred.dependencyId];
+	const resolution = runtime.resolveDependencies({
+		dependencyIds: depIds,
+		defaultValues: deferred.defaultValues
+	});
+	if (resolution.kind !== "resolved") return Promise.resolve(deferred.preliminaryResult);
+	if (resolution.usedDefaults.every((d) => d)) return Promise.resolve(deferred.preliminaryResult);
+	const depValue = isMultiDep ? resolution.values : resolution.values[0];
+	return Promise.resolve(deferred.parser[require_dependency.parseWithDependency](deferred.rawInput, depValue));
+}
 /**
 * Recursively collects dependency source values from {@link DependencySourceState}
 * objects found in the state tree and registers them in the runtime.
@@ -545,21 +557,27 @@ function resolveStateWithRuntime(state, runtime) {
 	return resolveDeferredInState(state, runtime);
 }
 /** Pass 2 helper: recursively replace DeferredParseState with resolved values. */
-function resolveDeferredInState(state, runtime, visited = /* @__PURE__ */ new WeakSet()) {
+function resolveDeferredInState(state, runtime, visited = /* @__PURE__ */ new WeakSet(), deferredCache = /* @__PURE__ */ new WeakMap()) {
 	if (state == null) return state;
+	if (require_dependency.isDeferredParseState(state)) {
+		const cached = deferredCache.get(state);
+		if (cached !== void 0) return cached;
+		const resolved = resolveSingleDeferred(state, runtime);
+		deferredCache.set(state, resolved);
+		return resolved;
+	}
+	if (require_dependency.isDependencySourceState(state)) return state;
 	if (typeof state === "object") {
 		if (visited.has(state)) return state;
 		visited.add(state);
 	}
-	if (require_dependency.isDeferredParseState(state)) return resolveSingleDeferred(state, runtime);
-	if (require_dependency.isDependencySourceState(state)) return state;
 	if (Array.isArray(state)) {
-		const resolved = state.map((item) => resolveDeferredInState(item, runtime, visited));
+		const resolved = state.map((item) => resolveDeferredInState(item, runtime, visited, deferredCache));
 		return resolved.every((item, index) => item === state[index]) ? state : resolved;
 	}
 	if (isPlainObject(state)) {
 		const keys = Reflect.ownKeys(state);
-		const resolvedEntries = keys.map((key) => [key, resolveDeferredInState(state[key], runtime, visited)]);
+		const resolvedEntries = keys.map((key) => [key, resolveDeferredInState(state[key], runtime, visited, deferredCache)]);
 		if (resolvedEntries.every(([key, value]) => value === state[key])) return state;
 		const resolved = Object.create(Object.getPrototypeOf(state));
 		for (const [key, value] of resolvedEntries) resolved[key] = value;
@@ -581,34 +599,28 @@ function resolveStateWithRuntimeAsync(state, runtime) {
 	return resolveDeferredInStateAsync(state, runtime);
 }
 /** Async pass 2 helper. */
-async function resolveDeferredInStateAsync(state, runtime, visited = /* @__PURE__ */ new WeakSet()) {
+async function resolveDeferredInStateAsync(state, runtime, visited = /* @__PURE__ */ new WeakSet(), deferredCache = /* @__PURE__ */ new WeakMap()) {
 	if (state == null) return state;
+	if (require_dependency.isDeferredParseState(state)) {
+		const cached = deferredCache.get(state);
+		if (cached !== void 0) return cached;
+		const resolved = resolveSingleDeferredAsync(state, runtime);
+		deferredCache.set(state, resolved);
+		return resolved;
+	}
+	if (require_dependency.isDependencySourceState(state)) return state;
 	if (typeof state === "object") {
 		if (visited.has(state)) return state;
 		visited.add(state);
 	}
-	if (require_dependency.isDeferredParseState(state)) {
-		const deferred = state;
-		const isMultiDep = deferred.dependencyIds != null && deferred.dependencyIds.length > 0;
-		const depIds = isMultiDep ? deferred.dependencyIds : [deferred.dependencyId];
-		const resolution = runtime.resolveDependencies({
-			dependencyIds: depIds,
-			defaultValues: deferred.defaultValues
-		});
-		if (resolution.kind !== "resolved") return deferred.preliminaryResult;
-		if (resolution.usedDefaults.every((d) => d)) return deferred.preliminaryResult;
-		const depValue = isMultiDep ? resolution.values : resolution.values[0];
-		return Promise.resolve(deferred.parser[require_dependency.parseWithDependency](deferred.rawInput, depValue));
-	}
-	if (require_dependency.isDependencySourceState(state)) return state;
 	if (Array.isArray(state)) {
-		const resolved = await Promise.all(state.map((item) => resolveDeferredInStateAsync(item, runtime, visited)));
+		const resolved = await Promise.all(state.map((item) => resolveDeferredInStateAsync(item, runtime, visited, deferredCache)));
 		return resolved.every((item, index) => item === state[index]) ? state : resolved;
 	}
 	if (isPlainObject(state)) {
 		const keys = Reflect.ownKeys(state);
 		const resolvedEntries = await Promise.all(keys.map(async (key) => {
-			return [key, await resolveDeferredInStateAsync(state[key], runtime, visited)];
+			return [key, await resolveDeferredInStateAsync(state[key], runtime, visited, deferredCache)];
 		}));
 		if (resolvedEntries.every(([key, value]) => value === state[key])) return state;
 		const resolved = Object.create(Object.getPrototypeOf(state));

package/dist/dependency-runtime.js

@@ -485,6 +485,18 @@ function resolveSingleDeferred(deferred, runtime) {
 	if (isPromiseLike(result)) throw new TypeError("resolveStateWithRuntime() received an async parseWithDependency() result. Use resolveStateWithRuntimeAsync() instead.");
 	return result;
 }
+function resolveSingleDeferredAsync(deferred, runtime) {
+	const isMultiDep = deferred.dependencyIds != null && deferred.dependencyIds.length > 0;
+	const depIds = isMultiDep ? deferred.dependencyIds : [deferred.dependencyId];
+	const resolution = runtime.resolveDependencies({
+		dependencyIds: depIds,
+		defaultValues: deferred.defaultValues
+	});
+	if (resolution.kind !== "resolved") return Promise.resolve(deferred.preliminaryResult);
+	if (resolution.usedDefaults.every((d) => d)) return Promise.resolve(deferred.preliminaryResult);
+	const depValue = isMultiDep ? resolution.values : resolution.values[0];
+	return Promise.resolve(deferred.parser[parseWithDependency](deferred.rawInput, depValue));
+}
 /**
 * Recursively collects dependency source values from {@link DependencySourceState}
 * objects found in the state tree and registers them in the runtime.
@@ -545,21 +557,27 @@ function resolveStateWithRuntime(state, runtime) {
 	return resolveDeferredInState(state, runtime);
 }
 /** Pass 2 helper: recursively replace DeferredParseState with resolved values. */
-function resolveDeferredInState(state, runtime, visited = /* @__PURE__ */ new WeakSet()) {
+function resolveDeferredInState(state, runtime, visited = /* @__PURE__ */ new WeakSet(), deferredCache = /* @__PURE__ */ new WeakMap()) {
 	if (state == null) return state;
+	if (isDeferredParseState(state)) {
+		const cached = deferredCache.get(state);
+		if (cached !== void 0) return cached;
+		const resolved = resolveSingleDeferred(state, runtime);
+		deferredCache.set(state, resolved);
+		return resolved;
+	}
+	if (isDependencySourceState(state)) return state;
 	if (typeof state === "object") {
 		if (visited.has(state)) return state;
 		visited.add(state);
 	}
-	if (isDeferredParseState(state)) return resolveSingleDeferred(state, runtime);
-	if (isDependencySourceState(state)) return state;
 	if (Array.isArray(state)) {
-		const resolved = state.map((item) => resolveDeferredInState(item, runtime, visited));
+		const resolved = state.map((item) => resolveDeferredInState(item, runtime, visited, deferredCache));
 		return resolved.every((item, index) => item === state[index]) ? state : resolved;
 	}
 	if (isPlainObject(state)) {
 		const keys = Reflect.ownKeys(state);
-		const resolvedEntries = keys.map((key) => [key, resolveDeferredInState(state[key], runtime, visited)]);
+		const resolvedEntries = keys.map((key) => [key, resolveDeferredInState(state[key], runtime, visited, deferredCache)]);
 		if (resolvedEntries.every(([key, value]) => value === state[key])) return state;
 		const resolved = Object.create(Object.getPrototypeOf(state));
 		for (const [key, value] of resolvedEntries) resolved[key] = value;
@@ -581,34 +599,28 @@ function resolveStateWithRuntimeAsync(state, runtime) {
 	return resolveDeferredInStateAsync(state, runtime);
 }
 /** Async pass 2 helper. */
-async function resolveDeferredInStateAsync(state, runtime, visited = /* @__PURE__ */ new WeakSet()) {
+async function resolveDeferredInStateAsync(state, runtime, visited = /* @__PURE__ */ new WeakSet(), deferredCache = /* @__PURE__ */ new WeakMap()) {
 	if (state == null) return state;
+	if (isDeferredParseState(state)) {
+		const cached = deferredCache.get(state);
+		if (cached !== void 0) return cached;
+		const resolved = resolveSingleDeferredAsync(state, runtime);
+		deferredCache.set(state, resolved);
+		return resolved;
+	}
+	if (isDependencySourceState(state)) return state;
 	if (typeof state === "object") {
 		if (visited.has(state)) return state;
 		visited.add(state);
 	}
-	if (isDeferredParseState(state)) {
-		const deferred = state;
-		const isMultiDep = deferred.dependencyIds != null && deferred.dependencyIds.length > 0;
-		const depIds = isMultiDep ? deferred.dependencyIds : [deferred.dependencyId];
-		const resolution = runtime.resolveDependencies({
-			dependencyIds: depIds,
-			defaultValues: deferred.defaultValues
-		});
-		if (resolution.kind !== "resolved") return deferred.preliminaryResult;
-		if (resolution.usedDefaults.every((d) => d)) return deferred.preliminaryResult;
-		const depValue = isMultiDep ? resolution.values : resolution.values[0];
-		return Promise.resolve(deferred.parser[parseWithDependency](deferred.rawInput, depValue));
-	}
-	if (isDependencySourceState(state)) return state;
 	if (Array.isArray(state)) {
-		const resolved = await Promise.all(state.map((item) => resolveDeferredInStateAsync(item, runtime, visited)));
+		const resolved = await Promise.all(state.map((item) => resolveDeferredInStateAsync(item, runtime, visited, deferredCache)));
 		return resolved.every((item, index) => item === state[index]) ? state : resolved;
 	}
 	if (isPlainObject(state)) {
 		const keys = Reflect.ownKeys(state);
 		const resolvedEntries = await Promise.all(keys.map(async (key) => {
-			return [key, await resolveDeferredInStateAsync(state[key], runtime, visited)];
+			return [key, await resolveDeferredInStateAsync(state[key], runtime, visited, deferredCache)];
 		}));
 		if (resolvedEntries.every(([key, value]) => value === state[key])) return state;
 		const resolved = Object.create(Object.getPrototypeOf(state));