@simplysm/sd-cli 12.16.27 → 13.0.0-beta.12

package/dist/ts-compiler/SdDepCache.js

@@ -1,248 +0,0 @@
-export class SdDepCache {
-    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) {
-        if (nPath.endsWith(".d.ts")) {
-            return [nPath, nPath.replace(/\.d\.ts$/, ".js")];
-        }
-        if (nPath.endsWith(".js")) {
-            return [nPath, nPath.replace(/\.js$/, ".d.ts")];
-        }
-        return [nPath];
-    }
-    /**
-     * 분석이 완료된 파일로 표시
-     */
-    addCollected(fileNPath) {
-        for (const path of this._getRelatedNPaths(fileNPath)) {
-            this._collectedCache.add(path);
-        }
-    }
-    hasCollected(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());
-            exportSymbolSet.add(exportSymbol);
-        }
-    }
-    /**
-     * import 구문 등록
-     * - import * from ... → symbol = 0
-     * - 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)) {
-                if (typeof targetSymbol === "string") {
-                    const importTargetSymbolSet = importTargetMap.getOrCreate(targetPath, new Set());
-                    if (!(importTargetSymbolSet instanceof Set))
-                        continue;
-                    importTargetSymbolSet.add(targetSymbol);
-                    this._addRevDep(targetPath, filePath, targetSymbol);
-                }
-                else {
-                    importTargetMap.set(targetPath, targetSymbol);
-                    this._addRevDep(targetPath, filePath, targetSymbol);
-                }
-            }
-        }
-    }
-    /**
-     * export * or export { A as B } from ... 구문 등록
-     * ※ 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)) {
-                if (targetSymbolInfo === 0) {
-                    reexportTargetMap.set(targetPath, 0);
-                    this._addRevDep(targetPath, filePath, 0);
-                }
-                else {
-                    const reexportTargetSymbolInfos = reexportTargetMap.getOrCreate(targetPath, []);
-                    if (reexportTargetSymbolInfos === 0)
-                        return;
-                    if (!reexportTargetSymbolInfos.some((item) => item.importSymbol === targetSymbolInfo.importSymbol &&
-                        item.exportSymbol === targetSymbolInfo.exportSymbol)) {
-                        reexportTargetSymbolInfos.push(targetSymbolInfo);
-                        this._addRevDep(targetPath, filePath, targetSymbolInfo.importSymbol);
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * 역의존 관계 등록 (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)) {
-                if (typeof exportSymbol === "string") {
-                    const exportSymbolSet = revDepInfoMap.getOrCreate(filePath, new Set());
-                    if (!(exportSymbolSet instanceof Set))
-                        continue;
-                    exportSymbolSet.add(exportSymbol);
-                }
-                else {
-                    revDepInfoMap.set(filePath, exportSymbol);
-                }
-            }
-        }
-    }
-    getAffectedFileMap(modifiedNPathSet) {
-        const resultMap = new Map();
-        for (const modifiedNPath of modifiedNPathSet) {
-            const visited = new Set();
-            const result = new Set();
-            const queue = [];
-            const enqueue = (fileNPath, exportSymbol) => {
-                const key = `${fileNPath}#${exportSymbol}`;
-                if (!visited.has(key)) {
-                    visited.add(key);
-                    queue.push({ fileNPath, exportSymbol });
-                }
-            };
-            for (const relatedNPath of this._getRelatedNPaths(modifiedNPath)) {
-                result.add(relatedNPath);
-                const exportSymbols = this._getExportSymbols(relatedNPath);
-                if (exportSymbols.size === 0) {
-                    enqueue(relatedNPath, undefined);
-                }
-                else {
-                    for (const symbol of exportSymbols) {
-                        enqueue(relatedNPath, symbol);
-                    }
-                }
-            }
-            while (queue.length > 0) {
-                const curr = queue.shift();
-                const revDepInfoMap = this._revDepCache.get(curr.fileNPath);
-                if (!revDepInfoMap)
-                    continue;
-                for (const [revDepFileNPath, revDepInfo] of revDepInfoMap) {
-                    if (curr.exportSymbol != null) {
-                        const hasImportSymbol = revDepInfo === 0 || revDepInfo.has(curr.exportSymbol);
-                        if (hasImportSymbol) {
-                            result.add(revDepFileNPath);
-                            const exportSymbol = this._convertImportSymbolToExportSymbol(revDepFileNPath, curr.fileNPath, curr.exportSymbol);
-                            enqueue(revDepFileNPath, exportSymbol);
-                        }
-                    }
-                    else {
-                        result.add(revDepFileNPath);
-                    }
-                }
-            }
-            resultMap.set(modifiedNPath, result);
-        }
-        return resultMap;
-    }
-    /**
-     * 주어진 파일들 및 그 영향 범위에 해당하는 모든 캐시를 무효화
-     */
-    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);
-            // if (this.#revDepCache.has(fileNPath)) {
-            //   this.#revDepCache.delete(fileNPath); // 자신이 key인 경우
-            // revDepCacheChanged.add(fileNPath);
-            // }
-        }
-        for (const [targetNPath, infoMap] of this._revDepCache) {
-            for (const fileNPath of fileNPathSet) {
-                if (infoMap.has(fileNPath)) {
-                    infoMap.delete(fileNPath);
-                    // revDepCacheChanged.add(targetNPath);
-                }
-            }
-            if (infoMap.size === 0) {
-                this._revDepCache.delete(targetNPath);
-            }
-        }
-    }
-    /**
-     * reexport된 경우 importSymbol → exportSymbol로 변환
-     */
-    _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)
-                return symbolInfo.exportSymbol;
-        }
-        return importSymbol;
-    }
-    /**
-     * 해당 파일에서 export된 모든 심볼 (직접 + 재export 포함)
-     */
-    _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);
-            if (set)
-                result.adds(...set);
-            const map = this._reexportCache.get(path);
-            if (map) {
-                for (const [key, val] of map) {
-                    if (val === 0) {
-                        result.adds(...this._getExportSymbols(key));
-                    }
-                    else {
-                        result.adds(...val.map((item) => item.exportSymbol));
-                    }
-                }
-            }
-        }
-        this._exportSymbolCache.set(fileNPath, result);
-        return result;
-    }
-}

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

@@ -1,23 +0,0 @@
-import { TNormPath } from "@simplysm/sd-core-node";
-import { TStylesheetBundlingResult } from "../types/build/TStylesheetBundlingResult";
-import { ScopePathSet } from "./ScopePathSet";
-export declare class SdStyleBundler {
-    private readonly _opt;
-    private readonly _ngStyleBundler;
-    private readonly _resultCache;
-    private readonly _refCache;
-    private readonly _revRefCache;
-    constructor(_opt: {
-        pkgPath: TNormPath;
-        scopePathSet: ScopePathSet;
-        dev: boolean;
-    });
-    getResultCache(): Map<TNormPath, TStylesheetBundlingResult>;
-    bundleAsync(data: string, containingFile: TNormPath, resourceFile?: TNormPath | null): Promise<TStylesheetBundlingResult & {
-        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

@@ -1,131 +0,0 @@
-import { PathUtils } from "@simplysm/sd-core-node";
-import { ComponentStylesheetBundler } from "@angular/build/src/tools/esbuild/angular/component-stylesheets";
-import { transformSupportedBrowsersToTargets } from "@angular/build/src/tools/esbuild/utils";
-import browserslist from "browserslist";
-import path from "path";
-export class SdStyleBundler {
-    constructor(_opt) {
-        this._opt = _opt;
-        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,
-            sourcemap: this._opt.dev ? "inline" : false,
-            sourcesContent: this._opt.dev,
-            outputNames: { bundles: "[name]-[hash]", media: "media/[name]-[hash]" },
-            includePaths: [],
-            sass: {
-                fatalDeprecations: undefined,
-                silenceDeprecations: undefined,
-                futureDeprecations: undefined,
-            },
-            externalDependencies: [],
-            target: transformSupportedBrowsersToTargets(browserslist(["Chrome > 78"])),
-            preserveSymlinks: false,
-            tailwindConfiguration: undefined,
-            postcssConfiguration: undefined,
-            cacheOptions: {
-                enabled: true,
-                basePath: path.resolve(this._opt.pkgPath, ".cache"),
-                path: path.resolve(this._opt.pkgPath, ".cache/angular"),
-            },
-            publicPath: undefined,
-        }, "scss", this._opt.dev);
-    }
-    getResultCache() {
-        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)) {
-            return {
-                ...this._resultCache.get(fileNPath),
-                cached: true,
-            };
-        }
-        try {
-            const result = resourceFile != null
-                ? 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._resultCache.set(fileNPath, result);
-            return { ...result, cached: false };
-        }
-        catch (err) {
-            const result = {
-                errors: [
-                    {
-                        text: `스타일 번들링 실패: ${err.message ?? "알 수 없는 오류"}`,
-                        location: { file: containingFile },
-                    },
-                ],
-                warnings: [],
-            };
-            this._resultCache.set(fileNPath, result);
-            return { ...result, cached: false };
-        }
-    }
-    invalidate(modifiedNPathSet) {
-        const affectedFileSet = this.getAffectedFileSet(modifiedNPathSet);
-        this._ngStyleBundler.invalidate(affectedFileSet);
-        for (const fileNPath of affectedFileSet) {
-            this._resultCache.delete(fileNPath);
-        }
-        // revRefCache/refCache
-        const targetSet = new Set();
-        for (const fileNPath of affectedFileSet) {
-            targetSet.adds(...(this._refCache.get(fileNPath) ?? []));
-        }
-        for (const target of [...targetSet]) {
-            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._refCache.delete(target);
-        }
-        return affectedFileSet;
-    }
-    _addReference(fileNPath, referencedFile) {
-        if (fileNPath === referencedFile)
-            return;
-        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)),
-        ]);
-    }
-    getAffectedFileSet(modifiedNPathSet) {
-        const affectedFileSet = new Set();
-        // 수정파일중 Result에 있는것
-        const modifiedResultFiles = Array.from(modifiedNPathSet)
-            // .filter((item) => item.endsWith(".scss"))
-            .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) ?? []));
-        }
-        return affectedFileSet;
-    }
-}

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

@@ -1,29 +0,0 @@
-import { TNormPath } from "@simplysm/sd-core-node";
-import { ISdTsCompilerOptions } from "../types/build/ISdTsCompilerOptions";
-import { ISdTsCompilerResult } from "../types/build/ISdTsCompilerResult";
-export declare class SdTsCompiler {
-    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;
-}