@simplysm/sd-cli 7.0.210 → 7.0.220

package/src/builder/SdCliClientBuilder.ts

@@ -16,10 +16,6 @@ import MiniCssExtractPlugin from "mini-css-extract-plugin";
 import { AngularWebpackPlugin } from "@ngtools/webpack";
 import { IndexHtmlWebpackPlugin } from "@angular-devkit/build-angular/src/webpack/plugins/index-html-webpack-plugin";
 import { SassWorkerImplementation } from "@angular-devkit/build-angular/src/sass/sass-service";
-import { HmrLoader } from "@angular-devkit/build-angular/src/webpack/plugins/hmr/hmr-loader";
-import wdm from "webpack-dev-middleware";
-import whm from "webpack-hot-middleware";
-import { NextHandleFunction } from "connect";
 import { LicenseWebpackPlugin } from "license-webpack-plugin";
 import NodePolyfillPlugin from "node-polyfill-webpack-plugin";
 import { createHash } from "crypto";
@@ -94,7 +90,7 @@ export class SdCliClientBuilder extends EventEmitter {
     return super.on(event, listener);
   }
 
-  public async watchAsync(): Promise<NextHandleFunction[]> {
+  public async watchAsync(): Promise<void> {
     // DIST 비우기
     await FsUtil.removeAsync(path.resolve(this._rootPath, ".electron"));
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
@@ -102,7 +98,7 @@ export class SdCliClientBuilder extends EventEmitter {
     // NgModule 생성
     await this._ngModuleGenerator.runAsync();
 
-    // CORDOVA
+    // CORDOVA 초기화
     if (this._cordova) {
       this._logger.debug("CORDOVA 구성...");
       await this._cordova.initializeAsync();
@@ -112,7 +108,7 @@ export class SdCliClientBuilder extends EventEmitter {
     const webpackConfigs = (Object.keys(this._config.builder ?? { web: {} }) as ("web" | "cordova" | "electron")[])
       .map((builderType) => this._getWebpackConfig(true, builderType));
     const multiCompiler = webpack(webpackConfigs);
-    return await new Promise<NextHandleFunction[]>((resolve, reject) => {
+    await new Promise<void>((resolve, reject) => {
       multiCompiler.hooks.invalid.tap(this.constructor.name, (fileName) => {
         if (fileName != null) {
           this._logger.debug("파일변경 감지", fileName);
@@ -132,22 +128,20 @@ export class SdCliClientBuilder extends EventEmitter {
         this._logger.debug("Webpack 빌드 수행...");
       });
 
-      for (const compiler of multiCompiler.compilers) {
-        compiler.hooks.failed.tap(this.constructor.name, (err) => {
+      multiCompiler.watch({}, async (err, multiStats) => {
+        if (err != null || multiStats == null) {
           this.emit("complete", [{
             filePath: undefined,
             line: undefined,
             char: undefined,
             code: undefined,
             severity: "error",
-            message: err.stack
+            message: err?.stack ?? "알 수 없는 오류 (multiStats=null)"
           }]);
           reject(err);
           return;
-        });
-      }
+        }
 
-      multiCompiler.hooks.done.tap(this.constructor.name, async (multiStats) => {
         // 결과 반환
         const results = multiStats.stats.mapMany((stats) => SdCliBuildResultUtil.convertFromWebpackStats(stats));
 
@@ -162,22 +156,10 @@ export class SdCliClientBuilder extends EventEmitter {
 
         // 마무리
         this._logger.debug("Webpack 빌드 완료");
-        resolve(middlewares);
+        resolve();
 
         this.emit("complete", results);
       });
-
-      const middlewares = multiCompiler.compilers.mapMany((compiler) => [
-        wdm(compiler, {
-          publicPath: compiler.options.output.publicPath,
-          index: "index.html",
-          stats: false
-        }),
-        whm(compiler, {
-          path: `${compiler.options.output.publicPath}__webpack_hmr`,
-          log: false
-        })
-      ]);
     });
   }
 
@@ -189,6 +171,12 @@ export class SdCliClientBuilder extends EventEmitter {
     // NgModule 생성
     await this._ngModuleGenerator.runAsync();
 
+    // CORDOVA 초기화
+    if (this._cordova) {
+      this._logger.debug("CORDOVA 구성...");
+      await this._cordova.initializeAsync();
+    }
+
     // 빌드
     this._logger.debug("Webpack 빌드 수행...");
     const builderTypes = (Object.keys(this._config.builder ?? { web: {} }) as ("web" | "cordova" | "electron")[]);
@@ -222,11 +210,8 @@ export class SdCliClientBuilder extends EventEmitter {
       );
     }
 
-    // CORDOVA
+    // CORDOVA 빌드
     if (this._cordova) {
-      this._logger.debug("CORDOVA 구성...");
-      await this._cordova.initializeAsync();
-
       this._logger.debug("CORDOVA 빌드...");
       await this._cordova.buildAsync(path.resolve(this._parsedTsconfig.options.outDir!, "cordova"));
     }
@@ -245,6 +230,8 @@ export class SdCliClientBuilder extends EventEmitter {
         throw new Error("ELECTRON 빌드 패키지의 'dependencies'에는 'dotenv'가 반드시 포함되어야 합니다.");
       }
 
+      const remoteVersion = npmConfig.dependencies?.["@electron/remote"];
+
       const electronSrcPath = path.resolve(this._rootPath, `.electron/src`);
       const electronDistPath = path.resolve(this._rootPath, `.electron/dist`);
 
@@ -259,7 +246,10 @@ export class SdCliClientBuilder extends EventEmitter {
           "electron": electronVersion.replace("^", "")
         },
         dependencies: {
-          "dotenv": dotenvVersion
+          "dotenv": dotenvVersion,
+          ...remoteVersion !== undefined ? {
+            "@electron/remote": remoteVersion
+          } : {}
         }
       });
 
@@ -325,8 +315,6 @@ export class SdCliClientBuilder extends EventEmitter {
     const internalModuleCachePaths = watch ? this._getInternalModuleCachePaths(workspaceName) : undefined;
 
     const npmConfig = this._getNpmConfig(this._rootPath)!;
-    // const pkgVersion = npmConfig.version;
-    // const ngVersion = this._getNpmConfig(FsUtil.findAllParentChildDirPaths("node_modules/@angular/core", this._rootPath, this._workspaceRootPath)[0])!.version;
 
     const workspacePkgLockContent = FsUtil.readFile(path.resolve(this._workspaceRootPath, "package-lock.json"));
 
@@ -334,7 +322,6 @@ export class SdCliClientBuilder extends EventEmitter {
     const publicPath = builderType === "web" ? `/${pkgKey}/` : watch ? `/${pkgKey}/${builderType}/` : ``;
 
     const cacheBasePath = path.resolve(this._rootPath, ".cache");
-    // const cachePath = path.resolve(cacheBasePath, pkgVersion);
 
     const distPath = (builderType === "cordova" && !watch) ? path.resolve(this._cordova!.cordovaPath, "www")
       : (builderType === "electron" && !watch) ? path.resolve(this._rootPath, ".electron/src")
@@ -355,7 +342,7 @@ export class SdCliClientBuilder extends EventEmitter {
       profile: false,
       resolve: {
         roots: [this._rootPath],
-        extensions: [".ts", ".tsx", ".mjs", ".cjs", ".js"],
+        extensions: [".ts", ".tsx", ".mjs", ".cjs", ".js", ".jsx"],
         symlinks: true,
         modules: [this._workspaceRootPath, "node_modules"],
         mainFields: ["es2015", "browser", "module", "main"],
@@ -366,14 +353,9 @@ export class SdCliClientBuilder extends EventEmitter {
       },
       context: this._workspaceRootPath,
       entry: {
-        main: [
-          ...watch ? [
-            `webpack-hot-middleware/client?path=${publicPath}__webpack_hmr&timeout=20000&reload=true&overlay=true`
-          ] : [],
-          mainFilePath
-        ],
-        ...FsUtil.exists(polyfillsFilePath) ? { polyfills: polyfillsFilePath } : {},
-        ...FsUtil.exists(stylesFilePath) ? { styles: stylesFilePath } : {}
+        main: [mainFilePath],
+        ...FsUtil.exists(polyfillsFilePath) ? { polyfills: [polyfillsFilePath] } : {},
+        ...FsUtil.exists(stylesFilePath) ? { styles: [stylesFilePath] } : {}
       },
       output: {
         uniqueName: pkgKey,
@@ -389,7 +371,10 @@ export class SdCliClientBuilder extends EventEmitter {
         scriptType: "module"
       },
       watch: false,
-      watchOptions: { poll: undefined, ignored: undefined },
+      watchOptions: {
+        poll: undefined,
+        ignored: undefined
+      },
       performance: { hints: false },
       ignoreWarnings: [
         /Failed to parse source map from/,
@@ -411,7 +396,6 @@ export class SdCliClientBuilder extends EventEmitter {
           .update(watch.toString())
           .digest("hex")
       },
-      // cache: { type: "memory", maxGenerations: 1 },
       ...watch ? {
         snapshot: {
           immutablePaths: internalModuleCachePaths,
@@ -484,27 +468,6 @@ export class SdCliClientBuilder extends EventEmitter {
             test: /[/\\]rxjs[/\\]add[/\\].+\.js$/,
             sideEffects: true
           },
-          ...watch ? [
-            {
-              loader: HmrLoader,
-              include: [mainFilePath]
-            }
-          ] : [],
-          ...watch ? [
-            {
-              test: /\.[cm]?jsx?$/,
-              enforce: "pre" as const,
-              loader: "source-map-loader",
-              options: {
-                filterSourceMappingUrl: (mapUri: string, resourcePath: string) => {
-                  const workspaceRegex = new RegExp(`node_modules[\\\\/]@${workspaceName}[\\\\/]`);
-                  return !resourcePath.includes("node_modules")
-                    || (/node_modules[\\/]@simplysm[\\/]/).test(resourcePath)
-                    || workspaceRegex.test(resourcePath);
-                }
-              }
-            }
-          ] : [],
           {
             test: /\.[cm]?[tj]sx?$/,
             resolve: { fullySpecified: false },
@@ -522,10 +485,25 @@ export class SdCliClientBuilder extends EventEmitter {
               }
             ]
           },
+          ...watch ? [
+            {
+              test: /\.[cm]?jsx?$/,
+              enforce: "pre" as const,
+              loader: "source-map-loader",
+              options: {
+                filterSourceMappingUrl: (mapUri: string, resourcePath: string) => {
+                  const workspaceRegex = new RegExp(`node_modules[\\\\/]@${workspaceName}[\\\\/]`);
+                  return !resourcePath.includes("node_modules")
+                    || (/node_modules[\\/]@simplysm[\\/]/).test(resourcePath)
+                    || workspaceRegex.test(resourcePath);
+                }
+              }
+            }
+          ] : [],
           {
             test: /\.[cm]?tsx?$/,
             loader: "@ngtools/webpack",
-            exclude: [/[/\\](?:css-loader|mini-css-extract-plugin|webpack-dev-server|webpack)[/\\]/]
+            exclude: [/[/\\](?:css-loader|mini-css-extract-plugin|webpack)[/\\]/]
           },
           {
             test: /\.css$/i,
@@ -678,9 +656,6 @@ export class SdCliClientBuilder extends EventEmitter {
           emitNgModuleScope: watch,
           inlineStyleFileExtension: "scss"
         }),
-        // new AnyComponentStyleBudgetChecker(watch ? [] : [
-        //   { type: Type.AnyComponentStyle, maximumWarning: "2kb", maximumError: "4kb" }
-        // ]),
         {
           apply: (compiler: webpack.Compiler) => {
             compiler.hooks.shutdown.tap("sass-worker", () => {
@@ -690,13 +665,12 @@ export class SdCliClientBuilder extends EventEmitter {
         },
         new MiniCssExtractPlugin({ filename: "[name].css" }),
         new SuppressExtractedTextChunksWebpackPlugin(),
-        // NgBuildAnalyticsPlugin,
         new IndexHtmlWebpackPlugin({
           indexPath: path.resolve(this._rootPath, "src/index.html"),
           outputPath: "index.html",
           baseHref: publicPath,
           entrypoints: [
-            ["runtime", true],
+            ["runtime", !watch],
             ["polyfills", true],
             ["styles", false],
             ["vendor", true],
@@ -718,9 +692,6 @@ export class SdCliClientBuilder extends EventEmitter {
           crossOrigin: "none",
           lang: undefined
         }),
-        ...watch ? [
-          new webpack.HotModuleReplacementPlugin()
-        ] : [],
         new webpack.EnvironmentPlugin({
           SD_VERSION: this._getNpmConfig(this._rootPath)!.version,
           ...this._config.env

package/src/builder/SdCliServerBuilder.ts

@@ -58,6 +58,14 @@ export class SdCliServerBuilder extends EventEmitter {
 
       compiler.watch({}, async (err, stats) => {
         if (err != null || stats == null) {
+          this.emit("complete", [{
+            filePath: undefined,
+            line: undefined,
+            char: undefined,
+            code: undefined,
+            severity: "error",
+            message: err?.stack ?? "알 수 없는 오류 (stats=null)"
+          }]);
           reject(err);
           return;
         }

package/src/entry-points/SdCliWorkspace.ts

@@ -8,8 +8,9 @@ import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import semver from "semver/preload";
 import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
 import { SdServiceServer } from "@simplysm/sd-service-server";
-import { SdCliNpm } from "./SdCliNpm";
 import { SdCliLocalUpdate } from "./SdCliLocalUpdate";
+import url from "url";
+import mime from "mime";
 import { NextHandleFunction } from "connect";
 
 export class SdCliWorkspace {
@@ -37,6 +38,7 @@ export class SdCliWorkspace {
 
     this._logger.debug("패키지 이벤트 설정...");
     let changeCount = 0;
+    let changePkgs: SdCliPackage[] = [];
     const totalResultMap = new Map<string, ISdCliPackageBuildResult[]>();
     for (const pkg of pkgs) {
       pkg
@@ -47,17 +49,35 @@ export class SdCliWorkspace {
           changeCount++;
           this._logger.debug(`[${pkg.name}] 빌드를 시작합니다...`);
         })
-        .on("complete", async (results) => {
-          if (pkg.config.type === "server" && !results.some((item) => item.severity === "error")) {
-            await this._restartServerAsync(pkg);
-          }
+        .on("complete", (results) => {
+          changePkgs.push(pkg);
 
           this._logger.debug(`[${pkg.name}] 빌드가 완료되었습니다.`);
           totalResultMap.set(pkg.name, results);
 
-          setTimeout(() => {
+          setTimeout(async () => {
             changeCount--;
             if (changeCount === 0) {
+              const currChangePkgs = [...changePkgs];
+              changePkgs = [];
+
+              for (const changePkg of currChangePkgs) {
+                if (changePkg.config.type === "server" && !results.some((item) => item.severity === "error")) {
+                  await this._restartServerAsync(changePkg);
+                }
+
+                if (changePkg.config.type === "client") {
+                  if (typeof changePkg.config.server === "string") {
+                    const serverInfo = this._serverInfoMap.get(changePkg.config.server);
+                    serverInfo?.server?.broadcastReload();
+                  }
+                  else {
+                    const serverInfo = this._serverInfoMap.get("PORT:" + changePkg.config.server.port);
+                    serverInfo?.server?.broadcastReload();
+                  }
+                }
+              }
+
               this._loggingResults(totalResultMap);
               this._loggingOpenClientHrefs();
               this._logger.info("모든 빌드가 완료되었습니다.");
@@ -78,11 +98,37 @@ export class SdCliWorkspace {
       await pkgs.parallelAsync(async (pkg) => {
         await Wait.until(() => !pkg.allDependencies.some((dep) => pkgNames.includes(dep) && !buildCompletedPackageNames.includes(dep)));
         if (pkg.config.type === "client") {
-          const middlewares = (await pkg.watchAsync()) as NextHandleFunction[];
+          await pkg.watchAsync();
+
+          const pkgMiddleware: NextHandleFunction = (req, res, next) => {
+            if (req.method === "GET") {
+              const urlObj = url.parse(req.url!, true, false);
+              const urlPathChain = decodeURI(urlObj.pathname!.slice(1)).split("/");
+              if (urlPathChain[0] === pkg.name.split("/").last()!) {
+                let targetFilePath = path.resolve(pkg.rootPath, "dist", ...urlPathChain.slice(1));
+                targetFilePath = FsUtil.exists(targetFilePath) && FsUtil.stat(targetFilePath).isDirectory() ? path.resolve(targetFilePath, "index.html") : targetFilePath;
+
+                if (FsUtil.exists(targetFilePath) && !path.basename(targetFilePath).startsWith(".")) {
+                  const fileStream = FsUtil.createReadStream(targetFilePath);
+                  const targetFileSize = FsUtil.lstat(targetFilePath).size;
+
+                  fileStream.on("open", () => {
+                    res.setHeader("Content-Length", targetFileSize);
+                    res.setHeader("Content-Type", mime.getType(targetFilePath)!);
+                    res.writeHead(200);
+                  });
+                  fileStream.pipe(res);
+                  return;
+                }
+              }
+            }
+
+            next();
+          };
 
           if (typeof pkg.config.server === "string") {
             const serverInfo = this._serverInfoMap.getOrCreate(pkg.config.server, { middlewares: [], clientInfos: [] });
-            serverInfo.middlewares.push(...middlewares);
+            serverInfo.middlewares.push(pkgMiddleware);
             serverInfo.clientInfos.push({
               pkgKey: pkg.name.split("/").last()!,
               platforms: pkg.config.builder ? Object.keys(pkg.config.builder) : ["web"],
@@ -90,7 +136,10 @@ export class SdCliWorkspace {
             });
           }
           else { // DEV SERVER
-            const serverInfo = this._serverInfoMap.getOrCreate("_", { middlewares: [], clientInfos: [] });
+            const serverInfo = this._serverInfoMap.getOrCreate("PORT:" + pkg.config.server.port, {
+              middlewares: [],
+              clientInfos: []
+            });
             if (serverInfo.server === undefined) {
               const server = new SdServiceServer({
                 rootPath: process.cwd(),
@@ -99,7 +148,7 @@ export class SdCliWorkspace {
               });
               await server.listenAsync();
               serverInfo.server = server;
-              serverInfo.server.devMiddlewares = middlewares;
+              serverInfo.server.devMiddlewares = [pkgMiddleware];
               serverInfo.clientInfos.push({
                 pkgKey: pkg.name.split("/").last()!,
                 platforms: pkg.config.builder ? Object.keys(pkg.config.builder) : ["web"],
@@ -245,8 +294,8 @@ export class SdCliWorkspace {
 
     // 빌드
     if (!opt.noBuild) {
-      this._logger.debug("노드패키지 업데이트...");
-      await new SdCliNpm(this._rootPath).updateAsync();
+      // this._logger.debug("노드패키지 업데이트...");
+      // await new SdCliNpm(this._rootPath).updateAsync();
 
       this._logger.debug("빌드를 시작합니다...");
       await this._buildPkgsAsync(pkgs);

package/src/packages/SdCliPackage.ts

@@ -2,16 +2,13 @@ import { INpmConfig, ISdCliPackageBuildResult, ITsconfig, TSdCliPackageConfig }
 import path from "path";
 import { FsUtil, PathUtil, SdProcess } from "@simplysm/sd-core-node";
 import { EventEmitter } from "events";
-import { NeverEntryError, ObjectUtil, StringUtil } from "@simplysm/sd-core-common";
-import { SdCliTsLibBuilder } from "../builder/SdCliTsLibBuilder";
-import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
-import { SdCliServerBuilder } from "../builder/SdCliServerBuilder";
+import { JsonConvert, NeverEntryError, ObjectUtil, StringUtil } from "@simplysm/sd-core-common";
 import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
-import { SdCliClientBuilder } from "../builder/SdCliClientBuilder";
-import { NextHandleFunction } from "connect";
 import { SdStorage } from "@simplysm/sd-storage";
 import ts from "typescript";
 import { SdCliGithubApi } from "../build-tool/SdCliGithubApi";
+import cp from "child_process";
+import { fileURLToPath } from "url";
 
 export class SdCliPackage extends EventEmitter {
   private readonly _npmConfig: INpmConfig;
@@ -70,19 +67,91 @@ export class SdCliPackage extends EventEmitter {
     await FsUtil.writeJsonAsync(npmConfigFilePath, this._npmConfig, { space: 2 });
   }
 
-  public async watchAsync(): Promise<NextHandleFunction[] | void> {
-    return await (await this._createBuilderAsync())
-      .on("change", () => {
-        this.emit("change");
-      })
-      .on("complete", (results) => {
-        this.emit("complete", results);
-      })
-      .watchAsync();
+  public async watchAsync(): Promise<void> {
+    const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
+
+    if (isTs) {
+      await this._genBuildTsconfigAsync();
+    }
+
+    const workerPath = fileURLToPath(await import.meta.resolve!("../worker/build-worker"));
+    await new Promise<void>((resolve, reject) => {
+      const worker = cp.fork(workerPath, [
+        "watch",
+        this.rootPath,
+        JsonConvert.stringify(this.config),
+        this._workspaceRootPath
+      ], {
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+        env: process.env
+      });
+
+      worker.on("error", (err) => {
+        reject(err);
+      });
+
+      worker.stdout!.pipe(process.stdout);
+      worker.stderr!.pipe(process.stderr);
+
+      worker.on("message", (json: string) => {
+        const msg = JsonConvert.parse(json);
+        if (msg.event === "ready") {
+          resolve();
+        }
+        else if (msg.event === "change") {
+          this.emit("change");
+        }
+        else if (msg.event === "complete") {
+          this.emit("complete", msg.body);
+        }
+        else {
+          throw new NeverEntryError();
+        }
+      });
+    });
   }
 
   public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
-    return await (await this._createBuilderAsync()).buildAsync();
+    const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
+
+    if (isTs) {
+      await this._genBuildTsconfigAsync();
+    }
+
+    const workerPath = fileURLToPath(await import.meta.resolve!("../worker/build-worker"));
+    return await new Promise<ISdCliPackageBuildResult[]>((resolve, reject) => {
+      const worker = cp.fork(workerPath, [
+        "build",
+        this.rootPath,
+        JsonConvert.stringify(this.config),
+        this._workspaceRootPath
+      ], {
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+        env: process.env
+      });
+
+      worker.on("error", (err) => {
+        reject(err);
+      });
+
+      worker.stdout!.pipe(process.stdout);
+      worker.stderr!.pipe(process.stderr);
+
+      let result: ISdCliPackageBuildResult[] = [];
+
+      worker.on("message", (json: string) => {
+        result = JsonConvert.parse(json);
+      });
+
+      worker.on("exit", (code) => {
+        if (code !== 0) {
+          reject(new Error(`오류와 함께 닫힘 (${code})`));
+          return;
+        }
+
+        resolve(result);
+      });
+    });
   }
 
   public async publishAsync(): Promise<void> {
@@ -156,24 +225,6 @@ export class SdCliPackage extends EventEmitter {
     }
   }
 
-  private async _createBuilderAsync(): Promise<SdCliJsLibBuilder | SdCliTsLibBuilder | SdCliServerBuilder | SdCliClientBuilder> {
-    const isTs = FsUtil.exists(path.resolve(this.rootPath, "tsconfig.json"));
-
-    if (isTs) {
-      await this._genBuildTsconfigAsync();
-    }
-
-    if (this.config.type === "library") {
-      return isTs ? new SdCliTsLibBuilder(this.rootPath, this.config, this._workspaceRootPath) : new SdCliJsLibBuilder(this.rootPath);
-    }
-    else if (this.config.type === "server") {
-      return new SdCliServerBuilder(this.rootPath, this.config, this._workspaceRootPath);
-    }
-    else {
-      return new SdCliClientBuilder(this.rootPath, this.config, this._workspaceRootPath);
-    }
-  }
-
   private async _genBuildTsconfigAsync(): Promise<void> {
     const baseTsconfigFilePath = path.resolve(this.rootPath, "tsconfig.json");
     const baseTsconfig: ITsconfig = await FsUtil.readJsonAsync(baseTsconfigFilePath);

package/src/utils/SdCliConfigUtil.ts

@@ -74,10 +74,10 @@ export class SdCliConfigUtil {
     return pkgConf;
   }
 
-  private static _mergeObj<A, B>(org: A, target: B): A & B {
-    return ObjectUtil.merge(org, target, {
+  private static _mergeObj<A, B>(orig: A, target: B): A & B {
+    return ObjectUtil.merge(orig, target, {
       arrayProcess: "replace",
-      useDelTargetUndefined: true
+      useDelTargetNull: true
     });
   }
 }

package/src/worker/build-worker.ts

@@ -0,0 +1,74 @@
+import { SdCliTsLibBuilder } from "../builder/SdCliTsLibBuilder";
+import { SdCliJsLibBuilder } from "../builder/SdCliJsLibBuilder";
+import { SdCliServerBuilder } from "../builder/SdCliServerBuilder";
+import { SdCliClientBuilder } from "../builder/SdCliClientBuilder";
+import { FsUtil, Logger, LoggerSeverity } from "@simplysm/sd-core-node";
+import path from "path";
+import { JsonConvert } from "@simplysm/sd-core-common";
+import { TSdCliPackageConfig } from "../commons";
+
+
+if (process.env["SD_CLI_LOGGER_SEVERITY"] === "DEBUG") {
+  Logger.setConfig({
+    console: {
+      level: LoggerSeverity.debug
+    }
+  });
+}
+else {
+  Logger.setConfig({
+    dot: true
+  });
+}
+
+const type = process.argv[2] as ("build" | "watch");
+const rootPath = process.argv[3];
+const config = JsonConvert.parse(process.argv[4]) as TSdCliPackageConfig;
+const workspaceRootPath = process.argv[5];
+
+function createBuilder(): SdCliJsLibBuilder | SdCliTsLibBuilder | SdCliServerBuilder | SdCliClientBuilder {
+  const isTs = FsUtil.exists(path.resolve(rootPath, "tsconfig.json"));
+
+  if (config.type === "library") {
+    return isTs ? new SdCliTsLibBuilder(rootPath, config, workspaceRootPath) : new SdCliJsLibBuilder(rootPath);
+  }
+  else if (config.type === "server") {
+    return new SdCliServerBuilder(rootPath, config, workspaceRootPath);
+  }
+  else {
+    return new SdCliClientBuilder(rootPath, config, workspaceRootPath);
+  }
+}
+
+const builder = createBuilder();
+
+if (type === "build") {
+  builder.buildAsync()
+    .then((result) => {
+      process.send!(JsonConvert.stringify(result));
+      process.exit(0);
+    })
+    .catch((err) => {
+      // eslint-disable-next-line no-console
+      console.error(err);
+      process.exit(1);
+    });
+}
+else {
+  builder
+    .on("change", () => {
+      process.send!(JsonConvert.stringify({ event: "change" }));
+    })
+    .on("complete", (results) => {
+      process.send!(JsonConvert.stringify({ event: "complete", body: results }));
+    })
+    .watchAsync()
+    .then(() => {
+      process.send!(JsonConvert.stringify({ event: "ready" }));
+    })
+    .catch((err) => {
+      // eslint-disable-next-line no-console
+      console.error(err);
+      process.exit(1);
+    });
+}

package/tsconfig-build.json

@@ -9,6 +9,7 @@
   },
   "files": [
     "src/bin/sd-cli.ts",
-    "src/index.ts"
+    "src/index.ts",
+    "src/worker/build-worker.ts"
   ]
 }