@simplysm/sd-cli 6.4.5 → 7.0.9

package/dist/commons.d.ts

@@ -0,0 +1,46 @@
+export interface INpmConfig {
+    name: string;
+    version: string;
+    workspaces?: string[];
+    es2020?: string;
+    browser?: string;
+    module?: string;
+    main?: string;
+    exports?: Record<string, {
+        types?: string;
+    }>;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+}
+export interface ITsconfig {
+    compilerOptions?: {
+        outDir?: string;
+        baseUrl?: string;
+        paths?: Record<string, string[]>;
+    };
+}
+export interface ISdCliPackageBuildResult {
+    filePath: string | undefined;
+    line: number | undefined;
+    char: number | undefined;
+    code: string | undefined;
+    severity: "error" | "warning";
+    message: string;
+}
+export interface ISdCliConfig {
+    packages: Record<string, TSdCliPackageConfig | undefined>;
+}
+export declare type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig;
+export interface ISdCliLibPackageConfig {
+    type: "library";
+    publish?: "npm";
+}
+export interface ISdCliNgLibPackageConfig {
+    type: "angular";
+}
+export interface ISdCliServerPackageConfig {
+    type: "server";
+}

package/dist/commons.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jb21tb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/entry-points/SdCliWorkspace.d.ts

@@ -0,0 +1,18 @@
+export declare class SdCliWorkspace {
+    private readonly _rootPath;
+    private readonly _configFilePath?;
+    private readonly _logger;
+    private readonly _npmConfig;
+    private readonly _config;
+    constructor(_rootPath: string, _configFilePath?: string | undefined);
+    watchAsync(): Promise<void>;
+    buildAsync(): Promise<void>;
+    private _buildPkgsAsync;
+    publishAsync(opt: {
+        noBuild: boolean;
+    }): Promise<void>;
+    private _upgradeVersionAsync;
+    private _waitSecMessageAsync;
+    private _getPackagesAsync;
+    private _loggingResults;
+}

package/dist/entry-points/SdCliWorkspace.mjs

@@ -0,0 +1,193 @@
+import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
+import path from "path";
+import { SdCliPackage } from "../packages/SdCliPackage";
+import { Wait } from "@simplysm/sd-core-common";
+import os from "os";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
+import semver from "semver/preload";
+export class SdCliWorkspace {
+    constructor(_rootPath, _configFilePath) {
+        this._rootPath = _rootPath;
+        this._configFilePath = _configFilePath;
+        this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+        const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+        this._npmConfig = FsUtil.readJson(npmConfigFilePath);
+        this._config = FsUtil.readJson(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"));
+    }
+    async watchAsync() {
+        this._logger.debug("패키지 목록 구성...");
+        const pkgs = await this._getPackagesAsync();
+        this._logger.debug("패키지 이벤트 설정...");
+        let changeCount = 0;
+        const totalResultMap = new Map();
+        for (const pkg of pkgs) {
+            pkg
+                .on("change", () => {
+                if (changeCount === 0) {
+                    this._logger.log("빌드를 시작합니다...");
+                }
+                changeCount++;
+                this._logger.debug(`[${pkg.name}] 빌드를 시작합니다...`);
+            })
+                .on("complete", (results) => {
+                this._logger.debug(`[${pkg.name}] 빌드가 완료되었습니다.`);
+                totalResultMap.set(pkg.name, results);
+                setTimeout(() => {
+                    changeCount--;
+                    if (changeCount === 0) {
+                        this._loggingResults(totalResultMap);
+                        this._logger.info("모든 빌드가 완료되었습니다.");
+                    }
+                }, 500);
+            });
+        }
+        this._logger.debug("빌드를 시작합니다...");
+        const pkgNames = pkgs.map((item) => item.name);
+        const buildCompletedPackageNames = [];
+        await pkgs.parallelAsync(async (pkg) => {
+            await Wait.until(() => !pkg.allDependencies.some((dep) => pkgNames.includes(dep) && !buildCompletedPackageNames.includes(dep)));
+            await pkg.watchAsync();
+            buildCompletedPackageNames.push(pkg.name);
+        });
+    }
+    async buildAsync() {
+        this._logger.debug("패키지 목록 구성...");
+        const pkgs = await this._getPackagesAsync();
+        this._logger.debug("프로젝트 및 패키지 버전 설정...");
+        await this._upgradeVersionAsync(pkgs);
+        // 빌드
+        await this._buildPkgsAsync(pkgs);
+    }
+    async _buildPkgsAsync(pkgs) {
+        this._logger.debug("빌드를 시작합니다...");
+        const pkgNames = pkgs.map((item) => item.name);
+        const buildCompletedPackageNames = [];
+        const totalResultMap = new Map();
+        await pkgs.parallelAsync(async (pkg) => {
+            await Wait.until(() => !pkg.allDependencies.some((dep) => pkgNames.includes(dep) && !buildCompletedPackageNames.includes(dep)));
+            this._logger.debug(`[${pkg.name}] 빌드를 시작합니다...`);
+            totalResultMap.set(pkg.name, await pkg.buildAsync());
+            this._logger.debug(`[${pkg.name}] 빌드가 완료되었습니다.`);
+            buildCompletedPackageNames.push(pkg.name);
+        });
+        this._loggingResults(totalResultMap);
+        if (Array.from(totalResultMap.values()).mapMany().some((item) => item.severity === "error")) {
+            throw new Error("빌드중 오류가 발생하였습니다.");
+        }
+        else {
+            this._logger.info("모든 빌드가 완료되었습니다.");
+        }
+    }
+    async publishAsync(opt) {
+        if (opt.noBuild) {
+            this._logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
+            await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
+        }
+        // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
+        if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
+            this._logger.debug("GIT 커밋여부 확인...");
+            const gitStatusResult = await SdProcess.execAsync("git status");
+            if (gitStatusResult.includes("Changes") || gitStatusResult.includes("Untracked")) {
+                throw new Error("커밋되지 않은 정보가 있습니다.");
+            }
+        }
+        this._logger.debug("패키지 목록 구성...");
+        const pkgs = await this._getPackagesAsync();
+        this._logger.debug("프로젝트 및 패키지 버전 설정...");
+        await this._upgradeVersionAsync(pkgs);
+        // 빌드
+        if (!opt.noBuild) {
+            this._logger.debug("빌드를 시작합니다...");
+            await this._buildPkgsAsync(pkgs);
+        }
+        // GIT 사용중일경우, 새 버전 커밋 및 TAG 생성
+        if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
+            this._logger.debug("새 버전 커밋 및 TAG 생성...");
+            await SdProcess.execAsync("git add .");
+            await SdProcess.execAsync(`git commit -m "v${this._npmConfig.version}"`);
+            await SdProcess.execAsync(`git tag -a "v${this._npmConfig.version}" -m "v${this._npmConfig.version}"`);
+        }
+        this._logger.debug("배포 시작...");
+        await pkgs.parallelAsync(async (pkg) => {
+            this._logger.debug(`[${pkg.name}] 배포를 시작합니다...`);
+            await pkg.publishAsync();
+            this._logger.debug(`[${pkg.name}] 배포가 완료되었습니다.`);
+        });
+        this._logger.info(`모든 배포가 완료되었습니다. (v${this._npmConfig.version})`);
+    }
+    async _upgradeVersionAsync(pkgs) {
+        // 작업공간 package.json 버전 설정
+        const newVersion = semver.inc(this._npmConfig.version, "patch");
+        this._npmConfig.version = newVersion;
+        const pkgNames = pkgs.map((item) => item.name);
+        const updateDepVersion = (deps) => {
+            if (!deps)
+                return;
+            for (const depName of Object.keys(deps)) {
+                if (pkgNames.includes(depName)) {
+                    deps[depName] = newVersion;
+                }
+            }
+        };
+        updateDepVersion(this._npmConfig.dependencies);
+        updateDepVersion(this._npmConfig.optionalDependencies);
+        updateDepVersion(this._npmConfig.devDependencies);
+        updateDepVersion(this._npmConfig.peerDependencies);
+        const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+        await FsUtil.writeJsonAsync(npmConfigFilePath, this._npmConfig, { space: 2 });
+        // 각 패키지 package.json 버전 설정
+        await pkgs.parallelAsync(async (pkg) => {
+            await pkg.setNewVersionAsync(newVersion, pkgNames);
+        });
+    }
+    async _waitSecMessageAsync(msg, sec) {
+        for (let i = sec; i > 0; i--) {
+            if (i !== sec) {
+                process.stdout.cursorTo(0);
+            }
+            process.stdout.write(msg + " " + i);
+            await Wait.time(1000);
+        }
+        process.stdout.cursorTo(0);
+        process.stdout.clearLine(0);
+    }
+    async _getPackagesAsync() {
+        const pkgRootPaths = await this._npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
+        if (!pkgRootPaths) {
+            throw new Error("최상위 'package.json'에서 'workspaces'를 찾을 수 없습니다.");
+        }
+        return pkgRootPaths.map((pkgRootPath) => {
+            const pkgConfig = this._config.packages[path.basename(pkgRootPath)];
+            return pkgConfig ? new SdCliPackage(this._rootPath, pkgRootPath, pkgConfig) : undefined;
+        }).filterExists();
+    }
+    _loggingResults(totalResultMap) {
+        const totalResults = Array.from(totalResultMap.entries())
+            .mapMany((item) => item[1].map((item1) => ({
+            pkgName: item[0],
+            ...item1
+        })))
+            .orderBy((item) => item.pkgName + "_" + item.filePath);
+        const warnings = totalResults
+            .filter((item) => item.severity === "warning")
+            .map((item) => `${SdCliBuildResultUtil.getMessage(item)} (${item.pkgName})`)
+            .distinct();
+        const errors = totalResults
+            .filter((item) => item.severity === "error")
+            .map((item) => `${SdCliBuildResultUtil.getMessage(item)} (${item.pkgName})`)
+            .distinct();
+        if (warnings.length > 0) {
+            this._logger.warn(`경고 발생${os.EOL}`, warnings.join(os.EOL));
+        }
+        if (errors.length > 0) {
+            this._logger.error(`오류 발생${os.EOL}`, errors.join(os.EOL));
+        }
+        if (errors.length > 0) {
+            this._logger.error(`경고: ${warnings.length}건, 오류: ${errors.length}건`);
+        }
+        else if (warnings.length > 0) {
+            this._logger.warn(`경고: ${warnings.length}건, 오류: ${errors.length}건`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SdCliWorkspace.js","sourceRoot":"","sources":["../../src/entry-points/SdCliWorkspace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAChD,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,MAAM,MAAM,gBAAgB,CAAC;AAEpC,MAAM,OAAO,cAAc;IAMzB,YAAoC,SAAiB,EACjB,eAAwB;QADxB,cAAS,GAAT,SAAS,CAAQ;QACjB,oBAAe,GAAf,eAAe,CAAS;QAN3C,YAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;QAOnF,MAAM,iBAAiB,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;QACvE,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;QAErD,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,IAAI,eAAe,CAAC,CAAC,CAAC;IACxG,CAAC;IAEM,KAAK,CAAC,UAAU;QACrB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QACnC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE5C,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;QACpC,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,MAAM,cAAc,GAAG,IAAI,GAAG,EAAsC,CAAC;QACrE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACtB,GAAG;iBACA,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;gBACjB,IAAI,WAAW,KAAK,CAAC,EAAE;oBACrB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;iBAClC;gBACD,WAAW,EAAE,CAAC;gBACd,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,gBAAgB,CAAC,CAAC;YACnD,CAAC,CAAC;iBACD,EAAE,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE;gBAC1B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,gBAAgB,CAAC,CAAC;gBACjD,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;gBAEtC,UAAU,CAAC,GAAG,EAAE;oBACd,WAAW,EAAE,CAAC;oBACd,IAAI,WAAW,KAAK,CAAC,EAAE;wBACrB,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;wBACrC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;qBACtC;gBACH,CAAC,EAAE,GAAG,CAAC,CAAC;YACV,CAAC,CAAC,CAAC;SACN;QAED,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/C,MAAM,0BAA0B,GAAa,EAAE,CAAC;QAChD,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YACrC,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,0BAA0B,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAChI,MAAM,GAAG,CAAC,UAAU,EAAE,CAAC;YACvB,0BAA0B,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,UAAU;QACrB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QACnC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE5C,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAC1C,MAAM,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAEtC,KAAK;QACL,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAEO,KAAK,CAAC,eAAe,CAAC,IAAoB;QAChD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/C,MAAM,0BAA0B,GAAa,EAAE,CAAC;QAChD,MAAM,cAAc,GAAG,IAAI,GAAG,EAAsC,CAAC;QACrE,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YACrC,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,0BAA0B,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAEhI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,gBAAgB,CAAC,CAAC;YACjD,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;YACrD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,gBAAgB,CAAC,CAAC;YAEjD,0BAA0B,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;QACrC,IAAI,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,KAAK,OAAO,CAAC,EAAE;YAC3F,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;SACrC;aACI;YACH,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;SACtC;IACH,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,GAAyB;QACjD,IAAI,GAAG,CAAC,OAAO,EAAE;YACf,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;YAChD,MAAM,IAAI,CAAC,oBAAoB,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC;SACpE;QAED,oCAAoC;QACpC,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC,EAAE;YACtD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;YACrC,MAAM,eAAe,GAAG,MAAM,SAAS,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YAChE,IAAI,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;gBAChF,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;aACtC;SACF;QAED,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QACnC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE5C,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAC1C,MAAM,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAEtC,KAAK;QACL,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;YACnC,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;SAClC;QAED,+BAA+B;QAC/B,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC,EAAE;YACtD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;YAC1C,MAAM,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;YACvC,MAAM,SAAS,CAAC,SAAS,CAAC,mBAAmB,IAAI,CAAC,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC;YACzE,MAAM,SAAS,CAAC,SAAS,CAAC,gBAAgB,IAAI,CAAC,UAAU,CAAC,OAAO,UAAU,IAAI,CAAC,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC;SACxG;QAED,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC/B,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YACrC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,gBAAgB,CAAC,CAAC;YACjD,MAAM,GAAG,CAAC,YAAY,EAAE,CAAC;YACzB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,gBAAgB,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,qBAAqB,IAAI,CAAC,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC;IACrE,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAAC,IAAoB;QACrD,0BAA0B;QAC1B,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAE,CAAC;QACjE,IAAI,CAAC,UAAU,CAAC,OAAO,GAAG,UAAU,CAAC;QAErC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE/C,MAAM,gBAAgB,GAAG,CAAC,IAAwC,EAAQ,EAAE;YAC1E,IAAI,CAAC,IAAI;gBAAE,OAAO;YAClB,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACvC,IAAI,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;oBAC9B,IAAI,CAAC,OAAO,CAAC,GAAG,UAAU,CAAC;iBAC5B;aACF;QACH,CAAC,CAAC;QACF,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QAC/C,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC;QACvD,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;QAClD,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;QAEnD,MAAM,iBAAiB,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;QACvE,MAAM,MAAM,CAAC,cAAc,CAAC,iBAAiB,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;QAE9E,2BAA2B;QAC3B,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;YACrC,MAAM,GAAG,CAAC,kBAAkB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAAC,GAAW,EAAE,GAAW;QACzD,KAAK,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;YAC5B,IAAI,CAAC,KAAK,GAAG,EAAE;gBACb,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;aAC5B;YACD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC;YACpC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACvB;QAED,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAC9B,CAAC;IAEO,KAAK,CAAC,iBAAiB;QAC7B,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,MAAM,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAClH,IAAI,CAAC,YAAY,EAAE;YACjB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;SAClE;QAED,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE;YACtC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;YACpE,OAAO,SAAS,CAAC,CAAC,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC1F,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC;IACpB,CAAC;IAEO,eAAe,CAAC,cAAuD;QAC7E,MAAM,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;aACtD,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACzC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;YAChB,GAAG,KAAK;SACT,CAAC,CAAC,CAAC;aACH,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,GAAG,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEzD,MAAM,QAAQ,GAAG,YAAY;aAC1B,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,KAAK,SAAS,CAAC;aAC7C,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,oBAAoB,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,OAAO,GAAG,CAAC;aAC3E,QAAQ,EAAE,CAAC;QAEd,MAAM,MAAM,GAAG,YAAY;aACxB,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,KAAK,OAAO,CAAC;aAC3C,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,oBAAoB,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,OAAO,GAAG,CAAC;aAC3E,QAAQ,EAAE,CAAC;QAEd,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YACvB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;SAC5D;QACD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACrB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;SAC3D;QAED,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACrB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,MAAM,UAAU,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;SACtE;aACI,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YAC5B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,QAAQ,CAAC,MAAM,UAAU,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;SACrE;IACH,CAAC;CACF"}

package/dist/packages/SdCliPackage.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { ISdCliPackageBuildResult, TSdCliPackageConfig } from "../commons";
+import { EventEmitter } from "events";
+export declare class SdCliPackage extends EventEmitter {
+    private readonly _workspaceRootPath;
+    private readonly _rootPath;
+    private readonly _config;
+    private readonly _npmConfig;
+    get name(): string;
+    get allDependencies(): string[];
+    constructor(_workspaceRootPath: string, _rootPath: string, _config: TSdCliPackageConfig);
+    on(event: "change", listener: () => void): this;
+    on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
+    setNewVersionAsync(newVersion: string, pkgNames: string[]): Promise<void>;
+    watchAsync(): Promise<void>;
+    buildAsync(): Promise<ISdCliPackageBuildResult[]>;
+    publishAsync(): Promise<void>;
+    private _genBuildTsconfigAsync;
+}

package/dist/packages/SdCliPackage.mjs

@@ -0,0 +1,89 @@
+import path from "path";
+import { FsUtil, SdProcess } from "@simplysm/sd-core-node";
+import { EventEmitter } from "events";
+import { ObjectUtil } from "@simplysm/sd-core-common";
+import { SdCliTsLibBuilder } from "../builder/SdCliTsLibBuilder";
+import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
+export class SdCliPackage extends EventEmitter {
+    constructor(_workspaceRootPath, _rootPath, _config) {
+        super();
+        this._workspaceRootPath = _workspaceRootPath;
+        this._rootPath = _rootPath;
+        this._config = _config;
+        const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+        this._npmConfig = FsUtil.readJson(npmConfigFilePath);
+    }
+    get name() {
+        return this._npmConfig.name;
+    }
+    get allDependencies() {
+        return [
+            ...Object.keys(this._npmConfig.dependencies ?? {}),
+            ...Object.keys(this._npmConfig.optionalDependencies ?? {}),
+            ...Object.keys(this._npmConfig.devDependencies ?? {}),
+            ...Object.keys(this._npmConfig.peerDependencies ?? {})
+        ].distinct();
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    async setNewVersionAsync(newVersion, pkgNames) {
+        this._npmConfig.version = newVersion;
+        const updateDepVersion = (deps) => {
+            if (!deps)
+                return;
+            for (const depName of Object.keys(deps)) {
+                if (pkgNames.includes(depName)) {
+                    deps[depName] = newVersion;
+                }
+            }
+        };
+        updateDepVersion(this._npmConfig.dependencies);
+        updateDepVersion(this._npmConfig.optionalDependencies);
+        updateDepVersion(this._npmConfig.devDependencies);
+        updateDepVersion(this._npmConfig.peerDependencies);
+        const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
+        await FsUtil.writeJsonAsync(npmConfigFilePath, this._npmConfig, { space: 2 });
+    }
+    async watchAsync() {
+        const isTs = FsUtil.exists(path.resolve(this._rootPath, "tsconfig.json"));
+        if (isTs) {
+            await this._genBuildTsconfigAsync();
+        }
+        const isAngular = isTs && this.allDependencies.includes("@angular/core");
+        const builder = !isTs ? new SdCliJsLibBuilder(this._rootPath) : new SdCliTsLibBuilder(this._rootPath, isAngular);
+        await builder
+            .on("change", () => {
+            this.emit("change");
+        })
+            .on("complete", (results) => {
+            this.emit("complete", results);
+        })
+            .watchAsync();
+    }
+    async buildAsync() {
+        const isTs = FsUtil.exists(path.resolve(this._rootPath, "tsconfig.json"));
+        if (isTs) {
+            await this._genBuildTsconfigAsync();
+        }
+        const isAngular = isTs && this.allDependencies.includes("@angular/core");
+        const builder = isTs ? new SdCliTsLibBuilder(this._rootPath, isAngular) : new SdCliJsLibBuilder(this._rootPath);
+        return await builder.buildAsync();
+    }
+    async publishAsync() {
+        if (this._config.type === "library" && this._config.publish === "npm") {
+            await SdProcess.execAsync("npm publish --quiet --access public", { cwd: this._rootPath });
+        }
+    }
+    async _genBuildTsconfigAsync() {
+        const baseTsconfigFilePath = path.resolve(this._rootPath, "tsconfig.json");
+        const baseTsconfig = await FsUtil.readJsonAsync(baseTsconfigFilePath);
+        const buildTsconfig = ObjectUtil.clone(baseTsconfig);
+        buildTsconfig.compilerOptions = buildTsconfig.compilerOptions ?? {};
+        delete buildTsconfig.compilerOptions.baseUrl;
+        delete buildTsconfig.compilerOptions.paths;
+        const buildTsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+        await FsUtil.writeJsonAsync(buildTsconfigFilePath, buildTsconfig, { space: 2 });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/SdCliBuildResultUtil.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import { ISdCliPackageBuildResult } from "../commons";
+export declare class SdCliBuildResultUtil {
+    static convertDiagsToResult(diag: ts.Diagnostic): ISdCliPackageBuildResult | undefined;
+    static getMessage(result: ISdCliPackageBuildResult): string;
+}

package/dist/utils/SdCliBuildResultUtil.mjs

@@ -0,0 +1,38 @@
+import ts from "typescript";
+import * as os from "os";
+import * as path from "path";
+export class SdCliBuildResultUtil {
+    static convertDiagsToResult(diag) {
+        const severity = diag.category === ts.DiagnosticCategory.Error ? "error"
+            : diag.category === ts.DiagnosticCategory.Warning ? "warning"
+                : undefined;
+        if (!severity)
+            return undefined;
+        const code = "TS" + diag.code;
+        const message = ts.flattenDiagnosticMessageText(diag.messageText, os.EOL);
+        const filePath = diag.file ? path.resolve(diag.file.fileName) : undefined;
+        const position = diag.file && diag.start !== undefined ? diag.file.getLineAndCharacterOfPosition(diag.start) : undefined;
+        const line = position ? position.line + 1 : undefined;
+        const char = position ? position.character + 1 : undefined;
+        return {
+            filePath,
+            line,
+            char,
+            code,
+            severity,
+            message
+        };
+    }
+    static getMessage(result) {
+        let str = "";
+        if (result.filePath !== undefined) {
+            str += `${result.filePath}(${result.line ?? 0}, ${result.char ?? 0}): `;
+        }
+        if (result.code !== undefined) {
+            str += `${result.code}: `;
+        }
+        str += `${result.severity} ${result.message}`;
+        return str;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/SdCliConfigUtil.d.ts

@@ -0,0 +1,7 @@
+import { ISdCliConfig } from "../commons";
+export declare class SdCliConfigUtil {
+    static loadConfig(confFilePath: string, isDev?: boolean, opts?: string[]): ISdCliConfig;
+    private static _getConfigFromFileContent;
+    private static _getPkgConfigFromFileContent;
+    private static _mergeObj;
+}

package/dist/utils/SdCliConfigUtil.mjs

@@ -0,0 +1,69 @@
+import { FsUtil } from "@simplysm/sd-core-node";
+import { ObjectUtil } from "@simplysm/sd-core-common";
+import path from "path";
+export class SdCliConfigUtil {
+    static loadConfig(confFilePath, isDev, opts) {
+        const confFileCont = FsUtil.readJson(confFilePath);
+        let conf = this._getConfigFromFileContent(confFileCont, isDev, opts);
+        // extends
+        if (conf.extends) {
+            for (const extConfFilePath of conf.extends) {
+                const extConf = this.loadConfig(path.resolve(path.dirname(confFilePath), extConfFilePath), isDev, opts);
+                conf = this._mergeObj(conf, extConf);
+            }
+        }
+        delete conf["extends"];
+        return conf;
+    }
+    static _getConfigFromFileContent(confFileCont, isDev, opts) {
+        const conf = ObjectUtil.clone(confFileCont);
+        if (conf.packages) {
+            for (const pkgName of Object.keys(conf.packages)) {
+                conf.packages[pkgName] = this._getPkgConfigFromFileContent(conf, conf.packages[pkgName], isDev, opts);
+            }
+        }
+        return conf;
+    }
+    static _getPkgConfigFromFileContent(confFileCont, pkgConfFileCont, isDev, opts) {
+        let pkgConf = ObjectUtil.clone(pkgConfFileCont);
+        // override
+        const pkgOvrNames = pkgConf.overrides;
+        if (pkgOvrNames) {
+            for (const pkgOvrName of pkgOvrNames) {
+                const rootOvr = confFileCont.overrides?.[pkgOvrName];
+                if (rootOvr) {
+                    const ovrConf = this._getPkgConfigFromFileContent(confFileCont, rootOvr, isDev, opts);
+                    pkgConf = this._mergeObj(pkgConf, ovrConf);
+                }
+            }
+            delete pkgConf.overrides;
+        }
+        // mode 처리
+        const mode = isDev ? "dev" : "prod";
+        if (pkgConf[mode] !== undefined) {
+            const modeConf = this._getPkgConfigFromFileContent(confFileCont, pkgConf[mode], isDev, opts);
+            pkgConf = this._mergeObj(pkgConf, modeConf);
+        }
+        delete pkgConf["dev"];
+        delete pkgConf["prod"];
+        // options
+        if (opts && opts.length > 0) {
+            const pkgOpts = Object.keys(pkgConf).filter((key) => key.startsWith("@") && opts.some((opt) => opt === key.slice(1)));
+            for (const pkgOpt of pkgOpts) {
+                const optConf = this._getPkgConfigFromFileContent(confFileCont, pkgConf[pkgOpt], isDev, opts);
+                pkgConf = this._mergeObj(pkgConf, optConf);
+            }
+            for (const optKey of Object.keys(pkgConf).filter((item) => item.startsWith("@"))) {
+                delete pkgConf[optKey];
+            }
+        }
+        return pkgConf;
+    }
+    static _mergeObj(org, target) {
+        return ObjectUtil.merge(org, target, {
+            arrayProcess: "replace",
+            useDelTargetUndefined: true
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/ts-node-esm-paths.mjs

@@ -0,0 +1,15 @@
+import { resolve as resolveTs } from "ts-node/esm";
+import * as tsConfigPaths from "tsconfig-paths";
+import { pathToFileURL } from "url";
+
+const { absoluteBaseUrl, paths } = tsConfigPaths.loadConfig();
+const matchPath = tsConfigPaths.createMatchPath(absoluteBaseUrl, paths);
+
+export function resolve(specifier, ctx, defaultResolve) {
+  const match = matchPath(specifier);
+  return match
+    ? resolveTs(pathToFileURL(`${match}`).href, ctx, defaultResolve)
+    : resolveTs(specifier, ctx, defaultResolve);
+}
+
+export { getFormat, load, transformSource } from "ts-node/esm";