@simplysm/sd-cli 6.4.5 → 7.0.9

package/src/builder/SdCliTsLibBuilder.ts

@@ -0,0 +1,335 @@
+import { ISdCliPackageBuildResult } from "../commons";
+import { EventEmitter } from "events";
+import ts from "typescript";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
+import * as path from "path";
+import { createHash } from "crypto";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
+import { NgtscProgram } from "@angular/compiler-cli";
+import sass from "sass";
+import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
+import { SdCliCacheCompilerHost } from "../build-tool/SdCliCacheCompilerHost";
+import { SdCliNgCacheCompilerHost } from "../build-tool/SdCliNgCacheCompilerHost";
+import { NgCompiler } from "@angular/compiler-cli/src/ngtsc/core";
+
+export class SdCliTsLibBuilder extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  private _moduleResolutionCache?: ts.ModuleResolutionCache;
+
+  private readonly _linter: SdCliPackageLinter;
+
+  private readonly _fileCache = new Map<string, IFileCache>();
+  private readonly _writeFileCache = new Map<string, string>();
+
+  private _program?: ts.Program;
+  private _ngProgram?: NgtscProgram;
+  private _builder?: ts.EmitAndSemanticDiagnosticsBuilderProgram;
+
+  public constructor(private readonly _rootPath,
+                     private readonly _isAngular: boolean) {
+    super();
+    this._linter = new SdCliPackageLinter(this._rootPath);
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    return super.on(event, listener);
+  }
+
+  public async watchAsync(): Promise<void> {
+    this.emit("change");
+
+    // TSCONFIG 읽기
+    const parsedTsconfig = await this._getParsedTsconfigAsync();
+
+    // DIST 비우기
+    await FsUtil.removeAsync(parsedTsconfig.options.outDir!);
+
+    // 프로그램 리로드
+    const buildPack = this._createSdBuildPack(parsedTsconfig);
+
+    const relatedPaths = await this.getAllRelatedPathsAsync();
+    const watcher = SdFsWatcher.watch(relatedPaths);
+    watcher.onChange(async (changeInfos) => {
+      const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+      if (changeFilePaths.length === 0) return;
+
+      this._logger.debug("파일 변경 감지", changeInfos);
+      this.emit("change");
+
+      // 캐쉬 삭제
+      for (const changeFilePath of changeFilePaths) {
+        this._fileCache.delete(PathUtil.posix(changeFilePath));
+      }
+
+      // 빌드
+      const watchBuildPack = this._createSdBuildPack(parsedTsconfig);
+
+      // 린트
+      const watchBuildResults = await this._runBuilderAsync(watchBuildPack.builder, watchBuildPack.ngCompiler);
+      watchBuildResults.push(...await this._linter.lintAsync([
+        ...watchBuildPack.affectedSourceFiles.map((item) => item.fileName),
+        ...changeFilePaths
+      ], watchBuildPack.program));
+
+      const watchRelatedPaths = await this.getAllRelatedPathsAsync();
+      watcher.add(watchRelatedPaths);
+
+      this.emit("complete", watchBuildResults);
+    });
+
+    // 빌드
+    const buildResults = await this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler);
+
+    // 린트
+    buildResults.push(...await this._linter.lintAsync(relatedPaths, buildPack.program));
+
+    this.emit("complete", buildResults);
+  }
+
+  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+    // TSCONFIG 읽기
+    const parsedTsconfig = await this._getParsedTsconfigAsync();
+
+    // DIST 비우기
+    await FsUtil.removeAsync(parsedTsconfig.options.outDir!);
+
+    // 프로그램 리로드
+    const buildPack = this._createSdBuildPack(parsedTsconfig);
+
+    // 빌드
+    const buildResults = await this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler);
+
+    // 린트
+    const relatedPaths = await this.getAllRelatedPathsAsync();
+    buildResults.push(...await this._linter.lintAsync(relatedPaths, buildPack.program));
+
+    return buildResults;
+  }
+
+  private async getAllRelatedPathsAsync(): Promise<string[]> {
+    const fileCachePaths = Array.from(this._fileCache.keys());
+    const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts)");
+    const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
+      ignore: [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/.*/**"
+      ]
+    });
+
+    return [...fileCachePaths, ...mySourceFilePaths, path.resolve(this._rootPath, ".eslintrc.cjs")].distinct();
+  }
+
+  private async _runBuilderAsync(builder: ts.EmitAndSemanticDiagnosticsBuilderProgram, ngCompiler?: NgCompiler): Promise<ISdCliPackageBuildResult[]> {
+    try {
+      const results: ISdCliPackageBuildResult[] = [];
+
+      const diagnostics: ts.Diagnostic[] = [];
+
+      if (ngCompiler) {
+        diagnostics.push(...ngCompiler.getOptionDiagnostics());
+      }
+
+      diagnostics.push(
+        ...builder.getOptionsDiagnostics(),
+        ...builder.getGlobalDiagnostics()
+      );
+
+      if (ngCompiler) {
+        await ngCompiler.analyzeAsync();
+      }
+
+      for (const sourceFile of builder.getSourceFiles()) {
+        if (ngCompiler?.ignoreForDiagnostics.has(sourceFile)) continue;
+
+        diagnostics.push(
+          ...builder.getSyntacticDiagnostics(sourceFile),
+          ...builder.getSemanticDiagnostics(sourceFile)
+        );
+
+        if (
+          ngCompiler &&
+          !sourceFile.isDeclarationFile &&
+          !ngCompiler.ignoreForEmit.has(sourceFile) &&
+          !ngCompiler.incrementalDriver.safeToSkipEmit(sourceFile)
+        ) {
+          diagnostics.push(
+            ...ngCompiler.getDiagnosticsForFile(sourceFile, 1)
+          );
+        }
+      }
+
+      results.push(
+        ...diagnostics
+          .filter((item) => [ts.DiagnosticCategory.Error, ts.DiagnosticCategory.Warning].includes(item.category))
+          .map((item) => SdCliBuildResultUtil.convertDiagsToResult(item))
+          .filterExists()
+      );
+
+      if (results.some((item) => item.severity === "error")) {
+        return results;
+      }
+
+      const transformers = ngCompiler?.prepareEmit().transformers;
+      for (const sourceFile of builder.getSourceFiles()) {
+        if (ngCompiler?.ignoreForEmit.has(sourceFile)) continue;
+        builder.emit(sourceFile, undefined, undefined, undefined, transformers);
+      }
+
+      return results;
+    }
+    catch (err) {
+      if (err instanceof sass.Exception) {
+        const matches = err.sassStack.match(/^(.*\.sd\.scss) ([0-9]*):([0-9]*)/)!;
+        const filePath = path.resolve(matches[1].replace(/\.sd\.scss/, "").replace(/^\.:/, item => item.toUpperCase()));
+        const scssLine = matches[2];
+        const scssChar = matches[3];
+        const message = err.sassMessage;
+
+        return [{
+          filePath,
+          line: undefined,
+          char: undefined,
+          code: undefined,
+          severity: "error",
+          message: `스타일(${scssLine}:${scssChar}): ${message}`
+        }];
+      }
+
+      return [{
+        filePath: undefined,
+        line: undefined,
+        char: undefined,
+        code: undefined,
+        severity: "error",
+        message: err.message
+      }];
+    }
+  }
+
+  private _createSdBuildPack(parsedTsconfig: ts.ParsedCommandLine): ISdBuildPack {
+    const compilerHost = this._createCacheCompilerHost(parsedTsconfig);
+    const { program, ngCompiler } = this._createProgram(parsedTsconfig, compilerHost);
+
+    this._builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
+      program,
+      compilerHost,
+      this._builder
+    );
+
+    const affectedSourceFileSet: Set<ts.SourceFile> = new Set<ts.SourceFile>();
+    while (true) {
+      const result = this._builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+        if (ngCompiler && ngCompiler.ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith(".ngtypecheck.ts")) {
+          const orgFileName = sourceFile.fileName.slice(0, -15) + ".ts";
+          const orgSourceFile = this._builder!.getSourceFile(orgFileName);
+          if (orgSourceFile) {
+            affectedSourceFileSet.add(orgSourceFile);
+          }
+
+          return true;
+        }
+
+        return false;
+      });
+      if (!result) break;
+
+      affectedSourceFileSet.add(result.affected as ts.SourceFile);
+    }
+
+    return {
+      program,
+      ngCompiler,
+      builder: this._builder,
+      affectedSourceFiles: Array.from(affectedSourceFileSet.values())
+    };
+  }
+
+  private _createProgram(parsedTsconfig: ts.ParsedCommandLine, compilerHost: ts.CompilerHost): { program: ts.Program; ngCompiler?: NgCompiler } {
+    if (this._isAngular) {
+      this._ngProgram = new NgtscProgram(
+        parsedTsconfig.fileNames,
+        parsedTsconfig.options,
+        compilerHost,
+        this._ngProgram
+      );
+      this._program = this._ngProgram.getTsProgram();
+
+      this._configProgramSourceFileVersions(this._program);
+      return {
+        program: this._program,
+        ngCompiler: this._ngProgram.compiler
+      };
+    }
+    else {
+      this._program = ts.createProgram(
+        parsedTsconfig.fileNames,
+        parsedTsconfig.options,
+        compilerHost,
+        this._program
+      );
+
+      this._configProgramSourceFileVersions(this._program);
+
+      return { program: this._program };
+    }
+  }
+
+  private _configProgramSourceFileVersions(program: ts.Program): void {
+    const baseGetSourceFiles = program.getSourceFiles;
+    program.getSourceFiles = function (...parameters) {
+      const files: readonly (ts.SourceFile & { version?: string })[] = baseGetSourceFiles(...parameters);
+
+      for (const file of files) {
+        if (file.version === undefined) {
+          file.version = createHash("sha256").update(file.text).digest("hex");
+        }
+      }
+
+      return files;
+    };
+  }
+
+  private _createCacheCompilerHost(parsedTsconfig: ts.ParsedCommandLine): ts.CompilerHost {
+    if (!this._moduleResolutionCache) {
+      this._moduleResolutionCache = ts.createModuleResolutionCache(this._rootPath, (s) => s, parsedTsconfig.options);
+    }
+
+    const compilerHost = SdCliCacheCompilerHost.create(
+      parsedTsconfig,
+      this._moduleResolutionCache,
+      this._fileCache,
+      this._writeFileCache
+    );
+
+    if (this._isAngular) {
+      return SdCliNgCacheCompilerHost.wrap(compilerHost, this._fileCache);
+    }
+    else {
+      return compilerHost;
+    }
+  }
+
+  private async _getParsedTsconfigAsync(): Promise<ts.ParsedCommandLine> {
+    const tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
+    const tsconfig = await FsUtil.readJsonAsync(tsconfigFilePath);
+    return ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath);
+  }
+}
+
+interface IFileCache {
+  exists?: boolean;
+  sourceFile?: ts.SourceFile;
+  content?: string;
+  styleContent?: string;
+}
+
+interface ISdBuildPack {
+  program: ts.Program;
+  ngCompiler?: NgCompiler;
+  builder: ts.EmitAndSemanticDiagnosticsBuilderProgram;
+  affectedSourceFiles: ts.SourceFile[];
+}

package/src/commons.ts

@@ -1,49 +1,3 @@
-export interface ISdProjectConfig {
-  packages: Record<string, TSdPackageConfig | undefined>;
-  localUpdates?: Record<string, string>;
-}
-
-export type TSdPackageConfig =
-  ISdLibraryPackageConfig |
-  ISdClientPackageConfig |
-  ISdServerPackageConfig |
-  ISdNonePackageConfig;
-
-export interface ISdLibraryPackageConfig {
-  type: "library";
-  targets?: ("node" | "browser" | "angular")[];
-  autoIndex?: ISdAutoIndexConfig | boolean;
-  publish?: "npm";
-}
-
-export interface ISdClientPackageConfig {
-  type: "client";
-  platforms?: TSdClientPlatformConfig[];
-  env?: Record<string, string>;
-  server?: string;
-  resolveFallback?: Record<string, string>;
-  configs?: Record<string, any>;
-  publish?: TSdPublishConfig;
-}
-
-export interface ISdServerPackageConfig {
-  type: "server";
-  env?: Record<string, string>;
-  externalDependencies?: string[];
-  configs?: Record<string, any>;
-  pm2?: Record<string, any> | boolean;
-  iis?: boolean | { serverExeFilePath?: string };
-  publish?: TSdPublishConfig;
-}
-
-export interface ISdNonePackageConfig {
-  type: "none";
-}
-
-export interface ISdAutoIndexConfig {
-  polyfills?: string[];
-}
-
 export interface INpmConfig {
   name: string;
   version: string;
@@ -52,6 +6,9 @@ export interface INpmConfig {
   browser?: string;
   module?: string;
   main?: string;
+  exports?: Record<string, {
+    types?: string;
+  }>;
   scripts?: Record<string, string>;
 
   dependencies?: Record<string, string>;
@@ -62,98 +19,36 @@ export interface INpmConfig {
 
 export interface ITsconfig {
   compilerOptions?: {
-    module?: "commonjs" | "es2020";
-    target?: "es2015" | "es2020";
-    lib?: ("dom" | "es2015" | "es2020")[];
     outDir?: string;
-    declarationDir?: string;
-    declaration?: boolean;
-    declarationMap?: boolean;
     baseUrl?: string;
     paths?: Record<string, string[]>;
-    generateTrace?: string;
-  };
-  angularCompilerOptions?: {
-    enableI18nLegacyMessageIdFormat?: boolean;
-    strictInjectionParameters?: boolean;
-    strictInputAccessModifiers?: boolean;
-    strictTemplates?: boolean;
-    strictInputTypes?: boolean;
-    strictOutputEventTypes?: boolean;
-    enableIvy?: boolean;
-    compilationMode?: "partial" | "full";
-    disableTypeScriptVersionCheck?: boolean;
   };
-  files?: string[];
-  include?: string[];
 }
 
-export interface ISdPackageBuildResult {
+export interface ISdCliPackageBuildResult {
   filePath: string | undefined;
+  line: number | undefined;
+  char: number | undefined;
+  code: string | undefined;
   severity: "error" | "warning";
   message: string;
 }
 
-export type TSdPublishConfig =
-  ISdSFtpPublishConfig |
-  ISdLocalDirectoryPublishConfig |
-  ISdFtpPublishConfig |
-  ISdAzureAppServicePublishConfig;
-
-export interface ISdSFtpPublishConfig {
-  type: "sftp";
-  host: string;
-  port?: number;
-  path: string;
-  username: string;
-  password: string;
+export interface ISdCliConfig {
+  packages: Record<string, TSdCliPackageConfig | undefined>;
 }
 
-export interface ISdFtpPublishConfig {
-  type: "ftp";
-  host: string;
-  port?: number;
-  path: string;
-  username: string;
-  password: string;
-  secure?: boolean;
-}
+export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig;
 
-export interface ISdAzureAppServicePublishConfig {
-  type: "azure-app-service";
-  username: string;
-  password: string;
-  subscriptionId: string;
-  resourceGroupName: string;
-  serviceName: string;
-  path: string;
-}
-
-export interface ISdLocalDirectoryPublishConfig {
-  type: "local-directory";
-  path: string;
+export interface ISdCliLibPackageConfig {
+  type: "library";
+  publish?: "npm";
 }
 
-export type TSdClientPlatformConfig =
-  ISdClientBrowserPlatformConfig |
-  ISdClientCordovaPlatformConfig;
-
-export interface ISdClientBrowserPlatformConfig {
-  type: "browser";
+export interface ISdCliNgLibPackageConfig {
+  type: "angular";
 }
 
-export interface ISdClientCordovaPlatformConfig {
-  type: "cordova";
-  targets: ("android")[];
-  appId: string;
-  appName: string;
-  plugins?: string[];
-  icon?: string;
-  sign?: {
-    keystore: string;
-    storePassword: string;
-    alias: string;
-    password: string;
-    keystoreType: string;
-  };
+export interface ISdCliServerPackageConfig {
+  type: "server";
 }