@simplysm/sd-cli 12.15.39 → 12.15.41

package/dist/ts-compiler/SdTsCompiler.js

@@ -13,41 +13,34 @@ import { FlatESLint } from "eslint/use-at-your-own-risk";
 import { SdStyleBundler } from "./SdStyleBundler";
 import { ScopePathSet } from "./ScopePathSet";
 export class SdTsCompiler {
-    #logger = SdLogger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
-    #isForAngular;
-    #scopePathSet;
-    #styleBundler;
-    #moduleResolutionCache;
-    #ngProgram;
-    #program;
-    // 빌드정보 캐싱
-    #cache = {
-        dep: new SdDepCache(),
-        type: new WeakMap(),
-        prop: new WeakMap(),
-        declFiles: new WeakMap(),
-        ngOrg: new Map(),
-    };
-    #sourceFileCacheMap = new Map();
-    #emittedFilesCacheMap = new Map();
-    #perf;
     constructor(_opt, _forBundle) {
         this._opt = _opt;
         this._forBundle = _forBundle;
-        this.#debug("초기화 중...");
+        this._logger = SdLogger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
+        // 빌드정보 캐싱
+        this._cache = {
+            dep: new SdDepCache(),
+            type: new WeakMap(),
+            prop: new WeakMap(),
+            declFiles: new WeakMap(),
+            ngOrg: new Map(),
+        };
+        this._sourceFileCacheMap = new Map();
+        this._emittedFilesCacheMap = new Map();
+        this._debug("초기화 중...");
         const tsconfigPath = path.resolve(this._opt.pkgPath, "tsconfig.json");
         const tsconfig = FsUtils.readJson(tsconfigPath);
-        this.#isForAngular = Boolean(tsconfig.angularCompilerOptions);
-        this.#scopePathSet = new ScopePathSet(this._opt.scopePathSet);
+        this._isForAngular = Boolean(tsconfig.angularCompilerOptions);
+        this._scopePathSet = new ScopePathSet(this._opt.scopePathSet);
         if (!this._opt.watch?.noEmit) {
-            this.#styleBundler = new SdStyleBundler({
+            this._styleBundler = new SdStyleBundler({
                 pkgPath: this._opt.pkgPath,
-                scopePathSet: this.#scopePathSet,
+                scopePathSet: this._scopePathSet,
                 dev: !!this._opt.watch?.dev,
             });
         }
     }
-    #parseTsConfig() {
+    _parseTsConfig() {
         const tsconfigPath = path.resolve(this._opt.pkgPath, "tsconfig.json");
         const tsconfig = FsUtils.readJson(tsconfigPath);
         const parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._opt.pkgPath, {
@@ -76,7 +69,7 @@ export class SdTsCompiler {
             distPath: distPath,
         };
     }
-    #createCompilerHost(compilerOptions, modifiedFileSet) {
+    _createCompilerHost(compilerOptions, modifiedFileSet) {
         // 지식: SourceFile은 하나의 파일에만 국한된 정적 정보객체임, 변경된 파일의 SourceFile만 다시 생성하면됨
         const compilerHost = ts.createCompilerHost(compilerOptions);
         const baseGetSourceFile = compilerHost.getSourceFile;
@@ -85,18 +78,18 @@ export class SdTsCompiler {
             /*if (!shouldCreateNewSourceFile && this.#sourceFileCacheMap.has(fileNPath)) {
               return this.#sourceFileCacheMap.get(fileNPath);
             }*/
-            if (this.#sourceFileCacheMap.has(fileNPath)) {
-                return this.#sourceFileCacheMap.get(fileNPath);
+            if (this._sourceFileCacheMap.has(fileNPath)) {
+                return this._sourceFileCacheMap.get(fileNPath);
             }
             const sf = baseGetSourceFile.call(compilerHost, fileName, languageVersionOrOptions, onError, false, ...args);
             if (!sf) {
-                this.#sourceFileCacheMap.delete(fileNPath);
+                this._sourceFileCacheMap.delete(fileNPath);
                 return undefined;
             }
-            this.#sourceFileCacheMap.set(fileNPath, sf);
+            this._sourceFileCacheMap.set(fileNPath, sf);
             return sf;
         };
-        if (this.#isForAngular) {
+        if (this._isForAngular) {
             compilerHost.readResource = (fileName) => {
                 return compilerHost.readFile(fileName) ?? "";
             };
@@ -105,7 +98,7 @@ export class SdTsCompiler {
                     if (context.type !== "style") {
                         return null;
                     }
-                    const styleBundleResult = await this.#styleBundler.bundleAsync(data, PathUtils.norm(context.containingFile), context.resourceFile != null ? PathUtils.norm(context.resourceFile) : undefined);
+                    const styleBundleResult = await this._styleBundler.bundleAsync(data, PathUtils.norm(context.containingFile), context.resourceFile != null ? PathUtils.norm(context.resourceFile) : undefined);
                     return StringUtils.isNullOrEmpty(styleBundleResult.contents)
                         ? null
                         : { content: styleBundleResult.contents };
@@ -115,17 +108,17 @@ export class SdTsCompiler {
                 return new Set(Array.from(modifiedFileSet).map((item) => PathUtils.posix(item)));
             };
         }
-        this.#moduleResolutionCache = ts.createModuleResolutionCache(compilerHost.getCurrentDirectory(), compilerHost.getCanonicalFileName.bind(compilerHost), compilerOptions, this.#moduleResolutionCache?.getPackageJsonInfoCache());
-        compilerHost.getModuleResolutionCache = () => this.#moduleResolutionCache;
+        this._moduleResolutionCache = ts.createModuleResolutionCache(compilerHost.getCurrentDirectory(), compilerHost.getCanonicalFileName.bind(compilerHost), compilerOptions, this._moduleResolutionCache?.getPackageJsonInfoCache());
+        compilerHost.getModuleResolutionCache = () => this._moduleResolutionCache;
         return compilerHost;
     }
     async compileAsync(modifiedFileSet) {
-        this.#perf = new SdCliPerformanceTimer("esbuild compile");
-        const prepareResult = await this.#prepareAsync(modifiedFileSet);
+        this._perf = new SdCliPerformanceTimer("esbuild compile");
+        const prepareResult = await this._prepareAsync(modifiedFileSet);
         const [globalStyleSheet, lintResults, buildResult] = await Promise.all([
-            this._opt.watch?.noEmit ? Promise.resolve(undefined) : this.#buildGlobalStyleAsync(),
-            this._opt.watch?.emitOnly ? Promise.resolve([]) : this.#lintAsync(prepareResult),
-            Promise.resolve(this.#build(prepareResult)),
+            this._opt.watch?.noEmit ? Promise.resolve(undefined) : this._buildGlobalStyleAsync(),
+            this._opt.watch?.emitOnly ? Promise.resolve([]) : this._lintAsync(prepareResult),
+            Promise.resolve(this._build(prepareResult)),
         ]);
         const messages = [
             ...SdCliConvertMessageUtils.convertToBuildMessagesFromTsDiag(buildResult.diagnostics),
@@ -133,101 +126,101 @@ export class SdTsCompiler {
         ];
         const affectedFileSet = new Set([
             ...prepareResult.affectedFileSet,
-            ...(this.#styleBundler?.getAffectedFileSet(modifiedFileSet) ?? []),
+            ...(this._styleBundler?.getAffectedFileSet(modifiedFileSet) ?? []),
         ]);
         const watchFileSet = new Set([
             ...prepareResult.watchFileSet,
-            ...(this.#styleBundler?.getAllStyleFileSet() ?? []),
+            ...(this._styleBundler?.getAllStyleFileSet() ?? []),
         ]);
-        this.#debug(`빌드 완료됨`, this.#perf.toString());
-        this.#debug(`영향 받은 파일: ${affectedFileSet.size}개`, ...(modifiedFileSet.size > 0 ? [affectedFileSet] : []));
-        this.#debug(`감시 중인 파일: ${watchFileSet.size}개`);
+        this._debug(`빌드 완료됨`, this._perf.toString());
+        this._debug(`영향 받은 파일: ${affectedFileSet.size}개`, ...(modifiedFileSet.size > 0 ? [affectedFileSet] : []));
+        this._debug(`감시 중인 파일: ${watchFileSet.size}개`);
         return {
             messages: messages,
             affectedFileSet: affectedFileSet,
             watchFileSet: watchFileSet,
-            stylesheetBundlingResultMap: this.#styleBundler?.getResultCache() ?? new Map(),
-            emittedFilesCacheMap: this.#emittedFilesCacheMap,
+            stylesheetBundlingResultMap: this._styleBundler?.getResultCache() ?? new Map(),
+            emittedFilesCacheMap: this._emittedFilesCacheMap,
             emitFileSet: new Set([...buildResult.emitFileSet, globalStyleSheet].filterExists()),
         };
     }
-    async #prepareAsync(modifiedFileSet) {
-        const tsconfig = this.#parseTsConfig();
+    async _prepareAsync(modifiedFileSet) {
+        const tsconfig = this._parseTsConfig();
         if (modifiedFileSet.size !== 0 && this._opt.watch) {
-            this.#debug(`캐시 무효화 및 초기화 중...`);
+            this._debug(`캐시 무효화 및 초기화 중...`);
             // this._perf.run("캐시 무효화 및 초기화", () => {
-            this.#perf.run("캐시 무효화 및 초기화", () => {
+            this._perf.run("캐시 무효화 및 초기화", () => {
                 // 소스파일은 변경된 파일들로 무효화
                 for (const modifiedFile of modifiedFileSet) {
-                    this.#sourceFileCacheMap.delete(modifiedFile);
+                    this._sourceFileCacheMap.delete(modifiedFile);
                 }
                 // 스타일 번들러 무효화 (transformResource 재실행 땜에 필요할듯)
-                if (this.#styleBundler) {
-                    const styleAffectedFileSet = this.#styleBundler.invalidate(modifiedFileSet);
+                if (this._styleBundler) {
+                    const styleAffectedFileSet = this._styleBundler.invalidate(modifiedFileSet);
                     // 스타일 변경된 파일들로 무효화
                     for (const styleAffectedFile of styleAffectedFileSet) {
-                        this.#sourceFileCacheMap.delete(styleAffectedFile);
-                        this.#emittedFilesCacheMap.delete(styleAffectedFile);
+                        this._sourceFileCacheMap.delete(styleAffectedFile);
+                        this._emittedFilesCacheMap.delete(styleAffectedFile);
                     }
                 }
                 // angular origin 파일 매핑은 변경된 파일들로 무효화
                 for (const modifiedFile of modifiedFileSet) {
-                    this.#cache.ngOrg.delete(modifiedFile);
+                    this._cache.ngOrg.delete(modifiedFile);
                 }
                 // 기존 의존성에 의해 영향받는 파일들 계산
-                this.#cache.dep.invalidates(modifiedFileSet);
+                this._cache.dep.invalidates(modifiedFileSet);
                 // 결과물이 바뀌어야 하는 캐시 모두 무효화 (modified만 다시쓰면될듯..)
                 for (const modifiedFile of modifiedFileSet) {
-                    this.#emittedFilesCacheMap.delete(modifiedFile);
+                    this._emittedFilesCacheMap.delete(modifiedFile);
                 }
             });
         }
-        this.#debug(`ts.Program 생성 중...`);
-        const compilerHost = this.#perf.run("ts.CompilerHost 생성", () => {
-            return this.#createCompilerHost(tsconfig.options, modifiedFileSet);
+        this._debug(`ts.Program 생성 중...`);
+        const compilerHost = this._perf.run("ts.CompilerHost 생성", () => {
+            return this._createCompilerHost(tsconfig.options, modifiedFileSet);
         });
-        this.#perf.run("ts.Program 생성", () => {
-            if (this.#isForAngular) {
-                this.#ngProgram = new NgtscProgram(tsconfig.fileNames, tsconfig.options, compilerHost, this.#ngProgram);
-                this.#program = this.#ngProgram.getTsProgram();
+        this._perf.run("ts.Program 생성", () => {
+            if (this._isForAngular) {
+                this._ngProgram = new NgtscProgram(tsconfig.fileNames, tsconfig.options, compilerHost, this._ngProgram);
+                this._program = this._ngProgram.getTsProgram();
             }
             else {
-                this.#program = ts.createProgram(tsconfig.fileNames, tsconfig.options, compilerHost, this.#program);
+                this._program = ts.createProgram(tsconfig.fileNames, tsconfig.options, compilerHost, this._program);
             }
         });
-        if (this.#ngProgram) {
-            this.#debug(`Angular 템플릿 분석...`);
-            await this.#perf.run("Angular 템플릿 분석", async () => {
-                await this.#ngProgram.compiler.analyzeAsync();
+        if (this._ngProgram) {
+            this._debug(`Angular 템플릿 분석...`);
+            await this._perf.run("Angular 템플릿 분석", async () => {
+                await this._ngProgram.compiler.analyzeAsync();
             });
         }
         if (this._opt.watch && !this._opt.watch.emitOnly) {
-            this.#debug(`새 의존성 분석 중...`);
-            this.#perf.run("새 의존성 분석", () => {
+            this._debug(`새 의존성 분석 중...`);
+            this._perf.run("새 의존성 분석", () => {
                 // SdTsDependencyAnalyzer를 통해 의존성 분석 및 SdDepCache 업데이트
-                SdDepAnalyzer.analyze(this.#program, compilerHost, this.#scopePathSet, this.#cache);
+                SdDepAnalyzer.analyze(this._program, compilerHost, this._scopePathSet, this._cache);
             });
             // Angular 리소스 의존성 추가
-            if (this.#ngProgram) {
-                this.#debug(`새 의존성 분석(Angular) 중...`);
-                this.#perf.run("새 의존성 분석(Angular)", () => {
-                    SdDepAnalyzer.analyzeAngularResources(this.#ngProgram, this.#scopePathSet, this.#cache.dep);
+            if (this._ngProgram) {
+                this._debug(`새 의존성 분석(Angular) 중...`);
+                this._perf.run("새 의존성 분석(Angular)", () => {
+                    SdDepAnalyzer.analyzeAngularResources(this._ngProgram, this._scopePathSet, this._cache.dep);
                 });
             }
         }
-        const allTsFiles = this.#program.getSourceFiles().mapMany((item) => [
+        const allTsFiles = this._program.getSourceFiles().mapMany((item) => [
             PathUtils.norm(item.fileName),
             ...(item.fileName.endsWith(".d.ts")
                 ? [PathUtils.norm(item.fileName.replace(/\.d\.ts$/, "") + ".js")]
                 : []),
         ]);
-        const watchFileSet = new Set(allTsFiles.filter((item) => this.#scopePathSet.inScope(item)));
+        const watchFileSet = new Set(allTsFiles.filter((item) => this._scopePathSet.inScope(item)));
         let affectedFileSet;
         if (modifiedFileSet.size === 0) {
-            affectedFileSet = new Set(allTsFiles.filter((item) => this.#scopePathSet.inScope(item)));
+            affectedFileSet = new Set(allTsFiles.filter((item) => this._scopePathSet.inScope(item)));
         }
         else {
-            const affectedFileMap = this.#cache.dep.getAffectedFileMap(modifiedFileSet);
+            const affectedFileMap = this._cache.dep.getAffectedFileMap(modifiedFileSet);
             affectedFileSet = new Set(Array.from(affectedFileMap.values()).mapMany((item) => Array.from(item)));
         }
         return {
@@ -235,12 +228,12 @@ export class SdTsCompiler {
             compilerHost,
             watchFileSet,
             affectedFileSet,
-            styleAffectedFileSet: this.#styleBundler?.getAffectedFileSet(modifiedFileSet) ?? new Set(),
+            styleAffectedFileSet: this._styleBundler?.getAffectedFileSet(modifiedFileSet) ?? new Set(),
         };
     }
-    async #lintAsync(prepareResult) {
-        return await this.#perf.run("Linting", async () => {
-            this.#debug(`Linting...`);
+    async _lintAsync(prepareResult) {
+        return await this._perf.run("Linting", async () => {
+            this._debug(`Linting...`);
             const lintFilePaths = Array.from(prepareResult.affectedFileSet)
                 .filter((item) => PathUtils.isChildPath(item, this._opt.pkgPath))
                 .filter((item) => (!item.endsWith(".d.ts") && item.endsWith(".ts")) || item.endsWith(".js"))
@@ -257,7 +250,7 @@ export class SdTsCompiler {
                             // project: true,
                             // tsconfigRootDir: this._opt.pkgPath,
                             project: null,
-                            programs: [this.#program],
+                            programs: [this._program],
                         },
                     },
                 },
@@ -268,25 +261,25 @@ export class SdTsCompiler {
             //   return await linter.lintText(sf.text, { filePath: lintFilePath });
             // });
             const result = await linter.lintFiles(lintFilePaths);
-            this.#debug(`Linting 완료`);
+            this._debug(`Linting 완료`);
             // return result.mapMany();
             return result;
         });
     }
-    async #buildGlobalStyleAsync() {
-        if (!this.#isForAngular)
+    async _buildGlobalStyleAsync() {
+        if (!this._isForAngular)
             return;
         //-- global style
         const globalStyleFilePath = PathUtils.norm(this._opt.pkgPath, "scss/styles.scss");
-        if (this.#emittedFilesCacheMap.has(globalStyleFilePath))
+        if (this._emittedFilesCacheMap.has(globalStyleFilePath))
             return;
         if (!FsUtils.exists(globalStyleFilePath))
             return;
-        this.#debug(`전역 스타일 번들링 중...`);
-        await this.#perf.run("전역 스타일 번들링", async () => {
+        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, []);
+            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, "scss"), globalStyleFilePath)
@@ -296,55 +289,55 @@ export class SdTsCompiler {
         });
         return globalStyleFilePath;
     }
-    #build(prepareResult) {
+    _build(prepareResult) {
         const emitFileSet = new Set();
         const diagnostics = [];
         if (!this._opt.watch?.emitOnly) {
-            this.#debug(`프로그램 진단 수집 중...`);
-            this.#perf.run("프로그램 진단 수집", () => {
-                diagnostics.push(...this.#program.getConfigFileParsingDiagnostics(), ...this.#program.getOptionsDiagnostics(), ...this.#program.getGlobalDiagnostics());
-                if (this.#ngProgram) {
-                    diagnostics.push(...this.#ngProgram.compiler.getOptionDiagnostics());
+            this._debug(`프로그램 진단 수집 중...`);
+            this._perf.run("프로그램 진단 수집", () => {
+                diagnostics.push(...this._program.getConfigFileParsingDiagnostics(), ...this._program.getOptionsDiagnostics(), ...this._program.getGlobalDiagnostics());
+                if (this._ngProgram) {
+                    diagnostics.push(...this._ngProgram.compiler.getOptionDiagnostics());
                 }
             });
-            this.#debug(`개별 파일 진단 수집 중...`);
+            this._debug(`개별 파일 진단 수집 중...`);
             for (const affectedFile of prepareResult.affectedFileSet) {
                 if (!PathUtils.isChildPath(affectedFile, this._opt.pkgPath))
                     continue;
-                const affectedSourceFile = this.#program.getSourceFile(affectedFile);
+                const affectedSourceFile = this._program.getSourceFile(affectedFile);
                 if (!affectedSourceFile ||
-                    (this.#ngProgram && this.#ngProgram.compiler.ignoreForDiagnostics.has(affectedSourceFile))) {
+                    (this._ngProgram && this._ngProgram.compiler.ignoreForDiagnostics.has(affectedSourceFile))) {
                     continue;
                 }
-                this.#perf.run("개별 파일 진단 수집", () => {
-                    diagnostics.push(...this.#program.getSyntacticDiagnostics(affectedSourceFile), ...this.#program.getSemanticDiagnostics(affectedSourceFile));
+                this._perf.run("개별 파일 진단 수집", () => {
+                    diagnostics.push(...this._program.getSyntacticDiagnostics(affectedSourceFile), ...this._program.getSemanticDiagnostics(affectedSourceFile));
                 });
-                if (this.#ngProgram) {
-                    this.#perf.run("개별 파일 진단 수집(Angular)", () => {
+                if (this._ngProgram) {
+                    this._perf.run("개별 파일 진단 수집(Angular)", () => {
                         if (affectedSourceFile.isDeclarationFile)
                             return;
-                        diagnostics.push(...this.#ngProgram.compiler.getDiagnosticsForFile(affectedSourceFile, OptimizeFor.WholeProgram));
+                        diagnostics.push(...this._ngProgram.compiler.getDiagnosticsForFile(affectedSourceFile, OptimizeFor.WholeProgram));
                     });
                 }
             }
         }
         if (!this._opt.watch?.noEmit) {
-            this.#perf.run("파일 출력 (emit)", () => {
-                this.#debug(`파일 출력 준비 중...`);
+            this._perf.run("파일 출력 (emit)", () => {
+                this._debug(`파일 출력 준비 중...`);
                 let transformers = {};
-                if (this.#ngProgram) {
-                    const angularTransfomers = this.#ngProgram.compiler.prepareEmit().transformers;
+                if (this._ngProgram) {
+                    const angularTransfomers = this._ngProgram.compiler.prepareEmit().transformers;
                     (transformers.before ??= []).push(...(angularTransfomers.before ?? []));
                     (transformers.after ??= []).push(...(angularTransfomers.after ?? []));
                     (transformers.afterDeclarations ??= []).push(...(angularTransfomers.afterDeclarations ?? []));
-                    (transformers.before ??= []).push(replaceBootstrap(() => this.#program.getTypeChecker()));
+                    (transformers.before ??= []).push(replaceBootstrap(() => this._program.getTypeChecker()));
                     (transformers.before ??= []).push(createWorkerTransformer((file, importer) => {
                         const fullPath = path.resolve(path.dirname(importer), file);
                         const relPath = path.relative(path.resolve(this._opt.pkgPath, "src"), fullPath);
                         return relPath.replace(/\.ts$/, "").replaceAll("\\", "/") + ".js";
                     }));
                 }
-                this.#debug(`파일 출력 중...`);
+                this._debug(`파일 출력 중...`);
                 // affected에 새로 추가된 파일은 포함되지 않는 현상이 있어 sourceFileSet으로 바꿈
                 // 비교해보니, 딱히 getSourceFiles라서 더 느려지는것 같지는 않음
                 // 그래도 affected로 다시 테스트 (조금이라도 더 빠르게)
@@ -354,39 +347,39 @@ export class SdTsCompiler {
                 ]) {
                     if (affectedFile.endsWith(".scss"))
                         continue;
-                    if (this.#emittedFilesCacheMap
+                    if (this._emittedFilesCacheMap
                         .get(affectedFile)
                         ?.some((item) => !item.outAbsPath?.endsWith(".css")))
                         continue;
-                    const sf = this.#program.getSourceFile(affectedFile);
+                    const sf = this._program.getSourceFile(affectedFile);
                     if (!sf || sf.isDeclarationFile)
                         continue;
-                    if (this.#ngProgram?.compiler.ignoreForEmit.has(sf))
+                    if (this._ngProgram?.compiler.ignoreForEmit.has(sf))
                         continue;
-                    if (this.#ngProgram?.compiler.incrementalCompilation.safeToSkipEmit(sf))
+                    if (this._ngProgram?.compiler.incrementalCompilation.safeToSkipEmit(sf))
                         continue;
                     // 번들이 아닌 외부패키지는 보통 emit안해도 됨
                     // but esbuild를 통해 bundle로 묶어야 하는놈들은 모든 output이 있어야 함.
                     if (!this._forBundle && !PathUtils.isChildPath(sf.fileName, this._opt.pkgPath)) {
                         continue;
                     }
-                    this.#program.emit(sf, (fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
+                    this._program.emit(sf, (fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
                         if (!sourceFiles || sourceFiles.length === 0) {
                             prepareResult.compilerHost.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
                             return;
                         }
                         const sourceFile = ts.getOriginalNode(sourceFiles[0], ts.isSourceFile);
-                        if (this.#ngProgram) {
-                            if (this.#ngProgram.compiler.ignoreForEmit.has(sourceFile))
+                        if (this._ngProgram) {
+                            if (this._ngProgram.compiler.ignoreForEmit.has(sourceFile))
                                 return;
-                            this.#ngProgram.compiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
+                            this._ngProgram.compiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
                         }
-                        const emitFileInfoCaches = this.#emittedFilesCacheMap.getOrCreate(PathUtils.norm(sourceFile.fileName), []);
+                        const emitFileInfoCaches = this._emittedFilesCacheMap.getOrCreate(PathUtils.norm(sourceFile.fileName), []);
                         if (PathUtils.isChildPath(sourceFile.fileName, this._opt.pkgPath)) {
-                            const real = this.#convertOutputToReal(fileName, prepareResult.tsconfig.distPath, text);
+                            const real = this._convertOutputToReal(fileName, prepareResult.tsconfig.distPath, text);
                             emitFileInfoCaches.push({
                                 outAbsPath: real.filePath,
-                                text: this.#removeOutputDevModeLine(real.text),
+                                text: this._removeOutputDevModeLine(real.text),
                             });
                         }
                         else {
@@ -395,7 +388,7 @@ export class SdTsCompiler {
                         emitFileSet.add(PathUtils.norm(sourceFile.fileName));
                     }, undefined, undefined, transformers);
                 }
-                this.#debug(`파일 출력 완료`);
+                this._debug(`파일 출력 완료`);
             });
         }
         return {
@@ -403,7 +396,7 @@ export class SdTsCompiler {
             diagnostics,
         };
     }
-    #convertOutputToReal(filePath, distPath, text) {
+    _convertOutputToReal(filePath, distPath, text) {
         let realFilePath = PathUtils.norm(filePath);
         let realText = text;
         const srcRelBasePath = path.resolve(distPath, path.basename(this._opt.pkgPath), "src");
@@ -418,10 +411,10 @@ export class SdTsCompiler {
         }
         return { filePath: realFilePath, text: realText };
     }
-    #removeOutputDevModeLine(str) {
+    _removeOutputDevModeLine(str) {
         return str.replace(/\(\(\) => \{ \(typeof ngDevMode === "undefined" \|\| ngDevMode\) && i0.ɵsetClassDebugInfo\(.*, \{ className: ".*", filePath: ".*", lineNumber: [0-9]* }\); }\)\(\);/, "");
     }
-    #debug(...msg) {
-        this.#logger.debug(`[${path.basename(this._opt.pkgPath)}]`, ...msg);
+    _debug(...msg) {
+        this._logger.debug(`[${path.basename(this._opt.pkgPath)}]`, ...msg);
     }
 }

package/dist/utils/SdCliPerformanceTimer.d.ts

@@ -1,6 +1,7 @@
 export declare class SdCliPerformanceTimer {
-    #private;
     private readonly _name;
+    private readonly _startingMap;
+    private readonly _resultMap;
     constructor(_name: string);
     start(name: string): void;
     end(name: string): void;

package/dist/utils/SdCliPerformanceTimer.js

@@ -1,24 +1,24 @@
 export class SdCliPerformanceTimer {
-    #startingMap = new Map();
-    #resultMap = new Map();
     constructor(_name) {
         this._name = _name;
+        this._startingMap = new Map();
+        this._resultMap = new Map();
     }
     start(name) {
-        this.#startingMap.set(name, {
+        this._startingMap.set(name, {
             time: new Date().getTime(),
             cpu: process.cpuUsage(),
         });
     }
     end(name) {
-        const start = this.#startingMap.get(name);
+        const start = this._startingMap.get(name);
         if (start == null)
             throw new Error(`No start record for '${name}'`);
         const time = new Date().getTime() - start.time;
         const cpuUsage = process.cpuUsage(start.cpu);
         const cpu = (cpuUsage.user + cpuUsage.system) / 1000; // μs -> ms
-        this.#resultMap.set(name, { time, cpu });
-        this.#startingMap.delete(name);
+        this._resultMap.set(name, { time, cpu });
+        this._startingMap.delete(name);
     }
     run(name, fn) {
         const startTime = new Date().getTime();
@@ -26,8 +26,8 @@ export class SdCliPerformanceTimer {
         const finish = (res, start) => {
             const duration = new Date().getTime() - start;
             const cpu = (process.cpuUsage(startCpu).user + process.cpuUsage(startCpu).system) / 1000;
-            const prev = this.#resultMap.get(name);
-            this.#resultMap.set(name, {
+            const prev = this._resultMap.get(name);
+            this._resultMap.set(name, {
                 time: (prev?.time ?? 0) + duration,
                 cpu: (prev?.cpu ?? 0) + cpu,
             });
@@ -42,7 +42,7 @@ export class SdCliPerformanceTimer {
     toString() {
         return `${this._name} 성능 보고서
 ------------------------------------
-${Array.from(this.#resultMap.entries())
+${Array.from(this._resultMap.entries())
             .map(([key, val]) => `${key}: ${val.time.toLocaleString()}ms (${val.cpu.toLocaleString()}ms CPU)`)
             .join("\n")}
 ------------------------------------`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-cli",
-  "version": "12.15.39",
+  "version": "12.15.41",
   "description": "심플리즘 패키지 - CLI",
   "author": "김석래",
   "repository": {
@@ -12,18 +12,18 @@
   "bin": "./dist/sd-cli.js",
   "type": "module",
   "dependencies": {
-    "@angular/build": "^20.3.12",
+    "@angular/build": "^20.3.13",
     "@angular/compiler": "^20.3.15",
     "@angular/compiler-cli": "^20.3.15",
     "@anthropic-ai/sdk": "^0.71.0",
     "@electron/rebuild": "^4.0.1",
-    "@simplysm/sd-core-common": "12.15.39",
-    "@simplysm/sd-core-node": "12.15.39",
-    "@simplysm/sd-service-server": "12.15.39",
-    "@simplysm/sd-storage": "12.15.39",
-    "browserslist": "^4.28.0",
+    "@simplysm/sd-core-common": "12.15.41",
+    "@simplysm/sd-core-node": "12.15.41",
+    "@simplysm/sd-service-server": "12.15.41",
+    "@simplysm/sd-storage": "12.15.41",
+    "browserslist": "^4.28.1",
     "cordova": "^13.0.0",
-    "electron": "^39.2.4",
+    "electron": "^39.2.5",
     "electron-builder": "26.0.12",
     "esbuild": "0.25.9",
     "esbuild-sass-plugin": "^3.3.1",