@simplysm/sd-cli 12.13.21 → 12.13.35

package/src/pkg-builders/client/{sd-ng.plugin-creator.ts → createSdNgPlugin.ts}

@@ -3,21 +3,22 @@ import path from "path";
 import os from "os";
 import { JavaScriptTransformer } from "@angular/build/src/tools/esbuild/javascript-transformer";
 import { FsUtils, PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
-import { SdCliPerformanceTimer } from "../../utils/sd-cli-performance-time";
-import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.utils";
-import { ISdCliNgPluginResultCache } from "../../types/build-plugin.types";
-import { ISdTsCompilerResult } from "../../types/ts-compiler.types";
-import { SdTsCompiler } from "../../ts-compiler/sd-ts-compiler";
-import { ScopePathSet } from "../commons/scope-path";
+import { SdCliPerformanceTimer } from "../../utils/SdCliPerformanceTimer";
+import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
+import { SdTsCompiler } from "../../ts-compiler/SdTsCompiler";
+import { ScopePathSet } from "../commons/ScopePathSet";
+import { ISdCliNgPluginResultCache } from "../../types/plugin/ISdCliNgPluginResultCache";
+import { ISdTsCompilerResult } from "../../types/build/ISdTsCompilerResult";
 
 export function createSdNgPlugin(conf: {
   pkgPath: TNormPath;
+  watch: boolean;
   dev: boolean;
   emitOnly: boolean;
   noEmit: boolean;
   modifiedFileSet: Set<TNormPath>;
   result: ISdCliNgPluginResultCache;
-  watchScopePathSet: ScopePathSet;
+  scopePathSet: ScopePathSet;
 }): esbuild.Plugin {
   let perf: SdCliPerformanceTimer;
   const logger = SdLogger.get(["simplysm", "sd-cli", "createSdNgPlugin"]);
@@ -32,11 +33,12 @@ export function createSdNgPlugin(conf: {
       const tsCompiler = new SdTsCompiler({
         pkgPath: conf.pkgPath,
         additionalOptions: { declaration: false },
+        isWatchMode: conf.watch,
         isDevMode: conf.dev,
         isForBundle: true,
         isEmitOnly: conf.emitOnly,
         isNoEmit: conf.noEmit,
-        watchScopePathSet: conf.watchScopePathSet,
+        scopePathSet: conf.scopePathSet,
       });
 
       let tsCompileResult: ISdTsCompilerResult;
@@ -53,8 +55,6 @@ export function createSdNgPlugin(conf: {
         Math.floor((os.cpus().length * 2) / 3),
       );
 
-      // let cssStore = new Map<TNormPath, Buffer>();
-
       //---------------------------
 
       build.onStart(async () => {
@@ -67,8 +67,6 @@ export function createSdNgPlugin(conf: {
 
           tsCompileResult = await tsCompiler.compileAsync(conf.modifiedFileSet);
 
-          // cssStore.clear();
-
           conf.result.watchFileSet = tsCompileResult.watchFileSet;
           conf.result.affectedFileSet = tsCompileResult.affectedFileSet;
 
@@ -76,6 +74,7 @@ export function createSdNgPlugin(conf: {
             tsCompileResult.messages,
             conf.pkgPath,
           );
+
           //-- return err/warn
           return {
             errors: [
@@ -97,83 +96,9 @@ export function createSdNgPlugin(conf: {
         return res;
       });
 
-      /*build.onResolve({ filter: /\.css$/ }, (args) => {
-        if (args.path.startsWith("sd-css-asset:")) return;
-        return {
-          path: path.resolve(args.resolveDir, args.path),
-          namespace: "sd-css",
-        };
-      });
-
-      build.onLoad({ filter: /\.css$/, namespace: "sd-css" }, async (args) => {
-        const code = /!* language=javascript *!/ `
-import href from "sd-css-asset:${PathUtils.posix(args.path)}"
-(function __sdEnsureStyle(href) {
-  let link = document.querySelector('link[data-sd-style="' + href + '"]');
-  if (link) return;
-  link = document.createElement('link');
-  link.rel = 'stylesheet';
-  link.setAttribute('data-sd-style', href);
-  link.href = href;
-  document.head.appendChild(link);
-})(href);`;
-
-        if (FsUtils.exists(args.path)) {
-          const css = await FsUtils.readFileBufferAsync(args.path);
-          cssStore.set(PathUtils.norm(args.path), css);
-        }
-
-        return { contents: code, loader: "js", resolveDir: path.dirname(args.path) };
-      });
-
-      build.onResolve({ filter: /^sd-css-asset:/ }, (args) => {
-        const real = args.path.replace(/^sd-css-asset:/, "");
-        return { path: real, namespace: "sd-css-asset" };
-      });
-
-      build.onLoad({ filter: /\.css$/, namespace: "sd-css-asset" }, (args) => {
-        const cssContent =
-          cssStore.get(PathUtils.norm(args.path)) ??
-          cssStore.get(PathUtils.norm(args.path.replace(/[\\\/]src[\\\/]/, "\\dist\\")));
-        if (cssContent == null) {
-          return {
-            errors: [
-              {
-                location: null,
-                text: `Missing CSS for ${PathUtils.norm(args.path)}`,
-              },
-            ],
-          };
-        }
-
-        return {
-          contents: cssContent,
-          loader: "file",
-          resolveDir: path.dirname(args.path),
-        };
-      });*/
-
       build.onLoad({ filter: /\.ts$/ }, async (args) => {
         const emittedFiles = tsCompileResult.emittedFilesCacheMap.get(PathUtils.norm(args.path));
 
-        /*try {
-          const css = emittedFiles?.single((item) => Boolean(item.outAbsPath?.endsWith(".css")));
-          if (css) {
-            cssStore.set(PathUtils.norm(css.outAbsPath!), Buffer.from(css.text));
-          }
-        } catch (err) {
-          return {
-            errors: [
-              {
-                text:
-                  (err?.message ?? String(err)) +
-                  "\n" +
-                  emittedFiles?.map((item) => "- " + item.outAbsPath).join("\n"),
-              },
-            ],
-          };
-        }*/
-
         const output = outputContentsCacheMap.get(PathUtils.norm(args.path));
         if (output != null) {
           return { contents: output, loader: "js" };
@@ -210,10 +135,6 @@ import href from "sd-css-asset:${PathUtils.posix(args.path)}"
 
         try {
           const newContents = await perf.run("esbuild transform:js:*.js", async () => {
-            /*return /\.min\.[cm]?js$/.test(args.path)
-              ? await FsUtils.readFileBufferAsync(args.path)
-              : await javascriptTransformer.transformFile(args.path, false, sideEffects);*/
-
             const contents = await FsUtils.readFileBufferAsync(args.path);
 
             return await javascriptTransformer.transformData(
@@ -232,10 +153,6 @@ import href from "sd-css-asset:${PathUtils.posix(args.path)}"
           };
         } catch (err) {
           return { errors: [{ text: err?.message ?? String(err) }] };
-          /*return {
-            contents: `console.error(${JSON.stringify(err.message)});`,
-            loader: "js",
-          };*/
         }
       });
 

package/src/pkg-builders/commons/{scope-path.ts → ScopePathSet.ts}

@@ -3,8 +3,8 @@ import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
 export class ScopePathSet {
   #data: Set<TNormPath>;
 
-  constructor(arr?: TNormPath[]) {
-    this.#data = new Set(arr);
+  constructor(arrOrSet?: TNormPath[] | Set<TNormPath>) {
+    this.#data = arrOrSet instanceof Set ? arrOrSet : new Set(arrOrSet);
   }
 
   inScope(filePath: string) {
@@ -14,4 +14,4 @@ export class ScopePathSet {
   toArray() {
     return Array.from(this.#data);
   }
-}
+}

package/src/pkg-builders/commons/SdBuildRunnerBase.ts

@@ -0,0 +1,47 @@
+import { FsUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
+import path from "path";
+import { ISdProjectConfig, TSdPackageConfig } from "../../types/config/ISdProjectConfig";
+import { ScopePathSet } from "./ScopePathSet";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
+
+export abstract class SdBuildRunnerBase<T extends "server" | "library" | "client"> {
+  protected abstract _logger: SdLogger;
+
+  protected _pkgName: string;
+  protected _pkgConf: TSdPackageConfig<T>;
+
+  protected _scopePathSet: ScopePathSet;
+
+  constructor(
+    protected _pkgPath: TNormPath,
+    protected _projConf: ISdProjectConfig,
+    scopePathSet: Set<TNormPath>,
+    protected _watch: boolean,
+    protected _dev: boolean,
+    protected _emitOnly?: boolean,
+    protected _noEmit?: boolean,
+  ) {
+    this._pkgName = path.basename(_pkgPath);
+    this._pkgConf = _projConf.packages[this._pkgName] as TSdPackageConfig<T>;
+
+    this._scopePathSet = new ScopePathSet(scopePathSet);
+  }
+
+  async rebuildAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
+    if (!modifiedFileSet && !this._noEmit) {
+      const distPath = path.resolve(this._pkgPath, "dist");
+      if (FsUtils.exists(distPath)) {
+        this._debug("dist 초기화...");
+        FsUtils.remove(distPath);
+      }
+    }
+
+    return await this._runAsync(modifiedFileSet);
+  }
+
+  protected abstract _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult>;
+
+  protected _debug(msg: string): void {
+    this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
+  }
+}

package/src/pkg-builders/lib/{sd-cli-db-context.file-generator.ts → SdCliDbContextFileGenerator.ts}

@@ -1,7 +1,7 @@
 import { FsUtils, HashUtils, PathUtils, SdFsWatcher } from "@simplysm/sd-core-node";
 import path from "path";
 import { StringUtils } from "@simplysm/sd-core-common";
-import { INpmConfig } from "../../types/common-configs.types";
+import { INpmConfig } from "../../types/common-config/INpmConfig";
 
 export class SdCliDbContextFileGenerator {
   cachedHash?: string;

package/src/pkg-builders/lib/{sd-js-lib.build-runner.ts → SdJsLibBuildRunner.ts}

@@ -1,29 +1,20 @@
-import {
-  FsUtils,
-  ISdFsWatcherChangeInfo,
-  PathUtils,
-  SdLogger,
-  TNormPath,
-} from "@simplysm/sd-core-node";
+import { FsUtils, PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
 import path from "path";
-import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.utils";
-// import { TSdLintWorkerType } from "../../types/workers.type";
 import { ESLint } from "eslint";
-import { BuildRunnerBase, IBuildRunnerRunResult } from "../commons/build-runner.base";
+import { SdBuildRunnerBase } from "../commons/SdBuildRunnerBase";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
+import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
 
-export class SdJsLibBuildRunner extends BuildRunnerBase<"library"> {
+export class SdJsLibBuildRunner extends SdBuildRunnerBase<"library"> {
   protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdJsLibBuildRunner"]);
 
-  protected override async _runAsync(
-    dev: boolean,
-    emitOnly: boolean,
-    noEmit: boolean,
-    modifiedFileSet?: Set<TNormPath>,
-  ): Promise<IBuildRunnerRunResult> {
-    if (emitOnly) {
+  protected override async _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
+    if (this._emitOnly) {
       return {
-        affectedFileSet: new Set(),
         buildMessages: [],
+
+        watchFileSet: new Set(),
+        affectedFileSet: new Set(),
         emitFileSet: new Set(),
       };
     }
@@ -44,24 +35,14 @@ export class SdJsLibBuildRunner extends BuildRunnerBase<"library"> {
     this._debug(`LINT 완료`);
 
     return {
-      affectedFileSet: filePathSet,
       buildMessages: messages,
+
+      watchFileSet: filePathSet,
+      affectedFileSet: filePathSet,
       emitFileSet: new Set(),
     };
   }
 
-  protected override _getModifiedFileSet(changeInfos: ISdFsWatcherChangeInfo[]) {
-    return new Set(
-      changeInfos
-        .filter(
-          (item) =>
-            FsUtils.exists(item.path) &&
-            PathUtils.isChildPath(item.path, path.resolve(this._pkgPath, "src")),
-        )
-        .map((item) => item.path),
-    );
-  }
-
   async #lintAsync(fileSet: Set<string>) {
     const lintFilePaths = Array.from(fileSet)
       .filter((item) => PathUtils.isChildPath(item, path.resolve(this._pkgPath, "src")))

package/src/pkg-builders/lib/SdTsLibBuildRunner.ts

@@ -0,0 +1,47 @@
+import { PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
+import { SdBuildRunnerBase } from "../commons/SdBuildRunnerBase";
+import { SdTsLibBuilder } from "./SdTsLibBuilder";
+import { SdCliIndexFileGenerator } from "./SdCliIndexFileGenerator";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
+import { SdCliDbContextFileGenerator } from "./SdCliDbContextFileGenerator";
+
+export class SdTsLibBuildRunner extends SdBuildRunnerBase<"library"> {
+  protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdTsLibBuildRunner"]);
+
+  #builder?: SdTsLibBuilder;
+
+  protected override async _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
+    // 최초한번
+    if (!modifiedFileSet) {
+      if (!this._noEmit) {
+        // index
+        if (!this._pkgConf.noGenIndex) {
+          this._debug("GEN index.ts...");
+          new SdCliIndexFileGenerator().watch(this._pkgPath, this._pkgConf.polyfills);
+        }
+
+        // db-context
+        if (this._pkgConf.dbContext != null) {
+          this._debug(`GEN ${this._pkgConf.dbContext}.ts...`);
+          new SdCliDbContextFileGenerator().watch(this._pkgPath, this._pkgConf.dbContext);
+        }
+      }
+
+      this._debug(`BUILD 준비...`);
+      this.#builder = new SdTsLibBuilder(
+        PathUtils.norm(this._pkgPath),
+        this._watch,
+        this._dev,
+        this._emitOnly ?? false,
+        this._noEmit ?? false,
+        this._scopePathSet,
+      );
+    }
+
+    this._debug(`BUILD...`);
+    const buildResult = await this.#builder!.buildAsync(modifiedFileSet);
+
+    this._debug(`빌드 완료`);
+    return buildResult;
+  }
+}

package/src/pkg-builders/lib/{sd-ts-lib.builder.ts → SdTsLibBuilder.ts}

@@ -1,9 +1,9 @@
 import path from "path";
-import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.utils";
+import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
 import { FsUtils, HashUtils, PathUtils, TNormPath } from "@simplysm/sd-core-node";
-import { ISdBuildMessage } from "../../types/build.types";
-import { SdTsCompiler } from "../../ts-compiler/sd-ts-compiler";
-import { ScopePathSet } from "../commons/scope-path";
+import { SdTsCompiler } from "../../ts-compiler/SdTsCompiler";
+import { ScopePathSet } from "../commons/ScopePathSet";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 
 export class SdTsLibBuilder {
   #tsCompiler: SdTsCompiler;
@@ -11,30 +11,26 @@ export class SdTsLibBuilder {
 
   constructor(
     private readonly _pkgPath: TNormPath,
+    watch: boolean,
     dev: boolean,
     emitOnly: boolean,
     noEmit: boolean,
-    watchScopePathSet: ScopePathSet,
+    scopePathSet: ScopePathSet,
   ) {
     this.#tsCompiler = new SdTsCompiler({
       pkgPath: this._pkgPath,
       additionalOptions: { declaration: true },
+      isWatchMode: watch,
       isDevMode: dev,
       isEmitOnly: emitOnly,
       isNoEmit: noEmit,
-      globalStyleFilePath: PathUtils.norm(this._pkgPath, "src/styles.scss"),
       isForBundle: false,
-      watchScopePathSet,
+      scopePathSet,
     });
   }
 
-  async buildAsync(modifiedFileSet: Set<TNormPath>): Promise<{
-    watchFileSet: Set<TNormPath>;
-    affectedFileSet: Set<TNormPath>;
-    results: ISdBuildMessage[];
-    emitFileSet: Set<TNormPath>;
-  }> {
-    const tsCompileResult = await this.#tsCompiler.compileAsync(modifiedFileSet);
+  async buildAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
+    const tsCompileResult = await this.#tsCompiler.compileAsync(modifiedFileSet ?? new Set());
 
     const emitFileSet = new Set<TNormPath>();
     for (const emitFile of tsCompileResult.emitFileSet) {
@@ -81,9 +77,10 @@ export class SdTsLibBuilder {
     );
 
     return {
+      buildMessages: [...tsCompileResult.messages, ...styleResults],
+
       watchFileSet: tsCompileResult.watchFileSet,
       affectedFileSet: tsCompileResult.affectedFileSet,
-      results: [...tsCompileResult.messages, ...styleResults],
       emitFileSet,
     };
   }

package/src/pkg-builders/server/{sd-server.build-runner.ts → SdServerBuildRunner.ts}

@@ -1,47 +1,40 @@
 import { FsUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
 import path from "path";
 import { javascript, StringUtils } from "@simplysm/sd-core-common";
-import { SdServerBundler } from "./sd-server.bundler";
-import { INpmConfig, ITsConfig } from "../../types/common-configs.types";
-import { BuildRunnerBase, IBuildRunnerRunResult } from "../commons/build-runner.base";
+import { SdBuildRunnerBase } from "../commons/SdBuildRunnerBase";
+import { SdServerBundler } from "./SdServerBundler";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
+import { ITsConfig } from "../../types/common-config/ITsConfig";
+import { INpmConfig } from "../../types/common-config/INpmConfig";
 
-export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
-  protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliServerBuildRunner"]);
+export class SdServerBuildRunner extends SdBuildRunnerBase<"server"> {
+  protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBuild2Runner"]);
 
   #serverBundler?: SdServerBundler;
   #extModules?: { name: string; exists: boolean }[];
 
-  protected override async _runAsync(
-    dev: boolean,
-    emitOnly: boolean,
-    noEmit: boolean,
-    modifiedFileSet?: Set<TNormPath>,
-  ): Promise<IBuildRunnerRunResult> {
-    if (!dev) {
+  protected override async _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
+    // prod일때 각종 파일들 생성
+    if (!this._dev) {
       await this.#generateProductionFilesAsync();
     }
 
-    if (!noEmit) {
-      if (!modifiedFileSet) {
+    // 최초
+    if (!modifiedFileSet) {
+      if (!this._noEmit) {
         this._debug("GEN .config...");
         const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
         FsUtils.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
       }
-    }
 
-    /*const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {}).mapMany((key) =>
-      FsUtils.glob(path.resolve(this._pkgPath, "../../node_modules", key)),
-    );*/
-
-    this._debug(`BUILD 준비...`);
-    const tsConfig = FsUtils.readJson(path.resolve(this._pkgPath, "tsconfig.json")) as ITsConfig;
-    this.#extModules = this.#extModules ?? (await this.#getExternalModulesAsync());
-    this.#serverBundler =
-      this.#serverBundler ??
-      new SdServerBundler({
-        dev,
-        emitOnly,
-        noEmit,
+      this._debug(`BUILD 준비...`);
+      const tsConfig = FsUtils.readJson(path.resolve(this._pkgPath, "tsconfig.json")) as ITsConfig;
+      this.#extModules = this.#extModules ?? (await this.#getExternalModulesAsync());
+      this.#serverBundler = new SdServerBundler({
+        watch: this._watch,
+        dev: this._dev,
+        emitOnly: this._emitOnly ?? false,
+        noEmit: this._noEmit ?? false,
         pkgPath: this._pkgPath,
         entryPoints: tsConfig.files
           ? tsConfig.files.map((item) => path.resolve(this._pkgPath, item))
@@ -50,24 +43,15 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
               ...FsUtils.glob(path.resolve(this._pkgPath, "src/workers/*.ts")),
             ],
         external: this.#extModules.map((item) => item.name),
-        watchScopePathSet: this._watchScopePathSet,
+        scopePathSet: this._scopePathSet,
       });
+    }
 
     this._debug(`BUILD...`);
-    const bundleResult = await this.#serverBundler.bundleAsync(modifiedFileSet);
-
-    //-- filePaths
-    const watchFileSet = new Set(
-      Array.from(bundleResult.watchFileSet).filter((item) => this._watchScopePathSet.inScope(item)),
-    );
+    const bundleResult = await this.#serverBundler!.bundleAsync(modifiedFileSet);
 
     this._debug(`빌드 완료`);
-    return {
-      watchFileSet,
-      affectedFileSet: bundleResult.affectedFileSet,
-      buildMessages: bundleResult.results,
-      emitFileSet: bundleResult.emitFileSet,
-    };
+    return bundleResult;
   }
 
   async #generateProductionFilesAsync() {
@@ -92,13 +76,6 @@ export class SdServerBuildRunner extends BuildRunnerBase<"server"> {
         distNpmConfig.dependencies[dep] = "*";
       }
 
-      // distNpmConfig.scripts = {};
-      // if (this._pkgConf.pm2 && !this._pkgConf.pm2.noStartScript) {
-      //   distNpmConfig.scripts["start"] = "pm2 start pm2.config.cjs";
-      //   distNpmConfig.scripts["stop"] = "pm2 stop pm2.config.cjs";
-      //   distNpmConfig.scripts["delete"] = "pm2 delete pm2.config.cjs";
-      // }
-
       distNpmConfig.volta = projNpmConf.volta;
 
       FsUtils.writeJson(path.resolve(this._pkgPath, "dist/package.json"), distNpmConfig, {

package/src/pkg-builders/server/{sd-server.bundler.ts → SdServerBundler.ts}

@@ -1,17 +1,17 @@
 import esbuild from "esbuild";
 import path from "path";
 import { FsUtils, HashUtils, PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
-import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.utils";
-import { ISdCliServerPluginResultCache } from "../../types/build-plugin.types";
-import { ISdBuildMessage } from "../../types/build.types";
-import { createSdServerPlugin } from "./sd-server.plugin-creator";
+import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
+import { createSdServerPlugin } from "./createSdServerPlugin";
 import {
   BuildOutputFile,
   BuildOutputFileType,
 } from "@angular/build/src/tools/esbuild/bundler-context";
 import { convertOutputFile } from "@angular/build/src/tools/esbuild/utils";
 import { resolveAssets } from "@angular/build/src/utils/resolve-assets";
-import { ScopePathSet } from "../commons/scope-path";
+import { ScopePathSet } from "../commons/ScopePathSet";
+import { ISdCliServerPluginResultCache } from "../../types/plugin/ISdCliServerPluginResultCache";
+import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 
 export class SdServerBundler {
   #logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
@@ -25,22 +25,18 @@ export class SdServerBundler {
 
   constructor(
     private readonly _opt: {
+      watch: boolean;
       dev: boolean;
       emitOnly: boolean;
       noEmit: boolean;
       pkgPath: TNormPath;
       entryPoints: string[];
       external?: string[];
-      watchScopePathSet: ScopePathSet;
+      scopePathSet: ScopePathSet;
     },
   ) {}
 
-  async bundleAsync(modifiedFileSet?: Set<TNormPath>): Promise<{
-    watchFileSet: Set<TNormPath>;
-    affectedFileSet: Set<TNormPath>;
-    results: ISdBuildMessage[];
-    emitFileSet: Set<TNormPath>;
-  }> {
+  async bundleAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult> {
     this.#modifiedFileSet.clear();
     if (modifiedFileSet) {
       this.#modifiedFileSet.adds(...modifiedFileSet);
@@ -109,25 +105,30 @@ const __dirname = __path__.dirname(__filename);`.trim(),
         plugins: [
           createSdServerPlugin({
             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.#resultCache,
-            watchScopePathSet: this._opt.watchScopePathSet,
+            scopePathSet: this._opt.scopePathSet,
           }),
         ],
       });
     }
 
-    let result: esbuild.BuildResult | esbuild.BuildFailure;
-    result = await this.#context.rebuild();
+    let esbuildResult: esbuild.BuildResult | esbuild.BuildFailure;
+    esbuildResult = await this.#context.rebuild();
 
     if (this._opt.noEmit) {
       return {
+        buildMessages: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
+          esbuildResult,
+          this._opt.pkgPath,
+        ),
+
         watchFileSet: this.#resultCache.watchFileSet!,
         affectedFileSet: this.#resultCache.affectedFileSet!,
-        results: [],
         emitFileSet: new Set<TNormPath>(),
       };
     } else {
@@ -135,8 +136,9 @@ const __dirname = __path__.dirname(__filename);`.trim(),
 
       try {
         const outputFiles: BuildOutputFile[] =
-          result.outputFiles?.map((file) => convertOutputFile(file, BuildOutputFileType.Root)) ??
-          [];
+          esbuildResult.outputFiles?.map((file) =>
+            convertOutputFile(file, BuildOutputFileType.Root),
+          ) ?? [];
 
         for (const outputFile of outputFiles) {
           const distFilePath = PathUtils.norm(this._opt.pkgPath, outputFile.path);
@@ -171,7 +173,7 @@ const __dirname = __path__.dirname(__filename);`.trim(),
           }
         }
       } catch (err) {
-        result = err;
+        esbuildResult = err;
         for (const e of err.errors) {
           if (e.detail != null) {
             this.#logger.error(e.detail);
@@ -180,12 +182,13 @@ const __dirname = __path__.dirname(__filename);`.trim(),
       }
 
       return {
-        watchFileSet: this.#resultCache.watchFileSet!,
-        affectedFileSet: this.#resultCache.affectedFileSet!,
-        results: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
-          result,
+        buildMessages: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
+          esbuildResult,
           this._opt.pkgPath,
         ),
+
+        watchFileSet: this.#resultCache.watchFileSet!,
+        affectedFileSet: this.#resultCache.affectedFileSet!,
         emitFileSet: emitFileSet,
       };
     }