@simplysm/sd-cli 12.15.39 → 12.15.41

package/dist/ts-compiler/SdDepCache.js

@@ -1,37 +1,39 @@
 export class SdDepCache {
-    /**
-     * 각 파일이 export한 심볼 집합 (예: export const A → "A")
-     */
-    #exportCache = new Map();
-    /**
-     * import한 타겟과 그 심볼 정보
-     * - 값이 0이면 전체 import(import * 또는 리소스 import)
-     * - 값이 Set이면 선택적 심볼 import (예: import { A } ...)
-     */
-    #importCache = new Map();
-    /**
-     * re-export한 타겟과 그 심볼 정보
-     * - export * from ...
-     * - export { A as B } from ...
-     * - 값이 0이면 전체 reexport(export * from ...)
-     */
-    #reexportCache = new Map();
-    /**
-     * 역의존 정보 (revDep)
-     * - 특정 파일이 어떤 파일에게 의존(참조)되는지
-     * - symbol 기반 추적
-     */
-    #revDepCache = new Map();
-    /**
-     * 분석이 완료된 파일 경로
-     */
-    #collectedCache = new Set();
-    #exportSymbolCache = new Map();
+    constructor() {
+        /**
+         * 각 파일이 export한 심볼 집합 (예: export const A → "A")
+         */
+        this._exportCache = new Map();
+        /**
+         * import한 타겟과 그 심볼 정보
+         * - 값이 0이면 전체 import(import * 또는 리소스 import)
+         * - 값이 Set이면 선택적 심볼 import (예: import { A } ...)
+         */
+        this._importCache = new Map();
+        /**
+         * re-export한 타겟과 그 심볼 정보
+         * - export * from ...
+         * - export { A as B } from ...
+         * - 값이 0이면 전체 reexport(export * from ...)
+         */
+        this._reexportCache = new Map();
+        /**
+         * 역의존 정보 (revDep)
+         * - 특정 파일이 어떤 파일에게 의존(참조)되는지
+         * - symbol 기반 추적
+         */
+        this._revDepCache = new Map();
+        /**
+         * 분석이 완료된 파일 경로
+         */
+        this._collectedCache = new Set();
+        this._exportSymbolCache = new Map();
+    }
     /**
      * .d.ts 또는 .js가 입력되었을 때 쌍으로 존재하는 파일 경로를 반환
      * 예: "/a.d.ts" → ["/a.d.ts", "/a.js"]
      */
-    #getRelatedNPaths(nPath) {
+    _getRelatedNPaths(nPath) {
         if (nPath.endsWith(".d.ts")) {
             return [nPath, nPath.replace(/\.d\.ts$/, ".js")];
         }
@@ -44,20 +46,20 @@ export class SdDepCache {
      * 분석이 완료된 파일로 표시
      */
     addCollected(fileNPath) {
-        for (const path of this.#getRelatedNPaths(fileNPath)) {
-            this.#collectedCache.add(path);
+        for (const path of this._getRelatedNPaths(fileNPath)) {
+            this._collectedCache.add(path);
         }
     }
     hasCollected(fileNPath) {
-        return this.#collectedCache.has(fileNPath);
+        return this._collectedCache.has(fileNPath);
     }
     /**
      * export한 심볼 등록
      * 예: export const A → "A"
      */
     addExport(fileNPath, exportSymbol) {
-        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);
         }
     }
@@ -67,19 +69,19 @@ export class SdDepCache {
      * - import { A } from ... → symbol = "A"
      */
     addImport(fileNPath, targetNPath, targetSymbol) {
-        for (const filePath of this.#getRelatedNPaths(fileNPath)) {
-            const importTargetMap = this.#importCache.getOrCreate(filePath, new Map());
-            for (const targetPath of this.#getRelatedNPaths(targetNPath)) {
+        for (const filePath of this._getRelatedNPaths(fileNPath)) {
+            const importTargetMap = this._importCache.getOrCreate(filePath, new Map());
+            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);
                 }
             }
         }
@@ -89,12 +91,12 @@ export class SdDepCache {
      * ※ export/import에 자동 등록되지 않으므로 외부에서 명시적으로 따로 입력해야 함
      */
     addReexport(fileNPath, targetNPath, targetSymbolInfo) {
-        for (const filePath of this.#getRelatedNPaths(fileNPath)) {
-            const reexportTargetMap = this.#reexportCache.getOrCreate(filePath, new Map());
-            for (const targetPath of this.#getRelatedNPaths(targetNPath)) {
+        for (const filePath of this._getRelatedNPaths(fileNPath)) {
+            const reexportTargetMap = this._reexportCache.getOrCreate(filePath, new Map());
+            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, []);
@@ -103,7 +105,7 @@ export class SdDepCache {
                     if (!reexportTargetSymbolInfos.some((item) => item.importSymbol === targetSymbolInfo.importSymbol &&
                         item.exportSymbol === targetSymbolInfo.exportSymbol)) {
                         reexportTargetSymbolInfos.push(targetSymbolInfo);
-                        this.#addRevDep(targetPath, filePath, targetSymbolInfo.importSymbol);
+                        this._addRevDep(targetPath, filePath, targetSymbolInfo.importSymbol);
                     }
                 }
             }
@@ -112,10 +114,10 @@ export class SdDepCache {
     /**
      * 역의존 관계 등록 (revDep)
      */
-    #addRevDep(targetNPath, fileNPath, exportSymbol) {
-        for (const targetPath of this.#getRelatedNPaths(targetNPath)) {
-            const revDepInfoMap = this.#revDepCache.getOrCreate(targetPath, new Map());
-            for (const filePath of this.#getRelatedNPaths(fileNPath)) {
+    _addRevDep(targetNPath, fileNPath, exportSymbol) {
+        for (const targetPath of this._getRelatedNPaths(targetNPath)) {
+            const revDepInfoMap = this._revDepCache.getOrCreate(targetPath, new Map());
+            for (const filePath of this._getRelatedNPaths(fileNPath)) {
                 if (typeof exportSymbol === "string") {
                     const exportSymbolSet = revDepInfoMap.getOrCreate(filePath, new Set());
                     if (!(exportSymbolSet instanceof Set))
@@ -141,9 +143,9 @@ export class SdDepCache {
                     queue.push({ fileNPath, exportSymbol });
                 }
             };
-            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);
                 }
@@ -155,7 +157,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) {
@@ -163,7 +165,7 @@ export class SdDepCache {
                         const hasImportSymbol = revDepInfo === 0 || revDepInfo.has(curr.exportSymbol);
                         if (hasImportSymbol) {
                             result.add(revDepFileNPath);
-                            const exportSymbol = this.#convertImportSymbolToExportSymbol(revDepFileNPath, curr.fileNPath, curr.exportSymbol);
+                            const exportSymbol = this._convertImportSymbolToExportSymbol(revDepFileNPath, curr.fileNPath, curr.exportSymbol);
                             enqueue(revDepFileNPath, exportSymbol);
                         }
                     }
@@ -182,17 +184,17 @@ export class SdDepCache {
     invalidates(fileNPathSet) {
         // 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인 경우
             // revDepCacheChanged.add(fileNPath);
             // }
         }
-        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);
@@ -200,15 +202,15 @@ export class SdDepCache {
                 }
             }
             if (infoMap.size === 0) {
-                this.#revDepCache.delete(targetNPath);
+                this._revDepCache.delete(targetNPath);
             }
         }
     }
     /**
      * reexport된 경우 importSymbol → exportSymbol로 변환
      */
-    #convertImportSymbolToExportSymbol(fileNPath, targetNPath, importSymbol) {
-        const symbolInfos = this.#reexportCache.get(fileNPath)?.get(targetNPath);
+    _convertImportSymbolToExportSymbol(fileNPath, targetNPath, importSymbol) {
+        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)
@@ -219,20 +221,20 @@ export class SdDepCache {
     /**
      * 해당 파일에서 export된 모든 심볼 (직접 + 재export 포함)
      */
-    #getExportSymbols(fileNPath) {
-        if (this.#exportSymbolCache.has(fileNPath)) {
-            return this.#exportSymbolCache.get(fileNPath);
+    _getExportSymbols(fileNPath) {
+        if (this._exportSymbolCache.has(fileNPath)) {
+            return this._exportSymbolCache.get(fileNPath);
         }
         const result = new Set();
-        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));
@@ -240,7 +242,7 @@ export class SdDepCache {
                 }
             }
         }
-        this.#exportSymbolCache.set(fileNPath, result);
+        this._exportSymbolCache.set(fileNPath, result);
         return result;
     }
 }

package/dist/ts-compiler/SdStyleBundler.d.ts

@@ -2,8 +2,11 @@ import { TNormPath } from "@simplysm/sd-core-node";
 import { TStylesheetBundlingResult } from "../types/build/TStylesheetBundlingResult";
 import { ScopePathSet } from "./ScopePathSet";
 export declare class SdStyleBundler {
-    #private;
     private readonly _opt;
+    private readonly _ngStyleBundler;
+    private readonly _resultCache;
+    private readonly _refCache;
+    private readonly _revRefCache;
     constructor(_opt: {
         pkgPath: TNormPath;
         scopePathSet: ScopePathSet;
@@ -14,6 +17,7 @@ export declare class SdStyleBundler {
         cached: boolean;
     }>;
     invalidate(modifiedNPathSet: Set<TNormPath>): Set<TNormPath>;
+    private _addReference;
     getAllStyleFileSet(): Set<TNormPath>;
     getAffectedFileSet(modifiedNPathSet: Set<TNormPath>): Set<TNormPath>;
 }

package/dist/ts-compiler/SdStyleBundler.js

@@ -4,13 +4,12 @@ import { transformSupportedBrowsersToTargets } from "@angular/build/src/tools/es
 import browserslist from "browserslist";
 import path from "path";
 export class SdStyleBundler {
-    #ngStyleBundler;
-    #resultCache = new Map();
-    #refCache = new Map();
-    #revRefCache = new Map();
     constructor(_opt) {
         this._opt = _opt;
-        this.#ngStyleBundler = new ComponentStylesheetBundler({
+        this._resultCache = new Map();
+        this._refCache = new Map();
+        this._revRefCache = new Map();
+        this._ngStyleBundler = new ComponentStylesheetBundler({
             workspaceRoot: this._opt.pkgPath,
             inlineFonts: !this._opt.dev,
             optimization: !this._opt.dev,
@@ -37,31 +36,31 @@ export class SdStyleBundler {
         }, "scss", this._opt.dev);
     }
     getResultCache() {
-        return this.#resultCache;
+        return this._resultCache;
     }
     async bundleAsync(data, containingFile, resourceFile = null) {
         // containingFile: 포함된 파일 (.ts 혹은 global style.scss)
         // resourceFile: 외부 리소스 파일 (styleUrls로 입력하지 않고 styles에 직접 입력한 경우 null)
         // referencedFiles: import한 외부 scss 파일 혹은 woff파일등 외부 파일
         const fileNPath = PathUtils.norm(resourceFile ?? containingFile);
-        if (this.#resultCache.has(fileNPath)) {
+        if (this._resultCache.has(fileNPath)) {
             return {
-                ...this.#resultCache.get(fileNPath),
+                ...this._resultCache.get(fileNPath),
                 cached: true,
             };
         }
         try {
             const result = resourceFile != null
-                ? await this.#ngStyleBundler.bundleFile(resourceFile)
-                : await this.#ngStyleBundler.bundleInline(data, containingFile, "scss");
+                ? await this._ngStyleBundler.bundleFile(resourceFile)
+                : await this._ngStyleBundler.bundleInline(data, containingFile, "scss");
             for (const referencedFile of result.referencedFiles ?? []) {
                 if (!this._opt.scopePathSet.inScope(fileNPath) ||
                     !this._opt.scopePathSet.inScope(PathUtils.norm(referencedFile)))
                     continue;
                 // 참조하는 파일과 참조된 파일 사이의 의존성 관계 추가
-                this.#addReference(fileNPath, PathUtils.norm(referencedFile));
+                this._addReference(fileNPath, PathUtils.norm(referencedFile));
             }
-            this.#resultCache.set(fileNPath, result);
+            this._resultCache.set(fileNPath, result);
             return { ...result, cached: false };
         }
         catch (err) {
@@ -74,45 +73,45 @@ export class SdStyleBundler {
                 ],
                 warnings: [],
             };
-            this.#resultCache.set(fileNPath, result);
+            this._resultCache.set(fileNPath, result);
             return { ...result, cached: false };
         }
     }
     invalidate(modifiedNPathSet) {
         const affectedFileSet = this.getAffectedFileSet(modifiedNPathSet);
-        this.#ngStyleBundler.invalidate(affectedFileSet);
+        this._ngStyleBundler.invalidate(affectedFileSet);
         for (const fileNPath of affectedFileSet) {
-            this.#resultCache.delete(fileNPath);
+            this._resultCache.delete(fileNPath);
         }
         // revRefCache/refCache
         const targetSet = new Set();
         for (const fileNPath of affectedFileSet) {
-            targetSet.adds(...(this.#refCache.get(fileNPath) ?? []));
+            targetSet.adds(...(this._refCache.get(fileNPath) ?? []));
         }
         for (const target of [...targetSet]) {
-            const source = this.#revRefCache.get(target);
+            const source = this._revRefCache.get(target);
             if (source == null)
                 continue;
             for (const affectedFile of affectedFileSet) {
                 source.delete(affectedFile);
             }
             if (source.size === 0) {
-                this.#revRefCache.delete(target);
+                this._revRefCache.delete(target);
             }
-            this.#refCache.delete(target);
+            this._refCache.delete(target);
         }
         return affectedFileSet;
     }
-    #addReference(fileNPath, referencedFile) {
+    _addReference(fileNPath, referencedFile) {
         if (fileNPath === referencedFile)
             return;
-        this.#refCache.getOrCreate(fileNPath, new Set()).add(referencedFile);
-        this.#revRefCache.getOrCreate(referencedFile, new Set()).add(fileNPath);
+        this._refCache.getOrCreate(fileNPath, new Set()).add(referencedFile);
+        this._revRefCache.getOrCreate(referencedFile, new Set()).add(fileNPath);
     }
     getAllStyleFileSet() {
         return new Set([
-            ...this.#revRefCache.keys(),
-            ...Array.from(this.#revRefCache.values()).mapMany((item) => Array.from(item)),
+            ...this._revRefCache.keys(),
+            ...Array.from(this._revRefCache.values()).mapMany((item) => Array.from(item)),
         ]);
     }
     getAffectedFileSet(modifiedNPathSet) {
@@ -120,12 +119,12 @@ export class SdStyleBundler {
         // 수정파일중 Result에 있는것
         const modifiedResultFiles = Array.from(modifiedNPathSet)
             // .filter((item) => item.endsWith(".scss"))
-            .filter((item) => this.#resultCache.has(item));
+            .filter((item) => this._resultCache.has(item));
         affectedFileSet.adds(...modifiedResultFiles);
         // 수정파일을 사용하는 파일
         const modifiedScssFiles = Array.from(modifiedNPathSet).filter((item) => item.endsWith(".scss"));
         for (const modifiedScss of modifiedScssFiles) {
-            affectedFileSet.adds(...(this.#revRefCache.get(modifiedScss) ?? []));
+            affectedFileSet.adds(...(this._revRefCache.get(modifiedScss) ?? []));
         }
         return affectedFileSet;
     }

package/dist/ts-compiler/SdTsCompiler.d.ts

@@ -2,9 +2,28 @@ import { TNormPath } from "@simplysm/sd-core-node";
 import { ISdTsCompilerOptions } from "../types/build/ISdTsCompilerOptions";
 import { ISdTsCompilerResult } from "../types/build/ISdTsCompilerResult";
 export declare class SdTsCompiler {
-    #private;
     private readonly _opt;
     private readonly _forBundle;
+    private readonly _logger;
+    private readonly _isForAngular;
+    private readonly _scopePathSet;
+    private readonly _styleBundler;
+    private _moduleResolutionCache;
+    private _ngProgram;
+    private _program;
+    private readonly _cache;
+    private readonly _sourceFileCacheMap;
+    private readonly _emittedFilesCacheMap;
+    private _perf;
     constructor(_opt: ISdTsCompilerOptions, _forBundle: boolean);
+    private _parseTsConfig;
+    private _createCompilerHost;
     compileAsync(modifiedFileSet: Set<TNormPath>): Promise<ISdTsCompilerResult>;
+    private _prepareAsync;
+    private _lintAsync;
+    private _buildGlobalStyleAsync;
+    private _build;
+    private _convertOutputToReal;
+    private _removeOutputDevModeLine;
+    private _debug;
 }