@simplysm/sd-cli 12.5.22 → 12.5.24

package/src/ts-builder/SdTsCompiler.ts

@@ -52,6 +52,8 @@ export class SdTsCompiler {
 
   readonly #lintWorker = new SdWorker<TSdLintWorkerType>(import.meta.resolve("../workers/lint-worker"));
 
+  #perf!: SdCliPerformanceTimer;
+
   constructor(opt: SdTsCompilerOptions) {
     this.#pkgPath = opt.pkgPath;
     this.#globalStyleFilePath = opt.globalStyleFilePath;
@@ -159,7 +161,7 @@ export class SdTsCompiler {
       };
 
       (this.#compilerHost as AngularCompilerHost).getModifiedResourceFiles = () => {
-        return this.#modifiedFileSet;
+        return new Set(Array.from(this.#modifiedFileSet).map((item) => PathUtil.posix(item)));
       };
     }
   }
@@ -169,73 +171,98 @@ export class SdTsCompiler {
     // resourceFile: 외부 리소스 파일 (styleUrls로 입력하지 않고 styles에 직접 입력한 경우 null)
     // referencedFiles: import한 외부 scss 파일 혹은 woff파일등 외부 파일
 
-    this.#debug(`스타일시트 번들링...(${containingFile}, ${resourceFile})`);
+    // this.#debug(`bundle stylesheet...(${containingFile}, ${resourceFile})`);
 
-    const stylesheetResult =
-      resourceFile != null
-        ? await this.#stylesheetBundler!.bundleFile(resourceFile)
-        : await this.#stylesheetBundler!.bundleInline(data, containingFile, "scss");
+    return await this.#perf.run("bundle style", async () => {
+      const stylesheetResult =
+        resourceFile != null
+          ? await this.#stylesheetBundler!.bundleFile(resourceFile)
+          : await this.#stylesheetBundler!.bundleInline(data, containingFile, "scss");
 
-    if (stylesheetResult.referencedFiles) {
-      for (const referencedFile of stylesheetResult.referencedFiles) {
-        const depCacheSet = this.#resourceDependencyCacheMap.getOrCreate(
-          PathUtil.norm(referencedFile),
-          new Set<TNormPath>(),
+      if (stylesheetResult.referencedFiles) {
+        for (const referencedFile of stylesheetResult.referencedFiles) {
+          const depCacheSet = this.#resourceDependencyCacheMap.getOrCreate(
+            PathUtil.norm(referencedFile),
+            new Set<TNormPath>(),
+          );
+          depCacheSet.add(resourceFile ?? containingFile);
+        }
+
+        this.#watchFileSet.adds(
+          ...Array.from(stylesheetResult.referencedFiles.values()).map((item) => PathUtil.norm(item)),
         );
-        depCacheSet.add(resourceFile ?? containingFile);
       }
 
-      this.#watchFileSet.adds(
-        ...Array.from(stylesheetResult.referencedFiles.values()).map((item) => PathUtil.norm(item)),
-      );
-    }
+      this.#stylesheetBundlingResultMap.set(PathUtil.norm(resourceFile ?? containingFile), {
+        outputFiles: stylesheetResult.outputFiles,
+        metafile: stylesheetResult.metafile,
+        errors: stylesheetResult.errors,
+        warnings: stylesheetResult.warnings,
+      });
 
-    this.#stylesheetBundlingResultMap.set(PathUtil.norm(resourceFile ?? containingFile), {
-      outputFiles: stylesheetResult.outputFiles,
-      metafile: stylesheetResult.metafile,
-      errors: stylesheetResult.errors,
-      warnings: stylesheetResult.warnings,
+      return stylesheetResult.contents;
     });
-
-    return stylesheetResult.contents;
   }
 
-  async compileAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdTsCompilerResult> {
-    let perf = new SdCliPerformanceTimer("esbuild compile");
+  async compileAsync(modifiedFileSet: Set<TNormPath>): Promise<ISdTsCompilerResult> {
+    this.#perf = new SdCliPerformanceTimer("esbuild compile");
 
-    this.#modifiedFileSet = modifiedFileSet ?? new Set<TNormPath>();
+    this.#modifiedFileSet = new Set(modifiedFileSet);
     this.#affectedFileSet = new Set<TNormPath>();
 
-    this.#debug(`get affected (old deps & old res deps)...`);
+    const prepareResult = await this.#prepareAsync();
 
-    perf.run("get affected", () => {
-      for (const modifiedFile of this.#modifiedFileSet) {
-        this.#affectedFileSet.add(modifiedFile);
-        this.#affectedFileSet.adds(...(this.#revDependencyCacheMap.get(modifiedFile) ?? []));
-        this.#affectedFileSet.adds(...(this.#resourceDependencyCacheMap.get(modifiedFile) ?? []));
+    const [buildResult, lintResults] = await Promise.all([this.#buildAsync(), this.#lintAsync()]);
 
-        this.#emittedFilesCacheMap.delete(modifiedFile);
-      }
-    });
+    this.#debug(`build completed`, this.#perf.toString());
 
-    this.#debug(`invalidate & clear cache...`);
+    return {
+      messages: [
+        ...prepareResult.messages,
+        ...SdCliConvertMessageUtil.convertToBuildMessagesFromTsDiag(buildResult.diagnostics),
+        ...SdCliConvertMessageUtil.convertToBuildMessagesFromEslint(lintResults),
+      ],
+      watchFileSet: this.#watchFileSet,
+      affectedFileSet: this.#affectedFileSet,
+      stylesheetBundlingResultMap: this.#stylesheetBundlingResultMap,
+      emittedFilesCacheMap: this.#emittedFilesCacheMap,
+      emitFileSet: buildResult.emitFileSet,
+    };
+  }
 
-    perf.run("invalidate & clear cache", () => {
-      this.#stylesheetBundler?.invalidate(this.#modifiedFileSet);
+  async #prepareAsync() {
+    if (this.#modifiedFileSet.size !== 0) {
+      this.#debug(`get affected (old deps & old res deps)...`);
 
-      for (const affectedFile of this.#affectedFileSet) {
-        this.#sourceFileCacheMap.delete(affectedFile);
-        this.#stylesheetBundlingResultMap.delete(affectedFile);
-        this.#watchFileSet.delete(affectedFile);
-      }
+      this.#perf.run("get affected", () => {
+        for (const modifiedFile of this.#modifiedFileSet) {
+          this.#affectedFileSet.add(modifiedFile);
+          this.#affectedFileSet.adds(...(this.#revDependencyCacheMap.get(modifiedFile) ?? []));
+          this.#affectedFileSet.adds(...(this.#resourceDependencyCacheMap.get(modifiedFile) ?? []));
 
-      this.#revDependencyCacheMap.clear();
-      this.#resourceDependencyCacheMap.clear();
-    });
+          this.#emittedFilesCacheMap.delete(modifiedFile);
+        }
+      });
+
+      this.#debug(`invalidate & clear cache...`);
+
+      this.#perf.run("invalidate & clear cache", () => {
+        this.#stylesheetBundler?.invalidate(this.#modifiedFileSet);
+
+        for (const affectedFile of this.#affectedFileSet) {
+          this.#sourceFileCacheMap.delete(affectedFile);
+          this.#stylesheetBundlingResultMap.delete(affectedFile);
+          this.#watchFileSet.delete(affectedFile);
+        }
+
+        this.#revDependencyCacheMap.clear();
+        this.#resourceDependencyCacheMap.clear();
+      });
+    }
 
     this.#debug(`create program...`);
 
-    perf.run("create program", () => {
+    this.#perf.run("create program", () => {
       if (this.#isForAngular) {
         this.#ngProgram = new NgtscProgram(
           this.#parsedTsconfig.fileNames,
@@ -255,7 +282,7 @@ export class SdTsCompiler {
     });
 
     if (this.#ngProgram) {
-      await perf.run("ng analyze", async () => {
+      await this.#perf.run("ng analyze", async () => {
         await this.#ngProgram!.compiler.analyzeAsync();
       });
     }
@@ -269,17 +296,17 @@ export class SdTsCompiler {
       return sf;
     };
 
-    this.#debug(`get affected (new deps)...`);
+    const sourceFileSet = new Set(
+      this.#program!.getSourceFiles()
+        .map((sf) => getOrgSourceFile(sf))
+        .filterExists(),
+    );
 
-    const messages: ISdBuildMessage[] = [];
+    this.#debug(`get new deps...`);
 
-    perf.run("get affected (deps)", () => {
-      const sourceFileSet = new Set(
-        this.#program!.getSourceFiles()
-          .map((sf) => getOrgSourceFile(sf))
-          .filterExists(),
-      );
+    const messages: ISdBuildMessage[] = [];
 
+    this.#perf.run("get new deps", () => {
       const depMap = new Map<
         TNormPath,
         {
@@ -346,14 +373,6 @@ export class SdTsCompiler {
         for (const dep of getAllDeps(PathUtil.norm(sf.fileName))) {
           const depCache = this.#revDependencyCacheMap.getOrCreate(dep, new Set<TNormPath>());
           depCache.add(PathUtil.norm(sf.fileName));
-          if (this.#modifiedFileSet.has(dep)) {
-            this.#affectedFileSet.add(PathUtil.norm(sf.fileName));
-          }
-          // dep이 emit된적이 없으면 affected에 추가해야함.
-          // dep파일이 추가된후 기존 파일에서 import하면 dep파일이 affected에 포함이 안되는 현상 때문
-          if (!this.#emittedFilesCacheMap.has(dep)) {
-            this.#affectedFileSet.add(dep);
-          }
         }
 
         if (this.#ngProgram) {
@@ -364,14 +383,6 @@ export class SdTsCompiler {
           for (const dep of this.#ngProgram.compiler.getResourceDependencies(sf)) {
             const ref = this.#resourceDependencyCacheMap.getOrCreate(PathUtil.norm(dep), new Set<TNormPath>());
             ref.add(PathUtil.norm(sf.fileName));
-            if (this.#modifiedFileSet.has(PathUtil.norm(dep))) {
-              this.#affectedFileSet.add(PathUtil.norm(sf.fileName));
-            }
-            // dep이 emit된적이 없으면 affected에 추가해야함.
-            // dep파일이 추가된후 기존 파일에서 import하면 dep파일이 affected에 포함이 안되는 현상 때문
-            if (!this.#emittedFilesCacheMap.has(PathUtil.norm(dep))) {
-              this.#affectedFileSet.add(PathUtil.norm(dep));
-            }
           }
         }
       }
@@ -380,239 +391,249 @@ export class SdTsCompiler {
     if (this.#modifiedFileSet.size === 0) {
       this.#debug(`get affected (init)...`);
 
-      perf.run("get affected (init)", () => {
-        for (const sf of this.#program!.getSourceFiles()) {
+      this.#perf.run("get affected (init)", () => {
+        for (const sf of sourceFileSet) {
           if (!this.#watchScopePaths.some((scopePath) => PathUtil.isChildPath(sf.fileName, scopePath))) {
             continue;
           }
 
-          const orgSf = getOrgSourceFile(sf);
-          if (!orgSf) continue;
-
-          this.#affectedFileSet.add(PathUtil.norm(orgSf.fileName));
+          this.#affectedFileSet.add(PathUtil.norm(sf.fileName));
         }
       });
     }
 
-    const emitFileSet = new Set<TNormPath>();
+    for (const dep of this.#revDependencyCacheMap.keys()) {
+      if (this.#modifiedFileSet.has(dep)) {
+        this.#affectedFileSet.adds(
+          ...Array.from(this.#revDependencyCacheMap.get(dep)!).mapMany((item) =>
+            [
+              item,
+              // .d.ts면 .js파일도 affected에 추가
+              item.endsWith(".d.ts") ? PathUtil.norm(item.replace(/\.d\.ts$/, ".js")) : undefined,
+            ].filterExists(),
+          ),
+        );
+      }
 
-    const [lintResults] = await Promise.all([
-      this.#lintWorker.run("lint", [
-        {
-          cwd: this.#pkgPath,
-          fileSet: this.#affectedFileSet,
-        },
-      ]),
-      (async () => {
-        this.#debug(`get diagnostics...`);
+      // dep이 emit된적이 없으면 affected에 추가해야함.
+      // dep파일이 추가된후 기존 파일에서 import하면 dep파일이 affected에 포함이 안되는 현상 때문
+      if (!this.#emittedFilesCacheMap.has(dep)) {
+        this.#affectedFileSet.add(dep);
+      }
+    }
 
-        const diagnostics: ts.Diagnostic[] = [];
+    if (this.#ngProgram) {
+      for (const dep of this.#resourceDependencyCacheMap.keys()) {
+        if (this.#modifiedFileSet.has(dep)) {
+          this.#affectedFileSet.adds(...this.#resourceDependencyCacheMap.get(dep)!);
+        }
 
-        perf.run("get program diagnostics", () => {
-          diagnostics.push(
-            ...this.#program!.getConfigFileParsingDiagnostics(),
-            ...this.#program!.getOptionsDiagnostics(),
-            ...this.#program!.getGlobalDiagnostics(),
-          );
+        // dep이 emit된적이 없으면 affected에 추가해야함.
+        // dep파일이 추가된후 기존 파일에서 import하면 dep파일이 affected에 포함이 안되는 현상 때문
+        if (!this.#emittedFilesCacheMap.has(dep)) {
+          this.#affectedFileSet.add(dep);
+        }
+      }
+    }
 
-          if (this.#ngProgram) {
-            diagnostics.push(...this.#ngProgram.compiler.getOptionDiagnostics());
-          }
-        });
+    return {
+      messages,
+    };
+  }
 
-        this.#debug(`get diagnostics of files...`);
+  async #lintAsync() {
+    return await this.#lintWorker.run("lint", [
+      {
+        cwd: this.#pkgPath,
+        fileSet: this.#affectedFileSet,
+      },
+    ]);
+  }
 
-        for (const affectedFile of this.#affectedFileSet) {
-          if (!PathUtil.isChildPath(affectedFile, this.#pkgPath)) {
-            continue;
-          }
+  async #buildAsync() {
+    const emitFileSet = new Set<TNormPath>();
+    const diagnostics: ts.Diagnostic[] = [];
 
-          const affectedSourceFile = this.#program!.getSourceFile(affectedFile);
+    this.#debug(`get diagnostics...`);
 
-          if (
-            !affectedSourceFile ||
-            (this.#ngProgram && this.#ngProgram.compiler.ignoreForDiagnostics.has(affectedSourceFile))
-          ) {
-            continue;
-          }
+    this.#perf.run("get program diagnostics", () => {
+      diagnostics.push(
+        ...this.#program!.getConfigFileParsingDiagnostics(),
+        ...this.#program!.getOptionsDiagnostics(),
+        ...this.#program!.getGlobalDiagnostics(),
+      );
 
-          // this.#debug(`get diagnostics of file ${affectedFile}...`);
+      if (this.#ngProgram) {
+        diagnostics.push(...this.#ngProgram.compiler.getOptionDiagnostics());
+      }
+    });
 
-          perf.run("get file diagnostics", () => {
-            diagnostics.push(
-              ...this.#program!.getSyntacticDiagnostics(affectedSourceFile),
-              ...this.#program!.getSemanticDiagnostics(affectedSourceFile),
-            );
-          });
+    this.#debug(`get diagnostics of files...`);
 
-          if (this.#ngProgram) {
-            perf.run("get file diagnostics: ng", () => {
-              if (affectedSourceFile.isDeclarationFile) {
-                return;
-              }
+    for (const affectedFile of this.#affectedFileSet) {
+      if (!PathUtil.isChildPath(affectedFile, this.#pkgPath)) {
+        continue;
+      }
 
-              diagnostics.push(
-                ...this.#ngProgram!.compiler.getDiagnosticsForFile(affectedSourceFile, OptimizeFor.WholeProgram),
-              );
-            });
-          }
-        }
+      const affectedSourceFile = this.#program!.getSourceFile(affectedFile);
 
-        perf.run("emit", () => {
-          this.#debug(`prepare emit...`);
+      if (
+        !affectedSourceFile ||
+        (this.#ngProgram && this.#ngProgram.compiler.ignoreForDiagnostics.has(affectedSourceFile))
+      ) {
+        continue;
+      }
+
+      // this.#debug(`get diagnostics of file ${affectedFile}...`);
 
-          let transformers: ts.CustomTransformers = {};
+      this.#perf.run("get file diagnostics", () => {
+        diagnostics.push(
+          ...this.#program!.getSyntacticDiagnostics(affectedSourceFile),
+          ...this.#program!.getSemanticDiagnostics(affectedSourceFile),
+        );
+      });
 
-          if (this.#ngProgram) {
-            transformers = {
-              ...transformers,
-              ...this.#ngProgram.compiler.prepareEmit().transformers,
-            };
-            (transformers.before ??= []).push(replaceBootstrap(() => this.#program!.getTypeChecker()));
+      if (this.#ngProgram) {
+        this.#perf.run("get file diagnostics: ng", () => {
+          if (affectedSourceFile.isDeclarationFile) {
+            return;
           }
-          // (transformers.before ??= []).push(transformKeys(this.#program));
 
-          this.#debug(`emit for files...`);
+          diagnostics.push(
+            ...this.#ngProgram!.compiler.getDiagnosticsForFile(affectedSourceFile, OptimizeFor.WholeProgram),
+          );
+        });
+      }
+    }
 
-          // affected에 새로 추가된 파일은 포함되지 않는 현상이 있어 sourceFileSet으로 바꿈
-          // 비교해보니, 딱히 getSourceFiles라서 더 느려지는것 같지는 않음
-          // 그래도 affected로 다시 테스트
-          for (const affectedFile of this.#affectedFileSet) {
-            if (this.#emittedFilesCacheMap.has(affectedFile)) {
-              continue;
-            }
+    this.#perf.run("emit", () => {
+      this.#debug(`prepare emit...`);
 
-            const sf = this.#program!.getSourceFile(affectedFile);
-            if (!sf) {
-              continue;
-            }
+      let transformers: ts.CustomTransformers = {};
 
-            if (sf.isDeclarationFile) {
-              continue;
-            }
+      if (this.#ngProgram) {
+        transformers = {
+          ...transformers,
+          ...this.#ngProgram.compiler.prepareEmit().transformers,
+        };
+        (transformers.before ??= []).push(replaceBootstrap(() => this.#program!.getTypeChecker()));
+      }
+      // (transformers.before ??= []).push(transformKeys(this.#program));
 
-            if (this.#ngProgram?.compiler.ignoreForEmit.has(sf)) {
-              continue;
-            }
+      this.#debug(`emit for files...`);
 
-            if (this.#ngProgram?.compiler.incrementalCompilation.safeToSkipEmit(sf)) {
-              continue;
-            }
-
-            // esbuild를 통해 bundle로 묶어야 하는놈들은 모든 output이 있어야 함.
-            if (!this.#isForBundle) {
-              if (!PathUtil.isChildPath(sf.fileName, this.#pkgPath)) {
-                continue;
-              }
-            }
+      // affected에 새로 추가된 파일은 포함되지 않는 현상이 있어 sourceFileSet으로 바꿈
+      // 비교해보니, 딱히 getSourceFiles라서 더 느려지는것 같지는 않음
+      // 그래도 affected로 다시 테스트
+      for (const affectedFile of this.#affectedFileSet) {
+        if (this.#emittedFilesCacheMap.has(affectedFile)) {
+          continue;
+        }
 
-            // this.#debug(`emit for`, sf.fileName);
-            this.#program!.emit(
-              sf,
-              (fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
-                if (!sourceFiles || sourceFiles.length === 0) {
-                  this.#compilerHost.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
-                  return;
-                }
+        const sf = this.#program!.getSourceFile(affectedFile);
+        if (!sf) {
+          continue;
+        }
 
-                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);
-                }
+        if (sf.isDeclarationFile) {
+          continue;
+        }
 
-                const emitFileInfoCaches = this.#emittedFilesCacheMap.getOrCreate(
-                  PathUtil.norm(sourceFile.fileName),
-                  [],
-                );
+        if (this.#ngProgram?.compiler.ignoreForEmit.has(sf)) {
+          continue;
+        }
 
-                if (PathUtil.isChildPath(sourceFile.fileName, this.#pkgPath)) {
-                  let realFilePath = PathUtil.norm(fileName);
-                  let realText = text;
-                  if (
-                    PathUtil.isChildPath(
-                      realFilePath,
-                      path.resolve(this.#distPath, path.basename(this.#pkgPath), "src"),
-                    )
-                  ) {
-                    realFilePath = PathUtil.norm(
-                      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);
-                    }
-                  }
-
-                  emitFileInfoCaches.push({
-                    outAbsPath: realFilePath,
-                    text: realText,
-                  });
-                } else {
-                  emitFileInfoCaches.push({ text });
-                }
+        if (this.#ngProgram?.compiler.incrementalCompilation.safeToSkipEmit(sf)) {
+          continue;
+        }
 
-                emitFileSet.add(PathUtil.norm(sourceFile.fileName));
-              },
-              undefined,
-              undefined,
-              transformers,
-            );
+        // esbuild를 통해 bundle로 묶어야 하는놈들은 모든 output이 있어야 함.
+        if (!this.#isForBundle) {
+          if (!PathUtil.isChildPath(sf.fileName, this.#pkgPath)) {
+            continue;
           }
-        });
-
-        //-- global style
-        if (
-          this.#globalStyleFilePath != null &&
-          FsUtil.exists(this.#globalStyleFilePath) &&
-          !this.#emittedFilesCacheMap.has(this.#globalStyleFilePath)
-        ) {
-          this.#debug(`bundle global style...`);
-
-          await perf.run("bundle global style", async () => {
-            const data = FsUtil.readFile(this.#globalStyleFilePath!);
-            const contents = await this.#bundleStylesheetAsync(
-              data,
-              this.#globalStyleFilePath!,
-              this.#globalStyleFilePath,
-            );
-            const emitFileInfos = this.#emittedFilesCacheMap.getOrCreate(this.#globalStyleFilePath!, []);
-            emitFileInfos.push({
-              outAbsPath: PathUtil.norm(
-                this.#pkgPath,
-                path
-                  .relative(path.resolve(this.#pkgPath, "src"), this.#globalStyleFilePath!)
-                  .replace(/\.scss$/, ".css"),
-              ),
-              text: contents,
-            });
-            emitFileSet.add(this.#globalStyleFilePath!);
-          });
         }
 
-        this.#debug(`build completed`, perf.toString());
+        this.#program!.emit(
+          sf,
+          (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);
+            }
 
-        //-- result
+            const emitFileInfoCaches = this.#emittedFilesCacheMap.getOrCreate(PathUtil.norm(sourceFile.fileName), []);
+
+            if (PathUtil.isChildPath(sourceFile.fileName, this.#pkgPath)) {
+              let realFilePath = PathUtil.norm(fileName);
+              let realText = text;
+              if (
+                PathUtil.isChildPath(realFilePath, path.resolve(this.#distPath, path.basename(this.#pkgPath), "src"))
+              ) {
+                realFilePath = PathUtil.norm(
+                  this.#distPath,
+                  path.relative(path.resolve(this.#distPath, path.basename(this.#pkgPath), "src"), realFilePath),
+                );
 
-        messages.push(...SdCliConvertMessageUtil.convertToBuildMessagesFromTsDiag(diagnostics));
-      })(),
-    ]);
+                if (fileName.endsWith(".js.map")) {
+                  const sourceMapContents = JSON.parse(realText);
+                  // remove "../../"
+                  sourceMapContents.sources[0] = sourceMapContents.sources[0].slice(6);
+                  realText = JSON.stringify(sourceMapContents);
+                }
+              }
 
-    messages.push(...SdCliConvertMessageUtil.convertToBuildMessagesFromEslint(lintResults));
+              emitFileInfoCaches.push({
+                outAbsPath: realFilePath,
+                text: realText,
+              });
+            } else {
+              emitFileInfoCaches.push({ text });
+            }
+
+            emitFileSet.add(PathUtil.norm(sourceFile.fileName));
+          },
+          undefined,
+          undefined,
+          transformers,
+        );
+      }
+    });
+
+    //-- global style
+    if (
+      this.#globalStyleFilePath != null &&
+      FsUtil.exists(this.#globalStyleFilePath) &&
+      !this.#emittedFilesCacheMap.has(this.#globalStyleFilePath)
+    ) {
+      this.#debug(`bundle global style...`);
+
+      await this.#perf.run("bundle global style", async () => {
+        const data = FsUtil.readFile(this.#globalStyleFilePath!);
+        const contents = await this.#bundleStylesheetAsync(data, this.#globalStyleFilePath!, this.#globalStyleFilePath);
+        const emitFileInfos = this.#emittedFilesCacheMap.getOrCreate(this.#globalStyleFilePath!, []);
+        emitFileInfos.push({
+          outAbsPath: PathUtil.norm(
+            this.#pkgPath,
+            path.relative(path.resolve(this.#pkgPath, "src"), this.#globalStyleFilePath!).replace(/\.scss$/, ".css"),
+          ),
+          text: contents,
+        });
+        emitFileSet.add(this.#globalStyleFilePath!);
+      });
+    }
 
     return {
-      messages,
-      watchFileSet: this.#watchFileSet,
-      affectedFileSet: this.#affectedFileSet,
-      stylesheetBundlingResultMap: this.#stylesheetBundlingResultMap,
-      emittedFilesCacheMap: this.#emittedFilesCacheMap,
       emitFileSet,
+      diagnostics,
     };
   }
 

package/src/types/build-runner.type.ts

@@ -0,0 +1,8 @@
+import { TNormPath } from "@simplysm/sd-core-node";
+import { ISdProjectConfig } from "./sd-configs.type";
+
+export interface ISdBuildRunnerWorkerRequest {
+  cmd: "watch" | "build";
+  pkgPath: TNormPath;
+  projConf: ISdProjectConfig;
+}