@simplysm/sd-cli 12.15.39 → 12.15.41

package/src/pkg-builders/client/SdNgBundlerContext.ts

@@ -15,9 +15,9 @@ interface InitialFileRecord {
 }
 
 export class SdNgBundlerContext {
-  #logger = SdLogger.get(["simplysm", "sd-cli", "SdNgBundlerContext"]);
+  private readonly _logger = SdLogger.get(["simplysm", "sd-cli", "SdNgBundlerContext"]);
 
-  #context?: esbuild.BuildContext;
+  private _context?: esbuild.BuildContext;
 
   constructor(
     private readonly _pkgPath: string,
@@ -28,14 +28,14 @@ export class SdNgBundlerContext {
   async bundleAsync() {
     let esbuildResult: esbuild.BuildResult;
 
-    this.#debug(`Building...`);
+    this._debug(`Building...`);
     if (this._watch) {
-      if (this.#context == null) {
-        this.#context = await esbuild.context(this._esbuildOptions);
+      if (this._context == null) {
+        this._context = await esbuild.context(this._esbuildOptions);
       }
 
       try {
-        esbuildResult = await this.#context.rebuild();
+        esbuildResult = await this._context.rebuild();
       } catch (err) {
         if ("warnings" in err || "errors" in err) {
           esbuildResult = err;
@@ -54,9 +54,9 @@ export class SdNgBundlerContext {
         }
       }
     }
-    this.#debug(`Build completed`);
+    this._debug(`Build completed`);
 
-    this.#debug(`Converting results...`);
+    this._debug(`Converting results...`);
     const results = SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
       esbuildResult,
       this._pkgPath,
@@ -127,8 +127,8 @@ export class SdNgBundlerContext {
     };
   }
 
-  #debug(...msg: any[]): void {
-    this.#logger.debug(
+  private _debug(...msg: any[]): void {
+    this._logger.debug(
       `[${path.basename(this._pkgPath)}] (${Object.keys(
         this._esbuildOptions.entryPoints as Record<string, any>,
       ).join(", ")})`,

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

@@ -11,7 +11,7 @@ export class SdCliIndexFileGenerator {
       : undefined;
 
     const watcher = await SdFsWatcher.watchAsync([path.resolve(pkgPath, "src")], {
-      ignored: await this.#getExcludesAsync(pkgPath, excludes),
+      ignored: await this._getExcludesAsync(pkgPath, excludes),
     });
     watcher.onChange({ delay: 50 }, async (changeInfos) => {
       if (changeInfos.some((item) => ["add", "addDir", "unlink", "unlinkDir"].includes(item.event)))
@@ -34,7 +34,7 @@ export class SdCliIndexFileGenerator {
     }
 
     // 내부 파일들 import
-    const filePaths = await this.#getFilePathsAsync(pkgPath, excludes);
+    const filePaths = await this._getFilePathsAsync(pkgPath, excludes);
     for (const filePath of filePaths.orderBy()) {
       const requirePath = PathUtils.posix(path.relative(path.dirname(indexFilePath), filePath))
         .replace(/\.tsx?$/, "")
@@ -59,7 +59,7 @@ export class SdCliIndexFileGenerator {
     }
   }
 
-  async #getFilePathsAsync(pkgPath: string, excludes?: string[]) {
+  private async _getFilePathsAsync(pkgPath: string, excludes?: string[]) {
     /*const indexFilePath = path.resolve(pkgPath, "src/index.ts");
 
     const tsconfig = await FsUtils.readJsonAsync(path.resolve(pkgPath, "tsconfig.json"));
@@ -68,11 +68,11 @@ export class SdCliIndexFileGenerator {
 
     return await FsUtils.globAsync(path.resolve(pkgPath, "src/**/*{.ts,.tsx}"), {
       nodir: true,
-      ignore: await this.#getExcludesAsync(pkgPath, excludes),
+      ignore: await this._getExcludesAsync(pkgPath, excludes),
     });
   }
 
-  async #getExcludesAsync(pkgPath: string, excludes?: string[]) {
+  private async _getExcludesAsync(pkgPath: string, excludes?: string[]) {
     const indexFilePath = path.resolve(pkgPath, "src/index.ts");
 
     const tsconfig = await FsUtils.readJsonAsync(path.resolve(pkgPath, "tsconfig.json"));

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

@@ -29,7 +29,7 @@ export class SdJsLibBuildRunner extends SdBuildRunnerBase<"library"> {
 
     this._debug("LINT...");
 
-    const lintResults = await this.#lintAsync(filePathSet);
+    const lintResults = await this._lintAsync(filePathSet);
     const messages = SdCliConvertMessageUtils.convertToBuildMessagesFromEslint(lintResults);
 
     this._debug(`LINT 완료`);
@@ -43,7 +43,7 @@ export class SdJsLibBuildRunner extends SdBuildRunnerBase<"library"> {
     };
   }
 
-  async #lintAsync(fileSet: Set<string>) {
+  private async _lintAsync(fileSet: Set<string>) {
     const lintFilePaths = Array.from(fileSet)
       .filter((item) => PathUtils.isChildPath(item, path.resolve(this._opt.pkgPath, "src")))
       .filter((item) => item.endsWith(".js"))

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

@@ -8,7 +8,7 @@ import { SdCliDbContextFileGenerator } from "./SdCliDbContextFileGenerator";
 export class SdTsLibBuildRunner extends SdBuildRunnerBase<"library"> {
   protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdTsLibBuildRunner"]);
 
-  #builder?: SdTsLibBuilder;
+  private _builder?: SdTsLibBuilder;
 
   protected override async _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
     // 최초한번
@@ -35,11 +35,11 @@ export class SdTsLibBuildRunner extends SdBuildRunnerBase<"library"> {
       }
 
       this._debug(`BUILD 준비...`);
-      this.#builder = new SdTsLibBuilder(this._opt);
+      this._builder = new SdTsLibBuilder(this._opt);
     }
 
     this._debug(`BUILD...`);
-    const buildResult = await this.#builder!.buildAsync(modifiedFileSet);
+    const buildResult = await this._builder!.buildAsync(modifiedFileSet);
 
     this._debug(`빌드 완료`);
     return buildResult;

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

@@ -6,15 +6,15 @@ import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 import { ISdTsCompilerOptions } from "../../types/build/ISdTsCompilerOptions";
 
 export class SdTsLibBuilder {
-  #tsCompiler: SdTsCompiler;
-  #outputHashCache = new Map<TNormPath, string>();
+  private readonly _tsCompiler: SdTsCompiler;
+  private readonly _outputHashCache = new Map<TNormPath, string>();
 
   constructor(private readonly _opt: ISdTsCompilerOptions) {
-    this.#tsCompiler = new SdTsCompiler(_opt, false);
+    this._tsCompiler = new SdTsCompiler(_opt, false);
   }
 
   async buildAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
-    const tsCompileResult = await this.#tsCompiler.compileAsync(modifiedFileSet ?? new Set());
+    const tsCompileResult = await this._tsCompiler.compileAsync(modifiedFileSet ?? new Set());
 
     const emitFileSet = new Set<TNormPath>();
     for (const emitFile of tsCompileResult.emitFileSet) {
@@ -23,11 +23,11 @@ export class SdTsLibBuilder {
         for (const emitFileInfo of emitFileInfos) {
           if (emitFileInfo.outAbsPath != null) {
             const emitFilePath = PathUtils.norm(emitFileInfo.outAbsPath);
-            const prevHash = this.#outputHashCache.get(emitFilePath);
+            const prevHash = this._outputHashCache.get(emitFilePath);
             const currHash = HashUtils.get(Buffer.from(emitFileInfo.text));
             if (prevHash !== currHash) {
               FsUtils.writeFile(emitFilePath, emitFileInfo.text);
-              this.#outputHashCache.set(emitFilePath, currHash);
+              this._outputHashCache.set(emitFilePath, currHash);
               emitFileSet.add(emitFilePath);
             }
           }
@@ -44,11 +44,11 @@ export class SdTsLibBuilder {
             path.relative(this._opt.pkgPath, outputFile.path),
           );
           if (PathUtils.isChildPath(distPath, path.resolve(this._opt.pkgPath, "dist"))) {
-            const prevHash = this.#outputHashCache.get(distPath);
+            const prevHash = this._outputHashCache.get(distPath);
             const currHash = HashUtils.get(Buffer.from(outputFile.text));
             if (prevHash !== currHash) {
               FsUtils.writeFile(distPath, outputFile.text);
-              this.#outputHashCache.set(distPath, currHash);
+              this._outputHashCache.set(distPath, currHash);
               emitFileSet.add(distPath);
             }
           }

package/src/pkg-builders/server/SdServerBuildRunner.ts

@@ -9,15 +9,15 @@ import { INpmConfig } from "../../types/common-config/INpmConfig";
 export class SdServerBuildRunner extends SdBuildRunnerBase<"server"> {
   protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBuildRunner"]);
 
-  #serverBundler?: SdServerBundler;
+  private _serverBundler?: SdServerBundler;
 
   protected override async _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
     // 최초
     if (!modifiedFileSet) {
-      const externalModules = this.#getExternalModules();
+      const externalModules = this._getExternalModules();
 
       if (!this._opt.watch?.dev) {
-        this.#generateProductionFiles(
+        this._generateProductionFiles(
           externalModules.filter((item) => item.exists).map((item) => item.name),
         );
       }
@@ -29,19 +29,19 @@ export class SdServerBuildRunner extends SdBuildRunnerBase<"server"> {
       }
 
       this._debug(`BUILD 준비...`);
-      this.#serverBundler = new SdServerBundler(this._opt, {
+      this._serverBundler = new SdServerBundler(this._opt, {
         external: externalModules.map((item) => item.name),
       });
     }
 
     this._debug(`BUILD...`);
-    const bundleResult = await this.#serverBundler!.bundleAsync(modifiedFileSet);
+    const bundleResult = await this._serverBundler!.bundleAsync(modifiedFileSet);
 
     this._debug(`빌드 완료`);
     return bundleResult;
   }
 
-  #generateProductionFiles(externals: string[]) {
+  private _generateProductionFiles(externals: string[]) {
     const npmConf = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json")) as INpmConfig;
 
     this._debug("GEN package.json...");
@@ -185,7 +185,7 @@ Options = UnsafeLegacyRenegotiation`.trim(),
     }
   }
 
-  #getExternalModules(): {
+  private _getExternalModules(): {
     name: string;
     exists: boolean;
   }[] {

package/src/pkg-builders/server/SdServerBundler.ts

@@ -15,22 +15,22 @@ import { ISdTsCompilerOptions } from "../../types/build/ISdTsCompilerOptions";
 import { SdWorkerPathPlugin } from "../commons/SdWorkerPathPlugin";
 
 export class SdServerBundler {
-  #logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
+  private readonly _logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
 
-  #context?: esbuild.BuildContext;
+  private _context?: esbuild.BuildContext;
 
-  #modifiedFileSet = new Set<TNormPath>();
-  #resultCache: ISdCliServerPluginResultCache = {};
+  private readonly _modifiedFileSet = new Set<TNormPath>();
+  private readonly _resultCache: ISdCliServerPluginResultCache = {};
 
-  #outputHashCache = new Map<TNormPath, string>();
+  private readonly _outputHashCache = new Map<TNormPath, string>();
 
-  #esbuildOptions: esbuild.BuildOptions;
+  private readonly _esbuildOptions: esbuild.BuildOptions;
 
   constructor(
     private readonly _opt: ISdTsCompilerOptions,
     private readonly _conf: { external: string[] },
   ) {
-    this.#esbuildOptions = {
+    this._esbuildOptions = {
       entryPoints: [
         path.resolve(this._opt.pkgPath, "src/main.ts"),
         // ...FsUtils.glob(path.resolve(this._opt.pkgPath, "src/workers/*.ts")),
@@ -93,26 +93,26 @@ const __filename = __fileURLToPath__(import.meta.url);
 const __dirname = __path__.dirname(__filename);`.trim(),
       },
       plugins: [
-        createSdServerPlugin(this._opt, this.#modifiedFileSet, this.#resultCache),
+        createSdServerPlugin(this._opt, this._modifiedFileSet, this._resultCache),
         SdWorkerPathPlugin(path.resolve(this._opt.pkgPath, "dist")),
       ],
     };
   }
 
   async bundleAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
-    this.#modifiedFileSet.clear();
+    this._modifiedFileSet.clear();
     if (modifiedFileSet) {
-      this.#modifiedFileSet.adds(...modifiedFileSet);
+      this._modifiedFileSet.adds(...modifiedFileSet);
     }
 
     let esbuildResult: esbuild.BuildResult;
     if (this._opt.watch) {
-      if (this.#context == null) {
-        this.#context = await esbuild.context(this.#esbuildOptions);
+      if (this._context == null) {
+        this._context = await esbuild.context(this._esbuildOptions);
       }
 
       try {
-        esbuildResult = await this.#context.rebuild();
+        esbuildResult = await this._context.rebuild();
       } catch (err) {
         if ("warnings" in err || "errors" in err) {
           esbuildResult = err;
@@ -122,7 +122,7 @@ const __dirname = __path__.dirname(__filename);`.trim(),
       }
     } else {
       try {
-        esbuildResult = await esbuild.build(this.#esbuildOptions);
+        esbuildResult = await esbuild.build(this._esbuildOptions);
       } catch (err) {
         if ("warnings" in err || "errors" in err) {
           esbuildResult = err;
@@ -139,8 +139,8 @@ const __dirname = __path__.dirname(__filename);`.trim(),
           this._opt.pkgPath,
         ),
 
-        watchFileSet: this.#resultCache.watchFileSet!,
-        affectedFileSet: this.#resultCache.affectedFileSet!,
+        watchFileSet: this._resultCache.watchFileSet!,
+        affectedFileSet: this._resultCache.affectedFileSet!,
         emitFileSet: new Set<TNormPath>(),
       };
     } else {
@@ -154,11 +154,11 @@ const __dirname = __path__.dirname(__filename);`.trim(),
 
         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);
           }
         }
@@ -173,14 +173,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 = HashUtils.get(FsUtils.readFileBuffer(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(this._opt.pkgPath, "dist", assetFile.destination));
           }
         }
@@ -188,7 +188,7 @@ const __dirname = __path__.dirname(__filename);`.trim(),
         esbuildResult = err;
         for (const e of err.errors) {
           if (e.detail != null) {
-            this.#logger.error(e.detail);
+            this._logger.error(e.detail);
           }
         }
       }
@@ -199,8 +199,8 @@ const __dirname = __path__.dirname(__filename);`.trim(),
           this._opt.pkgPath,
         ),
 
-        watchFileSet: this.#resultCache.watchFileSet!,
-        affectedFileSet: this.#resultCache.affectedFileSet!,
+        watchFileSet: this._resultCache.watchFileSet!,
+        affectedFileSet: this._resultCache.affectedFileSet!,
         emitFileSet: emitFileSet,
       };
     }

package/src/ts-compiler/ScopePathSet.ts

@@ -1,17 +1,17 @@
 import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
 
 export class ScopePathSet {
-  #data: Set<TNormPath>;
+  private readonly _data: Set<TNormPath>;
 
   constructor(arrOrSet?: TNormPath[] | Set<TNormPath>) {
-    this.#data = arrOrSet instanceof Set ? arrOrSet : new Set(arrOrSet);
+    this._data = arrOrSet instanceof Set ? arrOrSet : new Set(arrOrSet);
   }
 
   inScope(filePath: string) {
-    return Array.from(this.#data).some((scope) => PathUtils.isChildPath(filePath, scope));
+    return Array.from(this._data).some((scope) => PathUtils.isChildPath(filePath, scope));
   }
 
   toArray() {
-    return Array.from(this.#data);
+    return Array.from(this._data);
   }
 }

package/src/ts-compiler/SdDepCache.ts

@@ -4,14 +4,14 @@ export class SdDepCache {
   /**
    * 각 파일이 export한 심볼 집합 (예: export const A → "A")
    */
-  #exportCache = new Map<TNormPath, Set<string>>();
+  private readonly _exportCache = new Map<TNormPath, Set<string>>();
 
   /**
    * import한 타겟과 그 심볼 정보
    * - 값이 0이면 전체 import(import * 또는 리소스 import)
    * - 값이 Set이면 선택적 심볼 import (예: import { A } ...)
    */
-  #importCache = new Map<TNormPath, Map<TNormPath, Set<string> | 0>>();
+  private readonly _importCache = new Map<TNormPath, Map<TNormPath, Set<string> | 0>>();
 
   /**
    * re-export한 타겟과 그 심볼 정보
@@ -19,7 +19,7 @@ export class SdDepCache {
    * - export { A as B } from ...
    * - 값이 0이면 전체 reexport(export * from ...)
    */
-  #reexportCache = new Map<
+  private readonly _reexportCache = new Map<
     TNormPath,
     Map<
       TNormPath,
@@ -36,20 +36,20 @@ export class SdDepCache {
    * - 특정 파일이 어떤 파일에게 의존(참조)되는지
    * - symbol 기반 추적
    */
-  #revDepCache = new Map<TNormPath, Map<TNormPath, Set<string> | 0>>();
+  private readonly _revDepCache = new Map<TNormPath, Map<TNormPath, Set<string> | 0>>();
 
   /**
    * 분석이 완료된 파일 경로
    */
-  #collectedCache = new Set<TNormPath>();
+  private readonly _collectedCache = new Set<TNormPath>();
 
-  #exportSymbolCache = new Map<TNormPath, Set<string>>();
+  private readonly _exportSymbolCache = new Map<TNormPath, Set<string>>();
 
   /**
    * .d.ts 또는 .js가 입력되었을 때 쌍으로 존재하는 파일 경로를 반환
    * 예: "/a.d.ts" → ["/a.d.ts", "/a.js"]
    */
-  #getRelatedNPaths(nPath: TNormPath): TNormPath[] {
+  private _getRelatedNPaths(nPath: TNormPath): TNormPath[] {
     if (nPath.endsWith(".d.ts")) {
       return [nPath, nPath.replace(/\.d\.ts$/, ".js") as TNormPath];
     }
@@ -63,13 +63,13 @@ export class SdDepCache {
    * 분석이 완료된 파일로 표시
    */
   addCollected(fileNPath: TNormPath) {
-    for (const path of this.#getRelatedNPaths(fileNPath)) {
-      this.#collectedCache.add(path);
+    for (const path of this._getRelatedNPaths(fileNPath)) {
+      this._collectedCache.add(path);
     }
   }
 
   hasCollected(fileNPath: TNormPath) {
-    return this.#collectedCache.has(fileNPath);
+    return this._collectedCache.has(fileNPath);
   }
 
   /**
@@ -77,8 +77,8 @@ export class SdDepCache {
    * 예: export const A → "A"
    */
   addExport(fileNPath: TNormPath, exportSymbol: string) {
-    for (const path of this.#getRelatedNPaths(fileNPath)) {
-      const exportSymbolSet = this.#exportCache.getOrCreate(path, new Set());
+    for (const path of this._getRelatedNPaths(fileNPath)) {
+      const exportSymbolSet = this._exportCache.getOrCreate(path, new Set());
       exportSymbolSet.add(exportSymbol);
     }
   }
@@ -89,19 +89,19 @@ export class SdDepCache {
    * - import { A } from ... → symbol = "A"
    */
   addImport(fileNPath: TNormPath, targetNPath: TNormPath, targetSymbol: string | 0) {
-    for (const filePath of this.#getRelatedNPaths(fileNPath)) {
-      const importTargetMap = this.#importCache.getOrCreate(filePath, new Map());
+    for (const filePath of this._getRelatedNPaths(fileNPath)) {
+      const importTargetMap = this._importCache.getOrCreate(filePath, new Map());
 
-      for (const targetPath of this.#getRelatedNPaths(targetNPath)) {
+      for (const targetPath of this._getRelatedNPaths(targetNPath)) {
         if (typeof targetSymbol === "string") {
           const importTargetSymbolSet = importTargetMap.getOrCreate(targetPath, new Set());
           if (!(importTargetSymbolSet instanceof Set)) continue;
 
           importTargetSymbolSet.add(targetSymbol);
-          this.#addRevDep(targetPath, filePath, targetSymbol);
+          this._addRevDep(targetPath, filePath, targetSymbol);
         } else {
           importTargetMap.set(targetPath, targetSymbol);
-          this.#addRevDep(targetPath, filePath, targetSymbol);
+          this._addRevDep(targetPath, filePath, targetSymbol);
         }
       }
     }
@@ -121,13 +121,13 @@ export class SdDepCache {
         }
       | 0,
   ) {
-    for (const filePath of this.#getRelatedNPaths(fileNPath)) {
-      const reexportTargetMap = this.#reexportCache.getOrCreate(filePath, new Map());
+    for (const filePath of this._getRelatedNPaths(fileNPath)) {
+      const reexportTargetMap = this._reexportCache.getOrCreate(filePath, new Map());
 
-      for (const targetPath of this.#getRelatedNPaths(targetNPath)) {
+      for (const targetPath of this._getRelatedNPaths(targetNPath)) {
         if (targetSymbolInfo === 0) {
           reexportTargetMap.set(targetPath, 0);
-          this.#addRevDep(targetPath, filePath, 0);
+          this._addRevDep(targetPath, filePath, 0);
         } else {
           const reexportTargetSymbolInfos = reexportTargetMap.getOrCreate(targetPath, []);
           if (reexportTargetSymbolInfos === 0) return;
@@ -140,7 +140,7 @@ export class SdDepCache {
             )
           ) {
             reexportTargetSymbolInfos.push(targetSymbolInfo);
-            this.#addRevDep(targetPath, filePath, targetSymbolInfo.importSymbol);
+            this._addRevDep(targetPath, filePath, targetSymbolInfo.importSymbol);
           }
         }
       }
@@ -150,11 +150,11 @@ export class SdDepCache {
   /**
    * 역의존 관계 등록 (revDep)
    */
-  #addRevDep(targetNPath: TNormPath, fileNPath: TNormPath, exportSymbol: string | 0) {
-    for (const targetPath of this.#getRelatedNPaths(targetNPath)) {
-      const revDepInfoMap = this.#revDepCache.getOrCreate(targetPath, new Map());
+  private _addRevDep(targetNPath: TNormPath, fileNPath: TNormPath, exportSymbol: string | 0) {
+    for (const targetPath of this._getRelatedNPaths(targetNPath)) {
+      const revDepInfoMap = this._revDepCache.getOrCreate(targetPath, new Map());
 
-      for (const filePath of this.#getRelatedNPaths(fileNPath)) {
+      for (const filePath of this._getRelatedNPaths(fileNPath)) {
         if (typeof exportSymbol === "string") {
           const exportSymbolSet = revDepInfoMap.getOrCreate(filePath, new Set());
           if (!(exportSymbolSet instanceof Set)) continue;
@@ -183,9 +183,9 @@ export class SdDepCache {
         }
       };
 
-      for (const relatedNPath of this.#getRelatedNPaths(modifiedNPath)) {
+      for (const relatedNPath of this._getRelatedNPaths(modifiedNPath)) {
         result.add(relatedNPath);
-        const exportSymbols = this.#getExportSymbols(relatedNPath);
+        const exportSymbols = this._getExportSymbols(relatedNPath);
         if (exportSymbols.size === 0) {
           enqueue(relatedNPath, undefined);
         } else {
@@ -197,7 +197,7 @@ export class SdDepCache {
 
       while (queue.length > 0) {
         const curr = queue.shift()!;
-        const revDepInfoMap = this.#revDepCache.get(curr.fileNPath);
+        const revDepInfoMap = this._revDepCache.get(curr.fileNPath);
         if (!revDepInfoMap) continue;
 
         for (const [revDepFileNPath, revDepInfo] of revDepInfoMap) {
@@ -205,7 +205,7 @@ export class SdDepCache {
             const hasImportSymbol = revDepInfo === 0 || revDepInfo.has(curr.exportSymbol);
             if (hasImportSymbol) {
               result.add(revDepFileNPath);
-              const exportSymbol = this.#convertImportSymbolToExportSymbol(
+              const exportSymbol = this._convertImportSymbolToExportSymbol(
                 revDepFileNPath,
                 curr.fileNPath,
                 curr.exportSymbol,
@@ -231,11 +231,11 @@ export class SdDepCache {
     // const revDepCacheChanged = new Set<TNormPath>();
 
     for (const fileNPath of fileNPathSet) {
-      this.#exportCache.delete(fileNPath);
-      this.#importCache.delete(fileNPath);
-      this.#reexportCache.delete(fileNPath);
-      this.#exportSymbolCache.delete(fileNPath);
-      this.#collectedCache.delete(fileNPath);
+      this._exportCache.delete(fileNPath);
+      this._importCache.delete(fileNPath);
+      this._reexportCache.delete(fileNPath);
+      this._exportSymbolCache.delete(fileNPath);
+      this._collectedCache.delete(fileNPath);
 
       // if (this.#revDepCache.has(fileNPath)) {
       //   this.#revDepCache.delete(fileNPath); // 자신이 key인 경우
@@ -243,7 +243,7 @@ export class SdDepCache {
       // }
     }
 
-    for (const [targetNPath, infoMap] of this.#revDepCache) {
+    for (const [targetNPath, infoMap] of this._revDepCache) {
       for (const fileNPath of fileNPathSet) {
         if (infoMap.has(fileNPath)) {
           infoMap.delete(fileNPath);
@@ -251,7 +251,7 @@ export class SdDepCache {
         }
       }
       if (infoMap.size === 0) {
-        this.#revDepCache.delete(targetNPath);
+        this._revDepCache.delete(targetNPath);
       }
     }
   }
@@ -259,12 +259,12 @@ export class SdDepCache {
   /**
    * reexport된 경우 importSymbol → exportSymbol로 변환
    */
-  #convertImportSymbolToExportSymbol(
+  private _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) return symbolInfo.exportSymbol;
@@ -275,22 +275,22 @@ export class SdDepCache {
   /**
    * 해당 파일에서 export된 모든 심볼 (직접 + 재export 포함)
    */
-  #getExportSymbols(fileNPath: TNormPath): Set<string> {
-    if (this.#exportSymbolCache.has(fileNPath)) {
-      return this.#exportSymbolCache.get(fileNPath)!;
+  private _getExportSymbols(fileNPath: TNormPath): Set<string> {
+    if (this._exportSymbolCache.has(fileNPath)) {
+      return this._exportSymbolCache.get(fileNPath)!;
     }
 
     const result = new Set<string>();
 
-    for (const path of this.#getRelatedNPaths(fileNPath)) {
-      const set = this.#exportCache.get(path);
+    for (const path of this._getRelatedNPaths(fileNPath)) {
+      const set = this._exportCache.get(path);
       if (set) result.adds(...set);
 
-      const map = this.#reexportCache.get(path);
+      const map = this._reexportCache.get(path);
       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));
           }
@@ -298,7 +298,7 @@ export class SdDepCache {
       }
     }
 
-    this.#exportSymbolCache.set(fileNPath, result);
+    this._exportSymbolCache.set(fileNPath, result);
     return result;
   }
 }