@simplysm/sd-cli 12.5.23 → 12.5.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-cli",
-  "version": "12.5.23",
+  "version": "12.5.26",
   "description": "심플리즘 패키지 - CLI",
   "author": "김석래",
   "repository": {
@@ -17,18 +17,18 @@
     "postinstall": "node lib/postinstall.js"
   },
   "dependencies": {
-    "@angular/build": "^18.2.7",
-    "@angular/compiler": "^18.2.7",
-    "@angular/compiler-cli": "^18.2.7",
+    "@angular/build": "^18.2.8",
+    "@angular/compiler": "^18.2.8",
+    "@angular/compiler-cli": "^18.2.8",
     "@electron/rebuild": "^3.7.0",
-    "@simplysm/sd-core-common": "12.5.23",
-    "@simplysm/sd-core-node": "12.5.23",
-    "@simplysm/sd-service-server": "12.5.23",
-    "@simplysm/sd-storage": "12.5.23",
+    "@simplysm/sd-core-common": "12.5.26",
+    "@simplysm/sd-core-node": "12.5.26",
+    "@simplysm/sd-service-server": "12.5.26",
+    "@simplysm/sd-storage": "12.5.26",
     "browserslist": "^4.24.0",
     "cordova": "^12.0.0",
     "css-has-pseudo": "^7.0.0",
-    "electron": "^32.1.2",
+    "electron": "^32.2.0",
     "electron-builder": "^25.1.8",
     "esbuild": "^0.24.0",
     "eslint": "^9.12.0",
@@ -37,7 +37,7 @@
     "node-stdlib-browser": "^1.2.1",
     "postcss": "^8.4.47",
     "rxjs": "^7.8.1",
-    "sass": "^1.79.4",
+    "sass": "^1.79.5",
     "semver": "^7.6.3",
     "specifier-resolution-node": "^1.1.4",
     "typescript": "~5.5.4",

package/src/entry/SdCliCordova.ts

@@ -50,11 +50,12 @@ export class SdCliCordova {
     const alreadyPlatforms = FsUtil.readdir(path.resolve(cordovaPath, "platforms"));
     for (const platform of this._platforms) {
       if (!alreadyPlatforms.includes(platform)) {
-        if (platform === "android") {
-          await this._execAsync(`${BIN_PATH} platform add ${platform}@12.0.0`, cordovaPath);
-        } else {
-          await this._execAsync(`${BIN_PATH} platform add ${platform}`, cordovaPath);
-        }
+        await this._execAsync(`${BIN_PATH} platform add ${platform}`, cordovaPath);
+        // if (platform === "android") {
+        //   await this._execAsync(`${BIN_PATH} platform add ${platform}@12.0.0`, cordovaPath);
+        // } else {
+        //   await this._execAsync(`${BIN_PATH} platform add ${platform}`, cordovaPath);
+        // }
       }
     }
 

package/src/entry/SdCliElectron.ts

@@ -135,7 +135,7 @@ export class SdCliElectron {
         },
         ...(pkgConf.builder.electron.installerIcon !== undefined
           ? {
-              icon: path.resolve(pkgPath, "src", pkgConf.builder.electron.installerIcon),
+              icon: path.resolve(pkgPath, pkgConf.builder.electron.installerIcon),
             }
           : {}),
         removePackageScripts: false,
@@ -209,7 +209,7 @@ export class SdCliElectron {
         },
         ...(opt.config.installerIcon !== undefined
           ? {
-              icon: path.resolve(opt.pkgPath, "src", opt.config.installerIcon),
+              icon: path.resolve(opt.pkgPath, opt.config.installerIcon),
             }
           : {}),
         removePackageScripts: false,

package/src/entry/SdCliLocalUpdate.ts

@@ -45,9 +45,9 @@ export class SdCliLocalUpdate {
     const updatePathInfos = this.#getUpdatePathInfos(projConf.localUpdates);
     logger.debug("로컬 업데이트 구성");
 
-    const watchPaths = updatePathInfos.mapMany((item) => this.#getWatchPaths(item.source)).distinct();
+    // const watchPaths = updatePathInfos.mapMany((item) => this.#getWatchPaths(item.source)).distinct();
 
-    const watcher = SdFsWatcher.watch(watchPaths);
+    const watcher = SdFsWatcher.watch(updatePathInfos.map((item) => item.source));
     watcher.onChange({ delay: 500 }, (changedInfos) => {
       const changedFileInfos = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event));
       if (changedFileInfos.length === 0) return;
@@ -71,9 +71,9 @@ export class SdCliLocalUpdate {
         }
       }
 
-      const watchFileSet = new Set(updatePathInfos.mapMany((item) => this.#getWatchPaths(item.source)));
-
-      watcher.replaceWatchPaths(watchFileSet);
+      // const watchFileSet = new Set(updatePathInfos.mapMany((item) => this.#getWatchPaths(item.source)));
+      //
+      // watcher.replaceWatchPaths(watchFileSet);
 
       logger.info("로컬 라이브러리 복사 완료");
     });
@@ -110,9 +110,9 @@ export class SdCliLocalUpdate {
     return result;
   }
 
-  static #getWatchPaths(sourcePath: string): string[] {
+  /*static #getWatchPaths(sourcePath: string): string[] {
     return FsUtil.glob(path.resolve(sourcePath, "**"));
-  }
+  }*/
 }
 
 interface IUpdatePathInfo {

package/src/entry/SdCliProject.ts

@@ -103,10 +103,10 @@ export class SdCliProject {
     await this._upgradeVersionAsync(projNpmConf, allPkgPaths);
 
     logger.debug("빌드 프로세스 시작...");
-    const parallelBuildRunner = new SdMultiBuildRunner();
+    const multiBuildRunner = new SdMultiBuildRunner();
 
     const messages = await pkgPaths.parallelAsync(async (pkgPath) => {
-      return await parallelBuildRunner.runAsync({
+      return await multiBuildRunner.runAsync({
         cmd: "build",
         pkgPath,
         projConf: projConf,
@@ -165,10 +165,10 @@ export class SdCliProject {
     // 빌드
     if (!opt.noBuild) {
       logger.debug("빌드 프로세스 시작...");
-      const parallelBuildRunner = new SdMultiBuildRunner();
+      const multiBuildRunner = new SdMultiBuildRunner();
 
       const messages = await pkgPaths.parallelAsync(async (pkgPath) => {
-        return await parallelBuildRunner.runAsync({
+        return await multiBuildRunner.runAsync({
           cmd: "build",
           pkgPath,
           projConf: projConf,

package/src/index.ts

@@ -16,8 +16,8 @@ export * from "./pkg-builders/server/createSdServerPlugin";
 export * from "./pkg-builders/server/SdServerBuildRunner";
 export * from "./pkg-builders/server/SdServerBundler";
 export * from "./ts-builder/SdTsCompiler";
-export * from "./ts-builder/SdTsCompileWorker";
 export * from "./types/build-plugin.type";
+export * from "./types/build-runner.type";
 export * from "./types/build.type";
 export * from "./types/common-configs.type";
 export * from "./types/sd-configs.type";

package/src/pkg-builders/SdMultiBuildRunner.ts

@@ -1,14 +1,11 @@
 import { FsUtil, Logger, PathUtil, SdWorker, TNormPath } from "@simplysm/sd-core-node";
 import path from "path";
 import { EventEmitter } from "events";
-import { SdServerBuildRunner } from "./server/SdServerBuildRunner";
-import { SdClientBuildRunner } from "./client/SdClientBuildRunner";
-import { SdTsLibBuildRunner } from "./lib/SdTsLibBuildRunner";
-import { SdJsLibBuildRunner } from "./lib/SdJsLibBuildRunner";
-import { ISdProjectConfig, ISdServerPackageConfig } from "../types/sd-configs.type";
+import { ISdServerPackageConfig } from "../types/sd-configs.type";
 import { ISdBuildMessage, ISdBuildRunnerResult } from "../types/build.type";
-import { TServerWorkerType } from "../types/workers.type";
+import { TSdBuildRunnerWorkerType, TServerWorkerType } from "../types/workers.type";
 import { INpmConfig } from "../types/common-configs.type";
+import { ISdBuildRunnerWorkerRequest } from "../types/build-runner.type";
 
 export class SdMultiBuildRunner extends EventEmitter {
   #logger = Logger.get(["simplysm", "sd-cli", "SdMultiBuildRunner"]);
@@ -43,10 +40,20 @@ export class SdMultiBuildRunner extends EventEmitter {
     return this;
   }
 
-  async runAsync(req: IRequest & { cmd: "watch" }): Promise<void>;
-  async runAsync(req: IRequest & { cmd: "build" }): Promise<ISdBuildMessage[]>;
-  async runAsync(req: IRequest): Promise<ISdBuildMessage[] | void> {
-    const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
+  async runAsync(req: ISdBuildRunnerWorkerRequest & { cmd: "watch" }): Promise<void>;
+  async runAsync(req: ISdBuildRunnerWorkerRequest & { cmd: "build" }): Promise<ISdBuildMessage[]>;
+  async runAsync(req: ISdBuildRunnerWorkerRequest): Promise<ISdBuildMessage[] | void> {
+    const worker = new SdWorker<TSdBuildRunnerWorkerType>(import.meta.resolve("../workers/build-runner-worker"))
+      .on("change", () => {
+        if (this.#busyCount === 0) {
+          this.emit("change");
+        }
+        this.#busyCount++;
+      })
+      .on("complete", (result) => this.#onComplete(req, result));
+
+    return await worker.run("run", [req]);
+    /*const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
 
     const buildRunnerType =
       pkgConf.type === "server"
@@ -67,140 +74,133 @@ export class SdMultiBuildRunner extends EventEmitter {
     } else {
       await builder.watchAsync();
       return;
-    }
+    }*/
   }
 
-  #onMessage(req: IRequest, res: TResponse) {
-    if (res.type === "change") {
-      if (this.#busyCount === 0) {
-        this.emit("change");
-      }
-      this.#busyCount++;
-    } else {
-      this.#resultCache.delete(req.pkgPath);
-      for (const affectedFilePath of res.result.affectedFilePathSet) {
-        if (PathUtil.isChildPath(affectedFilePath, req.pkgPath)) {
-          this.#resultCache.delete(affectedFilePath);
-        }
+  #onComplete(req: ISdBuildRunnerWorkerRequest, result: ISdBuildRunnerResult) {
+    this.#resultCache.delete(req.pkgPath);
+    for (const affectedFilePath of result.affectedFilePathSet) {
+      if (PathUtil.isChildPath(affectedFilePath, req.pkgPath)) {
+        this.#resultCache.delete(affectedFilePath);
       }
+    }
 
-      for (const buildMessage of res.result.buildMessages) {
-        const cacheItem = this.#resultCache.getOrCreate(buildMessage.filePath ?? req.pkgPath, []);
-        cacheItem.push(buildMessage);
-      }
+    for (const buildMessage of result.buildMessages) {
+      const cacheItem = this.#resultCache.getOrCreate(buildMessage.filePath ?? req.pkgPath, []);
+      cacheItem.push(buildMessage);
+    }
+
+    const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
 
-      const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
+    if (pkgConf.type === "server") {
+      const pkgName = path.basename(req.pkgPath);
+      const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
+        hasChanges: true,
+        clientChangedFileSet: new Set(),
+        clients: {},
+      });
+
+      const serverPkgConf = req.projConf.packages[pkgName] as ISdServerPackageConfig;
+      serverInfo.pkgInfo = {
+        path: req.pkgPath,
+        conf: serverPkgConf,
+      };
+
+      serverInfo.hasChanges = true;
+    } else if (pkgConf.type === "client") {
+      const pkgName = path.basename(req.pkgPath);
+
+      if (pkgConf.server !== undefined) {
+        const serverInfo = this.#serverInfoMap.getOrCreate(
+          typeof pkgConf.server === "string" ? pkgConf.server : pkgConf.server.port.toString(),
+          {
+            hasChanges: true,
+            clientChangedFileSet: new Set(),
+            clients: {},
+          },
+        );
 
-      if (pkgConf.type === "server") {
-        const pkgName = path.basename(req.pkgPath);
+        if (typeof pkgConf.server !== "string") {
+          serverInfo.pkgInfo = pkgConf.server;
+        }
+
+        serverInfo.clients[pkgName] = {
+          path: path.resolve(req.pkgPath, "dist"),
+          buildTypes: (pkgConf.builder ? Object.keys(pkgConf.builder) : ["web"]) as any,
+        };
+
+        serverInfo.clientChangedFileSet.adds(...result.emitFileSet);
+      } else {
         const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
           hasChanges: true,
           clientChangedFileSet: new Set(),
           clients: {},
         });
 
-        const serverPkgConf = req.projConf.packages[pkgName] as ISdServerPackageConfig;
-        serverInfo.pkgInfo = {
-          path: req.pkgPath,
-          conf: serverPkgConf,
-        };
-
-        serverInfo.hasChanges = true;
-      } else if (pkgConf.type === "client") {
-        const pkgName = path.basename(req.pkgPath);
-
-        if (pkgConf.server !== undefined) {
-          const serverInfo = this.#serverInfoMap.getOrCreate(
-            typeof pkgConf.server === "string" ? pkgConf.server : pkgConf.server.port.toString(),
-            {
-              hasChanges: true,
-              clientChangedFileSet: new Set(),
-              clients: {},
-            },
-          );
-
-          if (typeof pkgConf.server !== "string") {
-            serverInfo.pkgInfo = pkgConf.server;
-          }
-
-          serverInfo.clients[pkgName] = {
-            path: path.resolve(req.pkgPath, "dist"),
-            buildTypes: (pkgConf.builder ? Object.keys(pkgConf.builder) : ["web"]) as any,
-          };
-
-          serverInfo.clientChangedFileSet.adds(...res.result.emitFileSet);
-        } else {
-          const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
-            hasChanges: true,
-            clientChangedFileSet: new Set(),
-            clients: {},
-          });
-
-          serverInfo.clientChangedFileSet.adds(...res.result.emitFileSet);
-        }
+        serverInfo.clientChangedFileSet.adds(...result.emitFileSet);
       }
+    }
 
-      setTimeout(async () => {
-        this.#busyCount--;
-        if (this.#busyCount === 0) {
-          for (const serverPkgNameOrPort of this.#serverInfoMap.keys()) {
-            const serverInfo = this.#serverInfoMap.get(serverPkgNameOrPort)!;
-            if (serverInfo.pkgInfo && serverInfo.hasChanges) {
-              this.#logger.debug("서버 재시작...");
-              try {
-                const restartServerResult = await this.#restartServerAsync(serverInfo.pkgInfo, serverInfo.worker);
-                serverInfo.worker = restartServerResult.worker;
-                serverInfo.port = restartServerResult.port;
-                serverInfo.hasChanges = false;
-              } catch (err) {
-                this.#logger.error(err);
-              }
+    setTimeout(async () => {
+      this.#busyCount--;
+      if (this.#busyCount === 0) {
+        for (const serverPkgNameOrPort of this.#serverInfoMap.keys()) {
+          const serverInfo = this.#serverInfoMap.get(serverPkgNameOrPort)!;
+          if (serverInfo.pkgInfo && serverInfo.hasChanges) {
+            this.#logger.debug("서버 재시작...");
+            try {
+              const restartServerResult = await this.#restartServerAsync(serverInfo.pkgInfo, serverInfo.worker);
+              serverInfo.worker = restartServerResult.worker;
+              serverInfo.port = restartServerResult.port;
+              serverInfo.hasChanges = false;
+            } catch (err) {
+              this.#logger.error(err);
             }
+          }
 
-            if (serverInfo.worker) {
-              this.#logger.debug("클라이언트 설정...");
-              await serverInfo.worker.run("setPathProxy", [
-                {
-                  ...Object.keys(serverInfo.clients).toObject(
-                    (key) => key,
-                    (key) => serverInfo.clients[key].path,
-                  ),
-                  node_modules: path.resolve(process.cwd(), "node_modules"),
-                },
-              ]);
-
-              if (serverInfo.clientChangedFileSet.size > 0) {
-                this.#logger.debug("클라이언트 새로고침...");
-                await serverInfo.worker.run("broadcastReload", [serverInfo.clientChangedFileSet]);
-              }
+          if (serverInfo.worker) {
+            this.#logger.debug("클라이언트 설정...");
+            await serverInfo.worker.run("setPathProxy", [
+              {
+                ...Object.keys(serverInfo.clients).toObject(
+                  (key) => key,
+                  (key) => serverInfo.clients[key].path,
+                ),
+                node_modules: path.resolve(process.cwd(), "node_modules"),
+              },
+            ]);
+
+            if (serverInfo.clientChangedFileSet.size > 0) {
+              this.#logger.debug("클라이언트 새로고침...");
+              await serverInfo.worker.run("broadcastReload", [serverInfo.clientChangedFileSet]);
             }
           }
+        }
 
-          const clientPaths: string[] = [];
-          for (const serverInfo of this.#serverInfoMap.values()) {
-            if (Object.keys(serverInfo.clients).length > 0) {
-              for (const clientPkgName of Object.keys(serverInfo.clients)) {
-                for (const buildType of serverInfo.clients[clientPkgName].buildTypes) {
-                  if (buildType === "web") {
-                    clientPaths.push(`http://localhost:${serverInfo.port}/${clientPkgName}/`);
-                  } else {
-                    clientPaths.push(`http://localhost:${serverInfo.port}/${clientPkgName}/${buildType}/`);
-                  }
+        const clientPaths: string[] = [];
+        for (const serverInfo of this.#serverInfoMap.values()) {
+          if (Object.keys(serverInfo.clients).length > 0) {
+            for (const clientPkgName of Object.keys(serverInfo.clients)) {
+              for (const buildType of serverInfo.clients[clientPkgName].buildTypes) {
+                if (buildType === "web") {
+                  clientPaths.push(`http://localhost:${serverInfo.port}/${clientPkgName}/`);
+                } else {
+                  clientPaths.push(`http://localhost:${serverInfo.port}/${clientPkgName}/${buildType}/`);
                 }
               }
-            } else {
-              clientPaths.push(`http://localhost:${serverInfo.port}/`);
             }
+          } else {
+            clientPaths.push(`http://localhost:${serverInfo.port}/`);
           }
-          if (clientPaths.length > 0) {
-            this.#logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
-          }
-
-          const messages = Array.from(this.#resultCache.values()).mapMany();
-          this.emit("complete", messages);
         }
-      }, 300);
-    }
+        if (clientPaths.length > 0) {
+          this.#logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
+        }
+
+        const messages = Array.from(this.#resultCache.values()).mapMany();
+        this.emit("complete", messages);
+      }
+    }, 300);
   }
 
   async #restartServerAsync(
@@ -234,6 +234,7 @@ export class SdMultiBuildRunner extends EventEmitter {
   }
 }
 
+/*
 interface IRequest {
   cmd: "watch" | "build";
   pkgPath: TNormPath;
@@ -248,3 +249,4 @@ type TResponse =
       type: "complete";
       result: ISdBuildRunnerResult;
     };
+*/

package/src/pkg-builders/client/SdClientBuildRunner.ts

@@ -10,19 +10,27 @@ import { INpmConfig } from "../../types/common-configs.type";
 import { ISdBuildMessage, ISdBuildRunnerResult } from "../../types/build.type";
 
 export class SdClientBuildRunner extends EventEmitter {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdClientBuildRunner"]);
-  private readonly _pkgConf: ISdClientPackageConfig;
-  private readonly _npmConf: INpmConfig;
+  private _logger = Logger.get(["simplysm", "sd-cli", "SdClientBuildRunner"]);
+  private _pkgConf: ISdClientPackageConfig;
+  private _npmConf: INpmConfig;
   private _ngBundlers?: SdNgBundler[];
   private _cordova?: SdCliCordova;
+  private _watchScopePathSet: Set<TNormPath>;
 
   public constructor(
-    private readonly _projConf: ISdProjectConfig,
-    private readonly _pkgPath: TNormPath,
+    private _projConf: ISdProjectConfig,
+    private _pkgPath: TNormPath,
   ) {
     super();
     this._pkgConf = this._projConf.packages[path.basename(_pkgPath)] as ISdClientPackageConfig;
     this._npmConf = FsUtil.readJson(path.resolve(_pkgPath, "package.json")) as INpmConfig;
+
+    const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {}).mapMany((key) =>
+      FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)),
+    );
+    this._watchScopePathSet = new Set(
+      [path.resolve(this._pkgPath, "../"), ...localUpdatePaths].map((item) => PathUtil.norm(item)),
+    );
   }
 
   public override on(event: "change", listener: () => void): this;
@@ -77,11 +85,15 @@ export class SdClientBuildRunner extends EventEmitter {
     this.emit("complete", res);
 
     this._debug("WATCH...");
-    const watcher = SdFsWatcher.watch(Array.from(result.watchFileSet)).onChange({ delay: 100 }, async (changeInfos) => {
+    let lastWatchFileSet = result.watchFileSet;
+    SdFsWatcher.watch(Array.from(this._watchScopePathSet)).onChange({ delay: 100 }, async (changeInfos) => {
+      const currentChangeInfos = changeInfos.filter((item) => lastWatchFileSet.has(item.path));
+      if (currentChangeInfos.length < 1) return;
+
       this.emit("change");
 
       for (const ngBundler of this._ngBundlers!) {
-        ngBundler.markForChanges(changeInfos.map((item) => item.path));
+        ngBundler.markForChanges(currentChangeInfos.map((item) => item.path));
       }
 
       const watchResult = await this._runAsync({ dev: !this._pkgConf.forceProductionMode });
@@ -92,7 +104,7 @@ export class SdClientBuildRunner extends EventEmitter {
       };
       this.emit("complete", watchRes);
 
-      watcher.replaceWatchPaths(watchResult.watchFileSet);
+      lastWatchFileSet = watchResult.watchFileSet;
     });
   }
 
@@ -102,10 +114,6 @@ export class SdClientBuildRunner extends EventEmitter {
     buildMessages: ISdBuildMessage[];
     emitFileSet: Set<TNormPath>;
   }> {
-    const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {}).mapMany((key) =>
-      FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)),
-    );
-
     const ngBundlerBuilderTypes = Object.keys(this._pkgConf.builder ?? { web: {} }) as (
       | "web"
       | "electron"
@@ -142,9 +150,7 @@ export class SdClientBuildRunner extends EventEmitter {
               ...this._pkgConf.builder?.[ngBundlerBuilderType]?.env,
             },
             cordovaConfig: ngBundlerBuilderType === "cordova" ? this._pkgConf.builder!.cordova : undefined,
-            watchScopePaths: [path.resolve(this._pkgPath, "../"), ...localUpdatePaths].map((item) =>
-              PathUtil.norm(item),
-            ),
+            watchScopePaths: Array.from(this._watchScopePathSet),
           }),
       );
     }
@@ -170,15 +176,13 @@ export class SdClientBuildRunner extends EventEmitter {
     }
 
     this._debug(`빌드 완료`);
-    const currWatchFileSet = new Set(
-      Array.from(watchFileSet).filter(
-        (item) =>
-          PathUtil.isChildPath(item, path.resolve(this._pkgPath, "../")) ||
-          localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu)),
+    /*const currWatchFileSet = new Set(
+      Array.from(watchFileSet).filter((item) =>
+        Array.from(this._watchScopePathSet).some((scope) => PathUtil.isChildPath(item, scope)),
       ),
-    );
+    );*/
     return {
-      watchFileSet: currWatchFileSet,
+      watchFileSet,
       affectedFileSet,
       buildMessages: results, //.filter((item) => item.filePath !== path.resolve(this._pkgPath, "src/routes.ts")),
       emitFileSet,

package/src/pkg-builders/client/SdNgBundler.ts

@@ -242,6 +242,7 @@ export class SdNgBundler {
       watchFileSet: new Set([
         ...this.#ngResultCache.watchFileSet!,
         ...this.#styleLoadResultCache.watchFiles.map((item) => PathUtil.norm(item)),
+        ...assetFiles.map((item) => PathUtil.norm(item.source)),
         PathUtil.norm(this.#indexHtmlFilePath),
       ]),
       affectedFileSet: this.#ngResultCache.affectedFileSet!,

package/src/pkg-builders/client/createSdNgPlugin.ts

@@ -7,7 +7,7 @@ import { SdCliPerformanceTimer } from "../../utils/SdCliPerformanceTime";
 import { SdCliConvertMessageUtil } from "../../utils/SdCliConvertMessageUtil";
 import { ISdCliNgPluginResultCache } from "../../types/build-plugin.type";
 import { ISdTsCompilerResult } from "../../types/ts-compiler.type";
-import { SdTsCompileWorker } from "../../ts-builder/SdTsCompileWorker";
+import { SdTsCompiler } from "../../ts-builder/SdTsCompiler";
 
 export function createSdNgPlugin(conf: {
   pkgPath: TNormPath;
@@ -25,8 +25,8 @@ export function createSdNgPlugin(conf: {
 
   return {
     name: "sd-ng-compile",
-    setup: async (build: esbuild.PluginBuild) => {
-      const tsCompiler = await SdTsCompileWorker.new({
+    setup: (build: esbuild.PluginBuild) => {
+      const tsCompiler = new SdTsCompiler({
         pkgPath: conf.pkgPath,
         additionalOptions: { declaration: false },
         isDevMode: conf.dev,