sonamu 0.8.26 → 0.9.0

package/dist/stream/sse.js

@@ -1,70 +1,75 @@
-// NOTE(Haze, 251106): context provider에서 인자를 채워주면 createSSE(events)만으로 사용 가능
-export function createSSEFactory(socket, reply, _events) {
-    return new SSEConnectionImpl(socket, reply);
-}
-export function createMockSSEFactory(_events) {
-    return {
-        get closed () {
-            return false;
-        },
-        onClose: (_callback)=>{},
-        publish: (_event, _data)=>{},
-        end: ()=>Promise.resolve()
-    };
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+
+//#region src/stream/sse.ts
+function createSSEFactory(socket, reply, _events) {
+	return new SSEConnectionImpl(socket, reply);
 }
-class SSEConnectionImpl {
-    socket;
-    reply;
-    _closed = false;
-    _closeCallbacks = [];
-    markClosed = ()=>{
-        this._closed = true;
-        this.fireCloseCallbacks();
-    };
-    get closed() {
-        return this._closed;
-    }
-    onClose(callback) {
-        this._closeCallbacks.push(callback);
-    }
-    // 콜백을 한 번만 실행하고 배열을 비워 중복 호출을 방지
-    fireCloseCallbacks() {
-        const callbacks = this._closeCallbacks;
-        this._closeCallbacks = [];
-        for (const cb of callbacks){
-            cb();
-        }
-    }
-    constructor(socket, reply){
-        this.socket = socket;
-        this.reply = reply;
-        this.socket.on("close", this.markClosed);
-        this.socket.on("error", this.markClosed);
-    }
-    publish(event, data) {
-        if (this._closed) {
-            return;
-        }
-        this.reply.sse({
-            event: event,
-            data: JSON.stringify(data)
-        });
-    }
-    async end() {
-        if (this._closed) {
-            return;
-        }
-        this._closed = true;
-        this.socket.off("close", this.markClosed);
-        this.socket.off("error", this.markClosed);
-        this.fireCloseCallbacks();
-        this.reply.sse({
-            event: "end",
-            data: "END"
-        });
-        await new Promise((resolve)=>setTimeout(resolve, 200));
-        this.reply.raw.end();
-    }
+function createMockSSEFactory(_events) {
+	return {
+		get closed() {
+			return false;
+		},
+		onClose: (_callback) => {},
+		publish: (_event, _data) => {},
+		end: () => Promise.resolve()
+	};
 }
+var SSEConnectionImpl;
+var init_sse = __esmMin((() => {
+	SSEConnectionImpl = class {
+		_closed = false;
+		_closeCallbacks = [];
+		markClosed = () => {
+			this._closed = true;
+			this.fireCloseCallbacks();
+		};
+		get closed() {
+			return this._closed;
+		}
+		onClose(callback) {
+			this._closeCallbacks.push(callback);
+		}
+		fireCloseCallbacks() {
+			const callbacks = this._closeCallbacks;
+			this._closeCallbacks = [];
+			for (const cb of callbacks) {
+				cb();
+			}
+		}
+		constructor(socket, reply) {
+			this.socket = socket;
+			this.reply = reply;
+			this.socket.on("close", this.markClosed);
+			this.socket.on("error", this.markClosed);
+		}
+		publish(event, data) {
+			if (this._closed) {
+				return;
+			}
+			this.reply.sse({
+				event,
+				data: JSON.stringify(data)
+			});
+		}
+		async end() {
+			if (this._closed) {
+				return;
+			}
+			this._closed = true;
+			this.socket.off("close", this.markClosed);
+			this.socket.off("error", this.markClosed);
+			this.fireCloseCallbacks();
+			this.reply.sse({
+				event: "end",
+				data: "END"
+			});
+			await new Promise((resolve) => setTimeout(resolve, 200));
+			this.reply.raw.end();
+		}
+	};
+}));
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+init_sse();
+export { createMockSSEFactory, createSSEFactory, init_sse };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/syncer/api-parser.d.ts

@@ -1,5 +1,5 @@
 import { type ExtendedApi } from "../api/decorators";
-import type { AbsolutePath } from "../utils/path-utils";
+import { type AbsolutePath } from "../utils/path-utils";
 /**
  * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
  * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.

package/dist/syncer/api-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-parser.d.ts","sourceRoot":"","sources":["../../src/syncer/api-parser.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAGrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAyGrF"}
+{"version":3,"file":"api-parser.d.ts","sourceRoot":"","sources":["../../src/syncer/api-parser.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAyGrF"}