@simplysm/sd-cli 12.13.21 → 12.13.35

package/src/pkg-builders/SdProjectBuildRunner.ts

@@ -0,0 +1,354 @@
+import {
+  FsUtils,
+  PathUtils,
+  SdFsWatcher,
+  SdLogger,
+  SdWorker,
+  TNormPath,
+} from "@simplysm/sd-core-node";
+import { ISdProjectConfig, ISdServerPackageConfig } from "../types/config/ISdProjectConfig";
+import path from "path";
+import { ISdBuildMessage } from "../types/build/ISdBuildMessage";
+import { ISdBuildRunnerWorkerType } from "../types/worker/ISdBuildRunnerWorkerType";
+import { IServerWorkerType } from "../types/worker/IServerWorkerType";
+import { INpmConfig } from "../types/common-config/INpmConfig";
+
+export class SdProjectBuildRunner {
+  static #logger = SdLogger.get(["simplysm", "sd-cli", "SdProjectBuildRunner"]);
+
+  static #buildInfoMap = new Map<
+    TNormPath,
+    {
+      buildWorker: SdWorker<ISdBuildRunnerWorkerType>;
+      watchFileSet: Set<TNormPath>;
+    }
+  >();
+
+  static #serverInfoMap = new Map<
+    string,
+    {
+      worker?: SdWorker<any>;
+      port?: number;
+      clientMap?: Map<
+        string,
+        {
+          distPath: string;
+          buildTypes: ("web" | "electron" | "cordova")[];
+        }
+      >;
+    }
+  >();
+
+  static #resultCache = new Map<TNormPath, ISdBuildMessage[]>();
+
+  static async watchAsync(opt: {
+    pkgPaths: TNormPath[];
+    projConf: ISdProjectConfig;
+    emitOnly: boolean;
+    noEmit: boolean;
+    onChange: () => void;
+    onComplete: (buildMessages: ISdBuildMessage[]) => void;
+  }) {
+    const scopePathSet = await this.#getScopePathSetAsync(
+      opt.pkgPaths,
+      Object.keys(opt.projConf.localUpdates ?? {}),
+    );
+
+    const watcher = SdFsWatcher.watch(Array.from(scopePathSet), {
+      ignoreInitial: false,
+    });
+    watcher.onChange({ delay: 300 }, async (changeInfos) => {
+      // 변경된 패키지 정보 구성
+      const changeFiles = changeInfos.map((item) => PathUtils.norm(item.path));
+      const changedPkgInfos = opt.pkgPaths
+        .map((pkgPath) => {
+          let buildInfo = this.#buildInfoMap.get(pkgPath);
+          if (!buildInfo) return { pkgPath };
+
+          const modifiedFileSet = new Set(
+            changeFiles.filter((item) => buildInfo.watchFileSet.has(item)),
+          );
+
+          if (modifiedFileSet.size < 1) return;
+
+          return { pkgPath, buildInfo: buildInfo, modifiedFileSet };
+        })
+        .filterExists();
+      if (changedPkgInfos.length < 1) return;
+
+      // 변경된 패키지들에 대한 change처리
+      opt.onChange();
+      const buildResults = await changedPkgInfos.parallelAsync(async (changedPkgInfo) => {
+        // 처음
+        if (!changedPkgInfo.buildInfo) {
+          const buildWorker = new SdWorker<ISdBuildRunnerWorkerType>(
+            import.meta.resolve("../workers/build-runner.worker"),
+          );
+          await buildWorker.run("initialize", [
+            {
+              pkgPath: changedPkgInfo.pkgPath,
+              projConf: opt.projConf,
+              scopePathSet: scopePathSet,
+
+              watch: true,
+              emitOnly: opt.emitOnly,
+              noEmit: opt.noEmit,
+            },
+          ]);
+
+          const result = await buildWorker.run("rebuild", []);
+
+          this.#buildInfoMap.set(changedPkgInfo.pkgPath, {
+            buildWorker,
+            watchFileSet: result.watchFileSet,
+          });
+
+          return {
+            isFirst: true,
+            pkgPath: changedPkgInfo.pkgPath,
+            emitFileSet: result.emitFileSet,
+            affectedFileSet: result.affectedFileSet,
+
+            buildMessages: result.buildMessages,
+          };
+        }
+        // changed
+        else {
+          const result = await changedPkgInfo.buildInfo.buildWorker.run("rebuild", [
+            changedPkgInfo.modifiedFileSet,
+          ]);
+          changedPkgInfo.buildInfo.watchFileSet = result.watchFileSet;
+
+          return {
+            isFirst: false,
+            pkgPath: changedPkgInfo.pkgPath,
+            emitFileSet: result.emitFileSet,
+            affectedFileSet: result.affectedFileSet,
+
+            buildMessages: result.buildMessages,
+          };
+        }
+      });
+
+      if (!opt.noEmit) {
+        // 서버 구성 및 재시작
+        for (const buildResult of buildResults) {
+          const pkgConf = opt.projConf.packages[path.basename(buildResult.pkgPath)]!;
+          if (pkgConf.type === "server") {
+            const serverName = path.basename(buildResult.pkgPath);
+            this.#logger.debug(`서버 '${serverName}' 재시작...`);
+
+            const serverInfo = this.#serverInfoMap.getOrCreate(serverName, {});
+            const restartServerResult = await this.#restartServerAsync(
+              serverInfo.worker,
+              buildResult.pkgPath,
+              pkgConf,
+            );
+            serverInfo.worker = restartServerResult.worker;
+            serverInfo.port = restartServerResult.port;
+
+            /*await serverInfo.worker.run("addPathProxy", [
+              "node_modules",
+              path.resolve(process.cwd(), "node_modules"),
+            ]);
+            if (serverInfo.clientMap) {
+              for (const [clientName, clientInfo] of serverInfo.clientMap.entries()) {
+                await serverInfo.worker.run("addPathProxy", [clientName, clientInfo.path]);
+              }
+            }*/
+          } else if (pkgConf.type === "client" && typeof pkgConf.server === "object") {
+            const serverName = pkgConf.server.port.toString();
+            this.#logger.debug(`서버 '${serverName}' 재시작...`);
+
+            const serverInfo = this.#serverInfoMap.getOrCreate(serverName, {});
+            const restartServerResult = await this.#restartServerAsync(
+              serverInfo.worker,
+              buildResult.pkgPath,
+              pkgConf.server.port,
+            );
+            serverInfo.worker = restartServerResult.worker;
+            serverInfo.port = restartServerResult.port;
+
+            /*await worker.run("addPathProxy", [
+              "node_modules",
+              path.resolve(process.cwd(), "node_modules"),
+            ]);*/
+          }
+        }
+
+        // 클라이언트 구성 및 변경 Reload
+        for (const buildResult of buildResults) {
+          const pkgConf = opt.projConf.packages[path.basename(buildResult.pkgPath)]!;
+          if (pkgConf.type === "client") {
+            const clientName = path.basename(buildResult.pkgPath);
+            const serverKey =
+              typeof pkgConf.server === "string"
+                ? pkgConf.server
+                : typeof pkgConf.server === "object"
+                  ? pkgConf.server.port.toString()
+                  : undefined;
+            if (serverKey == null) continue;
+
+            const serverInfo = this.#serverInfoMap.get(serverKey);
+            if (!serverInfo || !serverInfo.worker) continue;
+
+            const distPath = path.resolve(buildResult.pkgPath, "dist");
+            serverInfo.clientMap = serverInfo.clientMap ?? new Map();
+            serverInfo.clientMap.set(clientName, {
+              distPath,
+              buildTypes: (pkgConf.builder ? Object.keys(pkgConf.builder) : ["web"]) as any,
+            });
+
+            if (buildResult.isFirst) continue;
+
+            this.#logger.debug(`클라이언트 '${clientName}' 새로고침...`);
+            await serverInfo.worker.run("broadcastReload", [
+              clientName,
+              new Set(
+                Array.from(buildResult.emitFileSet)
+                  .filter((item) => !item.endsWith(".map"))
+                  .map((item) => path.relative(distPath, item)),
+              ),
+            ]);
+          }
+        }
+
+        // 서버 Proxy 설정
+        for (const serverInfo of this.#serverInfoMap.values()) {
+          if (!serverInfo.worker) continue;
+
+          await serverInfo.worker.run("setPathProxy", [
+            {
+              ...Array.from(serverInfo.clientMap?.entries() ?? []).toObject(
+                (entry) => entry[0],
+                (entry) => entry[1].distPath,
+              ),
+              node_modules: path.resolve(process.cwd(), "node_modules"),
+            },
+          ]);
+        }
+
+        // 접속주소 logging
+        for (const serverName of this.#serverInfoMap.keys()) {
+          const serverInfo = this.#serverInfoMap.get(serverName);
+          const clientPaths: string[] = [];
+          for (const [clientName, clientInfo] of serverInfo?.clientMap?.entries() ?? []) {
+            for (const buildType of clientInfo.buildTypes) {
+              if (buildType === "web") {
+                clientPaths.push(`http://localhost:${serverInfo!.port}/${clientName}/`);
+              } else {
+                clientPaths.push(`http://localhost:${serverInfo!.port}/${clientName}/${buildType}`);
+              }
+            }
+          }
+
+          this.#logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
+        }
+      }
+
+      // 빌드 완료 이벤트
+
+      for (const buildResult of buildResults) {
+        this.#resultCache.delete(buildResult.pkgPath);
+        for (const affectedFilePath of buildResult.affectedFileSet) {
+          this.#resultCache.delete(affectedFilePath);
+        }
+
+        for (const buildMessage of buildResult.buildMessages) {
+          if (
+            !buildMessage.filePath ||
+            PathUtils.isChildPath(buildMessage.filePath, buildResult.pkgPath)
+          ) {
+            const cacheItem = this.#resultCache.getOrCreate(
+              buildMessage.filePath ?? buildResult.pkgPath,
+              [],
+            );
+            cacheItem.push(buildMessage);
+          }
+        }
+      }
+
+      opt.onComplete(Array.from(this.#resultCache.values()).mapMany());
+    });
+  }
+
+  static async buildAsync(opt: { pkgPaths: TNormPath[]; projConf: ISdProjectConfig }) {
+    const scopePathSet = await this.#getScopePathSetAsync(
+      opt.pkgPaths,
+      Object.keys(opt.projConf.localUpdates ?? {}),
+    );
+
+    const buildResults = await opt.pkgPaths.parallelAsync(async (pkgPath) => {
+      const worker = new SdWorker<ISdBuildRunnerWorkerType>(
+        import.meta.resolve("../workers/build-runner.worker"),
+      );
+
+      await worker.run("initialize", [
+        {
+          pkgPath,
+          projConf: opt.projConf,
+          scopePathSet: scopePathSet,
+        },
+      ]);
+
+      const result = await worker.run("rebuild", []);
+      await worker.killAsync();
+      return {
+        buildMessages: result.buildMessages,
+      };
+    });
+
+    return buildResults.mapMany((item) => item.buildMessages);
+  }
+
+  static async #getScopePathSetAsync(pkgPaths: TNormPath[], localUpdateGlobs: string[]) {
+    const workspacePaths = pkgPaths.mapMany((item) => [
+      path.resolve(item, "src"),
+      path.resolve(item, "public"),
+      path.resolve(item, "public-dev"),
+    ]);
+    const localUpdatePaths = (
+      await localUpdateGlobs.mapManyAsync(
+        async (key) => await FsUtils.globAsync(path.resolve(process.cwd(), "node_modules", key)),
+      )
+    ).mapMany((key) => [
+      path.resolve(process.cwd(), "node_modules", key, "dist"),
+      path.resolve(process.cwd(), "node_modules", key, "src/**/*.scss"),
+    ]);
+
+    return new Set([...workspacePaths, ...localUpdatePaths].map((item) => PathUtils.norm(item)));
+  }
+
+  static async #restartServerAsync(
+    prevWorker: SdWorker<IServerWorkerType> | undefined,
+    pkgPath: string,
+    pkgConfOrPort: ISdServerPackageConfig | number,
+  ): Promise<{
+    worker: SdWorker<IServerWorkerType>;
+    port: number;
+  }> {
+    if (prevWorker) {
+      await prevWorker.killAsync();
+    }
+
+    const npmConf = FsUtils.readJson(path.resolve(pkgPath, "package.json")) as INpmConfig;
+
+    const worker = new SdWorker<IServerWorkerType>(
+      import.meta.resolve("../workers/server.worker"),
+      {
+        env: {
+          NODE_ENV: "development",
+          TZ: "Asia/Seoul",
+          SD_VERSION: npmConf.version,
+          ...(typeof pkgConfOrPort === "number" ? {} : pkgConfOrPort.env),
+        },
+      },
+    );
+    const port = await worker.run("listen", [
+      typeof pkgConfOrPort === "number" ? pkgConfOrPort : pkgPath,
+    ]);
+    this.#logger.debug("서버가 시작되었습니다.");
+
+    return { worker, port };
+  }
+}

package/src/pkg-builders/client/{sd-client.build-runner.ts → SdClientBuildRunner.ts}

@@ -1,27 +1,23 @@
 import { FsUtils, PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
 import path from "path";
-import { SdNgBundler } from "./sd-ng.bundler";
-import { SdCliCordova } from "../../entry/sd-cli-cordova";
-import { SdCliElectron } from "../../entry/sd-cli-electron";
-import { BuildRunnerBase, IBuildRunnerRunResult } from "../commons/build-runner.base";
-import { SdCliNgRoutesFileGenerator } from "./sd-cli-ng-routes.file-generator";
-import { INpmConfig } from "../../types/common-configs.types";
-
-export class SdClientBuildRunner extends BuildRunnerBase<"client"> {
+import { SdBuildRunnerBase } from "../commons/SdBuildRunnerBase";
+import { SdNgBundler } from "./SdNgBundler";
+import { SdCliCordova } from "../../entry/SdCliCordova";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
+import { INpmConfig } from "../../types/common-config/INpmConfig";
+import { SdCliNgRoutesFileGenerator } from "./SdCliNgRoutesFileGenerator";
+import { SdCliElectron } from "../../entry/SdCliElectron";
+
+export class SdClientBuildRunner extends SdBuildRunnerBase<"client"> {
   protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdClientBuildRunner"]);
 
   #ngBundlers?: SdNgBundler[];
   #cordova?: SdCliCordova;
 
-  protected override async _runAsync(
-    dev: boolean,
-    emitOnly: boolean,
-    noEmit: boolean,
-    modifiedFileSet?: Set<TNormPath>,
-  ): Promise<IBuildRunnerRunResult> {
+  protected override async _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
     // 최초 한번
     if (!modifiedFileSet) {
-      if (!noEmit) {
+      if (!this._noEmit) {
         // config
         this._debug("GEN .config...");
         const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
@@ -57,17 +53,18 @@ export class SdClientBuildRunner extends BuildRunnerBase<"client"> {
       this.#ngBundlers = ngBundlerBuilderTypes.map(
         (ngBundlerBuilderType) =>
           new SdNgBundler({
-            dev,
-            emitOnly,
-            noEmit,
+            watch: this._watch,
+            dev: this._dev,
+            emitOnly: this._emitOnly ?? false,
+            noEmit: this._noEmit ?? false,
             builderType: ngBundlerBuilderType,
             pkgPath: this._pkgPath,
             outputPath:
               ngBundlerBuilderType === "web"
                 ? PathUtils.norm(this._pkgPath, "dist")
-                : ngBundlerBuilderType === "electron" && !dev
+                : ngBundlerBuilderType === "electron" && !this._dev
                   ? PathUtils.norm(this._pkgPath, ".electron/src")
-                  : ngBundlerBuilderType === "cordova" && !dev
+                  : ngBundlerBuilderType === "cordova" && !this._dev
                     ? PathUtils.norm(this._pkgPath, ".cordova/www")
                     : PathUtils.norm(this._pkgPath, "dist", ngBundlerBuilderType),
             env: {
@@ -80,18 +77,18 @@ export class SdClientBuildRunner extends BuildRunnerBase<"client"> {
                 : [],
             cordovaConfig:
               ngBundlerBuilderType === "cordova" ? this._pkgConf.builder!.cordova : undefined,
-            watchScopePathSet: this._watchScopePathSet,
+            scopePathSet: this._scopePathSet,
           }),
       );
     }
 
-    if (noEmit) {
-      if (modifiedFileSet) {
-        for (const ngBundler of this.#ngBundlers!) {
-          ngBundler.markForChanges(Array.from(modifiedFileSet));
-        }
+    if (modifiedFileSet) {
+      for (const ngBundler of this.#ngBundlers!) {
+        ngBundler.markForChanges(Array.from(modifiedFileSet));
       }
+    }
 
+    if (this._noEmit) {
       this._debug(`BUILD...`);
       const buildResults = await Promise.all(
         this.#ngBundlers!.map((builder) => builder.bundleAsync()),
@@ -101,23 +98,18 @@ export class SdClientBuildRunner extends BuildRunnerBase<"client"> {
         buildResults.mapMany((item) => Array.from(item.affectedFileSet)),
       );
       const emitFileSet = new Set(buildResults.mapMany((item) => Array.from(item.emitFileSet)));
-      const results = buildResults.mapMany((item) => item.results).distinct();
+      const buildMessages = buildResults.mapMany((item) => item.buildMessages).distinct();
 
       this._debug(`빌드 완료`);
 
       return {
+        buildMessages,
+
         watchFileSet,
         affectedFileSet,
-        buildMessages: results,
         emitFileSet,
       };
     } else {
-      if (modifiedFileSet) {
-        for (const ngBundler of this.#ngBundlers!) {
-          ngBundler.markForChanges(Array.from(modifiedFileSet));
-        }
-      }
-
       this._debug(`BUILD...`);
       const buildResults = await Promise.all(
         this.#ngBundlers!.map((builder) => builder.bundleAsync()),
@@ -127,14 +119,14 @@ export class SdClientBuildRunner extends BuildRunnerBase<"client"> {
         buildResults.mapMany((item) => Array.from(item.affectedFileSet)),
       );
       const emitFileSet = new Set(buildResults.mapMany((item) => Array.from(item.emitFileSet)));
-      const results = buildResults.mapMany((item) => item.results).distinct();
+      const buildMessages = buildResults.mapMany((item) => item.buildMessages).distinct();
 
-      if (!dev && this.#cordova) {
+      if (!this._dev && this.#cordova) {
         this._debug("CORDOVA BUILD...");
         await this.#cordova.buildAsync(path.resolve(this._pkgPath, "dist"));
       }
 
-      if (!dev && this._pkgConf.builder?.electron) {
+      if (!this._dev && this._pkgConf.builder?.electron) {
         this._debug("ELECTRON BUILD...");
         await SdCliElectron.buildAsync({
           pkgPath: this._pkgPath,
@@ -145,9 +137,10 @@ export class SdClientBuildRunner extends BuildRunnerBase<"client"> {
       this._debug(`빌드 완료`);
 
       return {
+        buildMessages,
+
         watchFileSet,
         affectedFileSet,
-        buildMessages: results,
         emitFileSet,
       };
     }

package/src/pkg-builders/client/{sd-ng.bundler.ts → SdNgBundler.ts}

@@ -5,7 +5,7 @@ import { fileURLToPath } from "url";
 import nodeStdLibBrowser from "node-stdlib-browser";
 import nodeStdLibBrowserPlugin from "node-stdlib-browser/helpers/esbuild/plugin";
 import browserslist from "browserslist";
-import { SdNgBundlerContext } from "./sd-ng.bundler-context";
+import { SdNgBundlerContext } from "./SdNgBundlerContext";
 import { MemoryLoadResultCache } from "@angular/build/src/tools/esbuild/load-result-cache";
 import {
   convertOutputFile,
@@ -26,26 +26,20 @@ import {
 import { Entrypoint } from "@angular/build/src/utils/index-file/augment-index-html";
 import { CrossOrigin } from "@angular/build/src/builders/application/schema";
 import { augmentAppWithServiceWorkerEsbuild } from "@angular/build/src/utils/service-worker";
-import {
-  createSourcemapIgnorelistPlugin
-} from "@angular/build/src/tools/esbuild/sourcemap-ignorelist-plugin";
-import {
-  StylesheetPluginFactory
-} from "@angular/build/src/tools/esbuild/stylesheets/stylesheet-plugin-factory";
+import { createSourcemapIgnorelistPlugin } from "@angular/build/src/tools/esbuild/sourcemap-ignorelist-plugin";
+import { StylesheetPluginFactory } from "@angular/build/src/tools/esbuild/stylesheets/stylesheet-plugin-factory";
 import { SassStylesheetLanguage } from "@angular/build/src/tools/esbuild/stylesheets/sass-language";
 import { CssStylesheetLanguage } from "@angular/build/src/tools/esbuild/stylesheets/css-language";
-import {
-  createCssResourcePlugin
-} from "@angular/build/src/tools/esbuild/stylesheets/css-resource-plugin";
+import { createCssResourcePlugin } from "@angular/build/src/tools/esbuild/stylesheets/css-resource-plugin";
 import { resolveAssets } from "@angular/build/src/utils/resolve-assets";
-import { createSdNgPlugin } from "./sd-ng.plugin-creator";
-import { SdCliPerformanceTimer } from "../../utils/sd-cli-performance-time";
-import { INpmConfig } from "../../types/common-configs.types";
-import { ISdClientBuilderCordovaConfig } from "../../types/config.types";
-import { ISdCliNgPluginResultCache } from "../../types/build-plugin.types";
-import { ISdBuildMessage } from "../../types/build.types";
+import { createSdNgPlugin } from "./createSdNgPlugin";
+import { SdCliPerformanceTimer } from "../../utils/SdCliPerformanceTimer";
+import { ISdClientBuilderCordovaConfig } from "../../types/config/ISdProjectConfig";
 import nodeModule from "module";
-import { ScopePathSet } from "../commons/scope-path";
+import { ScopePathSet } from "../commons/ScopePathSet";
+import { ISdCliNgPluginResultCache } from "../../types/plugin/ISdCliNgPluginResultCache";
+import { INpmConfig } from "../../types/common-config/INpmConfig";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 
 export class SdNgBundler {
   #logger = SdLogger.get(["simplysm", "sd-cli", "SdNgBundler"]);
@@ -72,6 +66,7 @@ export class SdNgBundler {
 
   constructor(
     private readonly _opt: {
+      watch: boolean;
       dev: boolean;
       emitOnly: boolean;
       noEmit: boolean;
@@ -81,7 +76,7 @@ export class SdNgBundler {
       env: Record<string, string> | undefined;
       external: string[];
       cordovaConfig: ISdClientBuilderCordovaConfig | undefined;
-      watchScopePathSet: ScopePathSet;
+      scopePathSet: ScopePathSet;
     },
   ) {
     this.#pkgNpmConf = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
@@ -107,12 +102,7 @@ export class SdNgBundler {
     // this._sourceFileCache.invalidate(filePaths);
   }
 
-  async bundleAsync(): Promise<{
-    watchFileSet: Set<TNormPath>;
-    affectedFileSet: Set<TNormPath>;
-    results: ISdBuildMessage[];
-    emitFileSet: Set<TNormPath>;
-  }> {
+  async bundleAsync(): Promise<ISdBuildResult> {
     const perf = new SdCliPerformanceTimer("ng bundle");
 
     this.#debug(`get contexts...`);
@@ -134,13 +124,13 @@ export class SdNgBundler {
     });
 
     //-- results
-    const results = bundlingResults.mapMany((bundlingResult) => bundlingResult.results);
+    const buildMessages = bundlingResults.mapMany((bundlingResult) => bundlingResult.results);
 
     if (this._opt.noEmit) {
       return {
         watchFileSet: this.#ngResultCache.watchFileSet!,
         affectedFileSet: this.#ngResultCache.affectedFileSet!,
-        results,
+        buildMessages,
         emitFileSet: new Set<TNormPath>(),
       };
     } else {
@@ -173,7 +163,7 @@ export class SdNgBundler {
       await perf.run("create index.html", async () => {
         const genIndexHtmlResult = await this.#genIndexHtmlAsync(outputFiles, initialFiles);
         for (const warning of genIndexHtmlResult.warnings) {
-          results.push({
+          buildMessages.push({
             filePath: undefined,
             line: undefined,
             char: undefined,
@@ -184,7 +174,7 @@ export class SdNgBundler {
           });
         }
         for (const error of genIndexHtmlResult.errors) {
-          results.push({
+          buildMessages.push({
             filePath: undefined,
             line: undefined,
             char: undefined,
@@ -228,7 +218,7 @@ export class SdNgBundler {
             );
             assetFiles.push(...serviceWorkerResult.assetFiles);
           } catch (err) {
-            results.push({
+            buildMessages.push({
               filePath: undefined,
               line: undefined,
               char: undefined,
@@ -280,7 +270,7 @@ export class SdNgBundler {
           PathUtils.norm(this.#indexHtmlFilePath),
         ]),
         affectedFileSet: this.#ngResultCache.affectedFileSet!,
-        results,
+        buildMessages,
         emitFileSet: emitFileSet,
       };
     }
@@ -530,12 +520,13 @@ export class SdNgBundler {
         createSourcemapIgnorelistPlugin(),
         createSdNgPlugin({
           modifiedFileSet: this.#modifiedFileSet,
+          watch: this._opt.watch,
           dev: this._opt.dev,
           emitOnly: this._opt.emitOnly,
           noEmit: this._opt.noEmit,
           pkgPath: this._opt.pkgPath,
           result: this.#ngResultCache,
-          watchScopePathSet: this._opt.watchScopePathSet,
+          scopePathSet: this._opt.scopePathSet,
         }),
         ...(this._opt.builderType === "electron"
           ? []

package/src/pkg-builders/client/{sd-ng.bundler-context.ts → SdNgBundlerContext.ts}

@@ -1,7 +1,7 @@
 import esbuild from "esbuild";
 import path from "path";
 import { SdLogger } from "@simplysm/sd-core-node";
-import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.utils";
+import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
 
 // import { InitialFileRecord } from "@angular/build/src/tools/esbuild/bundler-context";
 
@@ -22,8 +22,7 @@ export class SdNgBundlerContext {
   constructor(
     private readonly _pkgPath: string,
     private readonly _esbuildOptions: esbuild.BuildOptions,
-  ) {
-  }
+  ) {}
 
   async bundleAsync() {
     if (this.#context == null) {
@@ -36,12 +35,10 @@ export class SdNgBundlerContext {
       this.#debug(`rebuild...`);
       esbuildResult = await this.#context.rebuild();
       this.#debug(`rebuild completed`);
-    }
-    catch (err) {
+    } catch (err) {
       if ("warnings" in err || "errors" in err) {
         esbuildResult = err;
-      }
-      else {
+      } else {
         throw err;
       }
     }
@@ -120,8 +117,9 @@ export class SdNgBundlerContext {
 
   #debug(...msg: any[]): void {
     this.#logger.debug(
-      `[${path.basename(this._pkgPath)}] (${Object.keys(this._esbuildOptions.entryPoints as Record<string, any>)
-        .join(", ")})`,
+      `[${path.basename(this._pkgPath)}] (${Object.keys(
+        this._esbuildOptions.entryPoints as Record<string, any>,
+      ).join(", ")})`,
       ...msg,
     );
   }