sonamu 0.9.4 → 0.9.6

package/dist/syncer/api-parser.js

@@ -53,12 +53,14 @@ async function readApisFromFile(filePath) {
 				throw new Error(`리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`);
 			}
 			const returnType = resolveTypeNode(node.type);
+			const websocketTypeRefs = readWebSocketTypeRefs(node);
 			methods.push({
 				modelName,
 				methodName,
 				typeParameters,
 				parameters,
-				returnType
+				returnType,
+				websocketTypeRefs
 			});
 		}
 		ts.forEachChild(node, visitor);
@@ -78,8 +80,13 @@ async function readApisFromFile(filePath) {
 		if (!foundMethod) {
 			throw new Error(`API ${api.modelName}.${api.methodName} not found in ${filePath}`);
 		}
+		const websocketOptions = api.websocketOptions ? {
+			...api.websocketOptions,
+			...foundMethod.websocketTypeRefs
+		} : undefined;
 		return {
 			...api,
+			websocketOptions,
 			typeParameters: foundMethod?.typeParameters,
 			parameters: foundMethod?.parameters,
 			returnType: foundMethod?.returnType
@@ -87,6 +94,69 @@ async function readApisFromFile(filePath) {
 	});
 	return extendedApis;
 }
+function readWebSocketTypeRefs(node) {
+	const optionsLiteral = getDecoratorOptionsObjectLiteral(node, "websocket");
+	if (!optionsLiteral) {
+		return {};
+	}
+	const refs = {};
+	for (const property of optionsLiteral.properties) {
+		if (!ts.isPropertyAssignment(property)) {
+			continue;
+		}
+		const propertyName = getPropertyNameText(property.name);
+		if (propertyName !== "outEvents" && propertyName !== "inEvents") {
+			continue;
+		}
+		const typeRef = resolveDecoratorTypeRef(property.initializer);
+		if (!typeRef) {
+			continue;
+		}
+		if (propertyName === "outEvents") {
+			refs.outEventsTypeRef = typeRef;
+		} else {
+			refs.inEventsTypeRef = typeRef;
+		}
+	}
+	return refs;
+}
+function getDecoratorOptionsObjectLiteral(node, decoratorName) {
+	for (const modifier of node.modifiers ?? []) {
+		if (!ts.isDecorator(modifier)) {
+			continue;
+		}
+		const expression = modifier.expression;
+		if (!ts.isCallExpression(expression)) {
+			continue;
+		}
+		if (!ts.isIdentifier(expression.expression) || expression.expression.text !== decoratorName) {
+			continue;
+		}
+		const [firstArg] = expression.arguments;
+		if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+			return firstArg;
+		}
+	}
+	return undefined;
+}
+function getPropertyNameText(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+		return name.text;
+	}
+	return undefined;
+}
+function resolveDecoratorTypeRef(expression) {
+	if (ts.isIdentifier(expression)) {
+		return {
+			t: "ref",
+			id: expression.text
+		};
+	}
+	if (ts.isAsExpression(expression) || ts.isParenthesizedExpression(expression) || ts.isNonNullExpression(expression) || ts.isTypeAssertionExpression(expression)) {
+		return resolveDecoratorTypeRef(expression.expression);
+	}
+	return undefined;
+}
 function resolveTypeNode(typeNode) {
 	switch (typeNode?.kind) {
 		case ts.SyntaxKind.AnyKeyword: return "any";
@@ -232,4 +302,4 @@ var init_api_parser = __esmMin((() => {
 //#endregion
 init_api_parser();
 export { init_api_parser, readApisFromFile };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"api-parser.js","names":["methods: Omit<ExtendedApi, \"path\" | \"options\">[]","modelName: string","methodName: string","typeParameters: ApiParamType.TypeParam[]","parameters: ApiParam[]","result: ApiParam"],"sources":["../../src/syncer/api-parser.ts"],"sourcesContent":["import assert from \"assert\";\nimport { readFile } from \"fs/promises\";\n\nimport inflection from \"inflection\";\nimport ts from \"typescript\";\n\nimport { registeredApis } from \"../api/decorators\";\nimport { type ExtendedApi } from \"../api/decorators\";\nimport { validateMethodName } from \"../api/validator\";\nimport { type ApiParam, type ApiParamType } from \"../types/types\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.\n * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.\n * @param filePath - 파싱할 TypeScript 파일의 절대 경로\n * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)\n */\nexport async function readApisFromFile(filePath: AbsolutePath): Promise<ExtendedApi[]> {\n  if (!filePath.endsWith(\".ts\")) {\n    throw new Error(\n      `${filePath} does not seem to be a TypeScript file. Please check the file path. We only support parsing TypeScript files.`,\n    );\n  }\n\n  const sourceFile = ts.createSourceFile(\n    filePath,\n    (await readFile(filePath)).toString(),\n    ts.ScriptTarget.Latest,\n  );\n\n  const methods: Omit<ExtendedApi, \"path\" | \"options\">[] = [];\n  let modelName: string = \"UnknownModel\";\n  let methodName: string = \"unknownMethod\";\n  const visitor = (node: ts.Node) => {\n    if (ts.isClassDeclaration(node)) {\n      if (node.name && ts.isIdentifier(node.name)) {\n        modelName = node.name.escapedText.toString().replace(/Class$/, \"\");\n      }\n    }\n    if (ts.isMethodDeclaration(node)) {\n      if (ts.isIdentifier(node.name)) {\n        methodName = node.name.escapedText.toString();\n        validateMethodName(methodName);\n      }\n\n      const typeParameters: ApiParamType.TypeParam[] = (node.typeParameters ?? []).map(\n        (typeParam) => {\n          const tp = typeParam;\n\n          return {\n            t: \"type-param\",\n            id: tp.name.escapedText.toString(),\n            constraint: tp.constraint ? resolveTypeNode(tp.constraint) : undefined,\n          };\n        },\n      );\n      const parameters: ApiParam[] = node.parameters.map((paramDec, index) => {\n        const defaultDef = printNode(paramDec.initializer, sourceFile);\n\n        // 기본값이 있는 경우 paramDec.type가 undefined로 나옴\n\n        return resolveParamDec(\n          {\n            name: paramDec.name,\n            type: paramDec.type as ts.TypeNode,\n            optional: paramDec.questionToken !== undefined || paramDec.initializer !== undefined,\n            defaultDef,\n          },\n          index,\n        );\n      });\n      if (node.type === undefined) {\n        throw new Error(`리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`);\n      }\n      const returnType = resolveTypeNode(node.type);\n\n      methods.push({\n        modelName,\n        methodName,\n        typeParameters,\n        parameters,\n        returnType,\n      });\n    }\n    ts.forEachChild(node, visitor);\n  };\n  visitor(sourceFile);\n\n  if (methods.length === 0) {\n    return [];\n  }\n\n  // 현재 파일의 등록된 API 필터\n  const currentModelApis = registeredApis.filter((api) => {\n    return methods.find(\n      (method) => method.modelName === api.modelName && method.methodName === api.methodName,\n    );\n  });\n  if (currentModelApis.length === 0) {\n    // const p = path.join(tmpdir(), \"sonamu-syncer-error.json\");\n    // writeFileSync(p, JSON.stringify(registeredApis, null, 2));\n    // execSync(`open ${p}`);\n    // throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);\n    return [];\n  }\n\n  // 등록된 API에 현재 메소드 타입 정보 확장\n  const extendedApis = currentModelApis.map((api) => {\n    const foundMethod = methods.find(\n      (method) => method.modelName === api.modelName && method.methodName === api.methodName,\n    );\n    if (!foundMethod) {\n      throw new Error(`API ${api.modelName}.${api.methodName} not found in ${filePath}`);\n    }\n    return {\n      ...api,\n      typeParameters: foundMethod?.typeParameters,\n      parameters: foundMethod?.parameters,\n      returnType: foundMethod?.returnType,\n    };\n  });\n  return extendedApis;\n}\n\nfunction resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {\n  switch (typeNode?.kind) {\n    case ts.SyntaxKind.AnyKeyword:\n      return \"any\";\n    case ts.SyntaxKind.UnknownKeyword:\n      return \"unknown\";\n    case ts.SyntaxKind.StringKeyword:\n      return \"string\";\n    case ts.SyntaxKind.NumberKeyword:\n      return \"number\";\n    case ts.SyntaxKind.BooleanKeyword:\n      return \"boolean\";\n    case ts.SyntaxKind.UndefinedKeyword:\n      return \"undefined\";\n    case ts.SyntaxKind.NullKeyword:\n      return \"null\";\n    case ts.SyntaxKind.VoidKeyword:\n      return \"void\";\n    case ts.SyntaxKind.LiteralType: {\n      const literal = (typeNode as ts.LiteralTypeNode).literal;\n      if (ts.isStringLiteral(literal)) {\n        return {\n          t: \"string-literal\",\n          value: literal.text,\n        };\n      } else if (ts.isNumericLiteral(literal)) {\n        return {\n          t: \"numeric-literal\",\n          value: Number(literal.text),\n        };\n      } else {\n        if (literal.kind === ts.SyntaxKind.NullKeyword) {\n          return \"null\";\n        } else if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {\n          return \"undefined\";\n        } else if (literal.kind === ts.SyntaxKind.TrueKeyword) {\n          return \"true\";\n        } else if (literal.kind === ts.SyntaxKind.FalseKeyword) {\n          return \"false\";\n        }\n        throw new Error(\"알 수 없는 리터럴\");\n      }\n    }\n    case ts.SyntaxKind.ArrayType: {\n      const arrNode = typeNode as ts.ArrayTypeNode;\n      return {\n        t: \"array\",\n        elementsType: resolveTypeNode(arrNode.elementType),\n      };\n    }\n    case ts.SyntaxKind.TypeLiteral: {\n      const literalNode = typeNode as ts.TypeLiteralNode;\n      return {\n        t: \"object\",\n        props: literalNode.members.map((member) => {\n          if (ts.isIndexSignatureDeclaration(member)) {\n            assert(member.parameters[0]);\n            const res = resolveParamDec({\n              name: member.parameters[0].name as ts.Identifier,\n              type: member.parameters[0].type as ts.TypeNode,\n            });\n\n            return resolveParamDec({\n              name: {\n                escapedText: `[${res.name}${res.optional ? \"?\" : \"\"}: ${res.type}]`,\n              } as ts.Identifier,\n              type: member.type,\n            });\n          } else {\n            return resolveParamDec({\n              name: (member as ts.PropertySignature).name as ts.Identifier,\n              type: (member as ts.PropertySignature).type as ts.TypeNode,\n              optional: (member as ts.PropertySignature).questionToken !== undefined,\n            });\n          }\n        }),\n      };\n    }\n    case ts.SyntaxKind.TypeReference:\n      return {\n        t: \"ref\",\n        id: ((typeNode as ts.TypeReferenceNode).typeName as ts.Identifier).escapedText.toString(),\n        args: (typeNode as ts.TypeReferenceNode).typeArguments?.map((typeArg) =>\n          resolveTypeNode(typeArg),\n        ),\n      };\n    case ts.SyntaxKind.UnionType:\n      return {\n        t: \"union\",\n        types: (typeNode as ts.UnionTypeNode).types.map((type) => resolveTypeNode(type)),\n      };\n    case ts.SyntaxKind.IntersectionType:\n      return {\n        t: \"intersection\",\n        types: (typeNode as ts.IntersectionTypeNode).types.map((type) => resolveTypeNode(type)),\n      };\n    case ts.SyntaxKind.IndexedAccessType:\n      return {\n        t: \"indexed-access\",\n        object: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).objectType),\n        index: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).indexType),\n      };\n    case ts.SyntaxKind.TupleType:\n      if (ts.isTupleTypeNode(typeNode)) {\n        return {\n          t: \"tuple-type\",\n          elements: typeNode.elements.map((elem) => resolveTypeNode(elem)),\n        };\n      }\n      break;\n    case ts.SyntaxKind.ParenthesizedType:\n      // 괄호로 묶인 타입 (예: (A & B)[] 에서 (A & B))\n      // 내부 타입을 재귀적으로 resolve\n      return resolveTypeNode((typeNode as ts.ParenthesizedTypeNode).type);\n\n    case ts.SyntaxKind.FunctionType:\n      return {\n        t: \"function\",\n        parameters: (typeNode as ts.FunctionTypeNode).parameters.map((param) => ({\n          name: param.name.getText(),\n          type: param.type ? resolveTypeNode(param.type) : \"unknown\",\n          optional: param.questionToken !== undefined,\n          defaultDef: undefined,\n        })),\n        returnType: resolveTypeNode((typeNode as ts.FunctionTypeNode).type),\n      };\n    case undefined:\n      throw new Error(`typeNode undefined`);\n  }\n\n  console.debug(typeNode);\n  throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);\n}\n\nfunction resolveParamDec(\n  paramDec: {\n    name: ts.BindingName;\n    type: ts.TypeNode;\n    optional?: boolean;\n    defaultDef?: string;\n  },\n  index: number = 0,\n): ApiParam {\n  const name = paramDec.name as ts.Identifier;\n  const type = resolveTypeNode(paramDec.type);\n\n  if (name === undefined) {\n    console.debug({ name, type, paramDec });\n  }\n\n  const result: ApiParam = {\n    name: name.escapedText ? name.escapedText.toString() : `nonameAt${index}`,\n    type,\n    optional: paramDec.optional === true,\n    defaultDef: paramDec?.defaultDef,\n  };\n\n  // 구조분해할당의 경우 타입이름 사용\n  if (\n    ts.isObjectBindingPattern(name) &&\n    ts.isTypeReferenceNode(paramDec.type) &&\n    ts.isIdentifier(paramDec.type.typeName)\n  ) {\n    result.name = inflection.camelize(paramDec.type.typeName.text, true);\n  }\n\n  return result;\n}\n\nfunction printNode(node: ts.Node | undefined, sourceFile: ts.SourceFile): string | undefined {\n  if (node === undefined) {\n    return undefined;\n  }\n\n  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });\n  return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"api-parser.js","names":["methods: ParsedMethod[]","modelName: string","methodName: string","typeParameters: ApiParamType.TypeParam[]","parameters: ApiParam[]","refs: WebSocketTypeRefs","result: ApiParam"],"sources":["../../src/syncer/api-parser.ts"],"sourcesContent":["import assert from \"assert\";\nimport { readFile } from \"fs/promises\";\n\nimport inflection from \"inflection\";\nimport ts from \"typescript\";\n\nimport { registeredApis } from \"../api/decorators\";\nimport { type ExtendedApi } from \"../api/decorators\";\nimport { type ResolvedWebSocketDecoratorOptions } from \"../api/decorators\";\nimport { validateMethodName } from \"../api/validator\";\nimport { type ApiParam, type ApiParamType } from \"../types/types\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\n\ntype WebSocketTypeRefs = Pick<\n  ResolvedWebSocketDecoratorOptions,\n  \"outEventsTypeRef\" | \"inEventsTypeRef\"\n>;\ntype ParsedMethod = {\n  modelName: string;\n  methodName: string;\n  typeParameters: ApiParamType.TypeParam[];\n  parameters: ApiParam[];\n  returnType: ApiParamType;\n  websocketTypeRefs: WebSocketTypeRefs;\n};\n\n/**\n * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.\n * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.\n * @param filePath - 파싱할 TypeScript 파일의 절대 경로\n * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)\n */\nexport async function readApisFromFile(filePath: AbsolutePath): Promise<ExtendedApi[]> {\n  if (!filePath.endsWith(\".ts\")) {\n    throw new Error(\n      `${filePath} does not seem to be a TypeScript file. Please check the file path. We only support parsing TypeScript files.`,\n    );\n  }\n\n  const sourceFile = ts.createSourceFile(\n    filePath,\n    (await readFile(filePath)).toString(),\n    ts.ScriptTarget.Latest,\n  );\n\n  const methods: ParsedMethod[] = [];\n  let modelName: string = \"UnknownModel\";\n  let methodName: string = \"unknownMethod\";\n  const visitor = (node: ts.Node) => {\n    if (ts.isClassDeclaration(node)) {\n      if (node.name && ts.isIdentifier(node.name)) {\n        modelName = node.name.escapedText.toString().replace(/Class$/, \"\");\n      }\n    }\n    if (ts.isMethodDeclaration(node)) {\n      if (ts.isIdentifier(node.name)) {\n        methodName = node.name.escapedText.toString();\n        validateMethodName(methodName);\n      }\n\n      const typeParameters: ApiParamType.TypeParam[] = (node.typeParameters ?? []).map(\n        (typeParam) => {\n          const tp = typeParam;\n\n          return {\n            t: \"type-param\",\n            id: tp.name.escapedText.toString(),\n            constraint: tp.constraint ? resolveTypeNode(tp.constraint) : undefined,\n          };\n        },\n      );\n      const parameters: ApiParam[] = node.parameters.map((paramDec, index) => {\n        const defaultDef = printNode(paramDec.initializer, sourceFile);\n\n        // 기본값이 있는 경우 paramDec.type가 undefined로 나옴\n\n        return resolveParamDec(\n          {\n            name: paramDec.name,\n            type: paramDec.type as ts.TypeNode,\n            optional: paramDec.questionToken !== undefined || paramDec.initializer !== undefined,\n            defaultDef,\n          },\n          index,\n        );\n      });\n      if (node.type === undefined) {\n        throw new Error(`리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`);\n      }\n      const returnType = resolveTypeNode(node.type);\n      const websocketTypeRefs = readWebSocketTypeRefs(node);\n\n      methods.push({\n        modelName,\n        methodName,\n        typeParameters,\n        parameters,\n        returnType,\n        websocketTypeRefs,\n      });\n    }\n    ts.forEachChild(node, visitor);\n  };\n  visitor(sourceFile);\n\n  if (methods.length === 0) {\n    return [];\n  }\n\n  // 현재 파일의 등록된 API 필터\n  const currentModelApis = registeredApis.filter((api) => {\n    return methods.find(\n      (method) => method.modelName === api.modelName && method.methodName === api.methodName,\n    );\n  });\n  if (currentModelApis.length === 0) {\n    // const p = path.join(tmpdir(), \"sonamu-syncer-error.json\");\n    // writeFileSync(p, JSON.stringify(registeredApis, null, 2));\n    // execSync(`open ${p}`);\n    // throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);\n    return [];\n  }\n\n  // 등록된 API에 현재 메소드 타입 정보 확장\n  const extendedApis = currentModelApis.map((api) => {\n    const foundMethod = methods.find(\n      (method) => method.modelName === api.modelName && method.methodName === api.methodName,\n    );\n    if (!foundMethod) {\n      throw new Error(`API ${api.modelName}.${api.methodName} not found in ${filePath}`);\n    }\n    const websocketOptions = api.websocketOptions\n      ? {\n          ...api.websocketOptions,\n          ...foundMethod.websocketTypeRefs,\n        }\n      : undefined;\n\n    return {\n      ...api,\n      websocketOptions,\n      typeParameters: foundMethod?.typeParameters,\n      parameters: foundMethod?.parameters,\n      returnType: foundMethod?.returnType,\n    };\n  });\n  return extendedApis;\n}\n\nfunction readWebSocketTypeRefs(node: ts.MethodDeclaration): WebSocketTypeRefs {\n  const optionsLiteral = getDecoratorOptionsObjectLiteral(node, \"websocket\");\n  if (!optionsLiteral) {\n    return {};\n  }\n\n  const refs: WebSocketTypeRefs = {};\n  for (const property of optionsLiteral.properties) {\n    if (!ts.isPropertyAssignment(property)) {\n      continue;\n    }\n\n    const propertyName = getPropertyNameText(property.name);\n    if (propertyName !== \"outEvents\" && propertyName !== \"inEvents\") {\n      continue;\n    }\n\n    const typeRef = resolveDecoratorTypeRef(property.initializer);\n    if (!typeRef) {\n      continue;\n    }\n\n    if (propertyName === \"outEvents\") {\n      refs.outEventsTypeRef = typeRef;\n    } else {\n      refs.inEventsTypeRef = typeRef;\n    }\n  }\n\n  return refs;\n}\n\nfunction getDecoratorOptionsObjectLiteral(\n  node: ts.MethodDeclaration,\n  decoratorName: string,\n): ts.ObjectLiteralExpression | undefined {\n  for (const modifier of node.modifiers ?? []) {\n    if (!ts.isDecorator(modifier)) {\n      continue;\n    }\n\n    const expression = modifier.expression;\n    if (!ts.isCallExpression(expression)) {\n      continue;\n    }\n\n    if (!ts.isIdentifier(expression.expression) || expression.expression.text !== decoratorName) {\n      continue;\n    }\n\n    const [firstArg] = expression.arguments;\n    if (firstArg && ts.isObjectLiteralExpression(firstArg)) {\n      return firstArg;\n    }\n  }\n\n  return undefined;\n}\n\nfunction getPropertyNameText(name: ts.PropertyName): string | undefined {\n  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {\n    return name.text;\n  }\n\n  return undefined;\n}\n\nfunction resolveDecoratorTypeRef(expression: ts.Expression): ApiParamType.Ref | undefined {\n  if (ts.isIdentifier(expression)) {\n    return {\n      t: \"ref\",\n      id: expression.text,\n    };\n  }\n\n  if (\n    ts.isAsExpression(expression) ||\n    ts.isParenthesizedExpression(expression) ||\n    ts.isNonNullExpression(expression) ||\n    ts.isTypeAssertionExpression(expression)\n  ) {\n    return resolveDecoratorTypeRef(expression.expression);\n  }\n\n  return undefined;\n}\n\nfunction resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {\n  switch (typeNode?.kind) {\n    case ts.SyntaxKind.AnyKeyword:\n      return \"any\";\n    case ts.SyntaxKind.UnknownKeyword:\n      return \"unknown\";\n    case ts.SyntaxKind.StringKeyword:\n      return \"string\";\n    case ts.SyntaxKind.NumberKeyword:\n      return \"number\";\n    case ts.SyntaxKind.BooleanKeyword:\n      return \"boolean\";\n    case ts.SyntaxKind.UndefinedKeyword:\n      return \"undefined\";\n    case ts.SyntaxKind.NullKeyword:\n      return \"null\";\n    case ts.SyntaxKind.VoidKeyword:\n      return \"void\";\n    case ts.SyntaxKind.LiteralType: {\n      const literal = (typeNode as ts.LiteralTypeNode).literal;\n      if (ts.isStringLiteral(literal)) {\n        return {\n          t: \"string-literal\",\n          value: literal.text,\n        };\n      } else if (ts.isNumericLiteral(literal)) {\n        return {\n          t: \"numeric-literal\",\n          value: Number(literal.text),\n        };\n      } else {\n        if (literal.kind === ts.SyntaxKind.NullKeyword) {\n          return \"null\";\n        } else if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {\n          return \"undefined\";\n        } else if (literal.kind === ts.SyntaxKind.TrueKeyword) {\n          return \"true\";\n        } else if (literal.kind === ts.SyntaxKind.FalseKeyword) {\n          return \"false\";\n        }\n        throw new Error(\"알 수 없는 리터럴\");\n      }\n    }\n    case ts.SyntaxKind.ArrayType: {\n      const arrNode = typeNode as ts.ArrayTypeNode;\n      return {\n        t: \"array\",\n        elementsType: resolveTypeNode(arrNode.elementType),\n      };\n    }\n    case ts.SyntaxKind.TypeLiteral: {\n      const literalNode = typeNode as ts.TypeLiteralNode;\n      return {\n        t: \"object\",\n        props: literalNode.members.map((member) => {\n          if (ts.isIndexSignatureDeclaration(member)) {\n            assert(member.parameters[0]);\n            const res = resolveParamDec({\n              name: member.parameters[0].name as ts.Identifier,\n              type: member.parameters[0].type as ts.TypeNode,\n            });\n\n            return resolveParamDec({\n              name: {\n                escapedText: `[${res.name}${res.optional ? \"?\" : \"\"}: ${res.type}]`,\n              } as ts.Identifier,\n              type: member.type,\n            });\n          } else {\n            return resolveParamDec({\n              name: (member as ts.PropertySignature).name as ts.Identifier,\n              type: (member as ts.PropertySignature).type as ts.TypeNode,\n              optional: (member as ts.PropertySignature).questionToken !== undefined,\n            });\n          }\n        }),\n      };\n    }\n    case ts.SyntaxKind.TypeReference:\n      return {\n        t: \"ref\",\n        id: ((typeNode as ts.TypeReferenceNode).typeName as ts.Identifier).escapedText.toString(),\n        args: (typeNode as ts.TypeReferenceNode).typeArguments?.map((typeArg) =>\n          resolveTypeNode(typeArg),\n        ),\n      };\n    case ts.SyntaxKind.UnionType:\n      return {\n        t: \"union\",\n        types: (typeNode as ts.UnionTypeNode).types.map((type) => resolveTypeNode(type)),\n      };\n    case ts.SyntaxKind.IntersectionType:\n      return {\n        t: \"intersection\",\n        types: (typeNode as ts.IntersectionTypeNode).types.map((type) => resolveTypeNode(type)),\n      };\n    case ts.SyntaxKind.IndexedAccessType:\n      return {\n        t: \"indexed-access\",\n        object: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).objectType),\n        index: resolveTypeNode((typeNode as ts.IndexedAccessTypeNode).indexType),\n      };\n    case ts.SyntaxKind.TupleType:\n      if (ts.isTupleTypeNode(typeNode)) {\n        return {\n          t: \"tuple-type\",\n          elements: typeNode.elements.map((elem) => resolveTypeNode(elem)),\n        };\n      }\n      break;\n    case ts.SyntaxKind.ParenthesizedType:\n      // 괄호로 묶인 타입 (예: (A & B)[] 에서 (A & B))\n      // 내부 타입을 재귀적으로 resolve\n      return resolveTypeNode((typeNode as ts.ParenthesizedTypeNode).type);\n\n    case ts.SyntaxKind.FunctionType:\n      return {\n        t: \"function\",\n        parameters: (typeNode as ts.FunctionTypeNode).parameters.map((param) => ({\n          name: param.name.getText(),\n          type: param.type ? resolveTypeNode(param.type) : \"unknown\",\n          optional: param.questionToken !== undefined,\n          defaultDef: undefined,\n        })),\n        returnType: resolveTypeNode((typeNode as ts.FunctionTypeNode).type),\n      };\n    case undefined:\n      throw new Error(`typeNode undefined`);\n  }\n\n  console.debug(typeNode);\n  throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);\n}\n\nfunction resolveParamDec(\n  paramDec: {\n    name: ts.BindingName;\n    type: ts.TypeNode;\n    optional?: boolean;\n    defaultDef?: string;\n  },\n  index: number = 0,\n): ApiParam {\n  const name = paramDec.name as ts.Identifier;\n  const type = resolveTypeNode(paramDec.type);\n\n  if (name === undefined) {\n    console.debug({ name, type, paramDec });\n  }\n\n  const result: ApiParam = {\n    name: name.escapedText ? name.escapedText.toString() : `nonameAt${index}`,\n    type,\n    optional: paramDec.optional === true,\n    defaultDef: paramDec?.defaultDef,\n  };\n\n  // 구조분해할당의 경우 타입이름 사용\n  if (\n    ts.isObjectBindingPattern(name) &&\n    ts.isTypeReferenceNode(paramDec.type) &&\n    ts.isIdentifier(paramDec.type.typeName)\n  ) {\n    result.name = inflection.camelize(paramDec.type.typeName.text, true);\n  }\n\n  return result;\n}\n\nfunction printNode(node: ts.Node | undefined, sourceFile: ts.SourceFile): string | undefined {\n  if (node === undefined) {\n    return undefined;\n  }\n\n  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });\n  return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);\n}\n"],"mappings":"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"}

package/dist/syncer/checksum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/syncer/checksum.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,KAAK,YAAY,EAAwB,MAAM,qBAAqB,CAAC;AAS9E;;;GAGG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAU9E;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAUpD"}
+{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/syncer/checksum.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,YAAY,EAAwB,MAAM,qBAAqB,CAAC;AAS9E;;;GAGG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAU9E;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAUpD"}

package/dist/syncer/checksum.js

@@ -1,9 +1,9 @@
 import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { globAsync, init_async_utils } from "../utils/async-utils.js";
 import { exists, init_fs_utils } from "../utils/fs-utils.js";
 import { differenceWith, init_utils } from "../utils/utils.js";
 import { Sonamu, init_sonamu } from "../api/sonamu.js";
-import { globAsync, init_async_utils } from "../utils/async-utils.js";
-import { getChecksumPatternGroupInAbsolutePath, init_file_patterns } from "./file-patterns.js";
+import { GLOB_EXCLUDE, getChecksumPatternGroupInAbsolutePath, init_file_patterns } from "./file-patterns.js";
 import { isEqual } from "radashi";
 import crypto from "crypto";
 import { readFile, writeFile } from "fs/promises";
@@ -39,16 +39,16 @@ async function renewChecksums() {
 	await saveChecksums(calculatedChecksums);
 }
 async function getCurrentChecksums() {
-	const filePaths = (await Promise.all(Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern]) => {
-		return globAsync(pattern);
-	}))).flat().toSorted();
-	const fileChecksums = await Promise.all(filePaths.map(async (filePath) => {
+	const allPaths = (await Promise.all(Object.entries(getChecksumPatternGroupInAbsolutePath()).map(([_fileType, pattern]) => {
+		return globAsync(pattern, { exclude: GLOB_EXCLUDE });
+	}))).flat();
+	const filePaths = Array.from(new Set(allPaths)).toSorted();
+	return await Promise.all(filePaths.map(async (filePath) => {
 		return {
 			path: filePath,
 			checksum: await getChecksumOfFile(filePath)
 		};
 	}));
-	return fileChecksums;
 }
 async function getPreviousChecksums() {
 	const checksumFilePath = getChecksumFilePath();
@@ -57,7 +57,7 @@ async function getPreviousChecksums() {
 	}
 	try {
 		const previousChecksums = JSON.parse(await readFile(checksumFilePath, "utf-8")).map((r) => ({
-			path: path.join(Sonamu.apiRootPath, r.path),
+			path: path.join(Sonamu.appRootPath, r.path),
 			checksum: r.checksum
 		}));
 		return previousChecksums;
@@ -71,10 +71,11 @@ function getChecksumFilePath() {
 }
 async function saveChecksums(checksums) {
 	const checksumFilePath = getChecksumFilePath();
-	await writeFile(checksumFilePath, JSON.stringify(checksums.map((r) => ({
-		path: path.relative(Sonamu.apiRootPath, r.path),
+	const serialized = checksums.map((r) => ({
+		path: path.relative(Sonamu.appRootPath, r.path),
 		checksum: r.checksum
-	})), null, 2), "utf-8");
+	})).sort((a, b) => a.path.localeCompare(b.path));
+	await writeFile(checksumFilePath, JSON.stringify(serialized, null, 2), "utf-8");
 }
 async function getChecksumOfFile(filePath) {
 	return new Promise((resolve, reject) => {
@@ -100,4 +101,4 @@ var init_checksum = __esmMin((() => {
 //#endregion
 init_checksum();
 export { findChangedFilesUsingChecksums, init_checksum, renewChecksums };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"checksum.js","names":[],"sources":["../../src/syncer/checksum.ts"],"sourcesContent":["import crypto from \"crypto\";\nimport { type BinaryLike } from \"crypto\";\nimport { createReadStream } from \"fs\";\nimport { type PathLike } from \"fs\";\nimport { readFile, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport equal from \"fast-deep-equal\";\nimport { isEqual } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { exists } from \"../utils/fs-utils\";\nimport { type AbsolutePath, type ApiRelativePath } from \"../utils/path-utils\";\nimport { differenceWith } from \"../utils/utils\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\n\ntype PathAndChecksum = {\n  path: AbsolutePath;\n  checksum: string;\n};\n\n/**\n * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.\n * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: \"/src/application/user/user.model.ts\"\n */\nexport async function findChangedFilesUsingChecksums(): Promise<AbsolutePath[]> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return [];\n  }\n\n  return differenceWith(calculatedChecksums, savedChecksums, isEqual).map((r) => r.path);\n}\n\n/**\n * 체크섬을 갱신합니다.\n * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.\n */\nexport async function renewChecksums(): Promise<void> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return;\n  }\n\n  await saveChecksums(calculatedChecksums);\n}\n\nasync function getCurrentChecksums(): Promise<PathAndChecksum[]> {\n  const filePaths = (\n    await Promise.all(\n      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern]) => {\n        return globAsync(pattern) as Promise<AbsolutePath[]>;\n      }),\n    )\n  )\n    .flat()\n    .toSorted();\n\n  const fileChecksums = await Promise.all(\n    filePaths.map(async (filePath) => {\n      return {\n        path: filePath,\n        checksum: await getChecksumOfFile(filePath),\n      };\n    }),\n  );\n\n  return fileChecksums;\n}\n\nasync function getPreviousChecksums(): Promise<PathAndChecksum[]> {\n  const checksumFilePath = getChecksumFilePath();\n  if (!(await exists(checksumFilePath))) {\n    return [];\n  }\n\n  try {\n    const previousChecksums = JSON.parse(await readFile(checksumFilePath, \"utf-8\")).map(\n      (r: { path: ApiRelativePath; checksum: string }) => ({\n        path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로\n        checksum: r.checksum,\n      }),\n    ) as PathAndChecksum[];\n    return previousChecksums;\n  } catch (e) {\n    // 체크섬 파일이 손상된 경우 빈 배열 반환 (전체 재동기화 유도)\n    console.warn(\n      `체크섬 파일(${checksumFilePath})을 파싱하는 데 실패했습니다. 전체 재동기화를 진행합니다.`,\n      e,\n    );\n    return [];\n  }\n}\n\nfunction getChecksumFilePath(): AbsolutePath {\n  return path.join(Sonamu.apiRootPath, \"sonamu.lock\") as AbsolutePath;\n}\n\nasync function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {\n  const checksumFilePath = getChecksumFilePath();\n  await writeFile(\n    checksumFilePath,\n    JSON.stringify(\n      checksums.map((r) => ({\n        path: path.relative(Sonamu.apiRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → API 상대 경로\n        checksum: r.checksum,\n      })),\n      null,\n      2,\n    ),\n    \"utf-8\",\n  );\n}\n\nasync function getChecksumOfFile(filePath: PathLike): Promise<string> {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"sha1\");\n    const input = createReadStream(filePath);\n    input.on(\"error\", reject);\n    input.on(\"data\", (chunk: BinaryLike) => {\n      hash.update(chunk);\n    });\n    input.on(\"close\", () => {\n      resolve(hash.digest(\"hex\"));\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA0BA,eAAsB,iCAA0D;CAC9E,MAAM,sBAAsB,MAAM,qBAAqB;CACvD,MAAM,iBAAiB,MAAM,sBAAsB;CAEnD,MAAM,SAAS,MAAM,qBAAqB,eAAe;AACzD,KAAI,QAAQ;AACV,SAAO,EAAE;;AAGX,QAAO,eAAe,qBAAqB,gBAAgB,QAAQ,CAAC,KAAK,MAAM,EAAE,KAAK;;;;;;AAOxF,eAAsB,iBAAgC;CACpD,MAAM,sBAAsB,MAAM,qBAAqB;CACvD,MAAM,iBAAiB,MAAM,sBAAsB;CAEnD,MAAM,SAAS,MAAM,qBAAqB,eAAe;AACzD,KAAI,QAAQ;AACV;;AAGF,OAAM,cAAc,oBAAoB;;AAG1C,eAAe,sBAAkD;CAC/D,MAAM,aACJ,MAAM,QAAQ,IACZ,OAAO,QAAQ,uCAAuC,CAAC,CAAC,IAAI,OAAO,CAAC,WAAW,aAAa;AAC1F,SAAO,UAAU,QAAQ;GACzB,CACH,EAEA,MAAM,CACN,UAAU;CAEb,MAAM,gBAAgB,MAAM,QAAQ,IAClC,UAAU,IAAI,OAAO,aAAa;AAChC,SAAO;GACL,MAAM;GACN,UAAU,MAAM,kBAAkB,SAAS;GAC5C;GACD,CACH;AAED,QAAO;;AAGT,eAAe,uBAAmD;CAChE,MAAM,mBAAmB,qBAAqB;AAC9C,KAAI,CAAE,MAAM,OAAO,iBAAiB,EAAG;AACrC,SAAO,EAAE;;AAGX,KAAI;EACF,MAAM,oBAAoB,KAAK,MAAM,MAAM,SAAS,kBAAkB,QAAQ,CAAC,CAAC,KAC7E,OAAoD;GACnD,MAAM,KAAK,KAAK,OAAO,aAAa,EAAE,KAAK;GAC3C,UAAU,EAAE;GACb,EACF;AACD,SAAO;UACA,GAAG;AAEV,UAAQ,KACN,UAAU,iBAAiB,oCAC3B,EACD;AACD,SAAO,EAAE;;;AAIb,SAAS,sBAAoC;AAC3C,QAAO,KAAK,KAAK,OAAO,aAAa,cAAc;;AAGrD,eAAe,cAAc,WAA6C;CACxE,MAAM,mBAAmB,qBAAqB;AAC9C,OAAM,UACJ,kBACA,KAAK,UACH,UAAU,KAAK,OAAO;EACpB,MAAM,KAAK,SAAS,OAAO,aAAa,EAAE,KAAK;EAC/C,UAAU,EAAE;EACb,EAAE,EACH,MACA,EACD,EACD,QACD;;AAGH,eAAe,kBAAkB,UAAqC;AACpE,QAAO,IAAI,SAAiB,SAAS,WAAW;EAC9C,MAAM,OAAO,OAAO,WAAW,OAAO;EACtC,MAAM,QAAQ,iBAAiB,SAAS;AACxC,QAAM,GAAG,SAAS,OAAO;AACzB,QAAM,GAAG,SAAS,UAAsB;AACtC,QAAK,OAAO,MAAM;IAClB;AACF,QAAM,GAAG,eAAe;AACtB,WAAQ,KAAK,OAAO,MAAM,CAAC;IAC3B;GACF;;;cA1HmC;mBACU;gBACN;aAEK;qBACwB"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"checksum.js","names":[],"sources":["../../src/syncer/checksum.ts"],"sourcesContent":["import crypto, { type BinaryLike } from \"crypto\";\nimport { createReadStream, type PathLike } from \"fs\";\nimport { readFile, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport equal from \"fast-deep-equal\";\nimport { isEqual } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { exists } from \"../utils/fs-utils\";\nimport { type AbsolutePath, type AppRelativePath } from \"../utils/path-utils\";\nimport { differenceWith } from \"../utils/utils\";\nimport { getChecksumPatternGroupInAbsolutePath, GLOB_EXCLUDE } from \"./file-patterns\";\n\ntype PathAndChecksum = {\n  path: AbsolutePath;\n  checksum: string;\n};\n\n/**\n * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.\n * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: \"/src/application/user/user.model.ts\"\n */\nexport async function findChangedFilesUsingChecksums(): Promise<AbsolutePath[]> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return [];\n  }\n\n  return differenceWith(calculatedChecksums, savedChecksums, isEqual).map((r) => r.path);\n}\n\n/**\n * 체크섬을 갱신합니다.\n * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.\n */\nexport async function renewChecksums(): Promise<void> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return;\n  }\n\n  await saveChecksums(calculatedChecksums);\n}\n\nasync function getCurrentChecksums(): Promise<PathAndChecksum[]> {\n  const allPaths = (\n    await Promise.all(\n      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(([_fileType, pattern]) => {\n        return globAsync(pattern, { exclude: GLOB_EXCLUDE });\n      }),\n    )\n  ).flat();\n\n  // 동일 파일이 여러 패턴에 매치될 수 있으므로(예: sd.generated.ts는 generated와 sdGenerated에 모두 매치)\n  // 중복 제거 후 안정 정렬.\n  const filePaths = Array.from(new Set(allPaths)).toSorted() as AbsolutePath[];\n\n  return await Promise.all(\n    filePaths.map(async (filePath) => {\n      return {\n        path: filePath,\n        checksum: await getChecksumOfFile(filePath),\n      };\n    }),\n  );\n}\n\nasync function getPreviousChecksums(): Promise<PathAndChecksum[]> {\n  const checksumFilePath = getChecksumFilePath();\n  if (!(await exists(checksumFilePath))) {\n    return [];\n  }\n\n  try {\n    const previousChecksums = JSON.parse(await readFile(checksumFilePath, \"utf-8\")).map(\n      (r: { path: AppRelativePath; checksum: string }) => ({\n        path: path.join(Sonamu.appRootPath, r.path), // 체크섬 파일에서 읽을 때: appRoot 상대 경로 → 절대 경로\n        checksum: r.checksum,\n      }),\n    ) as PathAndChecksum[];\n    return previousChecksums;\n  } catch (e) {\n    // 체크섬 파일이 손상된 경우 빈 배열 반환 (전체 재동기화 유도)\n    console.warn(\n      `체크섬 파일(${checksumFilePath})을 파싱하는 데 실패했습니다. 전체 재동기화를 진행합니다.`,\n      e,\n    );\n    return [];\n  }\n}\n\nfunction getChecksumFilePath(): AbsolutePath {\n  return path.join(Sonamu.apiRootPath, \"sonamu.lock\") as AbsolutePath;\n}\n\nasync function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {\n  const checksumFilePath = getChecksumFilePath();\n  // appRoot 상대 경로로 직렬화 + 알파벳 안정 정렬 (PR diff 깨끗하게 유지)\n  const serialized = checksums\n    .map((r) => ({\n      path: path.relative(Sonamu.appRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → appRoot 상대 경로\n      checksum: r.checksum,\n    }))\n    .sort((a, b) => a.path.localeCompare(b.path));\n  await writeFile(checksumFilePath, JSON.stringify(serialized, null, 2), \"utf-8\");\n}\n\nasync function getChecksumOfFile(filePath: PathLike): Promise<string> {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"sha1\");\n    const input = createReadStream(filePath);\n    input.on(\"error\", reject);\n    input.on(\"data\", (chunk: BinaryLike) => {\n      hash.update(chunk);\n    });\n    input.on(\"close\", () => {\n      resolve(hash.digest(\"hex\"));\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,eAAsB,iCAA0D;CAC9E,MAAM,sBAAsB,MAAM,qBAAqB;CACvD,MAAM,iBAAiB,MAAM,sBAAsB;CAEnD,MAAM,SAAS,MAAM,qBAAqB,eAAe;AACzD,KAAI,QAAQ;AACV,SAAO,EAAE;;AAGX,QAAO,eAAe,qBAAqB,gBAAgB,QAAQ,CAAC,KAAK,MAAM,EAAE,KAAK;;;;;;AAOxF,eAAsB,iBAAgC;CACpD,MAAM,sBAAsB,MAAM,qBAAqB;CACvD,MAAM,iBAAiB,MAAM,sBAAsB;CAEnD,MAAM,SAAS,MAAM,qBAAqB,eAAe;AACzD,KAAI,QAAQ;AACV;;AAGF,OAAM,cAAc,oBAAoB;;AAG1C,eAAe,sBAAkD;CAC/D,MAAM,YACJ,MAAM,QAAQ,IACZ,OAAO,QAAQ,uCAAuC,CAAC,CAAC,KAAK,CAAC,WAAW,aAAa;AACpF,SAAO,UAAU,SAAS,EAAE,SAAS,cAAc,CAAC;GACpD,CACH,EACD,MAAM;CAIR,MAAM,YAAY,MAAM,KAAK,IAAI,IAAI,SAAS,CAAC,CAAC,UAAU;AAE1D,QAAO,MAAM,QAAQ,IACnB,UAAU,IAAI,OAAO,aAAa;AAChC,SAAO;GACL,MAAM;GACN,UAAU,MAAM,kBAAkB,SAAS;GAC5C;GACD,CACH;;AAGH,eAAe,uBAAmD;CAChE,MAAM,mBAAmB,qBAAqB;AAC9C,KAAI,CAAE,MAAM,OAAO,iBAAiB,EAAG;AACrC,SAAO,EAAE;;AAGX,KAAI;EACF,MAAM,oBAAoB,KAAK,MAAM,MAAM,SAAS,kBAAkB,QAAQ,CAAC,CAAC,KAC7E,OAAoD;GACnD,MAAM,KAAK,KAAK,OAAO,aAAa,EAAE,KAAK;GAC3C,UAAU,EAAE;GACb,EACF;AACD,SAAO;UACA,GAAG;AAEV,UAAQ,KACN,UAAU,iBAAiB,oCAC3B,EACD;AACD,SAAO,EAAE;;;AAIb,SAAS,sBAAoC;AAC3C,QAAO,KAAK,KAAK,OAAO,aAAa,cAAc;;AAGrD,eAAe,cAAc,WAA6C;CACxE,MAAM,mBAAmB,qBAAqB;CAE9C,MAAM,aAAa,UAChB,KAAK,OAAO;EACX,MAAM,KAAK,SAAS,OAAO,aAAa,EAAE,KAAK;EAC/C,UAAU,EAAE;EACb,EAAE,CACF,MAAM,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,KAAK,CAAC;AAC/C,OAAM,UAAU,kBAAkB,KAAK,UAAU,YAAY,MAAM,EAAE,EAAE,QAAQ;;AAGjF,eAAe,kBAAkB,UAAqC;AACpE,QAAO,IAAI,SAAiB,SAAS,WAAW;EAC9C,MAAM,OAAO,OAAO,WAAW,OAAO;EACtC,MAAM,QAAQ,iBAAiB,SAAS;AACxC,QAAM,GAAG,SAAS,OAAO;AACzB,QAAM,GAAG,SAAS,UAAsB;AACtC,QAAK,OAAO,MAAM;IAClB;AACF,QAAM,GAAG,eAAe;AACtB,WAAQ,KAAK,OAAO,MAAM,CAAC;IAC3B;GACF;;;cAtHmC;mBACU;gBACN;aAEK;qBACsC"}

package/dist/syncer/code-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../src/syncer/code-generator.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAC;AAMxB,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAC1D,GAAG,EAAE,CAAC,EACN,eAAe,EAAE,eAAe,CAAC,CAAC,CAAC,EACnC,gBAAgB,CAAC,EAAE,eAAe,GACjC,OAAO,CAAC,YAAY,EAAE,CAAC,CAyCzB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,eAAe,EAClE,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,WAAW,EAAE,CAAC,CAoBxB"}
+{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../src/syncer/code-generator.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAC;AAMxB,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAC1D,GAAG,EAAE,CAAC,EACN,eAAe,EAAE,eAAe,CAAC,CAAC,CAAC,EACnC,gBAAgB,CAAC,EAAE,eAAe,GACjC,OAAO,CAAC,YAAY,EAAE,CAAC,CAyCzB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,eAAe,EAClE,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,WAAW,EAAE,CAAC,CAoBxB"}

package/dist/syncer/code-generator.js

@@ -2,15 +2,16 @@ import { __esmMin } from "../_virtual/rolldown_runtime.js";
 import { SD, init_sd } from "../dict/sd.js";
 import { AlreadyProcessedException, init_so_exceptions } from "../exceptions/so-exceptions.js";
 import { init_controller, isTest } from "../utils/controller.js";
+import { everyAsync, filterAsync, init_async_utils } from "../utils/async-utils.js";
+import { formatCode, init_formatter } from "../utils/formatter.js";
 import { exists, init_fs_utils } from "../utils/fs-utils.js";
 import { Sonamu, init_sonamu } from "../api/sonamu.js";
-import { everyAsync, filterAsync, init_async_utils } from "../utils/async-utils.js";
 import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
 import { Naite, init_naite } from "../naite/naite.js";
-import { formatCode, init_formatter } from "../utils/formatter.js";
 import { TemplateManager, init_template_manager } from "../template/template-manager.js";
 import { BUILT_IN_TYPES, init_zod_converter } from "../template/zod-converter.js";
 import { init_lodash_able, wrapIf } from "../utils/lodash-able.js";
+import { init_file_tracking, trackWritten } from "./file-tracking.js";
 import { unique } from "radashi";
 import { mkdir, writeFile } from "fs/promises";
 import path from "path";
@@ -118,7 +119,7 @@ async function resolveRenderedTemplate(key, result) {
 				header,
 				body
 			});
-			const formatted$1 = await formatCode([header, body].join("\n\n"), key === "entity" ? "json" : "typescript", `${Sonamu.appRootPath}/${filePath}`);
+			const formatted$1 = await formatCode([header, body].join("\n\n"), `${Sonamu.appRootPath}/${filePath}`);
 			Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted$1);
 			return formatted$1;
 		}
@@ -139,6 +140,7 @@ async function writeCodeToPathEachTarget(pathAndCode) {
 			await mkdir(dir, { recursive: true });
 		}
 		await writeFile(dstFilePath, pathAndCode.code);
+		await trackWritten(dstFilePath);
 		!isTest() && console.log(chalk.bold("Generated: ") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, "")}`));
 		return dstFilePath;
 	}));
@@ -156,9 +158,10 @@ var init_code_generator = __esmMin((() => {
 	init_formatter();
 	init_fs_utils();
 	init_lodash_able();
+	init_file_tracking();
 }));
 
 //#endregion
 init_code_generator();
 export { generateTemplate, init_code_generator, renderTemplate };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"code-generator.js","names":["keys: TemplateKey[]","key","filteredPathAndCodes: PathAndCode[]","preTemplateResolved: PathAndCode[]","options","formatted"],"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import { mkdir, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport { unique } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { SD } from \"../dict/sd\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { type RenderedTemplate } from \"../template/template\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { BUILT_IN_TYPES } from \"../template/zod-converter\";\nimport {\n  type GenerateOptions,\n  type PathAndCode,\n  type TemplateKey,\n  type TemplateOptions,\n} from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { exists } from \"../utils/fs-utils\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate<T extends TemplateKey>(\n  key: T,\n  templateOptions: TemplateOptions[T],\n  _generateOptions?: GenerateOptions,\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n  Naite.t(\"generateTemplate\", { key, templateOptions, generateOptions });\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      }),\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`));\n        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));\n      });\n    }\n  })();\n\n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(SD(\"sonamu.error.allFilesExist\"));\n  }\n\n  return (\n    await Promise.all(\n      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),\n    )\n  ).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T],\n): Promise<PathAndCode[]> {\n  Naite.t(\"renderTemplate\", { key, options });\n\n  const template = TemplateManager.get(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        }),\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate,\n): Promise<PathAndCode> {\n  Naite.t(`resolveRenderedTemplate${key}`, { key, result });\n\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map((info) => info.schemaName as string);\n  const importDefs = importKeys\n    // 내장 타입 스키마는 이미 sonamu에서 import되므로 제외\n    .filter((importKey) => !builtInSchemaNames.includes(importKey))\n    .reduce(\n      (r, importKey) => {\n        let modulePath = importKey;\n        try {\n          modulePath = EntityManager.getModulePath(importKey);\n        } catch (error) {\n          throw new Error(\n            `[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`,\n            { cause: error },\n          );\n        }\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [\n            !p.startsWith(\".\"),\n            `./${p}`,\n          ]);\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = unique(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[],\n    )\n    // 셀프 참조 방지\n    .filter((importDef) => !filePath.endsWith(`${importDef.from.replace(\"./\", \"\")}.ts`));\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) => `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`,\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      Naite.t(\"resolveRenderedTemplate:beforeFormat\", { key, header, body });\n      const formatted = await formatCode(\n        [header, body].join(\"\\n\\n\"),\n        key === \"entity\" ? \"json\" : \"typescript\",\n        `${Sonamu.appRootPath}/${filePath}`,\n      );\n      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);\n      return formatted;\n    }\n  })();\n\n  return {\n    path: `${target}/${filePath}`,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = unique(\n    targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`)) as AbsolutePath[],\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Generated: \") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, \"\")}`),\n        );\n      return dstFilePath;\n    }),\n  );\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"code-generator.js","names":["keys: TemplateKey[]","key","filteredPathAndCodes: PathAndCode[]","preTemplateResolved: PathAndCode[]","options","formatted"],"sources":["../../src/syncer/code-generator.ts"],"sourcesContent":["import { mkdir, writeFile } from \"fs/promises\";\nimport path from \"path\";\n\nimport chalk from \"chalk\";\nimport { unique } from \"radashi\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { SD } from \"../dict/sd\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { AlreadyProcessedException } from \"../exceptions/so-exceptions\";\nimport { Naite } from \"../naite/naite\";\nimport { type RenderedTemplate } from \"../template/template\";\nimport { TemplateManager } from \"../template/template-manager\";\nimport { BUILT_IN_TYPES } from \"../template/zod-converter\";\nimport {\n  type GenerateOptions,\n  type PathAndCode,\n  type TemplateKey,\n  type TemplateOptions,\n} from \"../types/types\";\nimport { everyAsync, filterAsync } from \"../utils/async-utils\";\nimport { isTest } from \"../utils/controller\";\nimport { formatCode } from \"../utils/formatter\";\nimport { exists } from \"../utils/fs-utils\";\nimport { wrapIf } from \"../utils/lodash-able\";\nimport { type AbsolutePath } from \"../utils/path-utils\";\nimport { trackWritten } from \"./file-tracking\";\n\n/**\n * 템플릿을 렌더링하고 파일로 생성합니다.\n * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.\n * @param key - 템플릿 키 (예: \"entity\", \"model\", \"service\" 등)\n * @param templateOptions - 템플릿 렌더링에 필요한 옵션\n * @param _generateOptions - 생성 옵션 (overwrite 여부)\n * @returns 생성된 파일 경로 배열\n */\nexport async function generateTemplate<T extends TemplateKey>(\n  key: T,\n  templateOptions: TemplateOptions[T],\n  _generateOptions?: GenerateOptions,\n): Promise<AbsolutePath[]> {\n  const generateOptions = {\n    overwrite: false,\n    ..._generateOptions,\n  };\n  Naite.t(\"generateTemplate\", { key, templateOptions, generateOptions });\n\n  // 키 children\n  const keys: TemplateKey[] = [key];\n\n  // 템플릿 렌더\n  const pathAndCodes = (\n    await Promise.all(\n      keys.map(async (key) => {\n        return await renderTemplate(key, templateOptions);\n      }),\n    )\n  ).flat();\n\n  const filteredPathAndCodes: PathAndCode[] = await (async () => {\n    if (generateOptions.overwrite) {\n      return pathAndCodes;\n    } else {\n      return await filterAsync(pathAndCodes, async (pathAndCode) => {\n        const { targets } = Sonamu.config.sync;\n        const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}`;\n        const dstFilePaths = targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`));\n        return await everyAsync(dstFilePaths, async (dstPath) => !(await exists(dstPath)));\n      });\n    }\n  })();\n\n  if (filteredPathAndCodes.length === 0) {\n    throw new AlreadyProcessedException(SD(\"sonamu.error.allFilesExist\"));\n  }\n\n  return (\n    await Promise.all(\n      filteredPathAndCodes.map((pathAndCode) => writeCodeToPathEachTarget(pathAndCode)),\n    )\n  ).flat();\n}\n\n/**\n * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.\n * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.\n * @param key - 템플릿 키\n * @param options - 템플릿 렌더링 옵션\n * @returns 경로와 코드 쌍의 배열\n */\nexport async function renderTemplate<T extends keyof TemplateOptions>(\n  key: T,\n  options: TemplateOptions[T],\n): Promise<PathAndCode[]> {\n  Naite.t(\"renderTemplate\", { key, options });\n\n  const template = TemplateManager.get(key);\n\n  const rendered = await template.render(options);\n  const resolved = await resolveRenderedTemplate(key, rendered);\n\n  let preTemplateResolved: PathAndCode[] = [];\n  if (rendered.preTemplates) {\n    preTemplateResolved = (\n      await Promise.all(\n        rendered.preTemplates.map(({ key, options }) => {\n          return renderTemplate(key, options);\n        }),\n      )\n    ).flat();\n  }\n\n  return [resolved, ...preTemplateResolved];\n}\n\nasync function resolveRenderedTemplate(\n  key: TemplateKey,\n  result: RenderedTemplate,\n): Promise<PathAndCode> {\n  Naite.t(`resolveRenderedTemplate${key}`, { key, result });\n\n  const { target, path: filePath, body, importKeys, customHeaders } = result;\n\n  // import 할 대상의 대상 path 추출\n  const builtInSchemaNames = Object.values(BUILT_IN_TYPES).map((info) => info.schemaName as string);\n  const importDefs = importKeys\n    // 내장 타입 스키마는 이미 sonamu에서 import되므로 제외\n    .filter((importKey) => !builtInSchemaNames.includes(importKey))\n    .reduce(\n      (r, importKey) => {\n        let modulePath = importKey;\n        try {\n          modulePath = EntityManager.getModulePath(importKey);\n        } catch (error) {\n          throw new Error(\n            `[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`,\n            { cause: error },\n          );\n        }\n        let importPath = modulePath;\n        if (modulePath.includes(\"/\") || modulePath.includes(\".\")) {\n          importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [\n            !p.startsWith(\".\"),\n            `./${p}`,\n          ]);\n        }\n\n        // 같은 파일에서 import 하는 경우 keys 로 나열 처리\n        const existsOne = r.find((importDef) => importDef.from === importPath);\n        if (existsOne) {\n          existsOne.keys = unique(existsOne.keys.concat(importKey));\n        } else {\n          r.push({\n            keys: [importKey],\n            from: importPath,\n          });\n        }\n        return r;\n      },\n      [] as {\n        keys: string[];\n        from: string;\n      }[],\n    )\n    // 셀프 참조 방지\n    .filter((importDef) => !filePath.endsWith(`${importDef.from.replace(\"./\", \"\")}.ts`));\n\n  // 커스텀 헤더 포함하여 헤더 생성\n  const header = [\n    ...(customHeaders ?? []),\n    ...importDefs.map(\n      (importDef) => `import { ${importDef.keys.join(\", \")} } from '${importDef.from}'`,\n    ),\n  ].join(\"\\n\");\n\n  const formatted = await (async () => {\n    if (key === \"generated_http\") {\n      return [header, body].join(\"\\n\\n\");\n    } else {\n      Naite.t(\"resolveRenderedTemplate:beforeFormat\", { key, header, body });\n      const formatted = await formatCode(\n        [header, body].join(\"\\n\\n\"),\n        `${Sonamu.appRootPath}/${filePath}`,\n      );\n      Naite.t(`resolveRenderedTemplate:formatted:${key}`, formatted);\n      return formatted;\n    }\n  })();\n\n  return {\n    path: `${target}/${filePath}`,\n    code: formatted,\n  };\n}\n\nasync function writeCodeToPathEachTarget(pathAndCode: PathAndCode): Promise<AbsolutePath[]> {\n  const { targets } = Sonamu.config.sync;\n  const { appRootPath } = Sonamu;\n  const filePath = `${Sonamu.appRootPath}/${pathAndCode.path}` as AbsolutePath;\n\n  const dstFilePaths = unique(\n    targets.map((target) => filePath.replace(\"/:target/\", `/${target}/`)) as AbsolutePath[],\n  );\n  return await Promise.all(\n    dstFilePaths.map(async (dstFilePath) => {\n      const dir = path.dirname(dstFilePath);\n      if (!(await exists(dir))) {\n        await mkdir(dir, { recursive: true });\n      }\n      await writeFile(dstFilePath, pathAndCode.code);\n      // 방금 우리가 쓴 path를 등록 → dev watcher의 후속 change 이벤트가\n      // 외부 변경으로 오인되지 않도록 거름 가드 자료 제공.\n      await trackWritten(dstFilePath);\n      !isTest() &&\n        console.log(\n          chalk.bold(\"Generated: \") + chalk.blue(`${dstFilePath.replace(`${appRootPath}/`, \"\")}`),\n        );\n      return dstFilePath;\n    }),\n  );\n}\n"],"mappings":"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"}

package/dist/syncer/event-batcher.d.ts

@@ -0,0 +1,27 @@
+import { type AbsolutePath } from "../utils/path-utils";
+/**
+ * 파일 변경 이벤트를 batch로 모아 한 번에 처리하는 throttler를 만듭니다.
+ *
+ * 동작:
+ * - 같은 path가 여러 번 push되면 마지막 event로 dedupe됩니다.
+ * - 마지막 push 후 `delayMs` 동안 추가 push가 없으면 한 번에 flush됩니다 (trailing debounce).
+ * - flush 도중 들어오는 push는 다음 batch로 큐잉됩니다.
+ * - 한 시점에 onFlush는 단 하나만 진행됩니다 — 이로써 onFlush 내부에서 일어나는
+ *   작업이 다른 onFlush 호출과 인터리브되지 않음을 보장합니다.
+ *
+ * 호출자는 push만 하면 됩니다. 내부 큐/타이머 상태는 캡슐화되어 있고, onFlush가
+ * 받는 fileEvents는 dedupe된 Map입니다.
+ *
+ * @example
+ * const push = createFileEventBatcher({
+ *   delayMs: 100,
+ *   onFlush: (fileEvents) => handleBatch(fileEvents),
+ * });
+ * push("/path/a.ts" as AbsolutePath, "change");
+ * push("/path/b.ts" as AbsolutePath, "change"); // 100ms 후 둘 다 한 번에 onFlush로
+ */
+export declare function createFileEventBatcher<FileEventT extends string>(options: {
+    delayMs: number;
+    onFlush: (fileEvents: Map<AbsolutePath, FileEventT>) => Promise<void>;
+}): (path: AbsolutePath, event: FileEventT) => void;
+//# sourceMappingURL=event-batcher.d.ts.map

package/dist/syncer/event-batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-batcher.d.ts","sourceRoot":"","sources":["../../src/syncer/event-batcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,SAAS,MAAM,EAAE,OAAO,EAAE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,CAAC,UAAU,EAAE,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CA6ClD"}

package/dist/syncer/event-batcher.js

@@ -0,0 +1,69 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+
+//#region src/syncer/event-batcher.ts
+/**
+* 파일 변경 이벤트를 batch로 모아 한 번에 처리하는 throttler를 만듭니다.
+*
+* 동작:
+* - 같은 path가 여러 번 push되면 마지막 event로 dedupe됩니다.
+* - 마지막 push 후 `delayMs` 동안 추가 push가 없으면 한 번에 flush됩니다 (trailing debounce).
+* - flush 도중 들어오는 push는 다음 batch로 큐잉됩니다.
+* - 한 시점에 onFlush는 단 하나만 진행됩니다 — 이로써 onFlush 내부에서 일어나는
+*   작업이 다른 onFlush 호출과 인터리브되지 않음을 보장합니다.
+*
+* 호출자는 push만 하면 됩니다. 내부 큐/타이머 상태는 캡슐화되어 있고, onFlush가
+* 받는 fileEvents는 dedupe된 Map입니다.
+*
+* @example
+* const push = createFileEventBatcher({
+*   delayMs: 100,
+*   onFlush: (fileEvents) => handleBatch(fileEvents),
+* });
+* push("/path/a.ts" as AbsolutePath, "change");
+* push("/path/b.ts" as AbsolutePath, "change"); // 100ms 후 둘 다 한 번에 onFlush로
+*/
+function createFileEventBatcher(options) {
+	const { delayMs, onFlush } = options;
+	const pending = new Map();
+	let flushTimer = null;
+	let isFlushing = false;
+	const scheduleFlush = () => {
+		if (flushTimer !== null) {
+			clearTimeout(flushTimer);
+		}
+		flushTimer = setTimeout(() => {
+			flushTimer = null;
+			void runFlush();
+		}, delayMs);
+	};
+	const runFlush = async () => {
+		if (isFlushing || pending.size === 0) {
+			return;
+		}
+		isFlushing = true;
+		try {
+			const batch = new Map(pending);
+			pending.clear();
+			try {
+				await onFlush(batch);
+			} catch (e) {
+				console.error(e);
+			}
+		} finally {
+			isFlushing = false;
+			if (pending.size > 0) {
+				scheduleFlush();
+			}
+		}
+	};
+	return (path, event) => {
+		pending.set(path, event);
+		scheduleFlush();
+	};
+}
+var init_event_batcher = __esmMin((() => {}));
+
+//#endregion
+init_event_batcher();
+export { createFileEventBatcher, init_event_batcher };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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