@simplysm/sd-cli 11.1.46 → 11.1.51

package/src/build-tools/SdTsCompiler.ts

@@ -1,286 +1,427 @@
-import {SdCliBuildResultUtil} from "../utils/SdCliBuildResultUtil";
-import {ISdCliPackageBuildResult} from "../commons";
-import {SdTsCompiler2} from "../build-tools2/SdTsCompiler2";
-import ts from "typescript";
+import ts, {CompilerOptions} from "typescript";
 import path from "path";
 import {FsUtil, PathUtil} from "@simplysm/sd-core-node";
+import {transformSupportedBrowsersToTargets} from "@angular-devkit/build-angular/src/tools/esbuild/utils";
+import browserslist from "browserslist";
+import {
+  ComponentStylesheetBundler
+} from "@angular-devkit/build-angular/src/tools/esbuild/angular/component-stylesheets";
+import {AngularCompilerHost} from "@angular-devkit/build-angular/src/tools/esbuild/angular/angular-host";
+import {StringUtil} from "@simplysm/sd-core-common";
+import esbuild from "esbuild";
+import {NgtscProgram, OptimizeFor} from "@angular/compiler-cli";
+import {createHash} from "crypto";
 
 export class SdTsCompiler {
-  /*private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
+  readonly #parsedTsconfig: ts.ParsedCommandLine;
+  readonly #isForAngular: boolean;
 
-  private readonly _parsedTsConfig: ts.ParsedCommandLine;
-  private readonly _writeFileCache = new Map<string, string>();
-  private readonly _compilerHost: ts.CompilerHost;
-  private _program?: ts.Program;
-  private _builder?: ts.EmitAndSemanticDiagnosticsBuilderProgram;
+  readonly #resourceDependencyCacheMap = new Map<string, Set<string>>();
+  readonly #sourceFileCacheMap = new Map<string, ts.SourceFile>();
+  readonly #emittedFilesCacheMap = new Map<string, {
+    outRelPath?: string;
+    text: string;
+  }[]>();
 
-  //-- for ng
-  private readonly _isForAngular: boolean;
-  private _ngProgram?: NgtscProgram;
-  private readonly _styleDepsCache = new Map<string, Set<string>>();
-  private _markedChanges: string[] = [];*/
+  readonly #stylesheetBundler: ComponentStylesheetBundler | undefined;
+  readonly #compilerHost: ts.CompilerHost | AngularCompilerHost;
 
-  program?: ts.Program;
+  #ngProgram: NgtscProgram | undefined;
+  #program: ts.Program | undefined;
+  #builder: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
 
-  readonly #compiler: SdTsCompiler2;
+  readonly #modifiedFileSet = new Set<string>();
 
-  readonly #pkgPath: string;
+  readonly #watchFileSet = new Set<string>();
+  readonly #stylesheetResultMap = new Map<string, IStylesheetResult>();
+  readonly #affectedFileSet = new Set<string>();
 
-  /*public get program(): ts.Program {
-    if (!this._program) {
-      throw new Error("TS 프로그램 NULL");
-    }
-    return this._program;
-  }*/
+  readonly #pkgPath: string;
+  readonly #distPath: string;
+  readonly #globalStyleFilePath?: string;
 
-  public constructor(pkgPath: string, dev: boolean) {
+  constructor(pkgPath: string,
+              additionalOptions: CompilerOptions,
+              isDevMode: boolean,
+              globalStyleFilePath?: string) {
     this.#pkgPath = pkgPath;
-    this.#compiler = new SdTsCompiler2(
-      pkgPath,
-      {declaration: true},
-      dev,
-      path.resolve(pkgPath, "src/styles.scss")
-    );
-  }
+    this.#globalStyleFilePath = globalStyleFilePath != null ? path.normalize(globalStyleFilePath) : undefined;
 
-  public markChanges(modifiedFileSet: Set<string>): void {
-    this.#compiler.invalidate(modifiedFileSet);
-  }
+    //-- isForAngular / parsedTsConfig
 
-  public async buildAsync(): Promise<{
-    watchFileSet: Set<string>;
-    affectedFileSet: Set<string>;
-    results: ISdCliPackageBuildResult[];
-  }> {
-    const buildResult = await this.#compiler.buildAsync();
-    this.program = buildResult.program;
-
-    for (const affectedFilePath of buildResult.affectedFileSet) {
-      const emittedFiles = buildResult.emittedFilesCacheMap.get(affectedFilePath) ?? [];
-      for (const emittedFile of emittedFiles) {
-        if (emittedFile.outRelPath != null) {
-          const distPath = path.resolve(this.#pkgPath, "dist", emittedFile.outRelPath);
-          if (PathUtil.isChildPath(distPath, path.resolve(this.#pkgPath, "dist"))) {
-            await FsUtil.writeFileAsync(distPath, emittedFile.text);
-          }
-        }
+    const tsconfigPath = path.resolve(pkgPath, "tsconfig.json");
+    const tsconfig = FsUtil.readJson(tsconfigPath);
+    this.#isForAngular = Boolean(tsconfig.angularCompilerOptions);
+    this.#parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, pkgPath, {
+      ...tsconfig.angularCompilerOptions,
+      ...additionalOptions
+    });
+
+    this.#distPath = this.#parsedTsconfig.options.outDir ?? path.resolve(pkgPath, "dist");
+
+    //-- compilerHost
+
+    this.#compilerHost = ts.createIncrementalCompilerHost(this.#parsedTsconfig.options);
+
+    const baseGetSourceFile = this.#compilerHost.getSourceFile;
+    this.#compilerHost.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile, ...args) => {
+      if (!shouldCreateNewSourceFile && this.#sourceFileCacheMap.has(path.normalize(fileName))) {
+        return this.#sourceFileCacheMap.get(path.normalize(fileName));
       }
 
-      const globalStylesheetResult = buildResult.stylesheetResultMap.get(affectedFilePath);
-      if (globalStylesheetResult) {
-        for (const outputFile of globalStylesheetResult.outputFiles) {
-          const distPath = path.resolve(this.#pkgPath, "dist", path.relative(this.#pkgPath, outputFile.path));
-          if (PathUtil.isChildPath(distPath, path.resolve(this.#pkgPath, "dist"))) {
-            await FsUtil.writeFileAsync(distPath, outputFile.text);
+      const sf = baseGetSourceFile.call(
+        this.#compilerHost,
+        fileName,
+        languageVersionOrOptions,
+        onError,
+        true,
+        ...args,
+      );
+
+      if (sf) {
+        this.#sourceFileCacheMap.set(path.normalize(fileName), sf);
+      }
+      else {
+        this.#sourceFileCacheMap.delete(path.normalize(fileName));
+      }
+
+      return sf;
+    };
+
+    if (this.#isForAngular) {
+      //-- stylesheetBundler
+
+      const browserTarget = transformSupportedBrowsersToTargets(browserslist("defaults and fully supports es6-module"));
+      this.#stylesheetBundler = new ComponentStylesheetBundler(
+        {
+          workspaceRoot: pkgPath,
+          optimization: !isDevMode,
+          inlineFonts: true,
+          preserveSymlinks: false,
+          sourcemap: 'inline', //conf.dev ? 'inline' : false,
+          outputNames: {bundles: '[name]', media: 'media/[name]'},
+          includePaths: [],
+          externalDependencies: [],
+          target: browserTarget,
+          tailwindConfiguration: undefined,
+          cacheOptions: {
+            enabled: true,
+            path: ".cache/angular",
+            basePath: ".cache"
           }
+        },
+        isDevMode
+      );
+
+      //-- compilerHost
+
+      (this.#compilerHost as AngularCompilerHost).readResource = (fileName: string) => {
+        return this.#compilerHost.readFile(fileName) ?? "";
+      };
+
+      (this.#compilerHost as AngularCompilerHost).transformResource = async (data: string, context: {
+        type: string,
+        containingFile: string,
+        resourceFile: string | null
+      }) => {
+        if (context.type !== "style") {
+          return null;
+        }
+
+        const contents = await this.#bundleStylesheetAsync(data, context.containingFile, context.resourceFile);
+
+        return StringUtil.isNullOrEmpty(contents) ? null : {content: contents};
+      };
+
+      (this.#compilerHost as AngularCompilerHost).getModifiedResourceFiles = () => {
+        return this.#modifiedFileSet;
+      };
+    }
+  }
+
+  async #bundleStylesheetAsync(data: string, containingFile: string, resourceFile: string | null = null) {
+    const stylesheetResult = resourceFile != null
+      ? await this.#stylesheetBundler!.bundleFile(resourceFile)
+      : await this.#stylesheetBundler!.bundleInline(
+        data,
+        containingFile,
+        "scss",
+      );
+
+    this.#watchFileSet.add(path.normalize(containingFile));
+    if (resourceFile != null) {
+      this.#watchFileSet.add(path.normalize(resourceFile));
+    }
+
+    if (stylesheetResult.referencedFiles) {
+      for (const referencedFile of stylesheetResult.referencedFiles) {
+        const referencingMapValSet = this.#resourceDependencyCacheMap.getOrCreate(path.normalize(referencedFile), new Set<string>());
+        referencingMapValSet.add(path.normalize(containingFile));
+        if (resourceFile != null) {
+          referencingMapValSet.add(path.normalize(resourceFile));
         }
       }
+
+      this.#watchFileSet.adds(...Array.from(stylesheetResult.referencedFiles.values()).map(item => path.normalize(item)));
     }
 
-    /*const markedChanges = this._markedChanges;
-    this._markedChanges = [];
+    this.#stylesheetResultMap.set(path.normalize(resourceFile ?? containingFile), {
+      outputFiles: stylesheetResult.outputFiles ?? [],
+      metafile: stylesheetResult.metafile,
+      errors: stylesheetResult.errors,
+      warnings: stylesheetResult.warnings
+    });
 
-    const distPath = path.resolve(this._opt.pkgPath, "dist");
-    const srcFilePaths = await FsUtil.globAsync(path.resolve(this._opt.pkgPath, "src/!**!/!*.{ts,tsx}"));
-    const srcFilePathSet = new Set<string>(srcFilePaths);
+    return stylesheetResult.contents;
+  }
 
-    if (this._isForAngular) {
-      this._ngProgram = new NgtscProgram(
-        srcFilePaths,
-        this._parsedTsConfig.options,
-        this._compilerHost,
-        this._ngProgram
-      );
-      this._program = this._ngProgram.getTsProgram();
+  invalidate(modifiedFileSet: Set<string>) {
+    this.#stylesheetBundler?.invalidate(modifiedFileSet);
 
-      const baseGetSourceFiles = this._program.getSourceFiles;
-      this._program.getSourceFiles = function (...parameters) {
-        const files: readonly (ts.SourceFile & { version?: string })[] = baseGetSourceFiles(...parameters);
+    for (const modifiedFile of modifiedFileSet) {
+      this.#stylesheetResultMap.delete(path.normalize(modifiedFile));
+      this.#sourceFileCacheMap.delete(path.normalize(modifiedFile));
+      this.#emittedFilesCacheMap.delete(path.normalize(modifiedFile));
 
-        for (const file of files) {
-          if (file.version === undefined) {
-            file.version = createHash("sha256").update(file.text).digest("hex");
-          }
+      if (this.#resourceDependencyCacheMap.has(path.normalize(modifiedFile))) {
+        for (const referencingFile of this.#resourceDependencyCacheMap.get(path.normalize(modifiedFile))!) {
+          this.#stylesheetResultMap.delete(path.normalize(referencingFile));
+          this.#sourceFileCacheMap.delete(path.normalize(referencingFile));
+          this.#emittedFilesCacheMap.delete(path.normalize(referencingFile));
         }
+      }
+    }
 
-        return files;
-      };
+    this.#modifiedFileSet.adds(...modifiedFileSet);
+  }
 
-      this._builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
-        this._program,
-        this._compilerHost,
-        this._builder
+  async buildAsync(): Promise<ISdTsCompiler2Result> {
+    this.#resourceDependencyCacheMap.clear();
+    this.#watchFileSet.clear();
+    this.#stylesheetResultMap.clear();
+    this.#affectedFileSet.clear();
+
+    if (this.#isForAngular) {
+      this.#ngProgram = new NgtscProgram(
+        this.#parsedTsconfig.fileNames,
+        this.#parsedTsconfig.options,
+        this.#compilerHost,
+        this.#ngProgram
       );
+      this.#program = this.#ngProgram.getTsProgram();
     }
     else {
-      /!*this._program = ts.createProgram(
-        srcFilePaths,
-        this._parsedTsConfig.options,
-        this._compilerHost,
-        this._program
-      );*!/
-
-      this._builder = ts.createIncrementalProgram({
-        rootNames: srcFilePaths,
-        host: this._compilerHost,
-        options: this._parsedTsConfig.options,
-        createProgram: ts.createEmitAndSemanticDiagnosticsBuilderProgram
-      });
-      this._program = this._builder.getProgram();
+      // noinspection UnnecessaryLocalVariableJS
+      this.#program = ts.createProgram(
+        this.#parsedTsconfig.fileNames,
+        this.#parsedTsconfig.options,
+        this.#compilerHost,
+        this.#program
+      );
     }
 
-    const diagnostics: ts.Diagnostic[] = [];
-    const affectedFileSet = new Set<string>();
+    const baseGetSourceFiles = this.#program.getSourceFiles;
+    this.#program.getSourceFiles = function (...parameters) {
+      const files: readonly (ts.SourceFile & { version?: string })[] = baseGetSourceFiles(...parameters);
 
-    if (this._ngProgram) {
-      diagnostics.push(...this._ngProgram.compiler.getOptionDiagnostics());
-    }
+      for (const file of files) {
+        if (file.version === undefined) {
+          file.version = createHash("sha256").update(file.text).digest("hex");
+        }
+      }
 
-    diagnostics.push(
-      ...this._builder.getOptionsDiagnostics(),
-      ...this._builder.getGlobalDiagnostics()
+      return files;
+    };
+
+    this.#builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
+      this.#program,
+      this.#compilerHost,
+      this.#builder
     );
 
-    if (this._ngProgram) {
-      await this._ngProgram.compiler.analyzeAsync();
+    if (this.#ngProgram) {
+      await this.#ngProgram.compiler.analyzeAsync();
     }
 
-    this._logger.debug(`[${path.basename(this._opt.pkgPath)}] 영향받는 파일 확인중...`);
+    //-- affectedFilePathSet
+
     while (true) {
-      let affectedSourceFile: ts.SourceFile | undefined;
-
-      const semanticResult = this._builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
-        //-- ngtypecheck의 org파일 포함 (ngtypecheck 파일는 무시)
-        if (this._ngProgram?.compiler.ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith(".ngtypecheck.ts")) {
-          const orgFileName = sourceFile.fileName.slice(0, -15) + ".ts";
-          const orgSourceFile = this._builder!.getSourceFile(orgFileName);
-          if (orgSourceFile) {
-            affectedSourceFile = orgSourceFile;
+      const result = this.#builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+        if (
+          this.#ngProgram
+          && this.#ngProgram.compiler.ignoreForDiagnostics.has(sourceFile)
+          && sourceFile.fileName.endsWith('.ngtypecheck.ts')
+        ) {
+          const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';
+          const originalSourceFile = this.#sourceFileCacheMap.get(originalFilename);
+          if (originalSourceFile) {
+            this.#affectedFileSet.add(path.normalize(originalSourceFile.fileName));
           }
-          return true;
-        }
 
-        //-- 소스폴더 파일 포함
-        else if (srcFilePathSet.has(path.resolve(sourceFile.fileName))) {
-          affectedSourceFile = sourceFile;
-          return false;
-        }
-
-        //-- 나머지 무시
-        else {
           return true;
         }
+
+        return false;
       });
-      if (!semanticResult || !affectedSourceFile) break;
-      diagnostics.push(...semanticResult.result);
 
-      if ("fileName" in affectedSourceFile) {
-        affectedFileSet.add(path.normalize(affectedSourceFile.fileName));
+      if (!result) {
+        break;
       }
-    }
 
-    if (this._isForAngular) {
-      for (const markedChange of markedChanges) {
-        const depsSet = this._styleDepsCache.get(markedChange);
-        if (depsSet) {
-          affectedFileSet.adds(...depsSet);
-        }
-      }
+      this.#affectedFileSet.add(path.normalize((result.affected as ts.SourceFile).fileName));
     }
 
-    const globalStyleFilePath = path.resolve(this._opt.pkgPath, "src/styles.scss");
-    if (this._opt.globalStyle && FsUtil.exists(globalStyleFilePath) && markedChanges.includes(globalStyleFilePath)) {
-      affectedFileSet.add(globalStyleFilePath);
-    }
+    // Deps -> refMap
 
-    this._logger.debug(`[${path.basename(this._opt.pkgPath)}] 영향받는 파일 ${this._opt.emit ? "EMIT" : "CHECK"}...`);
-
-    for (const affectedFilePath of affectedFileSet) {
-      if (this._opt.globalStyle && affectedFilePath === globalStyleFilePath) {
-        try {
-          const content = await FsUtil.readFileAsync(affectedFilePath);
-          const scssResult = await sass.compileStringAsync(content, {
-            url: new URL(affectedFilePath),
-            importer: {
-              findFileUrl: (url) => pathToFileURL(url)
-            },
-            logger: sass.Logger.silent
-          });
+    this.#builder.getSourceFiles().filter(sf => !this.#ngProgram || !this.#ngProgram.compiler.ignoreForEmit.has(sf))
+      .forEach(sf => {
+        this.#watchFileSet.add(path.normalize(sf.fileName));
 
-          const deps = scssResult.loadedUrls.slice(1).map((item) => path.resolve(fileURLToPath(item.href)));
+        if (this.#ngProgram) {
+          const deps = this.#ngProgram.compiler.getResourceDependencies(sf);
           for (const dep of deps) {
-            const depCache = this._styleDepsCache.getOrCreate(dep, new Set<string>());
-            depCache.add(affectedFilePath);
-          }
-
-          if (this._opt.emit) {
-            const outFilePath = path.resolve(this._opt.pkgPath, path.basename(affectedFilePath, path.extname(affectedFilePath)) + ".css");
+            const ref = this.#resourceDependencyCacheMap.getOrCreate(path.normalize(dep), new Set<string>());
+            ref.add(path.normalize(sf.fileName));
 
-            this._writeFile(outFilePath, scssResult.css.toString());
+            this.#watchFileSet.add(path.normalize(dep));
           }
         }
-        catch (err) {
-          this._logger.error(err);
-        }
+      });
+
+    //-- diagnostics
+
+    const diagnostics: ts.Diagnostic[] = [];
+
+    diagnostics.push(
+      ...this.#builder.getConfigFileParsingDiagnostics(),
+      ...this.#builder.getOptionsDiagnostics(),
+      ...this.#builder.getGlobalDiagnostics()
+    );
+
+    if (this.#ngProgram) {
+      diagnostics.push(...this.#ngProgram.compiler.getOptionDiagnostics());
+    }
+
+    for (const affectedFile of this.#affectedFileSet) {
+      const affectedSourceFile = this.#sourceFileCacheMap.get(affectedFile);
+      if (!affectedSourceFile || (this.#ngProgram && this.#ngProgram.compiler.ignoreForDiagnostics.has(affectedSourceFile))) {
+        continue;
       }
-      else {
-        const affectedSourceFile = this._builder.getSourceFile(affectedFilePath);
-        if (!affectedSourceFile) continue;
-
-        const emitResult = this._builder.emit(affectedSourceFile,
-          (filePath, data) => {
-            let realFilePath = filePath;
-            let realData = data;
-            if (PathUtil.isChildPath(realFilePath, path.resolve(distPath, path.basename(this._opt.pkgPath), "src"))) {
-              realFilePath = path.resolve(distPath, path.relative(path.resolve(distPath, path.basename(this._opt.pkgPath), "src"), realFilePath));
-
-              if (filePath.endsWith(".js.map")) {
-                const sourceMapContents = JSON.parse(realData);
-                // remove "../../"
-                sourceMapContents.sources[0] = sourceMapContents.sources[0].slice(6);
-                realData = JSON.stringify(sourceMapContents);
-              }
-            }
 
-            this._ngProgram?.compiler.incrementalCompilation.recordSuccessfulEmit(affectedSourceFile);
-            this._writeFile(realFilePath, realData);
-          },
-          undefined,
-          !this._opt.emit,
-          {...this._ngProgram?.compiler.prepareEmit().transformers ?? {}}
+      diagnostics.push(
+        ...this.#builder.getSyntacticDiagnostics(affectedSourceFile),
+        ...this.#builder.getSemanticDiagnostics(affectedSourceFile)
+      );
+
+      if (this.#ngProgram) {
+        if (affectedSourceFile.isDeclarationFile) {
+          continue;
+        }
+
+        diagnostics.push(
+          ...this.#ngProgram.compiler.getDiagnosticsForFile(affectedSourceFile, OptimizeFor.WholeProgram),
         );
+      }
+    }
+
+    //-- prepare emit cache
+
+    while (true) {
+      const affectedFileResult = this.#builder.emitNextAffectedFile((fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
+        if (!sourceFiles || sourceFiles.length === 0) {
+          this.#compilerHost.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
+          return;
+        }
 
-        diagnostics.push(...emitResult.diagnostics);
+        const sourceFile = ts.getOriginalNode(sourceFiles[0], ts.isSourceFile);
 
-        diagnostics.push(...this._builder.getSyntacticDiagnostics(affectedSourceFile));
+        if (this.#ngProgram) {
+          if (this.#ngProgram.compiler.ignoreForEmit.has(sourceFile)) {
+            return;
+          }
+          this.#ngProgram.compiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
+        }
 
-        if (
-          this._ngProgram &&
-          !affectedSourceFile.isDeclarationFile &&
-          !this._ngProgram.compiler.ignoreForEmit.has(affectedSourceFile) &&
-          !this._ngProgram.compiler.incrementalCompilation.safeToSkipEmit(affectedSourceFile)
-        ) {
-          diagnostics.push(
-            ...this._ngProgram.compiler.getDiagnosticsForFile(affectedSourceFile, OptimizeFor.WholeProgram)
-          );
+        const emittedFiles = this.#emittedFilesCacheMap.getOrCreate(path.normalize(sourceFile.fileName), []);
+        if (PathUtil.isChildPath(sourceFile.fileName, this.#pkgPath)) {
+          let realFilePath = fileName;
+          let realText = text;
+          if (PathUtil.isChildPath(realFilePath, path.resolve(this.#distPath, path.basename(this.#pkgPath), "src"))) {
+            realFilePath = path.resolve(this.#distPath, path.relative(path.resolve(this.#distPath, path.basename(this.#pkgPath), "src"), realFilePath));
+
+            if (fileName.endsWith(".js.map")) {
+              const sourceMapContents = JSON.parse(realText);
+              // remove "../../"
+              sourceMapContents.sources[0] = sourceMapContents.sources[0].slice(6);
+              realText = JSON.stringify(sourceMapContents);
+            }
+          }
+
+          emittedFiles.push({
+            outRelPath: path.relative(this.#distPath, realFilePath),
+            text: realText
+          });
         }
+        else {
+          emittedFiles.push({text});
+        }
+      }, undefined, undefined, this.#ngProgram?.compiler.prepareEmit().transformers);
+
+      if (!affectedFileResult) {
+        break;
       }
+
+      diagnostics.push(...affectedFileResult.result.diagnostics);
     }
 
-    this._logger.debug(`[${path.basename(this._opt.pkgPath)}] 영향받는 파일 ${this._opt.emit ? "EMIT" : "CHECK"} 완료`, affectedFileSet);
+    //-- global style
+    if (
+      this.#globalStyleFilePath != null
+      && !this.#stylesheetResultMap.has(this.#globalStyleFilePath)
+      && FsUtil.exists(this.#globalStyleFilePath)
+    ) {
+      const data = await FsUtil.readFileAsync(this.#globalStyleFilePath);
+      const contents = await this.#bundleStylesheetAsync(data, this.#globalStyleFilePath, this.#globalStyleFilePath);
+      const emittedFiles = this.#emittedFilesCacheMap.getOrCreate(path.normalize(this.#globalStyleFilePath), []);
+      emittedFiles.push({
+        outRelPath: path.relative(path.resolve(this.#pkgPath, "src"), this.#globalStyleFilePath).replace(/\.scss$/, ".css"),
+        text: contents
+      });
+      this.#affectedFileSet.add(this.#globalStyleFilePath);
+    }
+
+    //-- init
+
+    this.#modifiedFileSet.clear();
 
-    const buildResults = diagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item, this._opt.emit ? "build" : "check"));*/
+    //-- result
 
     return {
-      watchFileSet: buildResult.watchFileSet,
-      affectedFileSet: buildResult.affectedFileSet,
-      results: [
-        ...buildResult.typescriptDiagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item, "build")),
-        ...Array.from(buildResult.stylesheetResultMap.values()).mapMany(item => item.errors!)
-          .map(err => SdCliBuildResultUtil.convertFromEsbuildResult(err, "build", "error")),
-        /*...Array.from(buildResult.stylesheetResultMap.values()).mapMany(item => item.warnings!)
-          .map(warn => SdCliBuildResultUtil.convertFromEsbuildResult(warn, "build", "warning"))*/
-      ]
+      program: this.#program,
+      typescriptDiagnostics: diagnostics,
+      stylesheetResultMap: this.#stylesheetResultMap,
+      emittedFilesCacheMap: this.#emittedFilesCacheMap,
+      watchFileSet: this.#watchFileSet,
+      affectedFileSet: this.#affectedFileSet
     };
   }
 }
+
+export interface ISdTsCompiler2Result {
+  program: ts.Program,
+  typescriptDiagnostics: ts.Diagnostic[],
+  stylesheetResultMap: Map<string, IStylesheetResult>,
+  emittedFilesCacheMap: Map<string, {
+    outRelPath?: string;
+    text: string;
+  }[]>,
+  watchFileSet: Set<string>,
+  affectedFileSet: Set<string>
+}
+
+interface IStylesheetResult {
+  outputFiles: esbuild.OutputFile[];
+  metafile?: esbuild.Metafile;
+  errors?: esbuild.PartialMessage[];
+  warnings?: esbuild.PartialMessage[];
+}