@simplysm/sd-cli 12.13.21 → 12.13.35

package/src/pkg-builders/server/{sd-server.plugin-creator.ts → createSdServerPlugin.ts}

@@ -1,19 +1,20 @@
 import esbuild from "esbuild";
-import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.utils";
-import { ISdCliServerPluginResultCache } from "../../types/build-plugin.types";
+import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
 import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
-import { ISdTsCompilerResult } from "../../types/ts-compiler.types";
-import { SdTsCompiler } from "../../ts-compiler/sd-ts-compiler";
-import { ScopePathSet } from "../commons/scope-path";
+import { SdTsCompiler } from "../../ts-compiler/SdTsCompiler";
+import { ScopePathSet } from "../commons/ScopePathSet";
+import { ISdCliServerPluginResultCache } from "../../types/plugin/ISdCliServerPluginResultCache";
+import { ISdTsCompilerResult } from "../../types/build/ISdTsCompilerResult";
 
 export function createSdServerPlugin(conf: {
   pkgPath: TNormPath;
+  watch: boolean;
   dev: boolean;
   emitOnly: boolean;
   noEmit: boolean;
   modifiedFileSet: Set<TNormPath>;
   result: ISdCliServerPluginResultCache;
-  watchScopePathSet: ScopePathSet;
+  scopePathSet: ScopePathSet;
 }): esbuild.Plugin {
   return {
     name: "sd-server-compile",
@@ -21,11 +22,12 @@ export function createSdServerPlugin(conf: {
       const tsCompiler = new SdTsCompiler({
         pkgPath: conf.pkgPath,
         additionalOptions: { declaration: false },
+        isWatchMode: conf.watch,
         isDevMode: conf.dev,
         isNoEmit: conf.noEmit,
         isEmitOnly: conf.emitOnly,
         isForBundle: true,
-        watchScopePathSet: conf.watchScopePathSet,
+        scopePathSet: conf.scopePathSet,
       });
 
       let tsCompileResult: ISdTsCompilerResult;

package/src/sd-cli-entry.ts

@@ -6,12 +6,12 @@ import { SdLogger, SdLoggerSeverity } from "@simplysm/sd-core-node";
 import { EventEmitter } from "events";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { SdCliAiCommand } from "./entry/sd-cli-ai-command";
-import { SdCliCordova } from "./entry/sd-cli-cordova";
-import { SdCliElectron } from "./entry/sd-cli-electron";
-import { SdCliLocalUpdate } from "./entry/sd-cli-local-update";
-import { SdCliPostinstall } from "./entry/sd-cli-postinstall";
-import { SdCliProject } from "./entry/sd-cli-project";
+import { SdCliAiCommand } from "./entry/SdCliAiCommand";
+import { SdCliCordova } from "./entry/SdCliCordova";
+import { SdCliElectron } from "./entry/SdCliElectron";
+import { SdCliLocalUpdate } from "./entry/SdCliLocalUpdate";
+import { SdCliPostinstall } from "./entry/SdCliPostinstall";
+import { SdCliProject } from "./entry/SdCliProject";
 import convertPrivateToHash from "./fix/convert-private-to-hash";
 import removeSdAngularSymbolNames from "./fix/remove-sd-angular-symbol-names";
 import convertSdAngularSymbolNames from "./fix/convert-sd-angular-symbol-names";
@@ -88,11 +88,6 @@ await yargs(hideBin(process.argv))
             array: true,
             describe: "수행할 패키지 설정",
           },
-          inspects: {
-            string: true,
-            array: true,
-            describe: "크롬 inspect를 수행할 패키지 설정",
-          },
           emitOnly: {
             type: "boolean",
             describe: "emit만 수행",
@@ -133,7 +128,6 @@ await yargs(hideBin(process.argv))
         }),
     async (argv) => {
       await SdCliProject.buildAsync(argv);
-      process.exit(0);
     },
   )
   .command(

package/src/sd-cli.ts

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 
-/* eslint-disable no-console */
-
 import { exec, spawn } from "child_process";
 import os from "os";
 import path from "path";
@@ -67,6 +65,7 @@ function configureProcessorAffinityAndPriority(pid: number) {
 
   exec(command, (err) => {
     if (err) {
+      // eslint-disable-next-line no-console
       console.error("Affinity 또는 우선순위 설정 실패:", err.message);
     }
   });
@@ -91,19 +90,6 @@ function calculateAffinityMask(cpuCount: number): string {
   return "0x" + mask.toString(16).toUpperCase();
 }
 
-// ProcessorAffinity 마스크 계산 (뒤 코어 빼기)
-// function calculateAffinityMask(cpuCount: number): string {
-//   const exclude = cpuCount <= 1 ? 0 : Math.ceil(cpuCount / 8); // 8개당 1개씩 뺌
-//   const usable = cpuCount - exclude;
-//
-//   if (usable <= 0) {
-//     throw new Error(`CPU 사용 가능 개수가 0 이하입니다 (총: ${cpuCount}, 제외: ${exclude})`);
-//   }
-//
-//   const maskValue = (1 << usable) - 1;
-//   return "0x" + maskValue.toString(16).toUpperCase();
-// }
-
 async function spawnWaitAsync(command: string, args: string[]) {
   await new Promise<void>((resolve) => {
     const child = spawn(command, args, {

package/src/ts-compiler/{sd-dependency-analyzer.ts → SdDepAnalyzer.ts}

@@ -1,17 +1,17 @@
 import ts from "typescript";
-import { SdDependencyCache } from "./sd-dependency-cache";
+import { SdDepCache } from "./SdDepCache";
 import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
 import path from "path";
 import { NgtscProgram } from "@angular/compiler-cli";
-import { ScopePathSet } from "../pkg-builders/commons/scope-path";
+import { ScopePathSet } from "../pkg-builders/commons/ScopePathSet";
 
-export class SdDependencyAnalyzer {
+export class SdDepAnalyzer {
   static analyze(
     program: ts.Program,
     compilerHost: ts.CompilerHost,
     scopePathSet: ScopePathSet,
     cache: {
-      dep: SdDependencyCache;
+      dep: SdDepCache;
       type: WeakMap<ts.Node, ts.Type | undefined>;
       prop: WeakMap<ts.Type, Map<string, ts.Symbol | undefined>>;
       declFiles: WeakMap<ts.Symbol, TNormPath[]>;
@@ -162,8 +162,6 @@ export class SdDependencyAnalyzer {
       return s;
     };
 
-    // const declFilesCache = new WeakMap<ts.Symbol, TNormPath[]>();
-
     const getDeclFileNPaths = (sym: ts.Symbol | undefined): TNormPath[] => {
       if (!sym) return [];
       const c = cache.declFiles.get(sym);
@@ -328,8 +326,6 @@ export class SdDependencyAnalyzer {
       ts.forEachChild(sf, visit);
     };
 
-    // const ngToOrgCache = new Map<TNormPath, ts.SourceFile>();
-
     const getOrgSourceFile = (sf: ts.SourceFile) => {
       if (sf.fileName.endsWith(".ngtypecheck.ts")) {
         const sfNPath = PathUtils.norm(sf.fileName);
@@ -362,7 +358,7 @@ export class SdDependencyAnalyzer {
   static analyzeAngularResources(
     ngProgram: NgtscProgram,
     scopePathSet: ScopePathSet,
-    depCache: SdDependencyCache,
+    depCache: SdDepCache,
   ) {
     for (const sf of ngProgram.getTsProgram().getSourceFiles()) {
       const fileNPath = PathUtils.norm(sf.fileName);

package/src/ts-compiler/{sd-dependency-cache.ts → SdDepCache.ts}

@@ -1,6 +1,6 @@
 import { TNormPath } from "@simplysm/sd-core-node";
 
-export class SdDependencyCache {
+export class SdDepCache {
   /**
    * 각 파일이 export한 심볼 집합 (예: export const A → "A")
    */
@@ -59,13 +59,6 @@ export class SdDependencyCache {
     return [nPath];
   }
 
-  /**
-   * 전체 추적된 파일 경로를 반환
-   */
-  // getFiles(): Set<TNormPath> {
-  //   return new Set<TNormPath>([...this.#collectedCache.keys(), ...this.revDepCache.keys()]);
-  // }
-
   /**
    * 분석이 완료된 파일로 표시
    */
@@ -174,63 +167,6 @@ export class SdDependencyCache {
     }
   }
 
-  /**
-   * 변경된 파일 경로 집합으로부터 영향을 받는 전체 파일 집합을 계산
-   */
-  /*getAffectedFileSet(modifiedNPathSet: Set<TNormPath>): Set<TNormPath> {
-    const visited = new Set<string>();
-    const result = new Set<TNormPath>();
-
-    const queue: { fileNPath: TNormPath; exportSymbol: string | undefined }[] = [];
-
-    const enqueue = (fileNPath: TNormPath, exportSymbol: string | undefined) => {
-      const key = `${fileNPath}#${exportSymbol}`;
-      if (!visited.has(key)) {
-        visited.add(key);
-        queue.push({ fileNPath, exportSymbol });
-      }
-    };
-
-    for (const modifiedNPath of modifiedNPathSet) {
-      for (const path of this.#getRelatedNPaths(modifiedNPath)) {
-        result.add(path);
-        const exportSymbols = this.#getExportSymbols(path);
-        if (exportSymbols.size === 0) {
-          enqueue(path, undefined);
-        } else {
-          for (const symbol of exportSymbols) {
-            enqueue(path, symbol);
-          }
-        }
-      }
-    }
-
-    while (queue.length > 0) {
-      const curr = queue.shift()!;
-      const revDepInfoMap = this._revDepCache.get(curr.fileNPath);
-      if (!revDepInfoMap) continue;
-
-      for (const [revDepFileNPath, revDepInfo] of revDepInfoMap) {
-        if (curr.exportSymbol != null) {
-          const hasImportSymbol = revDepInfo === 0 || revDepInfo.has(curr.exportSymbol);
-          if (hasImportSymbol) {
-            result.add(revDepFileNPath);
-            const exportSymbol = this.#convertImportSymbolToExportSymbol(
-              revDepFileNPath,
-              curr.fileNPath,
-              curr.exportSymbol,
-            );
-            enqueue(revDepFileNPath, exportSymbol);
-          }
-        } else {
-          result.add(revDepFileNPath);
-        }
-      }
-    }
-
-    return result;
-  }*/
-
   getAffectedFileMap(modifiedNPathSet: Set<TNormPath>): Map<TNormPath, Set<TNormPath>> {
     const resultMap = new Map<TNormPath, Set<TNormPath>>();
 
@@ -292,8 +228,6 @@ export class SdDependencyCache {
    * 주어진 파일들 및 그 영향 범위에 해당하는 모든 캐시를 무효화
    */
   invalidates(fileNPathSet: Set<TNormPath>) {
-    // const affectedFileMap = this.getAffectedFileMap(fileNPathSet);
-
     const revDepCacheChanged = new Set<TNormPath>();
 
     for (const fileNPath of fileNPathSet) {
@@ -367,74 +301,4 @@ export class SdDependencyCache {
     this.#exportSymbolCache.set(fileNPath, result);
     return result;
   }
-
-  /**
-   * 변경된 파일로부터 영향을 받는 전체 트리를 반환
-   * - 의존 관계를 시각화 및 구조적으로 추적할 수 있도록 트리 형태로 구성
-   */
-  // getAffectedFileTree(modifiedNPathSet: Set<TNormPath>): ISdAffectedFileTreeNode[] {
-  //   const visited = new Set<string>();
-  //   const nodeMap = new Map<string, ISdAffectedFileTreeNode>();
-  //
-  //   const buildTree = (
-  //     fileNPath: TNormPath,
-  //     exportSymbol: string | undefined,
-  //   ): ISdAffectedFileTreeNode => {
-  //     const key = `${fileNPath}#${exportSymbol ?? "*"}`;
-  //     if (nodeMap.has(key)) return nodeMap.get(key)!;
-  //
-  //     visited.add(key);
-  //
-  //     const node: ISdAffectedFileTreeNode = {
-  //       fileNPath,
-  //       children: [],
-  //     };
-  //     nodeMap.set(key, node);
-  //
-  //     const revDepInfoMap = this.revDepCache.get(fileNPath);
-  //     if (!revDepInfoMap) return node;
-  //
-  //     for (const [revDepFileNPath, revDepInfo] of revDepInfoMap.entries()) {
-  //       const hasImportSymbol =
-  //         exportSymbol == null || revDepInfo === 0 || revDepInfo.has(exportSymbol);
-  //       if (!hasImportSymbol) continue;
-  //
-  //       const nextExportSymbol =
-  //         exportSymbol != null
-  //           ? this.#convertImportSymbolToExportSymbol(revDepFileNPath, fileNPath, exportSymbol)
-  //           : undefined;
-  //
-  //       const childKey = `${revDepFileNPath}#${nextExportSymbol ?? "*"}`;
-  //       if (visited.has(childKey)) continue;
-  //
-  //       const childNode = buildTree(revDepFileNPath, nextExportSymbol);
-  //       node.children.push(childNode);
-  //     }
-  //
-  //     return node;
-  //   };
-  //
-  //   const result: ISdAffectedFileTreeNode[] = [];
-  //
-  //   for (const modifiedNPath of modifiedNPathSet) {
-  //     for (const path of this.#getRelatedNPaths(modifiedNPath)) {
-  //       result.push(buildTree(path, undefined)); // root는 symbol상관없이
-  //       /*const exportSymbols = this.#getExportSymbols(path);
-  //       if (exportSymbols.size === 0) {
-  //         result.push(buildTree(path, undefined));
-  //       } else {
-  //         for (const symbol of exportSymbols) {
-  //           result.push(buildTree(path, symbol));
-  //         }
-  //       }*/
-  //     }
-  //   }
-  //
-  //   return result;
-  // }
-}
-
-export interface ISdAffectedFileTreeNode {
-  fileNPath: TNormPath;
-  children: ISdAffectedFileTreeNode[];
 }

package/src/ts-compiler/{sd-style-bundler.ts → SdStyleBundler.ts}

@@ -1,9 +1,9 @@
 import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
-import { TStylesheetBundlingResult } from "../types/ts-compiler.types";
 import { ComponentStylesheetBundler } from "@angular/build/src/tools/esbuild/angular/component-stylesheets";
 import { transformSupportedBrowsersToTargets } from "@angular/build/src/tools/esbuild/utils";
 import browserslist from "browserslist";
-import { ScopePathSet } from "../pkg-builders/commons/scope-path";
+import { ScopePathSet } from "../pkg-builders/commons/ScopePathSet";
+import { TStylesheetBundlingResult } from "../types/build/TStylesheetBundlingResult";
 
 export class SdStyleBundler {
   #ngStyleBundler: ComponentStylesheetBundler;
@@ -14,7 +14,7 @@ export class SdStyleBundler {
   constructor(
     private readonly _pkgPath: TNormPath,
     private readonly _isDevMode: boolean,
-    private readonly _watchScopePathSet: ScopePathSet,
+    private readonly _scopePathSet: ScopePathSet,
   ) {
     this.#ngStyleBundler = new ComponentStylesheetBundler(
       {
@@ -68,8 +68,8 @@ export class SdStyleBundler {
 
       for (const referencedFile of result.referencedFiles ?? []) {
         if (
-          !this._watchScopePathSet.inScope(fileNPath) ||
-          !this._watchScopePathSet.inScope(PathUtils.norm(referencedFile))
+          !this._scopePathSet.inScope(fileNPath) ||
+          !this._scopePathSet.inScope(PathUtils.norm(referencedFile))
         )
           continue;
 

package/src/ts-compiler/{sd-ts-compiler.ts → SdTsCompiler.ts}

@@ -5,14 +5,15 @@ import { StringUtils } from "@simplysm/sd-core-common";
 import { NgtscProgram, OptimizeFor } from "@angular/compiler-cli";
 import { AngularCompilerHost } from "@angular/build/src/tools/angular/angular-host";
 import { replaceBootstrap } from "@angular/build/src/tools/angular/transformers/jit-bootstrap-transformer";
-import { SdCliPerformanceTimer } from "../utils/sd-cli-performance-time";
-import { SdCliConvertMessageUtils } from "../utils/sd-cli-convert-message.utils";
-import { ISdTsCompilerResult, SdTsCompilerOptions } from "../types/ts-compiler.types";
+import { SdCliPerformanceTimer } from "../utils/SdCliPerformanceTimer";
+import { SdCliConvertMessageUtils } from "../utils/SdCliConvertMessageUtils";
 import { createWorkerTransformer } from "@angular/build/src/tools/angular/transformers/web-worker-transformer";
-import { SdDependencyCache } from "./sd-dependency-cache";
-import { SdDependencyAnalyzer } from "./sd-dependency-analyzer";
+import { SdDepCache } from "./SdDepCache";
+import { SdDepAnalyzer } from "./SdDepAnalyzer";
 import { FlatESLint } from "eslint/use-at-your-own-risk";
-import { SdStyleBundler } from "./sd-style-bundler";
+import { SdStyleBundler } from "./SdStyleBundler";
+import { ISdTsCompilerOptions } from "../types/build/ISdTsCompilerOptions";
+import { ISdTsCompilerResult } from "../types/build/ISdTsCompilerResult";
 
 export class SdTsCompiler {
   #logger = SdLogger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
@@ -26,7 +27,7 @@ export class SdTsCompiler {
 
   // 빌드정보 캐싱
   #cache = {
-    dep: new SdDependencyCache(),
+    dep: new SdDepCache(),
     type: new WeakMap<ts.Node, ts.Type | undefined>(),
     prop: new WeakMap<ts.Type, Map<string, ts.Symbol | undefined>>(),
     declFiles: new WeakMap<ts.Symbol, TNormPath[]>(),
@@ -43,7 +44,7 @@ export class SdTsCompiler {
 
   #perf!: SdCliPerformanceTimer;
 
-  constructor(private readonly _opt: SdTsCompilerOptions) {
+  constructor(private readonly _opt: ISdTsCompilerOptions) {
     this.#debug("초기화 중...");
 
     const tsconfigPath = path.resolve(this._opt.pkgPath, "tsconfig.json");
@@ -54,7 +55,7 @@ export class SdTsCompiler {
       this.#styleBundler = new SdStyleBundler(
         this._opt.pkgPath,
         this._opt.isDevMode,
-        this._opt.watchScopePathSet,
+        this._opt.scopePathSet,
       );
     }
   }
@@ -171,23 +172,6 @@ export class SdTsCompiler {
             context.resourceFile != null ? PathUtils.norm(context.resourceFile) : undefined,
           );
 
-          /*if (!styleBundleResult.cached && !StringUtils.isNullOrEmpty(styleBundleResult.contents)) {
-            const relPath = path.relative(
-              path.resolve(this._opt.pkgPath, "src"),
-              context.containingFile,
-            );
-            const outAbsPath = PathUtils.norm(
-              compilerOptions.outDir!,
-              relPath.replace(/\.ts$/, ".css"),
-            );
-            const cache = this.#emittedFilesCacheMap.getOrCreate(
-              PathUtils.norm(context.containingFile),
-              [],
-            );
-            cache.remove((item) => item.outAbsPath === outAbsPath);
-            cache.push({ outAbsPath, text: styleBundleResult.contents });
-          }*/
-
           return StringUtils.isNullOrEmpty(styleBundleResult.contents)
             ? null
             : { content: styleBundleResult.contents };
@@ -240,7 +224,7 @@ export class SdTsCompiler {
 
     const tsconfig = this.#parseTsConfig();
 
-    if (modifiedFileSet.size !== 0) {
+    if (modifiedFileSet.size !== 0 && this._opt.isWatchMode) {
       this.#debug(`캐시 무효화 및 초기화 중...`);
 
       // this._perf.run("캐시 무효화 및 초기화", () => {
@@ -313,17 +297,12 @@ export class SdTsCompiler {
       });
     }
 
-    if (!this._opt.isEmitOnly) {
+    if (!this._opt.isEmitOnly && this._opt.isWatchMode) {
       this.#debug(`새 의존성 분석 중...`);
 
       this.#perf.run("새 의존성 분석", () => {
         // SdTsDependencyAnalyzer를 통해 의존성 분석 및 SdDepCache 업데이트
-        SdDependencyAnalyzer.analyze(
-          this.#program!,
-          compilerHost,
-          this._opt.watchScopePathSet,
-          this.#cache,
-        );
+        SdDepAnalyzer.analyze(this.#program!, compilerHost, this._opt.scopePathSet, this.#cache);
       });
 
       this.#debug(`새 의존성 분석(Angular) 중...`);
@@ -331,9 +310,9 @@ export class SdTsCompiler {
       // Angular 리소스 의존성 추가
       if (this.#ngProgram) {
         this.#perf.run("새 의존성 분석(Angular)", () => {
-          SdDependencyAnalyzer.analyzeAngularResources(
+          SdDepAnalyzer.analyzeAngularResources(
             this.#ngProgram!,
-            this._opt.watchScopePathSet,
+            this._opt.scopePathSet,
             this.#cache.dep,
           );
         });
@@ -341,13 +320,11 @@ export class SdTsCompiler {
     }
 
     const allFiles = this.#program!.getSourceFiles().map((item) => PathUtils.norm(item.fileName));
-    const watchFileSet = new Set(
-      allFiles.filter((item) => this._opt.watchScopePathSet.inScope(item)),
-    );
+    const watchFileSet = new Set(allFiles.filter((item) => this._opt.scopePathSet.inScope(item)));
 
     let affectedFileSet: Set<TNormPath>;
     if (modifiedFileSet.size === 0) {
-      affectedFileSet = new Set(allFiles);
+      affectedFileSet = new Set(allFiles.filter((item) => this._opt.scopePathSet.inScope(item)));
     } else {
       const affectedFileMap = this.#cache.dep.getAffectedFileMap(modifiedFileSet);
       this.#debug("영향받은 파일:", affectedFileMap);
@@ -391,40 +368,35 @@ export class SdTsCompiler {
   }
 
   async #buildGlobalStyleAsync() {
+    if (!this.#isForAngular) return;
+
     //-- global style
-    if (
-      this._opt.globalStyleFilePath != null &&
-      FsUtils.exists(this._opt.globalStyleFilePath) &&
-      !this.#emittedFilesCacheMap.has(this._opt.globalStyleFilePath)
-    ) {
-      this.#debug(`전역 스타일 번들링 중...`);
-
-      await this.#perf.run("전역 스타일 번들링", async () => {
-        const data = await FsUtils.readFileAsync(this._opt.globalStyleFilePath!);
-        const stylesheetBundlingResult = await this.#styleBundler!.bundleAsync(
-          data,
-          this._opt.globalStyleFilePath!,
-          this._opt.globalStyleFilePath,
-        );
-        const emitFileInfos = this.#emittedFilesCacheMap.getOrCreate(
-          this._opt.globalStyleFilePath!,
-          [],
-        );
-        emitFileInfos.push({
-          outAbsPath: PathUtils.norm(
-            this._opt.pkgPath,
-            path
-              .relative(path.resolve(this._opt.pkgPath, "src"), this._opt.globalStyleFilePath!)
-              .replace(/\.scss$/, ".css"),
-          ),
-          text: stylesheetBundlingResult.contents ?? "",
-        });
+    const globalStyleFilePath = PathUtils.norm(this._opt.pkgPath, "src/styles.scss");
+    if (this.#emittedFilesCacheMap.has(globalStyleFilePath)) return;
+    if (!FsUtils.exists(globalStyleFilePath)) return;
+
+    this.#debug(`전역 스타일 번들링 중...`);
+
+    await this.#perf.run("전역 스타일 번들링", async () => {
+      const data = await FsUtils.readFileAsync(globalStyleFilePath);
+      const stylesheetBundlingResult = await this.#styleBundler!.bundleAsync(
+        data,
+        globalStyleFilePath,
+        globalStyleFilePath,
+      );
+      const emitFileInfos = this.#emittedFilesCacheMap.getOrCreate(globalStyleFilePath, []);
+      emitFileInfos.push({
+        outAbsPath: PathUtils.norm(
+          this._opt.pkgPath,
+          path
+            .relative(path.resolve(this._opt.pkgPath, "src"), globalStyleFilePath)
+            .replace(/\.scss$/, ".css"),
+        ),
+        text: stylesheetBundlingResult.contents ?? "",
       });
+    });
 
-      return this._opt.globalStyleFilePath;
-    }
-
-    return undefined;
+    return globalStyleFilePath;
   }
 
   #build(prepareResult: IPrepareResult) {
@@ -459,8 +431,6 @@ export class SdTsCompiler {
           continue;
         }
 
-        // this.#debug(`get diagnostics of file ${affectedFile}...`);
-
         this.#perf.run("개별 파일 진단 수집", () => {
           diagnostics.push(
             ...this.#program!.getSyntacticDiagnostics(affectedSourceFile),
@@ -507,8 +477,6 @@ export class SdTsCompiler {
               return relPath.replace(/\.ts$/, "").replaceAll("\\", "/") + ".js";
             }),
           );
-
-          // (transformers.before ??= []).push(this.#createExternalizeComponentStylesTransformer());
         }
 
         this.#debug(`파일 출력 중...`);
@@ -595,106 +563,6 @@ export class SdTsCompiler {
     };
   }
 
-  /*#createExternalizeComponentStylesTransformer() {
-    const f = ts.factory;
-
-    function upsertEnsureStyleHelper(sf: ts.SourceFile): ts.SourceFile {
-      const importTarget = "./" + path.basename(sf.fileName).replace(/\.ts$/, ".css");
-
-      // 이미 동일한 import가 있으면 스킵
-      if (
-        sf.statements.some(
-          (s) =>
-            ts.isImportDeclaration(s) &&
-            ts.isStringLiteral(s.moduleSpecifier) &&
-            s.moduleSpecifier.text === importTarget,
-        )
-      ) {
-        return sf;
-      }
-
-      const importDecl = f.createImportDeclaration(
-        undefined,
-        undefined,
-        f.createStringLiteral(importTarget),
-      );
-
-      return f.updateSourceFile(sf, [importDecl, ...sf.statements]);
-    }
-
-    const removeStyleProp = (node: ts.ClassDeclaration) => {
-      const allDecorators = ts.getDecorators(node);
-      if (!allDecorators || allDecorators.length === 0) return node;
-
-      const decoratorsUpdated = allDecorators.map((dec) => {
-        if (!ts.isCallExpression(dec.expression)) return dec;
-        const call = dec.expression;
-        if (!ts.isIdentifier(call.expression) || call.expression.text !== "Component") return dec;
-        if (call.arguments.length !== 1) return dec;
-        const arg = call.arguments[0];
-        if (!ts.isObjectLiteralExpression(arg)) return dec;
-
-        const filteredProps = arg.properties.filter((p) => {
-          if (!ts.isPropertyAssignment(p)) return true;
-          const name = p.name;
-          const key = ts.isIdentifier(name)
-            ? name.text
-            : ts.isStringLiteralLike(name)
-              ? name.text
-              : undefined;
-          return !(key === "styles" || key === "styleUrls");
-        });
-
-        const newArg = f.updateObjectLiteralExpression(arg, filteredProps);
-        const newCall = f.updateCallExpression(call, call.expression, call.typeArguments, [newArg]);
-        return f.updateDecorator(dec, newCall);
-      });
-
-      const existingModifiers = node.modifiers ?? [];
-      const modifiersWithoutOldDecos = existingModifiers.filter((m) => !ts.isDecorator(m));
-      const newModifiers: readonly ts.ModifierLike[] = [
-        ...decoratorsUpdated,
-        ...modifiersWithoutOldDecos,
-      ];
-
-      const newNode = f.updateClassDeclaration(
-        node,
-        newModifiers,
-        node.name,
-        node.typeParameters,
-        node.heritageClauses,
-        node.members,
-      );
-
-      return f.updateClassDeclaration(
-        newNode,
-        newNode.modifiers,
-        newNode.name,
-        newNode.typeParameters,
-        newNode.heritageClauses,
-        newNode.members,
-      );
-    };
-
-    return (ctx: ts.TransformationContext) => {
-      return (sf: ts.SourceFile) => {
-        const has = this.#styleBundler!.getResultCache().get(PathUtils.norm(sf.fileName));
-        if (!has) return sf;
-
-        const realSf = upsertEnsureStyleHelper(sf);
-
-        function visitor(node: ts.Node): ts.Node {
-          if (ts.isClassDeclaration(node) && Boolean(ts.getDecorators(node)?.length)) {
-            return removeStyleProp(node);
-          }
-          return ts.visitEachChild(node, visitor, ctx);
-        }
-
-        return ts.visitNode(realSf, visitor) as ts.SourceFile;
-      };
-    };
-  }*/
-
   #convertOutputToReal(filePath: string, distPath: string, text: string) {
     let realFilePath = PathUtils.norm(filePath);
     let realText = text;