@simplysm/sd-cli 12.16.24 → 13.0.0-beta.11

package/dist/sd-cli-entry.js

@@ -1,230 +0,0 @@
-#!/usr/bin/env node
-/* eslint-disable no-console */
-import { SdLogger, SdLoggerSeverity } from "@simplysm/sd-core-node";
-import { EventEmitter } from "events";
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { SdCliAiCommand } from "./entry/SdCliAiCommand";
-import { SdCliCordova } from "./entry/SdCliCordova";
-import { SdCliElectron } from "./entry/SdCliElectron";
-import { SdCliLocalUpdate } from "./entry/SdCliLocalUpdate";
-import { SdCliPostInstall } from "./entry/SdCliPostInstall";
-import { SdCliProject } from "./entry/SdCliProject";
-import { SdCliCapacitor } from "./entry/SdCliCapacitor";
-Error.stackTraceLimit = Infinity;
-EventEmitter.defaultMaxListeners = 0;
-await yargs(hideBin(process.argv))
-    .help("help", "도움말")
-    .alias("help", "h")
-    .options({
-    debug: {
-        type: "boolean",
-        describe: "디버그 로그를 표시할 것인지 여부",
-        default: false,
-    },
-})
-    .middleware((argv) => {
-    if (argv.debug) {
-        process.env["SD_DEBUG"] = "true";
-        SdLogger.setConfig({
-            console: { level: SdLoggerSeverity.debug },
-        });
-    }
-    else {
-        SdLogger.setConfig({ dot: true });
-    }
-})
-    .command("local-update", "로컬 라이브러리 업데이트를 수행합니다.", (cmd) => cmd
-    .version(false)
-    .hide("help")
-    .hide("debug")
-    .options({
-    config: {
-        string: true,
-        describe: "설정 파일 경로",
-        default: "simplysm.js",
-    },
-    options: {
-        string: true,
-        array: true,
-        describe: "옵션 설정",
-    },
-}), async (argv) => await SdCliLocalUpdate.runAsync(argv))
-    .command("watch", "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.", (cmd) => cmd
-    .version(false)
-    .hide("help")
-    .hide("debug")
-    .options({
-    config: {
-        string: true,
-        describe: "설정 파일 경로",
-        default: "simplysm.js",
-    },
-    options: {
-        string: true,
-        array: true,
-        describe: "옵션 설정",
-    },
-    packages: {
-        string: true,
-        array: true,
-        describe: "수행할 패키지 설정",
-    },
-    emitOnly: {
-        type: "boolean",
-        describe: "emit만 수행",
-        default: false,
-    },
-    noEmit: {
-        type: "boolean",
-        describe: "emit만 수행",
-        default: false,
-    },
-}), async (argv) => await SdCliProject.watchAsync(argv))
-    .command("build", "프로젝트의 각 패키지에 대한 빌드를 수행합니다.", (cmd) => cmd
-    .version(false)
-    .hide("help")
-    .hide("debug")
-    .options({
-    config: {
-        string: true,
-        describe: "설정 파일 경로",
-        default: "simplysm.js",
-    },
-    options: {
-        string: true,
-        array: true,
-        describe: "옵션 설정",
-    },
-    packages: {
-        string: true,
-        array: true,
-        describe: "수행할 패키지 설정",
-    },
-}), async (argv) => {
-    await SdCliProject.buildAsync(argv);
-})
-    .command("publish", "프로젝트의 각 패키지를 배포합니다.", (cmd) => cmd
-    .version(false)
-    .hide("help")
-    .hide("debug")
-    .options({
-    noBuild: {
-        type: "boolean",
-        describe: "빌드를 하지않고 배포합니다.",
-        default: false,
-    },
-    config: {
-        type: "string",
-        describe: "설정 파일 경로",
-        default: "simplysm.js",
-    },
-    options: {
-        type: "string",
-        array: true,
-        describe: "옵션 설정",
-    },
-    packages: {
-        type: "string",
-        array: true,
-        describe: "수행할 패키지 설정",
-    },
-}), async (argv) => {
-    await SdCliProject.publishAsync(argv);
-    process.exit(0);
-})
-    .command("run-electron <package>", "변경감지중인 플랫폼을 ELECTRON 앱 형태로 띄웁니다.", (cmd) => cmd
-    .version(false)
-    .hide("help")
-    .hide("debug")
-    .positional("package", {
-    type: "string",
-    describe: "패키지명",
-    demandOption: true,
-})
-    .options({
-    config: {
-        type: "string",
-        describe: "설정 파일 경로",
-        default: "simplysm.js",
-    },
-    options: {
-        type: "string",
-        array: true,
-        describe: "옵션 설정",
-    },
-}), async (argv) => await SdCliElectron.runAsync(argv))
-    .command("build-electron-for-dev <package>", "변경감지중인 플랫폼을 ELECTRON 앱 형태로 띄웁니다.", (cmd) => cmd
-    .version(false)
-    .hide("help")
-    .hide("debug")
-    .positional("package", {
-    type: "string",
-    describe: "패키지명",
-    demandOption: true,
-})
-    .options({
-    config: {
-        type: "string",
-        describe: "설정 파일 경로",
-        default: "simplysm.js",
-    },
-    options: {
-        type: "string",
-        array: true,
-        describe: "옵션 설정",
-    },
-}), async (argv) => await SdCliElectron.buildForDevAsync(argv))
-    .command("run-cordova <platform> <package> [url]", "변경감지중인 플랫폼을 코도바 디바이스에 앱 형태로 띄웁니다.", (cmd) => cmd
-    .version(false)
-    .hide("help")
-    .hide("debug")
-    .positional("platform", {
-    type: "string",
-    describe: "빌드 플랫폼(android,...)",
-    demandOption: true,
-})
-    .positional("package", {
-    type: "string",
-    describe: "패키지명",
-    demandOption: true,
-})
-    .positional("url", {
-    type: "string",
-    describe: "Webview로 오픈할 URL",
-    demandOption: true,
-}), async (argv) => await SdCliCordova.runWebviewOnDeviceAsync(argv))
-    .command("run-capacitor <platform> <package> [url]", "변경감지중인 플랫폼을 Capacitor 디바이스에 앱 형태로 띄웁니다.", (cmd) => cmd
-    .version(false)
-    .hide("help")
-    .hide("debug")
-    .positional("platform", {
-    type: "string",
-    describe: "빌드 플랫폼(android,...)",
-    demandOption: true,
-})
-    .positional("package", {
-    type: "string",
-    describe: "패키지명",
-    demandOption: true,
-})
-    .positional("url", {
-    type: "string",
-    describe: "Webview로 오픈할 URL",
-    demandOption: true,
-}), async (argv) => await SdCliCapacitor.runWebviewOnDeviceAsync(argv))
-    .command("commit", "AI를 통해 변경사항에 대한 커밋 메시지를 작성하여, 커밋 및 푸쉬를 수행합니다.", (cmd) => cmd.version(false).hide("help").hide("debug"), async () => await SdCliAiCommand.commitAsync())
-    .command("postinstall", "설치후 자동실행할 작업", (cmd) => cmd.version(false).hide("help").hide("debug"), () => SdCliPostInstall.run())
-    .strict()
-    .recommendCommands()
-    .fail((msg, err, cmd) => {
-    if (Boolean(err)) {
-        throw err;
-    }
-    console.error("지원되지 않는 명령입니다.");
-    console.error(msg);
-    console.log("\n명령어 목록:");
-    cmd.showHelp();
-    process.exit(1);
-})
-    .parseAsync();

package/dist/sd-cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

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

@@ -1,7 +0,0 @@
-import { TNormPath } from "@simplysm/sd-core-node";
-export declare class ScopePathSet {
-    private readonly _data;
-    constructor(arrOrSet?: TNormPath[] | Set<TNormPath>);
-    inScope(filePath: string): boolean;
-    toArray(): TNormPath[];
-}

package/dist/ts-compiler/ScopePathSet.js

@@ -1,12 +0,0 @@
-import { PathUtils } from "@simplysm/sd-core-node";
-export class ScopePathSet {
-    constructor(arrOrSet) {
-        this._data = arrOrSet instanceof Set ? arrOrSet : new Set(arrOrSet);
-    }
-    inScope(filePath) {
-        return Array.from(this._data).some((scope) => PathUtils.isChildPath(filePath, scope));
-    }
-    toArray() {
-        return Array.from(this._data);
-    }
-}

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

@@ -1,15 +0,0 @@
-import ts from "typescript";
-import { SdDepCache } from "./SdDepCache";
-import { TNormPath } from "@simplysm/sd-core-node";
-import { NgtscProgram } from "@angular/compiler-cli";
-import { ScopePathSet } from "./ScopePathSet";
-export declare class SdDepAnalyzer {
-    static analyze(program: ts.Program, compilerHost: ts.CompilerHost, scopePathSet: ScopePathSet, cache: {
-        dep: SdDepCache;
-        type: WeakMap<ts.Node, ts.Type | undefined>;
-        prop: WeakMap<ts.Type, Map<string, ts.Symbol | undefined>>;
-        declFiles: WeakMap<ts.Symbol, TNormPath[]>;
-        ngOrg: Map<TNormPath, ts.SourceFile>;
-    }): void;
-    static analyzeAngularResources(ngProgram: NgtscProgram, scopePathSet: ScopePathSet, depCache: SdDepCache): void;
-}

package/dist/ts-compiler/SdDepAnalyzer.js

@@ -1,299 +0,0 @@
-import ts from "typescript";
-import { PathUtils } from "@simplysm/sd-core-node";
-import path from "path";
-export class SdDepAnalyzer {
-    static analyze(program, compilerHost, scopePathSet, cache) {
-        const compilerOpts = program.getCompilerOptions();
-        const typeChecker = program.getTypeChecker();
-        const moduleResolutionCache = compilerHost.getModuleResolutionCache();
-        const resolveModule = (text, base) => {
-            const res = ts.resolveModuleName(text, base, compilerOpts, compilerHost, moduleResolutionCache);
-            if (res.resolvedModule) {
-                return [PathUtils.norm(res.resolvedModule.resolvedFileName)];
-            }
-            const absPath = path.resolve(path.dirname(base), text);
-            if (!scopePathSet.inScope(absPath)) {
-                return [];
-            }
-            else if (
-            // 지원되게할 .png등이면 그냥 가져오고 (bundling  loader에 들어가는것들과 .ts, .json등)
-            // fallback일때는 absPath에 .ts, .d.ts, .js, .json 등 다붙여서 가져와야함
-            [
-                ".ts",
-                ".d.ts",
-                ".js",
-                ".json",
-                ".html",
-                ".scss",
-                ".css",
-                ".png",
-                ".jpeg",
-                ".jpg",
-                ".jfif",
-                ".gif",
-                ".svg",
-                ".woff",
-                ".woff2",
-                ".ttf",
-                ".ttc",
-                ".eot",
-                ".ico",
-                ".otf",
-                ".csv",
-                ".xlsx",
-                ".xls",
-                ".pptx",
-                ".ppt",
-                ".docx",
-                ".doc",
-                ".zip",
-                ".pfx",
-                ".pkl",
-                ".mp3",
-                ".ogg",
-            ].some((ext) => absPath.endsWith(ext))) {
-                return [PathUtils.norm(absPath)];
-            }
-            else {
-                return [
-                    PathUtils.norm(absPath + ".ts"),
-                    PathUtils.norm(absPath + ".js"),
-                    PathUtils.norm(absPath + ".d.ts"),
-                    PathUtils.norm(absPath + ".json"),
-                ];
-            }
-        };
-        const isInImportOrExport = (node) => {
-            const p = node.parent;
-            return (ts.isImportDeclaration(p) ||
-                ts.isExportDeclaration(p) ||
-                ts.isImportSpecifier(p) ||
-                ts.isExportSpecifier(p) ||
-                ts.isNamespaceImport(p));
-        };
-        const isDeclarationIdentifier = (id) => {
-            const p = id.parent;
-            return ((ts.isParameter(p) && p.name === id) ||
-                (ts.isVariableDeclaration(p) && p.name === id) ||
-                (ts.isFunctionDeclaration(p) && p.name === id) ||
-                (ts.isClassDeclaration(p) && p.name === id) ||
-                (ts.isInterfaceDeclaration(p) && p.name === id) ||
-                (ts.isTypeAliasDeclaration(p) && p.name === id) ||
-                (ts.isEnumDeclaration(p) && p.name === id) ||
-                (ts.isPropertySignature(p) && p.name === id) ||
-                (ts.isPropertyDeclaration(p) && p.name === id) ||
-                (ts.isMethodSignature(p) && p.name === id) ||
-                (ts.isMethodDeclaration(p) && p.name === id));
-        };
-        // const typeCache = new WeakMap<ts.Node, ts.Type | undefined>();
-        const getCachedType = (node) => {
-            if (cache.type.has(node))
-                return cache.type.get(node);
-            const type = typeChecker.getTypeAtLocation(node);
-            if (!type)
-                return undefined;
-            const skipMask = ts.TypeFlags.Any |
-                ts.TypeFlags.Unknown |
-                ts.TypeFlags.Never |
-                ts.TypeFlags.Null |
-                ts.TypeFlags.Undefined |
-                ts.TypeFlags.BooleanLike |
-                ts.TypeFlags.NumberLike |
-                ts.TypeFlags.StringLike |
-                ts.TypeFlags.BigIntLike |
-                ts.TypeFlags.ESSymbolLike;
-            const result = (type.flags & skipMask) !== 0 ? undefined : type;
-            cache.type.set(node, result);
-            return result;
-        };
-        // const propCache = new WeakMap<ts.Type, Map<string, ts.Symbol | undefined>>();
-        const getCachedProp = (type, name) => {
-            if (!type)
-                return undefined;
-            let map = cache.prop.get(type);
-            if (!map) {
-                map = new Map();
-                cache.prop.set(type, map);
-            }
-            if (map.has(name))
-                return map.get(name);
-            const s = type.getProperty(name);
-            map.set(name, s);
-            return s;
-        };
-        const getDeclFileNPaths = (sym) => {
-            if (!sym)
-                return [];
-            const c = cache.declFiles.get(sym);
-            if (c)
-                return c;
-            const paths = (sym.getDeclarations() ?? []).map((d) => PathUtils.norm(d.getSourceFile().fileName));
-            cache.declFiles.set(sym, paths);
-            return paths;
-        };
-        const collectDeps = (sf) => {
-            const sfNPath = PathUtils.norm(sf.fileName);
-            if (cache.dep.hasCollected(sfNPath))
-                return;
-            cache.dep.addCollected(sfNPath);
-            if (!scopePathSet.inScope(sfNPath))
-                return;
-            const visit = (node) => {
-                // --- import ... from '...'
-                if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
-                    const resolvedNPaths = resolveModule(node.moduleSpecifier.text, sf.fileName);
-                    for (const resolvedNPath of resolvedNPaths) {
-                        if (!scopePathSet.inScope(resolvedNPath))
-                            continue;
-                        if (node.importClause &&
-                            node.importClause.namedBindings &&
-                            ts.isNamedImports(node.importClause.namedBindings)) {
-                            // import ... from '...'
-                            for (const element of node.importClause.namedBindings.elements) {
-                                cache.dep.addImport(sfNPath, resolvedNPath, element.propertyName?.text ?? element.name.text);
-                            }
-                        }
-                        else {
-                            cache.dep.addImport(sfNPath, resolvedNPath, 0);
-                        }
-                    }
-                    return;
-                }
-                // --- export * from '...'
-                else if (ts.isExportDeclaration(node) &&
-                    !node.exportClause &&
-                    node.moduleSpecifier &&
-                    ts.isStringLiteral(node.moduleSpecifier)) {
-                    const resolvedNPaths = resolveModule(node.moduleSpecifier.text, sf.fileName);
-                    for (const resolvedNPath of resolvedNPaths) {
-                        if (!scopePathSet.inScope(resolvedNPath))
-                            continue;
-                        cache.dep.addReexport(sfNPath, resolvedNPath, 0);
-                    }
-                    return;
-                }
-                // --- export { A as B } from '...'
-                else if (ts.isExportDeclaration(node) &&
-                    node.exportClause &&
-                    ts.isNamedExports(node.exportClause) &&
-                    node.moduleSpecifier &&
-                    ts.isStringLiteral(node.moduleSpecifier)) {
-                    const resolvedNPaths = resolveModule(node.moduleSpecifier.text, sf.fileName);
-                    for (const resolvedNPath of resolvedNPaths) {
-                        if (!scopePathSet.inScope(resolvedNPath))
-                            continue;
-                        for (const element of node.exportClause.elements) {
-                            const local = element.propertyName?.text ?? element.name.text;
-                            const exported = element.name.text;
-                            cache.dep.addReexport(sfNPath, resolvedNPath, {
-                                importSymbol: local,
-                                exportSymbol: exported,
-                            });
-                        }
-                    }
-                    return;
-                }
-                // --- export const A = ...
-                else if (ts.isVariableStatement(node) &&
-                    node.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)) {
-                    for (const decl of node.declarationList.declarations) {
-                        if (ts.isIdentifier(decl.name)) {
-                            cache.dep.addExport(sfNPath, decl.name.text);
-                        }
-                    }
-                }
-                // --- export function/class/interface A ...
-                if ((ts.isFunctionDeclaration(node) ||
-                    ts.isClassDeclaration(node) ||
-                    ts.isInterfaceDeclaration(node) ||
-                    ts.isTypeAliasDeclaration(node) ||
-                    ts.isEnumDeclaration(node)) &&
-                    node.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword) &&
-                    node.name) {
-                    cache.dep.addExport(sfNPath, node.name.text);
-                }
-                else if (ts.isIdentifier(node) &&
-                    isDeclarationIdentifier(node) &&
-                    !isInImportOrExport(node)) {
-                    const orgValSymbol = typeChecker.getSymbolAtLocation(node);
-                    let valSymbol = orgValSymbol;
-                    if (orgValSymbol && orgValSymbol.flags & ts.SymbolFlags.Alias) {
-                        // 현 파일 선언으로 확정되면 굳이 치환 불필요
-                        const declNPaths = getDeclFileNPaths(orgValSymbol);
-                        const external = declNPaths.some((declNPath) => declNPath !== sfNPath);
-                        if (external) {
-                            valSymbol = typeChecker.getAliasedSymbol(orgValSymbol);
-                        }
-                    }
-                    for (const declNPath of getDeclFileNPaths(valSymbol)) {
-                        if (declNPath !== sfNPath && scopePathSet.inScope(declNPath)) {
-                            cache.dep.addImport(sfNPath, declNPath, 0);
-                        }
-                    }
-                }
-                else if (ts.isPropertyAccessExpression(node)) {
-                    const type = getCachedType(node.expression);
-                    const propSymbol = getCachedProp(type, node.name.text);
-                    if (propSymbol) {
-                        for (const declNPath of getDeclFileNPaths(propSymbol)) {
-                            if (declNPath !== sfNPath && scopePathSet.inScope(declNPath)) {
-                                cache.dep.addImport(sfNPath, declNPath, 0);
-                            }
-                        }
-                    }
-                }
-                else if (ts.isElementAccessExpression(node) &&
-                    ts.isStringLiteral(node.argumentExpression)) {
-                    const type = getCachedType(node.expression);
-                    const propSymbol = getCachedProp(type, node.argumentExpression.text);
-                    if (propSymbol) {
-                        for (const declNPath of getDeclFileNPaths(propSymbol)) {
-                            if (declNPath !== sfNPath && scopePathSet.inScope(declNPath)) {
-                                cache.dep.addImport(sfNPath, declNPath, 0);
-                            }
-                        }
-                    }
-                }
-                ts.forEachChild(node, visit);
-            };
-            ts.forEachChild(sf, visit);
-        };
-        const getOrgSourceFile = (sf) => {
-            if (sf.fileName.endsWith(".ngtypecheck.ts")) {
-                const sfNPath = PathUtils.norm(sf.fileName);
-                let org = cache.ngOrg.get(sfNPath);
-                if (!org) {
-                    const orgPath = sf.fileName.slice(0, -15) + ".ts";
-                    org = program.getSourceFile(orgPath) ?? sf;
-                    const realOrg = program.getSourceFile(orgPath);
-                    if (realOrg)
-                        cache.ngOrg.set(sfNPath, realOrg);
-                }
-                return org;
-            }
-            return sf;
-        };
-        const sourceFileSet = new Set(program
-            .getSourceFiles()
-            .filter((sf) => scopePathSet.inScope(sf.fileName))
-            .map((sf) => getOrgSourceFile(sf))
-            .filterExists());
-        for (const sf of sourceFileSet) {
-            collectDeps(sf);
-        }
-    }
-    static analyzeAngularResources(ngProgram, scopePathSet, depCache) {
-        for (const sf of ngProgram.getTsProgram().getSourceFiles()) {
-            const fileNPath = PathUtils.norm(sf.fileName);
-            if (!scopePathSet.inScope(fileNPath))
-                continue;
-            const dependencies = ngProgram.compiler.getResourceDependencies(sf);
-            for (const dep of dependencies) {
-                const depNPath = PathUtils.norm(dep);
-                if (!scopePathSet.inScope(depNPath))
-                    continue;
-                depCache.addImport(fileNPath, depNPath, 0);
-            }
-        }
-    }
-}

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

@@ -1,77 +0,0 @@
-import { TNormPath } from "@simplysm/sd-core-node";
-export declare class SdDepCache {
-    /**
-     * 각 파일이 export한 심볼 집합 (예: export const A → "A")
-     */
-    private readonly _exportCache;
-    /**
-     * import한 타겟과 그 심볼 정보
-     * - 값이 0이면 전체 import(import * 또는 리소스 import)
-     * - 값이 Set이면 선택적 심볼 import (예: import { A } ...)
-     */
-    private readonly _importCache;
-    /**
-     * re-export한 타겟과 그 심볼 정보
-     * - export * from ...
-     * - export { A as B } from ...
-     * - 값이 0이면 전체 reexport(export * from ...)
-     */
-    private readonly _reexportCache;
-    /**
-     * 역의존 정보 (revDep)
-     * - 특정 파일이 어떤 파일에게 의존(참조)되는지
-     * - symbol 기반 추적
-     */
-    private readonly _revDepCache;
-    /**
-     * 분석이 완료된 파일 경로
-     */
-    private readonly _collectedCache;
-    private readonly _exportSymbolCache;
-    /**
-     * .d.ts 또는 .js가 입력되었을 때 쌍으로 존재하는 파일 경로를 반환
-     * 예: "/a.d.ts" → ["/a.d.ts", "/a.js"]
-     */
-    private _getRelatedNPaths;
-    /**
-     * 분석이 완료된 파일로 표시
-     */
-    addCollected(fileNPath: TNormPath): void;
-    hasCollected(fileNPath: TNormPath): boolean;
-    /**
-     * export한 심볼 등록
-     * 예: export const A → "A"
-     */
-    addExport(fileNPath: TNormPath, exportSymbol: string): void;
-    /**
-     * import 구문 등록
-     * - import * from ... → symbol = 0
-     * - import { A } from ... → symbol = "A"
-     */
-    addImport(fileNPath: TNormPath, targetNPath: TNormPath, targetSymbol: string | 0): void;
-    /**
-     * export * or export { A as B } from ... 구문 등록
-     * ※ export/import에 자동 등록되지 않으므로 외부에서 명시적으로 따로 입력해야 함
-     */
-    addReexport(fileNPath: TNormPath, targetNPath: TNormPath, targetSymbolInfo: {
-        importSymbol: string;
-        exportSymbol: string;
-    } | 0): void;
-    /**
-     * 역의존 관계 등록 (revDep)
-     */
-    private _addRevDep;
-    getAffectedFileMap(modifiedNPathSet: Set<TNormPath>): Map<TNormPath, Set<TNormPath>>;
-    /**
-     * 주어진 파일들 및 그 영향 범위에 해당하는 모든 캐시를 무효화
-     */
-    invalidates(fileNPathSet: Set<TNormPath>): void;
-    /**
-     * reexport된 경우 importSymbol → exportSymbol로 변환
-     */
-    private _convertImportSymbolToExportSymbol;
-    /**
-     * 해당 파일에서 export된 모든 심볼 (직접 + 재export 포함)
-     */
-    private _getExportSymbols;
-}