@simplysm/sd-cli 11.1.20 → 11.1.21

package/src/build-tools/SdNgBundler.ts

@@ -93,8 +93,8 @@ export class SdNgBundler {
 
   public async bundleAsync(): Promise<{
     program: ts.Program;
-    filePaths: string[],
-    affectedFilePaths: string[],
+    watchFileSet: Set<string>,
+    affectedFileSet: Set<string>,
     results: ISdCliPackageBuildResult[]
   }> {
     const logger = Logger.get(["simplysm", "sd-cli", "SdNgBundler", "bundleAsync"]);
@@ -211,8 +211,8 @@ export class SdNgBundler {
 
     return {
       program: this.#ngResultCache.program!,
-      filePaths: Array.from(this.#ngResultCache.watchFileSet!),
-      affectedFilePaths: Array.from(this.#ngResultCache.affectedFileSet!),
+      watchFileSet: this.#ngResultCache.watchFileSet!,
+      affectedFileSet: this.#ngResultCache.affectedFileSet!,
       results
     };
   }

package/src/build-tools/{SdTsBundler.ts → SdServerBundler.ts}

@@ -1,14 +1,15 @@
 import {ISdCliPackageBuildResult} from "../commons";
 import esbuild from "esbuild";
 import path from "path";
+import {IServerBundlerResultCache, sdServerPlugin} from "../bundle-plugins/sdServerPlugin";
 import ts from "typescript";
-import {FsUtil} from "@simplysm/sd-core-node";
-import {sdLoadedFilesPlugin} from "../bundle-plugins/sdLoadedFilesPlugin";
-import {sdTscPlugin} from "../bundle-plugins/sdTscPlugin";
 
-export class SdTsBundler {
+export class SdServerBundler {
   #context?: esbuild.BuildContext;
 
+  #modifiedFileSet = new Set<string>();
+  #resultCache: Partial<IServerBundlerResultCache> = {};
+
   constructor(private readonly _opt: {
     dev: boolean;
     pkgPath: string;
@@ -17,12 +18,18 @@ export class SdTsBundler {
   }) {
   }
 
+  public markForChanges(filePaths: string[]): void {
+    for (const filePath of filePaths) {
+      this.#modifiedFileSet.add(path.normalize(filePath));
+    }
+  }
+
   async bundleAsync(): Promise<{
-    filePaths: string[];
+    program: ts.Program;
+    watchFileSet: Set<string>;
+    affectedFileSet: Set<string>;
     results: ISdCliPackageBuildResult[];
   }> {
-    const loadFilePathSet = new Set<string>();
-
     if (!this.#context) {
       this.#context = await esbuild.context({
         entryPoints: this._opt.entryPoints,
@@ -65,7 +72,6 @@ export class SdTsBundler {
         },
         platform: "node",
         logLevel: "silent",
-        // packages: "external",
         external: this._opt.external,
         banner: {
           js: `
@@ -78,16 +84,12 @@ const __filename = __fileURLToPath__(import.meta.url);
 const __dirname = __path__.dirname(__filename);`.trim()
         },
         plugins: [
-          sdTscPlugin({
-            parsedTsconfig: ts.parseJsonConfigFileContent(
-              FsUtil.readJson(path.resolve(this._opt.pkgPath, "tsconfig.json")),
-              ts.sys,
-              this._opt.pkgPath
-            )
+          sdServerPlugin({
+            modifiedFileSet: this.#modifiedFileSet,
+            dev: this._opt.dev,
+            pkgPath: this._opt.pkgPath,
+            result: this.#resultCache
           }),
-          sdLoadedFilesPlugin({
-            loadedFileSet: loadFilePathSet
-          })
         ]
       });
     }
@@ -101,7 +103,9 @@ const __dirname = __path__.dirname(__filename);`.trim()
     }
 
     return {
-      filePaths: Array.from(loadFilePathSet).map(item => path.resolve(item)),
+      program: this.#resultCache.program!,
+      watchFileSet: this.#resultCache.watchFileSet!,
+      affectedFileSet: this.#resultCache.affectedFileSet!,
       results: [
         ...result.warnings.map((warn) => ({
           type: "build" as const,

package/src/build-tools/SdTsCompiler.ts

@@ -99,8 +99,8 @@ export class SdTsCompiler {
   }
 
   public async buildAsync(): Promise<{
-    filePaths: string[];
-    affectedFilePaths: string[];
+    watchFileSet: Set<string>;
+    affectedFileSet: Set<string>;
     results: ISdCliPackageBuildResult[];
   }> {
     const markedChanges = this._markedChanges;
@@ -156,7 +156,7 @@ export class SdTsCompiler {
     }
 
     const diagnostics: ts.Diagnostic[] = [];
-    const affectedFilePaths: string[] = [];
+    const affectedFileSet = new Set<string>();
 
     if (this._ngProgram) {
       diagnostics.push(...this._ngProgram.compiler.getOptionDiagnostics());
@@ -201,7 +201,7 @@ export class SdTsCompiler {
       diagnostics.push(...semanticResult.result);
 
       if ("fileName" in affectedSourceFile) {
-        affectedFilePaths.push(path.resolve(affectedSourceFile.fileName));
+        affectedFileSet.add(path.normalize(affectedSourceFile.fileName));
       }
     }
 
@@ -209,21 +209,19 @@ export class SdTsCompiler {
       for (const markedChange of markedChanges) {
         const depsSet = this._styleDepsCache.get(markedChange);
         if (depsSet) {
-          affectedFilePaths.push(...depsSet);
+          affectedFileSet.adds(...depsSet);
         }
       }
-      affectedFilePaths.distinctThis();
     }
 
     const globalStyleFilePath = path.resolve(this._opt.pkgPath, "src/styles.scss");
     if (this._opt.globalStyle && FsUtil.exists(globalStyleFilePath) && markedChanges.includes(globalStyleFilePath)) {
-      affectedFilePaths.push(globalStyleFilePath);
-      affectedFilePaths.distinctThis();
+      affectedFileSet.add(globalStyleFilePath);
     }
 
     this._logger.debug(`[${path.basename(this._opt.pkgPath)}] 영향받는 파일 ${this._opt.emit ? "EMIT" : "CHECK"}...`);
 
-    for (const affectedFilePath of affectedFilePaths) {
+    for (const affectedFilePath of affectedFileSet) {
       if (this._opt.globalStyle && affectedFilePath === globalStyleFilePath) {
         try {
           const content = await FsUtil.readFileAsync(affectedFilePath);
@@ -294,16 +292,16 @@ export class SdTsCompiler {
       }
     }
 
-    this._logger.debug(`[${path.basename(this._opt.pkgPath)}] 영향받는 파일 ${this._opt.emit ? "EMIT" : "CHECK"} 완료`, affectedFilePaths);
+    this._logger.debug(`[${path.basename(this._opt.pkgPath)}] 영향받는 파일 ${this._opt.emit ? "EMIT" : "CHECK"} 완료`, affectedFileSet);
 
     const buildResults = diagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item, this._opt.emit ? "build" : "check"));
 
     return {
-      filePaths: [
+      watchFileSet: new Set([
         ...Array.from(this._styleDepsCache.keys()),
-        ...this._builder.getSourceFiles().map(item => path.resolve(item.fileName))
-      ],
-      affectedFilePaths: affectedFilePaths,
+        ...this._builder.getSourceFiles().map(item => path.normalize(item.fileName))
+      ]),
+      affectedFileSet: affectedFileSet,
       results: buildResults
     };
   }

package/src/builders/SdCliClientBuilder.ts

@@ -42,7 +42,11 @@ export class SdCliClientBuilder extends EventEmitter {
     const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
     await FsUtil.writeFileAsync(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
 
-    return await this._runAsync({dev: false});
+    const result = await this._runAsync({dev: false});
+    return {
+      affectedFilePaths: Array.from(result.affectedFileSet),
+      buildResults: result.buildResults
+    };
   }
 
   public async watchAsync() {
@@ -59,13 +63,16 @@ export class SdCliClientBuilder extends EventEmitter {
     await FsUtil.writeFileAsync(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
 
     const result = await this._runAsync({dev: true});
-    this.emit("complete", result);
+    this.emit("complete", {
+      affectedFilePaths: Array.from(result.affectedFileSet),
+      buildResults: result.buildResults
+    });
 
     this._debug("WATCH...");
     let changeFiles: string[] = [];
     const fnQ = new FunctionQueue();
     const watcher = SdFsWatcher
-      .watch(result.watchFilePaths)
+      .watch(Array.from(result.watchFileSet))
       .onChange({delay: 100}, (changeInfos) => {
         changeFiles.push(...changeInfos.map((item) => item.path));
 
@@ -81,9 +88,12 @@ export class SdCliClientBuilder extends EventEmitter {
           }
 
           const watchResult = await this._runAsync({dev: true});
-          this.emit("complete", watchResult);
+          this.emit("complete", {
+            affectedFilePaths: Array.from(watchResult.affectedFileSet),
+            buildResults: watchResult.buildResults
+          });
 
-          watcher.add(watchResult.watchFilePaths);
+          watcher.add(watchResult.watchFileSet);
         });
       });
   }
@@ -91,8 +101,8 @@ export class SdCliClientBuilder extends EventEmitter {
   private async _runAsync(opt: {
     dev: boolean;
   }): Promise<{
-    watchFilePaths: string[];
-    affectedFilePaths: string[];
+    watchFileSet: Set<string>;
+    affectedFileSet: Set<string>;
     buildResults: ISdCliPackageBuildResult[];
   }> {
     const builderTypes = (Object.keys(this._pkgConf.builder ?? {web: {}}) as ("web" | "electron" | "cordova")[]);
@@ -126,8 +136,8 @@ export class SdCliClientBuilder extends EventEmitter {
 
     this._debug(`BUILD & CHECK...`);
     const buildResults = await Promise.all(this._builders.map((builder) => builder.bundleAsync()));
-    const filePaths = buildResults.mapMany(item => item.filePaths).distinct();
-    const affectedFilePaths = buildResults.mapMany(item => item.affectedFilePaths).distinct();
+    const watchFileSet = new Set(buildResults.mapMany(item => Array.from(item.watchFileSet)));
+    const affectedFileSet = new Set(buildResults.mapMany(item => Array.from(item.affectedFileSet)));
     const results = buildResults.mapMany((item) => item.results).distinct();
     const firstProgram = buildResults.first()?.program;
 
@@ -140,7 +150,7 @@ export class SdCliClientBuilder extends EventEmitter {
     //   oldProgram: this.#program
     // });
     // const pkgFilePaths = filePaths.filter(item => PathUtil.isChildPath(item, this._pkgPath));
-    const lintResults = await SdLinter.lintAsync(affectedFilePaths.filter(item => PathUtil.isChildPath(item, this._pkgPath)), firstProgram);
+    const lintResults = await SdLinter.lintAsync(Array.from(affectedFileSet).filter(item => PathUtil.isChildPath(item, this._pkgPath)), firstProgram);
 
     if (!opt.dev && this._cordova) {
       this._debug("CORDOVA BUILD...");
@@ -150,13 +160,13 @@ export class SdCliClientBuilder extends EventEmitter {
     this._debug(`빌드 완료`);
     const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {})
       .mapMany((key) => FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)));
-    const watchFilePaths = filePaths.filter(item =>
+    const currWatchFileSet = new Set(Array.from(watchFileSet).filter(item =>
       PathUtil.isChildPath(item, path.resolve(this._pkgPath, "../")) ||
       localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu))
-    );
+    ));
     return {
-      watchFilePaths: watchFilePaths,
-      affectedFilePaths: affectedFilePaths,
+      watchFileSet: currWatchFileSet,
+      affectedFileSet,
       buildResults: [...results, ...lintResults]
     };
   }

package/src/builders/SdCliServerBuilder.ts

@@ -9,16 +9,14 @@ import {
   ITsConfig
 } from "../commons";
 import path from "path";
-import {SdTsCompiler} from "../build-tools/SdTsCompiler";
 import {SdLinter} from "../build-tools/SdLinter";
 import {FunctionQueue, ObjectUtil, StringUtil} from "@simplysm/sd-core-common";
-import {SdTsBundler} from "../build-tools/SdTsBundler";
+import {SdServerBundler} from "../build-tools/SdServerBundler";
 
 export class SdCliServerBuilder extends EventEmitter {
   #logger = Logger.get(["simplysm", "sd-cli", "SdCliServerBuilder"]);
   #pkgConf: ISdCliServerPackageConfig;
-  #builder?: SdTsBundler;
-  #checker?: SdTsCompiler;
+  #builder?: SdServerBundler;
   #extModules?: { name: string; exists: boolean }[];
 
   public constructor(private readonly _projConf: ISdCliConfig,
@@ -45,20 +43,34 @@ export class SdCliServerBuilder extends EventEmitter {
     await FsUtil.writeFileAsync(confDistPath, JSON.stringify(this.#pkgConf.configs ?? {}, undefined, 2));
 
     const result = await this._runAsync({dev: true});
-    this.emit("complete", result);
+    this.emit("complete", {
+      affectedFilePaths: Array.from(result.affectedFileSet),
+      buildResults: result.buildResults
+    });
 
     this._debug("WATCH...");
+    let changeFiles: string[] = [];
     const fnQ = new FunctionQueue();
     const watcher = SdFsWatcher
-      .watch(result.watchFilePaths)
-      .onChange({delay: 100}, () => {
+      .watch(Array.from(result.watchFileSet))
+      .onChange({delay: 100}, (changeInfos) => {
+        changeFiles.push(...changeInfos.map((item) => item.path));
+
         fnQ.runLast(async () => {
+          const currChangeFiles = [...changeFiles];
+          changeFiles = [];
+
           this.emit("change");
 
+          this.#builder!.markForChanges(currChangeFiles);
+
           const watchResult = await this._runAsync({dev: true});
-          this.emit("complete", watchResult);
+          this.emit("complete", {
+            affectedFilePaths: Array.from(watchResult.affectedFileSet),
+            buildResults: watchResult.buildResults
+          });
 
-          watcher.add(watchResult.watchFilePaths);
+          watcher.add(watchResult.watchFileSet);
         });
       });
   }
@@ -190,22 +202,22 @@ Options = UnsafeLegacyRenegotiation`.trim()
 `.trim());
     }
 
-    return await this._runAsync({dev: false});
+    const result = await this._runAsync({dev: false});
+    return {
+      affectedFilePaths: Array.from(result.affectedFileSet),
+      buildResults: result.buildResults
+    };
   }
 
   private async _runAsync(opt: { dev: boolean }): Promise<{
-    watchFilePaths: string[];
-    affectedFilePaths: string[];
+    watchFileSet: Set<string>;
+    affectedFileSet: Set<string>;
     buildResults: ISdCliPackageBuildResult[];
   }> {
     this._debug(`BUILD 준비...`);
-
-    this.#extModules = this.#extModules ?? await this._getExternalModulesAsync();
-
-
-    this._debug(`BUILD...`);
     const tsConfig = FsUtil.readJson(path.resolve(this._pkgPath, "tsconfig.json")) as ITsConfig;
-    this.#builder = this.#builder ?? new SdTsBundler({
+    this.#extModules = this.#extModules ?? await this._getExternalModulesAsync();
+    this.#builder = this.#builder ?? new SdServerBundler({
       dev: opt.dev,
       pkgPath: this._pkgPath,
       entryPoints: tsConfig.files ? tsConfig.files.map((item) => path.resolve(this._pkgPath, item)) : [
@@ -213,40 +225,27 @@ Options = UnsafeLegacyRenegotiation`.trim()
       ],
       external: this.#extModules.map((item) => item.name)
     });
-    const buildResult = await this.#builder.bundleAsync();
 
-    this._debug("CHECK...");
-    this.#checker = this.#checker ?? new SdTsCompiler({
-      pkgPath: this._pkgPath,
-      emit: false,
-      emitDts: false,
-      globalStyle: false
-    });
-    const checkResult = await this.#checker.buildAsync();
+    this._debug(`BUILD & CHECK...`);
+    const buildResult = await this.#builder.bundleAsync();
 
     //-- filePaths
 
-    const filePaths = [
-      ...buildResult.filePaths,
-      ...checkResult.filePaths
-    ];
-    const pkgFilePaths = filePaths.filter(item => PathUtil.isChildPath(item, this._pkgPath));
-
     const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {})
       .mapMany((key) => FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)));
-    const watchFilePaths = filePaths.filter(item =>
+    const watchFileSet = new Set(Array.from(buildResult.watchFileSet).filter(item =>
       PathUtil.isChildPath(item, path.resolve(this._pkgPath, "../")) ||
       localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu))
-    );
+    ));
 
     this._debug(`LINT...`);
-    const lintResults = await SdLinter.lintAsync(pkgFilePaths, this.#checker!.program);
+    const lintResults = await SdLinter.lintAsync(Array.from(buildResult.affectedFileSet).filter(item => PathUtil.isChildPath(item, this._pkgPath)), buildResult.program);
 
     this._debug(`빌드 완료`);
     return {
-      watchFilePaths,
-      affectedFilePaths: pkgFilePaths, //checkResult.affectedFilePaths,
-      buildResults: [...buildResult.results, ...checkResult.results, ...lintResults]
+      watchFileSet,
+      affectedFileSet: buildResult.affectedFileSet,
+      buildResults: [...buildResult.results, ...lintResults]
     };
   }
 

package/src/builders/SdCliTsLibBuilder.ts

@@ -35,7 +35,11 @@ export class SdCliTsLibBuilder extends EventEmitter {
       await SdCliIndexFileGenerator.runAsync(this._pkgPath, this._pkgConf.polyfills);
     }
 
-    return await this._runAsync();
+    const result = await this._runAsync();
+    return {
+      affectedFilePaths: Array.from(result.affectedFileSet),
+      buildResults: result.buildResults
+    };
   }
 
   public async watchAsync(): Promise<void> {
@@ -50,12 +54,15 @@ export class SdCliTsLibBuilder extends EventEmitter {
     }
 
     const result = await this._runAsync();
-    this.emit("complete", result);
+    this.emit("complete", {
+      affectedFilePaths: Array.from(result.affectedFileSet),
+      buildResults: result.buildResults
+    });
 
     this._debug("WATCH...");
     const fnQ = new FunctionQueue();
     const watcher = SdFsWatcher
-      .watch(result.watchFilePaths)
+      .watch(Array.from(result.watchFileSet))
       .onChange({delay: 100,}, (changeInfos) => {
         this._builder!.markChanges(changeInfos.map((item) => item.path));
 
@@ -63,16 +70,19 @@ export class SdCliTsLibBuilder extends EventEmitter {
           this.emit("change");
 
           const watchResult = await this._runAsync();
-          this.emit("complete", watchResult);
+          this.emit("complete", {
+            affectedFilePaths: Array.from(watchResult.affectedFileSet),
+            buildResults: watchResult.buildResults
+          });
 
-          watcher.add(watchResult.watchFilePaths);
+          watcher.add(watchResult.watchFileSet);
         });
       });
   }
 
   private async _runAsync(): Promise<{
-    watchFilePaths: string[];
-    affectedFilePaths: string[];
+    watchFileSet: Set<string>;
+    affectedFileSet: Set<string>;
     buildResults: ISdCliPackageBuildResult[];
   }> {
     this._debug(`BUILD && CHECK...`);
@@ -82,23 +92,23 @@ export class SdCliTsLibBuilder extends EventEmitter {
       emitDts: true,
       globalStyle: true
     });
-    const buildAndCheckResult = await this._builder.buildAsync();
+    const buildResult = await this._builder.buildAsync();
 
     this._debug("LINT...");
-    const lintResults = await SdLinter.lintAsync(buildAndCheckResult.affectedFilePaths, this._builder.program);
+    const lintResults = await SdLinter.lintAsync(Array.from(buildResult.affectedFileSet).filter(item => PathUtil.isChildPath(item, this._pkgPath)), this._builder.program);
 
     this._debug(`빌드 완료`);
     const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {})
       .mapMany((key) => FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)));
-    const watchFilePaths = buildAndCheckResult.filePaths.filter(item =>
+    const watchFileSet = new Set(Array.from(buildResult.watchFileSet).filter(item =>
       PathUtil.isChildPath(item, path.resolve(this._pkgPath, "../")) ||
       localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu))
-    );
+    ));
 
     return {
-      watchFilePaths,
-      affectedFilePaths: buildAndCheckResult.affectedFilePaths,
-      buildResults: [...buildAndCheckResult.results, ...lintResults]
+      watchFileSet,
+      affectedFileSet: buildResult.affectedFileSet,
+      buildResults: [...buildResult.results, ...lintResults]
     };
   }
 

package/src/bundle-plugins/sdNgPlugin.ts

@@ -146,7 +146,7 @@ export function sdNgPlugin(conf: {
   }
 
   return {
-    name: "sd-ng",
+    name: "sd-ng-compiler",
     setup: (build: esbuild.PluginBuild) => {
       //-- stylesheetBundler
       const browserTarget = transformSupportedBrowsersToTargets(browserslist("defaults and fully supports es6-module"));