@vibesdotdev/config 0.0.1

package/src/routing/registry.ts

@@ -0,0 +1,595 @@
+/**
+ * Variant Registry
+ *
+ * Generic registry for manifest variants with lazy loading support.
+ * Can be used for providers, agents, or any discriminated config type.
+ */
+
+import {
+	type ManifestVariant,
+	type ManifestRouting,
+	type ResolvedVariant,
+	type NestedRouting,
+	type ResolvedNestedVariant,
+	type ActiveNestedVariant,
+	hasLazyVariants,
+	hasEagerVariants,
+	hasNestedLazyVariants,
+	hasNestedEagerVariants,
+	getNestedDiscriminatorPath,
+	getNestedEnablePath
+} from './types.ts';
+
+// Registry State
+
+/**
+ * Internal registry state for a specific manifest's variants
+ */
+interface RegistryState {
+	/** Loaded variants map */
+	variants: Map<string, ManifestVariant>;
+	/** Whether lazy variants have been loaded */
+	loaded: boolean;
+	/** Loading promise (for deduplication) */
+	loadingPromise?: Promise<void>;
+}
+
+/**
+ * Global registry state keyed by manifest ID
+ */
+const registryState = new Map<string, RegistryState>();
+
+// Registry Functions
+
+/**
+ * Get or create registry state for a manifest
+ */
+function getState(manifestId: string): RegistryState {
+	let state = registryState.get(manifestId);
+	if (!state) {
+		state = {
+			variants: new Map(),
+			loaded: false
+		};
+		registryState.set(manifestId, state);
+	}
+	return state;
+}
+
+/**
+ * Register a variant for a manifest
+ *
+ * @param manifestId - The manifest this variant belongs to
+ * @param variant - The variant to register
+ */
+export function registerVariant(manifestId: string, variant: ManifestVariant): void {
+	const state = getState(manifestId);
+	state.variants.set(variant.id, variant);
+}
+
+/**
+ * Register multiple variants for a manifest
+ *
+ * @param manifestId - The manifest these variants belong to
+ * @param variants - Array of variants to register
+ */
+export function registerVariants(manifestId: string, variants: ManifestVariant[]): void {
+	const state = getState(manifestId);
+	for (const variant of variants) {
+		state.variants.set(variant.id, variant);
+	}
+}
+
+/**
+ * Get a specific variant by ID
+ *
+ * @param manifestId - The manifest to look up
+ * @param variantId - The variant ID (discriminator value)
+ * @returns The variant or undefined
+ */
+export function getVariant(manifestId: string, variantId: string): ManifestVariant | undefined {
+	const state = getState(manifestId);
+	return state.variants.get(variantId);
+}
+
+/**
+ * Get all registered variants for a manifest
+ *
+ * @param manifestId - The manifest to look up
+ * @returns Map of variants keyed by ID
+ */
+export function getAllVariants(manifestId: string): Map<string, ManifestVariant> {
+	const state = getState(manifestId);
+	return new Map(state.variants);
+}
+
+/**
+ * Check if a variant is registered
+ *
+ * @param manifestId - The manifest to check
+ * @param variantId - The variant ID to check
+ * @returns Whether the variant is registered
+ */
+export function hasVariant(manifestId: string, variantId: string): boolean {
+	const state = getState(manifestId);
+	return state.variants.has(variantId);
+}
+
+/**
+ * Clear all variants for a manifest
+ *
+ * @param manifestId - The manifest to clear
+ */
+export function clearVariants(manifestId: string): void {
+	const state = getState(manifestId);
+	state.variants.clear();
+	state.loaded = false;
+	state.loadingPromise = undefined;
+}
+
+/**
+ * Clear the entire registry (useful for testing)
+ */
+export function clearRegistry(): void {
+	registryState.clear();
+}
+
+// Routing Integration
+
+/**
+ * Load variants from a routing configuration
+ * Handles both eager and lazy loading, with deduplication
+ *
+ * @param manifestId - The manifest ID
+ * @param routing - The routing configuration
+ */
+export async function loadVariantsFromRouting(
+	manifestId: string,
+	routing: ManifestRouting
+): Promise<void> {
+	const state = getState(manifestId);
+
+	// Already loaded
+	if (state.loaded) {
+		return;
+	}
+
+	// Loading in progress - wait for it
+	if (state.loadingPromise) {
+		return state.loadingPromise;
+	}
+
+	// Eager variants - just copy them
+	if (hasEagerVariants(routing)) {
+		for (const [id, variant] of routing.variants) {
+			state.variants.set(id, variant);
+		}
+		state.loaded = true;
+		return;
+	}
+
+	// Lazy variants - load them
+	if (hasLazyVariants(routing)) {
+		state.loadingPromise = (async () => {
+			try {
+				const loadedVariants = await routing.variants();
+				for (const [id, variant] of loadedVariants) {
+					state.variants.set(id, variant);
+				}
+				state.loaded = true;
+			} finally {
+				state.loadingPromise = undefined;
+			}
+		})();
+
+		return state.loadingPromise;
+	}
+}
+
+/**
+ * Resolve a variant from routing based on discriminator value
+ *
+ * @param manifestId - The manifest ID
+ * @param routing - The routing configuration
+ * @param discriminatorValue - The current value of the discriminator field
+ * @returns Resolved variant information
+ */
+export async function resolveVariant<
+	TConfig extends Record<string, unknown> = Record<string, unknown>
+>(
+	manifestId: string,
+	routing: ManifestRouting,
+	discriminatorValue: string
+): Promise<ResolvedVariant<TConfig>> {
+	// Ensure variants are loaded
+	await loadVariantsFromRouting(manifestId, routing);
+
+	const state = getState(manifestId);
+	const variant = state.variants.get(discriminatorValue) as ManifestVariant<TConfig> | undefined;
+
+	if (variant) {
+		return {
+			variant,
+			found: true,
+			discriminatorValue,
+			usedFallback: false
+		};
+	}
+
+	// Try fallback
+	if (routing.fallback) {
+		return {
+			variant: routing.fallback as ManifestVariant<TConfig>,
+			found: true,
+			discriminatorValue,
+			usedFallback: true
+		};
+	}
+
+	return {
+		variant: undefined,
+		found: false,
+		discriminatorValue,
+		usedFallback: false
+	};
+}
+
+/**
+ * Synchronously get a variant (only works if already loaded)
+ * Use this when you know variants have been pre-loaded
+ *
+ * @param manifestId - The manifest ID
+ * @param routing - The routing configuration
+ * @param discriminatorValue - The current value of the discriminator field
+ * @returns The variant or undefined
+ */
+export function resolveVariantSync<
+	TConfig extends Record<string, unknown> = Record<string, unknown>
+>(
+	manifestId: string,
+	routing: ManifestRouting,
+	discriminatorValue: string
+): ManifestVariant<TConfig> | undefined {
+	const state = getState(manifestId);
+
+	// Check if lazy variants need loading
+	if (!state.loaded && hasLazyVariants(routing)) {
+		// Can't resolve synchronously - variants not loaded
+		return undefined;
+	}
+
+	// For eager variants, ensure they're in state
+	if (hasEagerVariants(routing)) {
+		for (const [id, variant] of routing.variants) {
+			if (!state.variants.has(id)) {
+				state.variants.set(id, variant);
+			}
+		}
+	}
+
+	const variant = state.variants.get(discriminatorValue);
+	if (variant) {
+		return variant as ManifestVariant<TConfig>;
+	}
+
+	// Try fallback
+	if (routing.fallback) {
+		return routing.fallback as ManifestVariant<TConfig>;
+	}
+
+	return undefined;
+}
+
+// Nested Routing Integration
+
+/**
+ * Generate a unique registry key for a nested routing path
+ * This allows nested routings to share variants when they use the same variants map
+ *
+ * @param manifestId - The base manifest ID
+ * @param path - The nested routing path
+ */
+function getNestedRegistryKey(manifestId: string, path: string): string {
+	return `${manifestId}:${path}`;
+}
+
+/**
+ * Load variants from a nested routing configuration
+ * Handles both eager and lazy loading, with deduplication
+ *
+ * @param manifestId - The base manifest ID
+ * @param routing - The nested routing configuration
+ */
+export async function loadNestedVariantsFromRouting(
+	manifestId: string,
+	routing: NestedRouting
+): Promise<void> {
+	const registryKey = getNestedRegistryKey(manifestId, routing.path);
+	const state = getState(registryKey);
+
+	// Already loaded
+	if (state.loaded) {
+		return;
+	}
+
+	// Loading in progress - wait for it
+	if (state.loadingPromise) {
+		return state.loadingPromise;
+	}
+
+	// Eager variants - just copy them
+	if (hasNestedEagerVariants(routing)) {
+		for (const [id, variant] of routing.variants) {
+			state.variants.set(id, variant);
+		}
+		state.loaded = true;
+		return;
+	}
+
+	// Lazy variants - load them
+	if (hasNestedLazyVariants(routing)) {
+		state.loadingPromise = (async () => {
+			try {
+				const loadedVariants = await routing.variants();
+				for (const [id, variant] of loadedVariants) {
+					state.variants.set(id, variant);
+				}
+				state.loaded = true;
+			} finally {
+				state.loadingPromise = undefined;
+			}
+		})();
+
+		return state.loadingPromise;
+	}
+}
+
+/**
+ * Get a value at a dot-notation path from an object
+ */
+function getValueAtPath(obj: Record<string, unknown>, path: string): unknown {
+	const parts = path.split('.');
+	let current: unknown = obj;
+	for (const part of parts) {
+		if (current == null || typeof current !== 'object') {
+			return undefined;
+		}
+		current = (current as Record<string, unknown>)[part];
+	}
+	return current;
+}
+
+/**
+ * Resolve a nested variant from routing based on discriminator value
+ *
+ * @param manifestId - The base manifest ID
+ * @param routing - The nested routing configuration
+ * @param values - Current form values (used to extract discriminator value)
+ * @returns Resolved nested variant information
+ */
+export async function resolveNestedVariant<
+	TConfig extends Record<string, unknown> = Record<string, unknown>
+>(
+	manifestId: string,
+	routing: NestedRouting,
+	values: Record<string, unknown>
+): Promise<ResolvedNestedVariant<TConfig>> {
+	// Get the discriminator value from the nested path
+	const discriminatorPath = getNestedDiscriminatorPath(routing);
+	const discriminatorValue = getValueAtPath(values, discriminatorPath) as string | undefined;
+
+	// Check if this section is enabled
+	const enablePath = getNestedEnablePath(routing);
+	const enabled = enablePath
+		? ((getValueAtPath(values, enablePath) as boolean) ?? false)
+		: (routing.required ?? true);
+
+	// If not enabled and not required, return early
+	if (!enabled && !routing.required) {
+		return {
+			path: routing.path,
+			variant: undefined,
+			found: false,
+			discriminatorValue: discriminatorValue ?? '',
+			usedFallback: false,
+			enabled: false
+		};
+	}
+
+	// No discriminator value yet
+	if (!discriminatorValue) {
+		return {
+			path: routing.path,
+			variant: undefined,
+			found: false,
+			discriminatorValue: '',
+			usedFallback: false,
+			enabled
+		};
+	}
+
+	// Ensure variants are loaded
+	await loadNestedVariantsFromRouting(manifestId, routing);
+
+	const registryKey = getNestedRegistryKey(manifestId, routing.path);
+	const state = getState(registryKey);
+	const variant = state.variants.get(discriminatorValue) as ManifestVariant<TConfig> | undefined;
+
+	if (variant) {
+		return {
+			path: routing.path,
+			variant,
+			found: true,
+			discriminatorValue,
+			usedFallback: false,
+			enabled
+		};
+	}
+
+	// Try fallback
+	if (routing.fallback) {
+		return {
+			path: routing.path,
+			variant: routing.fallback as ManifestVariant<TConfig>,
+			found: true,
+			discriminatorValue,
+			usedFallback: true,
+			enabled
+		};
+	}
+
+	return {
+		path: routing.path,
+		variant: undefined,
+		found: false,
+		discriminatorValue,
+		usedFallback: false,
+		enabled
+	};
+}
+
+/**
+ * Resolve all nested variants from multiple routing configurations
+ *
+ * @param manifestId - The base manifest ID
+ * @param routings - Array of nested routing configurations
+ * @param values - Current form values
+ * @returns Array of resolved nested variants
+ */
+export async function resolveAllNestedVariants<
+	TConfig extends Record<string, unknown> = Record<string, unknown>
+>(
+	manifestId: string,
+	routings: NestedRouting[],
+	values: Record<string, unknown>
+): Promise<ResolvedNestedVariant<TConfig>[]> {
+	const results = await Promise.all(
+		routings.map((routing) => resolveNestedVariant<TConfig>(manifestId, routing, values))
+	);
+	return results;
+}
+
+/**
+ * Get all active nested variants (enabled and resolved)
+ *
+ * @param manifestId - The base manifest ID
+ * @param routings - Array of nested routing configurations
+ * @param values - Current form values
+ * @returns Map of active variants keyed by path
+ */
+export async function getActiveNestedVariants(
+	manifestId: string,
+	routings: NestedRouting[],
+	values: Record<string, unknown>
+): Promise<Map<string, ActiveNestedVariant>> {
+	const resolved = await resolveAllNestedVariants(manifestId, routings, values);
+	const active = new Map<string, ActiveNestedVariant>();
+
+	for (const result of resolved) {
+		if (result.found && result.variant && result.enabled) {
+			active.set(result.path, {
+				path: result.path,
+				discriminatorValue: result.discriminatorValue,
+				variant: result.variant,
+				enabled: result.enabled
+			});
+		}
+	}
+
+	return active;
+}
+
+/**
+ * Synchronously get a nested variant (only works if already loaded)
+ *
+ * @param manifestId - The base manifest ID
+ * @param routing - The nested routing configuration
+ * @param discriminatorValue - The discriminator value
+ * @returns The variant or undefined
+ */
+export function resolveNestedVariantSync<
+	TConfig extends Record<string, unknown> = Record<string, unknown>
+>(
+	manifestId: string,
+	routing: NestedRouting,
+	discriminatorValue: string
+): ManifestVariant<TConfig> | undefined {
+	const registryKey = getNestedRegistryKey(manifestId, routing.path);
+	const state = getState(registryKey);
+
+	// Check if lazy variants need loading
+	if (!state.loaded && hasNestedLazyVariants(routing)) {
+		// Can't resolve synchronously - variants not loaded
+		return undefined;
+	}
+
+	// For eager variants, ensure they're in state
+	if (hasNestedEagerVariants(routing)) {
+		for (const [id, variant] of routing.variants) {
+			if (!state.variants.has(id)) {
+				state.variants.set(id, variant);
+			}
+		}
+	}
+
+	const variant = state.variants.get(discriminatorValue);
+	if (variant) {
+		return variant as ManifestVariant<TConfig>;
+	}
+
+	// Try fallback
+	if (routing.fallback) {
+		return routing.fallback as ManifestVariant<TConfig>;
+	}
+
+	return undefined;
+}
+
+/**
+ * Check if nested variants are loaded for a manifest path
+ */
+export function areNestedVariantsLoaded(manifestId: string, path: string): boolean {
+	const registryKey = getNestedRegistryKey(manifestId, path);
+	const state = registryState.get(registryKey);
+	return state?.loaded ?? false;
+}
+
+/**
+ * Get all nested variants for a manifest path
+ */
+export function getAllNestedVariants(
+	manifestId: string,
+	path: string
+): Map<string, ManifestVariant> {
+	const registryKey = getNestedRegistryKey(manifestId, path);
+	const state = getState(registryKey);
+	return new Map(state.variants);
+}
+
+// Registry Information
+
+/**
+ * Get registry status for debugging
+ */
+export function getRegistryStatus(): {
+	manifests: string[];
+	variants: Record<string, string[]>;
+} {
+	const manifests: string[] = [];
+	const variants: Record<string, string[]> = {};
+
+	for (const [manifestId, state] of registryState) {
+		manifests.push(manifestId);
+		variants[manifestId] = Array.from(state.variants.keys());
+	}
+
+	return { manifests, variants };
+}
+
+/**
+ * Check if variants are loaded for a manifest
+ */
+export function areVariantsLoaded(manifestId: string): boolean {
+	const state = registryState.get(manifestId);
+	return state?.loaded ?? false;
+}

package/src/routing/schemas/merge.schema.ts

@@ -0,0 +1,6 @@
+import type { ConfigFieldGroup, ConfigFieldMeta } from '../../manifest/types.ts';
+
+export interface MergeManifestOptions {
+	mergeSchemas?: boolean;
+	injectIntoSteps?: boolean;
+}