@simplysm/sd-cli 7.0.6 → 7.0.13

package/dist/bin/sd-cli.mjs

@@ -2,6 +2,7 @@ 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)
@@ -14,10 +15,33 @@ const argv = yargs(hideBin(process.argv))
         default: false
     }
 })
-    .command("watch", "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.")
-    .command("build", "프로젝트의 각 패키지에 대한 빌드를 수행합니다.")
-    .command("publish", "프로젝트의 각 패키지를 배포합니다.", (cmd) => cmd
+    .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: "빌드를 하지않고 배포합니다.",
@@ -40,14 +64,21 @@ else {
 }
 const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
 (async () => {
-    if (argv._[0] === "watch") {
-        await new SdCliWorkspace(process.cwd()).watchAsync();
+    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()).buildAsync();
+        await new SdCliWorkspace(process.cwd(), argv.config)
+            .buildAsync();
     }
     else if (argv._[0] === "publish") {
-        await new SdCliWorkspace(process.cwd()).publishAsync({
+        await new SdCliWorkspace(process.cwd(), argv.config)
+            .publishAsync({
             noBuild: argv.noBuild
         });
     }
@@ -57,4 +88,4 @@ const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
 })().catch((err) => {
     logger.error(err);
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2QtY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Jpbi9zZC1jbGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBQzFCLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDeEMsT0FBTyxFQUFFLE1BQU0sRUFBRSxjQUFjLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNoRSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFaEUsS0FBSyxDQUFDLGVBQWUsR0FBRyxRQUFRLENBQUM7QUFFakMsTUFBTSxJQUFJLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7S0FDdEMsT0FBTyxDQUFDLEtBQUssQ0FBQztLQUNkLElBQUksQ0FBQyxNQUFNLEVBQUUsS0FBSyxDQUFDO0tBQ25CLEtBQUssQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDO0tBQ2xCLE9BQU8sQ0FBQztJQUNQLEtBQUssRUFBRTtRQUNMLElBQUksRUFBRSxTQUFTO1FBQ2YsUUFBUSxFQUFFLG9CQUFvQjtRQUM5QixPQUFPLEVBQUUsS0FBSztLQUNmO0NBQ0YsQ0FBQztLQUNELE9BQU8sQ0FBQyxPQUFPLEVBQUUsaUNBQWlDLENBQUM7S0FDbkQsT0FBTyxDQUFDLE9BQU8sRUFBRSw0QkFBNEIsQ0FBQztLQUM5QyxPQUFPLENBQ04sU0FBUyxFQUNULHFCQUFxQixFQUNyQixDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsR0FBRztLQUNULE9BQU8sQ0FBQztJQUNQLFNBQVMsRUFBQztRQUNSLElBQUksRUFBRSxTQUFTO1FBQ2YsUUFBUSxFQUFFLGlCQUFpQjtRQUMzQixPQUFPLEVBQUUsS0FBSztLQUNmO0NBQ0YsQ0FBQyxDQUNMO0tBQ0EsU0FBUyxFQUFFLENBQUM7QUFFZixJQUFJLElBQUksQ0FBQyxLQUFLLEVBQUU7SUFDZCxPQUFPLENBQUMsR0FBRyxDQUFDLHdCQUF3QixDQUFDLEdBQUcsT0FBTyxDQUFDO0lBRWhELE1BQU0sQ0FBQyxTQUFTLENBQUM7UUFDZixPQUFPLEVBQUU7WUFDUCxLQUFLLEVBQUUsY0FBYyxDQUFDLEtBQUs7U0FDNUI7S0FDRixDQUFDLENBQUM7Q0FDSjtLQUNJO0lBQ0gsTUFBTSxDQUFDLFNBQVMsQ0FBQztRQUNmLEdBQUcsRUFBRSxJQUFJO0tBQ1YsQ0FBQyxDQUFDO0NBQ0o7QUFFRCxNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsVUFBVSxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztBQUVuRSxDQUFDLEtBQUssSUFBSSxFQUFFO0lBQ1YsSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLE9BQU8sRUFBRTtRQUN6QixNQUFNLElBQUksY0FBYyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLFVBQVUsRUFBRSxDQUFDO0tBQ3REO1NBQ0ksSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLE9BQU8sRUFBRTtRQUM5QixNQUFNLElBQUksY0FBYyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLFVBQVUsRUFBRSxDQUFDO0tBQ3REO1NBQ0ksSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLFNBQVMsRUFBRTtRQUNoQyxNQUFNLElBQUksY0FBYyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLFlBQVksQ0FBQztZQUNuRCxPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU87U0FDdEIsQ0FBQyxDQUFDO0tBQ0o7U0FDSTtRQUNILE1BQU0sSUFBSSxLQUFLLENBQUMscUJBQXFCLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDO0tBQ3JEO0FBQ0gsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtJQUNqQixNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ3BCLENBQUMsQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/build-tool/SdCliNgCacheCompilerHost.mjs

@@ -22,7 +22,7 @@ export class SdCliNgCacheCompilerHost {
                     importer: {
                         findFileUrl: (url) => {
                             if (!url.startsWith("~"))
-                                return undefined;
+                                return null;
                             return new URL(url.substring(1), pathToFileURL("node_modules"));
                         }
                     }
@@ -33,4 +33,4 @@ export class SdCliNgCacheCompilerHost {
         return cacheCompilerHost;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/builder/SdCliTsLibBuilder.mjs

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import * as path from "path";
 import { createHash } from "crypto";
-import { SdBuildResultUtil } from "../utils/SdBuildResultUtil";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import { NgtscProgram } from "@angular/compiler-cli";
 import sass from "sass";
 import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
@@ -110,7 +110,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
             }
             results.push(...diagnostics
                 .filter((item) => [ts.DiagnosticCategory.Error, ts.DiagnosticCategory.Warning].includes(item.category))
-                .map((item) => SdBuildResultUtil.convertDiagsToResult(item))
+                .map((item) => SdCliBuildResultUtil.convertDiagsToResult(item))
                 .filterExists());
             if (results.some((item) => item.severity === "error")) {
                 return results;
@@ -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

@@ -30,8 +30,9 @@ export interface ISdCliPackageBuildResult {
     severity: "error" | "warning";
     message: string;
 }
-export interface ISdCliWorkspaceConfig {
+export interface ISdCliConfig {
     packages: Record<string, TSdCliPackageConfig | undefined>;
+    localUpdates?: Record<string, string>;
 }
 export declare type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig;
 export interface ISdCliLibPackageConfig {
@@ -41,3 +42,6 @@ export interface ISdCliLibPackageConfig {
 export interface ISdCliNgLibPackageConfig {
     type: "angular";
 }
+export interface ISdCliServerPackageConfig {
+    type: "server";
+}

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.mjs

@@ -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/entry-points/SdCliWorkspace.d.ts

@@ -1,9 +1,10 @@
 export declare class SdCliWorkspace {
     private readonly _rootPath;
+    private readonly _configFilePath?;
     private readonly _logger;
     private readonly _npmConfig;
     private readonly _config;
-    constructor(_rootPath: string);
+    constructor(_rootPath: string, _configFilePath?: string | undefined);
     watchAsync(): Promise<void>;
     buildAsync(): Promise<void>;
     private _buildPkgsAsync;

package/dist/entry-points/SdCliWorkspace.mjs

@@ -3,15 +3,16 @@ import path from "path";
 import { SdCliPackage } from "../packages/SdCliPackage";
 import { Wait } from "@simplysm/sd-core-common";
 import os from "os";
-import { SdBuildResultUtil } from "../utils/SdBuildResultUtil";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import semver from "semver/preload";
 export class SdCliWorkspace {
-    constructor(_rootPath) {
+    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, "simplysm.json"));
+        this._config = FsUtil.readJson(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"));
     }
     async watchAsync() {
         this._logger.debug("패키지 목록 구성...");
@@ -70,7 +71,12 @@ export class SdCliWorkspace {
             buildCompletedPackageNames.push(pkg.name);
         });
         this._loggingResults(totalResultMap);
-        this._logger.info("모든 빌드가 완료되었습니다.");
+        if (Array.from(totalResultMap.values()).mapMany().some((item) => item.severity === "error")) {
+            throw new Error("빌드중 오류가 발생하였습니다.");
+        }
+        else {
+            this._logger.info("모든 빌드가 완료되었습니다.");
+        }
     }
     async publishAsync(opt) {
         if (opt.noBuild) {
@@ -91,6 +97,7 @@ export class SdCliWorkspace {
         await this._upgradeVersionAsync(pkgs);
         // 빌드
         if (!opt.noBuild) {
+            this._logger.debug("빌드를 시작합니다...");
             await this._buildPkgsAsync(pkgs);
         }
         // GIT 사용중일경우, 새 버전 커밋 및 TAG 생성
@@ -106,7 +113,7 @@ export class SdCliWorkspace {
             await pkg.publishAsync();
             this._logger.debug(`[${pkg.name}] 배포가 완료되었습니다.`);
         });
-        this._logger.info("모든 배포가 완료되었습니다.");
+        this._logger.info(`모든 배포가 완료되었습니다. (v${this._npmConfig.version})`);
     }
     async _upgradeVersionAsync(pkgs) {
         // 작업공간 package.json 버전 설정
@@ -163,11 +170,11 @@ export class SdCliWorkspace {
             .orderBy((item) => item.pkgName + "_" + item.filePath);
         const warnings = totalResults
             .filter((item) => item.severity === "warning")
-            .map((item) => `${SdBuildResultUtil.getMessage(item)} (${item.pkgName})`)
+            .map((item) => `${SdCliBuildResultUtil.getMessage(item)} (${item.pkgName})`)
             .distinct();
         const errors = totalResults
             .filter((item) => item.severity === "error")
-            .map((item) => `${SdBuildResultUtil.getMessage(item)} (${item.pkgName})`)
+            .map((item) => `${SdCliBuildResultUtil.getMessage(item)} (${item.pkgName})`)
             .distinct();
         if (warnings.length > 0) {
             this._logger.warn(`경고 발생${os.EOL}`, warnings.join(os.EOL));
@@ -183,4 +190,4 @@ export class SdCliWorkspace {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SdCliWorkspace.js","sourceRoot":"","sources":["../../src/entry-points/SdCliWorkspace.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SdCliWorkspace.js","sourceRoot":"","sources":["../../src/entry-points/SdCliWorkspace.ts"],"names":[],"mappings":"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"}

package/dist/packages/SdCliPackage.mjs

@@ -51,7 +51,7 @@ export class SdCliPackage extends EventEmitter {
             await this._genBuildTsconfigAsync();
         }
         const isAngular = isTs && this.allDependencies.includes("@angular/core");
-        const builder = isTs ? new SdCliTsLibBuilder(this._rootPath, isAngular) : new SdCliJsLibBuilder(this._rootPath);
+        const builder = !isTs ? new SdCliJsLibBuilder(this._rootPath) : new SdCliTsLibBuilder(this._rootPath, isAngular);
         await builder
             .on("change", () => {
             this.emit("change");
@@ -72,7 +72,7 @@ export class SdCliPackage extends EventEmitter {
     }
     async publishAsync() {
         if (this._config.type === "library" && this._config.publish === "npm") {
-            await SdProcess.execAsync("npm publish --access public", { cwd: this._rootPath });
+            await SdProcess.execAsync("npm publish --quiet --access public", { cwd: this._rootPath });
         }
     }
     async _genBuildTsconfigAsync() {
@@ -86,4 +86,4 @@ export class SdCliPackage extends EventEmitter {
         await FsUtil.writeJsonAsync(buildTsconfigFilePath, buildTsconfig, { space: 2 });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/{SdBuildResultUtil.d.ts → SdCliBuildResultUtil.d.ts}

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import { ISdCliPackageBuildResult } from "../commons";
-export declare class SdBuildResultUtil {
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-cli",
-  "version": "7.0.6",
+  "version": "7.0.13",
   "description": "심플리즘 패키지 - CLI",
   "author": "김석래",
   "repository": {
@@ -35,7 +35,7 @@
     "@types/semver": "^7.3.9"
   },
   "peerDependencies": {
-    "@simplysm/sd-core-common": "7.0.6",
-    "@simplysm/sd-core-node": "7.0.6"
+    "@simplysm/sd-core-common": "7.0.13",
+    "@simplysm/sd-core-node": "7.0.13"
   }
 }

package/src/bin/sd-cli.ts

@@ -2,6 +2,7 @@ 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;
 
@@ -16,14 +17,49 @@ const argv = yargs(hideBin(process.argv))
       default: false
     }
   })
-  .command("watch", "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.")
-  .command("build", "프로젝트의 각 패키지에 대한 빌드를 수행합니다.")
+  .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
+    (cmd) => cmd.version(false)
       .options({
-        "noBuild":{
+        config: {
+          type: "string",
+          describe: "simplysm.json 파일 경로"
+        },
+        "noBuild": {
           type: "boolean",
           describe: "빌드를 하지않고 배포합니다.",
           default: false
@@ -50,16 +86,23 @@ else {
 const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
 
 (async () => {
-  if (argv._[0] === "watch") {
-    await new SdCliWorkspace(process.cwd()).watchAsync();
+  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()).buildAsync();
+    await new SdCliWorkspace(process.cwd(), argv.config)
+      .buildAsync();
   }
   else if (argv._[0] === "publish") {
-    await new SdCliWorkspace(process.cwd()).publishAsync({
-      noBuild: argv.noBuild
-    });
+    await new SdCliWorkspace(process.cwd(), argv.config)
+      .publishAsync({
+        noBuild: argv.noBuild
+      });
   }
   else {
     throw new Error(`명령어가 잘못 되었습니다.\n\t${argv._[0]}\n`);

package/src/build-tool/SdCliNgCacheCompilerHost.ts

@@ -28,7 +28,7 @@ export class SdCliNgCacheCompilerHost {
             url: new URL(context.containingFile + ".sd.scss"),
             importer: {
               findFileUrl: (url) => {
-                if (!url.startsWith("~")) return undefined;
+                if (!url.startsWith("~")) return null;
                 return new URL(url.substring(1), pathToFileURL("node_modules"));
               }
             }
@@ -47,4 +47,4 @@ interface IFileCache {
   sourceFile?: ts.SourceFile;
   content?: string;
   styleContent?: string;
-}
+}

package/src/builder/SdCliTsLibBuilder.ts

@@ -4,7 +4,7 @@ import ts from "typescript";
 import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import * as path from "path";
 import { createHash } from "crypto";
-import { SdBuildResultUtil } from "../utils/SdBuildResultUtil";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import { NgtscProgram } from "@angular/compiler-cli";
 import sass from "sass";
 import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
@@ -165,7 +165,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
       results.push(
         ...diagnostics
           .filter((item) => [ts.DiagnosticCategory.Error, ts.DiagnosticCategory.Warning].includes(item.category))
-          .map((item) => SdBuildResultUtil.convertDiagsToResult(item))
+          .map((item) => SdCliBuildResultUtil.convertDiagsToResult(item))
           .filterExists()
       );
 

package/src/commons.ts

@@ -34,8 +34,9 @@ export interface ISdCliPackageBuildResult {
   message: string;
 }
 
-export interface ISdCliWorkspaceConfig {
+export interface ISdCliConfig {
   packages: Record<string, TSdCliPackageConfig | undefined>;
+  localUpdates?: Record<string, string>;
 }
 
 export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig;
@@ -48,3 +49,7 @@ export interface ISdCliLibPackageConfig {
 export interface ISdCliNgLibPackageConfig {
   type: "angular";
 }
+
+export interface ISdCliServerPackageConfig {
+  type: "server";
+}

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/entry-points/SdCliWorkspace.ts

@@ -1,23 +1,24 @@
 import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
 import path from "path";
-import { INpmConfig, ISdCliPackageBuildResult, ISdCliWorkspaceConfig } from "../commons";
+import { INpmConfig, ISdCliConfig, ISdCliPackageBuildResult } from "../commons";
 import { SdCliPackage } from "../packages/SdCliPackage";
 import { Wait } from "@simplysm/sd-core-common";
 import os from "os";
-import { SdBuildResultUtil } from "../utils/SdBuildResultUtil";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import semver from "semver/preload";
 
 export class SdCliWorkspace {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
 
   private readonly _npmConfig: INpmConfig;
-  private readonly _config: ISdCliWorkspaceConfig;
+  private readonly _config: ISdCliConfig;
 
-  public constructor(private readonly _rootPath: string) {
+  public constructor(private readonly _rootPath: string,
+                     private readonly _configFilePath?: string) {
     const npmConfigFilePath = path.resolve(this._rootPath, "package.json");
     this._npmConfig = FsUtil.readJson(npmConfigFilePath);
 
-    this._config = FsUtil.readJson(path.resolve(this._rootPath, "simplysm.json"));
+    this._config = FsUtil.readJson(path.resolve(this._rootPath, this._configFilePath ?? "simplysm.json"));
   }
 
   public async watchAsync(): Promise<void> {
@@ -87,7 +88,12 @@ export class SdCliWorkspace {
     });
 
     this._loggingResults(totalResultMap);
-    this._logger.info("모든 빌드가 완료되었습니다.");
+    if (Array.from(totalResultMap.values()).mapMany().some((item) => item.severity === "error")) {
+      throw new Error("빌드중 오류가 발생하였습니다.");
+    }
+    else {
+      this._logger.info("모든 빌드가 완료되었습니다.");
+    }
   }
 
   public async publishAsync(opt: { noBuild: boolean }): Promise<void> {
@@ -113,6 +119,7 @@ export class SdCliWorkspace {
 
     // 빌드
     if (!opt.noBuild) {
+      this._logger.debug("빌드를 시작합니다...");
       await this._buildPkgsAsync(pkgs);
     }
 
@@ -130,7 +137,7 @@ export class SdCliWorkspace {
       await pkg.publishAsync();
       this._logger.debug(`[${pkg.name}] 배포가 완료되었습니다.`);
     });
-    this._logger.info("모든 배포가 완료되었습니다.");
+    this._logger.info(`모든 배포가 완료되었습니다. (v${this._npmConfig.version})`);
   }
 
   private async _upgradeVersionAsync(pkgs: SdCliPackage[]): Promise<void> {
@@ -197,12 +204,12 @@ export class SdCliWorkspace {
 
     const warnings = totalResults
       .filter((item) => item.severity === "warning")
-      .map((item) => `${SdBuildResultUtil.getMessage(item)} (${item.pkgName})`)
+      .map((item) => `${SdCliBuildResultUtil.getMessage(item)} (${item.pkgName})`)
       .distinct();
 
     const errors = totalResults
       .filter((item) => item.severity === "error")
-      .map((item) => `${SdBuildResultUtil.getMessage(item)} (${item.pkgName})`)
+      .map((item) => `${SdCliBuildResultUtil.getMessage(item)} (${item.pkgName})`)
       .distinct();
 
     if (warnings.length > 0) {

package/src/packages/SdCliPackage.ts

@@ -65,7 +65,7 @@ export class SdCliPackage extends EventEmitter {
     }
 
     const isAngular = isTs && this.allDependencies.includes("@angular/core");
-    const builder = isTs ? new SdCliTsLibBuilder(this._rootPath, isAngular) : new SdCliJsLibBuilder(this._rootPath);
+    const builder = !isTs ? new SdCliJsLibBuilder(this._rootPath) : new SdCliTsLibBuilder(this._rootPath, isAngular);
 
     await builder
       .on("change", () => {
@@ -92,7 +92,7 @@ export class SdCliPackage extends EventEmitter {
 
   public async publishAsync(): Promise<void> {
     if (this._config.type === "library" && this._config.publish === "npm") {
-      await SdProcess.execAsync("npm publish --access public", { cwd: this._rootPath });
+      await SdProcess.execAsync("npm publish --quiet --access public", { cwd: this._rootPath });
     }
   }
 

package/src/utils/{SdBuildResultUtil.ts → SdCliBuildResultUtil.ts}

@@ -3,7 +3,7 @@ import * as os from "os";
 import * as path from "path";
 import { ISdCliPackageBuildResult } from "../commons";
 
-export class SdBuildResultUtil {
+export class SdCliBuildResultUtil {
   public static convertDiagsToResult(diag: ts.Diagnostic): ISdCliPackageBuildResult | undefined {
     const severity = diag.category === ts.DiagnosticCategory.Error ? "error"
       : diag.category === ts.DiagnosticCategory.Warning ? "warning"

package/src/utils/SdCliConfigUtil.ts

@@ -0,0 +1,94 @@
+import { ISdCliConfig, TSdCliPackageConfig } from "../commons";
+import { FsUtil } from "@simplysm/sd-core-node";
+import { ObjectUtil } from "@simplysm/sd-core-common";
+import path from "path";
+
+export class SdCliConfigUtil {
+  public static loadConfig(confFilePath: string, isDev: boolean, opts?: string[]): ISdCliConfig {
+    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 as ISdCliConfig;
+  }
+
+  private static _getConfigFromFileContent(confFileCont: ISdCliConfigFileContent, isDev: boolean, opts?: string[]): ISdCliConfigFileContent {
+    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;
+  }
+
+  private static _getPkgConfigFromFileContent(confFileCont: ISdCliConfigFileContent, pkgConfFileCont: TSdCliPackageConfigFileContent, isDev: boolean, opts?: string[]): TSdCliPackageConfig {
+    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;
+  }
+
+  private static _mergeObj<A, B>(org: A, target: B): A & B {
+    return ObjectUtil.merge(org, target, {
+      arrayProcess: "replace",
+      useDelTargetUndefined: true
+    });
+  }
+}
+
+interface ISdCliConfigFileContent {
+  packages?: Record<string, TSdCliPackageConfigFileContent>;
+  overrides?: Record<string, TSdCliPackageConfigFileContent>;
+  extends?: string[];
+}
+
+type TSdCliPackageConfigFileContent =
+  TSdCliPackageConfig
+  & { overrides?: string[] }
+  & Record<string, any>;

package/dist/utils/SdBuildResultUtil.mjs

@@ -1,38 +0,0 @@
-import ts from "typescript";
-import * as os from "os";
-import * as path from "path";
-export class SdBuildResultUtil {
-    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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