@simplysm/sd-cli 6.0.19 → 6.0.27

package/src/builders/SdCliNgLibraryBuilder.ts

@@ -0,0 +1,336 @@
+import * as ts from "typescript";
+import { ISdAutoIndexConfig, ISdPackageBuildResult, ITsconfig } 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 { 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 * 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 { ModuleMetadata } from "@angular/compiler-cli/src/metadata/schema";
+
+export class SdCliNgLibraryBuilder extends SdCliTypescriptBuilder {
+  protected _ngProgram?: NgtscProgram;
+  protected _ngCompiler?: NgCompiler;
+  private readonly _ngccProcessingCache = new NgccProcessingCache();
+
+  private readonly _moduleFilesGenerator = new SdCliNgModuleFilesGenerator(this.rootPath);
+
+  protected override readonly _fileCache = new Map<string, (ITsBuildFileCache & { scssDependencies?: string[] })>();
+
+  public constructor(public rootPath: string,
+                     public tsconfigFilePath: string,
+                     ignoreProcesses: ("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
+      }
+    };
+  }
+
+  protected override async _runProgramAsync(dirtyFilePaths: string[]): Promise<ISdPackageBuildResult[]> {
+    this._logger.debug("빌드", dirtyFilePaths);
+
+    if (!this._ngCompiler) throw new NeverEntryError();
+    if (!this._builder) throw new NeverEntryError();
+
+    const diagnostics: ts.Diagnostic[] = [];
+
+    if (!this.ignoreProcesses.includes("check")) {
+      diagnostics.push(
+        ...this._ngCompiler.getOptionDiagnostics(),
+        ...this._builder.getOptionsDiagnostics(),
+        ...this._builder.getGlobalDiagnostics()
+      );
+
+      await this._ngCompiler.analyzeAsync();
+
+      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;
+
+        diagnostics.push(
+          ...this._builder.getSyntacticDiagnostics(sourceFile),
+          ...this._builder.getSemanticDiagnostics(sourceFile),
+          ...this._ngCompiler.getDiagnosticsForFile(sourceFile, OptimizeFor.WholeProgram)
+        );
+      }
+    }
+
+    if (!this.ignoreProcesses.includes("emit")) {
+      const transformers = this._ngCompiler.prepareEmit().transformers;
+
+      for (const filePath of dirtyFilePaths) {
+        const sourceFile = this._builder.getSourceFile(filePath);
+        if (!sourceFile) continue;
+        if (this._ngCompiler.ignoreForEmit.has(sourceFile)) continue;
+        if (sourceFile.isDeclarationFile) continue;
+
+        this._builder.emit(sourceFile, undefined, undefined, undefined, transformers);
+
+        if (this._parsedTsconfig.options.declaration) {
+          if (sourceFile.fileName.endsWith(".ts") && !sourceFile.fileName.endsWith(".d.ts")) {
+            const metadata = this._getMetadata(sourceFile);
+            if (metadata) {
+              this._writeMetadataFile(sourceFile, metadata);
+            }
+          }
+        }
+      }
+    }
+
+    const result = diagnostics.map((item) => SdTsDiagnosticUtil.convertDiagnosticsToResult(item)).filterExists();
+
+    this._logger.debug("빌드 결과", result);
+
+    return result;
+  }
+
+  private _writeMetadataFile(sourceFile: ts.SourceFile, metadata: ModuleMetadata): void {
+    const metadataText = JSON.stringify([metadata]);
+    const outFileName = path.resolve(
+      this._parsedTsconfig.options.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);
+  }
+
+  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);
+
+    this._ngProgram = new NgtscProgram(
+      this._parsedTsconfig.fileNames,
+      this._parsedTsconfig.options,
+      this._cacheCompilerHost,
+      this._ngProgram
+    );
+
+    this._ngCompiler = this._ngProgram.compiler;
+    this._program = this._ngProgram.getTsProgram();
+
+    const baseGetSourceFiles = this._program.getSourceFiles;
+    this._program.getSourceFiles = function (...parameters) {
+      const sourceFiles: readonly (ts.SourceFile & { version?: string })[] = baseGetSourceFiles(...parameters);
+
+      for (const sourceFile of sourceFiles) {
+        if (sourceFile.version === undefined) {
+          sourceFile.version = createHash("sha256").update(sourceFile.text).digest("hex");
+        }
+      }
+
+      return sourceFiles;
+    };
+
+    if (watch) {
+      const builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
+        this._program,
+        this._cacheCompilerHost,
+        this._builder as ts.EmitAndSemanticDiagnosticsBuilderProgram
+      );
+      this._builder = builder;
+
+      const affectedFilePaths: string[] = [];
+      while (true) {
+        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";
+            const originalSourceFile = builder.getSourceFile(originalFilename);
+            if (originalSourceFile) {
+              affectedFilePaths.push(originalSourceFile.fileName);
+            }
+            return true;
+          }
+          return false;
+        });
+
+        if (!result) break;
+
+        if ("fileName" in result.affected) {
+          affectedFilePaths.push(result.affected.fileName);
+        }
+      }
+
+      const result = affectedFilePaths.distinct();
+
+      this._logger.debug("프로그램 리로드", result);
+
+      return result;
+    }
+    else {
+      this._builder = ts.createAbstractBuilder(this._program, this._cacheCompilerHost);
+      const result = this._builder.getSourceFiles().map((item) => item.fileName).distinct();
+
+      this._logger.debug("프로그램 리로드", result);
+
+      return result;
+    }
+  }
+
+  protected override _deleteFileCaches(filePaths: string[]): void {
+    super._deleteFileCaches(filePaths);
+    this._moduleFilesGenerator.deleteFileCaches(filePaths);
+  }
+
+  public async generateAdditionalFilesAsync(dirtyFilePaths: string[], watch: boolean): Promise<ITsGenResult> {
+    const result: ITsGenResult = { dirtyFilePaths: [], result: [] };
+
+    // index.ts 파일 생성
+    const genIndexResult = await super._generateIndexFileAsync(watch);
+    result.result.push(...genIndexResult.result);
+    result.dirtyFilePaths.push(...genIndexResult.dirtyFilePaths);
+
+    // Angular Module 및 RoutingModule 생성
+    const genModuleResult = await this._generateModuleFilesAsync(
+      [...dirtyFilePaths, ...genIndexResult.dirtyFilePaths].distinct()
+      , watch
+    );
+    result.result.push(...genModuleResult.result);
+    result.dirtyFilePaths.push(...genModuleResult.dirtyFilePaths);
+
+    // 'Angular Module 및 RoutingModule 생성'중에 변경사항이 있다면, index.ts 다시 생성
+    if (genModuleResult.dirtyFilePaths.length > 0) {
+      const newGenIndexResult = await super._generateIndexFileAsync(watch);
+      result.result.push(...newGenIndexResult.result);
+      result.dirtyFilePaths.push(...newGenIndexResult.dirtyFilePaths);
+    }
+
+    return {
+      dirtyFilePaths: result.dirtyFilePaths.distinct(),
+      result: result.result.distinct()
+    };
+  }
+
+  private async _generateModuleFilesAsync(dirtyFilePaths: string[], watch: boolean): Promise<ITsGenResult> {
+    this._logger.debug("Angular Module, RoutingModule 생성", dirtyFilePaths);
+
+    const result: ITsGenResult = { dirtyFilePaths: [], result: [] };
+    if (this.ignoreProcesses.includes("genNgModule")) return result;
+
+    const reloadResult = await this._moduleFilesGenerator.reloadSourceFilesAsync(
+      dirtyFilePaths,
+      this._cacheCompilerHost!,
+      this._moduleResolutionCache!,
+      this._ngProgram!
+    );
+    result.result.push(...reloadResult.result);
+
+    if (!reloadResult.changed) return result;
+
+    const generateResult = await this._moduleFilesGenerator.generateAsync();
+    result.result.push(...generateResult.result);
+    if (generateResult.changedFilePaths.length > 0) {
+      result.dirtyFilePaths = await this.reloadChangedProgramAsync(generateResult.changedFilePaths, watch);
+    }
+
+    this._logger.debug("Angular Module, RoutingModule 생성 결과", result);
+
+    return result;
+  }
+
+  protected override async _createCacheCompilerHostAsync(parsedTsconfig: ts.ParsedCommandLine, moduleResolutionCache: ts.ModuleResolutionCache): Promise<ts.CompilerHost> {
+    const tsCacheCompilerHost = await super._createCacheCompilerHostAsync(parsedTsconfig, moduleResolutionCache);
+
+    const ngccProcessor = new NgccProcessor(
+      this._ngccProcessingCache,
+      this.tsconfigFilePath,
+      parsedTsconfig.options,
+      parsedTsconfig.fileNames.map((item) => ({ url: item }) as EntryPointNode)
+    );
+
+    await ngccProcessor.process();
+
+    const ngCompilerHost = ngccTransformCompilerHost(
+      tsCacheCompilerHost,
+      parsedTsconfig.options,
+      ngccProcessor,
+      moduleResolutionCache
+    );
+
+    const resultCompilerHost = { ...ngCompilerHost };
+
+    resultCompilerHost.getSourceFile = (fileName: string, languageVersion: ts.ScriptTarget) => {
+      const cache = this._fileCache.getOrCreate(PathUtil.posix(fileName), {});
+      if (!cache.sourceFile) {
+        const orgContent = ngCompilerHost.readFile.call(resultCompilerHost, fileName);
+        if (StringUtil.isNullOrEmpty(orgContent)) {
+          cache.sourceFile = undefined;
+          cache.scssDependencies = undefined;
+        }
+        else {
+          const scssResult = this._replaceScssToCss(fileName, orgContent);
+          cache.sourceFile = ts.createSourceFile(fileName, scssResult.content, languageVersion);
+          cache.scssDependencies = scssResult.dependencies;
+        }
+      }
+      return cache.sourceFile;
+    };
+
+    return resultCompilerHost;
+  }
+
+  private _replaceScssToCss(filePath: string, content: string): { content: string; dependencies: string[] } {
+    const scssRegex = /\/\* *language=SCSS *\*\/ *[`"'](((?!['"`]\)?[\],][,;]?[\r\n\\])(.|\r|\n))*)['"`]/;
+
+    const matches = content.match(new RegExp(scssRegex, "gi"));
+    if (!matches) {
+      return { content, dependencies: [] };
+    }
+
+    const results = matches.map((match) => nodeSass.renderSync({
+      file: filePath,
+      data: scssRegex.exec(match)?.[1],
+      precision: 8,
+      includePaths: [],
+      outputStyle: "expanded",
+      sourceMapEmbed: false,
+      sourceMap: false
+    }));
+
+    const deps = results.mapMany((result) => result.stats.includedFiles).map((item) => path.resolve(item));
+
+    let i = 0;
+    const newContent = content.replace(new RegExp(scssRegex, "gi"), () => {
+      let result = "`" + results[i].css.toString() + "`";
+      const prev = matches[i];
+
+      const diffCount = Array.from(prev).filter((item) => item === "\n").length
+        - Array.from(result).filter((item) => item === "\n").length;
+
+      for (let j = 0; j < diffCount; j++) {
+        result += os.EOL;
+      }
+
+      i += 1;
+      return result;
+    });
+
+    return { content: newContent, dependencies: deps };
+  }
+}

package/src/{build-tools → builders}/SdCliServerBuilder.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from "events";
 import { INpmConfig, ISdPackageBuildResult, ISdServerPackageConfig, ITsconfig } from "../commons";
 import * as ts from "typescript";
-import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
+import { FsUtil, Logger, PathUtil } from "@simplysm/sd-core-node";
 import { ObjectUtil, StringUtil, Wait } from "@simplysm/sd-core-common";
 import * as webpack from "webpack";
 import * as path from "path";
@@ -10,7 +10,7 @@ import { DedupeModuleResolvePlugin } from "@angular-devkit/build-angular/src/web
 import { LicenseWebpackPlugin } from "license-webpack-plugin";
 import { SdWebpackUtil } from "../utils/SdWebpackUtil";
 import { ErrorInfo } from "ts-loader/dist/interfaces";
-import { LintResult, LintResultData } from "eslint-webpack-plugin/declarations/options";
+import { LintResult } from "eslint-webpack-plugin/declarations/options";
 import * as os from "os";
 import { SdServiceServer } from "@simplysm/sd-service-node";
 import decache from "decache";
@@ -69,13 +69,13 @@ export class SdCliServerBuilder extends EventEmitter {
     // .config.json 파일 쓰기
 
     const targetPath = path.resolve(this.parsedTsconfig.options.outDir!, ".config.json");
-    FsUtil.writeFile(targetPath, JSON.stringify(this.config.configs ?? {}, undefined, 2));
+    await FsUtil.writeFileAsync(targetPath, JSON.stringify(this.config.configs ?? {}, undefined, 2));
 
     // pm2.json 파일 쓰기
     if (this.config.pm2 !== undefined && this.config.pm2 !== false) {
       const npmConfig = this._getNpmConfig(this.rootPath)!;
       const pm2DistPath = path.resolve(this.parsedTsconfig.options.outDir!, "pm2.json");
-      FsUtil.writeFile(pm2DistPath, JSON.stringify(ObjectUtil.merge(
+      await FsUtil.writeFileAsync(pm2DistPath, JSON.stringify(ObjectUtil.merge(
         {
           "name": npmConfig.name.replace(/@/g, "").replace(/\//g, "-"),
           "script": path.basename(path.resolve(this.parsedTsconfig.options.outDir!, "main.js")),
@@ -100,7 +100,7 @@ export class SdCliServerBuilder extends EventEmitter {
     // iis 파일 쓰기
     if (this.config.iis) {
       const iisDistPath = path.resolve(this.parsedTsconfig.options.outDir!, "web.config");
-      FsUtil.writeFile(iisDistPath, `
+      await FsUtil.writeFileAsync(iisDistPath, `
 <configuration>
   <system.webServer>
     <webSocket enabled="false" />
@@ -135,7 +135,7 @@ export class SdCliServerBuilder extends EventEmitter {
 
     // CopyWebpackPlugin 대신 직접 카피
 
-    for (const item of ["favicon.icon", "assets/", "icons/", "manifest.webmanifest"]) {
+    for (const item of ["assets/"]) {
       await FsUtil.copyAsync(path.resolve(this.rootPath, "src", item), path.resolve(this.parsedTsconfig.options.outDir!, item));
     }
 
@@ -168,7 +168,7 @@ export class SdCliServerBuilder extends EventEmitter {
         // .config.json 파일 쓰기
 
         const configDistPath = path.resolve(this.parsedTsconfig.options.outDir!, ".config.json");
-        FsUtil.writeFile(configDistPath, JSON.stringify(this.config.configs ?? {}, undefined, 2));
+        await FsUtil.writeFileAsync(configDistPath, JSON.stringify(this.config.configs ?? {}, undefined, 2));
 
         // 결과 변환
 
@@ -206,12 +206,18 @@ export class SdCliServerBuilder extends EventEmitter {
   private async _startServerAsync(): Promise<void> {
     await Wait.true(() => this._server === undefined);
 
+
     const mainFilePath = path.resolve(this.parsedTsconfig.options.outDir!, "main.js");
+
+    const prevLoggerConfigs = ObjectUtil.clone(Logger.configs);
     this._server = require(mainFilePath) as SdServiceServer | undefined;
+    Logger.configs = prevLoggerConfigs;
+
     if (!this._server) {
       throw new Error(`${mainFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
     }
 
+
     await new Promise<void>((resolve) => {
       this._server!.on("ready", () => {
         resolve();
@@ -339,7 +345,7 @@ export class SdCliServerBuilder extends EventEmitter {
           exclude: ["node_modules"],
           fix: false,
           threads: true,
-          formatter: (results: LintResult[], data?: LintResultData | undefined) => {
+          formatter: (results: LintResult[]) => {
             const resultMessages: string[] = [];
             for (const result of results) {
               for (const msg of result.messages) {