@simplysm/sd-cli 11.1.45 → 11.1.46

package/src/build-tools/SdTsCompiler.ts

@@ -1,15 +1,12 @@
-import path from "path";
-import ts from "typescript";
 import {SdCliBuildResultUtil} from "../utils/SdCliBuildResultUtil";
-import {FsUtil, Logger, PathUtil} from "@simplysm/sd-core-node";
-import {ISdCliPackageBuildResult, ITsConfig} from "../commons";
-import {NgtscProgram, OptimizeFor} from "@angular/compiler-cli";
-import {createHash} from "crypto";
-import {fileURLToPath, pathToFileURL} from "url";
-import * as sass from "sass";
+import {ISdCliPackageBuildResult} from "../commons";
+import {SdTsCompiler2} from "../build-tools2/SdTsCompiler2";
+import ts from "typescript";
+import path from "path";
+import {FsUtil, PathUtil} from "@simplysm/sd-core-node";
 
 export class SdTsCompiler {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
+  /*private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
 
   private readonly _parsedTsConfig: ts.ParsedCommandLine;
   private readonly _writeFileCache = new Map<string, string>();
@@ -21,81 +18,33 @@ export class SdTsCompiler {
   private readonly _isForAngular: boolean;
   private _ngProgram?: NgtscProgram;
   private readonly _styleDepsCache = new Map<string, Set<string>>();
-  private _markedChanges: string[] = [];
+  private _markedChanges: string[] = [];*/
+
+  program?: ts.Program;
+
+  readonly #compiler: SdTsCompiler2;
 
-  public get program(): ts.Program {
+  readonly #pkgPath: string;
+
+  /*public get program(): ts.Program {
     if (!this._program) {
       throw new Error("TS 프로그램 NULL");
     }
     return this._program;
-  }
-
-  public constructor(private readonly _opt: {
-    pkgPath: string,
-    emit: boolean;
-    emitDts: boolean;
-    globalStyle: boolean;
-  }) {
-    //-- tsconfig
-    const tsConfigFilePath = path.resolve(_opt.pkgPath, "tsconfig.json");
-    const tsConfig = FsUtil.readJson(tsConfigFilePath) as ITsConfig;
-    this._parsedTsConfig = ts.parseJsonConfigFileContent(
-      tsConfig,
-      ts.sys,
-      _opt.pkgPath,
-      {
-        ...tsConfig.angularCompilerOptions ?? {},
-        ..._opt.emitDts !== undefined ? {declaration: _opt.emitDts} : {}
-      }
+  }*/
+
+  public constructor(pkgPath: string, dev: boolean) {
+    this.#pkgPath = pkgPath;
+    this.#compiler = new SdTsCompiler2(
+      pkgPath,
+      {declaration: true},
+      dev,
+      path.resolve(pkgPath, "src/styles.scss")
     );
-
-    //-- vars
-    this._isForAngular = Boolean(tsConfig.angularCompilerOptions);
-
-    //-- host
-    this._compilerHost = ts.createIncrementalCompilerHost(this._parsedTsConfig.options);
-    if (tsConfig.angularCompilerOptions) {
-      this._compilerHost["readResource"] = (fileName: string) => {
-        return this._compilerHost.readFile(fileName);
-      };
-
-      this._compilerHost["transformResource"] = async (data: string, context: {
-        type: string,
-        containingFile: string,
-        resourceFile: any
-      }) => {
-        if (context.resourceFile != null || context.type !== "style") {
-          return null;
-        }
-
-        try {
-          const scssResult = await sass.compileStringAsync(data, {
-            url: new URL((context.containingFile as string) + ".scss"),
-            importer: {
-              findFileUrl: (url) => pathToFileURL(url)
-            },
-            logger: sass.Logger.silent
-          });
-
-          const styleContent = scssResult.css.toString();
-
-          const deps = scssResult.loadedUrls.slice(1).map((item) => path.resolve(fileURLToPath(item.href)));
-          for (const dep of deps) {
-            const depCache = this._styleDepsCache.getOrCreate(dep, new Set<string>());
-            depCache.add(path.resolve(context.containingFile));
-          }
-          return {content: styleContent};
-        }
-        catch (err) {
-          this._logger.error("scss 파싱 에러", err);
-          return null;
-        }
-      };
-    }
   }
 
-  public markChanges(changes: string[]): void {
-    this._markedChanges.push(...changes);
+  public markChanges(modifiedFileSet: Set<string>): void {
+    this.#compiler.invalidate(modifiedFileSet);
   }
 
   public async buildAsync(): Promise<{
@@ -103,11 +52,36 @@ export class SdTsCompiler {
     affectedFileSet: Set<string>;
     results: ISdCliPackageBuildResult[];
   }> {
-    const markedChanges = this._markedChanges;
+    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 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 markedChanges = this._markedChanges;
     this._markedChanges = [];
 
     const distPath = path.resolve(this._opt.pkgPath, "dist");
-    const srcFilePaths = await FsUtil.globAsync(path.resolve(this._opt.pkgPath, "src/**/*.{ts,tsx}"));
+    const srcFilePaths = await FsUtil.globAsync(path.resolve(this._opt.pkgPath, "src/!**!/!*.{ts,tsx}"));
     const srcFilePathSet = new Set<string>(srcFilePaths);
 
     if (this._isForAngular) {
@@ -139,12 +113,12 @@ export class SdTsCompiler {
       );
     }
     else {
-      /*this._program = ts.createProgram(
+      /!*this._program = ts.createProgram(
         srcFilePaths,
         this._parsedTsConfig.options,
         this._compilerHost,
         this._program
-      );*/
+      );*!/
 
       this._builder = ts.createIncrementalProgram({
         rootNames: srcFilePaths,
@@ -295,22 +269,18 @@ export class SdTsCompiler {
 
     this._logger.debug(`[${path.basename(this._opt.pkgPath)}] 영향받는 파일 ${this._opt.emit ? "EMIT" : "CHECK"} 완료`, affectedFileSet);
 
-    const buildResults = diagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item, this._opt.emit ? "build" : "check"));
+    const buildResults = diagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item, this._opt.emit ? "build" : "check"));*/
 
     return {
-      watchFileSet: new Set([
-        ...Array.from(this._styleDepsCache.keys()),
-        ...this._builder.getSourceFiles().map(item => path.normalize(item.fileName))
-      ]),
-      affectedFileSet: affectedFileSet,
-      results: buildResults
+      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"))*/
+      ]
     };
   }
-
-  private _writeFile(filePath: string, data: string): void {
-    if (this._writeFileCache.get(filePath) !== data) {
-      this._compilerHost.writeFile(filePath, data, false);
-    }
-    this._writeFileCache.set(filePath, data);
-  }
 }

package/src/build-tools2/SdTsCompiler2.ts

@@ -0,0 +1,427 @@
+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 SdTsCompiler2 {
+  readonly #parsedTsconfig: ts.ParsedCommandLine;
+  readonly #isForAngular: boolean;
+
+  readonly #resourceDependencyCacheMap = new Map<string, Set<string>>();
+  readonly #sourceFileCacheMap = new Map<string, ts.SourceFile>();
+  readonly #emittedFilesCacheMap = new Map<string, {
+    outRelPath?: string;
+    text: string;
+  }[]>();
+
+  readonly #stylesheetBundler: ComponentStylesheetBundler | undefined;
+  readonly #compilerHost: ts.CompilerHost | AngularCompilerHost;
+
+  #ngProgram: NgtscProgram | undefined;
+  #program: ts.Program | undefined;
+  #builder: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
+
+  readonly #modifiedFileSet = new Set<string>();
+
+  readonly #watchFileSet = new Set<string>();
+  readonly #stylesheetResultMap = new Map<string, IStylesheetResult>();
+  readonly #affectedFileSet = new Set<string>();
+
+  readonly #pkgPath: string;
+  readonly #distPath: string;
+  readonly #globalStyleFilePath?: string;
+
+  constructor(pkgPath: string,
+              additionalOptions: CompilerOptions,
+              isDevMode: boolean,
+              globalStyleFilePath?: string) {
+    this.#pkgPath = pkgPath;
+    this.#globalStyleFilePath = globalStyleFilePath != null ? path.normalize(globalStyleFilePath) : undefined;
+
+    //-- isForAngular / parsedTsConfig
+
+    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 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)));
+    }
+
+    this.#stylesheetResultMap.set(path.normalize(resourceFile ?? containingFile), {
+      outputFiles: stylesheetResult.outputFiles ?? [],
+      metafile: stylesheetResult.metafile,
+      errors: stylesheetResult.errors,
+      warnings: stylesheetResult.warnings
+    });
+
+    return stylesheetResult.contents;
+  }
+
+  invalidate(modifiedFileSet: Set<string>) {
+    this.#stylesheetBundler?.invalidate(modifiedFileSet);
+
+    for (const modifiedFile of modifiedFileSet) {
+      this.#stylesheetResultMap.delete(path.normalize(modifiedFile));
+      this.#sourceFileCacheMap.delete(path.normalize(modifiedFile));
+      this.#emittedFilesCacheMap.delete(path.normalize(modifiedFile));
+
+      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));
+        }
+      }
+    }
+
+    this.#modifiedFileSet.adds(...modifiedFileSet);
+  }
+
+  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 {
+      // noinspection UnnecessaryLocalVariableJS
+      this.#program = ts.createProgram(
+        this.#parsedTsconfig.fileNames,
+        this.#parsedTsconfig.options,
+        this.#compilerHost,
+        this.#program
+      );
+    }
+
+    const baseGetSourceFiles = this.#program.getSourceFiles;
+    this.#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;
+    };
+
+    this.#builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
+      this.#program,
+      this.#compilerHost,
+      this.#builder
+    );
+
+    if (this.#ngProgram) {
+      await this.#ngProgram.compiler.analyzeAsync();
+    }
+
+    //-- affectedFilePathSet
+
+    while (true) {
+      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;
+        }
+
+        return false;
+      });
+
+      if (!result) {
+        break;
+      }
+
+      this.#affectedFileSet.add(path.normalize((result.affected as ts.SourceFile).fileName));
+    }
+
+    // Deps -> refMap
+
+    this.#builder.getSourceFiles().filter(sf => !this.#ngProgram || !this.#ngProgram.compiler.ignoreForEmit.has(sf))
+      .forEach(sf => {
+        this.#watchFileSet.add(path.normalize(sf.fileName));
+
+        if (this.#ngProgram) {
+          const deps = this.#ngProgram.compiler.getResourceDependencies(sf);
+          for (const dep of deps) {
+            const ref = this.#resourceDependencyCacheMap.getOrCreate(path.normalize(dep), new Set<string>());
+            ref.add(path.normalize(sf.fileName));
+
+            this.#watchFileSet.add(path.normalize(dep));
+          }
+        }
+      });
+
+    //-- 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;
+      }
+
+      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;
+        }
+
+        const sourceFile = ts.getOriginalNode(sourceFiles[0], ts.isSourceFile);
+
+        if (this.#ngProgram) {
+          if (this.#ngProgram.compiler.ignoreForEmit.has(sourceFile)) {
+            return;
+          }
+          this.#ngProgram.compiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
+        }
+
+        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);
+    }
+
+    //-- 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();
+
+    //-- result
+
+    return {
+      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[];
+}

package/src/builders/SdCliTsLibBuilder.ts

@@ -35,7 +35,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
       await SdCliIndexFileGenerator.runAsync(this._pkgPath, this._pkgConf.polyfills);
     }
 
-    const result = await this._runAsync();
+    const result = await this._runAsync(false);
     return {
       affectedFilePaths: Array.from(result.affectedFileSet),
       buildResults: result.buildResults
@@ -53,7 +53,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
       await SdCliIndexFileGenerator.watchAsync(this._pkgPath, this._pkgConf.polyfills);
     }
 
-    const result = await this._runAsync();
+    const result = await this._runAsync(true);
     this.emit("complete", {
       affectedFilePaths: Array.from(result.affectedFileSet),
       buildResults: result.buildResults
@@ -64,12 +64,12 @@ export class SdCliTsLibBuilder extends EventEmitter {
     const watcher = SdFsWatcher
       .watch(Array.from(result.watchFileSet))
       .onChange({delay: 100,}, (changeInfos) => {
-        this._builder!.markChanges(changeInfos.map((item) => item.path));
+        this._builder!.markChanges(new Set(changeInfos.map((item) => item.path)));
 
         fnQ.runLast(async () => {
           this.emit("change");
 
-          const watchResult = await this._runAsync();
+          const watchResult = await this._runAsync(true);
           this.emit("complete", {
             affectedFilePaths: Array.from(watchResult.affectedFileSet),
             buildResults: watchResult.buildResults
@@ -80,18 +80,13 @@ export class SdCliTsLibBuilder extends EventEmitter {
       });
   }
 
-  private async _runAsync(): Promise<{
+  private async _runAsync(dev: boolean): Promise<{
     watchFileSet: Set<string>;
     affectedFileSet: Set<string>;
     buildResults: ISdCliPackageBuildResult[];
   }> {
     this._debug(`BUILD & CHECK...`);
-    this._builder = this._builder ?? new SdTsCompiler({
-      pkgPath: this._pkgPath,
-      emit: true,
-      emitDts: true,
-      globalStyle: true
-    });
+    this._builder = this._builder ?? new SdTsCompiler(this._pkgPath, dev);
     const buildResult = await this._builder.buildAsync();
 
     this._debug("LINT...");