@simplysm/sd-cli 6.0.26 → 6.0.30

package/src/entry-points/SdCliProject.ts

@@ -34,7 +34,7 @@ export class SdCliProject {
     this.npmConfig = FsUtil.readJson(this.npmConfigFilePath);
   }
 
-  public async buildAsync(opt: { watch?: boolean; packages?: string[]; options?: string[]; config?: string }): Promise<void> {
+  public async buildAsync(opt: { watch?: boolean; packages?: string[]; options?: string[]; config?: string; skipProcesses?: string[]; localUpdate?: boolean }): Promise<void> {
     this._logger.debug("프로젝트 설정 가져오기...");
     const config = await SdProjectConfigUtil.loadConfigAsync(
       this._rootPath,
@@ -43,13 +43,13 @@ export class SdCliProject {
       opt.config
     );
 
-    if (opt.watch && config.localUpdates) {
+    if (opt.watch && opt.localUpdate && config.localUpdates) {
       this._logger.debug("로컬 라이브러리 업데이트 변경감지 시작...");
       await new SdCliLocalUpdater(this._rootPath).localUpdateAsync(true, opt);
     }
 
     this._logger.debug("프로젝트 패키지 목록 구성...");
-    const allPkgs = await this._getAllPackagesAsync(config, opt.packages);
+    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, opt.skipProcesses ?? [], !opt.localUpdate);
     const pkgs = allPkgs.filter((item) => !(item instanceof SdCliUnknownPackage)) as TSdCliBuildablePackage[];
 
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
@@ -174,7 +174,7 @@ export class SdCliProject {
     );
 
     this._logger.debug("프로젝트 패키지 목록 구성...");
-    const allPkgs = await this._getAllPackagesAsync(config, opt.packages);
+    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, [], false);
     const pkgs = allPkgs.filter((item) => !(item instanceof SdCliUnknownPackage) && item.config.publish) as TSdCliBuildablePackage[];
 
     // 빌드가 필요하면 빌드함
@@ -239,7 +239,7 @@ export class SdCliProject {
     }
   }
 
-  private async _getAllPackagesAsync(config: ISdProjectConfig, packages: string[] | undefined): Promise<TSdCliPackage[]> {
+  private async _getAllPackagesAsync(config: ISdProjectConfig, packages: string[] | undefined, skipProcesses: string[], useCache: boolean): Promise<TSdCliPackage[]> {
     // package.json에서 workspaces를 통해 패키지 경로 목록 가져오기
     const allPkgPaths = await this.npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
     if (!allPkgPaths) {
@@ -268,32 +268,33 @@ export class SdCliProject {
     }
 
     // 각 package를 위한 worker 준비
-    const workerCount = allPackageInfos.sum((item) => {
+    /*const workerCount = allPackageInfos.sum((item) => {
       if (item.config && item.config.type === "library") {
         return item.config.targets?.length ?? 1;
       }
       return 0;
-    });
+    });*/
 
     const processWorkManager = await SdProcessWorkManager.createAsync(
       path.resolve(__dirname, `../workers/lib-build-worker`),
       [],
+      this._logger/*,
       Math.min(workerCount, Math.max(os.cpus().length - 2, 1)),
-      Math.max(os.cpus().length - 2, 1)
+      Math.max(os.cpus().length - 2, 1)*/
     );
 
     // 패키지 목록 구성
     const pkgs: TSdCliPackage[] = [];
     for (const pkgInfo of allPackageInfos) {
       if (pkgInfo.config?.type === "library") {
-        pkgs.push(new SdCliLibraryPackage(pkgInfo.rootPath, pkgInfo.config, processWorkManager));
+        pkgs.push(new SdCliLibraryPackage(pkgInfo.rootPath, pkgInfo.config, skipProcesses as any, processWorkManager));
       }
       else if (pkgInfo.config?.type === "client") {
         const serverPkgInfo = allPackageInfos.single((item) => item.name === (pkgInfo.config as ISdClientPackageConfig).server);
-        pkgs.push(new SdCliClientPackage(pkgInfo.rootPath, pkgInfo.config, serverPkgInfo?.rootPath));
+        pkgs.push(new SdCliClientPackage(pkgInfo.rootPath, pkgInfo.config, useCache, serverPkgInfo?.rootPath));
       }
       else if (pkgInfo.config?.type === "server") {
-        pkgs.push(new SdCliServerPackage(pkgInfo.rootPath, pkgInfo.config));
+        pkgs.push(new SdCliServerPackage(pkgInfo.rootPath, pkgInfo.config, useCache));
       }
       else {
         pkgs.push(new SdCliUnknownPackage(pkgInfo.rootPath));
@@ -322,12 +323,12 @@ export class SdCliProject {
 
     const warnings = totalResults
       .filter((item) => item.severity === "warning")
-      .map((item) => item.message.trim() + "(" + item.pkgName + ")")
+      .map((item) => item.message.trim() + " (" + item.pkgName + ")")
       .distinct();
 
     const errors = totalResults
       .filter((item) => item.severity === "error")
-      .map((item) => item.message.trim() + "(" + item.pkgName + ")")
+      .map((item) => item.message.trim() + " (" + item.pkgName + ")")
       .distinct();
 
     if (warnings.length > 0) {

package/src/packages/SdCliClientPackage.ts

@@ -16,6 +16,7 @@ export class SdCliClientPackage extends SdCliPackageBase {
 
   public constructor(public readonly rootPath: string,
                      public readonly config: ISdClientPackageConfig,
+                     public readonly useCache: boolean,
                      public readonly _serverPath?: string) {
     super(rootPath);
   }
@@ -24,7 +25,7 @@ export class SdCliClientPackage extends SdCliPackageBase {
     await this._genBuildTsconfigAsync();
 
     const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);
-    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config);
+    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.useCache);
 
     await builder
       .on("change", () => {
@@ -40,7 +41,7 @@ export class SdCliClientPackage extends SdCliPackageBase {
     await this._genBuildTsconfigAsync();
 
     const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);
-    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config);
+    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.useCache);
     return await builder
       .on("change", () => {
         this.emit("change", undefined);

package/src/packages/SdCliLibraryPackage.ts

@@ -15,6 +15,7 @@ export class SdCliLibraryPackage extends SdCliPackageBase {
 
   public constructor(public readonly rootPath: string,
                      public readonly config: ISdLibraryPackageConfig,
+                     private readonly _skipProcesses: ("emit" | "check" | "lint" | "genIndex")[],
                      private readonly _processWorkManager: SdProcessWorkManager) {
     super(rootPath);
     this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name, this.npmConfig.name]);
@@ -66,7 +67,7 @@ export class SdCliLibraryPackage extends SdCliPackageBase {
       .on("complete", (results) => {
         this.emit("complete", target, results);
       })
-      .sendAsync(this.rootPath, target, watch, autoIndexConfig);
+      .sendAsync(this.rootPath, target, watch, this._skipProcesses, autoIndexConfig);
   }
 
   private async _genBuildTsconfigAsync(): Promise<void> {

package/src/packages/SdCliServerPackage.ts

@@ -15,7 +15,8 @@ export class SdCliServerPackage extends SdCliPackageBase {
   }
 
   public constructor(public readonly rootPath: string,
-                     public readonly config: ISdServerPackageConfig) {
+                     public readonly config: ISdServerPackageConfig,
+                     public readonly useCache: boolean) {
     super(rootPath);
   }
 
@@ -23,7 +24,7 @@ export class SdCliServerPackage extends SdCliPackageBase {
     await this._genBuildTsconfigAsync();
 
     const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);
-    const builder = new SdCliServerBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config);
+    const builder = new SdCliServerBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.useCache);
 
     await builder
       .on("change", () => {
@@ -50,7 +51,7 @@ export class SdCliServerPackage extends SdCliPackageBase {
     await this._genBuildTsconfigAsync();
 
     const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);
-    const builder = new SdCliServerBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config);
+    const builder = new SdCliServerBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.useCache);
 
     await builder
       .on("change", () => {

package/src/utils/SdCliFileCrypto.ts

@@ -84,4 +84,4 @@ export class SdCliFileCrypto {
       });
     });
   }
-}
+}

package/src/utils/SdProjectConfigUtil.ts

@@ -5,7 +5,7 @@ import { ObjectUtil } from "@simplysm/sd-core-common";
 
 export class SdProjectConfigUtil {
   public static async loadConfigAsync(rootPath: string, isDevMode?: boolean, options?: string[], configFilePath?: string): Promise<ISdProjectConfig> {
-    const config = await this._loadConfigFileContentAsync(configFilePath ?? path.resolve(rootPath, "simplysm.json"));
+    const config = await this._loadConfigFileContentAsync(path.resolve(rootPath, configFilePath ?? "simplysm.json"));
 
     if (config.packages !== undefined) {
       const mode = isDevMode ? "development" : "production";

package/src/utils/SdWebpackUtil.ts

@@ -1,6 +1,6 @@
 import { ISdPackageBuildResult } from "../commons";
 import * as webpack from "webpack";
-import { StringUtil } from "@simplysm/sd-core-common";
+import { NeverEntryError } from "@simplysm/sd-core-common";
 
 export class SdWebpackUtil {
   public static getWebpackResults(stats: Error | webpack.Stats): ISdPackageBuildResult[] {
@@ -14,37 +14,57 @@ export class SdWebpackUtil {
 
     const results: ISdPackageBuildResult[] = [];
 
-    const info = stats.toJson("errors-warnings");
+    for (const warn of stats.compilation.warnings) {
+      if (stats.compilation.options.ignoreWarnings?.some((ignoreWarning) => ignoreWarning(warn, stats.compilation))) continue;
 
-    if (info.warnings) {
-      results.push(
-        ...info.warnings.map((statWarning) => ({
-          filePath: undefined,
-          severity: "warning" as const,
-          message: this._statErrorToMessage(statWarning)
-        }))
-      );
+      results.push({
+        filePath: undefined,
+        severity: "warning",
+        message: this._errorToMessage(warn)
+      });
     }
 
-    if (info.errors) {
-      results.push(
-        ...info.errors.map((statError) => ({
-          filePath: undefined,
-          severity: "error" as const,
-          message: this._statErrorToMessage(statError)
-        }))
-      );
+    for (const err of stats.compilation.errors) {
+      results.push({
+        filePath: undefined,
+        severity: "error",
+        message: this._errorToMessage(err)
+      });
     }
 
     return results;
   }
 
-  private static _statErrorToMessage(statsError: webpack.StatsError): string {
-    if (StringUtil.isNullOrEmpty(statsError.moduleName)) {
-      return statsError.message;
+  private static _errorToMessage(err: Partial<webpack.WebpackError>): string {
+    let result = "";
+
+    if ("error" in err && "originalSassError" in err["error"]) {
+      const sassError = err["error"]["originalSassError"];
+      result += sassError.file.replace(/^\.\//, "");
+      // result += `(${sassError.line as number}${sassError.column !== undefined ? `, ${sassError.column as number}` : ""})`;
+      result += ": ";
+      result += err.name + ": ";
+      result += err.message;
     }
     else {
-      return `${statsError.moduleName.replace(/^\.\//, "")}:${statsError.loc!} - error: ${statsError.message}`;
+      if (err.file !== undefined) {
+        result += err.file.replace(/^\.\//, "");
+        if (err.loc !== undefined) {
+          if ("start" in err.loc) {
+            result += `(${err.loc.start.line}${err.loc.start.column !== undefined ? `, ${err.loc.start.column}` : ""})`;
+          }
+          else {
+            throw new NeverEntryError();
+          }
+        }
+        result += ": ";
+
+        result += err.name + ": ";
+      }
+
+      result += err.message;
     }
+
+    return result;
   }
 }

package/src/workers/client-ng-gen-worker.ts

@@ -0,0 +1,60 @@
+import { EventEmitter } from "events";
+import { Logger, LoggerSeverity, SdProcessChildWorker } from "@simplysm/sd-core-node";
+import { SdCliNgLibraryBuilder } from "../builders/SdCliNgLibraryBuilder";
+import * as path from "path";
+
+EventEmitter.defaultMaxListeners = 0;
+process.setMaxListeners(0);
+
+const logger = Logger.get(["simplysm", "sd-cli", "ng-gen-worker"]);
+
+if (process.env.SD_CLI_LOGGER_SEVERITY === "DEBUG") {
+  Error.stackTraceLimit = 100; //Infinity;
+
+  Logger.setConfig(["simplysm", "sd-cli"], {
+    console: {
+      level: LoggerSeverity.debug
+    }
+  });
+}
+else {
+  Logger.setConfig(["simplysm", "sd-cli"], {
+    dot: true
+  });
+}
+
+
+try {
+  let ngGenerator: SdCliNgLibraryBuilder | undefined;
+  SdProcessChildWorker.defineWorker(async (worker, args) => {
+    const rootPath = args[0] as string;
+    const watch = args[1] as boolean;
+    const changedFilePaths = args[2] as string[] | undefined;
+
+    const tsconfigFilePath = path.resolve(rootPath, `sd-tsconfig.json`);
+
+    if (!ngGenerator || !changedFilePaths) {
+      ngGenerator = new SdCliNgLibraryBuilder(rootPath, tsconfigFilePath, ["emit", "check", "lint", "genIndex"], undefined);
+      const genDirtyFilePaths = await ngGenerator.reloadProgramAsync(watch);
+      const genResult = await ngGenerator.generateAdditionalFilesAsync(genDirtyFilePaths, watch);
+      worker.send("complete", {
+        dirtyFilePaths: [...genDirtyFilePaths, ...genResult.dirtyFilePaths],
+        result: genResult.result
+      });
+    }
+    else {
+      const genDirtyFilePaths = await ngGenerator.reloadChangedProgramAsync(changedFilePaths, watch);
+      if (genDirtyFilePaths.length === 0) {
+        worker.send("complete", { dirtyFilePaths: [], result: [] });
+        return;
+      }
+
+      const genResult = await ngGenerator.generateAdditionalFilesAsync(genDirtyFilePaths.distinct(), watch);
+      worker.send("complete", { dirtyFilePaths: genResult.dirtyFilePaths, result: genResult.result });
+    }
+  });
+}
+catch (err) {
+  logger.error(err);
+  process.exit(1);
+}

package/src/workers/lib-build-worker.ts

@@ -14,14 +14,14 @@ const logger = Logger.get(["simplysm", "sd-cli", "lib-build-worker"]);
 if (process.env.SD_CLI_LOGGER_SEVERITY === "DEBUG") {
   Error.stackTraceLimit = 100; //Infinity;
 
-  Logger.setConfig({
+  Logger.setConfig(["simplysm", "sd-cli"], {
     console: {
       level: LoggerSeverity.debug
     }
   });
 }
 else {
-  Logger.setConfig({
+  Logger.setConfig(["simplysm", "sd-cli"], {
     dot: true
   });
 }
@@ -32,13 +32,14 @@ try {
     const rootPath = args[0] as string;
     const target = args[1] as "node" | "browser" | "angular" | undefined;
     const watch = args[2] as boolean;
+    const skipProcesses = args[3] as ("emit" | "check" | "lint" | "genIndex")[];
 
     if (target === undefined) {
       // 1. output를 내놓지 않는 Typescript 라이브러리(types)인 경우, typecheck와 lint만 수행
       if (FsUtil.exists(path.resolve(rootPath, `tsconfig.json`))) {
         const tsconfigFilePath = path.resolve(rootPath, `tsconfig.json`);
 
-        const builder = new SdCliTypescriptBuilder(rootPath, tsconfigFilePath, ["emit", "genIndex"], undefined);
+        const builder = new SdCliTypescriptBuilder(rootPath, tsconfigFilePath, skipProcesses.concat(["emit", "genIndex"]).distinct(), undefined);
         await builder
           .on("change", () => {
             worker.send("change");
@@ -62,11 +63,11 @@ try {
       }
     }
     else {
-      const autoIndexConfig = args[3] as ISdAutoIndexConfig | undefined;
+      const autoIndexConfig = args[4] as ISdAutoIndexConfig | undefined;
       const tsconfigFilePath = path.resolve(rootPath, `sd-tsconfig.${target}.json`);
 
       if (target !== "angular") {
-        const builder = new SdCliTypescriptBuilder(rootPath, tsconfigFilePath, [], autoIndexConfig);
+        const builder = new SdCliTypescriptBuilder(rootPath, tsconfigFilePath, skipProcesses, autoIndexConfig);
         await builder
           .on("change", () => {
             worker.send("change");
@@ -77,7 +78,7 @@ try {
           .buildAsync(watch);
       }
       else {
-        const builder = new SdCliNgLibraryBuilder(rootPath, tsconfigFilePath, [], autoIndexConfig);
+        const builder = new SdCliNgLibraryBuilder(rootPath, tsconfigFilePath, skipProcesses, autoIndexConfig);
         await builder
           .on("change", () => {
             worker.send("change");

package/tsconfig.json

@@ -23,6 +23,7 @@
   },
   "files": [
     "src/bin/sd-cli.ts",
-    "src/workers/lib-build-worker.ts"
+    "src/workers/lib-build-worker.ts",
+    "src/workers/client-ng-gen-worker.ts"
   ]
 }