@simplysm/sd-cli 6.0.28 → 6.0.38

package/src/builders/SdCliNgClientBuilder.ts

@@ -3,18 +3,16 @@ import { INpmConfig, ISdClientPackageConfig, ISdPackageBuildResult, ITsconfig }
 import * as webpack from "webpack";
 import * as path from "path";
 import * as ts from "typescript";
-import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
+import { FsUtil, Logger, PathUtil, SdProcessWorker } from "@simplysm/sd-core-node";
 import { JavaScriptOptimizerPlugin } from "@angular-devkit/build-angular/src/webpack/plugins/javascript-optimizer-plugin";
 import * as CssMinimizerPlugin from "css-minimizer-webpack-plugin";
 import * as esbuild from "esbuild";
 import {
-  AnyComponentStyleBudgetChecker,
   CommonJsUsageWarnPlugin,
   DedupeModuleResolvePlugin,
   SuppressExtractedTextChunksWebpackPlugin
 } from "@angular-devkit/build-angular/src/webpack/plugins";
 import { LicenseWebpackPlugin } from "license-webpack-plugin";
-import { Type } from "@angular-devkit/build-angular";
 import { SassWorkerImplementation } from "@angular-devkit/build-angular/src/sass/sass-service";
 import * as MiniCssExtractPlugin from "mini-css-extract-plugin";
 import { AngularWebpackPlugin } from "@ngtools/webpack";
@@ -28,7 +26,6 @@ import { StringUtil, Wait } from "@simplysm/sd-core-common";
 import { augmentAppWithServiceWorker } from "@angular-devkit/build-angular/src/utils/service-worker";
 import * as browserslist from "browserslist";
 import * as WebpackHotMiddleware from "webpack-hot-middleware";
-import { SdCliNgLibraryBuilder } from "./SdCliNgLibraryBuilder";
 import * as os from "os";
 import { LintResult } from "eslint-webpack-plugin/declarations/options";
 
@@ -39,23 +36,23 @@ export class SdCliNgClientBuilder extends EventEmitter {
   public parsedTsconfig: ts.ParsedCommandLine;
   public readonly npmConfig: INpmConfig;
 
+  private _ngGenWorker?: SdProcessWorker;
+
+  protected readonly _logger: Logger;
+
   public constructor(public rootPath: string,
                      public tsconfigFilePath: string,
                      public projectRootPath: string,
-                     public config: ISdClientPackageConfig) {
+                     public config: ISdClientPackageConfig,
+                     public useCache: boolean) {
     super();
 
     const tsconfig: ITsconfig = FsUtil.readJson(this.tsconfigFilePath);
-    const parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this.rootPath);
-    this.parsedTsconfig = {
-      ...parsedTsconfig,
-      options: {
-        ...parsedTsconfig.options,
-        ...tsconfig.angularCompilerOptions
-      }
-    };
+    this.parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this.rootPath, tsconfig.angularCompilerOptions);
 
     this.npmConfig = FsUtil.readJson(path.resolve(this.rootPath, "package.json"));
+
+    this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name, this.npmConfig.name]);
   }
 
   public on(event: "change", listener: () => void): this;
@@ -72,12 +69,16 @@ export class SdCliNgClientBuilder extends EventEmitter {
     const buildResult: ISdPackageBuildResult[] = [];
 
     // GENERATOR
-    const ngGenerator = new SdCliNgLibraryBuilder(this.rootPath, this.tsconfigFilePath, ["emit", "check", "lint"], undefined);
-    const genFilePaths = await ngGenerator.reloadProgramAsync(false);
-    const genResult = await ngGenerator.generateAdditionalFilesAsync(genFilePaths, false);
+    this._logger.debug("NgGen 수행");
+    const genResult = await this._runNgGenWorkerAsync(false);
+    // const ngGenerator = new SdCliNgLibraryBuilder(this.rootPath, this.tsconfigFilePath, ["emit", "check", "lint"], undefined);
+    // const genFilePaths = await ngGenerator.reloadProgramAsync(false);
+    // const genResult = await ngGenerator.generateAdditionalFilesAsync(genFilePaths, false);
     buildResult.push(...genResult.result);
+    this._logger.debug("NgGen 수행 결과", genResult);
 
     // WEBPACK 빌드
+    this._logger.debug("Webpack 빌드 수행");
     const webpackConfig = this._getWebpackConfig(false);
     const compiler = webpack(webpackConfig);
     const webpackBuildResults = await new Promise<ISdPackageBuildResult[]>((resolve, reject) => {
@@ -91,6 +92,7 @@ export class SdCliNgClientBuilder extends EventEmitter {
         resolve(results);
       });
     });
+    this._logger.debug("Webpack 빌드 결과", webpackBuildResults);
     buildResult.push(...webpackBuildResults);
 
     // .config.json 파일 쓰기
@@ -100,14 +102,16 @@ export class SdCliNgClientBuilder extends EventEmitter {
 
     // service-worker 처리
 
-    const packageKey = this.npmConfig.name.split("/").last()!;
-    await augmentAppWithServiceWorker(
-      PathUtil.posix(this.projectRootPath) as any,
-      PathUtil.posix(path.relative(this.projectRootPath, this.rootPath)) as any,
-      PathUtil.posix(path.relative(this.projectRootPath, this.parsedTsconfig.options.outDir!)) as any,
-      `/${packageKey}/`,
-      PathUtil.posix(path.relative(this.projectRootPath, path.resolve(this.rootPath, "ngsw-config.json")))
-    );
+    if (FsUtil.exists(path.resolve(this.rootPath, "ngsw-config.json"))) {
+      const packageKey = this.npmConfig.name.split("/").last()!;
+      await augmentAppWithServiceWorker(
+        PathUtil.posix(this.projectRootPath) as any,
+        PathUtil.posix(path.relative(this.projectRootPath, this.rootPath)) as any,
+        PathUtil.posix(path.relative(this.projectRootPath, this.parsedTsconfig.options.outDir!)) as any,
+        `/${packageKey}/`,
+        PathUtil.posix(path.relative(this.projectRootPath, path.resolve(this.rootPath, "ngsw-config.json")))
+      );
+    }
 
     this.emit("complete", buildResult.distinct());
   }
@@ -115,66 +119,73 @@ export class SdCliNgClientBuilder extends EventEmitter {
   public async watchAsync(serverPath?: string): Promise<NextHandleFunction[]> {
     await FsUtil.removeAsync(this.parsedTsconfig.options.outDir!);
 
-    let buildResult: ISdPackageBuildResult[] = [];
+    let ngGenResults: ISdPackageBuildResult[] = [];
 
-    const ngGenerator = new SdCliNgLibraryBuilder(this.rootPath, this.tsconfigFilePath, ["emit", "check", "lint"], undefined);
+    // const ngGenerator = new SdCliNgLibraryBuilder(this.rootPath, this.tsconfigFilePath, ["emit", "check", "lint", "genIndex"], undefined);
 
     // WEBPACK 빌드
+    let invalidFiles = new Set<string>();
     const webpackConfig = this._getWebpackConfig(true);
     const compiler = webpack(webpackConfig);
     return await new Promise<NextHandleFunction[]>((resolve, reject) => {
+      compiler.hooks.invalid.tap(this.constructor.name, (fileName) => {
+        if (fileName != null) {
+          invalidFiles.add(fileName);
+        }
+      });
+
       compiler.hooks.watchRun.tapAsync(this.constructor.name, async (compiler1, callback) => {
         this.emit("change");
 
-        buildResult = [];
+        ngGenResults = [];
 
         // -- FIRST
 
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition,@typescript-eslint/strict-boolean-expressions
-        if (!compiler.modifiedFiles || !compiler.removedFiles) {
-          const genDirtyFilePaths = await ngGenerator.reloadProgramAsync(true);
-          const genResult = await ngGenerator.generateAdditionalFilesAsync(genDirtyFilePaths, true);
-          buildResult.push(...genResult.result);
-
+        if (invalidFiles.size === 0) {
+          this._logger.debug("첫 NgGen 수행");
+          const genResult = await this._runNgGenWorkerAsync(true);
+          // const genDirtyFilePaths = await ngGenerator.reloadProgramAsync(true);
+          // const genResult = await ngGenerator.generateAdditionalFilesAsync(genDirtyFilePaths, true);
+          ngGenResults.push(...genResult.result);
+          this._logger.debug("첫 NgGen 수행 결과", genResult);
+
+          this._logger.debug("Webpack 빌드 수행");
           callback();
         }
 
         // -- NOT FIRST
-
         else {
-          const changedFiles = [...compiler.modifiedFiles, ...compiler.removedFiles];
-
           // 변경파일 중, 유효한 파일 추출
-          const watchPaths = ngGenerator.getWatchPaths();
+          const changedFiles = [...invalidFiles];
+          invalidFiles = new Set<string>();
+
           const changedFilePaths = changedFiles
             .map((item) => PathUtil.posix(item))
             .filter((item) => path.basename(item).includes("."))
-            .filter((item) => watchPaths.includes(path.dirname(item)))
             .distinct();
           if (changedFilePaths.length === 0) {
+            this._logger.debug("Webpack 빌드 수행");
             callback();
             return;
           }
 
-          // 변경파일에 대한 프로그램 리로드
-          const genDirtyFilePaths = await ngGenerator.reloadChangedProgramAsync(changedFilePaths, true);
-          if (genDirtyFilePaths.length === 0) {
-            callback();
-            return;
-          }
+          this._logger.debug("변경파일에 대한, NgGen 수행", changedFilePaths);
 
-          // 변경파일에 대해 자동생성할 소스파일들 생성 및 리로드 (index.ts등)
-          const genResult = await ngGenerator.generateAdditionalFilesAsync(genDirtyFilePaths, true);
-          buildResult.push(...genResult.result);
+          const genResult = await this._runNgGenWorkerAsync(true, changedFilePaths);
+          ngGenResults.push(...genResult.result);
           if (genResult.dirtyFilePaths.length === 0) {
+            this._logger.debug("변경파일에 대한, NgGen 결과", genResult);
+            this._logger.debug("Webpack 빌드 수행");
             callback();
             return;
           }
-          genDirtyFilePaths.push(...genResult.dirtyFilePaths);
+
+          this._logger.debug("변경파일에 대한, NgGen 결과", genResult);
 
           const modifiedFiles = [...compiler.modifiedFiles];
           const removedFiles = [...compiler.removedFiles];
-          for (const genFilePath of genDirtyFilePaths.distinct()) {
+          for (const genFilePath of genResult.dirtyFilePaths.distinct()) {
             if (FsUtil.exists(genFilePath)) {
               modifiedFiles.push(genFilePath);
             }
@@ -185,6 +196,7 @@ export class SdCliNgClientBuilder extends EventEmitter {
           compiler.modifiedFiles = new Set(modifiedFiles.distinct());
           compiler.removedFiles = new Set(removedFiles.distinct());
 
+          this._logger.debug("Webpack 빌드 수행");
           callback();
         }
       });
@@ -196,7 +208,9 @@ export class SdCliNgClientBuilder extends EventEmitter {
 
       compiler.hooks.failed.tap(this.constructor.name, (err) => {
         const results = SdWebpackUtil.getWebpackResults(err);
-        this.emit("complete", [...buildResult, ...results].distinct());
+        const allResults = [...ngGenResults, ...results].distinct();
+        this.emit("complete", allResults);
+        this._logger.debug("Webpack 빌드 수행 결과", allResults);
         reject(err);
       });
 
@@ -212,7 +226,9 @@ export class SdCliNgClientBuilder extends EventEmitter {
 
 
         await Wait.true(() => devMiddleware !== undefined && hotMiddleware !== undefined);
-        this.emit("complete", [...buildResult, ...results].distinct());
+        const allResults = [...ngGenResults, ...results].distinct();
+        this.emit("complete", allResults);
+        this._logger.debug("Webpack 빌드 수행 결과", allResults);
         resolve([devMiddleware!, hotMiddleware!]);
       });
 
@@ -242,19 +258,16 @@ export class SdCliNgClientBuilder extends EventEmitter {
       profile: false,
       resolve: {
         roots: [this.rootPath],
-        extensions: [".ts", ".tsx", ".mjs", ".js"],
+        extensions: [".ts", ".js"],
         symlinks: true,
-        modules: [this.projectRootPath, "node_modules"],
+        // modules: allNodeModulePaths,
         mainFields: ["es2015", "browser", "module", "main"],
         fallback: this.config.resolveFallback
       },
-      resolveLoader: {
+      /*resolveLoader: {
         symlinks: true,
-        modules: [
-          "node_modules",
-          ...this._findAllNodeModules(__dirname, this.projectRootPath)
-        ]
-      },
+        modules: allNodeModulePaths
+      },*/
       context: this.projectRootPath,
       entry: {
         main: [
@@ -278,6 +291,7 @@ export class SdCliNgClientBuilder extends EventEmitter {
         // chunkFilename: watch ? "[name].js" : "[name].[chunkhash:20].js",
         filename: "[name].js",
         chunkFilename: "[name].js",
+        assetModuleFilename: "resources/[name][ext][query]",
         crossOriginLoading: false,
         trustedTypes: "angular#bundler"
       },
@@ -377,18 +391,22 @@ export class SdCliNgClientBuilder extends EventEmitter {
           {
             test: /\.[jt]sx?$/,
             loader: "@ngtools/webpack"
+          },
+          {
+            test: /\.(png|jpe?g|gif|svg|woff|woff2|ttf|eot|ico|otf|xlsx?|pptx?|docx?|zip|pfx|pkl)$/,
+            type: "asset/resource"
           }
         ]
       },
       experiments: { syncWebAssembly: true, asyncWebAssembly: true },
-      cache: watch ? { type: "memory", maxGenerations: 1 } : false,
+      cache: (watch && this.useCache) ? { type: "memory", maxGenerations: 1 } : false,
       optimization: {
         minimizer: watch ? [] : [
           new JavaScriptOptimizerPlugin({
             define: { ngDevMode: false, ngI18nClosureMode: false, ngJitMode: false },
             sourcemap: false,
             target: this.parsedTsconfig.options.target,
-            keepNames: false,
+            keepNames: true,
             removeLicenses: true,
             advanced: true
           }) as any,
@@ -403,9 +421,9 @@ export class SdCliNgClientBuilder extends EventEmitter {
                 minify: true,
                 sourcefile,
                 target: browserslist([
-                  "last 2 Chrome versions",
+                  "last 1 Chrome versions",
                   "last 2 Edge major versions"
-                ])
+                ]).map((item) => item.replace(/ /g, ""))
               });
 
               return {
@@ -437,7 +455,7 @@ export class SdCliNgClientBuilder extends EventEmitter {
         ],
         moduleIds: "deterministic",
         chunkIds: watch ? "named" : "deterministic",
-        emitOnErrors: false,
+        emitOnErrors: watch,
         runtimeChunk: "single",
         splitChunks: {
           maxAsyncRequests: Infinity,
@@ -504,13 +522,13 @@ export class SdCliNgClientBuilder extends EventEmitter {
             append: undefined
           })
         ] : [],
-        new AnyComponentStyleBudgetChecker(watch ? [] : [
+        /*new AnyComponentStyleBudgetChecker(watch ? [] : [
           {
             type: Type.Any,
             maximumWarning: "2kb",
             maximumError: "4kb"
           }
-        ]),
+        ]),*/
         {
           apply(compiler) {
             compiler.hooks.shutdown.tap("sass-worker", () => {
@@ -584,13 +602,37 @@ export class SdCliNgClientBuilder extends EventEmitter {
         }),
         ...watch ? [
           new webpack.HotModuleReplacementPlugin()
-        ] : []
+        ] : [],
+        /*...watch ? [
+          new webpack.WatchIgnorePlugin({
+            paths: [
+              path.resolve(this.rootPath, "src/_modules/"),
+              path.resolve(this.rootPath, "src/_routes.ts")
+            ]
+          })
+        ] : [],*/
+        new webpack.ProgressPlugin({
+          handler: (per: number, msg: string, ...args: string[]) => {
+            const phaseText = msg ? ` - phase: ${msg}` : "";
+            const argsText = args.length > 0 ? ` - args: [${args.join(", ")}]` : "";
+            this._logger.debug(`Webpack 빌드 수행중...(${Math.round(per * 100)}%)${phaseText}${argsText}`);
+          }
+        })
       ],
       node: false,
       stats: "errors-warnings"
     };
   }
 
+  /*private _findAllInternalModuleCachePaths(): string[] {
+    return this._findAllNodeModules(this.rootPath, this.projectRootPath)
+      .mapMany((item) => (
+        FsUtil.readdir(item)
+          .filter((item1) => !item1.startsWith("@simplysm"))
+          .map((item1) => path.resolve(item, item1))
+      ));
+  }
+
   private _findAllNodeModules(from: string, root: string): string[] {
     const nodeModules: string[] = [];
 
@@ -609,5 +651,20 @@ export class SdCliNgClientBuilder extends EventEmitter {
     }
 
     return nodeModules;
+  }*/
+
+  private async _runNgGenWorkerAsync(watch: boolean, changedFilePaths?: string[]): Promise<{ dirtyFilePaths: string[]; result: ISdPackageBuildResult[] }> {
+    if (!this._ngGenWorker) {
+      this._ngGenWorker = await SdProcessWorker.createAsync(path.resolve(__dirname, `../workers/client-ng-gen-worker`), []);
+    }
+
+    const sender = this._ngGenWorker.createWorkSender();
+    return await new Promise<{ dirtyFilePaths: string[]; result: ISdPackageBuildResult[] }>(async (resolve) => {
+      await sender
+        .on("complete", (result) => {
+          resolve(result);
+        })
+        .sendAsync(this.rootPath, watch, changedFilePaths);
+    });
   }
 }

package/src/builders/SdCliNgLibraryBuilder.ts

@@ -1,22 +1,22 @@
 import * as ts from "typescript";
-import { ISdAutoIndexConfig, ISdPackageBuildResult, ITsconfig } from "../commons";
+import { ISdAutoIndexConfig, ISdPackageBuildResult } from "../commons";
 import * as path from "path";
 import { SdTsDiagnosticUtil } from "../utils/SdTsDiagnosticUtil";
 import { NgccProcessingCache } from "ng-packagr/lib/ng-package/ngcc-cache";
 import { NgccProcessor } from "ng-packagr/lib/ngc/ngcc-processor";
 import { EntryPointNode } from "ng-packagr/lib/ng-package/nodes";
 import { ngccTransformCompilerHost } from "ng-packagr/lib/ts/ngcc-transform-compiler-host";
-import { NgtscProgram } from "@angular/compiler-cli";
+import { MetadataCollector, NgtscProgram } from "@angular/compiler-cli";
 import { ITsBuildFileCache, ITsGenResult, SdCliTypescriptBuilder } from "./SdCliTypescriptBuilder";
 import { NgCompiler } from "@angular/compiler-cli/src/ngtsc/core";
 import { NeverEntryError, StringUtil } from "@simplysm/sd-core-common";
-import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
+import { PathUtil } from "@simplysm/sd-core-node";
 import * as os from "os";
 import * as nodeSass from "node-sass";
 import { createHash } from "crypto";
 import { SdCliNgModuleFilesGenerator } from "../build-tools/SdCliNgModuleFilesGenerator";
 import { OptimizeFor } from "@angular/compiler-cli/src/ngtsc/typecheck/api";
-import { CompilerHostAdapter, MetadataBundler } from "@angular/compiler-cli/src/metadata/bundler";
+import { ModuleMetadata } from "@angular/compiler-cli/src/metadata/schema";
 
 export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
   protected _ngProgram?: NgtscProgram;
@@ -29,20 +29,10 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
 
   public constructor(public rootPath: string,
                      public tsconfigFilePath: string,
-                     ignoreProcesses: ("emit" | "check" | "lint" | "genIndex" | "genNgModule")[],
+                     skipProcesses: ("emit" | "check" | "lint" | "genIndex" | "genNgModule")[],
                      public autoIndexConfig: ISdAutoIndexConfig | undefined) {
-    super(rootPath, tsconfigFilePath, ignoreProcesses as ("emit" | "check" | "lint" | "genIndex")[], autoIndexConfig);
-    this.ignoreProcesses = ignoreProcesses;
-
-    const tsconfig: ITsconfig = FsUtil.readJson(this.tsconfigFilePath);
-    this._parsedTsconfig = {
-      ...this._parsedTsconfig,
-      options: {
-        baseUrl: path.dirname(this.tsconfigFilePath),
-        ...this._parsedTsconfig.options,
-        ...tsconfig.angularCompilerOptions
-      }
-    };
+    super(rootPath, tsconfigFilePath, skipProcesses as ("emit" | "check" | "lint" | "genIndex")[], autoIndexConfig);
+    this.skipProcesses = skipProcesses;
   }
 
   protected override async _runProgramAsync(dirtyFilePaths: string[]): Promise<ISdPackageBuildResult[]> {
@@ -53,7 +43,7 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
 
     const diagnostics: ts.Diagnostic[] = [];
 
-    if (!this.ignoreProcesses.includes("check")) {
+    if (!this.skipProcesses.includes("check")) {
       diagnostics.push(
         ...this._ngCompiler.getOptionDiagnostics(),
         ...this._builder.getOptionsDiagnostics(),
@@ -62,9 +52,10 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
 
       await this._ngCompiler.analyzeAsync();
 
-      for (const filePath of dirtyFilePaths) {
-        const sourceFile = this._builder.getSourceFile(filePath);
-        if (!sourceFile) continue;
+      for (const sourceFile of this._builder.getSourceFiles()) {
+        /*for (const filePath of dirtyFilePaths) {
+          const sourceFile = this._builder.getSourceFile(filePath);
+          if (!sourceFile) continue;*/
 
         if (this._ngCompiler.ignoreForDiagnostics.has(sourceFile)) continue;
         if (sourceFile.isDeclarationFile) continue;
@@ -77,7 +68,7 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
       }
     }
 
-    if (!this.ignoreProcesses.includes("emit")) {
+    if (!this.skipProcesses.includes("emit")) {
       const transformers = this._ngCompiler.prepareEmit().transformers;
 
       for (const filePath of dirtyFilePaths) {
@@ -87,11 +78,21 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
         if (sourceFile.isDeclarationFile) continue;
 
         this._builder.emit(sourceFile, undefined, undefined, undefined, transformers);
+
+        // TODO: sd-metadata를 ModuleMetadata로 만들게 아니고, 아예 IAotModuleDefMetadata형식으로 만들어지게 해야함
+        if (this._program!.getCompilerOptions().declaration) {
+          if (sourceFile.fileName.endsWith(".ts") && !sourceFile.fileName.endsWith(".d.ts")) {
+            const metadata = this._getMetadata(sourceFile);
+            if (metadata) {
+              this._writeMetadataFile(sourceFile, metadata);
+            }
+          }
+        }
       }
 
-      if (this._parsedTsconfig.options.declaration) {
+      /*if (this._parsedTsconfig.options.declaration) {
         this._writeMetadataBundles();
-      }
+      }*/
     }
 
     const result = diagnostics.map((item) => SdTsDiagnosticUtil.convertDiagnosticsToResult(item)).filterExists();
@@ -101,7 +102,23 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
     return result;
   }
 
-  private _writeMetadataBundles(): void {
+  private _writeMetadataFile(sourceFile: ts.SourceFile, metadata: ModuleMetadata): void {
+    const metadataText = JSON.stringify({
+      ...metadata,
+      importAs: this.npmConfig.name
+    });
+    const outFileName = path.resolve(
+      this._program!.getCompilerOptions().declarationDir!,
+      path.relative(path.resolve(this.rootPath, "src"), sourceFile.fileName)
+    ).replace(/\.ts$/, ".sd-metadata.json");
+    this._cacheCompilerHost!.writeFile(outFileName, metadataText, false, undefined, [sourceFile]);
+  }
+
+  private _getMetadata(sourceFile: ts.SourceFile): ModuleMetadata | undefined {
+    return new MetadataCollector().getMetadata(sourceFile, true);
+  }
+
+  /*private _writeMetadataBundles(): void {
     for (const rootFilePath of this._parsedTsconfig.fileNames) {
       const metadata = new MetadataBundler(
         rootFilePath.replace(/\.ts$/, ""),
@@ -120,17 +137,19 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
       if (!fileCache?.sourceFile) throw new NeverEntryError();
       this._cacheCompilerHost!.writeFile(outFileName, JSON.stringify(metadata), false, undefined, [fileCache.sourceFile]);
     }
-  }
+  }*/
 
   public override async reloadProgramAsync(watch: boolean): Promise<string[]> {
     this._logger.debug("프로그램 리로드");
 
-    this._moduleResolutionCache = ts.createModuleResolutionCache(this.rootPath, (s) => s, this._parsedTsconfig.options);
-    this._cacheCompilerHost = await this._createCacheCompilerHostAsync(this._parsedTsconfig, this._moduleResolutionCache);
+    const parsedTsconfig = ts.parseJsonConfigFileContent(this._tsconfig, ts.sys, this.rootPath, this._tsconfig.angularCompilerOptions);
+
+    this._moduleResolutionCache = ts.createModuleResolutionCache(this.rootPath, (s) => s, parsedTsconfig.options);
+    this._cacheCompilerHost = await this._createCacheCompilerHostAsync(parsedTsconfig, this._moduleResolutionCache);
 
     this._ngProgram = new NgtscProgram(
-      this._parsedTsconfig.fileNames,
-      this._parsedTsconfig.options,
+      parsedTsconfig.fileNames,
+      parsedTsconfig.options,
       this._cacheCompilerHost,
       this._ngProgram
     );
@@ -152,15 +171,27 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
     };
 
     if (watch) {
-      const builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
-        this._program,
-        this._cacheCompilerHost,
-        this._builder as ts.EmitAndSemanticDiagnosticsBuilderProgram
-      );
-      this._builder = builder;
+      if (this.skipProcesses.includes("emit")) {
+        this._builder = ts.createSemanticDiagnosticsBuilderProgram(
+          this._program,
+          this._cacheCompilerHost,
+          this._builder as ts.SemanticDiagnosticsBuilderProgram
+        );
+      }
+      else {
+        this._builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
+          this._program,
+          this._cacheCompilerHost,
+          this._builder as ts.EmitAndSemanticDiagnosticsBuilderProgram
+        );
+      }
+      const builder = this._builder as ts.SemanticDiagnosticsBuilderProgram;
 
-      const affectedFilePaths: string[] = [];
+      let seq = 0;
+      const affectedFilePathSet = new Set<string>();
       while (true) {
+        const affectedFilePaths: string[] = [];
+        this._logger.debug(`프로그램 리로드 > 변경파일 목록구성: [SEQ: ${++seq}]`);
         const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
           if (this._ngCompiler!.ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith(".ngtypecheck.ts")) {
             const originalFilename = sourceFile.fileName.slice(0, -15) + ".ts";
@@ -173,14 +204,20 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
           return false;
         });
 
-        if (!result) break;
-
-        if ("fileName" in result.affected) {
+        if (result && "fileName" in result.affected) {
           affectedFilePaths.push(result.affected.fileName);
         }
+
+        affectedFilePaths.distinctThis();
+
+        this._logger.debug(`프로그램 리로드 > 변경파일 목록구성: [SEQ: ${seq}, SIZE:${affectedFilePathSet.size}]\n` + affectedFilePaths.map((item) => "- " + item).join("\n"));
+
+        affectedFilePathSet.adds(...affectedFilePaths.distinct());
+
+        if (!result) break;
       }
 
-      const result = affectedFilePaths.distinct();
+      const result = Array.from(affectedFilePathSet.values());
 
       this._logger.debug("프로그램 리로드", result);
 
@@ -234,7 +271,7 @@ export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
     this._logger.debug("Angular Module, RoutingModule 생성", dirtyFilePaths);
 
     const result: ITsGenResult = { dirtyFilePaths: [], result: [] };
-    if (this.ignoreProcesses.includes("genNgModule")) return result;
+    if (this.skipProcesses.includes("genNgModule")) return result;
 
     const reloadResult = await this._moduleFilesGenerator.reloadSourceFilesAsync(
       dirtyFilePaths,