@nbreak/core 0.1.0

package/dist/cjs/index.cjs

@@ -0,0 +1,831 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _nbreak_shared = require("@nbreak/shared");
+//#region src/pluginSystem.js
+/**
+* @nbreak/core - 插件系统
+*
+* 升级自现有 src/core/pluginSystem.js，保留 hooks 机制并扩展：
+*   - 增加中间件支持（hook 前后置拦截）
+*   - 增加钩子结果聚合策略
+*   - 与 ExtensionRegistry 协同
+*/
+/**
+* 钩子聚合策略
+*/
+var HOOK_AGGREGATE_STRATEGIES = {
+	/** 后者覆盖前者（默认，pipe 风格） */
+	PIPE: "pipe",
+	/** 收集所有结果为数组 */
+	COLLECT: "collect",
+	/** 取第一个非空结果 */
+	FIRST: "first",
+	/** 取最后一个非空结果 */
+	LAST: "last",
+	/** 并行执行，结果为数组（无序） */
+	PARALLEL: "parallel"
+};
+var PluginSystem = class {
+	constructor() {
+		this.plugins = /* @__PURE__ */ new Map();
+		this.hooks = /* @__PURE__ */ new Map();
+		this.middlewares = [];
+	}
+	/**
+	* 注册插件
+	* @param {Object} plugin - 插件定义
+	* @param {string} plugin.name - 插件名称（唯一）
+	* @param {Function} plugin.install - 安装函数 (api) => {}
+	* @param {Function} [plugin.uninstall] - 卸载函数
+	*/
+	register(plugin) {
+		if (!plugin || !plugin.name) {
+			console.warn("[DataScreen] 插件注册失败：缺少 name 字段");
+			return this;
+		}
+		if (this.plugins.has(plugin.name)) {
+			console.warn(`[DataScreen] 插件 "${plugin.name}" 已注册，跳过`);
+			return this;
+		}
+		const api = this._createPluginApi(plugin.name);
+		if (typeof plugin.install === "function") try {
+			plugin.install(api);
+		} catch (e) {
+			console.error(`[DataScreen] 插件 "${plugin.name}" 安装失败:`, e);
+		}
+		this.plugins.set(plugin.name, {
+			...plugin,
+			api
+		});
+		return this;
+	}
+	/**
+	* 注入钩子（按优先级顺序执行）
+	* @param {string} hookName - 钩子名称
+	* @param {Object} [context={}] - 上下文数据
+	* @param {Object} [options] - 执行选项
+	* @param {string} [options.strategy] - 聚合策略
+	* @returns {*} 钩子执行结果
+	*/
+	async callHook(hookName, context = {}, options = {}) {
+		const sorted = [...this.hooks.get(hookName) || []].sort((a, b) => a.priority - b.priority);
+		const strategy = options.strategy || HOOK_AGGREGATE_STRATEGIES.PIPE;
+		let processedContext = context;
+		for (const mw of this.middlewares) if (mw.before) try {
+			processedContext = await mw.before(hookName, processedContext);
+		} catch (e) {
+			console.error(`[DataScreen] 中间件 before 错误 (${hookName}):`, e);
+		}
+		if (strategy === HOOK_AGGREGATE_STRATEGIES.COLLECT || strategy === HOOK_AGGREGATE_STRATEGIES.PARALLEL) {
+			if (strategy === HOOK_AGGREGATE_STRATEGIES.PARALLEL) return (await Promise.allSettled(sorted.map((h) => Promise.resolve(h.handler((0, _nbreak_shared.deepClone)(processedContext)))))).map((r) => r.status === "fulfilled" ? r.value : null);
+			const collected = [];
+			for (const handler of sorted) try {
+				const result = await handler.handler((0, _nbreak_shared.deepClone)(processedContext));
+				collected.push(result);
+			} catch (e) {
+				console.error(`[DataScreen] Hook "${hookName}" 错误 (${handler.pluginName}):`, e);
+			}
+			return collected;
+		}
+		if (strategy === HOOK_AGGREGATE_STRATEGIES.FIRST) {
+			for (const handler of sorted) try {
+				const result = await handler.handler((0, _nbreak_shared.deepClone)(processedContext));
+				if (result !== void 0 && result !== null) return result;
+			} catch (e) {
+				console.error(`[DataScreen] Hook "${hookName}" 错误 (${handler.pluginName}):`, e);
+			}
+			return;
+		}
+		if (strategy === HOOK_AGGREGATE_STRATEGIES.LAST) {
+			let lastResult;
+			for (const handler of sorted) try {
+				const result = await handler.handler((0, _nbreak_shared.deepClone)(processedContext));
+				if (result !== void 0 && result !== null) lastResult = result;
+			} catch (e) {
+				console.error(`[DataScreen] Hook "${hookName}" 错误 (${handler.pluginName}):`, e);
+			}
+			return lastResult;
+		}
+		let result = processedContext;
+		for (const handler of sorted) try {
+			result = await handler.handler(result);
+		} catch (e) {
+			console.error(`[DataScreen] Hook "${hookName}" 错误 (${handler.pluginName}):`, e);
+		}
+		for (const mw of this.middlewares) if (mw.after) try {
+			result = await mw.after(hookName, result);
+		} catch (e) {
+			console.error(`[DataScreen] 中间件 after 错误 (${hookName}):`, e);
+		}
+		return result;
+	}
+	/**
+	* 同步注入钩子（不等待 Promise）
+	* @param {string} hookName
+	* @param {Object} [context={}]
+	* @returns {Object}
+	*/
+	callHookSync(hookName, context = {}) {
+		const sorted = [...this.hooks.get(hookName) || []].sort((a, b) => a.priority - b.priority);
+		let result = context;
+		for (const handler of sorted) try {
+			const ret = handler.handler(result);
+			if (ret !== void 0) result = ret;
+		} catch (e) {
+			console.error(`[DataScreen] Hook sync "${hookName}" 错误 (${handler.pluginName}):`, e);
+		}
+		return result;
+	}
+	/**
+	* 添加全局中间件
+	* @param {Object} middleware
+	* @param {Function} [middleware.before]
+	* @param {Function} [middleware.after]
+	*/
+	use(middleware) {
+		if (middleware && (middleware.before || middleware.after)) this.middlewares.push(middleware);
+		return this;
+	}
+	/**
+	* 获取所有已注册插件
+	*/
+	getPlugins() {
+		return Array.from(this.plugins.values());
+	}
+	/**
+	* 获取插件
+	*/
+	getPlugin(name) {
+		return this.plugins.get(name);
+	}
+	/**
+	* 检查插件是否已注册
+	*/
+	hasPlugin(name) {
+		return this.plugins.has(name);
+	}
+	/**
+	* 获取所有钩子名
+	*/
+	getHookNames() {
+		return Array.from(this.hooks.keys());
+	}
+	/**
+	* 获取某个钩子的处理器数量
+	*/
+	getHookHandlerCount(hookName) {
+		return (this.hooks.get(hookName) || []).length;
+	}
+	/**
+	* 卸载插件
+	*/
+	unregister(name) {
+		const plugin = this.plugins.get(name);
+		if (plugin && typeof plugin.uninstall === "function") try {
+			plugin.uninstall();
+		} catch (e) {
+			console.error(`[DataScreen] 插件 "${name}" 卸载失败:`, e);
+		}
+		this.plugins.delete(name);
+		this.hooks.forEach((handlers, hookName) => {
+			this.hooks.set(hookName, handlers.filter((h) => h.pluginName !== name));
+		});
+		return this;
+	}
+	/**
+	* 清空所有插件与钩子
+	*/
+	clear() {
+		this.plugins.clear();
+		this.hooks.clear();
+		this.middlewares = [];
+		return this;
+	}
+	/**
+	* 为插件创建 API 对象
+	*/
+	_createPluginApi(pluginName) {
+		return {
+			pluginName,
+			/**
+			* 注册钩子处理器
+			* @param {string} hookName
+			* @param {Function} handler
+			* @param {number} [priority=100] - 优先级（越小越先执行）
+			*/
+			hook: (hookName, handler, priority = 100) => {
+				if (typeof handler !== "function") {
+					console.warn(`[DataScreen] 插件 "${pluginName}" 注册钩子 "${hookName}" 失败：handler 不是函数`);
+					return;
+				}
+				if (!this.hooks.has(hookName)) this.hooks.set(hookName, []);
+				this.hooks.get(hookName).push({
+					pluginName,
+					handler,
+					priority
+				});
+			},
+			/**
+			* 注册多个钩子
+			* @param {Object} hooks - { hookName: handler }
+			*/
+			hooks: (hooks = {}) => {
+				Object.entries(hooks).forEach(([hookName, handler]) => {
+					if (typeof handler === "function") this._createPluginApi(pluginName).hook(hookName, handler);
+				});
+			},
+			/**
+			* 获取已注册插件
+			*/
+			getPlugin: (name) => this.plugins.get(name),
+			/**
+			* 获取所有插件
+			*/
+			getPlugins: () => Array.from(this.plugins.values())
+		};
+	}
+};
+var pluginSystem = new PluginSystem();
+//#endregion
+//#region src/eventBus.js
+/**
+* @nbreak/core - 事件总线（统一版）
+*
+* 合并原 core 与 app(interactions/EventBus) 两套实现，作为唯一事件总线：
+*   - 标准 on/off/once/emit（同步触发，双参 handler(data, meta)）
+*   - emitSync 别名 / emitAsync 异步触发（await handler 返回的 Promise）
+*   - 通配符订阅（component:*）+ 命名空间级通配（user:*）
+*   - 优先级排序、命名空间隔离、createNamespace 子总线
+*   - waitFor（Promise 风格等待事件）
+*   - clearEvent / clearNamespace / offNamespace / clear
+*   - listenerCount / eventNames / getEvents / getNamespaces
+*/
+/**
+* 事件总线类
+*/
+var EventBus = class {
+	constructor() {
+		this.events = /* @__PURE__ */ new Map();
+		this.namespaces = /* @__PURE__ */ new Map();
+		this.wildcardListeners = [];
+	}
+	/**
+	* 解析事件名称，提取命名空间
+	* @param {string} event - 事件名称 (如: 'user:login', 'data:update')
+	* @returns {{ event: string, namespace: string|null, action: string }}
+	*/
+	parseEventName(event) {
+		const parts = event.split(":");
+		return {
+			event,
+			namespace: parts.length > 1 ? parts[0] : null,
+			action: parts.length > 1 ? parts.slice(1).join(":") : event
+		};
+	}
+	/**
+	* 订阅事件
+	* @param {string} event - 事件名称，支持通配符（如 'component:*'）与命名空间
+	* @param {Function} callback - 回调函数 (data, meta) => void
+	* @param {Object} [options]
+	* @param {string} [options.namespace] - 命名空间
+	* @param {number} [options.priority] - 优先级（数字越大越先执行）
+	* @returns {Function} 取消订阅函数
+	*/
+	on(event, callback, options = {}) {
+		if (typeof callback !== "function") {
+			console.warn("[EventBus] callback 必须是函数");
+			return () => {};
+		}
+		const { namespace, priority = 0 } = options;
+		const eventKey = namespace ? `${namespace}:${event}` : event;
+		if (event.includes("*")) {
+			this.wildcardListeners.push({
+				pattern: event,
+				regex: new RegExp("^" + event.replace(/\*/g, ".*") + "$"),
+				callback,
+				priority
+			});
+			return () => this.offWildcard(callback);
+		}
+		if (!this.events.has(eventKey)) this.events.set(eventKey, []);
+		const listeners = this.events.get(eventKey);
+		const listener = {
+			callback,
+			priority,
+			namespace
+		};
+		const insertIndex = listeners.findIndex((l) => l.priority < priority);
+		if (insertIndex === -1) listeners.push(listener);
+		else listeners.splice(insertIndex, 0, listener);
+		if (namespace) {
+			if (!this.namespaces.has(namespace)) this.namespaces.set(namespace, /* @__PURE__ */ new Set());
+			this.namespaces.get(namespace).add(eventKey);
+		}
+		return () => this.off(eventKey, callback);
+	}
+	/**
+	* 订阅事件（只触发一次）
+	*/
+	once(event, callback, options = {}) {
+		const { namespace } = options;
+		const eventKey = namespace ? `${namespace}:${event}` : event;
+		const wrapper = (data, meta) => {
+			callback(data, meta);
+			this.off(eventKey, wrapper);
+		};
+		return this.on(event, wrapper, options);
+	}
+	/**
+	* 取消订阅
+	* @param {string} event - 事件名称（或 eventKey）
+	* @param {Function} callback - 回调函数；省略则清空该事件所有订阅
+	*/
+	off(event, callback) {
+		const listeners = this.events.get(event);
+		if (listeners) if (callback) {
+			const index = listeners.findIndex((l) => l.callback === callback);
+			if (index > -1) listeners.splice(index, 1);
+			if (listeners.length === 0) this.events.delete(event);
+		} else this.events.delete(event);
+		return this;
+	}
+	/**
+	* 取消通配符订阅
+	*/
+	offWildcard(callback) {
+		const index = this.wildcardListeners.findIndex((l) => l.callback === callback);
+		if (index > -1) this.wildcardListeners.splice(index, 1);
+		return this;
+	}
+	/**
+	* 同步触发事件（默认行为）
+	*
+	* handler 接收双参：(data, meta)
+	* meta 包含 { timestamp, event, namespace }
+	*
+	* @param {string} event - 事件名称
+	* @param {*} [data] - 事件数据
+	* @param {Object} [meta] - 额外元数据
+	*/
+	emit(event, data, meta = {}) {
+		const timestamp = Date.now();
+		const eventInfo = this.parseEventName(event);
+		const fullMeta = {
+			...meta,
+			timestamp,
+			event,
+			namespace: eventInfo.namespace
+		};
+		const listeners = this.events.get(event);
+		if (listeners) [...listeners].forEach(({ callback }) => {
+			try {
+				callback(data, fullMeta);
+			} catch (e) {
+				console.error(`[EventBus] 事件 "${event}" 处理错误:`, e);
+			}
+		});
+		this.wildcardListeners.forEach(({ regex, callback }) => {
+			if (regex.test(event)) try {
+				callback(data, fullMeta);
+			} catch (e) {
+				console.error(`[EventBus] 通配事件 "${event}" 处理错误:`, e);
+			}
+		});
+		if (eventInfo.namespace) {
+			const nsListeners = this.events.get(`${eventInfo.namespace}:*`);
+			if (nsListeners) [...nsListeners].forEach(({ callback }) => {
+				try {
+					callback(data, fullMeta);
+				} catch (e) {
+					console.error(`[EventBus] 命名空间事件 "${event}" 处理错误:`, e);
+				}
+			});
+		}
+	}
+	/**
+	* 同步触发（emit 的别名，保持向后兼容）
+	*/
+	emitSync(event, data, meta = {}) {
+		return this.emit(event, data, meta);
+	}
+	/**
+	* 异步触发事件（等待 handler 返回的 Promise）
+	* @param {string} event
+	* @param {*} [data]
+	* @param {Object} [meta]
+	* @returns {Promise<void>}
+	*/
+	async emitAsync(event, data, meta = {}) {
+		const timestamp = Date.now();
+		const eventInfo = this.parseEventName(event);
+		const fullMeta = {
+			...meta,
+			timestamp,
+			event,
+			namespace: eventInfo.namespace
+		};
+		const runHandler = async (callback) => {
+			try {
+				const result = callback(data, fullMeta);
+				if (result && typeof result.then === "function") await result;
+			} catch (e) {
+				console.error(`[EventBus] async 事件 "${event}" 处理错误:`, e);
+			}
+		};
+		const listeners = this.events.get(event);
+		if (listeners) for (const { callback } of listeners) await runHandler(callback);
+		for (const { regex, callback } of this.wildcardListeners) if (regex.test(event)) await runHandler(callback);
+		if (eventInfo.namespace) {
+			const nsListeners = this.events.get(`${eventInfo.namespace}:*`);
+			if (nsListeners) for (const { callback } of nsListeners) await runHandler(callback);
+		}
+	}
+	/**
+	* 清除指定事件的所有订阅
+	*/
+	clearEvent(event) {
+		this.events.delete(event);
+		return this;
+	}
+	/**
+	* 清除指定命名空间的所有订阅
+	*/
+	clearNamespace(namespace) {
+		const events = this.namespaces.get(namespace);
+		if (events) {
+			events.forEach((event) => this.events.delete(event));
+			this.namespaces.delete(namespace);
+		}
+		return this;
+	}
+	/**
+	* 取消某命名空间下的所有订阅（clearNamespace 别名，向后兼容）
+	*/
+	offNamespace(namespace) {
+		return this.clearNamespace(namespace);
+	}
+	/**
+	* 清空所有订阅
+	*/
+	clear() {
+		this.events.clear();
+		this.namespaces.clear();
+		this.wildcardListeners = [];
+		return this;
+	}
+	/**
+	* 获取事件的监听器数量
+	*/
+	listenerCount(event) {
+		const listeners = this.events.get(event);
+		return listeners ? listeners.length : 0;
+	}
+	/**
+	* 获取所有注册的事件名（eventNames 别名）
+	*/
+	getEvents() {
+		return Array.from(this.events.keys());
+	}
+	eventNames() {
+		return this.getEvents();
+	}
+	/**
+	* 获取所有命名空间
+	*/
+	getNamespaces() {
+		return Array.from(this.namespaces.keys());
+	}
+	/**
+	* 等待某个事件触发（Promise 风格）
+	* @param {string} event
+	* @param {number} [timeout=5000] - 超时毫秒
+	* @returns {Promise} 事件数据
+	*/
+	waitFor(event, timeout = 5e3) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.off(event, handler);
+				reject(/* @__PURE__ */ new Error(`Timeout waiting for event: ${event}`));
+			}, timeout);
+			const handler = (data) => {
+				clearTimeout(timer);
+				this.off(event, handler);
+				resolve(data);
+			};
+			this.on(event, handler);
+		});
+	}
+	/**
+	* 创建命名空间子总线
+	* @param {string} namespace
+	* @returns {{ on, once, emit, clear }}
+	*/
+	createNamespace(namespace) {
+		return {
+			on: (event, callback, options = {}) => this.on(event, callback, {
+				...options,
+				namespace
+			}),
+			once: (event, callback, options = {}) => this.once(event, callback, {
+				...options,
+				namespace
+			}),
+			emit: (event, data, meta = {}) => this.emit(`${namespace}:${event}`, data, meta),
+			clear: () => this.clearNamespace(namespace)
+		};
+	}
+	/**
+	* 通配符匹配（内部使用，保留以兼容直接调用）
+	*/
+	_matchPattern(pattern, event) {
+		if (!pattern.includes("*")) return false;
+		return new RegExp("^" + pattern.replace(/\*/g, ".*") + "$").test(event);
+	}
+};
+var eventBus = new EventBus();
+//#endregion
+//#region src/extensionRegistry.js
+/**
+* @nbreak/core - 扩展注册表
+*
+* 核心扩展注册表，按 type 分桶管理所有扩展物
+* 静态加载与动态加载的扩展最终都通过 register() 装载到此
+*
+* 对标：
+*   - Superset: PluginContext.registerPlugin()
+*   - DataV: 组件市场注册中心
+*   - Tableau: Extensions Service
+*/
+var { HOOK_NAMES: HOOK_NAMES$1 } = { HOOK_NAMES: {
+	BEFORE_EXTENSION_REGISTER: "beforeExtensionRegister",
+	AFTER_EXTENSION_REGISTER: "afterExtensionRegister",
+	BEFORE_EXTENSION_UNREGISTER: "beforeExtensionUnregister"
+} };
+var ExtensionRegistry = class {
+	constructor() {
+		this.buckets = /* @__PURE__ */ new Map();
+		for (const type of _nbreak_shared.ALL_EXTENSION_TYPES) this.buckets.set(type, /* @__PURE__ */ new Map());
+		this.nameIndex = /* @__PURE__ */ new Map();
+		this._disposers = [];
+	}
+	/**
+	* 注册扩展
+	* @param {Object} extension - 扩展定义对象
+	* @returns {boolean} 是否注册成功
+	*/
+	async register(extension) {
+		if (!extension || !extension.type || !extension.name) {
+			console.warn("[DataScreen Registry] 扩展注册失败：缺少 type 或 name", extension);
+			return false;
+		}
+		if (!_nbreak_shared.ALL_EXTENSION_TYPES.includes(extension.type)) {
+			console.warn(`[DataScreen Registry] 无效的扩展类型: "${extension.type}"`);
+			return false;
+		}
+		if (this.nameIndex.has(extension.name)) {
+			console.warn(`[DataScreen Registry] 扩展 "${extension.name}" 已注册，跳过`);
+			return false;
+		}
+		if (extension.manifest) {
+			const { valid, errors } = (0, _nbreak_shared.validateManifest)(extension.manifest);
+			if (!valid) {
+				console.warn(`[DataScreen Registry] 扩展 "${extension.name}" manifest 校验失败:`, errors);
+				return false;
+			}
+		}
+		try {
+			await pluginSystem.callHook(HOOK_NAMES$1.BEFORE_EXTENSION_REGISTER, { extension });
+		} catch (e) {
+			console.error(`[DataScreen Registry] 扩展 "${extension.name}" 前置钩子异常:`, e);
+		}
+		const bucket = this.buckets.get(extension.type);
+		const ext = {
+			...extension,
+			status: _nbreak_shared.EXTENSION_STATUS.REGISTERED,
+			registeredAt: Date.now()
+		};
+		bucket.set(extension.name, ext);
+		this.nameIndex.set(extension.name, extension.type);
+		eventBus.emit("extension:registered", {
+			type: extension.type,
+			name: extension.name,
+			extension: ext
+		});
+		try {
+			await pluginSystem.callHook(HOOK_NAMES$1.AFTER_EXTENSION_REGISTER, { extension: ext });
+		} catch (e) {
+			console.error(`[DataScreen Registry] 扩展 "${extension.name}" 后置钩子异常:`, e);
+		}
+		return true;
+	}
+	/**
+	* 批量注册扩展
+	*/
+	async registerAll(extensions) {
+		if (!Array.isArray(extensions)) return [];
+		const results = [];
+		for (const ext of extensions) results.push(await this.register(ext));
+		return results;
+	}
+	/**
+	* 注销扩展
+	*/
+	async unregister(name) {
+		const type = this.nameIndex.get(name);
+		if (!type) return false;
+		try {
+			await pluginSystem.callHook(HOOK_NAMES$1.BEFORE_EXTENSION_UNREGISTER, {
+				name,
+				type
+			});
+		} catch (e) {
+			console.error(`[DataScreen Registry] 扩展 "${name}" 注销前置钩子异常:`, e);
+		}
+		const bucket = this.buckets.get(type);
+		const ext = bucket.get(name);
+		bucket.delete(name);
+		this.nameIndex.delete(name);
+		eventBus.emit("extension:unregistered", {
+			name,
+			type,
+			extension: ext
+		});
+		return true;
+	}
+	/**
+	* 获取扩展（按 type + name）
+	*/
+	get(type, name) {
+		const bucket = this.buckets.get(type);
+		if (!bucket) return null;
+		return bucket.get(name) || null;
+	}
+	/**
+	* 按 name 跨类型查找
+	*/
+	getByName(name) {
+		const type = this.nameIndex.get(name);
+		if (!type) return null;
+		return this.get(type, name);
+	}
+	/**
+	* 获取某类型的所有扩展
+	*/
+	getByType(type) {
+		const bucket = this.buckets.get(type);
+		if (!bucket) return [];
+		return Array.from(bucket.values());
+	}
+	/**
+	* 获取所有扩展
+	*/
+	getAll() {
+		const all = [];
+		for (const bucket of this.buckets.values()) for (const ext of bucket.values()) all.push(ext);
+		return all;
+	}
+	/**
+	* 检查扩展是否存在
+	*/
+	has(name) {
+		return this.nameIndex.has(name);
+	}
+	/**
+	* 按类型检查扩展是否存在
+	*/
+	hasOfType(type, name) {
+		const bucket = this.buckets.get(type);
+		return bucket ? bucket.has(name) : false;
+	}
+	/**
+	* 获取扩展数量
+	*/
+	size(type) {
+		if (type) {
+			const bucket = this.buckets.get(type);
+			return bucket ? bucket.size : 0;
+		}
+		return this.nameIndex.size;
+	}
+	/**
+	* 启用扩展
+	*/
+	enable(name) {
+		const ext = this.getByName(name);
+		if (ext) {
+			ext.status = _nbreak_shared.EXTENSION_STATUS.ENABLED;
+			eventBus.emit("extension:enabled", {
+				name,
+				type: ext.type
+			});
+		}
+		return this;
+	}
+	/**
+	* 禁用扩展
+	*/
+	disable(name) {
+		const ext = this.getByName(name);
+		if (ext) {
+			ext.status = _nbreak_shared.EXTENSION_STATUS.DISABLED;
+			eventBus.emit("extension:disabled", {
+				name,
+				type: ext.type
+			});
+		}
+		return this;
+	}
+	/**
+	* 是否启用
+	*/
+	isEnabled(name) {
+		const ext = this.getByName(name);
+		return ext ? ext.status === _nbreak_shared.EXTENSION_STATUS.ENABLED : false;
+	}
+	/**
+	* 按分类筛选组件扩展
+	*/
+	getComponentsByCategory(category) {
+		return this.getByType(_nbreak_shared.EXTENSION_TYPES.COMPONENT).filter((ext) => ext.definition && ext.definition.category === category);
+	}
+	/**
+	* 搜索组件扩展
+	*/
+	searchComponents(keyword) {
+		const components = this.getByType(_nbreak_shared.EXTENSION_TYPES.COMPONENT);
+		if (!keyword) return components;
+		const lower = keyword.toLowerCase();
+		return components.filter((ext) => {
+			const def = ext.definition || {};
+			return (ext.name || "").toLowerCase().includes(lower) || (def.name || "").toLowerCase().includes(lower) || (ext.displayName || "").toLowerCase().includes(lower) || (def.description || "").toLowerCase().includes(lower) || (def.tags || []).some((t) => t.toLowerCase().includes(lower));
+		});
+	}
+	/**
+	* 清空所有扩展
+	*/
+	clear() {
+		for (const bucket of this.buckets.values()) bucket.clear();
+		this.nameIndex.clear();
+		return this;
+	}
+	/**
+	* 获取注册表快照（用于调试/序列化）
+	*/
+	snapshot() {
+		const snap = {};
+		for (const [type, bucket] of this.buckets) snap[type] = Array.from(bucket.keys());
+		return snap;
+	}
+};
+var extensionRegistry = new ExtensionRegistry();
+//#endregion
+//#region src/index.js
+var VERSION = "0.1.0";
+var PACKAGE_NAME = "@nbreak/core";
+//#endregion
+Object.defineProperty(exports, "ALL_EXTENSION_TYPES", {
+	enumerable: true,
+	get: function() {
+		return _nbreak_shared.ALL_EXTENSION_TYPES;
+	}
+});
+Object.defineProperty(exports, "COMPONENT_CATEGORIES", {
+	enumerable: true,
+	get: function() {
+		return _nbreak_shared.COMPONENT_CATEGORIES;
+	}
+});
+Object.defineProperty(exports, "EXTENSION_STATUS", {
+	enumerable: true,
+	get: function() {
+		return _nbreak_shared.EXTENSION_STATUS;
+	}
+});
+Object.defineProperty(exports, "EXTENSION_TYPES", {
+	enumerable: true,
+	get: function() {
+		return _nbreak_shared.EXTENSION_TYPES;
+	}
+});
+exports.EventBus = EventBus;
+exports.ExtensionRegistry = ExtensionRegistry;
+exports.HOOK_AGGREGATE_STRATEGIES = HOOK_AGGREGATE_STRATEGIES;
+Object.defineProperty(exports, "HOOK_NAMES", {
+	enumerable: true,
+	get: function() {
+		return _nbreak_shared.HOOK_NAMES;
+	}
+});
+exports.PACKAGE_NAME = PACKAGE_NAME;
+Object.defineProperty(exports, "PROPERTY_FIELD_TYPES", {
+	enumerable: true,
+	get: function() {
+		return _nbreak_shared.PROPERTY_FIELD_TYPES;
+	}
+});
+exports.PluginSystem = PluginSystem;
+exports.VERSION = VERSION;
+exports.eventBus = eventBus;
+exports.extensionRegistry = extensionRegistry;
+exports.pluginSystem = pluginSystem;
+
+//# sourceMappingURL=index.cjs.map