@simplysm/sd-cli 12.13.21 → 12.13.23

package/src/pkg-builders/lib/SdTsLibBuildRunner.ts

@@ -0,0 +1,47 @@
+import { PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
+import { SdBuildRunnerBase } from "../commons/SdBuildRunnerBase";
+import { SdTsLibBuilder } from "./SdTsLibBuilder";
+import { SdCliIndexFileGenerator } from "./SdCliIndexFileGenerator";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
+import { SdCliDbContextFileGenerator } from "./SdCliDbContextFileGenerator";
+
+export class SdTsLibBuildRunner extends SdBuildRunnerBase<"library"> {
+  protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdTsLibBuildRunner"]);
+
+  #builder?: SdTsLibBuilder;
+
+  protected override async _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
+    // 최초한번
+    if (!modifiedFileSet) {
+      if (!this._noEmit) {
+        // index
+        if (!this._pkgConf.noGenIndex) {
+          this._debug("GEN index.ts...");
+          new SdCliIndexFileGenerator().watch(this._pkgPath, this._pkgConf.polyfills);
+        }
+
+        // db-context
+        if (this._pkgConf.dbContext != null) {
+          this._debug(`GEN ${this._pkgConf.dbContext}.ts...`);
+          new SdCliDbContextFileGenerator().watch(this._pkgPath, this._pkgConf.dbContext);
+        }
+      }
+
+      this._debug(`BUILD 준비...`);
+      this.#builder = new SdTsLibBuilder(
+        PathUtils.norm(this._pkgPath),
+        this._watch,
+        this._dev,
+        this._emitOnly ?? false,
+        this._noEmit ?? false,
+        this._scopePathSet,
+      );
+    }
+
+    this._debug(`BUILD...`);
+    const buildResult = await this.#builder!.buildAsync(modifiedFileSet);
+
+    this._debug(`빌드 완료`);
+    return buildResult;
+  }
+}

package/src/pkg-builders/lib/{sd-ts-lib.builder.ts → SdTsLibBuilder.ts}

@@ -1,9 +1,9 @@
 import path from "path";
-import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.utils";
+import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
 import { FsUtils, HashUtils, PathUtils, TNormPath } from "@simplysm/sd-core-node";
-import { ISdBuildMessage } from "../../types/build.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 { ISdBuildResult } from "../../types/build/ISdBuildResult";
 
 export class SdTsLibBuilder {
   #tsCompiler: SdTsCompiler;
@@ -11,30 +11,27 @@ export class SdTsLibBuilder {
 
   constructor(
     private readonly _pkgPath: TNormPath,
+    watch: boolean,
     dev: boolean,
     emitOnly: boolean,
     noEmit: boolean,
-    watchScopePathSet: ScopePathSet,
+    scopePathSet: ScopePathSet,
   ) {
     this.#tsCompiler = new SdTsCompiler({
       pkgPath: this._pkgPath,
       additionalOptions: { declaration: true },
+      isWatchMode: watch,
       isDevMode: dev,
       isEmitOnly: emitOnly,
       isNoEmit: noEmit,
       globalStyleFilePath: PathUtils.norm(this._pkgPath, "src/styles.scss"),
       isForBundle: false,
-      watchScopePathSet,
+      scopePathSet,
     });
   }
 
-  async buildAsync(modifiedFileSet: Set<TNormPath>): Promise<{
-    watchFileSet: Set<TNormPath>;
-    affectedFileSet: Set<TNormPath>;
-    results: ISdBuildMessage[];
-    emitFileSet: Set<TNormPath>;
-  }> {
-    const tsCompileResult = await this.#tsCompiler.compileAsync(modifiedFileSet);
+  async buildAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
+    const tsCompileResult = await this.#tsCompiler.compileAsync(modifiedFileSet ?? new Set());
 
     const emitFileSet = new Set<TNormPath>();
     for (const emitFile of tsCompileResult.emitFileSet) {
@@ -81,9 +78,10 @@ export class SdTsLibBuilder {
     );
 
     return {
+      buildMessages: [...tsCompileResult.messages, ...styleResults],
+
       watchFileSet: tsCompileResult.watchFileSet,
       affectedFileSet: tsCompileResult.affectedFileSet,
-      results: [...tsCompileResult.messages, ...styleResults],
       emitFileSet,
     };
   }

package/src/pkg-builders/server/{sd-server.build-runner.ts → SdServerBuildRunner.ts}

@@ -1,47 +1,40 @@
 import { FsUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
 import path from "path";
 import { javascript, StringUtils } from "@simplysm/sd-core-common";
-import { SdServerBundler } from "./sd-server.bundler";
-import { INpmConfig, ITsConfig } from "../../types/common-configs.types";
-import { BuildRunnerBase, IBuildRunnerRunResult } from "../commons/build-runner.base";
+import { SdBuildRunnerBase } from "../commons/SdBuildRunnerBase";
+import { SdServerBundler } from "./SdServerBundler";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
+import { ITsConfig } from "../../types/common-config/ITsConfig";
+import { INpmConfig } from "../../types/common-config/INpmConfig";
 
-export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
-  protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliServerBuildRunner"]);
+export class SdServerBuildRunner extends SdBuildRunnerBase<"server"> {
+  protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBuild2Runner"]);
 
   #serverBundler?: SdServerBundler;
   #extModules?: { name: string; exists: boolean }[];
 
-  protected override async _runAsync(
-    dev: boolean,
-    emitOnly: boolean,
-    noEmit: boolean,
-    modifiedFileSet?: Set<TNormPath>,
-  ): Promise<IBuildRunnerRunResult> {
-    if (!dev) {
+  protected override async _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
+    // prod일때 각종 파일들 생성
+    if (!this._dev) {
       await this.#generateProductionFilesAsync();
     }
 
-    if (!noEmit) {
-      if (!modifiedFileSet) {
+    // 최초
+    if (!modifiedFileSet) {
+      if (!this._noEmit) {
         this._debug("GEN .config...");
         const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
         FsUtils.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
       }
-    }
 
-    /*const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {}).mapMany((key) =>
-      FsUtils.glob(path.resolve(this._pkgPath, "../../node_modules", key)),
-    );*/
-
-    this._debug(`BUILD 준비...`);
-    const tsConfig = FsUtils.readJson(path.resolve(this._pkgPath, "tsconfig.json")) as ITsConfig;
-    this.#extModules = this.#extModules ?? (await this.#getExternalModulesAsync());
-    this.#serverBundler =
-      this.#serverBundler ??
-      new SdServerBundler({
-        dev,
-        emitOnly,
-        noEmit,
+      this._debug(`BUILD 준비...`);
+      const tsConfig = FsUtils.readJson(path.resolve(this._pkgPath, "tsconfig.json")) as ITsConfig;
+      this.#extModules = this.#extModules ?? (await this.#getExternalModulesAsync());
+      this.#serverBundler = new SdServerBundler({
+        watch: this._watch,
+        dev: this._dev,
+        emitOnly: this._emitOnly ?? false,
+        noEmit: this._noEmit ?? false,
         pkgPath: this._pkgPath,
         entryPoints: tsConfig.files
           ? tsConfig.files.map((item) => path.resolve(this._pkgPath, item))
@@ -50,24 +43,15 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
               ...FsUtils.glob(path.resolve(this._pkgPath, "src/workers/*.ts")),
             ],
         external: this.#extModules.map((item) => item.name),
-        watchScopePathSet: this._watchScopePathSet,
+        scopePathSet: this._scopePathSet,
       });
+    }
 
     this._debug(`BUILD...`);
-    const bundleResult = await this.#serverBundler.bundleAsync(modifiedFileSet);
-
-    //-- filePaths
-    const watchFileSet = new Set(
-      Array.from(bundleResult.watchFileSet).filter((item) => this._watchScopePathSet.inScope(item)),
-    );
+    const bundleResult = await this.#serverBundler!.bundleAsync(modifiedFileSet);
 
     this._debug(`빌드 완료`);
-    return {
-      watchFileSet,
-      affectedFileSet: bundleResult.affectedFileSet,
-      buildMessages: bundleResult.results,
-      emitFileSet: bundleResult.emitFileSet,
-    };
+    return bundleResult;
   }
 
   async #generateProductionFilesAsync() {
@@ -92,13 +76,6 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
         distNpmConfig.dependencies[dep] = "*";
       }
 
-      // distNpmConfig.scripts = {};
-      // if (this._pkgConf.pm2 && !this._pkgConf.pm2.noStartScript) {
-      //   distNpmConfig.scripts["start"] = "pm2 start pm2.config.cjs";
-      //   distNpmConfig.scripts["stop"] = "pm2 stop pm2.config.cjs";
-      //   distNpmConfig.scripts["delete"] = "pm2 delete pm2.config.cjs";
-      // }
-
       distNpmConfig.volta = projNpmConf.volta;
 
       FsUtils.writeJson(path.resolve(this._pkgPath, "dist/package.json"), distNpmConfig, {

package/src/pkg-builders/server/{sd-server.bundler.ts → SdServerBundler.ts}

@@ -1,17 +1,17 @@
 import esbuild from "esbuild";
 import path from "path";
 import { FsUtils, HashUtils, PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
-import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.utils";
-import { ISdCliServerPluginResultCache } from "../../types/build-plugin.types";
-import { ISdBuildMessage } from "../../types/build.types";
-import { createSdServerPlugin } from "./sd-server.plugin-creator";
+import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
+import { createSdServerPlugin } from "./createSdServerPlugin";
 import {
   BuildOutputFile,
   BuildOutputFileType,
 } from "@angular/build/src/tools/esbuild/bundler-context";
 import { convertOutputFile } from "@angular/build/src/tools/esbuild/utils";
 import { resolveAssets } from "@angular/build/src/utils/resolve-assets";
-import { ScopePathSet } from "../commons/scope-path";
+import { ScopePathSet } from "../commons/ScopePathSet";
+import { ISdCliServerPluginResultCache } from "../../types/plugin/ISdCliServerPluginResultCache";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 
 export class SdServerBundler {
   #logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
@@ -25,22 +25,18 @@ export class SdServerBundler {
 
   constructor(
     private readonly _opt: {
+      watch: boolean;
       dev: boolean;
       emitOnly: boolean;
       noEmit: boolean;
       pkgPath: TNormPath;
       entryPoints: string[];
       external?: string[];
-      watchScopePathSet: ScopePathSet;
+      scopePathSet: ScopePathSet;
     },
   ) {}
 
-  async bundleAsync(modifiedFileSet?: Set<TNormPath>): Promise<{
-    watchFileSet: Set<TNormPath>;
-    affectedFileSet: Set<TNormPath>;
-    results: ISdBuildMessage[];
-    emitFileSet: Set<TNormPath>;
-  }> {
+  async bundleAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
     this.#modifiedFileSet.clear();
     if (modifiedFileSet) {
       this.#modifiedFileSet.adds(...modifiedFileSet);
@@ -109,25 +105,30 @@ const __dirname = __path__.dirname(__filename);`.trim(),
         plugins: [
           createSdServerPlugin({
             modifiedFileSet: this.#modifiedFileSet,
+            watch: this._opt.watch,
             dev: this._opt.dev,
             emitOnly: this._opt.emitOnly,
             noEmit: this._opt.noEmit,
             pkgPath: this._opt.pkgPath,
             result: this.#resultCache,
-            watchScopePathSet: this._opt.watchScopePathSet,
+            scopePathSet: this._opt.scopePathSet,
           }),
         ],
       });
     }
 
-    let result: esbuild.BuildResult | esbuild.BuildFailure;
-    result = await this.#context.rebuild();
+    let esbuildResult: esbuild.BuildResult | esbuild.BuildFailure;
+    esbuildResult = await this.#context.rebuild();
 
     if (this._opt.noEmit) {
       return {
+        buildMessages: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
+          esbuildResult,
+          this._opt.pkgPath,
+        ),
+
         watchFileSet: this.#resultCache.watchFileSet!,
         affectedFileSet: this.#resultCache.affectedFileSet!,
-        results: [],
         emitFileSet: new Set<TNormPath>(),
       };
     } else {
@@ -135,8 +136,9 @@ const __dirname = __path__.dirname(__filename);`.trim(),
 
       try {
         const outputFiles: BuildOutputFile[] =
-          result.outputFiles?.map((file) => convertOutputFile(file, BuildOutputFileType.Root)) ??
-          [];
+          esbuildResult.outputFiles?.map((file) =>
+            convertOutputFile(file, BuildOutputFileType.Root),
+          ) ?? [];
 
         for (const outputFile of outputFiles) {
           const distFilePath = PathUtils.norm(this._opt.pkgPath, outputFile.path);
@@ -171,7 +173,7 @@ const __dirname = __path__.dirname(__filename);`.trim(),
           }
         }
       } catch (err) {
-        result = err;
+        esbuildResult = err;
         for (const e of err.errors) {
           if (e.detail != null) {
             this.#logger.error(e.detail);
@@ -180,12 +182,13 @@ const __dirname = __path__.dirname(__filename);`.trim(),
       }
 
       return {
-        watchFileSet: this.#resultCache.watchFileSet!,
-        affectedFileSet: this.#resultCache.affectedFileSet!,
-        results: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
-          result,
+        buildMessages: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
+          esbuildResult,
           this._opt.pkgPath,
         ),
+
+        watchFileSet: this.#resultCache.watchFileSet!,
+        affectedFileSet: this.#resultCache.affectedFileSet!,
         emitFileSet: emitFileSet,
       };
     }

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[];
 }