@simplysm/sd-cli 7.0.12 → 7.0.17

package/dist/bin/sd-cli.d.ts

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

package/dist/bin/sd-cli.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
+import { SdCliWorkspace } from "../entry-points/SdCliWorkspace";
+import { SdCliLocalUpdate } from "../entry-points/SdCliLocalUpdate";
+Error.stackTraceLimit = Infinity;
+const argv = yargs(hideBin(process.argv))
+    .version(false)
+    .help("help", "도움말")
+    .alias("help", "h")
+    .options({
+    debug: {
+        type: "boolean",
+        describe: "디버그 로그를 표시할 것인지 여부",
+        default: false
+    }
+})
+    .command("local-update", "로컬 라이브러리 업데이트를 수행합니다.", (cmd) => cmd.version(false)
+    .options({
+    config: {
+        type: "string",
+        describe: "simplysm.json 파일 경로"
+    }
+}))
+    .command("watch", "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.", (cmd) => cmd.version(false)
+    .options({
+    config: {
+        type: "string",
+        describe: "simplysm.json 파일 경로"
+    }
+}))
+    .command("build", "프로젝트의 각 패키지에 대한 빌드를 수행합니다.", (cmd) => cmd.version(false)
+    .options({
+    config: {
+        type: "string",
+        describe: "simplysm.json 파일 경로"
+    }
+}))
+    .command("publish", "프로젝트의 각 패키지를 배포합니다.", (cmd) => cmd.version(false)
+    .options({
+    config: {
+        type: "string",
+        describe: "simplysm.json 파일 경로"
+    },
+    "noBuild": {
+        type: "boolean",
+        describe: "빌드를 하지않고 배포합니다.",
+        default: false
+    }
+}))
+    .parseSync();
+if (argv.debug) {
+    process.env["SD_CLI_LOGGER_SEVERITY"] = "DEBUG";
+    Logger.setConfig({
+        console: {
+            level: LoggerSeverity.debug
+        }
+    });
+}
+else {
+    Logger.setConfig({
+        dot: true
+    });
+}
+const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
+(async () => {
+    if (argv._[0] === "local-update") {
+        await new SdCliLocalUpdate(process.cwd(), argv.config)
+            .runAsync();
+    }
+    else if (argv._[0] === "watch") {
+        await new SdCliWorkspace(process.cwd(), argv.config)
+            .watchAsync();
+    }
+    else if (argv._[0] === "build") {
+        await new SdCliWorkspace(process.cwd(), argv.config)
+            .buildAsync();
+    }
+    else if (argv._[0] === "publish") {
+        await new SdCliWorkspace(process.cwd(), argv.config)
+            .publishAsync({
+            noBuild: argv.noBuild
+        });
+    }
+    else {
+        throw new Error(`명령어가 잘못 되었습니다.\n\t${argv._[0]}\n`);
+    }
+})().catch((err) => {
+    logger.error(err);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/build-tool/{SdCliCacheCompilerHost.mjs → SdCliCacheCompilerHost.js}

@@ -19,7 +19,7 @@ export class SdCliCacheCompilerHost {
             return cache.sourceFile;
         };
         cacheCompilerHost.writeFile = (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
-            fileName = fileName.replace(/\.js(\.map)?$/, ".mjs$1");
+            // fileName = fileName.replace(/\.js(\.map)?$/, ".mjs$1");
             const writeCache = outputFileCache.get(PathUtil.posix(fileName));
             if (writeCache !== data) {
                 outputFileCache.set(PathUtil.posix(fileName), data);
@@ -41,4 +41,4 @@ export class SdCliCacheCompilerHost {
         return cacheCompilerHost;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/builder/{SdCliJsLibBuilder.mjs → SdCliJsLibBuilder.js}

@@ -36,7 +36,7 @@ export class SdCliJsLibBuilder extends EventEmitter {
         return await this._linter.lintAsync(relatedPaths);
     }
     async getRelatedPathsAsync() {
-        const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts)");
+        const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.ts)");
         const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
             ignore: [
                 "**/node_modules/**",
@@ -47,4 +47,4 @@ export class SdCliJsLibBuilder extends EventEmitter {
         return [...mySourceFilePaths, path.resolve(this._rootPath, ".eslintrc.cjs")].distinct();
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2RDbGlKc0xpYkJ1aWxkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYnVpbGRlci9TZENsaUpzTGliQnVpbGRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JFLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRXRFLE1BQU0sT0FBTyxpQkFBa0IsU0FBUSxZQUFZO0lBS2pELFlBQW9DLFNBQWlCO1FBQ25ELEtBQUssRUFBRSxDQUFDO1FBRDBCLGNBQVMsR0FBVCxTQUFTLENBQVE7UUFKcEMsWUFBTyxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxVQUFVLEVBQUUsUUFBUSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQU1uRixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksa0JBQWtCLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFJZSxFQUFFLENBQUMsS0FBc0IsRUFBRSxRQUFrQztRQUMzRSxPQUFPLEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFFTSxLQUFLLENBQUMsVUFBVTtRQUNyQixJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBRXBCLE1BQU0sWUFBWSxHQUFHLE1BQU0sSUFBSSxDQUFDLG9CQUFvQixFQUFFLENBQUM7UUFDdkQsTUFBTSxPQUFPLEdBQUcsV0FBVyxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUNoRCxPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxXQUFXLEVBQUUsRUFBRTtZQUNyQyxNQUFNLGVBQWUsR0FBRyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDLEtBQUssRUFBRSxRQUFRLEVBQUUsUUFBUSxDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ2hJLElBQUcsZUFBZSxDQUFDLE1BQU0sS0FBSyxDQUFDO2dCQUFFLE9BQU87WUFFeEMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsVUFBVSxFQUFFLFdBQVcsQ0FBQyxDQUFDO1lBQzVDLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7WUFFcEIsTUFBTSxpQkFBaUIsR0FBRyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1lBRXhFLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxJQUFJLENBQUMsb0JBQW9CLEVBQUUsQ0FBQztZQUM1RCxPQUFPLENBQUMsR0FBRyxDQUFDLGlCQUFpQixDQUFDLENBQUM7WUFFL0IsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsaUJBQWlCLENBQUMsQ0FBQztRQUMzQyxDQUFDLENBQUMsQ0FBQztRQUVILEtBQUs7UUFDTCxNQUFNLFlBQVksR0FBRyxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBRWhFLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLFlBQVksQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFTSxLQUFLLENBQUMsVUFBVTtRQUNyQixNQUFNLFlBQVksR0FBRyxNQUFNLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxDQUFDO1FBQ3ZELE9BQU8sTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUNwRCxDQUFDO0lBRU8sS0FBSyxDQUFDLG9CQUFvQjtRQUNoQyxNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxJQUFJLEVBQUUsMEJBQTBCLENBQUMsQ0FBQztRQUN4RixNQUFNLGlCQUFpQixHQUFHLE1BQU0sTUFBTSxDQUFDLFNBQVMsQ0FBQyxnQkFBZ0IsRUFBRTtZQUNqRSxNQUFNLEVBQUU7Z0JBQ04sb0JBQW9CO2dCQUNwQixZQUFZO2dCQUNaLFVBQVU7YUFDWDtTQUNGLENBQUMsQ0FBQztRQUVILE9BQU8sQ0FBQyxHQUFHLGlCQUFpQixFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxlQUFlLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQzFGLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist/builder/{SdCliTsLibBuilder.mjs → SdCliTsLibBuilder.js}

@@ -76,7 +76,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
     }
     async getAllRelatedPathsAsync() {
         const fileCachePaths = Array.from(this._fileCache.keys());
-        const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts)");
+        const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.ts)");
         const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
             ignore: [
                 "**/node_modules/**",
@@ -223,4 +223,4 @@ export class SdCliTsLibBuilder extends EventEmitter {
         return ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SdCliTsLibBuilder.js","sourceRoot":"","sources":["../../src/builder/SdCliTsLibBuilder.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SdCliTsLibBuilder.js","sourceRoot":"","sources":["../../src/builder/SdCliTsLibBuilder.ts"],"names":[],"mappings":"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"}

package/dist/commons.d.ts

@@ -32,6 +32,7 @@ export interface ISdCliPackageBuildResult {
 }
 export interface ISdCliConfig {
     packages: Record<string, TSdCliPackageConfig | undefined>;
+    localUpdates?: Record<string, string>;
 }
 export declare type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig;
 export interface ISdCliLibPackageConfig {

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

@@ -0,0 +1,10 @@
+export declare class SdCliLocalUpdate {
+    private readonly _rootPath;
+    private readonly _configFilePath?;
+    private readonly _logger;
+    constructor(_rootPath: string, _configFilePath?: string | undefined);
+    runAsync(): Promise<void>;
+    watchAsync(): Promise<void>;
+    private _getUpdatePathInfosAsync;
+    protected _getWatchPathsAsync(sourcePath: string): Promise<string[]>;
+}

package/dist/entry-points/SdCliLocalUpdate.js

@@ -0,0 +1,90 @@
+import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
+import * as path from "path";
+export class SdCliLocalUpdate {
+    constructor(_rootPath, _configFilePath) {
+        this._rootPath = _rootPath;
+        this._configFilePath = _configFilePath;
+        this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+    }
+    async runAsync() {
+        this._logger.debug("프로젝트 설정 가져오기...");
+        const conf = SdCliConfigUtil.loadConfig(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"), false);
+        if (!conf.localUpdates)
+            return;
+        const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
+        this._logger.log("로컬 라이브러리 업데이트 시작...");
+        for (const updatePathInfo of updatePathInfos) {
+            if (!FsUtil.exists(updatePathInfo.source)) {
+                this._logger.warn(`소스경로를 찾을 수 없어 무시됩니다(${updatePathInfo.source})`);
+                return;
+            }
+            // 소스경로에서 대상경로로 파일 복사
+            await FsUtil.copyAsync(updatePathInfo.source, updatePathInfo.target, (src) => {
+                return !src.includes("node_modules") && !src.endsWith("package.json");
+            });
+        }
+        this._logger.info("로컬 라이브러리 업데이트 완료");
+    }
+    async watchAsync() {
+        this._logger.debug("프로젝트 설정 가져오기...");
+        const conf = SdCliConfigUtil.loadConfig(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"), false);
+        if (!conf.localUpdates)
+            return;
+        const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
+        const watchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
+        const watcher = SdFsWatcher.watch(watchPaths);
+        watcher.onChange(async (changeInfos) => {
+            const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+            if (changeFilePaths.length === 0)
+                return;
+            this._logger.log("로컬 라이브러리 변경감지...");
+            for (const changedFilePath of changeFilePaths) {
+                const currentUpdatePathInfos = updatePathInfos.filter((item) => PathUtil.isChildPath(changedFilePath, item.source));
+                const targetFilePaths = currentUpdatePathInfos.map((item) => path.resolve(item.target, path.relative(item.source, changedFilePath)));
+                if (FsUtil.exists(changedFilePath)) {
+                    this._logger.debug(`변경파일감지(복사): ${changedFilePath}`);
+                    for (const targetFilePath of targetFilePaths) {
+                        await FsUtil.copyAsync(changedFilePath, targetFilePath);
+                    }
+                }
+            }
+            const watchWatchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
+            watcher.add(watchWatchPaths);
+            this._logger.info("로컬 라이브러리 복사 완료");
+        });
+    }
+    async _getUpdatePathInfosAsync(record) {
+        const result = [];
+        for (const pkgGlobPath of Object.keys(record)) {
+            // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기
+            const targetPaths = await FsUtil.globAsync(path.resolve(this._rootPath, "node_modules", pkgGlobPath));
+            result.push(...targetPaths
+                .map((targetPath) => {
+                // 대상의 명칭 추출
+                const regexpText = pkgGlobPath.replace(/[\\/.*]/g, (item) => (item === "/" ? "[\\\\\\/]"
+                    : item === "." ? "\\."
+                        : item === "*" ? "(.*)"
+                            : item));
+                const targetNameMatch = new RegExp(regexpText).exec(targetPath);
+                if (!targetNameMatch || typeof targetNameMatch[1] === "undefined")
+                    return undefined;
+                const targetName = targetNameMatch[1];
+                // 가져올 소스 경로 추출
+                const sourcePath = path.resolve(record[pkgGlobPath].replace(/\*/g, targetName));
+                return { source: sourcePath, target: targetPath };
+            })
+                .filterExists());
+        }
+        return result;
+    }
+    async _getWatchPathsAsync(sourcePath) {
+        return await FsUtil.globAsync(path.resolve(sourcePath, "**"), {
+            ignore: [
+                "**/node_modules/**",
+                "**/package.json"
+            ]
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/SdCliConfigUtil.d.ts

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

package/dist/utils/{SdCliConfigUtil.mjs → SdCliConfigUtil.js}

@@ -66,4 +66,4 @@ export class SdCliConfigUtil {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-cli",
-  "version": "7.0.12",
+  "version": "7.0.17",
   "description": "심플리즘 패키지 - CLI",
   "author": "김석래",
   "repository": {
@@ -10,10 +10,10 @@
   },
   "license": "MIT",
   "bin": {
-    "sd-cli": "./dist/bin/sd-cli.mjs"
+    "sd-cli": "./dist/bin/sd-cli.js"
   },
   "exports": {
-    "./ts-node-esm-paths": "./lib/ts-node-esm-paths.mjs"
+    "./ts-node-esm-paths": "./lib/ts-node-esm-paths.js"
   },
   "type": "module",
   "engines": {
@@ -35,7 +35,7 @@
     "@types/semver": "^7.3.9"
   },
   "peerDependencies": {
-    "@simplysm/sd-core-common": "7.0.12",
-    "@simplysm/sd-core-node": "7.0.12"
+    "@simplysm/sd-core-common": "7.0.17",
+    "@simplysm/sd-core-node": "7.0.17"
   }
 }

package/src/bin/sd-cli.ts

@@ -1,7 +1,10 @@
+#!/usr/bin/env node
+
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
 import { SdCliWorkspace } from "../entry-points/SdCliWorkspace";
+import { SdCliLocalUpdate } from "../entry-points/SdCliLocalUpdate";
 
 Error.stackTraceLimit = Infinity;
 
@@ -85,7 +88,11 @@ else {
 const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
 
 (async () => {
-  if (argv._[0] === "watch") {
+  if (argv._[0] === "local-update") {
+    await new SdCliLocalUpdate(process.cwd(), argv.config)
+      .runAsync();
+  }
+  else if (argv._[0] === "watch") {
     await new SdCliWorkspace(process.cwd(), argv.config)
       .watchAsync();
   }

package/src/build-tool/SdCliCacheCompilerHost.ts

@@ -31,7 +31,7 @@ export class SdCliCacheCompilerHost {
                                    writeByteOrderMark: boolean,
                                    onError?: (message: string) => void,
                                    sourceFiles?: readonly ts.SourceFile[]) => {
-      fileName = fileName.replace(/\.js(\.map)?$/, ".mjs$1");
+      // fileName = fileName.replace(/\.js(\.map)?$/, ".mjs$1");
 
       const writeCache = outputFileCache.get(PathUtil.posix(fileName));
       if (writeCache !== data) {

package/src/builder/SdCliJsLibBuilder.ts

@@ -52,7 +52,7 @@ export class SdCliJsLibBuilder extends EventEmitter {
   }
 
   private async getRelatedPathsAsync(): Promise<string[]> {
-    const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts)");
+    const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.ts)");
     const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
       ignore: [
         "**/node_modules/**",

package/src/builder/SdCliTsLibBuilder.ts

@@ -111,7 +111,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
 
   private async getAllRelatedPathsAsync(): Promise<string[]> {
     const fileCachePaths = Array.from(this._fileCache.keys());
-    const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts)");
+    const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.ts)");
     const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
       ignore: [
         "**/node_modules/**",

package/src/commons.ts

@@ -36,6 +36,7 @@ export interface ISdCliPackageBuildResult {
 
 export interface ISdCliConfig {
   packages: Record<string, TSdCliPackageConfig | undefined>;
+  localUpdates?: Record<string, string>;
 }
 
 export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig;

package/src/entry-points/SdCliLocalUpdate.ts

@@ -0,0 +1,111 @@
+import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
+import * as path from "path";
+
+export class SdCliLocalUpdate {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  public constructor(private readonly _rootPath: string,
+                     private readonly _configFilePath?: string) {
+  }
+
+  public async runAsync(): Promise<void> {
+    this._logger.debug("프로젝트 설정 가져오기...");
+    const conf = SdCliConfigUtil.loadConfig(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"), false);
+    if (!conf.localUpdates) return;
+
+    const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
+
+    this._logger.log("로컬 라이브러리 업데이트 시작...");
+    for (const updatePathInfo of updatePathInfos) {
+      if (!FsUtil.exists(updatePathInfo.source)) {
+        this._logger.warn(`소스경로를 찾을 수 없어 무시됩니다(${updatePathInfo.source})`);
+        return;
+      }
+
+      // 소스경로에서 대상경로로 파일 복사
+      await FsUtil.copyAsync(updatePathInfo.source, updatePathInfo.target, (src) => {
+        return !src.includes("node_modules") && !src.endsWith("package.json");
+      });
+    }
+    this._logger.info("로컬 라이브러리 업데이트 완료");
+  }
+
+  public async watchAsync(): Promise<void> {
+    this._logger.debug("프로젝트 설정 가져오기...");
+    const conf = SdCliConfigUtil.loadConfig(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"), false);
+    if (!conf.localUpdates) return;
+
+    const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
+
+    const watchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
+
+    const watcher = SdFsWatcher.watch(watchPaths);
+    watcher.onChange(async (changeInfos) => {
+      const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+      if (changeFilePaths.length === 0) return;
+
+      this._logger.log("로컬 라이브러리 변경감지...");
+      for (const changedFilePath of changeFilePaths) {
+        const currentUpdatePathInfos = updatePathInfos.filter((item) => PathUtil.isChildPath(changedFilePath, item.source));
+        const targetFilePaths = currentUpdatePathInfos.map((item) => path.resolve(item.target, path.relative(item.source, changedFilePath)));
+        if (FsUtil.exists(changedFilePath)) {
+          this._logger.debug(`변경파일감지(복사): ${changedFilePath}`);
+          for (const targetFilePath of targetFilePaths) {
+            await FsUtil.copyAsync(changedFilePath, targetFilePath);
+          }
+        }
+      }
+
+      const watchWatchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
+      watcher.add(watchWatchPaths);
+
+      this._logger.info("로컬 라이브러리 복사 완료");
+    });
+  }
+
+  private async _getUpdatePathInfosAsync(record: Record<string, string>): Promise<IUpdatePathInfo[]> {
+    const result: IUpdatePathInfo[] = [];
+    for (const pkgGlobPath of Object.keys(record)) {
+      // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기
+      const targetPaths = await FsUtil.globAsync(path.resolve(this._rootPath, "node_modules", pkgGlobPath));
+
+      result.push(
+        ...targetPaths
+          .map((targetPath) => {
+            // 대상의 명칭 추출
+            const regexpText = pkgGlobPath.replace(/[\\/.*]/g, (item) => (
+              item === "/" ? "[\\\\\\/]"
+                : item === "." ? "\\."
+                  : item === "*" ? "(.*)"
+                    : item
+            ));
+            const targetNameMatch = new RegExp(regexpText).exec(targetPath);
+            if (!targetNameMatch || typeof targetNameMatch[1] === "undefined") return undefined;
+            const targetName = targetNameMatch[1];
+
+            // 가져올 소스 경로 추출
+            const sourcePath = path.resolve(record[pkgGlobPath].replace(/\*/g, targetName));
+            return { source: sourcePath, target: targetPath };
+          })
+          .filterExists()
+      );
+    }
+
+    return result;
+  }
+
+  protected async _getWatchPathsAsync(sourcePath: string): Promise<string[]> {
+    return await FsUtil.globAsync(path.resolve(sourcePath, "**"), {
+      ignore: [
+        "**/node_modules/**",
+        "**/package.json"
+      ]
+    });
+  }
+}
+
+interface IUpdatePathInfo {
+  source: string;
+  target: string;
+}

package/src/utils/SdCliConfigUtil.ts

@@ -4,7 +4,7 @@ import { ObjectUtil } from "@simplysm/sd-core-common";
 import path from "path";
 
 export class SdCliConfigUtil {
-  public static loadConfig(confFilePath: string, isDev?: boolean, opts?: string[]): ISdCliConfig {
+  public static loadConfig(confFilePath: string, isDev: boolean, opts?: string[]): ISdCliConfig {
     const confFileCont = FsUtil.readJson(confFilePath);
     let conf = this._getConfigFromFileContent(confFileCont, isDev, opts);
 
@@ -20,7 +20,7 @@ export class SdCliConfigUtil {
     return conf as ISdCliConfig;
   }
 
-  private static _getConfigFromFileContent(confFileCont: ISdCliConfigFileContent, isDev?: boolean, opts?: string[]): ISdCliConfigFileContent {
+  private static _getConfigFromFileContent(confFileCont: ISdCliConfigFileContent, isDev: boolean, opts?: string[]): ISdCliConfigFileContent {
     const conf = ObjectUtil.clone(confFileCont);
 
     if (conf.packages) {
@@ -31,7 +31,7 @@ export class SdCliConfigUtil {
     return conf;
   }
 
-  private static _getPkgConfigFromFileContent(confFileCont: ISdCliConfigFileContent, pkgConfFileCont: TSdCliPackageConfigFileContent, isDev?: boolean, opts?: string[]): TSdCliPackageConfig {
+  private static _getPkgConfigFromFileContent(confFileCont: ISdCliConfigFileContent, pkgConfFileCont: TSdCliPackageConfigFileContent, isDev: boolean, opts?: string[]): TSdCliPackageConfig {
     let pkgConf = ObjectUtil.clone(pkgConfFileCont);
 
     // override

package/dist/bin/sd-cli.mjs

@@ -1,86 +0,0 @@
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
-import { SdCliWorkspace } from "../entry-points/SdCliWorkspace";
-Error.stackTraceLimit = Infinity;
-const argv = yargs(hideBin(process.argv))
-    .version(false)
-    .help("help", "도움말")
-    .alias("help", "h")
-    .options({
-    debug: {
-        type: "boolean",
-        describe: "디버그 로그를 표시할 것인지 여부",
-        default: false
-    }
-})
-    .command("local-update", "로컬 라이브러리 업데이트를 수행합니다.", (cmd) => cmd.version(false)
-    .options({
-    config: {
-        type: "string",
-        describe: "simplysm.json 파일 경로"
-    }
-}))
-    .command("watch", "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.", (cmd) => cmd.version(false)
-    .options({
-    config: {
-        type: "string",
-        describe: "simplysm.json 파일 경로"
-    }
-}))
-    .command("build", "프로젝트의 각 패키지에 대한 빌드를 수행합니다.", (cmd) => cmd.version(false)
-    .options({
-    config: {
-        type: "string",
-        describe: "simplysm.json 파일 경로"
-    }
-}))
-    .command("publish", "프로젝트의 각 패키지를 배포합니다.", (cmd) => cmd.version(false)
-    .options({
-    config: {
-        type: "string",
-        describe: "simplysm.json 파일 경로"
-    },
-    "noBuild": {
-        type: "boolean",
-        describe: "빌드를 하지않고 배포합니다.",
-        default: false
-    }
-}))
-    .parseSync();
-if (argv.debug) {
-    process.env["SD_CLI_LOGGER_SEVERITY"] = "DEBUG";
-    Logger.setConfig({
-        console: {
-            level: LoggerSeverity.debug
-        }
-    });
-}
-else {
-    Logger.setConfig({
-        dot: true
-    });
-}
-const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
-(async () => {
-    if (argv._[0] === "watch") {
-        await new SdCliWorkspace(process.cwd(), argv.config)
-            .watchAsync();
-    }
-    else if (argv._[0] === "build") {
-        await new SdCliWorkspace(process.cwd(), argv.config)
-            .buildAsync();
-    }
-    else if (argv._[0] === "publish") {
-        await new SdCliWorkspace(process.cwd(), argv.config)
-            .publishAsync({
-            noBuild: argv.noBuild
-        });
-    }
-    else {
-        throw new Error(`명령어가 잘못 되었습니다.\n\t${argv._[0]}\n`);
-    }
-})().catch((err) => {
-    logger.error(err);
-});
-//# sourceMappingURL=data:application/json;base64,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