@composy/store-core 0.0.1

package/lib/middleware/time-travel.cjs

@@ -0,0 +1,154 @@
+/*!
+* ***********************************
+* @composy/store-core v0.0.1      *
+* Built with rollup               *
+* Build time: 2024-08-17 11:27:33 *
+* Build mode: production          *
+* Minified: No                    *
+* ***********************************
+*/
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_deep_clone = require("../utils/deep-clone.cjs");
+//#region src/middleware/time-travel.ts
+const defaultOptions = {
+	maxHistory: 100,
+	enabled: true
+};
+function createTimeTravelMiddleware(options = {}) {
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	const maxHistory = opts.maxHistory ?? defaultOptions.maxHistory ?? 100;
+	const history = [];
+	let currentIndex = -1;
+	let isTraveling = false;
+	let restoreCallback = () => {};
+	const addSnapshot = (snapshot) => {
+		if (!opts.enabled || isTraveling) return;
+		if (currentIndex < history.length - 1) history.splice(currentIndex + 1);
+		history.push(snapshot);
+		currentIndex = history.length - 1;
+		if (history.length > maxHistory) {
+			history.shift();
+			currentIndex--;
+		}
+	};
+	const controller = {
+		/**
+		* 撤销操作
+		* 将当前指针前移一步，恢复到上一个历史快照状态
+		*/
+		undo: () => {
+			if (!controller.canUndo()) return;
+			isTraveling = true;
+			currentIndex--;
+			const snapshot = history[currentIndex];
+			restoreCallback(snapshot.storeId, require_deep_clone.deepClone(snapshot.state));
+			isTraveling = false;
+		},
+		/**
+		* 重做操作
+		* 将当前指针后移一步，恢复到下一个历史快照状态
+		*/
+		redo: () => {
+			if (!controller.canRedo()) return;
+			isTraveling = true;
+			currentIndex++;
+			const snapshot = history[currentIndex];
+			restoreCallback(snapshot.storeId, require_deep_clone.deepClone(snapshot.state));
+			isTraveling = false;
+		},
+		/**
+		* 跳转到指定历史索引
+		* 将当前指针直接移动到指定位置，恢复对应的快照状态
+		*
+		* @param index - 目标历史索引（0-based）
+		*/
+		goto: (index) => {
+			if (index < 0 || index >= history.length) return;
+			isTraveling = true;
+			currentIndex = index;
+			const snapshot = history[currentIndex];
+			restoreCallback(snapshot.storeId, require_deep_clone.deepClone(snapshot.state));
+			isTraveling = false;
+		},
+		/**
+		* 获取完整的快照历史（返回深拷贝，防止外部修改内部历史记录）
+		* @returns 历史快照数组的深拷贝
+		*/
+		getHistory: () => require_deep_clone.deepClone(history),
+		/**
+		* 获取当前快照指针索引
+		* @returns 当前索引值，-1 表示无快照
+		*/
+		getCurrentIndex: () => currentIndex,
+		/**
+		* 判断是否可以撤销
+		* 当前索引大于 0 时，说明前面还有历史快照
+		* @returns 是否可以执行 undo 操作
+		*/
+		canUndo: () => currentIndex > 0,
+		/**
+		* 判断是否可以重做
+		* 当前索引小于历史长度 - 1 时，说明后面还有快照
+		* @returns 是否可以执行 redo 操作
+		*/
+		canRedo: () => currentIndex < history.length - 1,
+		/**
+		* 清除所有历史快照并重置指针
+		* 通常在 Store 销毁或需要重置历史时调用
+		*/
+		clear: () => {
+			history.length = 0;
+			currentIndex = -1;
+		}
+	};
+	controller.__setRestoreCallback = (callback) => {
+		restoreCallback = callback;
+	};
+	return {
+		middleware: {
+			name: "time-travel",
+			priority: 50,
+			/**
+			* 中间件处理函数
+			* 只拦截 "state:" 类型的操作（状态变更操作），其他类型直接放行
+			* 正在时间旅行时也不记录快照，避免循环
+			*
+			* @param context - 中间件上下文，包含 storeId、操作类型、状态等信息
+			* @param next - 调用下一个中间件或最终操作的函数
+			*/
+			handler: async (context, next) => {
+				const { storeId, type, state } = context;
+				if (!type.startsWith("state:") || isTraveling) {
+					await next();
+					return;
+				}
+				const snapshot = {
+					timestamp: Date.now(),
+					state: require_deep_clone.deepClone(state),
+					type,
+					storeId
+				};
+				await next();
+				addSnapshot(snapshot);
+			}
+		},
+		controller
+	};
+}
+function setRestoreCallback(controller, callback) {
+	const controllerWithSetter = controller;
+	if (typeof controllerWithSetter.__setRestoreCallback === "function") {
+		controllerWithSetter.__setRestoreCallback(callback);
+		return;
+	}
+	console.warn("[TimeTravel] 请使用 createTimeTravelMiddleware 返回的 controller");
+}
+//#endregion
+exports.createTimeTravelMiddleware = createTimeTravelMiddleware;
+exports.setRestoreCallback = setRestoreCallback;
+/*! End of @composy/store-core | Powered by @composy/builder */
+//# sourceMappingURL=time-travel.cjs.map

package/lib/middleware/time-travel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-travel.cjs","names":[],"sources":["../../src/middleware/time-travel.ts"],"sourcesContent":["/* ============================================================\n * time-travel.ts\n * 时间旅行中间件\n * 提供状态快照历史记录、撤销（undo）、重做（redo）、跳转（goto）等能力\n * 用于实现 Store 状态的可回溯调试与操作历史管理\n * ============================================================ */\n\n/* 从类型文件导入中间件、上下文、快照、状态树等核心类型 */\nimport type {\n  Middleware,                  // 中间件接口\n  MiddlewareContext,           // 中间件执行上下文接口\n  StateSnapshot,              // 状态快照接口\n  StateTree,                  // 状态树类型\n  StoreId,                    // Store 标识类型\n  TimeTravelController,       // 时间旅行控制器接口\n  TimeTravelMiddlewareOptions, // 时间旅行中间件配置选项接口\n} from '../types'\n/* 从工具库导入深拷贝函数，用于快照的隔离存储 */\nimport { deepClone } from '../utils/deep-clone'\n\n/* ── 内部类型定义 ── */\n\n/**\n * 恢复回调函数类型\n * 当执行 undo/redo/goto 操作时，通过此回调将历史快照状态应用到对应 Store\n * @param storeId - 目标 Store 的标识\n * @param state - 要恢复的状态树（已深拷贝，可安全修改）\n */\ntype RestoreCallback = (storeId: StoreId, state: StateTree) => void\n\n/**\n * 带有内部恢复回调设置器的控制器扩展类型\n * 在 TimeTravelController 基础上增加 __setRestoreCallback 内部方法\n * 用于在创建后注入实际的恢复回调（由 Store 运行时提供）\n */\ntype TimeTravelControllerWithRestoreSetter = TimeTravelController & {\n  __setRestoreCallback?: (callback: RestoreCallback) => void\n}\n\n/* ── 默认配置 ── */\n\n/** 中间件默认选项：最多保留 100 条历史记录，功能默认启用 */\nconst defaultOptions: TimeTravelMiddlewareOptions = {\n  maxHistory: 100,\n  enabled: true,\n}\n\n/**\n * 创建时间旅行中间件\n *\n * 返回一个中间件函数和一个控制器对象：\n * - 中间件负责拦截 state: 类型的操作，在操作前后记录状态快照\n * - 控制器提供 undo/redo/goto/clear 等方法，用于在历史快照之间跳转\n *\n * @param options - 中间件配置选项（可选，与默认值合并）\n * @returns 包含 middleware（中间件）和 controller（控制器）的对象\n */\nexport function createTimeTravelMiddleware(\n  options: TimeTravelMiddlewareOptions = {},\n): {\n  middleware: Middleware\n  controller: TimeTravelController\n} {\n  /* 将用户选项与默认选项合并 */\n  const opts = { ...defaultOptions, ...options }\n  /* 最大历史记录条数，确保至少为 1 */\n  const maxHistory = opts.maxHistory ?? defaultOptions.maxHistory ?? 100\n  /* 历史快照数组，存储所有状态变更的快照 */\n  const history: StateSnapshot[] = []\n\n  /* 当前快照指针，指向 history 数组中的当前位置，-1 表示无快照 */\n  let currentIndex = -1\n  /* 标记是否正在进行时间旅行（undo/redo/goto），防止在恢复过程中重复记录快照 */\n  let isTraveling = false\n  /* 恢复回调函数，初始为空函数，后续通过 __setRestoreCallback 注入实际实现 */\n  let restoreCallback: RestoreCallback = () => {}\n\n  /**\n   * 添加新的状态快照到历史记录\n   * 业务处理过程：\n   * 1. 如果中间件未启用或正在时间旅行中，则跳过\n   * 2. 如果当前指针不在末尾（即之前执行过 undo），则丢弃指针之后的快照（分支覆盖）\n   * 3. 推入新快照并更新指针\n   * 4. 如果超过最大历史条数，移除最早的快照并调整指针\n   *\n   * @param snapshot - 要添加的状态快照\n   */\n  const addSnapshot = (snapshot: StateSnapshot): void => {\n    /* 中间件未启用或正在时间旅行中，不记录快照 */\n    if (!opts.enabled || isTraveling) {\n      return\n    }\n\n    /* 如果当前指针不在历史末尾（之前执行过 undo），丢弃后续快照（创建新分支） */\n    if (currentIndex < history.length - 1) {\n      history.splice(currentIndex + 1)\n    }\n\n    /* 将新快照推入历史数组 */\n    history.push(snapshot)\n    /* 更新指针到最新快照 */\n    currentIndex = history.length - 1\n\n    /* 如果历史记录超过上限，移除最早的快照 */\n    if (history.length > maxHistory) {\n      history.shift()\n      /* 移除头部元素后指针需要前移一位 */\n      currentIndex--\n    }\n  }\n\n  /**\n   * 时间旅行控制器\n   * 提供 undo（撤销）、redo（重做）、goto（跳转）、clear（清除）等操作\n   * 所有恢复操作都通过 restoreCallback 将历史快照应用到 Store\n   */\n  const controller: TimeTravelControllerWithRestoreSetter = {\n    /**\n     * 撤销操作\n     * 将当前指针前移一步，恢复到上一个历史快照状态\n     */\n    undo: () => {\n      /* 无法撤销（已到最早快照）则跳过 */\n      if (!controller.canUndo()) {\n        return\n      }\n\n      /* 标记进入时间旅行模式，防止恢复过程触发新的快照记录 */\n      isTraveling = true\n      /* 指针前移 */\n      currentIndex--\n      /* 获取目标快照 */\n      const snapshot = history[currentIndex]\n      /* 通过恢复回调将快照状态（深拷贝）应用到 Store，避免污染历史记录 */\n      restoreCallback(snapshot.storeId, deepClone(snapshot.state))\n      /* 退出时间旅行模式 */\n      isTraveling = false\n    },\n\n    /**\n     * 重做操作\n     * 将当前指针后移一步，恢复到下一个历史快照状态\n     */\n    redo: () => {\n      /* 无法重做（已到最新快照）则跳过 */\n      if (!controller.canRedo()) {\n        return\n      }\n\n      /* 标记进入时间旅行模式 */\n      isTraveling = true\n      /* 指针后移 */\n      currentIndex++\n      /* 获取目标快照 */\n      const snapshot = history[currentIndex]\n      /* 恢复快照状态（深拷贝） */\n      restoreCallback(snapshot.storeId, deepClone(snapshot.state))\n      /* 退出时间旅行模式 */\n      isTraveling = false\n    },\n\n    /**\n     * 跳转到指定历史索引\n     * 将当前指针直接移动到指定位置，恢复对应的快照状态\n     *\n     * @param index - 目标历史索引（0-based）\n     */\n    goto: (index: number) => {\n      /* 索引越界检查 */\n      if (index < 0 || index >= history.length) {\n        return\n      }\n\n      /* 标记进入时间旅行模式 */\n      isTraveling = true\n      /* 直接设置指针到目标索引 */\n      currentIndex = index\n      /* 获取目标快照 */\n      const snapshot = history[currentIndex]\n      /* 恢复快照状态（深拷贝） */\n      restoreCallback(snapshot.storeId, deepClone(snapshot.state))\n      /* 退出时间旅行模式 */\n      isTraveling = false\n    },\n\n    /**\n     * 获取完整的快照历史（返回深拷贝，防止外部修改内部历史记录）\n     * @returns 历史快照数组的深拷贝\n     */\n    getHistory: () => deepClone(history),\n\n    /**\n     * 获取当前快照指针索引\n     * @returns 当前索引值，-1 表示无快照\n     */\n    getCurrentIndex: () => currentIndex,\n\n    /**\n     * 判断是否可以撤销\n     * 当前索引大于 0 时，说明前面还有历史快照\n     * @returns 是否可以执行 undo 操作\n     */\n    canUndo: () => currentIndex > 0,\n\n    /**\n     * 判断是否可以重做\n     * 当前索引小于历史长度 - 1 时，说明后面还有快照\n     * @returns 是否可以执行 redo 操作\n     */\n    canRedo: () => currentIndex < history.length - 1,\n\n    /**\n     * 清除所有历史快照并重置指针\n     * 通常在 Store 销毁或需要重置历史时调用\n     */\n    clear: () => {\n      /* 清空历史数组 */\n      history.length = 0\n      /* 重置指针到初始状态 */\n      currentIndex = -1\n    },\n  }\n\n  /**\n   * 在控制器上挂载内部恢复回调设置器\n   * 允许 Store 运行时在初始化时注入实际的状态恢复逻辑\n   * 使用 __ 前缀表示这是内部方法，不建议外部直接调用\n   */\n  controller.__setRestoreCallback = (callback: RestoreCallback) => {\n    restoreCallback = callback\n  }\n\n  /**\n   * 时间旅行中间件\n   * 拦截所有 \"state:\" 前缀的操作（如 state:update），在操作执行前后\n   * 记录状态快照，从而构建可回溯的状态历史\n   */\n  const middleware: Middleware = {\n    /* 中间件名称，用于调试和日志 */\n    name: 'time-travel',\n    /* 中间件优先级，50 为中等优先级（数值越小越先执行） */\n    priority: 50,\n    /**\n     * 中间件处理函数\n     * 只拦截 \"state:\" 类型的操作（状态变更操作），其他类型直接放行\n     * 正在时间旅行时也不记录快照，避免循环\n     *\n     * @param context - 中间件上下文，包含 storeId、操作类型、状态等信息\n     * @param next - 调用下一个中间件或最终操作的函数\n     */\n    handler: async (context: MiddlewareContext, next: () => void | Promise<void>) => {\n      /* 解构上下文：Store 标识、操作类型、当前状态 */\n      const { storeId, type, state } = context\n\n      /* 非状态变更操作（不以 \"state:\" 开头）或正在时间旅行中，直接执行后续操作 */\n      if (!type.startsWith('state:') || isTraveling) {\n        await next()\n        return\n      }\n\n      /* 在执行操作前，创建当前状态的快照（before snapshot） */\n      const snapshot: StateSnapshot = {\n        timestamp: Date.now(),          /* 快照时间戳 */\n        state: deepClone(state),         /* 深拷贝当前状态，隔离引用 */\n        type,                            /* 操作类型 */\n        storeId,                         /* Store 标识 */\n      }\n\n      /* 执行后续中间件或最终操作 */\n      await next()\n\n      /* 操作执行完成后，将快照添加到历史记录 */\n      addSnapshot(snapshot)\n    },\n  }\n\n  /* 返回中间件和控制器 */\n  return {\n    middleware,\n    controller,\n  }\n}\n\n/**\n * 外部设置恢复回调的辅助函数\n * 将外部提供的状态恢复函数注入到时间旅行控制器中\n *\n * 使用场景：Store 运行时初始化时调用此函数，将控制器与 Store 的状态恢复逻辑连接\n *\n * @param controller - 时间旅行控制器实例\n * @param callback - 恢复回调函数，接收 storeId 和已深拷贝的状态树\n */\nexport function setRestoreCallback(\n  controller: TimeTravelController,\n  callback: (storeId: StoreId, state: StateTree) => void,\n): void {\n  /* 将通用控制器类型断言为带内部设置器的扩展类型 */\n  const controllerWithSetter = controller as TimeTravelControllerWithRestoreSetter\n  /* 检查控制器是否支持 __setRestoreCallback 方法 */\n  if (typeof controllerWithSetter.__setRestoreCallback === 'function') {\n    /* 注入恢复回调 */\n    controllerWithSetter.__setRestoreCallback(callback)\n    return\n  }\n\n  /* 如果控制器不支持，输出警告（说明传入的不是 createTimeTravelMiddleware 创建的控制器） */\n  console.warn('[TimeTravel] 请使用 createTimeTravelMiddleware 返回的 controller')\n}\n"],"mappings":";;;;;;;;;;;;;AA0CA,MAAM,iBAA8C;CAClD,YAAY;CACZ,SAAS;AACX;AAYO,SAAS,2BACd,UAAuC,CAAC,GAIxC;CAEA,MAAM,OAAO;EAAE,GAAG;EAAgB,GAAG;CAAQ;CAE7C,MAAM,aAAa,KAAK,cAAc,eAAe,cAAc;CAEnE,MAAM,UAA2B,CAAC;CAGlC,IAAI,eAAe;CAEnB,IAAI,cAAc;CAElB,IAAI,wBAAyC,CAAC;CAY9C,MAAM,eAAe,aAAkC;EAErD,IAAI,CAAC,KAAK,WAAW,aACnB;EAIF,IAAI,eAAe,QAAQ,SAAS,GAClC,QAAQ,OAAO,eAAe,CAAC;EAIjC,QAAQ,KAAK,QAAQ;EAErB,eAAe,QAAQ,SAAS;EAGhC,IAAI,QAAQ,SAAS,YAAY;GAC/B,QAAQ,MAAM;GAEd;EACF;CACF;CAOA,MAAM,aAAoD;;;;;EAKxD,YAAY;GAEV,IAAI,CAAC,WAAW,QAAQ,GACtB;GAIF,cAAc;GAEd;GAEA,MAAM,WAAW,QAAQ;GAEzB,gBAAgB,SAAS,SAAS,mBAAA,UAAU,SAAS,KAAK,CAAC;GAE3D,cAAc;EAChB;;;;;EAMA,YAAY;GAEV,IAAI,CAAC,WAAW,QAAQ,GACtB;GAIF,cAAc;GAEd;GAEA,MAAM,WAAW,QAAQ;GAEzB,gBAAgB,SAAS,SAAS,mBAAA,UAAU,SAAS,KAAK,CAAC;GAE3D,cAAc;EAChB;;;;;;;EAQA,OAAO,UAAkB;GAEvB,IAAI,QAAQ,KAAK,SAAS,QAAQ,QAChC;GAIF,cAAc;GAEd,eAAe;GAEf,MAAM,WAAW,QAAQ;GAEzB,gBAAgB,SAAS,SAAS,mBAAA,UAAU,SAAS,KAAK,CAAC;GAE3D,cAAc;EAChB;;;;;EAMA,kBAAkB,mBAAA,UAAU,OAAO;;;;;EAMnC,uBAAuB;;;;;;EAOvB,eAAe,eAAe;;;;;;EAO9B,eAAe,eAAe,QAAQ,SAAS;;;;;EAM/C,aAAa;GAEX,QAAQ,SAAS;GAEjB,eAAe;EACjB;CACF;CAOA,WAAW,wBAAwB,aAA8B;EAC/D,kBAAkB;CACpB;CA+CA,OAAO;EACL,YAAA;GAvCA,MAAM;GAEN,UAAU;;;;;;;;;GASV,SAAS,OAAO,SAA4B,SAAqC;IAE/E,MAAM,EAAE,SAAS,MAAM,UAAU;IAGjC,IAAI,CAAC,KAAK,WAAW,QAAQ,KAAK,aAAa;KAC7C,MAAM,KAAK;KACX;IACF;IAGA,MAAM,WAA0B;KAC9B,WAAW,KAAK,IAAI;KACpB,OAAO,mBAAA,UAAU,KAAK;KACtB;KACA;IACF;IAGA,MAAM,KAAK;IAGX,YAAY,QAAQ;GACtB;EAKA;EACA;CACF;AACF;AAWO,SAAS,mBACd,YACA,UACM;CAEN,MAAM,uBAAuB;CAE7B,IAAI,OAAO,qBAAqB,yBAAyB,YAAY;EAEnE,qBAAqB,qBAAqB,QAAQ;EAClD;CACF;CAGA,QAAQ,KAAK,4DAA4D;AAC3E"}

package/lib/middleware/time-travel.d.ts

@@ -0,0 +1,30 @@
+import type { Middleware, // 状态快照接口
+StateTree, // 状态树类型
+StoreId, // Store 标识类型
+TimeTravelController, // 时间旅行控制器接口
+TimeTravelMiddlewareOptions } from '../types';
+/**
+ * 创建时间旅行中间件
+ *
+ * 返回一个中间件函数和一个控制器对象：
+ * - 中间件负责拦截 state: 类型的操作，在操作前后记录状态快照
+ * - 控制器提供 undo/redo/goto/clear 等方法，用于在历史快照之间跳转
+ *
+ * @param options - 中间件配置选项（可选，与默认值合并）
+ * @returns 包含 middleware（中间件）和 controller（控制器）的对象
+ */
+export declare function createTimeTravelMiddleware(options?: TimeTravelMiddlewareOptions): {
+    middleware: Middleware;
+    controller: TimeTravelController;
+};
+/**
+ * 外部设置恢复回调的辅助函数
+ * 将外部提供的状态恢复函数注入到时间旅行控制器中
+ *
+ * 使用场景：Store 运行时初始化时调用此函数，将控制器与 Store 的状态恢复逻辑连接
+ *
+ * @param controller - 时间旅行控制器实例
+ * @param callback - 恢复回调函数，接收 storeId 和已深拷贝的状态树
+ */
+export declare function setRestoreCallback(controller: TimeTravelController, callback: (storeId: StoreId, state: StateTree) => void): void;
+//# sourceMappingURL=time-travel.d.ts.map

package/lib/middleware/validation.cjs

@@ -0,0 +1,76 @@
+/*!
+* ***********************************
+* @composy/store-core v0.0.1      *
+* Built with rollup               *
+* Build time: 2024-08-17 11:27:33 *
+* Build mode: production          *
+* Minified: No                    *
+* ***********************************
+*/
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/middleware/validation.ts
+function createValidationMiddleware(options) {
+	const { rules, onValidationError, blocking = false, patchOnly = false } = options;
+	let lastErrors = [];
+	async function validateState(storeId, state) {
+		const storeRules = rules[storeId];
+		if (!storeRules) return {
+			valid: true,
+			errors: []
+		};
+		const errors = [];
+		for (const [field, fieldRules] of Object.entries(storeRules)) {
+			const ruleList = Array.isArray(fieldRules) ? fieldRules : [fieldRules];
+			const value = state[field];
+			for (const rule of ruleList) try {
+				if (!await rule.validate(value, state)) errors.push({
+					storeId,
+					field,
+					message: rule.message,
+					value
+				});
+			} catch {
+				errors.push({
+					storeId,
+					field,
+					message: rule.message || `Validation error on field "${field}"`,
+					value
+				});
+			}
+		}
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+	return {
+		middleware: {
+			name: "validation",
+			priority: 5,
+			handler: async (context, next) => {
+				const { storeId, type, state } = context;
+				if (!(patchOnly ? type === "state:patch" : type.startsWith("state:")) || !rules[storeId]) {
+					await next();
+					return;
+				}
+				await next();
+				const result = await validateState(storeId, state);
+				if (!result.valid) {
+					lastErrors = result.errors;
+					onValidationError?.(result);
+					if (blocking) throw new Error(`[Validation] ${storeId}: ${result.errors.map((e) => e.message).join("; ")}`);
+				} else lastErrors = lastErrors.filter((e) => e.storeId !== storeId);
+			}
+		},
+		validate: validateState,
+		getErrors: () => [...lastErrors],
+		clearErrors: () => {
+			lastErrors = [];
+		}
+	};
+}
+//#endregion
+exports.createValidationMiddleware = createValidationMiddleware;
+/*! End of @composy/store-core | Powered by @composy/builder */
+//# sourceMappingURL=validation.cjs.map

package/lib/middleware/validation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.cjs","names":[],"sources":["../../src/middleware/validation.ts"],"sourcesContent":["/**\n * 验证中间件\n *\n * 对状态变化进行规则校验，支持同步/异步校验器\n * @module middleware/validation\n */\n\nimport type { Middleware, MiddlewareContext, StateTree, StoreId } from '../types'\n\n/**\n * 单个字段校验规则\n */\nexport interface ValidationRule<T = unknown> {\n  /** 校验函数，返回 true 表示通过 */\n  validate: (value: T, state: StateTree) => boolean | Promise<boolean>\n  /** 校验失败时的错误信息 */\n  message: string\n}\n\n/**\n * Store 校验规则集\n */\nexport type StoreValidationRules = Record<string, ValidationRule | ValidationRule[]>\n\n/**\n * 校验错误\n */\nexport interface ValidationError {\n  /** Store ID */\n  storeId: StoreId\n  /** 字段路径 */\n  field: string\n  /** 错误信息 */\n  message: string\n  /** 字段值 */\n  value: unknown\n}\n\n/**\n * 校验结果\n */\nexport interface ValidationResult {\n  /** 是否全部通过 */\n  valid: boolean\n  /** 错误列表 */\n  errors: ValidationError[]\n}\n\n/**\n * 验证中间件选项\n */\nexport interface ValidationMiddlewareOptions {\n  /** 按 Store ID 配置的校验规则 */\n  rules: Record<StoreId, StoreValidationRules>\n  /** 校验失败时的回调 */\n  onValidationError?: (result: ValidationResult) => void\n  /** 校验失败是否阻止状态变化 (默认 false，仅报告) */\n  blocking?: boolean\n  /** 是否只在 state:patch 时校验 (默认 false，所有 state: 前缀均校验) */\n  patchOnly?: boolean\n}\n\n/**\n * 创建验证中间件\n *\n * 对状态变化进行规则校验，可选择阻止无效变化或仅报告错误\n *\n * @param options - 验证配置\n * @returns 中间件实例和校验辅助 API\n *\n * @example\n * ```typescript\n * const { middleware, validate, getErrors, clearErrors } = createValidationMiddleware({\n *   rules: {\n *     'user-form': {\n *       name: {\n *         validate: (v) => typeof v === 'string' && v.length >= 2,\n *         message: 'Name must be at least 2 characters',\n *       },\n *       age: [\n *         { validate: (v) => typeof v === 'number', message: 'Age must be a number' },\n *         { validate: (v) => (v as number) >= 0 && (v as number) <= 150, message: 'Age must be 0-150' },\n *       ],\n *       email: {\n *         validate: (v) => /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(String(v)),\n *         message: 'Invalid email format',\n *       },\n *     },\n *   },\n *   onValidationError: (result) => {\n *     console.warn('Validation failed:', result.errors)\n *   },\n * })\n *\n * manager.use(middleware)\n * ```\n */\nexport function createValidationMiddleware(options: ValidationMiddlewareOptions): {\n  middleware: Middleware\n  /** 手动校验某个 store 的当前状态 */\n  validate: (storeId: StoreId, state: StateTree) => Promise<ValidationResult>\n  /** 获取最近一次的校验错误 */\n  getErrors: () => ValidationError[]\n  /** 清空错误 */\n  clearErrors: () => void\n} {\n  const {\n    rules,\n    onValidationError,\n    blocking = false,\n    patchOnly = false,\n  } = options\n\n  let lastErrors: ValidationError[] = []\n\n  /**\n   * 校验单个 store 状态\n   */\n  async function validateState(storeId: StoreId, state: StateTree): Promise<ValidationResult> {\n    const storeRules = rules[storeId]\n    if (!storeRules) return { valid: true, errors: [] }\n\n    const errors: ValidationError[] = []\n\n    for (const [field, fieldRules] of Object.entries(storeRules)) {\n      const ruleList = Array.isArray(fieldRules) ? fieldRules : [fieldRules]\n      const value = state[field]\n\n      for (const rule of ruleList) {\n        try {\n          const isValid = await rule.validate(value, state)\n          if (!isValid) {\n            errors.push({\n              storeId,\n              field,\n              message: rule.message,\n              value,\n            })\n          }\n        }\n        catch {\n          errors.push({\n            storeId,\n            field,\n            message: rule.message || `Validation error on field \"${field}\"`,\n            value,\n          })\n        }\n      }\n    }\n\n    return { valid: errors.length === 0, errors }\n  }\n\n  const middleware: Middleware = {\n    name: 'validation',\n    priority: 5, // 在 logger (0) 之后、大多数业务中间件之前\n\n    handler: async (context: MiddlewareContext, next: () => void | Promise<void>) => {\n      const { storeId, type, state } = context\n\n      // 检查是否需要校验\n      const shouldValidate = patchOnly\n        ? type === 'state:patch'\n        : type.startsWith('state:')\n\n      if (!shouldValidate || !rules[storeId]) {\n        await next()\n        return\n      }\n\n      // 先执行状态变化\n      await next()\n\n      // 校验变化后的状态\n      const result = await validateState(storeId, state)\n\n      if (!result.valid) {\n        lastErrors = result.errors\n        onValidationError?.(result)\n\n        if (blocking) {\n          throw new Error(\n            `[Validation] ${storeId}: ${result.errors.map(e => e.message).join('; ')}`,\n          )\n        }\n      }\n      else {\n        // 校验通过，清除该 store 的错误\n        lastErrors = lastErrors.filter(e => e.storeId !== storeId)\n      }\n    },\n  }\n\n  return {\n    middleware,\n    validate: validateState,\n    getErrors: () => [...lastErrors],\n    clearErrors: () => { lastErrors = [] },\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAiGO,SAAS,2BAA2B,SAQzC;CACA,MAAM,EACJ,OACA,mBACA,WAAW,OACX,YAAY,UACV;CAEJ,IAAI,aAAgC,CAAC;CAKrC,eAAe,cAAc,SAAkB,OAA6C;EAC1F,MAAM,aAAa,MAAM;EACzB,IAAI,CAAC,YAAY,OAAO;GAAE,OAAO;GAAM,QAAQ,CAAC;EAAE;EAElD,MAAM,SAA4B,CAAC;EAEnC,KAAA,MAAW,CAAC,OAAO,eAAe,OAAO,QAAQ,UAAU,GAAG;GAC5D,MAAM,WAAW,MAAM,QAAQ,UAAU,IAAI,aAAa,CAAC,UAAU;GACrE,MAAM,QAAQ,MAAM;GAEpB,KAAA,MAAW,QAAQ,UACjB,IAAI;IAEF,IAAI,CAAC,MADiB,KAAK,SAAS,OAAO,KAAK,GAE9C,OAAO,KAAK;KACV;KACA;KACA,SAAS,KAAK;KACd;IACF,CAAC;GAEL,QACM;IACJ,OAAO,KAAK;KACV;KACA;KACA,SAAS,KAAK,WAAW,8BAA8B,MAAK;KAC5D;IACF,CAAC;GACH;EAEJ;EAEA,OAAO;GAAE,OAAO,OAAO,WAAW;GAAG;EAAO;CAC9C;CA0CA,OAAO;EACL,YAAA;GAxCA,MAAM;GACN,UAAU;GAEV,SAAS,OAAO,SAA4B,SAAqC;IAC/E,MAAM,EAAE,SAAS,MAAM,UAAU;IAOjC,IAAI,EAJmB,YACnB,SAAS,gBACT,KAAK,WAAW,QAAQ,MAEL,CAAC,MAAM,UAAU;KACtC,MAAM,KAAK;KACX;IACF;IAGA,MAAM,KAAK;IAGX,MAAM,SAAS,MAAM,cAAc,SAAS,KAAK;IAEjD,IAAI,CAAC,OAAO,OAAO;KACjB,aAAa,OAAO;KACpB,oBAAoB,MAAM;KAE1B,IAAI,UACF,MAAM,IAAI,MACR,gBAAgB,QAAO,IAAK,OAAO,OAAO,KAAI,MAAK,EAAE,OAAO,CAAA,CAAE,KAAK,IAAI,GACzE;IAEJ,OAGE,aAAa,WAAW,QAAO,MAAK,EAAE,YAAY,OAAO;GAE7D;EAIA;EACA,UAAU;EACV,iBAAiB,CAAC,GAAG,UAAU;EAC/B,mBAAmB;GAAE,aAAa,CAAC;EAAE;CACvC;AACF"}

package/lib/middleware/validation.d.ts

@@ -0,0 +1,100 @@
+/**
+ * 验证中间件
+ *
+ * 对状态变化进行规则校验，支持同步/异步校验器
+ * @module middleware/validation
+ */
+import type { Middleware, StateTree, StoreId } from '../types';
+/**
+ * 单个字段校验规则
+ */
+export interface ValidationRule<T = unknown> {
+    /** 校验函数，返回 true 表示通过 */
+    validate: (value: T, state: StateTree) => boolean | Promise<boolean>;
+    /** 校验失败时的错误信息 */
+    message: string;
+}
+/**
+ * Store 校验规则集
+ */
+export type StoreValidationRules = Record<string, ValidationRule | ValidationRule[]>;
+/**
+ * 校验错误
+ */
+export interface ValidationError {
+    /** Store ID */
+    storeId: StoreId;
+    /** 字段路径 */
+    field: string;
+    /** 错误信息 */
+    message: string;
+    /** 字段值 */
+    value: unknown;
+}
+/**
+ * 校验结果
+ */
+export interface ValidationResult {
+    /** 是否全部通过 */
+    valid: boolean;
+    /** 错误列表 */
+    errors: ValidationError[];
+}
+/**
+ * 验证中间件选项
+ */
+export interface ValidationMiddlewareOptions {
+    /** 按 Store ID 配置的校验规则 */
+    rules: Record<StoreId, StoreValidationRules>;
+    /** 校验失败时的回调 */
+    onValidationError?: (result: ValidationResult) => void;
+    /** 校验失败是否阻止状态变化 (默认 false，仅报告) */
+    blocking?: boolean;
+    /** 是否只在 state:patch 时校验 (默认 false，所有 state: 前缀均校验) */
+    patchOnly?: boolean;
+}
+/**
+ * 创建验证中间件
+ *
+ * 对状态变化进行规则校验，可选择阻止无效变化或仅报告错误
+ *
+ * @param options - 验证配置
+ * @returns 中间件实例和校验辅助 API
+ *
+ * @example
+ * ```typescript
+ * const { middleware, validate, getErrors, clearErrors } = createValidationMiddleware({
+ *   rules: {
+ *     'user-form': {
+ *       name: {
+ *         validate: (v) => typeof v === 'string' && v.length >= 2,
+ *         message: 'Name must be at least 2 characters',
+ *       },
+ *       age: [
+ *         { validate: (v) => typeof v === 'number', message: 'Age must be a number' },
+ *         { validate: (v) => (v as number) >= 0 && (v as number) <= 150, message: 'Age must be 0-150' },
+ *       ],
+ *       email: {
+ *         validate: (v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(v)),
+ *         message: 'Invalid email format',
+ *       },
+ *     },
+ *   },
+ *   onValidationError: (result) => {
+ *     console.warn('Validation failed:', result.errors)
+ *   },
+ * })
+ *
+ * manager.use(middleware)
+ * ```
+ */
+export declare function createValidationMiddleware(options: ValidationMiddlewareOptions): {
+    middleware: Middleware;
+    /** 手动校验某个 store 的当前状态 */
+    validate: (storeId: StoreId, state: StateTree) => Promise<ValidationResult>;
+    /** 获取最近一次的校验错误 */
+    getErrors: () => ValidationError[];
+    /** 清空错误 */
+    clearErrors: () => void;
+};
+//# sourceMappingURL=validation.d.ts.map

package/lib/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/lib/plugins/define-plugin.cjs

@@ -0,0 +1,56 @@
+/*!
+* ***********************************
+* @composy/store-core v0.0.1      *
+* Built with rollup               *
+* Build time: 2024-08-17 11:27:33 *
+* Build mode: production          *
+* Minified: No                    *
+* ***********************************
+*/
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/plugins/define-plugin.ts
+function defineStorePlugin(options) {
+	return {
+		name: options.name,
+		version: options.version,
+		description: options.description,
+		install: options.install,
+		uninstall: options.uninstall,
+		onStoreCreated: options.onStoreCreated,
+		onStoreDisposed: options.onStoreDisposed,
+		onStateChange: options.onStateChange
+	};
+}
+function createPluginFactory(factory) {
+	return (options) => {
+		return defineStorePlugin(factory(options));
+	};
+}
+function composePlugins(plugins) {
+	return {
+		name: "composed-plugins",
+		version: "1.0.0",
+		async install(context, options) {
+			for (const plugin of plugins) await plugin.install(context, options);
+		},
+		async uninstall(context) {
+			for (let i = plugins.length - 1; i >= 0; i--) await plugins[i].uninstall?.(context);
+		},
+		onStoreCreated(store) {
+			plugins.forEach((plugin) => plugin.onStoreCreated?.(store));
+		},
+		onStoreDisposed(store) {
+			plugins.forEach((plugin) => plugin.onStoreDisposed?.(store));
+		},
+		onStateChange(storeId, state, oldState) {
+			plugins.forEach((plugin) => plugin.onStateChange?.(storeId, state, oldState));
+		}
+	};
+}
+//#endregion
+exports.composePlugins = composePlugins;
+exports.createPluginFactory = createPluginFactory;
+exports.defineStorePlugin = defineStorePlugin;
+/*! End of @composy/store-core | Powered by @composy/builder */
+//# sourceMappingURL=define-plugin.cjs.map

package/lib/plugins/define-plugin.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-plugin.cjs","names":[],"sources":["../../src/plugins/define-plugin.ts"],"sourcesContent":["/**\n * 插件定义辅助函数\n *\n * @module plugins/define-plugin\n */\n\nimport type { DefinePluginOptions, PluginFactory, StorePlugin } from '../types'\n\n/**\n * 定义 Store 插件\n *\n * 提供类型安全的插件定义方式\n *\n * @template Options - 插件选项类型\n * @param options - 插件定义选项\n * @returns 插件实例\n *\n * @example\n * ```typescript\n * // 定义一个简单的日志插件\n * const loggerPlugin = defineStorePlugin({\n *   name: 'logger',\n *   version: '1.0.0',\n *   install(context) {\n *     console.log('Logger plugin installed')\n *   },\n *   onStateChange(storeId, state, oldState) {\n *     console.log(`[${storeId}] State changed:`, state)\n *   },\n * })\n * ```\n */\nexport function defineStorePlugin<Options = Record<string, unknown>>(\n  options: DefinePluginOptions<Options>,\n): StorePlugin<Options> {\n  return {\n    name: options.name,\n    version: options.version,\n    description: options.description,\n    install: options.install,\n    uninstall: options.uninstall,\n    onStoreCreated: options.onStoreCreated,\n    onStoreDisposed: options.onStoreDisposed,\n    onStateChange: options.onStateChange,\n  }\n}\n\n/**\n * 创建插件工厂函数\n *\n * 用于创建可配置的插件\n *\n * @template Options - 插件选项类型\n * @param factory - 插件工厂函数\n * @returns 插件工厂\n *\n * @example\n * ```typescript\n * // 创建可配置的持久化插件\n * const createPersistPlugin = createPluginFactory<{ key: string }>(\n *   (options) => ({\n *     name: 'persist',\n *     install(context) {\n *       console.log('Persist key:', options?.key)\n *     },\n *   })\n * )\n *\n * // 使用\n * const plugin = createPersistPlugin({ key: 'my-store' })\n * ```\n */\nexport function createPluginFactory<Options = Record<string, unknown>>(\n  factory: (options?: Options) => DefinePluginOptions<Options>,\n): PluginFactory<Options> {\n  return (options?: Options): StorePlugin<Options> => {\n    return defineStorePlugin(factory(options))\n  }\n}\n\n/**\n * 组合多个插件\n *\n * @param plugins - 插件列表\n * @returns 组合后的插件\n *\n * @example\n * ```typescript\n * const combinedPlugin = composePlugins([\n *   loggerPlugin,\n *   persistPlugin,\n *   devtoolsPlugin,\n * ])\n * ```\n */\nexport function composePlugins(\n  plugins: StorePlugin[],\n): StorePlugin {\n  return {\n    name: 'composed-plugins',\n    version: '1.0.0',\n\n    async install(context, options) {\n      for (const plugin of plugins) {\n        await plugin.install(context, options)\n      }\n    },\n\n    async uninstall(context) {\n      // 逆序卸载\n      for (let i = plugins.length - 1; i >= 0; i--) {\n        await plugins[i].uninstall?.(context)\n      }\n    },\n\n    onStoreCreated(store) {\n      plugins.forEach(plugin => plugin.onStoreCreated?.(store))\n    },\n\n    onStoreDisposed(store) {\n      plugins.forEach(plugin => plugin.onStoreDisposed?.(store))\n    },\n\n    onStateChange(storeId, state, oldState) {\n      plugins.forEach(plugin => plugin.onStateChange?.(storeId, state, oldState))\n    },\n  }\n}\n\n"],"mappings":";;;;;;;;;;;;AAgCO,SAAS,kBACd,SACsB;CACtB,OAAO;EACL,MAAM,QAAQ;EACd,SAAS,QAAQ;EACjB,aAAa,QAAQ;EACrB,SAAS,QAAQ;EACjB,WAAW,QAAQ;EACnB,gBAAgB,QAAQ;EACxB,iBAAiB,QAAQ;EACzB,eAAe,QAAQ;CACzB;AACF;AA2BO,SAAS,oBACd,SACwB;CACxB,QAAQ,YAA4C;EAClD,OAAO,kBAAkB,QAAQ,OAAO,CAAC;CAC3C;AACF;AAiBO,SAAS,eACd,SACa;CACb,OAAO;EACL,MAAM;EACN,SAAS;EAET,MAAM,QAAQ,SAAS,SAAS;GAC9B,KAAA,MAAW,UAAU,SACnB,MAAM,OAAO,QAAQ,SAAS,OAAO;EAEzC;EAEA,MAAM,UAAU,SAAS;GAEvB,KAAA,IAAS,IAAI,QAAQ,SAAS,GAAG,KAAK,GAAG,KACvC,MAAM,QAAQ,EAAC,CAAE,YAAY,OAAO;EAExC;EAEA,eAAe,OAAO;GACpB,QAAQ,SAAQ,WAAU,OAAO,iBAAiB,KAAK,CAAC;EAC1D;EAEA,gBAAgB,OAAO;GACrB,QAAQ,SAAQ,WAAU,OAAO,kBAAkB,KAAK,CAAC;EAC3D;EAEA,cAAc,SAAS,OAAO,UAAU;GACtC,QAAQ,SAAQ,WAAU,OAAO,gBAAgB,SAAS,OAAO,QAAQ,CAAC;EAC5E;CACF;AACF"}

package/lib/plugins/define-plugin.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 插件定义辅助函数
+ *
+ * @module plugins/define-plugin
+ */
+import type { DefinePluginOptions, PluginFactory, StorePlugin } from '../types';
+/**
+ * 定义 Store 插件
+ *
+ * 提供类型安全的插件定义方式
+ *
+ * @template Options - 插件选项类型
+ * @param options - 插件定义选项
+ * @returns 插件实例
+ *
+ * @example
+ * ```typescript
+ * // 定义一个简单的日志插件
+ * const loggerPlugin = defineStorePlugin({
+ *   name: 'logger',
+ *   version: '1.0.0',
+ *   install(context) {
+ *     console.log('Logger plugin installed')
+ *   },
+ *   onStateChange(storeId, state, oldState) {
+ *     console.log(`[${storeId}] State changed:`, state)
+ *   },
+ * })
+ * ```
+ */
+export declare function defineStorePlugin<Options = Record<string, unknown>>(options: DefinePluginOptions<Options>): StorePlugin<Options>;
+/**
+ * 创建插件工厂函数
+ *
+ * 用于创建可配置的插件
+ *
+ * @template Options - 插件选项类型
+ * @param factory - 插件工厂函数
+ * @returns 插件工厂
+ *
+ * @example
+ * ```typescript
+ * // 创建可配置的持久化插件
+ * const createPersistPlugin = createPluginFactory<{ key: string }>(
+ *   (options) => ({
+ *     name: 'persist',
+ *     install(context) {
+ *       console.log('Persist key:', options?.key)
+ *     },
+ *   })
+ * )
+ *
+ * // 使用
+ * const plugin = createPersistPlugin({ key: 'my-store' })
+ * ```
+ */
+export declare function createPluginFactory<Options = Record<string, unknown>>(factory: (options?: Options) => DefinePluginOptions<Options>): PluginFactory<Options>;
+/**
+ * 组合多个插件
+ *
+ * @param plugins - 插件列表
+ * @returns 组合后的插件
+ *
+ * @example
+ * ```typescript
+ * const combinedPlugin = composePlugins([
+ *   loggerPlugin,
+ *   persistPlugin,
+ *   devtoolsPlugin,
+ * ])
+ * ```
+ */
+export declare function composePlugins(plugins: StorePlugin[]): StorePlugin;
+//# sourceMappingURL=define-plugin.d.ts.map

package/lib/plugins/index.cjs

@@ -0,0 +1,20 @@
+/*!
+* ***********************************
+* @composy/store-core v0.0.1      *
+* Built with rollup               *
+* Build time: 2024-08-17 11:27:33 *
+* Build mode: production          *
+* Minified: No                    *
+* ***********************************
+*/
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_define_plugin = require("./define-plugin.cjs");
+const require_plugin_manager = require("./plugin-manager.cjs");
+exports.composePlugins = require_define_plugin.composePlugins;
+exports.createPluginFactory = require_define_plugin.createPluginFactory;
+exports.createPluginManager = require_plugin_manager.createPluginManager;
+exports.defineStorePlugin = require_define_plugin.defineStorePlugin;
+exports.getGlobalPluginManager = require_plugin_manager.getGlobalPluginManager;
+exports.setGlobalPluginManager = require_plugin_manager.setGlobalPluginManager;
+/*! End of @composy/store-core | Powered by @composy/builder */

package/lib/plugins/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 插件模块导出
+ *
+ * @module plugins
+ */
+export { composePlugins, createPluginFactory, defineStorePlugin, } from './define-plugin';
+export { createPluginManager, getGlobalPluginManager, setGlobalPluginManager, } from './plugin-manager';
+//# sourceMappingURL=index.d.ts.map

package/lib/plugins/plugin-manager.cjs

@@ -0,0 +1,81 @@
+/*!
+* ***********************************
+* @composy/store-core v0.0.1      *
+* Built with rollup               *
+* Build time: 2024-08-17 11:27:33 *
+* Build mode: production          *
+* Minified: No                    *
+* ***********************************
+*/
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/plugins/plugin-manager.ts
+function createPluginManager() {
+	const plugins = /* @__PURE__ */ new Map();
+	const contexts = /* @__PURE__ */ new Map();
+	const use = (plugin, options) => {
+		if (plugins.has(plugin.name)) console.warn(`[Plugin] \u63D2\u4EF6 "${plugin.name}" \u5DF2\u5B58\u5728\uFF0C\u5C06\u88AB\u8986\u76D6`);
+		plugins.set(plugin.name, plugin);
+		const context = {
+			storeManager: {
+				getStore: () => null,
+				hasStore: () => false,
+				getStoreIds: () => []
+			},
+			storeId: "",
+			store: null,
+			options: options || {}
+		};
+		contexts.set(plugin.name, context);
+	};
+	const remove = (name) => {
+		const plugin = plugins.get(name);
+		const context = contexts.get(name);
+		if (plugin && context) plugin.uninstall?.(context);
+		plugins.delete(name);
+		contexts.delete(name);
+	};
+	const get = (name) => {
+		return plugins.get(name);
+	};
+	const has = (name) => {
+		return plugins.has(name);
+	};
+	const getAll = () => {
+		return new Map(plugins);
+	};
+	const size = () => {
+		return plugins.size;
+	};
+	const clear = () => {
+		plugins.forEach((plugin, name) => {
+			const context = contexts.get(name);
+			if (context) plugin.uninstall?.(context);
+		});
+		plugins.clear();
+		contexts.clear();
+	};
+	return {
+		use,
+		remove,
+		get,
+		has,
+		getAll,
+		size,
+		clear
+	};
+}
+let globalPluginManager = null;
+function getGlobalPluginManager() {
+	if (!globalPluginManager) globalPluginManager = createPluginManager();
+	return globalPluginManager;
+}
+function setGlobalPluginManager(manager) {
+	globalPluginManager = manager;
+}
+//#endregion
+exports.createPluginManager = createPluginManager;
+exports.getGlobalPluginManager = getGlobalPluginManager;
+exports.setGlobalPluginManager = setGlobalPluginManager;
+/*! End of @composy/store-core | Powered by @composy/builder */
+//# sourceMappingURL=plugin-manager.cjs.map