@simplysm/sd-cli 11.1.44 → 11.1.46

package/src/build-cluster.ts

@@ -39,9 +39,10 @@ if (cluster.isPrimary) {
     sendMessage(message);
   });
 
-  process.on("message", (message) => {
+  process.on("message", (message: ISdCliBuildClusterReqMessage) => {
     cluster.fork({
-      "SD_CLUSTER_MESSAGE": JSON.stringify(message)
+      "SD_CLUSTER_MESSAGE": JSON.stringify(message),
+      "NODE_OPTIONS": message.execArgs?.join(" ")
     });
   });
   process.send!("ready");
@@ -50,143 +51,162 @@ else {
   const message = JSON.parse(process.env["SD_CLUSTER_MESSAGE"]!) as ISdCliBuildClusterReqMessage;
   const pkgConf = message.projConf.packages[path.basename(message.pkgPath)]!;
 
-  if (message.cmd === "watch") {
-    // [library] javascript
-    if (pkgConf.type === "library" && !FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
-      await new SdCliJsLibLinter(message.pkgPath)
-        .on("change", () => {
-          sendMessage({
-            type: "change",
-            req: message
-          });
-        })
-        .on("complete", (result) => {
-          sendMessage({
-            type: "complete",
-            result,
-            req: message
-          });
-        })
-        .watchAsync();
+  try {
+    if (message.cmd === "watch") {
+      // [library] javascript
+      if (pkgConf.type === "library" && !FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
+        await new SdCliJsLibLinter(message.pkgPath)
+          .on("change", () => {
+            sendMessage({
+              type: "change",
+              req: message
+            });
+          })
+          .on("complete", (result) => {
+            sendMessage({
+              type: "complete",
+              result,
+              req: message
+            });
+            logMemory(message);
+          })
+          .watchAsync();
 
-      sendMessage({
-        type: "ready",
-        req: message
-      });
+        sendMessage({
+          type: "ready",
+          req: message
+        });
+      }
+      // [library] typescript
+      else if (pkgConf.type === "library" && FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
+        await new SdCliTsLibBuilder(message.projConf, message.pkgPath)
+          .on("change", () => {
+            sendMessage({
+              type: "change",
+              req: message
+            });
+          })
+          .on("complete", (result) => {
+            sendMessage({
+              type: "complete",
+              result,
+              req: message
+            });
+            logMemory(message);
+          })
+          .watchAsync();
+        sendMessage({
+          type: "ready",
+          req: message
+        });
+      }
+      // [server]
+      else if (pkgConf.type === "server") {
+        await new SdCliServerBuilder(message.projConf, message.pkgPath)
+          .on("change", () => {
+            sendMessage({
+              type: "change",
+              req: message
+            });
+          })
+          .on("complete", (result) => {
+            sendMessage({
+              type: "complete",
+              result,
+              req: message
+            });
+            logMemory(message);
+          })
+          .watchAsync();
+        sendMessage({
+          type: "ready",
+          req: message
+        });
+      }
+      // [client]
+      else if (pkgConf.type === "client") {
+        await new SdCliClientBuilder(message.projConf, message.pkgPath)
+          .on("change", () => {
+            sendMessage({
+              type: "change",
+              req: message
+            });
+          })
+          .on("complete", (result) => {
+            sendMessage({
+              type: "complete",
+              result,
+              req: message
+            });
+            logMemory(message);
+          })
+          .watchAsync();
+        sendMessage({
+          type: "ready",
+          req: message
+        });
+      }
+      else {
+        throw new NeverEntryError();
+      }
     }
-    // [library] typescript
-    else if (pkgConf.type === "library" && FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
-      await new SdCliTsLibBuilder(message.projConf, message.pkgPath)
-        .on("change", () => {
-          sendMessage({
-            type: "change",
-            req: message
-          });
-        })
-        .on("complete", (result) => {
-          sendMessage({
-            type: "complete",
-            result,
-            req: message
-          });
-        })
-        .watchAsync();
-      sendMessage({
-        type: "ready",
-        req: message
-      });
-    }
-    // [server]
-    else if (pkgConf.type === "server") {
-      await new SdCliServerBuilder(message.projConf, message.pkgPath)
-        .on("change", () => {
-          sendMessage({
-            type: "change",
-            req: message
-          });
-        })
-        .on("complete", (result) => {
-          sendMessage({
-            type: "complete",
-            result,
-            req: message
-          });
-        })
-        .watchAsync();
-      sendMessage({
-        type: "ready",
-        req: message
-      });
-    }
-    // [client]
-    else if (pkgConf.type === "client") {
-      await new SdCliClientBuilder(message.projConf, message.pkgPath)
-        .on("change", () => {
-          sendMessage({
-            type: "change",
-            req: message
-          });
-        })
-        .on("complete", (result) => {
-          sendMessage({
-            type: "complete",
-            result,
-            req: message
-          });
-        })
-        .watchAsync();
-      sendMessage({
-        type: "ready",
-        req: message
-      });
-    }
-    else {
-      throw new NeverEntryError();
+    else { // build
+      // [library] javascript
+      if (pkgConf.type === "library" && !FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
+        const result = await new SdCliJsLibLinter(message.pkgPath).buildAsync();
+        sendMessage({
+          type: "complete",
+          result,
+          req: message
+        });
+        logMemory(message);
+      }
+      // [library] typescript
+      else if (pkgConf.type === "library" && FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
+        const result = await new SdCliTsLibBuilder(message.projConf, message.pkgPath).buildAsync();
+        sendMessage({
+          type: "complete",
+          result,
+          req: message
+        });
+        logMemory(message);
+      }
+      // [server]
+      else if (pkgConf.type === "server") {
+        const result = await new SdCliServerBuilder(message.projConf, message.pkgPath).buildAsync();
+        sendMessage({
+          type: "complete",
+          result,
+          req: message,
+        });
+        logMemory(message);
+      }
+      // [client]
+      else if (pkgConf.type === "client") {
+        const result = await new SdCliClientBuilder(message.projConf, message.pkgPath).buildAsync();
+        sendMessage({
+          type: "complete",
+          result,
+          req: message,
+        });
+        logMemory(message);
+      }
+      else {
+        throw new NeverEntryError();
+      }
     }
   }
-  else { // build
-    // [library] javascript
-    if (pkgConf.type === "library" && !FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
-      const result = await new SdCliJsLibLinter(message.pkgPath).buildAsync();
-      sendMessage({
-        type: "complete",
-        result,
-        req: message
-      });
-    }
-    // [library] typescript
-    else if (pkgConf.type === "library" && FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
-      const result = await new SdCliTsLibBuilder(message.projConf, message.pkgPath).buildAsync();
-      sendMessage({
-        type: "complete",
-        result,
-        req: message
-      });
-    }
-    // [server]
-    else if (pkgConf.type === "server") {
-      const result = await new SdCliServerBuilder(message.projConf, message.pkgPath).buildAsync();
-      sendMessage({
-        type: "complete",
-        result,
-        req: message
-      });
-    }
-    // [client]
-    else if (pkgConf.type === "client") {
-      const result = await new SdCliClientBuilder(message.projConf, message.pkgPath).buildAsync();
-      sendMessage({
-        type: "complete",
-        result,
-        req: message
-      });
-    }
-    else {
-      throw new NeverEntryError();
-    }
+  catch (err) {
+    logger.error(`${message.pkgPath}:${message.cmd}`, err);
+    throw err;
   }
 }
 
 function sendMessage(message: ISdCliBuildClusterResMessage): void {
   process.send!(message);
 }
+
+function logMemory(message: ISdCliBuildClusterReqMessage) {
+  /*global.gc!();
+  logger.log(`[${process.pid}:${path.basename(message.pkgPath)}] 메모리 사용량: ${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB`);*/
+}

package/src/build-tools/SdNgBundler.ts

@@ -37,7 +37,7 @@ import {Entrypoint} from "@angular-devkit/build-angular/src/utils/index-file/aug
 import {CrossOrigin} from "@angular-devkit/build-angular";
 import {InlineCriticalCssProcessor} from "@angular-devkit/build-angular/src/utils/index-file/inline-critical-css";
 import {SdNgBundlerContext} from "./SdNgBundlerContext";
-import {INgResultCache, sdNgPlugin} from "../bundle-plugins/sdNgPlugin";
+import {INgPluginResultCache, sdNgPlugin} from "../bundle-plugins/sdNgPlugin";
 import {MemoryLoadResultCache} from "@angular-devkit/build-angular/src/tools/esbuild/load-result-cache";
 import ts from "typescript";
 
@@ -47,7 +47,10 @@ export class SdNgBundler {
   // );
 
   #modifiedFileSet = new Set<string>();
-  #ngResultCache: Partial<INgResultCache> = {};
+  #ngResultCache: INgPluginResultCache = {
+    affectedFileSet: new Set<string>(),
+    watchFileSet: new Set<string>()
+  };
   #styleLoadResultCache = new MemoryLoadResultCache();
 
   private _contexts: SdNgBundlerContext[] | undefined;
@@ -92,7 +95,7 @@ export class SdNgBundler {
   }
 
   public async bundleAsync(): Promise<{
-    program: ts.Program;
+    program?: ts.Program;
     watchFileSet: Set<string>,
     affectedFileSet: Set<string>,
     results: ISdCliPackageBuildResult[]
@@ -213,7 +216,7 @@ export class SdNgBundler {
     logger.debug(`[${path.basename(this._opt.pkgPath)}] 번들링중 영향받은 파일`, Array.from(this.#ngResultCache.affectedFileSet!));
 
     return {
-      program: this.#ngResultCache.program!,
+      program: this.#ngResultCache.program,
       watchFileSet: new Set([
         ...this.#ngResultCache.watchFileSet!,
         ...this.#styleLoadResultCache.watchFiles

package/src/build-tools/SdServerBundler.ts

@@ -1,7 +1,7 @@
 import {ISdCliPackageBuildResult} from "../commons";
 import esbuild from "esbuild";
 import path from "path";
-import {IServerBundlerResultCache, sdServerPlugin} from "../bundle-plugins/sdServerPlugin";
+import {IServerPluginResultCache, sdServerPlugin} from "../bundle-plugins/sdServerPlugin";
 import ts from "typescript";
 import {Logger} from "@simplysm/sd-core-node";
 
@@ -11,7 +11,7 @@ export class SdServerBundler {
   #context?: esbuild.BuildContext;
 
   #modifiedFileSet = new Set<string>();
-  #resultCache: Partial<IServerBundlerResultCache> = {};
+  #resultCache: IServerPluginResultCache = {};
 
   constructor(private readonly _opt: {
     dev: boolean;

package/src/build-tools/SdTsCompiler.ts

@@ -1,15 +1,12 @@
-import path from "path";
-import ts from "typescript";
 import {SdCliBuildResultUtil} from "../utils/SdCliBuildResultUtil";
-import {FsUtil, Logger, PathUtil} from "@simplysm/sd-core-node";
-import {ISdCliPackageBuildResult, ITsConfig} from "../commons";
-import {NgtscProgram, OptimizeFor} from "@angular/compiler-cli";
-import {createHash} from "crypto";
-import {fileURLToPath, pathToFileURL} from "url";
-import * as sass from "sass";
+import {ISdCliPackageBuildResult} from "../commons";
+import {SdTsCompiler2} from "../build-tools2/SdTsCompiler2";
+import ts from "typescript";
+import path from "path";
+import {FsUtil, PathUtil} from "@simplysm/sd-core-node";
 
 export class SdTsCompiler {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
+  /*private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
 
   private readonly _parsedTsConfig: ts.ParsedCommandLine;
   private readonly _writeFileCache = new Map<string, string>();
@@ -21,81 +18,33 @@ export class SdTsCompiler {
   private readonly _isForAngular: boolean;
   private _ngProgram?: NgtscProgram;
   private readonly _styleDepsCache = new Map<string, Set<string>>();
-  private _markedChanges: string[] = [];
+  private _markedChanges: string[] = [];*/
+
+  program?: ts.Program;
+
+  readonly #compiler: SdTsCompiler2;
 
-  public get program(): ts.Program {
+  readonly #pkgPath: string;
+
+  /*public get program(): ts.Program {
     if (!this._program) {
       throw new Error("TS 프로그램 NULL");
     }
     return this._program;
-  }
-
-  public constructor(private readonly _opt: {
-    pkgPath: string,
-    emit: boolean;
-    emitDts: boolean;
-    globalStyle: boolean;
-  }) {
-    //-- tsconfig
-    const tsConfigFilePath = path.resolve(_opt.pkgPath, "tsconfig.json");
-    const tsConfig = FsUtil.readJson(tsConfigFilePath) as ITsConfig;
-    this._parsedTsConfig = ts.parseJsonConfigFileContent(
-      tsConfig,
-      ts.sys,
-      _opt.pkgPath,
-      {
-        ...tsConfig.angularCompilerOptions ?? {},
-        ..._opt.emitDts !== undefined ? {declaration: _opt.emitDts} : {}
-      }
+  }*/
+
+  public constructor(pkgPath: string, dev: boolean) {
+    this.#pkgPath = pkgPath;
+    this.#compiler = new SdTsCompiler2(
+      pkgPath,
+      {declaration: true},
+      dev,
+      path.resolve(pkgPath, "src/styles.scss")
     );
-
-    //-- vars
-    this._isForAngular = Boolean(tsConfig.angularCompilerOptions);
-
-    //-- host
-    this._compilerHost = ts.createIncrementalCompilerHost(this._parsedTsConfig.options);
-    if (tsConfig.angularCompilerOptions) {
-      this._compilerHost["readResource"] = (fileName: string) => {
-        return this._compilerHost.readFile(fileName);
-      };
-
-      this._compilerHost["transformResource"] = async (data: string, context: {
-        type: string,
-        containingFile: string,
-        resourceFile: any
-      }) => {
-        if (context.resourceFile != null || context.type !== "style") {
-          return null;
-        }
-
-        try {
-          const scssResult = await sass.compileStringAsync(data, {
-            url: new URL((context.containingFile as string) + ".scss"),
-            importer: {
-              findFileUrl: (url) => pathToFileURL(url)
-            },
-            logger: sass.Logger.silent
-          });
-
-          const styleContent = scssResult.css.toString();
-
-          const deps = scssResult.loadedUrls.slice(1).map((item) => path.resolve(fileURLToPath(item.href)));
-          for (const dep of deps) {
-            const depCache = this._styleDepsCache.getOrCreate(dep, new Set<string>());
-            depCache.add(path.resolve(context.containingFile));
-          }
-          return {content: styleContent};
-        }
-        catch (err) {
-          this._logger.error("scss 파싱 에러", err);
-          return null;
-        }
-      };
-    }
   }
 
-  public markChanges(changes: string[]): void {
-    this._markedChanges.push(...changes);
+  public markChanges(modifiedFileSet: Set<string>): void {
+    this.#compiler.invalidate(modifiedFileSet);
   }
 
   public async buildAsync(): Promise<{
@@ -103,11 +52,36 @@ export class SdTsCompiler {
     affectedFileSet: Set<string>;
     results: ISdCliPackageBuildResult[];
   }> {
-    const markedChanges = this._markedChanges;
+    const buildResult = await this.#compiler.buildAsync();
+    this.program = buildResult.program;
+
+    for (const affectedFilePath of buildResult.affectedFileSet) {
+      const emittedFiles = buildResult.emittedFilesCacheMap.get(affectedFilePath) ?? [];
+      for (const emittedFile of emittedFiles) {
+        if (emittedFile.outRelPath != null) {
+          const distPath = path.resolve(this.#pkgPath, "dist", emittedFile.outRelPath);
+          if (PathUtil.isChildPath(distPath, path.resolve(this.#pkgPath, "dist"))) {
+            await FsUtil.writeFileAsync(distPath, emittedFile.text);
+          }
+        }
+      }
+
+      const globalStylesheetResult = buildResult.stylesheetResultMap.get(affectedFilePath);
+      if (globalStylesheetResult) {
+        for (const outputFile of globalStylesheetResult.outputFiles) {
+          const distPath = path.resolve(this.#pkgPath, "dist", path.relative(this.#pkgPath, outputFile.path));
+          if (PathUtil.isChildPath(distPath, path.resolve(this.#pkgPath, "dist"))) {
+            await FsUtil.writeFileAsync(distPath, outputFile.text);
+          }
+        }
+      }
+    }
+
+    /*const markedChanges = this._markedChanges;
     this._markedChanges = [];
 
     const distPath = path.resolve(this._opt.pkgPath, "dist");
-    const srcFilePaths = await FsUtil.globAsync(path.resolve(this._opt.pkgPath, "src/**/*.{ts,tsx}"));
+    const srcFilePaths = await FsUtil.globAsync(path.resolve(this._opt.pkgPath, "src/!**!/!*.{ts,tsx}"));
     const srcFilePathSet = new Set<string>(srcFilePaths);
 
     if (this._isForAngular) {
@@ -139,12 +113,12 @@ export class SdTsCompiler {
       );
     }
     else {
-      /*this._program = ts.createProgram(
+      /!*this._program = ts.createProgram(
         srcFilePaths,
         this._parsedTsConfig.options,
         this._compilerHost,
         this._program
-      );*/
+      );*!/
 
       this._builder = ts.createIncrementalProgram({
         rootNames: srcFilePaths,
@@ -295,22 +269,18 @@ export class SdTsCompiler {
 
     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"));
+    const buildResults = diagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item, this._opt.emit ? "build" : "check"));*/
 
     return {
-      watchFileSet: new Set([
-        ...Array.from(this._styleDepsCache.keys()),
-        ...this._builder.getSourceFiles().map(item => path.normalize(item.fileName))
-      ]),
-      affectedFileSet: affectedFileSet,
-      results: buildResults
+      watchFileSet: buildResult.watchFileSet,
+      affectedFileSet: buildResult.affectedFileSet,
+      results: [
+        ...buildResult.typescriptDiagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item, "build")),
+        ...Array.from(buildResult.stylesheetResultMap.values()).mapMany(item => item.errors!)
+          .map(err => SdCliBuildResultUtil.convertFromEsbuildResult(err, "build", "error")),
+        /*...Array.from(buildResult.stylesheetResultMap.values()).mapMany(item => item.warnings!)
+          .map(warn => SdCliBuildResultUtil.convertFromEsbuildResult(warn, "build", "warning"))*/
+      ]
     };
   }
-
-  private _writeFile(filePath: string, data: string): void {
-    if (this._writeFileCache.get(filePath) !== data) {
-      this._compilerHost.writeFile(filePath, data, false);
-    }
-    this._writeFileCache.set(filePath, data);
-  }
 }