@simplysm/service-client 13.0.69 → 13.0.71

package/src/protocol/client-protocol-wrapper.ts

@@ -17,10 +17,10 @@ const workerResolvers = new LazyGcMap<
   string,
   { resolve: (res: unknown) => void; reject: (err: Error) => void }
 >({
-  gcInterval: 5 * 1000, // 5초마다 만료 검사
-  expireTime: 60 * 1000, // 60초가 지나면 만료 (타임아웃)
+  gcInterval: 5 * 1000, // Check for expired entries every 5s
+  expireTime: 60 * 1000, // Expire after 60s (timeout)
   onExpire: (key, item) => {
-    // 만료 시 reject 호출 (메모리 릭 방지 핵심)
+    // Reject on expiry (critical for preventing memory leaks)
     item.reject(new Error(`Worker task timed out (uuid: ${key})`));
   },
 });
@@ -40,8 +40,8 @@ function getWorker(): Worker | undefined {
   }
 
   if (!worker) {
-    // Vite/Esbuild/Webpack 등 모던 번들러는 이 문법을 통해 Worker를 별도 파일로 분리/로드함
-    // 주의: import.meta.resolve 대신 상대경로 사용 (Vite 호환)
+    // Modern bundlers (Vite/Esbuild/Webpack) use this syntax to split/load the Worker as a separate file
+    // Note: use relative path instead of import.meta.resolve (Vite compatibility)
     worker = new Worker(new URL("../workers/client-protocol.worker.ts", import.meta.url), {
       type: "module",
     });
@@ -71,8 +71,8 @@ function getWorker(): Worker | undefined {
 }
 
 /**
- * Worker에 작업 위임 및 결과 대기
- * 주의: workerAvailable이 true일 때만 호출해야 함
+ * Delegate work to Worker and await result
+ * Note: only call when workerAvailable is true
  */
 async function runWorker(
   type: "encode" | "decode",
@@ -83,20 +83,20 @@ async function runWorker(
     const id = Uuid.new().toString();
 
     workerResolvers.set(id, { resolve, reject });
-    // workerAvailable 체크 후 호출되므로 worker는 항상 존재
+    // Called after workerAvailable check, so worker always exists
     getWorker()!.postMessage({ id, type, data }, { transfer });
   });
 }
 
 export function createClientProtocolWrapper(protocol: ServiceProtocol): ClientProtocolWrapper {
-  // 기준값: 30KB
+  // Threshold: 30KB
   const SIZE_THRESHOLD = 30 * 1024;
 
   function shouldUseWorkerForEncode(msg: ServiceMessage): boolean {
     if (!("body" in msg)) return false;
     const body = msg.body;
 
-    // Uint8Array가 있거나, 배열 길이가 길면 워커 사용
+    // Use worker if Uint8Array is present or array length is large
     if (body instanceof Uint8Array) return true;
     if (typeof body === "string" && body.length > SIZE_THRESHOLD) return true;
     if (Array.isArray(body)) {
@@ -110,14 +110,14 @@ export function createClientProtocolWrapper(protocol: ServiceProtocol): ClientPr
     uuid: string,
     message: ServiceMessage,
   ): Promise<{ chunks: Bytes[]; totalSize: number }> {
-    // Worker가 없거나 작은 데이터는 메인 스레드에서 처리
+    // Process on main thread if no Worker or small data
     if (!isWorkerAvailable() || !shouldUseWorkerForEncode(message)) {
       return protocol.encode(uuid, message);
     }
 
     // [Worker]
-    // Encode는 객체를 보내야 하므로 Structured Clone이 발생함.
-    // 하지만 JSON.stringify 비용을 메인 스레드에서 제거하는 이득이 더 큼.
+    // Encode requires sending an object, so Structured Clone occurs.
+    // But the benefit of offloading JSON.stringify cost from the main thread is greater.
     return (await runWorker("encode", { uuid, message })) as {
       chunks: Bytes[];
       totalSize: number;
@@ -127,16 +127,16 @@ export function createClientProtocolWrapper(protocol: ServiceProtocol): ClientPr
   async function decode(bytes: Bytes): Promise<ServiceMessageDecodeResult<ServiceMessage>> {
     const totalSize = bytes.length;
 
-    // Worker가 없거나 작은 데이터는 메인 스레드에서 처리
+    // Process on main thread if no Worker or small data
     if (!isWorkerAvailable() || totalSize <= SIZE_THRESHOLD) {
       return protocol.decode(bytes);
     }
 
     // [Worker]
-    // Zero-Copy 전송 (buffer의 소유권이 Worker로 넘어감)
+    // Zero-copy transfer (buffer ownership moves to Worker)
     const rawResult = await runWorker("decode", bytes, [bytes.buffer]);
 
-    // Worker에서 온 결과(Plain Object)를 클래스 인스턴스(DateTime 등)로 복원
+    // Restore class instances (DateTime, etc.) from Worker's plain object result
     return transferableDecode(rawResult) as ServiceMessageDecodeResult<ServiceMessage>;
   }
 

package/src/service-client.ts

@@ -21,7 +21,7 @@ interface ServiceClientEvents {
 }
 
 export class ServiceClient extends EventEmitter<ServiceClientEvents> {
-  // 모듈들
+  // Modules
   private readonly _socket: SocketProvider;
   private readonly _transport: ServiceTransport;
   private readonly _eventClient: EventClient;
@@ -29,7 +29,7 @@ export class ServiceClient extends EventEmitter<ServiceClientEvents> {
 
   private _authToken?: string;
 
-  // 상태 접근자
+  // State accessors
   get connected() {
     return this._socket.connected;
   }
@@ -47,7 +47,7 @@ export class ServiceClient extends EventEmitter<ServiceClientEvents> {
     const wsProtocol = options.ssl ? "wss" : "ws";
     const wsUrl = `${wsProtocol}://${options.host}:${options.port}/ws`;
 
-    // 모듈 초기화
+    // Initialize modules
     this._socket = createSocketProvider(wsUrl, this.name, this.options.maxReconnectCount ?? 10);
     const protocol = createServiceProtocol();
     const protocolWrapper = createClientProtocolWrapper(protocol);
@@ -55,19 +55,19 @@ export class ServiceClient extends EventEmitter<ServiceClientEvents> {
     this._eventClient = createEventClient(this._transport);
     this._fileClient = createFileClient(this.hostUrl, this.name);
 
-    // 이벤트 바인딩
+    // Event bindings
     this._socket.on("state", async (state) => {
       this.emit("state", state);
 
-      // 재연결 시 이벤트 리스너 자동 복구
+      // Auto-recover event listeners on reconnect
       if (state === "connected") {
         try {
           if (this._authToken != null) {
-            await this.auth(this._authToken); // 재인증
+            await this.auth(this._authToken); // Re-authenticate
           }
           await this._eventClient.reRegisterAll();
         } catch (err) {
-          logger.error("이벤트 리스너 복구 실패", err);
+          logger.error("Failed to recover event listeners", err);
         }
       }
     });
@@ -77,7 +77,7 @@ export class ServiceClient extends EventEmitter<ServiceClientEvents> {
     });
   }
 
-  // 타입 안전성을 위한 Proxy 생성 메소드
+  // Proxy creation method for type safety
   getService<TService>(serviceName: string): RemoteService<TService> {
     return new Proxy({} as RemoteService<TService>, {
       get: (_target, prop) => {
@@ -131,7 +131,7 @@ export class ServiceClient extends EventEmitter<ServiceClientEvents> {
     info: TInfo,
     cb: (data: TData) => PromiseLike<void>,
   ): Promise<string> {
-    if (!this.connected) throw new Error("서버와 연결되어있지 않습니다.");
+    if (!this.connected) throw new Error("Not connected to the server.");
     return this._eventClient.addListener(eventDef, info, cb);
   }
 
@@ -150,7 +150,7 @@ export class ServiceClient extends EventEmitter<ServiceClientEvents> {
   async uploadFile(files: File[] | FileList | { name: string; data: BlobPart }[]) {
     if (this._authToken == null) {
       throw new Error(
-        "인증 토큰이 없습니다. 파일 업로드를 위해서는 먼저 auth()를 호출하여 인증해야 합니다.",
+        "No authentication token found. Call auth() to authenticate before uploading files.",
       );
     }
     return this._fileClient.upload(files, this._authToken);
@@ -161,11 +161,11 @@ export class ServiceClient extends EventEmitter<ServiceClientEvents> {
   }
 }
 
-// TService의 모든 메소드 반환형을 Promise로 감싸주는 타입 변환기
+// Type transformer that wraps all method return types of TService with Promise
 export type RemoteService<TService> = {
   [K in keyof TService]: TService[K] extends (...args: infer P) => infer R
     ? (...args: P) => Promise<Awaited<R>>
-    : never; // 함수가 아닌 프로퍼티는 안씀
+    : never; // Non-function properties are excluded
 };
 
 export function createServiceClient(name: string, options: ServiceConnectionConfig): ServiceClient {

package/src/transport/service-transport.ts

@@ -41,12 +41,12 @@ export function createServiceTransport(
     }
   >();
 
-  // 응답 progress의 totalSize 저장 (complete 시 100% emit용)
+  // Store response progress totalSize (for emitting 100% on complete)
   const responseProgressTotalSize = new Map<string, number>();
 
   socket.on("message", onMessage);
 
-  // 소켓이 끊기면 대기 중인 모든 요청을 에러 처리하여 메모리 해제
+  // When socket disconnects, reject all pending requests to free memory
   socket.on("state", (state) => {
     if (state === "closed" || state === "reconnecting") {
       cancelAllRequests("Socket connection lost");
@@ -56,16 +56,19 @@ export function createServiceTransport(
   async function send(message: ServiceClientMessage, progress?: ServiceProgress): Promise<unknown> {
     const uuid = Uuid.new().toString();
 
-    // 응답 대기 시작 (요청 보내기 전에 리스너를 먼저 등록해야 안전함)
+    // Start awaiting response (register listener before sending request for safety)
     const responsePromise = new Promise((resolve, reject) => {
       pendingRequests.set(uuid, { resolve, reject, progress });
     });
 
-    // 요청 전송
+    // Prevent unhandled rejection when the promise is orphaned (e.g., during HMR cleanup)
+    responsePromise.catch(() => {});
+
+    // Send request
     try {
       const { chunks, totalSize } = await protocol.encode(uuid, message);
 
-      // 진행률 초기화
+      // Initialize progress
       if (chunks.length > 1) {
         progress?.request?.({
           uuid,
@@ -74,18 +77,18 @@ export function createServiceTransport(
         });
       }
 
-      // 전송
+      // Send
       for (const chunk of chunks) {
         await socket.send(chunk);
       }
     } catch (err) {
-      // 전송 실패 시 즉시 정리
+      // Clean up immediately on send failure
       pendingRequests.get(uuid)?.reject(err as Error);
       pendingRequests.delete(uuid);
       throw err;
     }
 
-    // 응답 결과 반환
+    // Return response result
     return responsePromise;
   }
 
@@ -96,7 +99,7 @@ export function createServiceTransport(
 
     try {
       if (decoded.type === "progress") {
-        // totalSize 기억 (complete 시 100% emit용)
+        // Remember totalSize (for emitting 100% on complete)
         responseProgressTotalSize.set(decoded.uuid, decoded.totalSize);
 
         listenerInfo?.progress?.response?.({
@@ -113,7 +116,7 @@ export function createServiceTransport(
             completedSize: body.completedSize,
           });
         } else if (decoded.message.name === "response") {
-          // split된 메시지였으면 100% progress emit
+          // Emit 100% progress if it was a split message
           const totalSize = responseProgressTotalSize.get(decoded.uuid);
           if (totalSize != null) {
             responseProgressTotalSize.delete(decoded.uuid);
@@ -124,15 +127,15 @@ export function createServiceTransport(
             });
           }
 
-          // 응답을 받았으므로 Map에서 제거
+          // Remove from Map since response received
           pendingRequests.delete(decoded.uuid);
 
           listenerInfo?.resolve(decoded.message.body as ServiceResponseMessage);
         } else if (decoded.message.name === "error") {
-          // progress totalSize 정리
+          // Clean up progress totalSize
           responseProgressTotalSize.delete(decoded.uuid);
 
-          // 에러를 받았으므로 Map에서 제거
+          // Remove from Map since error received
           pendingRequests.delete(decoded.uuid);
 
           listenerInfo?.reject(toError(decoded.message.body));
@@ -145,7 +148,7 @@ export function createServiceTransport(
           const body = decoded.message.body as { keys: string[]; data: unknown };
           emitter.emit("event", { keys: body.keys, data: body.data });
         } else {
-          throw new Error("요청이 잘 못 되었습니다.");
+          throw new Error("Invalid message received from server.");
         }
       }
     } catch (err) {
@@ -153,7 +156,7 @@ export function createServiceTransport(
     }
   }
 
-  // 모든 대기 요청 취소 처리
+  // Cancel all pending requests
   function cancelAllRequests(reason: string): void {
     for (const listenerInfo of pendingRequests.values()) {
       listenerInfo.reject(new Error(`Request canceled: ${reason}`));

package/src/transport/socket-provider.ts

@@ -30,15 +30,15 @@ export function createSocketProvider(
   clientName: string,
   maxReconnectCount: number,
 ): SocketProvider {
-  // 설정상수
-  const HEARTBEAT_TIMEOUT = 30000; // 30초간 아무런 메시지가 없으면 끊김으로 간주
-  const HEARTBEAT_INTERVAL = 5000; // 5초마다 핑 전송
-  const RECONNECT_DELAY = 3000; // 3초마다 재연결 시도
+  // Configuration constants
+  const HEARTBEAT_TIMEOUT = 30000; // Consider disconnected if no message for 30s
+  const HEARTBEAT_INTERVAL = 5000; // Send ping every 5s
+  const RECONNECT_DELAY = 3000; // Retry reconnect every 3s
 
-  // 1바이트 버퍼 미리 생성 (메모리 절약)
+  // Pre-allocate 1-byte buffer (saves memory)
   const PING_PACKET = new Uint8Array([0x01]);
 
-  // 상태
+  // State
   let ws: WebSocket | undefined;
   let isManualClose = false;
   let reconnectCount = 0;
@@ -58,10 +58,10 @@ export function createSocketProvider(
     try {
       await createSocket();
       startHeartbeat();
-      reconnectCount = 0; // 연결 성공 시 카운트 초기화
+      reconnectCount = 0; // Reset count on successful connection
       emitter.emit("state", "connected");
     } catch (err) {
-      // 최초 연결 실패는 에러를 던짐 (호출자가 알 수 있게)
+      // Throw on initial connection failure (so the caller can handle it)
       throw err;
     }
   }
@@ -72,7 +72,7 @@ export function createSocketProvider(
     const currentWs = ws;
     if (currentWs != null) {
       currentWs.close();
-      // 완전히 닫힐 때까지 대기 (Graceful Shutdown)
+      // Wait until fully closed (graceful shutdown)
       await waitUntil(() => currentWs.readyState === WebSocket.CLOSED, 100, 30).catch(() => {});
     }
     emitter.emit("state", "closed");
@@ -82,11 +82,11 @@ export function createSocketProvider(
     try {
       await waitUntil(() => isConnected(), undefined, 50);
     } catch {
-      throw new Error("서버와 연결되어있지 않습니다. 인터넷 연결을 확인하세요.");
+      throw new Error("Not connected to the server. Please check your internet connection.");
     }
     const currentWs = ws;
     if (currentWs == null) {
-      throw new Error("WebSocket이 연결되어있지 않습니다.");
+      throw new Error("WebSocket is not connected.");
     }
     currentWs.send(data);
   }
@@ -109,7 +109,7 @@ export function createSocketProvider(
       };
 
       newWs.onerror = (event: Event) => {
-        // 연결 중 에러 발생 시 reject
+        // Reject on error during connection
         if (!isConnected()) {
           const errorEvent = event as ErrorEvent;
           const msg = errorEvent.message;
@@ -118,21 +118,21 @@ export function createSocketProvider(
       };
     });
 
-    // 이 시점에서 ws는 항상 할당되어 있음 (ws.onopen에서 할당)
+    // At this point ws is always assigned (assigned in ws.onopen)
     const currentWs = ws;
     if (currentWs == null) {
-      throw new Error("WebSocket 초기화 실패");
+      throw new Error("WebSocket initialization failed");
     }
 
     currentWs.onmessage = (event) => {
-      lastHeartbeatTime = Date.now(); // 하트비트 갱신
+      lastHeartbeatTime = Date.now(); // Update heartbeat
 
       const data = event.data as ArrayBuffer;
       const bytes = new Uint8Array(data);
 
-      // Raw Ping/Pong 처리 (가장 먼저 체크)
-      // 1바이트이고 첫 바이트가 0x02(Pong)이면 무시
-      // (하트비트 타임스탬프만 갱신하고 끝냄)
+      // Raw Ping/Pong handling (checked first)
+      // If 1 byte and first byte is 0x02 (Pong), ignore
+      // (only heartbeat timestamp was updated, nothing else to do)
       if (bytes.length === 1 && bytes[0] === 0x02) return;
 
       emitter.emit("message", bytes);
@@ -147,11 +147,11 @@ export function createSocketProvider(
   }
 
   async function tryReconnect(): Promise<void> {
-    // 루프 기반 재연결 (재귀 대신 사용하여 스택 안전성 확보)
+    // Loop-based reconnect (used instead of recursion for stack safety)
     while (reconnectCount < maxReconnectCount) {
       reconnectCount++;
       emitter.emit("state", "reconnecting");
-      logger.warn("WebSocket 연결 끊김. 재연결 시도...", {
+      logger.warn("WebSocket disconnected. Attempting reconnect...", {
         reconnectCount,
         maxReconnectCount,
       });
@@ -162,16 +162,16 @@ export function createSocketProvider(
         await createSocket();
         startHeartbeat();
         reconnectCount = 0;
-        emitter.emit("state", "connected"); // 재연결 성공 알림
-        logger.info("WebSocket 재연결 성공");
-        return; // 재연결 성공 시 종료
+        emitter.emit("state", "connected"); // Notify reconnect success
+        logger.info("WebSocket reconnected successfully");
+        return; // Exit on successful reconnect
       } catch {
-        // 실패 시 루프 계속
+        // Continue loop on failure
       }
     }
 
-    // 최대 재시도 횟수 초과
-    logger.error("재연결 시도 횟수 초과. 연결을 포기합니다.");
+    // Max retry count exceeded
+    logger.error("Reconnect retry limit exceeded. Giving up.");
     emitter.emit("state", "closed");
   }
 
@@ -180,32 +180,32 @@ export function createSocketProvider(
     lastHeartbeatTime = Date.now();
 
     heartbeatTimer = setInterval(() => {
-      // 타임아웃 체크
+      // Timeout check
       if (Date.now() - lastHeartbeatTime > HEARTBEAT_TIMEOUT) {
         logger.warn("Heartbeat Timeout. Connection lost.");
 
-        // 타임아웃이 발생했으므로 즉시 타이머를 멈춰서 반복 실행을 막습니다.
+        // Stop the timer immediately on timeout to prevent repeated execution.
         stopHeartbeat();
 
-        // 소켓이 닫히기를 기다리지 말고(onclose 미발생 대비), 강제로 정리 후 재연결합니다.
+        // Don't wait for socket close (onclose may not fire); force cleanup and reconnect.
         if (ws != null) {
           const tempWs = ws;
-          ws = undefined; // 연결 상태 끊김으로 간주
+          ws = undefined; // Consider connection as disconnected
 
-          // 기존 소켓의 이벤트 핸들러 제거
-          // 뒤늦게 발생한 onclose에 따른 중복 재연결 방지
+          // Remove event handlers from old socket
+          // Prevent duplicate reconnect from late onclose events
           tempWs.onclose = null;
           tempWs.onerror = null;
           tempWs.onmessage = null;
 
-          // 소켓 닫기 시도 (에러 무시)
+          // Attempt to close socket (ignore errors)
           try {
             tempWs.close();
           } catch {
             // ignore
           }
 
-          // 수동 종료가 아니라면 재연결 로직 강제 실행
+          // Force reconnect logic if not a manual close
           if (!isManualClose) {
             void tryReconnect();
           }
@@ -213,7 +213,7 @@ export function createSocketProvider(
         return;
       }
 
-      // ping 전송
+      // Send ping
       const currentWs = ws;
       if (isConnected() && currentWs != null) {
         try {

package/src/types/connection-config.ts

@@ -2,6 +2,6 @@ export interface ServiceConnectionConfig {
   port: number;
   host: string;
   ssl?: boolean;
-  /** 0 입력시 reconnect안함. 바로 끊김 */
+  /** Set to 0 to disable reconnect; disconnects immediately */
   maxReconnectCount?: number;
 }

package/src/workers/client-protocol.worker.ts

@@ -17,34 +17,34 @@ self.onmessage = (event: MessageEvent) => {
     let transferList: Transferable[] = [];
 
     if (type === "encode") {
-      // [Main -> Worker] 인코딩 요청 (data: { uuid, message })
-      // message는 이미 Plain Object로 넘어옴 (Structured Clone)
+      // [Main -> Worker] Encode request (data: { uuid, message })
+      // message is already a Plain Object (via Structured Clone)
       const { uuid, message } = data as {
         uuid: string;
         message: Parameters<typeof protocol.encode>[1];
       };
       const { chunks } = protocol.encode(uuid, message);
 
-      // Buffer[]는 전송 가능하므로 결과로 반환
+      // Buffer[] is transferable, return as result
       result = chunks;
-      // 결과물 청크들의 내부 ArrayBuffer를 소유권 이전 목록에 추가
+      // Add internal ArrayBuffers of result chunks to transfer list
       transferList = chunks.map((chunk) => chunk.buffer as ArrayBuffer);
     } else {
-      // [Main -> Worker] 디코딩 요청 (data: Uint8Array)
-      // data는 Uint8Array로 넘어옴
+      // [Main -> Worker] Decode request (data: Uint8Array)
+      // data arrives as Uint8Array
       const bytes = new Uint8Array(data as ArrayBuffer);
       const decodeResult = protocol.decode(bytes);
 
-      // 결과물(객체)을 전송 가능한 형태로 변환 (Zero-Copy 준비)
+      // Convert result object to transferable form (prepare for zero-copy)
       const encoded = transferableEncode(decodeResult);
       result = encoded.result;
       transferList = encoded.transferList;
     }
 
-    // [Worker -> Main] 성공 응답
+    // [Worker -> Main] Success response
     self.postMessage({ id, type: "success", result }, { transfer: transferList });
   } catch (err) {
-    // [Worker -> Main] 에러 응답
+    // [Worker -> Main] Error response
     self.postMessage({
       id,
       type: "error",