@context-action/core 0.1.0 → 0.2.0

package/dist/index.js

@@ -235,7 +235,7 @@ var require_toPropertyKey = /* @__PURE__ */ __commonJS({ "../../node_modules/.pn
 //#region ../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js
 var require_defineProperty = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.81.0/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js": ((exports, module) => {
 	var toPropertyKey = require_toPropertyKey();
-	function _defineProperty$2(e, r, t) {
+	function _defineProperty$3(e, r, t) {
 		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 			value: t,
 			enumerable: !0,
@@ -243,12 +243,12 @@ var require_defineProperty = /* @__PURE__ */ __commonJS({ "../../node_modules/.p
 			writable: !0
 		}) : e[r] = t, e;
 	}
-	module.exports = _defineProperty$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	module.exports = _defineProperty$3, module.exports.__esModule = true, module.exports["default"] = module.exports;
 }) });
 
 //#endregion
 //#region src/action-guard.ts
-var import_defineProperty$1 = /* @__PURE__ */ __toESM(require_defineProperty(), 1);
+var import_defineProperty$2 = /* @__PURE__ */ __toESM(require_defineProperty(), 1);
 /**
 * Action Guard system for managing action execution timing
 * @implements action-guard
@@ -279,7 +279,7 @@ var import_defineProperty$1 = /* @__PURE__ */ __toESM(require_defineProperty(),
 */
 var ActionGuard = class {
 	constructor() {
-		(0, import_defineProperty$1.default)(this, "guards", /* @__PURE__ */ new Map());
+		(0, import_defineProperty$2.default)(this, "guards", /* @__PURE__ */ new Map());
 	}
 	/**
 	* Check if action should be debounced
@@ -299,15 +299,21 @@ var ActionGuard = class {
 			this.guards.set(actionKey, state);
 		}
 		/** Clear any existing debounce timer to restart the delay period */
-		/** This implements the "debounce" behavior where rapid calls reset the timer */
-		if (state.debounceTimer) clearTimeout(state.debounceTimer);
-		/** Create new debounce promise that resolves after the delay period */
-		/** The promise will only resolve if no new debounce requests arrive */
+		if (state.debounceTimer) {
+			clearTimeout(state.debounceTimer);
+			if (state.debounceResolve) {
+				state.debounceResolve(false);
+				state.debounceResolve = void 0;
+			}
+		}
+		/** Create new debounce promise */
 		return new Promise((resolve) => {
+			state.debounceResolve = resolve;
 			state.debounceTimer = setTimeout(() => {
-				/** Clean up timer reference to prevent memory leaks */
+				/** Clean up timer and resolver references */
 				state.debounceTimer = void 0;
-				/** Update last execution timestamp for throttling calculations */
+				state.debounceResolve = void 0;
+				/** Update last execution timestamp */
 				state.lastExecuted = Date.now();
 				resolve(true);
 			}, debounceMs);
@@ -363,7 +369,10 @@ var ActionGuard = class {
 		const state = this.guards.get(actionKey);
 		if (state) {
 			/** Clear debounce timer if active to prevent memory leaks */
-			if (state.debounceTimer) clearTimeout(state.debounceTimer);
+			if (state.debounceTimer) {
+				clearTimeout(state.debounceTimer);
+				if (state.debounceResolve) state.debounceResolve(false);
+			}
 			/** Clear throttle timer if active to prevent memory leaks */
 			if (state.throttleTimer) clearTimeout(state.throttleTimer);
 			/** Remove guard state from memory */
@@ -378,7 +387,10 @@ var ActionGuard = class {
 		/** This prevents memory leaks when clearing the entire guard system */
 		for (const [, state] of this.guards) {
 			/** Clear any active debounce timers */
-			if (state.debounceTimer) clearTimeout(state.debounceTimer);
+			if (state.debounceTimer) {
+				clearTimeout(state.debounceTimer);
+				if (state.debounceResolve) state.debounceResolve(false);
+			}
 			/** Clear any active throttle timers */
 			if (state.throttleTimer) clearTimeout(state.throttleTimer);
 		}
@@ -400,6 +412,112 @@ var ActionGuard = class {
 	}
 };
 
+//#endregion
+//#region src/concurrency/OperationQueue.ts
+var import_defineProperty$1 = /* @__PURE__ */ __toESM(require_defineProperty(), 1);
+/**
+* 작업 큐 관리자
+* 
+* 핵심 기능:
+* 1. 작업 직렬화 - 모든 작업을 순서대로 실행
+* 2. 우선순위 지원 - 중요한 작업 우선 처리
+* 3. 에러 처리 - 개별 작업 실패가 전체에 영향 주지 않음
+* 4. 메모리 관리 - 완료된 작업 자동 정리
+*/
+var OperationQueue = class {
+	constructor(name = "OperationQueue") {
+		this.name = name;
+		(0, import_defineProperty$1.default)(this, "queue", []);
+		(0, import_defineProperty$1.default)(this, "isProcessing", false);
+		(0, import_defineProperty$1.default)(this, "operationCounter", 0);
+	}
+	/**
+	* 작업을 큐에 추가하고 실행 결과를 반환
+	* 
+	* @param operation 실행할 작업
+	* @param priority 우선순위 (높을수록 먼저 실행)
+	* @returns Promise로 래핑된 작업 결과
+	*/
+	enqueue(operation, priority = 0) {
+		return new Promise((resolve, reject) => {
+			const queuedOperation = {
+				id: `${this.name}-${++this.operationCounter}`,
+				operation,
+				resolve,
+				reject,
+				priority,
+				timestamp: Date.now()
+			};
+			let insertIndex = this.queue.length;
+			for (let i = 0; i < this.queue.length; i++) if ((this.queue[i].priority || 0) < priority) {
+				insertIndex = i;
+				break;
+			}
+			this.queue.splice(insertIndex, 0, queuedOperation);
+			this.processQueue();
+		});
+	}
+	/**
+	* 큐 처리 메인 로직
+	* 
+	* 한 번에 하나씩 순서대로 작업을 실행하여 동시성 문제 방지
+	*/
+	async processQueue() {
+		if (this.isProcessing || this.queue.length === 0) return;
+		this.isProcessing = true;
+		try {
+			while (this.queue.length > 0) {
+				const operation = this.queue.shift();
+				try {
+					const result = await Promise.resolve(operation.operation());
+					operation.resolve(result);
+				} catch (error) {
+					operation.reject(error);
+				}
+			}
+		} finally {
+			this.isProcessing = false;
+		}
+	}
+	/**
+	* 현재 큐 상태 조회 (디버깅용)
+	*/
+	getQueueInfo() {
+		return {
+			name: this.name,
+			queueLength: this.queue.length,
+			isProcessing: this.isProcessing,
+			operations: this.queue.map((op) => ({
+				id: op.id,
+				priority: op.priority,
+				timestamp: op.timestamp
+			}))
+		};
+	}
+	/**
+	* 큐 비우기 (테스트용)
+	*/
+	clear() {
+		this.queue.forEach((operation) => {
+			operation.reject(/* @__PURE__ */ new Error("Queue cleared"));
+		});
+		this.queue = [];
+		this.isProcessing = false;
+	}
+	/**
+	* 큐 크기 조회
+	*/
+	get size() {
+		return this.queue.length;
+	}
+	/**
+	* 처리 중 여부 조회  
+	*/
+	get processing() {
+		return this.isProcessing;
+	}
+};
+
 //#endregion
 //#region src/ActionRegister.ts
 var import_defineProperty = /* @__PURE__ */ __toESM(require_defineProperty(), 1);
@@ -425,7 +543,7 @@ var import_defineProperty = /* @__PURE__ */ __toESM(require_defineProperty(), 1)
 * // 핸들러 등록
 * register.register('updateUser', ({ id, name }, controller) => {
 *   userStore.setValue({ id, name });
-*   controller.next();
+*   // 핸들러가 자동으로 다음 핸들러로 진행
 * }, { priority: 10 });
 * 
 * // 액션 디스패치
@@ -442,18 +560,93 @@ var ActionRegister = class {
 		(0, import_defineProperty.default)(this, "name", void 0);
 		(0, import_defineProperty.default)(this, "registryConfig", void 0);
 		(0, import_defineProperty.default)(this, "executionStats", /* @__PURE__ */ new Map());
+		(0, import_defineProperty.default)(this, "registrationQueue", void 0);
+		(0, import_defineProperty.default)(this, "dispatchQueue", void 0);
 		this.name = config.name || "ActionRegister";
 		this.registryConfig = config.registry;
 		this.actionGuard = new ActionGuard();
+		this.registrationQueue = new OperationQueue(`${this.name}-Registration`);
+		this.dispatchQueue = new OperationQueue(`${this.name}-Dispatch`);
 		if (this.registryConfig?.defaultExecutionMode) this.executionMode = this.registryConfig.defaultExecutionMode;
 		if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 ActionRegister created: ${this.name}`, {
 			defaultExecutionMode: this.executionMode,
 			maxHandlers: this.registryConfig.maxHandlers,
-			autoCleanup: this.registryConfig.autoCleanup ?? true
+			autoCleanup: this.registryConfig.autoCleanup ?? true,
+			concurrencyProtection: true
 		});
 	}
 	register(action, handler, config = {}) {
 		const handlerId = config.id || `handler_${++this.handlerCounter}_${Math.random().toString(36).substr(2, 5)}`;
+		const unregisterFn = this._performRegistrationSync(action, handler, config, handlerId);
+		return unregisterFn;
+	}
+	/**
+	* 🆕 동기적 등록 수행 (개선된 버전)
+	*/
+	_performRegistrationSync(action, handler, config, handlerId) {
+		const registration = {
+			handler,
+			config: {
+				priority: config.priority ?? 0,
+				id: handlerId,
+				blocking: config.blocking ?? false,
+				once: config.once ?? false,
+				condition: config.condition || (() => true),
+				debounce: config.debounce ?? void 0,
+				throttle: config.throttle ?? void 0,
+				validation: config.validation ?? void 0,
+				middleware: config.middleware ?? false,
+				tags: config.tags ?? [],
+				category: config.category ?? void 0,
+				description: config.description ?? void 0,
+				version: config.version ?? void 0,
+				returnType: config.returnType ?? "value",
+				timeout: config.timeout ?? void 0,
+				retries: config.retries ?? 0,
+				dependencies: config.dependencies ?? [],
+				conflicts: config.conflicts ?? [],
+				environment: config.environment ?? void 0,
+				feature: config.feature ?? void 0,
+				metrics: config.metrics ?? {
+					collectTiming: false,
+					collectErrors: false,
+					customMetrics: {}
+				},
+				metadata: config.metadata ?? {}
+			},
+			id: handlerId
+		};
+		if (!this.pipelines.has(action)) this.pipelines.set(action, []);
+		const pipeline = this.pipelines.get(action);
+		const existingIndex = pipeline.findIndex((reg) => reg.id === handlerId);
+		if (existingIndex !== -1) return () => {};
+		if (this.registryConfig?.maxHandlers && pipeline.length >= this.registryConfig.maxHandlers) throw new Error(`Maximum number of handlers (${this.registryConfig.maxHandlers}) reached for action '${String(action)}' in registry '${this.name}'`);
+		pipeline.push(registration);
+		pipeline.sort((a, b) => b.config.priority - a.config.priority);
+		if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 Handler registered: ${String(action)}`, {
+			handlerId,
+			priority: config.priority,
+			tags: config.tags,
+			category: config.category,
+			totalHandlers: pipeline.length,
+			registry: this.name
+		});
+		return () => {
+			const index = pipeline.findIndex((reg) => reg.id === handlerId && reg === registration);
+			if (index !== -1) {
+				pipeline.splice(index, 1);
+				if (this.registryConfig?.debug && process.env.NODE_ENV === "development") console.log(`🎯 Handler unregistered: ${String(action)}`, {
+					handlerId,
+					remainingHandlers: pipeline.length,
+					registry: this.name
+				});
+			}
+		};
+	}
+	/**
+	* 🆕 실제 등록 작업 수행 (큐에서 호출됨)
+	*/
+	_performRegistration(action, handler, config, handlerId) {
 		const registration = {
 			handler,
 			config: {
@@ -514,6 +707,14 @@ var ActionRegister = class {
 		};
 	}
 	async dispatch(action, payload, options) {
+		return this.dispatchQueue.enqueue(async () => {
+			return this._performDispatch(action, payload, options);
+		});
+	}
+	/**
+	* 🆕 실제 디스패치 작업 수행 (큐에서 호출됨)
+	*/
+	async _performDispatch(action, payload, options) {
 		let autoAbortController;
 		let effectiveSignal = options?.signal;
 		if (options?.autoAbort?.enabled) {
@@ -811,7 +1012,6 @@ var ActionRegister = class {
 	async executePipeline(context, autoAbortController, autoAbortOptions) {
 		const createController = (_registration, _index) => {
 			return {
-				next: () => {},
 				abort: (reason) => {
 					context.aborted = true;
 					context.abortReason = reason;