@optique/config 0.10.7-dev.485 → 1.0.0-dev.1109

package/README.md

@@ -29,11 +29,11 @@ Quick start
 ~~~~ typescript
 import { z } from "zod";
 import { createConfigContext, bindConfig } from "@optique/config";
-import { runWithConfig } from "@optique/config/run";
 import { object } from "@optique/core/constructs";
 import { option } from "@optique/core/primitives";
 import { string, integer } from "@optique/core/valueparser";
 import { withDefault } from "@optique/core/modifiers";
+import { runAsync } from "@optique/run";
 
 // 1. Define config schema
 const configSchema = z.object({
@@ -58,8 +58,9 @@ const parser = object({
   }),
 });
 
-// 3. Run with config support
-const result = await runWithConfig(parser, configContext, {
+// 3. Run with config support via contexts
+const result = await runAsync(parser, {
+  contexts: [configContext],
   getConfigPath: (parsed) => parsed.config,
   args: process.argv.slice(2),
 });

package/dist/index.cjs

@@ -1,8 +1,617 @@
-const require_src = require('./src-9MkUoh9z.cjs');
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-exports.bindConfig = require_src.bindConfig;
-exports.clearActiveConfig = require_src.clearActiveConfig;
-exports.configKey = require_src.configKey;
-exports.createConfigContext = require_src.createConfigContext;
-exports.getActiveConfig = require_src.getActiveConfig;
-exports.setActiveConfig = require_src.setActiveConfig;
+//#endregion
+const node_fs = __toESM(require("node:fs"));
+const node_path = __toESM(require("node:path"));
+const __optique_core_annotations = __toESM(require("@optique/core/annotations"));
+const __optique_core_context = __toESM(require("@optique/core/context"));
+const __optique_core_message = __toESM(require("@optique/core/message"));
+const __optique_core_mode_dispatch = __toESM(require("@optique/core/mode-dispatch"));
+
+//#region src/index.ts
+const phase2UndefinedParsedValueKey = Symbol("@optique/config/phase2UndefinedParsedValue");
+/**
+* Internal registry for active config data during config context execution.
+* This is a workaround for the limitation that object() doesn't propagate
+* annotations to child field parsers.
+* @internal
+*/
+const activeConfigRegistry = /* @__PURE__ */ new Map();
+/**
+* Internal registry for active config metadata during config context execution.
+* @internal
+*/
+const activeConfigMetaRegistry = /* @__PURE__ */ new Map();
+const phase1ConfigAnnotationMarker = Symbol("@optique/config/phase1Annotation");
+function isDeferredPromptValue(value) {
+	return (0, __optique_core_context.isPlaceholderValue)(value);
+}
+function isPhase2UndefinedParsedValue(value) {
+	return value != null && typeof value === "object" && phase2UndefinedParsedValueKey in value;
+}
+function isPlainObject(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function shouldSkipCollectionOwnKey(value, key) {
+	if (Array.isArray(value)) return key === "length" || typeof key === "string" && Number.isInteger(Number(key)) && String(Number(key)) === key;
+	return false;
+}
+function containsDeferredPromptValuesInOwnProperties(value, seen) {
+	for (const key of Reflect.ownKeys(value)) {
+		if (shouldSkipCollectionOwnKey(value, key)) continue;
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (descriptor != null && "value" in descriptor && containsDeferredPromptValues(descriptor.value, seen)) return true;
+	}
+	return false;
+}
+function copySanitizedOwnProperties(source, target, seen) {
+	for (const key of Reflect.ownKeys(source)) {
+		if (shouldSkipCollectionOwnKey(source, key)) continue;
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (descriptor == null) continue;
+		if ("value" in descriptor) descriptor.value = stripDeferredPromptValues(descriptor.value, seen);
+		Object.defineProperty(target, key, descriptor);
+	}
+}
+function containsDeferredPromptValues(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isDeferredPromptValue(value)) return true;
+	if (value == null || typeof value !== "object") return false;
+	if (seen.has(value)) return false;
+	seen.add(value);
+	if (Array.isArray(value)) {
+		if (value.some((item) => containsDeferredPromptValues(item, seen))) return true;
+		return containsDeferredPromptValuesInOwnProperties(value, seen);
+	}
+	if (value instanceof Set) {
+		for (const entryValue of value) if (containsDeferredPromptValues(entryValue, seen)) return true;
+		return containsDeferredPromptValuesInOwnProperties(value, seen);
+	}
+	if (value instanceof Map) {
+		for (const [key, entryValue] of value) if (containsDeferredPromptValues(key, seen) || containsDeferredPromptValues(entryValue, seen)) return true;
+		return containsDeferredPromptValuesInOwnProperties(value, seen);
+	}
+	return containsDeferredPromptValuesInOwnProperties(value, seen);
+}
+const SANITIZE_FAILED = Symbol("sanitizeFailed");
+const activeSanitizations = /* @__PURE__ */ new WeakMap();
+function callWithSanitizedOwnProperties(target, fn, args, strip, seen) {
+	let active = activeSanitizations.get(target);
+	if (active != null) active.count++;
+	else {
+		const saved = /* @__PURE__ */ new Map();
+		const sanitizedValues = /* @__PURE__ */ new Map();
+		for (const key of Reflect.ownKeys(target)) {
+			const desc = Object.getOwnPropertyDescriptor(target, key);
+			if (desc != null && "value" in desc) {
+				let stripped;
+				try {
+					stripped = strip(desc.value, seen);
+				} catch {
+					for (const [k, d] of saved) try {
+						Object.defineProperty(target, k, d);
+					} catch {}
+					return SANITIZE_FAILED;
+				}
+				if (stripped !== desc.value) try {
+					Object.defineProperty(target, key, {
+						...desc,
+						value: stripped
+					});
+					saved.set(key, desc);
+					sanitizedValues.set(key, stripped);
+				} catch {
+					for (const [k, d] of saved) try {
+						Object.defineProperty(target, k, d);
+					} catch {}
+					return SANITIZE_FAILED;
+				}
+			}
+		}
+		active = {
+			saved,
+			sanitizedValues,
+			count: 1
+		};
+		activeSanitizations.set(target, active);
+	}
+	function release() {
+		active.count--;
+		if (active.count === 0) {
+			activeSanitizations.delete(target);
+			for (const [key, desc] of active.saved) try {
+				const current = Object.getOwnPropertyDescriptor(target, key);
+				if (current == null) continue;
+				if ("value" in current && current.value !== active.sanitizedValues.get(key)) continue;
+				Object.defineProperty(target, key, desc);
+			} catch {}
+		}
+	}
+	let result;
+	try {
+		result = fn.apply(target, args);
+	} catch (e) {
+		release();
+		throw e;
+	}
+	if (result instanceof Promise) return result.then((v) => {
+		release();
+		return strip(v, seen);
+	}, (e) => {
+		release();
+		throw e;
+	});
+	release();
+	return strip(result, seen);
+}
+function callMethodOnSanitizedTarget(fn, proxy, target, args, strip, seen) {
+	const result = callWithSanitizedOwnProperties(target, fn, args, strip, seen);
+	if (result !== SANITIZE_FAILED) return result;
+	const fallback = fn.apply(proxy, args);
+	if (fallback instanceof Promise) return fallback.then((v) => strip(v, seen));
+	return strip(fallback, seen);
+}
+function createSanitizedNonPlainView(value, seen) {
+	const methodCache = /* @__PURE__ */ new Map();
+	const proxy = new Proxy(value, {
+		get(target, key, receiver) {
+			const descriptor = Object.getOwnPropertyDescriptor(target, key);
+			if (descriptor != null && "value" in descriptor) {
+				if (!descriptor.configurable && !descriptor.writable) return descriptor.value;
+				const val = stripDeferredPromptValues(descriptor.value, seen);
+				if (typeof val === "function") {
+					if (!descriptor.configurable && !descriptor.writable || /^class[\s{]/.test(Function.prototype.toString.call(val))) return val;
+					const cached = methodCache.get(key);
+					if (cached != null && cached.fn === val) return cached.wrapper;
+					const wrapper = function(...args) {
+						if (this !== proxy) return stripDeferredPromptValues(val.apply(this, args), seen);
+						return callMethodOnSanitizedTarget(val, proxy, target, args, stripDeferredPromptValues, seen);
+					};
+					methodCache.set(key, {
+						fn: val,
+						wrapper
+					});
+					return wrapper;
+				}
+				return val;
+			}
+			let isAccessor = false;
+			for (let proto = target; proto != null; proto = Object.getPrototypeOf(proto)) {
+				const d = Object.getOwnPropertyDescriptor(proto, key);
+				if (d != null) {
+					isAccessor = "get" in d;
+					break;
+				}
+			}
+			const result = Reflect.get(target, key, receiver);
+			if (typeof result === "function") {
+				if (/^class[\s{]/.test(Function.prototype.toString.call(result))) return result;
+				if (!isAccessor) {
+					const cached = methodCache.get(key);
+					if (cached != null && cached.fn === result) return cached.wrapper;
+					const wrapper = function(...args) {
+						if (this !== proxy) return stripDeferredPromptValues(result.apply(this, args), seen);
+						return callMethodOnSanitizedTarget(result, proxy, target, args, stripDeferredPromptValues, seen);
+					};
+					methodCache.set(key, {
+						fn: result,
+						wrapper
+					});
+					return wrapper;
+				}
+				return function(...args) {
+					if (this !== proxy) return stripDeferredPromptValues(result.apply(this, args), seen);
+					return callMethodOnSanitizedTarget(result, proxy, target, args, stripDeferredPromptValues, seen);
+				};
+			}
+			return stripDeferredPromptValues(result, seen);
+		},
+		getOwnPropertyDescriptor(target, key) {
+			const descriptor = Object.getOwnPropertyDescriptor(target, key);
+			if (descriptor == null || !("value" in descriptor)) return descriptor;
+			if (!descriptor.configurable && !descriptor.writable) return descriptor;
+			return {
+				...descriptor,
+				value: stripDeferredPromptValues(descriptor.value, seen)
+			};
+		}
+	});
+	seen.set(value, proxy);
+	return proxy;
+}
+function stripDeferredPromptValues(value, seen = /* @__PURE__ */ new WeakMap()) {
+	if (isDeferredPromptValue(value)) return void 0;
+	if (value == null || typeof value !== "object") return value;
+	const cached = seen.get(value);
+	if (cached !== void 0) return cached;
+	if (Array.isArray(value)) {
+		if (!containsDeferredPromptValues(value)) return value;
+		const clone$1 = new Array(value.length);
+		seen.set(value, clone$1);
+		for (let i = 0; i < value.length; i++) clone$1[i] = stripDeferredPromptValues(value[i], seen);
+		copySanitizedOwnProperties(value, clone$1, seen);
+		return clone$1;
+	}
+	if (value instanceof Set) {
+		if (!containsDeferredPromptValues(value)) return value;
+		const clone$1 = /* @__PURE__ */ new Set();
+		seen.set(value, clone$1);
+		for (const entryValue of value) clone$1.add(stripDeferredPromptValues(entryValue, seen));
+		copySanitizedOwnProperties(value, clone$1, seen);
+		return clone$1;
+	}
+	if (value instanceof Map) {
+		if (!containsDeferredPromptValues(value)) return value;
+		const clone$1 = /* @__PURE__ */ new Map();
+		seen.set(value, clone$1);
+		for (const [key, entryValue] of value) clone$1.set(stripDeferredPromptValues(key, seen), stripDeferredPromptValues(entryValue, seen));
+		copySanitizedOwnProperties(value, clone$1, seen);
+		return clone$1;
+	}
+	if (!isPlainObject(value)) return containsDeferredPromptValues(value) ? createSanitizedNonPlainView(value, seen) : value;
+	if (!containsDeferredPromptValues(value)) return value;
+	const clone = Object.create(Object.getPrototypeOf(value));
+	seen.set(value, clone);
+	for (const key of Reflect.ownKeys(value)) {
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (descriptor == null) continue;
+		if ("value" in descriptor) descriptor.value = stripDeferredPromptValues(descriptor.value, seen);
+		Object.defineProperty(clone, key, descriptor);
+	}
+	return clone;
+}
+/**
+* Sets active config data for a context.
+* @internal
+*/
+function setActiveConfig(contextId, data) {
+	activeConfigRegistry.set(contextId, data);
+}
+/**
+* Gets active config data for a context.
+* @internal
+*/
+function getActiveConfig(contextId) {
+	return activeConfigRegistry.get(contextId);
+}
+/**
+* Clears active config data for a context.
+* @internal
+*/
+function clearActiveConfig(contextId) {
+	activeConfigRegistry.delete(contextId);
+}
+/**
+* Sets active config metadata for a context.
+* @internal
+*/
+function setActiveConfigMeta(contextId, meta) {
+	activeConfigMetaRegistry.set(contextId, meta);
+}
+/**
+* Gets active config metadata for a context.
+* @internal
+*/
+function getActiveConfigMeta(contextId) {
+	return activeConfigMetaRegistry.get(contextId);
+}
+/**
+* Clears active config metadata for a context.
+* @internal
+*/
+function clearActiveConfigMeta(contextId) {
+	activeConfigMetaRegistry.delete(contextId);
+}
+function getTypeName(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+function isStandardSchema(value) {
+	if (value == null || typeof value !== "object" && typeof value !== "function") return false;
+	if (!("~standard" in value)) return false;
+	const standard = value["~standard"];
+	if (standard == null || typeof standard !== "object" && typeof standard !== "function") return false;
+	return typeof standard.validate === "function";
+}
+function isErrnoException(error) {
+	return typeof error === "object" && error !== null && "code" in error;
+}
+/**
+* Validates raw data against a Standard Schema and returns the validated value.
+* @internal
+*/
+function processValidationResult(validationResult) {
+	if (validationResult.issues) {
+		const firstIssue = validationResult.issues[0];
+		throw new Error(`Config validation failed: ${firstIssue?.message ?? "Unknown error"}`);
+	}
+	return validationResult.value;
+}
+function validateWithSchema(schema, rawData) {
+	const validation = schema["~standard"].validate(rawData);
+	if (validation instanceof Promise) return validation.then((result) => processValidationResult(result));
+	return processValidationResult(validation);
+}
+/**
+* Creates a config context for use with Optique parsers.
+*
+* The config context implements the `SourceContext` interface and can be used
+* with `runWith()` from *@optique/core* or `run()`/`runAsync()` from
+* *@optique/run* to provide configuration file support.
+*
+* @template T The output type of the config schema.
+* @template TConfigMeta The metadata type for config sources.
+* @param options Configuration options including schema and optional file
+*   parser.
+* @returns A config context that can be used with `bindConfig()` and runners.
+* @throws {TypeError} If `schema` is not a valid Standard Schema object.
+* @throws {TypeError} If `fileParser` is provided but is not a function.
+* @since 0.10.0
+*
+* @example
+* ```typescript
+* import { z } from "zod";
+* import { createConfigContext } from "@optique/config";
+*
+* const schema = z.object({
+*   host: z.string(),
+*   port: z.number(),
+* });
+*
+* const configContext = createConfigContext({ schema });
+* ```
+*/
+function createConfigContext(options) {
+	const rawSchema = options.schema;
+	if (!isStandardSchema(rawSchema)) throw new TypeError(`Expected schema to be a Standard Schema object, but got: ${getTypeName(rawSchema)}.`);
+	const rawFileParser = options.fileParser;
+	if (rawFileParser !== void 0 && typeof rawFileParser !== "function") throw new TypeError(`Expected fileParser to be a function, but got: ${getTypeName(rawFileParser)}.`);
+	const contextId = Symbol(`@optique/config:${Math.random()}`);
+	const context = {
+		id: contextId,
+		schema: rawSchema,
+		mode: "dynamic",
+		getInternalAnnotations(parsed, annotations) {
+			if (parsed === void 0) return { [contextId]: phase1ConfigAnnotationMarker };
+			return Object.getOwnPropertySymbols(annotations).includes(contextId) ? void 0 : { [contextId]: void 0 };
+		},
+		finalizeParsed(parsed) {
+			return parsed === void 0 ? { [phase2UndefinedParsedValueKey]: true } : parsed;
+		},
+		getAnnotations(parsed, runtimeOptions) {
+			if (parsed === void 0) return {};
+			const opts = runtimeOptions;
+			if (!opts || !opts.getConfigPath && !opts.load) throw new TypeError("Either getConfigPath or load must be provided in the runner options when using ConfigContext.");
+			if (opts.load !== void 0 && typeof opts.load !== "function") throw new TypeError(`Expected load to be a function, but got: ${getTypeName(opts.load)}.`);
+			if (!opts.load && opts.getConfigPath !== void 0 && typeof opts.getConfigPath !== "function") throw new TypeError(`Expected getConfigPath to be a function, but got: ${getTypeName(opts.getConfigPath)}.`);
+			const parsedValue = isPhase2UndefinedParsedValue(parsed) ? void 0 : stripDeferredPromptValues(parsed);
+			const parsedPlaceholder = parsedValue;
+			const buildAnnotations = (configData, configMeta) => {
+				if (configData === void 0 || configData === null) return {};
+				setActiveConfig(contextId, configData);
+				if (configMeta !== void 0) {
+					setActiveConfigMeta(contextId, configMeta);
+					return { [contextId]: {
+						data: configData,
+						meta: configMeta
+					} };
+				}
+				return { [contextId]: { data: configData } };
+			};
+			const validateAndBuildAnnotations = (rawData, configMeta) => {
+				const validated = validateWithSchema(rawSchema, rawData);
+				if (validated instanceof Promise) return validated.then((configData) => buildAnnotations(configData, configMeta));
+				return buildAnnotations(validated, configMeta);
+			};
+			if (opts.load) {
+				const loaded = opts.load(parsedPlaceholder);
+				if (loaded instanceof Promise) return loaded.then(({ config, meta }) => validateAndBuildAnnotations(config, meta));
+				return validateAndBuildAnnotations(loaded.config, loaded.meta);
+			}
+			if (opts.getConfigPath) {
+				const configPath = opts.getConfigPath(parsedPlaceholder);
+				if (configPath !== void 0 && typeof configPath !== "string") throw new TypeError(`Expected getConfigPath() to return a string or undefined, but got: ${getTypeName(configPath)}.`);
+				if (!configPath) return {};
+				const absoluteConfigPath = (0, node_path.resolve)(configPath);
+				const singleFileMeta = {
+					configDir: (0, node_path.dirname)(absoluteConfigPath),
+					configPath: absoluteConfigPath
+				};
+				try {
+					const contents = (0, node_fs.readFileSync)(absoluteConfigPath);
+					let rawData;
+					if (rawFileParser) rawData = rawFileParser(contents);
+					else {
+						const text = new TextDecoder().decode(contents);
+						rawData = JSON.parse(text);
+					}
+					return validateAndBuildAnnotations(rawData, singleFileMeta);
+				} catch (error) {
+					if (isErrnoException(error) && error.code === "ENOENT") return {};
+					if (error instanceof SyntaxError) throw new Error(`Failed to parse config file ${absoluteConfigPath}: ${error.message}`);
+					throw error;
+				}
+			}
+			return {};
+		},
+		[Symbol.dispose]() {
+			clearActiveConfig(contextId);
+			clearActiveConfigMeta(contextId);
+		}
+	};
+	return context;
+}
+/**
+* Binds a parser to configuration values with fallback priority.
+*
+* The binding implements the following priority order:
+* 1. CLI argument (if provided)
+* 2. Config file value (if available)
+* 3. Default value (if specified)
+* 4. Error (if none of the above)
+*
+* @template M The parser mode (sync or async).
+* @template TValue The parser value type.
+* @template TState The parser state type.
+* @template T The config data type.
+* @param parser The parser to bind to config values.
+* @param options Binding options including context, key, and default.
+* @returns A new parser with config fallback behavior.
+* @throws {TypeError} If `key` is not a property key or function.
+* @since 0.10.0
+*
+* @example
+* ```typescript
+* import { bindConfig } from "@optique/config";
+* import { option } from "@optique/core/primitives";
+* import { string } from "@optique/core/valueparser";
+*
+* const hostParser = bindConfig(option("--host", string()), {
+*   context: configContext,
+*   key: "host",
+*   default: "localhost",
+* });
+* ```
+*/
+function bindConfig(parser, options) {
+	const keyType = typeof options.key;
+	if (keyType !== "string" && keyType !== "number" && keyType !== "symbol" && keyType !== "function") throw new TypeError(`Expected key to be a property key or function, but got: ${getTypeName(options.key)}.`);
+	const configBindStateKey = Symbol("@optique/config/bindState");
+	function isConfigBindState(value) {
+		return value != null && typeof value === "object" && configBindStateKey in value;
+	}
+	function shouldDeferPromptUntilConfigResolves(state) {
+		const annotations = (0, __optique_core_annotations.getAnnotations)(state);
+		return annotations?.[options.context.id] === phase1ConfigAnnotationMarker;
+	}
+	const boundParser = {
+		$mode: parser.$mode,
+		$valueType: parser.$valueType,
+		$stateType: parser.$stateType,
+		priority: parser.priority,
+		usage: options.default !== void 0 ? [{
+			type: "optional",
+			terms: parser.usage
+		}] : parser.usage,
+		initialState: parser.initialState,
+		parse: (context) => {
+			const annotations = (0, __optique_core_annotations.getAnnotations)(context.state);
+			const innerState = isConfigBindState(context.state) ? context.state.hasCliValue ? context.state.cliState : parser.initialState : context.state;
+			const innerContext = innerState !== context.state ? {
+				...context,
+				state: innerState
+			} : context;
+			const processResult = (result) => {
+				if (result.success) {
+					const cliConsumed = result.consumed.length > 0;
+					const newState$1 = {
+						[configBindStateKey]: true,
+						hasCliValue: cliConsumed,
+						cliState: result.next.state,
+						...annotations && { [__optique_core_annotations.annotationKey]: annotations }
+					};
+					return {
+						success: true,
+						next: {
+							...result.next,
+							state: newState$1
+						},
+						consumed: result.consumed
+					};
+				}
+				if (result.consumed > 0) return result;
+				const newState = {
+					[configBindStateKey]: true,
+					hasCliValue: false,
+					...annotations && { [__optique_core_annotations.annotationKey]: annotations }
+				};
+				return {
+					success: true,
+					next: {
+						...innerContext,
+						state: newState
+					},
+					consumed: []
+				};
+			};
+			return (0, __optique_core_mode_dispatch.mapModeValue)(parser.$mode, parser.parse(innerContext), processResult);
+		},
+		complete: (state) => {
+			if (isConfigBindState(state) && state.hasCliValue) return parser.complete(state.cliState);
+			return (0, __optique_core_mode_dispatch.wrapForMode)(parser.$mode, getConfigOrDefault(state, options));
+		},
+		suggest: parser.suggest,
+		shouldDeferCompletion: shouldDeferPromptUntilConfigResolves,
+		getDocFragments(state, upperDefaultValue) {
+			const defaultValue = upperDefaultValue ?? options.default;
+			return parser.getDocFragments(state, defaultValue);
+		}
+	};
+	return boundParser;
+}
+/**
+* Helper function to get value from config or default.
+* Checks both annotations (for top-level parsers) and the active config
+* registry (for parsers nested inside object() when used with context-aware
+* runners).
+* @throws {TypeError} If the key callback returns a Promise or thenable.
+*/
+function getConfigOrDefault(state, options) {
+	const annotations = (0, __optique_core_annotations.getAnnotations)(state);
+	const contextId = options.context.id;
+	const annotationValue = annotations?.[contextId];
+	let configData = annotationValue?.data;
+	let configMeta = annotationValue?.meta;
+	if (configData === void 0 || configData === null) {
+		configData = getActiveConfig(contextId);
+		configMeta = getActiveConfigMeta(contextId);
+	}
+	let configValue;
+	if (configData !== void 0 && configData !== null) if (typeof options.key === "function") {
+		configValue = options.key(configData, configMeta);
+		if (configValue != null && (typeof configValue === "object" || typeof configValue === "function") && "then" in configValue && typeof configValue.then === "function") throw new TypeError("The key callback must return a synchronous value, but got a thenable.");
+	} else configValue = configData[options.key];
+	if (configValue !== void 0) return {
+		success: true,
+		value: configValue
+	};
+	if (options.default !== void 0) return {
+		success: true,
+		value: options.default
+	};
+	return {
+		success: false,
+		error: __optique_core_message.message`Missing required configuration value.`
+	};
+}
+
+//#endregion
+exports.bindConfig = bindConfig;
+exports.clearActiveConfig = clearActiveConfig;
+exports.clearActiveConfigMeta = clearActiveConfigMeta;
+exports.createConfigContext = createConfigContext;
+exports.getActiveConfig = getActiveConfig;
+exports.getActiveConfigMeta = getActiveConfigMeta;
+exports.setActiveConfig = setActiveConfig;
+exports.setActiveConfigMeta = setActiveConfigMeta;