@simplysm/sd-cli 12.11.6 → 12.11.8

package/src/pkg-builders/lib/sd-ts-lib.builder.ts

@@ -6,14 +6,14 @@ import { SdTsCompiler } from "../../ts-compiler/sd-ts-compiler";
 import { ScopePathSet } from "../commons/scope-path";
 
 export class SdTsLibBuilder {
-  private _tsCompiler: SdTsCompiler;
+  #tsCompiler: SdTsCompiler;
 
   constructor(
-    private _pkgPath: TNormPath,
+    private readonly _pkgPath: TNormPath,
     dev: boolean,
     watchScopePathSet: ScopePathSet,
   ) {
-    this._tsCompiler = new SdTsCompiler({
+    this.#tsCompiler = new SdTsCompiler({
       pkgPath: this._pkgPath,
       additionalOptions: { declaration: true },
       isDevMode: dev,
@@ -29,7 +29,7 @@ export class SdTsLibBuilder {
     results: ISdBuildMessage[];
     emitFileSet: Set<TNormPath>;
   }> {
-    const tsCompileResult = await this._tsCompiler.compileAsync(modifiedFileSet);
+    const tsCompileResult = await this.#tsCompiler.compileAsync(modifiedFileSet);
 
     const emitFileSet = new Set<TNormPath>();
     for (const emitFile of tsCompileResult.emitFileSet) {

package/src/pkg-builders/sd-multi.build-runner.ts

@@ -8,12 +8,12 @@ import { INpmConfig } from "../types/common-configs.types";
 import { ISdBuildRunnerWorkerRequest } from "../types/build-runner.types";
 
 export class SdMultiBuildRunner extends EventEmitter {
-  private _logger = SdLogger.get(["simplysm", "sd-cli", "SdMultiBuildRunner"]);
+  #logger = SdLogger.get(["simplysm", "sd-cli", "SdMultiBuildRunner"]);
 
-  private _busyCount = 0;
+  #busyCount = 0;
 
-  private _resultCache = new Map<TNormPath, ISdBuildMessage[]>();
-  private _serverInfoMap = new Map<
+  #resultCache = new Map<TNormPath, ISdBuildMessage[]>();
+  #serverInfoMap = new Map<
     string,
     {
       pkgInfo?: { path: string; conf: ISdServerPackageConfig } | { port: number }; // persist
@@ -46,12 +46,12 @@ export class SdMultiBuildRunner extends EventEmitter {
     const worker = new SdWorker<TSdBuildRunnerWorkerType>(import.meta.resolve(
       "../workers/build-runner.worker"))
       .on("change", () => {
-        if (this._busyCount === 0) {
+        if (this.#busyCount === 0) {
           this.emit("change");
         }
-        this._busyCount++;
+        this.#busyCount++;
       })
-      .on("complete", (result) => this._onComplete(req, result));
+      .on("complete", (result) => this.#onComplete(req, result));
 
     return await worker.run("run", [req]);
     /*const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
@@ -78,16 +78,16 @@ export class SdMultiBuildRunner extends EventEmitter {
     }*/
   }
 
-  private _onComplete(req: ISdBuildRunnerWorkerRequest, result: ISdBuildRunnerResult) {
-    this._resultCache.delete(req.pkgPath);
+  #onComplete(req: ISdBuildRunnerWorkerRequest, result: ISdBuildRunnerResult) {
+    this.#resultCache.delete(req.pkgPath);
     for (const affectedFilePath of result.affectedFilePathSet) {
       if (PathUtils.isChildPath(affectedFilePath, req.pkgPath)) {
-        this._resultCache.delete(affectedFilePath);
+        this.#resultCache.delete(affectedFilePath);
       }
     }
 
     for (const buildMessage of result.buildMessages) {
-      const cacheItem = this._resultCache.getOrCreate(buildMessage.filePath ?? req.pkgPath, []);
+      const cacheItem = this.#resultCache.getOrCreate(buildMessage.filePath ?? req.pkgPath, []);
       cacheItem.push(buildMessage);
     }
 
@@ -95,7 +95,7 @@ export class SdMultiBuildRunner extends EventEmitter {
 
     if (pkgConf.type === "server") {
       const pkgName = path.basename(req.pkgPath);
-      const serverInfo = this._serverInfoMap.getOrCreate(pkgName, {
+      const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
         hasChanges: true,
         clientChangedFileSet: new Set(),
         clients: {},
@@ -113,7 +113,7 @@ export class SdMultiBuildRunner extends EventEmitter {
       const pkgName = path.basename(req.pkgPath);
 
       if (pkgConf.server !== undefined) {
-        const serverInfo = this._serverInfoMap.getOrCreate(
+        const serverInfo = this.#serverInfoMap.getOrCreate(
           typeof pkgConf.server === "string" ? pkgConf.server : pkgConf.server.port.toString(),
           {
             hasChanges: true,
@@ -134,7 +134,7 @@ export class SdMultiBuildRunner extends EventEmitter {
         serverInfo.clientChangedFileSet.adds(...result.emitFileSet);
       }
       else {
-        const serverInfo = this._serverInfoMap.getOrCreate(pkgName, {
+        const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
           hasChanges: true,
           clientChangedFileSet: new Set(),
           clients: {},
@@ -145,14 +145,14 @@ export class SdMultiBuildRunner extends EventEmitter {
     }
 
     setTimeout(async () => {
-      this._busyCount--;
-      if (this._busyCount === 0) {
-        for (const serverPkgNameOrPort of this._serverInfoMap.keys()) {
-          const serverInfo = this._serverInfoMap.get(serverPkgNameOrPort)!;
+      this.#busyCount--;
+      if (this.#busyCount === 0) {
+        for (const serverPkgNameOrPort of this.#serverInfoMap.keys()) {
+          const serverInfo = this.#serverInfoMap.get(serverPkgNameOrPort)!;
           if (serverInfo.pkgInfo && serverInfo.hasChanges) {
-            this._logger.debug("서버 재시작...");
+            this.#logger.debug("서버 재시작...");
             try {
-              const restartServerResult = await this._restartServerAsync(
+              const restartServerResult = await this.#restartServerAsync(
                 serverInfo.pkgInfo,
                 serverInfo.worker,
               );
@@ -161,12 +161,12 @@ export class SdMultiBuildRunner extends EventEmitter {
               serverInfo.hasChanges = false;
             }
             catch (err) {
-              this._logger.error(err);
+              this.#logger.error(err);
             }
           }
 
           if (serverInfo.worker) {
-            this._logger.debug("클라이언트 설정...");
+            this.#logger.debug("클라이언트 설정...");
             await serverInfo.worker.run("setPathProxy", [
               {
                 ...Object.keys(serverInfo.clients).toObject(
@@ -178,14 +178,14 @@ export class SdMultiBuildRunner extends EventEmitter {
             ]);
 
             if (serverInfo.clientChangedFileSet.size > 0) {
-              this._logger.debug("클라이언트 새로고침...");
+              this.#logger.debug("클라이언트 새로고침...");
               await serverInfo.worker.run("broadcastReload", [serverInfo.clientChangedFileSet]);
             }
           }
         }
 
         const clientPaths: string[] = [];
-        for (const serverInfo of this._serverInfoMap.values()) {
+        for (const serverInfo of this.#serverInfoMap.values()) {
           if (Object.keys(serverInfo.clients).length > 0) {
             for (const clientPkgName of Object.keys(serverInfo.clients)) {
               for (const buildType of serverInfo.clients[clientPkgName].buildTypes) {
@@ -203,16 +203,16 @@ export class SdMultiBuildRunner extends EventEmitter {
           }
         }
         if (clientPaths.length > 0) {
-          this._logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
+          this.#logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
         }
 
-        const messages = Array.from(this._resultCache.values()).mapMany();
+        const messages = Array.from(this.#resultCache.values()).mapMany();
         this.emit("complete", messages);
       }
     }, 300);
   }
 
-  private async _restartServerAsync(
+  async #restartServerAsync(
     pkgInfo: { path: string; conf: ISdServerPackageConfig } | { port: number },
     prevWorker?: SdWorker<TServerWorkerType>,
   ): Promise<{

package/src/pkg-builders/server/sd-server.build-runner.ts

@@ -8,15 +8,15 @@ import { BuildRunnerBase, IBuildRunnerRunResult } from "../commons/build-runner.
 export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
   protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliServerBuildRunner"]);
 
-  private _serverBundler?: SdServerBundler;
-  private _extModules?: { name: string; exists: boolean }[];
+  #serverBundler?: SdServerBundler;
+  #extModules?: { name: string; exists: boolean }[];
 
   protected override async _runAsync(
     dev: boolean,
     modifiedFileSet?: Set<TNormPath>,
   ): Promise<IBuildRunnerRunResult> {
     if (!dev) {
-      await this._generateProductionFilesAsync();
+      await this.#generateProductionFilesAsync();
     }
 
     if (!modifiedFileSet) {
@@ -31,9 +31,9 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
 
     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 ??
+    this.#extModules = this.#extModules ?? (await this.#getExternalModulesAsync());
+    this.#serverBundler =
+      this.#serverBundler ??
       new SdServerBundler({
         dev,
         pkgPath: this._pkgPath,
@@ -43,12 +43,12 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
               path.resolve(this._pkgPath, "src/main.ts"),
               ...FsUtils.glob(path.resolve(this._pkgPath, "src/workers/*.ts")),
             ],
-        external: this._extModules.map((item) => item.name),
+        external: this.#extModules.map((item) => item.name),
         watchScopePathSet: this._watchScopePathSet,
       });
 
     this._debug(`BUILD...`);
-    const bundleResult = await this._serverBundler.bundleAsync(modifiedFileSet);
+    const bundleResult = await this.#serverBundler.bundleAsync(modifiedFileSet);
 
     //-- filePaths
     const watchFileSet = new Set(
@@ -64,7 +64,7 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
     };
   }
 
-  private async _generateProductionFilesAsync() {
+  async #generateProductionFilesAsync() {
     const npmConf = FsUtils.readJson(path.resolve(this._pkgPath, "package.json")) as INpmConfig;
 
     this._debug("GEN package.json...");
@@ -72,7 +72,7 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
       const projNpmConf = FsUtils.readJson(
         path.resolve(process.cwd(), "package.json"),
       ) as INpmConfig;
-      const extModules = await this._getExternalModulesAsync();
+      const extModules = await this.#getExternalModulesAsync();
 
       const deps = extModules.filter((item) => item.exists).map((item) => item.name);
 
@@ -220,7 +220,7 @@ Options = UnsafeLegacyRenegotiation`.trim(),
     }
   }
 
-  private async _getExternalModulesAsync(): Promise<
+  async #getExternalModulesAsync(): Promise<
     {
       name: string;
       exists: boolean;

package/src/pkg-builders/server/sd-server.bundler.ts

@@ -14,16 +14,16 @@ import { resolveAssets } from "@angular/build/src/utils/resolve-assets";
 import { ScopePathSet } from "../commons/scope-path";
 
 export class SdServerBundler {
-  private _logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
+  #logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
 
-  private _context?: esbuild.BuildContext;
+  #context?: esbuild.BuildContext;
 
-  private _modifiedFileSet = new Set<TNormPath>();
-  private _resultCache: ISdCliServerPluginResultCache = {};
+  #modifiedFileSet = new Set<TNormPath>();
+  #resultCache: ISdCliServerPluginResultCache = {};
 
-  private _outputHashCache = new Map<TNormPath, string>();
+  #outputHashCache = new Map<TNormPath, string>();
 
-  constructor(private _opt: {
+  constructor(private readonly _opt: {
     dev: boolean;
     pkgPath: TNormPath;
     entryPoints: string[];
@@ -38,13 +38,13 @@ export class SdServerBundler {
     results: ISdBuildMessage[];
     emitFileSet: Set<TNormPath>;
   }> {
-    this._modifiedFileSet.clear();
+    this.#modifiedFileSet.clear();
     if (modifiedFileSet) {
-      this._modifiedFileSet.adds(...modifiedFileSet);
+      this.#modifiedFileSet.adds(...modifiedFileSet);
     }
 
-    if (!this._context) {
-      this._context = await esbuild.context({
+    if (!this.#context) {
+      this.#context = await esbuild.context({
         entryPoints: this._opt.entryPoints,
         keepNames: true,
         bundle: true,
@@ -105,10 +105,10 @@ const __dirname = __path__.dirname(__filename);`.trim(),
         },
         plugins: [
           createSdServerPlugin({
-            modifiedFileSet: this._modifiedFileSet,
+            modifiedFileSet: this.#modifiedFileSet,
             dev: this._opt.dev,
             pkgPath: this._opt.pkgPath,
-            result: this._resultCache,
+            result: this.#resultCache,
             watchScopePathSet: this._opt.watchScopePathSet,
           }),
         ],
@@ -118,18 +118,18 @@ const __dirname = __path__.dirname(__filename);`.trim(),
     const emitFileSet = new Set<TNormPath>();
     let result: esbuild.BuildResult | esbuild.BuildFailure;
     try {
-      result = await this._context.rebuild();
+      result = await this.#context.rebuild();
 
       const outputFiles: BuildOutputFile[] =
         result.outputFiles?.map((file) => convertOutputFile(file, BuildOutputFileType.Root)) ?? [];
 
       for (const outputFile of outputFiles) {
         const distFilePath = PathUtils.norm(this._opt.pkgPath, outputFile.path);
-        const prevHash = this._outputHashCache.get(distFilePath);
+        const prevHash = this.#outputHashCache.get(distFilePath);
         const currHash = HashUtils.get(Buffer.from(outputFile.contents));
         if (prevHash !== currHash) {
           FsUtils.writeFile(distFilePath, outputFile.contents);
-          this._outputHashCache.set(distFilePath, currHash);
+          this.#outputHashCache.set(distFilePath, currHash);
           emitFileSet.add(distFilePath);
         }
       }
@@ -144,14 +144,14 @@ const __dirname = __path__.dirname(__filename);`.trim(),
       );
 
       for (const assetFile of assetFiles) {
-        const prevHash = this._outputHashCache.get(PathUtils.norm(assetFile.source));
+        const prevHash = this.#outputHashCache.get(PathUtils.norm(assetFile.source));
         const currHash = FsUtils.hash(assetFile.source);
         if (prevHash !== currHash) {
           FsUtils.copy(
             assetFile.source,
             path.resolve(this._opt.pkgPath, "dist", assetFile.destination),
           );
-          this._outputHashCache.set(PathUtils.norm(assetFile.source), currHash);
+          this.#outputHashCache.set(PathUtils.norm(assetFile.source), currHash);
           emitFileSet.add(PathUtils.norm(assetFile.destination));
         }
       }
@@ -160,14 +160,14 @@ const __dirname = __path__.dirname(__filename);`.trim(),
       result = err;
       for (const e of err.errors) {
         if (e.detail != null) {
-          this._logger.error(e.detail);
+          this.#logger.error(e.detail);
         }
       }
     }
 
     return {
-      watchFileSet: this._resultCache.watchFileSet!,
-      affectedFileSet: this._resultCache.affectedFileSet!,
+      watchFileSet: this.#resultCache.watchFileSet!,
+      affectedFileSet: this.#resultCache.affectedFileSet!,
       results: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
         result,
         this._opt.pkgPath,

package/src/sd-cli-entry.ts

@@ -12,9 +12,8 @@ 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 convertEcmaPrivateToTsPrivate from "./fix/convert-ecma-private-to-ts-private";
 import {
-  convertExtendsSdModalBaseToInterface
+  convertExtendsSdModalBaseToInterface,
 } from "./fix/convert-extends-sd-modal-base-to-interface";
 import convertModalShowParams from "./fix/convert-modal-show-params";
 import convertSdAngularSymbolNames from "./fix/convert-sd-angular-symbol-names";
@@ -22,10 +21,9 @@ import convertSdSheetBindingsInInlineTemplate
   from "./fix/convert-sd-sheet-bindings-inInline-template";
 import convertSetupCumulateSelectedKeysToObjectParam
   from "./fix/convert-setup-cumulate-selected-keys-to-object-param";
-import prefixUnderscoreForAccessModifiers from "./fix/prefix-underscore-for-access-modifiers";
 import removeSdAngularSymbolNames from "./fix/remove-sd-angular-symbol-names";
 import {
-  convertExtendsSdPrintTemplateBaseToInterface
+  convertExtendsSdPrintTemplateBaseToInterface,
 } from "./fix/convert-extends-sd-print-template-base-to-interface";
 import convertPrintParams from "./fix/convert-print-params";
 import { convertToUsePermsSignal } from "./fix/convert-to-use-perms-signal";
@@ -33,6 +31,7 @@ import { convertGetMenusToUsableMenus } from "./fix/convert-get-menus-to-usable-
 import { removeUnusedInjects } from "./fix/remove-unused-injects";
 import { removeUnusedImports } from "./fix/remove-unused-imports";
 import { convertFlatPagesToUsableFlatMenus } from "./fix/convert-flat-pages-to-flat-menus";
+import convertPrivateToHash from "./fix/convert-private-to-hash";
 
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 0;
@@ -264,8 +263,19 @@ await yargs(hideBin(process.argv))
   .command(
     "fix",
     "가능한 내용 자동 수정",
-    (cmd) => cmd.version(false).hide("help").hide("debug"),
-    () => {
+    (cmd) =>
+      cmd
+        .version(false)
+        .hide("help")
+        .hide("debug")
+        .options({
+          library: {
+            type: "boolean",
+            describe: "simplysm 라이브러리 픽스",
+            default: false,
+          },
+        }),
+    (argv) => {
       // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
       /*if (FsUtils.exists(path.resolve(process.cwd(), ".git"))) {
         const gitStatusResult = await SdProcess.spawnAsync("git status");
@@ -274,8 +284,9 @@ await yargs(hideBin(process.argv))
         }
       }*/
 
-      convertEcmaPrivateToTsPrivate();
-      prefixUnderscoreForAccessModifiers();
+      convertPrivateToHash();
+      if (argv.library) return;
+
       convertSdSheetBindingsInInlineTemplate();
       convertSetupCumulateSelectedKeysToObjectParam();
       convertExtendsSdModalBaseToInterface();

package/src/ts-compiler/sd-dependency-cache.ts

@@ -1,12 +1,12 @@
 import { TNormPath } from "@simplysm/sd-core-node";
 
 export class SdDependencyCache {
-  private _exportCache = new Map<
+  #exportCache = new Map<
     /* fileNPath: */ TNormPath,
     /* exportSymbolSet: */ Set<string>
   >();
 
-  private _importCache = new Map<
+  #importCache = new Map<
     /* fileNPath: */ TNormPath,
     Map<
       /* targetNPath: */ TNormPath,
@@ -14,7 +14,7 @@ export class SdDependencyCache {
     >
   >();
 
-  private _reexportCache = new Map<
+  #reexportCache = new Map<
     /* fileNPath: */ TNormPath,
     Map<
       /* targetNPath: */ TNormPath,
@@ -25,7 +25,7 @@ export class SdDependencyCache {
     >
   >();
 
-  private _revDepCache = new Map<
+  #revDepCache = new Map<
     /* targetNPath: */ TNormPath,
     Map<
       /* fileNPath: */ TNormPath,
@@ -33,27 +33,27 @@ export class SdDependencyCache {
     >
   >();
 
-  private _collectedCache = new Set<TNormPath>();
+  #collectedCache = new Set<TNormPath>();
 
   getFiles(): Set<TNormPath> {
     return new Set<TNormPath>([
-      ...this._collectedCache.keys(),
-      ...this._revDepCache.keys(),
+      ...this.#collectedCache.keys(),
+      ...this.#revDepCache.keys(),
     ]);
   }
 
   addCollected(fileNPath: TNormPath) {
-    this._collectedCache.add(fileNPath);
+    this.#collectedCache.add(fileNPath);
   }
 
   hasCollected(fileNPath: TNormPath) {
-    return this._collectedCache.has(fileNPath);
+    return this.#collectedCache.has(fileNPath);
   }
 
   // export const ...
   // export function/class/interface A ...
   addExport(fileNPath: TNormPath, exportSymbol: string) {
-    const exportSymbolSet = this._exportCache.getOrCreate(fileNPath, new Set());
+    const exportSymbolSet = this.#exportCache.getOrCreate(fileNPath, new Set());
     exportSymbolSet.add(exportSymbol);
   }
 
@@ -62,10 +62,10 @@ export class SdDependencyCache {
   // import(...)
   // require(...)
   addImport(fileNPath: TNormPath, targetNPath: TNormPath, targetSymbol: string | 0) {
-    const importTargetMap = this._importCache.getOrCreate(fileNPath, new Map());
+    const importTargetMap = this.#importCache.getOrCreate(fileNPath, new Map());
     if (targetSymbol === 0) {
       importTargetMap.set(targetNPath, 0);
-      this._addRevDep(targetNPath, fileNPath, 0);
+      this.#addRevDep(targetNPath, fileNPath, 0);
     }
     else {
       const importTargetSymbolSet = importTargetMap.getOrCreate(targetNPath, new Set());
@@ -74,7 +74,7 @@ export class SdDependencyCache {
       }
 
       importTargetSymbolSet.add(targetSymbol);
-      this._addRevDep(targetNPath, fileNPath, targetSymbol);
+      this.#addRevDep(targetNPath, fileNPath, targetSymbol);
     }
   }
 
@@ -89,10 +89,10 @@ export class SdDependencyCache {
     targetNPath: TNormPath,
     targetSymbolInfo: { importSymbol: string, exportSymbol: string } | 0,
   ) {
-    const reexportTargetMap = this._reexportCache.getOrCreate(fileNPath, new Map());
+    const reexportTargetMap = this.#reexportCache.getOrCreate(fileNPath, new Map());
     if (targetSymbolInfo === 0) {
       reexportTargetMap.set(targetNPath, 0);
-      this._addRevDep(targetNPath, fileNPath, 0);
+      this.#addRevDep(targetNPath, fileNPath, 0);
     }
     else {
       const reexportTargetSymbolInfos = reexportTargetMap.getOrCreate(targetNPath, []);
@@ -107,13 +107,13 @@ export class SdDependencyCache {
         )
       ) {
         reexportTargetSymbolInfos.push(targetSymbolInfo);
-        this._addRevDep(targetNPath, fileNPath, targetSymbolInfo.importSymbol);
+        this.#addRevDep(targetNPath, fileNPath, targetSymbolInfo.importSymbol);
       }
     }
   }
 
-  private _addRevDep(targetNPath: TNormPath, fileNPath: TNormPath, exportSymbol: string | 0) {
-    const revDepInfoMap = this._revDepCache.getOrCreate(targetNPath, new Map());
+  #addRevDep(targetNPath: TNormPath, fileNPath: TNormPath, exportSymbol: string | 0) {
+    const revDepInfoMap = this.#revDepCache.getOrCreate(targetNPath, new Map());
     if (exportSymbol === 0) {
       revDepInfoMap.set(fileNPath, exportSymbol);
     }
@@ -143,7 +143,7 @@ export class SdDependencyCache {
     };
 
     for (const modifiedNPath of modifiedNPathSet) {
-      const exportSymbols = this._getExportSymbols(modifiedNPath);
+      const exportSymbols = this.#getExportSymbols(modifiedNPath);
       if (exportSymbols.size === 0) {
         enqueue(modifiedNPath, undefined);
       }
@@ -161,7 +161,7 @@ export class SdDependencyCache {
       if (visited.has(key)) continue;
       visited.add(key);*/
 
-      const revDepInfoMap = this._revDepCache.get(curr.fileNPath);
+      const revDepInfoMap = this.#revDepCache.get(curr.fileNPath);
       if (!revDepInfoMap) continue;
 
       for (const [revDepFileNPath, revDepInfo] of revDepInfoMap) {
@@ -173,7 +173,7 @@ export class SdDependencyCache {
             result.add(revDepFileNPath);
 
             // 하위 Deps를 queue에 넣기전 export명칭 변환 (이름을 변경한 reexport일 경우 필요)
-            const exportSymbol = this._convertImportSymbolToExportSymbol(
+            const exportSymbol = this.#convertImportSymbolToExportSymbol(
               revDepFileNPath,
               curr.fileNPath,
               curr.exportSymbol, // revdep의 importSymbol
@@ -194,31 +194,31 @@ export class SdDependencyCache {
     const affectedFiles = this.getAffectedFileSet(fileNPathSet);
 
     for (const fileNPath of affectedFiles) {
-      this._exportCache.delete(fileNPath);
-      this._importCache.delete(fileNPath);
-      this._reexportCache.delete(fileNPath);
-      this._collectedCache.delete(fileNPath);
-      this._revDepCache.delete(fileNPath); // ← 자기 자신이 key인 경우도 정리
+      this.#exportCache.delete(fileNPath);
+      this.#importCache.delete(fileNPath);
+      this.#reexportCache.delete(fileNPath);
+      this.#collectedCache.delete(fileNPath);
+      this.#revDepCache.delete(fileNPath); // ← 자기 자신이 key인 경우도 정리
     }
 
     // _revDepCache는 역방향으로 순회
-    for (const [targetNPath, infoMap] of this._revDepCache) {
+    for (const [targetNPath, infoMap] of this.#revDepCache) {
       for (const fileNPath of affectedFiles) {
         infoMap.delete(fileNPath);
       }
 
       if (infoMap.size === 0) {
-        this._revDepCache.delete(targetNPath);
+        this.#revDepCache.delete(targetNPath);
       }
     }
   }
 
-  private _convertImportSymbolToExportSymbol(
+  #convertImportSymbolToExportSymbol(
     fileNPath: TNormPath,
     targetNPath: TNormPath,
     importSymbol: string,
   ) {
-    const symbolInfos = this._reexportCache.get(fileNPath)?.get(targetNPath);
+    const symbolInfos = this.#reexportCache.get(fileNPath)?.get(targetNPath);
     if (symbolInfos != null && symbolInfos !== 0 && symbolInfos.length > 0) {
       const symbolInfo = symbolInfos.single(item => item.importSymbol === importSymbol);
       if (symbolInfo) {
@@ -229,19 +229,19 @@ export class SdDependencyCache {
     return importSymbol;
   }
 
-  private _getExportSymbols(fileNPath: TNormPath): Set<string> {
+  #getExportSymbols(fileNPath: TNormPath): Set<string> {
     const result = new Set<string>();
 
-    const set = this._exportCache.get(fileNPath);
+    const set = this.#exportCache.get(fileNPath);
     if (set) {
       result.adds(...set);
     }
 
-    const map = this._reexportCache.get(fileNPath);
+    const map = this.#reexportCache.get(fileNPath);
     if (map) {
       for (const [key, val] of map) {
         if (val === 0) {
-          result.adds(...this._getExportSymbols(key));
+          result.adds(...this.#getExportSymbols(key));
         }
         else {
           result.adds(...val.map(item => item.exportSymbol));
@@ -277,7 +277,7 @@ export class SdDependencyCache {
       };
       nodeMap.set(key, node);
 
-      const revDepInfoMap = this._revDepCache.get(fileNPath);
+      const revDepInfoMap = this.#revDepCache.get(fileNPath);
       if (!revDepInfoMap) return node;
 
       for (const [revDepFileNPath, revDepInfo] of revDepInfoMap.entries()) {
@@ -286,7 +286,7 @@ export class SdDependencyCache {
         if (!hasImportSymbol) continue;
 
         const nextExportSymbol = exportSymbol != null
-          ? this._convertImportSymbolToExportSymbol(
+          ? this.#convertImportSymbolToExportSymbol(
             revDepFileNPath,
             fileNPath,
             exportSymbol
@@ -306,7 +306,7 @@ export class SdDependencyCache {
     const result: ISdAffectedFileTreeNode[] = [];
 
     for (const modifiedNPath of modifiedNPathSet) {
-      const exportSymbols = this._getExportSymbols(modifiedNPath);
+      const exportSymbols = this.#getExportSymbols(modifiedNPath);
       if (exportSymbols.size === 0) {
         const rootNode = buildTree(modifiedNPath, undefined);
         result.push(rootNode);