import { lazy } from "react";

//#region src/react-renderer/registry/ComponentRegistry.ts
/**
* Registry for A2UI components. Allows registration of custom components
* and supports lazy loading for code splitting.
*
* @example
* ```tsx
* const registry = new ComponentRegistry();
*
* // Register a component directly
* registry.register('Text', { component: Text });
*
* // Register with lazy loading
* registry.register('Modal', {
*   component: () => import('./components/Modal'),
*   lazy: true
* });
*
* // Use with A2UIRenderer
* <A2UIRenderer surfaceId="main" registry={registry} />
* ```
*/
var ComponentRegistry = class ComponentRegistry {
	constructor() {
		this.registry = /* @__PURE__ */ new Map();
		this.lazyCache = /* @__PURE__ */ new Map();
	}
	static {
		this._instance = null;
	}
	/**
	* Get the singleton instance of the registry.
	* Use this for the default global registry.
	*/
	static getInstance() {
		if (!ComponentRegistry._instance) ComponentRegistry._instance = new ComponentRegistry();
		return ComponentRegistry._instance;
	}
	/**
	* Reset the singleton instance.
	* Useful for testing.
	*/
	static resetInstance() {
		ComponentRegistry._instance = null;
	}
	/**
	* Register a component type.
	*
	* @param type - The A2UI component type name (e.g., 'Text', 'Button')
	* @param registration - The component registration
	*/
	register(type, registration) {
		this.registry.set(type, registration);
	}
	/**
	* Unregister a component type.
	*
	* @param type - The component type to unregister
	*/
	unregister(type) {
		this.registry.delete(type);
		this.lazyCache.delete(type);
	}
	/**
	* Check if a component type is registered.
	*
	* @param type - The component type to check
	* @returns True if the component is registered
	*/
	has(type) {
		return this.registry.has(type);
	}
	/**
	* Get a component by type. If the component is registered with lazy loading,
	* returns a React.lazy wrapped component.
	*
	* @param type - The component type to get
	* @returns The React component, or null if not found
	*/
	get(type) {
		const registration = this.registry.get(type);
		if (!registration) return null;
		if (registration.lazy && typeof registration.component === "function") {
			const cached = this.lazyCache.get(type);
			if (cached) return cached;
			const lazyComponent = lazy(registration.component);
			this.lazyCache.set(type, lazyComponent);
			return lazyComponent;
		}
		return registration.component;
	}
	/**
	* Get all registered component types.
	*
	* @returns Array of registered type names
	*/
	getRegisteredTypes() {
		return Array.from(this.registry.keys());
	}
	/**
	* Clear all registrations.
	*/
	clear() {
		this.registry.clear();
		this.lazyCache.clear();
	}
};

//#endregion
export { ComponentRegistry };
//# sourceMappingURL=ComponentRegistry.mjs.map