@simplysm/sd-cli 6.0.44 → 6.1.1

package/src/builders/SdCliTypescriptBuilder.ts

@@ -5,10 +5,10 @@ import { NeverEntryError } from "@simplysm/sd-core-common";
 import { EventEmitter } from "events";
 import * as path from "path";
 import { SdTsDiagnosticUtil } from "../utils/SdTsDiagnosticUtil";
-import { ESLint } from "eslint";
+import { ESLint, Linter } from "eslint";
 import { createHash } from "crypto";
 import { SdCliIndexFileGenerator } from "../build-tools/SdCliIndexFileGenerator";
-import { ParserOptions } from "@typescript-eslint/types";
+import ParserOptions = Linter.ParserOptions;
 
 export class SdCliTypescriptBuilder extends EventEmitter {
   protected readonly _logger: Logger;
@@ -64,16 +64,17 @@ export class SdCliTypescriptBuilder extends EventEmitter {
 
     // 프로그램 리로드
     const buildResult: ISdPackageBuildResult[] = [];
-    const buildDirtyFilePaths = await this.reloadProgramAsync(watch);
+    const reloadProgramResult = await this.reloadProgramAsync(watch);
+    buildResult.push(...reloadProgramResult.result);
 
     // 자동생성할 소스파일들 생성 및 리로드 (index.ts등)
-    const buildGenAdditionalResult = await this.generateAdditionalFilesAsync(buildDirtyFilePaths, watch);
+    const buildGenAdditionalResult = await this.generateAdditionalFilesAsync(reloadProgramResult.dirtyFilePaths, watch);
     buildResult.push(...buildGenAdditionalResult.result);
-    buildDirtyFilePaths.push(...buildGenAdditionalResult.dirtyFilePaths);
+    reloadProgramResult.dirtyFilePaths.push(...buildGenAdditionalResult.dirtyFilePaths);
 
     // 빌드시, 빌드 수행하고 종료
     if (!watch) {
-      const buildDoAllResults = await this.doAllAsync(buildDirtyFilePaths.distinct());
+      const buildDoAllResults = await this.doAllAsync(reloadProgramResult.dirtyFilePaths.distinct());
       buildResult.push(...buildDoAllResults);
       this.emit("complete", buildResult.distinct());
       return;
@@ -98,14 +99,15 @@ export class SdCliTypescriptBuilder extends EventEmitter {
           this.emit("change");
 
           // 변경파일에 대한 프로그램 리로드
-          const watchDirtyFilePaths = await this.reloadChangedProgramAsync(changedFilePaths, watch);
+          const reloadChangedProgramResult = await this.reloadChangedProgramAsync(changedFilePaths, watch);
+          const watchDirtyFilePaths = reloadChangedProgramResult.dirtyFilePaths;
           if (watchDirtyFilePaths.length === 0) {
             this.emit("complete", Array.from(resultMap.values()).mapMany());
             return;
           }
 
           // 변경파일에 대해 자동생성할 소스파일들 생성 및 리로드 (index.ts등)
-          const watchGenAdditionalResult = await this.generateAdditionalFilesAsync(watchDirtyFilePaths, watch);
+          const watchGenAdditionalResult = await this.generateAdditionalFilesAsync([...changedFilePaths, ...watchDirtyFilePaths], watch);
           watchDirtyFilePaths.push(...watchGenAdditionalResult.dirtyFilePaths);
           watchDirtyFilePaths.distinctThis();
 
@@ -119,7 +121,7 @@ export class SdCliTypescriptBuilder extends EventEmitter {
           }
 
           // 결과 MAP 구성
-          const result = [...watchGenAdditionalResult.result, ...watchDoAllResults].distinct();
+          const result = [...reloadChangedProgramResult.result, ...watchGenAdditionalResult.result, ...watchDoAllResults].distinct();
           for (const resultItem of result) {
             const posixFilePath = resultItem.filePath !== undefined ? PathUtil.posix(resultItem.filePath) : "undefined";
             const resultMapValue = resultMap.getOrCreate(posixFilePath, []);
@@ -146,7 +148,7 @@ export class SdCliTypescriptBuilder extends EventEmitter {
     // 변경감지용, 최초 빌드
 
     // 빌드 및 린트
-    const buildDoAllResults = await this.doAllAsync(buildDirtyFilePaths.distinct());
+    const buildDoAllResults = await this.doAllAsync(reloadProgramResult.dirtyFilePaths.distinct());
     buildResult.push(...buildDoAllResults);
 
     // 결과 MAP 구성
@@ -173,7 +175,9 @@ export class SdCliTypescriptBuilder extends EventEmitter {
       const generateResult = await this._indexFileGenerator.generateAsync();
       result.result.push(...generateResult.result);
       if (generateResult.changed) {
-        result.dirtyFilePaths = await this.reloadChangedProgramAsync([this._indexFileGenerator.indexFilePath], watch);
+        const reloadChangedProgramResult = await this.reloadChangedProgramAsync([this._indexFileGenerator.indexFilePath], watch);
+        result.dirtyFilePaths = reloadChangedProgramResult.dirtyFilePaths;
+        result.result.push(...reloadChangedProgramResult.result);
       }
     }
 
@@ -227,6 +231,7 @@ export class SdCliTypescriptBuilder extends EventEmitter {
           && PathUtil.isChildPath(item, this.rootPath)
           && FsUtil.exists(item)
           && !FsUtil.isDirectory(item)
+          && Boolean(this._program?.getSourceFiles().some((item1) => PathUtil.posix(item1.fileName) === PathUtil.posix(item)))
           && !await linter.isPathIgnored(item)
         ));
 
@@ -237,6 +242,7 @@ export class SdCliTypescriptBuilder extends EventEmitter {
           const severity: "warning" | "error" = msg.severity === 1 ? "warning" : "error";
 
           return {
+            type: "lint",
             filePath: report.filePath,
             severity,
             message: `${report.filePath}(${msg.line}, ${msg.column}): ${msg.ruleId ?? ""}: ${severity} ${msg.message}`
@@ -342,7 +348,7 @@ export class SdCliTypescriptBuilder extends EventEmitter {
     return result;
   }
 
-  public async reloadChangedProgramAsync(changedFilePaths: string[], watch: boolean): Promise<string[]> {
+  public async reloadChangedProgramAsync(changedFilePaths: string[], watch: boolean): Promise<{ dirtyFilePaths: string[]; result: ISdPackageBuildResult[] }> {
     this._logger.debug("변경 프로그램 리로드", changedFilePaths);
 
     // 캐시 삭제
@@ -351,37 +357,59 @@ export class SdCliTypescriptBuilder extends EventEmitter {
     this._deleteFileCaches(changedFilePaths);
 
     // 프로그램 리로드
-    const dirtyFilePaths = await this.reloadProgramAsync(watch);
+    const reloadProgramResult = await this.reloadProgramAsync(watch);
 
     // 변경사항 있을 경우, 변경감지중이면, 변경감지 경로 리로드
-    if (dirtyFilePaths.length > 0 && watch) {
+    if (reloadProgramResult.dirtyFilePaths.length > 0 && watch) {
       this._reloadWatchPaths();
     }
 
     /*dirtyFilePaths.push(...changedFilePaths.filter((key) => this._fileCache.has(key)));
     dirtyFilePaths.distinctThis();*/
 
-    this._logger.debug("변경 프로그램 리로드 결과", dirtyFilePaths);
-    return dirtyFilePaths;
+    this._logger.debug("변경 프로그램 리로드 결과", reloadProgramResult.dirtyFilePaths);
+    return reloadProgramResult;
   }
 
-  public async reloadProgramAsync(watch: boolean): Promise<string[]> {
-    this._logger.debug("프로그램 리로드");
-
-    const parsedTsconfig = ts.parseJsonConfigFileContent(this._tsconfig, ts.sys, this.rootPath);
-
-    this._moduleResolutionCache = ts.createModuleResolutionCache(this.rootPath, (s) => s, parsedTsconfig.options);
-    this._cacheCompilerHost = await this._createCacheCompilerHostAsync(parsedTsconfig, this._moduleResolutionCache);
+  public getParsedTsconfig(): ts.ParsedCommandLine {
+    return ts.parseJsonConfigFileContent(this._tsconfig, ts.sys, this.rootPath);
+  }
 
+  public configProgram(parsedTsconfig: ts.ParsedCommandLine): void {
     this._program = ts.createProgram(
       parsedTsconfig.fileNames,
       parsedTsconfig.options,
       this._cacheCompilerHost,
       this._program
     );
+  }
+
+  public getSemanticDiagnosticsOfNextAffectedFiles(): string[] | undefined {
+    const builder = this._builder as ts.SemanticDiagnosticsBuilderProgram;
+    const result = builder.getSemanticDiagnosticsOfNextAffectedFile();
+
+    if (result && "fileName" in result.affected) {
+      return [result.affected.fileName];
+    }
+    if (!result) {
+      return undefined;
+    }
+
+    return [];
+  }
+
+  public async reloadProgramAsync(watch: boolean): Promise<{ dirtyFilePaths: string[]; result: ISdPackageBuildResult[] }> {
+    this._logger.debug("프로그램 리로드");
+
+    const parsedTsconfig = this.getParsedTsconfig();
+
+    this._moduleResolutionCache = ts.createModuleResolutionCache(this.rootPath, (s) => s, parsedTsconfig.options);
+    this._cacheCompilerHost = await this._createCacheCompilerHostAsync(parsedTsconfig, this._moduleResolutionCache);
+
+    this.configProgram(parsedTsconfig);
 
-    const baseGetSourceFiles = this._program.getSourceFiles;
-    this._program.getSourceFiles = function (...parameters) {
+    const baseGetSourceFiles = this._program!.getSourceFiles;
+    this._program!.getSourceFiles = function (...parameters) {
       const files: readonly (ts.SourceFile & { version?: string })[] = baseGetSourceFiles(...parameters);
 
       for (const file of files) {
@@ -396,44 +424,67 @@ export class SdCliTypescriptBuilder extends EventEmitter {
     if (watch) {
       if (this.skipProcesses.includes("emit")) {
         this._builder = ts.createSemanticDiagnosticsBuilderProgram(
-          this._program,
+          this._program!,
           this._cacheCompilerHost,
           this._builder as ts.SemanticDiagnosticsBuilderProgram
         );
       }
       else {
         this._builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
-          this._program,
+          this._program!,
           this._cacheCompilerHost,
           this._builder as ts.EmitAndSemanticDiagnosticsBuilderProgram
         );
       }
-      const builder = this._builder as ts.SemanticDiagnosticsBuilderProgram;
 
-      const affectedFilePaths: string[] = [];
+      const buildResults: ISdPackageBuildResult[] = [];
+      let seq = 0;
+      const affectedFilePathSet = new Set<string>();
       while (true) {
-        const result = builder.getSemanticDiagnosticsOfNextAffectedFile();
+        const prevUsage = process.cpuUsage();
+        if (process.env.SD_CLI_LOGGER_SEVERITY === "DEBUG") {
+          this._logger.debug(`프로그램 리로드 > 변경파일 목록구성: [SEQ: ${++seq}]`);
+        }
+
+        const affectedFilePaths = this.getSemanticDiagnosticsOfNextAffectedFiles();
 
-        if (!result) break;
+        if (affectedFilePaths) {
+          if (affectedFilePaths.length > 0) {
+            const usage = process.cpuUsage(prevUsage);
 
-        if ("fileName" in result.affected) {
-          affectedFilePaths.push(result.affected.fileName);
+            if (usage.user + usage.system > 1000 * 1000) { // 1000ms
+              buildResults.push({
+                filePath: path.resolve(affectedFilePaths.last()!),
+                severity: "warning",
+                message: `${path.resolve(affectedFilePaths.last()!)}(0, 0): warning 소스코드 타입분석에 너무 많은 시간이 소요됩니다. (${Math.floor((usage.user + usage.system) / 1000).toLocaleString()}ms/cpu)`
+              });
+            }
+
+            affectedFilePathSet.adds(...affectedFilePaths.distinct());
+          }
+
+          if (process.env.SD_CLI_LOGGER_SEVERITY === "DEBUG") {
+            this._logger.debug(`프로그램 리로드 > 변경파일 목록구성: [SEQ: ${seq}, SIZE:${affectedFilePathSet.size}]\n` + affectedFilePaths.map((item) => "- " + item).join("\n"));
+          }
+        }
+        else {
+          break;
         }
       }
 
-      const result = affectedFilePaths.distinct();
+      const dirtyFilePaths = Array.from(affectedFilePathSet.values());
 
-      this._logger.debug("프로그램 리로드 결과", result);
+      this._logger.debug("프로그램 리로드 결과", dirtyFilePaths);
 
-      return result;
+      return { dirtyFilePaths, result: buildResults };
     }
     else {
-      this._builder = ts.createAbstractBuilder(this._program, this._cacheCompilerHost);
-      const result = this._builder.getSourceFiles().map((item) => item.fileName).distinct();
+      this._builder = ts.createAbstractBuilder(this._program!, this._cacheCompilerHost);
+      const dirtyFilePaths = this._builder.getSourceFiles().map((item) => item.fileName).distinct();
 
-      this._logger.debug("프로그램 리로드 결과", result);
+      this._logger.debug("프로그램 리로드 결과", dirtyFilePaths);
 
-      return result;
+      return { dirtyFilePaths, result: [] };
     }
   }
 

package/src/commons.ts

@@ -48,9 +48,13 @@ export interface INpmConfig {
   name: string;
   version: string;
   workspaces?: string[];
+  es2020?: string;
+  browser?: string;
+  module?: string;
   main?: string;
 
   dependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
   devDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
 }
@@ -63,8 +67,10 @@ export interface ITsconfig {
     outDir?: string;
     declarationDir?: string;
     declaration?: boolean;
+    declarationMap?: boolean;
     baseUrl?: string;
     paths?: Record<string, string[]>;
+    generateTrace?: string;
   };
   angularCompilerOptions?: {
     enableI18nLegacyMessageIdFormat?: boolean;
@@ -73,6 +79,7 @@ export interface ITsconfig {
     strictTemplates?: boolean;
     strictInputTypes?: boolean;
     strictOutputEventTypes?: boolean;
+    enableIvy?: boolean;
     compilationMode?: "partial" | "full";
     disableTypeScriptVersionCheck?: boolean;
   };

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; skipProcesses?: string[]; localUpdate?: boolean }): Promise<{ hasError: boolean }> {
+  public async buildAsync(opt: { watch?: boolean; packages?: string[]; options?: string[]; config?: string; skipProcesses?: string[] }): Promise<{ hasError: boolean }> {
     this._logger.debug("프로젝트 설정 가져오기...");
     const config = await SdProjectConfigUtil.loadConfigAsync(
       this._rootPath,
@@ -43,13 +43,13 @@ export class SdCliProject {
       opt.config
     );
 
-    if (opt.watch && opt.localUpdate && config.localUpdates) {
+    if (opt.watch && config.localUpdates) {
       this._logger.debug("로컬 라이브러리 업데이트 변경감지 시작...");
       await new SdCliLocalUpdater(this._rootPath).localUpdateAsync(true, opt);
     }
 
     this._logger.debug("프로젝트 패키지 목록 구성...");
-    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, opt.skipProcesses ?? [], !opt.localUpdate);
+    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, opt.skipProcesses ?? []);
     const pkgs = allPkgs.filter((item) => !(item instanceof SdCliUnknownPackage)) as TSdCliBuildablePackage[];
 
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
@@ -178,7 +178,7 @@ export class SdCliProject {
     );
 
     this._logger.debug("프로젝트 패키지 목록 구성...");
-    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, [], false);
+    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, []);
     const pkgs = allPkgs.filter((item) => !(item instanceof SdCliUnknownPackage) && item.config.publish) as TSdCliBuildablePackage[];
 
     // 빌드가 필요하면 빌드함
@@ -186,8 +186,7 @@ export class SdCliProject {
       this._logger.debug("빌드 수행...");
       const buildResult = await this.buildAsync({
         watch: false,
-        packages: pkgs.map((item) => item.npmConfig.name)
-          .filter((item) => !opt.packages || opt.packages.includes(item)),
+        packages: opt.packages,
         options: opt.options,
         config: opt.config
       });
@@ -246,7 +245,7 @@ export class SdCliProject {
     }
   }
 
-  private async _getAllPackagesAsync(config: ISdProjectConfig, packages: string[] | undefined, skipProcesses: string[], useCache: boolean): Promise<TSdCliPackage[]> {
+  private async _getAllPackagesAsync(config: ISdProjectConfig, packages: string[] | undefined, skipProcesses: string[]): Promise<TSdCliPackage[]> {
     // package.json에서 workspaces를 통해 패키지 경로 목록 가져오기
     const allPkgPaths = await this.npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
     if (!allPkgPaths) {
@@ -298,10 +297,10 @@ export class SdCliProject {
       }
       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, useCache, serverPkgInfo?.rootPath));
+        pkgs.push(new SdCliClientPackage(pkgInfo.rootPath, pkgInfo.config, skipProcesses as any, serverPkgInfo?.rootPath));
       }
       else if (pkgInfo.config?.type === "server") {
-        pkgs.push(new SdCliServerPackage(pkgInfo.rootPath, pkgInfo.config, useCache));
+        pkgs.push(new SdCliServerPackage(pkgInfo.rootPath, pkgInfo.config, skipProcesses as any));
       }
       else {
         pkgs.push(new SdCliUnknownPackage(pkgInfo.rootPath));
@@ -315,6 +314,7 @@ export class SdCliProject {
     // 패키지의 의존성 패키지 중에 빌드해야할 패키지 목록에 이미 있는 의존성 패키지만 추리기
     const depNames = [
       ...Object.keys(pkg.npmConfig.dependencies ?? {}),
+      ...Object.keys(pkg.npmConfig.optionalDependencies ?? {}),
       ...Object.keys(pkg.npmConfig.devDependencies ?? {}),
       ...Object.keys(pkg.npmConfig.peerDependencies ?? {})
     ].distinct().filter((dep) => pkgNames.includes(dep));
@@ -367,6 +367,7 @@ export class SdCliProject {
       }
     };
     updateDepVersion(this.npmConfig.dependencies);
+    updateDepVersion(this.npmConfig.optionalDependencies);
     updateDepVersion(this.npmConfig.devDependencies);
     updateDepVersion(this.npmConfig.peerDependencies);
 

package/src/packages/SdCliClientPackage.ts

@@ -16,7 +16,7 @@ export class SdCliClientPackage extends SdCliPackageBase {
 
   public constructor(public readonly rootPath: string,
                      public readonly config: ISdClientPackageConfig,
-                     public readonly useCache: boolean,
+                     public readonly skipProcesses: ("lint" | "genNgModule")[],
                      public readonly _serverPath?: string) {
     super(rootPath);
   }
@@ -25,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, this.useCache);
+    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.skipProcesses);
 
     await builder
       .on("change", () => {
@@ -41,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, this.useCache);
+    const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.skipProcesses);
     return await builder
       .on("change", () => {
         this.emit("change", undefined);
@@ -72,14 +72,17 @@ export class SdCliClientPackage extends SdCliPackageBase {
     buildTsconfig.compilerOptions = buildTsconfig.compilerOptions ?? {};
     delete buildTsconfig.compilerOptions.baseUrl;
     delete buildTsconfig.compilerOptions.paths;
-    buildTsconfig.compilerOptions.module = "es2020";
-    buildTsconfig.compilerOptions.target = "es2015";
-    buildTsconfig.compilerOptions.lib = ["es2015", "dom"];
-    buildTsconfig.compilerOptions.outDir = `dist`;
-    buildTsconfig.compilerOptions.declaration = false;
     delete buildTsconfig.compilerOptions.declarationDir;
+    buildTsconfig.compilerOptions = {
+      ...buildTsconfig.compilerOptions,
+      module: "es2020",
+      target: "es2015",
+      lib: ["es2015", "dom"],
+      outDir: "dist",
+      declaration: false,
+      baseUrl: this.rootPath
+    };
 
-    buildTsconfig.compilerOptions.baseUrl = this.rootPath;
     buildTsconfig.angularCompilerOptions = {
       ...buildTsconfig.angularCompilerOptions ?? {},
       enableI18nLegacyMessageIdFormat: false,

package/src/packages/SdCliLibraryPackage.ts

@@ -91,6 +91,7 @@ export class SdCliLibraryPackage extends SdCliPackageBase {
       if (i === 0) {
         buildTsconfig.compilerOptions.declaration = true;
         buildTsconfig.compilerOptions.declarationDir = "dist-types";
+        buildTsconfig.compilerOptions.declarationMap = true;
       }
       else {
         buildTsconfig.compilerOptions.declaration = false;

package/src/packages/SdCliPackageBase.ts

@@ -25,6 +25,7 @@ export abstract class SdCliPackageBase extends EventEmitter {
       }
     };
     updateDepVersion(this.npmConfig.dependencies);
+    updateDepVersion(this.npmConfig.optionalDependencies);
     updateDepVersion(this.npmConfig.devDependencies);
     updateDepVersion(this.npmConfig.peerDependencies);
 

package/src/packages/SdCliServerPackage.ts

@@ -16,7 +16,7 @@ export class SdCliServerPackage extends SdCliPackageBase {
 
   public constructor(public readonly rootPath: string,
                      public readonly config: ISdServerPackageConfig,
-                     public readonly useCache: boolean) {
+                     public readonly skipProcesses: "lint"[]) {
     super(rootPath);
   }
 
@@ -24,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, this.useCache);
+    const builder = new SdCliServerBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.skipProcesses);
 
     await builder
       .on("change", () => {
@@ -51,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, this.useCache);
+    const builder = new SdCliServerBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, this.skipProcesses);
 
     await builder
       .on("change", () => {

package/src/utils/SdWebpackUtil.ts

@@ -47,8 +47,9 @@ export class SdWebpackUtil {
       result += err.message;
     }
     else {
-      if (err.file !== undefined) {
-        result += err.file.replace(/^\.\//, "");
+      const filePath = err.file ?? err.module?.nameForCondition();
+      if (filePath != null) {
+        result += filePath.replace(/^\.\//, "");
         if (err.loc !== undefined) {
           if ("start" in err.loc) {
             result += `(${err.loc.start.line}${err.loc.start.column !== undefined ? `, ${err.loc.start.column}` : ""})`;

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

@@ -35,22 +35,25 @@ try {
 
     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);
+      const reloadProgramResult = await ngGenerator.reloadProgramAsync(watch);
+      const genResult = await ngGenerator.generateAdditionalFilesAsync(reloadProgramResult.dirtyFilePaths, watch);
       worker.send("complete", {
-        dirtyFilePaths: [...genDirtyFilePaths, ...genResult.dirtyFilePaths],
-        result: genResult.result
+        dirtyFilePaths: [...reloadProgramResult.dirtyFilePaths, ...genResult.dirtyFilePaths].distinct(),
+        result: [...reloadProgramResult.result, ...genResult.result].distinct()
       });
     }
     else {
-      const genDirtyFilePaths = await ngGenerator.reloadChangedProgramAsync(changedFilePaths, watch);
-      if (genDirtyFilePaths.length === 0) {
+      const reloadProgramResult = await ngGenerator.reloadChangedProgramAsync(changedFilePaths, watch);
+      if (reloadProgramResult.dirtyFilePaths.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 });
+      const genResult = await ngGenerator.generateAdditionalFilesAsync(reloadProgramResult.dirtyFilePaths.distinct(), watch);
+      worker.send("complete", {
+        dirtyFilePaths: [...reloadProgramResult.dirtyFilePaths, ...genResult.dirtyFilePaths].distinct(),
+        result: [...reloadProgramResult.result, ...genResult.result].distinct()
+      });
     }
   });
 }