@simplysm/sd-cli 12.8.21 → 12.9.1

package/src/ts-compiler/sd-ts-compiler.ts

@@ -1,14 +1,9 @@
 import ts from "typescript";
 import path from "path";
-import { FsUtils, PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
+import { FsUtils, PathUtils, SdLogger, SdWorker, TNormPath } from "@simplysm/sd-core-node";
 import { StringUtils } from "@simplysm/sd-core-common";
 import { NgtscProgram, OptimizeFor } from "@angular/compiler-cli";
-import {
-  ComponentStylesheetBundler,
-} from "@angular/build/src/tools/esbuild/angular/component-stylesheets";
 import { AngularCompilerHost } from "@angular/build/src/tools/angular/angular-host";
-import { transformSupportedBrowsersToTargets } from "@angular/build/src/tools/esbuild/utils";
-import browserslist from "browserslist";
 import {
   replaceBootstrap,
 } from "@angular/build/src/tools/angular/transformers/jit-bootstrap-transformer";
@@ -19,19 +14,26 @@ import {
   SdTsCompilerOptions,
   TStylesheetBundlingResult,
 } from "../types/ts-compiler.types";
-import { ISdBuildMessage } from "../types/build.types";
 import {
   createWorkerTransformer,
 } from "@angular/build/src/tools/angular/transformers/web-worker-transformer";
 import { ESLint } from "eslint";
-import { SdTsDependencyAnalyzer } from "./sd-ts-dependency-analyzer";
+import { ISdAffectedFileTreeNode, SdDependencyCache } from "./sd-dependency-cache";
+import { SdDependencyAnalyzer } from "./sd-dependency-analyzer";
+import { TStyleBundlerWorkerType } from "../types/worker.types";
 
 export class SdTsCompiler {
   private _logger = SdLogger.get(["simplysm", "sd-cli", "SdTsCompiler"]);
 
   private _isForAngular: boolean;
 
-  private _revDepCacheMap = new Map<TNormPath, Set<TNormPath>>();
+  private _stylesheetBundlingWorker?: SdWorker<TStyleBundlerWorkerType>;
+
+  private _ngProgram: NgtscProgram | undefined;
+  private _program: ts.Program | undefined;
+
+  // 빌드정보 캐싱
+  private _depCache = new SdDependencyCache();
   private _sourceFileCacheMap = new Map<TNormPath, ts.SourceFile>();
   private _emittedFilesCacheMap = new Map<
     TNormPath,
@@ -41,15 +43,7 @@ export class SdTsCompiler {
     }[]
   >();
 
-  private _stylesheetBundler: ComponentStylesheetBundler | undefined;
-
-  private _ngProgram: NgtscProgram | undefined;
-  private _program: ts.Program | undefined;
-
-  private _modifiedFileSet = new Set<TNormPath>();
-  private _affectedFileSet = new Set<TNormPath>();
-
-  private _watchFileSet = new Set<TNormPath>();
+  // 빌드결과 캐싱
   private _stylesheetBundlingResultMap = new Map<TNormPath, TStylesheetBundlingResult>();
 
   private _perf!: SdCliPerformanceTimer;
@@ -60,46 +54,9 @@ export class SdTsCompiler {
     const tsconfigPath = path.resolve(this._opt.pkgPath, "tsconfig.json");
     const tsconfig = FsUtils.readJson(tsconfigPath);
     this._isForAngular = Boolean(tsconfig.angularCompilerOptions);
-
-    if (this._isForAngular) {
-      //-- stylesheetBundler
-      this._stylesheetBundler = new ComponentStylesheetBundler(
-        {
-          workspaceRoot: this._opt.pkgPath,
-          optimization: !this._opt.isDevMode,
-          inlineFonts: true,
-          preserveSymlinks: false,
-          sourcemap: this._opt.isDevMode ? "inline" : false,
-          outputNames: { bundles: "[name]", media: "media/[name]" },
-          includePaths: [],
-          externalDependencies: [],
-          target: transformSupportedBrowsersToTargets(browserslist(["Chrome > 78"])),
-          postcssConfiguration: {
-            plugins: [["css-has-pseudo"]],
-          },
-          tailwindConfiguration: undefined,
-          cacheOptions: {
-            enabled: true,
-            path: ".cache/angular",
-            basePath: ".cache",
-          },
-        },
-        "scss",
-        this._opt.isDevMode,
-      );
-    }
   }
 
-  private _parseTsConfig(): ITsConfigInfo {
-    const config = this._loadTsConfig();
-    const compilerHost = this._createCompilerHost(config.options);
-    return {
-      ...config,
-      compilerHost,
-    };
-  }
-
-  private _loadTsConfig() {
+  private _parseTsConfig() {
     const tsconfigPath = path.resolve(this._opt.pkgPath, "tsconfig.json");
     const tsconfig = FsUtils.readJson(tsconfigPath);
     const parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._opt.pkgPath, {
@@ -119,7 +76,10 @@ export class SdTsCompiler {
     };
   }
 
-  private _createCompilerHost(compilerOptions: ts.CompilerOptions) {
+  private _createCompilerHost(
+    compilerOptions: ts.CompilerOptions,
+    modifiedFileSet: Set<TNormPath>,
+  ) {
     const compilerHost = ts.createCompilerHost(compilerOptions);
 
     const baseGetSourceFile = compilerHost.getSourceFile;
@@ -155,12 +115,6 @@ export class SdTsCompiler {
       return sf;
     };
 
-    const baseReadFile = compilerHost.readFile;
-    compilerHost.readFile = (fileName) => {
-      this._watchFileSet.add(PathUtils.norm(fileName));
-      return baseReadFile.call(compilerHost, fileName);
-    };
-
     if (this._isForAngular) {
       (compilerHost as AngularCompilerHost).readResource = (fileName: string) => {
         return compilerHost.readFile(fileName) ?? "";
@@ -190,13 +144,30 @@ export class SdTsCompiler {
       };
 
       (compilerHost as AngularCompilerHost).getModifiedResourceFiles = () => {
-        return new Set(Array.from(this._modifiedFileSet).map((item) => PathUtils.posix(item)));
+        return new Set(Array.from(modifiedFileSet).map((item) => PathUtils.posix(item)));
       };
     }
 
     return compilerHost;
   }
 
+  private async _getOrCreateStyleBundleWorkerAsync() {
+    if (this._stylesheetBundlingWorker) {
+      return this._stylesheetBundlingWorker;
+    }
+
+    this._stylesheetBundlingWorker = new SdWorker<TStyleBundlerWorkerType>(
+      import.meta.resolve("../workers/style-bundler.worker"),
+    );
+
+    await this._stylesheetBundlingWorker.run(
+      "prepare",
+      [this._opt.pkgPath, this._opt.isDevMode],
+    );
+
+    return this._stylesheetBundlingWorker;
+  }
+
   private async _bundleStylesheetAsync(
     data: string,
     containingFile: TNormPath,
@@ -215,24 +186,12 @@ export class SdTsCompiler {
       }
 
       try {
-        const result =
-          resourceFile != null
-            ? await this._stylesheetBundler!.bundleFile(resourceFile)
-            : await this._stylesheetBundler!.bundleInline(data, containingFile, "scss");
-
-        if (result.referencedFiles) {
-          for (const referencedFile of result.referencedFiles) {
-            const depCacheSet = this._revDepCacheMap.getOrCreate(
-              PathUtils.norm(referencedFile),
-              new Set<TNormPath>(),
-            );
-            depCacheSet.add(fileNPath);
-          }
+        const worker = this._stylesheetBundlingWorker!;
+        const result = await worker.run("bundle", [data, containingFile, resourceFile]);
 
-          this._watchFileSet.adds(
-            ...Array.from(result.referencedFiles.values())
-              .map((item) => PathUtils.norm(item)),
-          );
+        for (const referencedFile of result.referencedFiles ?? []) {
+          // 참조하는 파일과 참조된 파일 사이의 의존성 관계 추가
+          this._depCache.addImport(fileNPath, PathUtils.norm(referencedFile), 0);
         }
 
         this._stylesheetBundlingResultMap.set(fileNPath, result);
@@ -255,111 +214,96 @@ export class SdTsCompiler {
     });
   }
 
-  public async compileAsync(modifiedFileSet: Set<TNormPath>): Promise<ISdTsCompilerResult> {
+  async compileAsync(modifiedFileSet: Set<TNormPath>): Promise<ISdTsCompilerResult> {
     this._perf = new SdCliPerformanceTimer("esbuild compile");
 
-    this._modifiedFileSet = new Set(modifiedFileSet);
-    this._affectedFileSet = new Set<TNormPath>();
-
-    /*for (const mod of modifiedFileSet) {
-      const workerImporters = this.#workerRevDependencyCacheMap.get(mod);
-      if (workerImporters) {
-        this.#modifiedFileSet.adds(...workerImporters);
-      } else {
-        this.#modifiedFileSet.add(mod);
-      }
-    }*/
-
-    const tsconf = this._parseTsConfig();
-
-    const prepareResult = await this._prepareAsync(tsconf);
+    const prepareResult = await this._prepareAsync(modifiedFileSet);
 
-    const [buildResult, lintResults] = await Promise.all([
-      this._buildAsync(tsconf),
-      this._lintAsync(),
+    const [globalStyleSheet, buildResult, lintResults] = await Promise.all([
+      this._buildGlobalStyleAsync(),
+      this._build(prepareResult),
+      this._lintAsync(prepareResult),
     ]);
 
     this._debug(`빌드 완료됨`, this._perf.toString());
-    this._debug(`영향 받은 파일: ${this._affectedFileSet.size}개`);
-    this._debug(`감시 중인 파일: ${this._watchFileSet.size}개`);
+    this._debug(`영향 받은 파일: ${prepareResult.affectedFileSet.size}개`);
+    this._debug(`감시 중인 파일: ${prepareResult.watchFileSet.size}개`);
 
     return {
       messages: [
-        ...prepareResult.messages,
         ...SdCliConvertMessageUtils.convertToBuildMessagesFromTsDiag(buildResult.diagnostics),
         ...SdCliConvertMessageUtils.convertToBuildMessagesFromEslint(lintResults),
       ],
-      watchFileSet: this._watchFileSet,
-      affectedFileSet: this._affectedFileSet,
+      affectedFileSet: prepareResult.affectedFileSet,
+      watchFileSet: prepareResult.watchFileSet,
       stylesheetBundlingResultMap: this._stylesheetBundlingResultMap,
       emittedFilesCacheMap: this._emittedFilesCacheMap,
-      emitFileSet: buildResult.emitFileSet,
+      emitFileSet: new Set([...buildResult.emitFileSet, globalStyleSheet].filterExists()),
     };
   }
 
-  private async _prepareAsync(tsconf: ITsConfigInfo) {
-    if (this._modifiedFileSet.size !== 0) {
-      this._debug(`영향 받은 파일 추적 중... (구 의존성)`);
+  private async _prepareAsync(modifiedFileSet: Set<TNormPath>): Promise<IPrepareResult> {
+    const worker = await this._getOrCreateStyleBundleWorkerAsync();
 
-      this._perf.run("영향 받은 파일 추적", () => {
-        for (const modifiedFile of this._modifiedFileSet) {
-          this._affectedFileSet.add(modifiedFile);
+    const tsconfig = this._parseTsConfig();
 
-          this._affectedFileSet.adds(...(this._revDepCacheMap.get(modifiedFile) ?? []));
+    if (modifiedFileSet.size !== 0) {
+      this._debug(`캐시 무효화 및 초기화 중...`);
+
+      await this._perf.run("캐시 무효화 및 초기화", async () => {
+        // 기존 의존성에 의해 영향받는 파일들 계산
+        const affectedFileSet = this._depCache.getAffectedFileSet(modifiedFileSet);
 
-          // .d.ts → .js 대응
-          if (modifiedFile.endsWith(".d.ts")) {
-            const jsEquivalent = PathUtils.norm(modifiedFile.replace(/\.d\.ts$/, ".js"));
-            this._affectedFileSet.add(jsEquivalent);
+        const getTreeText = (node: ISdAffectedFileTreeNode, indent = "") => {
+          let result = indent + node.fileNPath + "\n";
+          for (const child of node.children) {
+            result += getTreeText(child, indent + "  ");
           }
-        }
-      });
 
-      this._debug(`캐시 무효화 및 초기화 중...`);
+          return result;
+        };
+
+        const affectedFileTree = this._depCache.getAffectedFileTree(modifiedFileSet);
+        this._debug(`
+영향받은 기존파일:
+${affectedFileTree.map(item => getTreeText(item)).join("\n")}`.trim());
 
-      this._perf.run("캐시 무효화 및 초기화", () => {
-        this._stylesheetBundler?.invalidate(this._affectedFileSet);
+        // 스타일 번들러에서 영향받은 파일 관련 항목 무효화
+        await worker.run("invalidate", [affectedFileSet]);
 
-        for (const affectedFile of this._affectedFileSet) {
+        // 의존성 캐시에서 영향받은 파일 관련 항목 무효화
+        this._depCache.invalidates(affectedFileSet);
+
+        // 내부 캐시에서 영향받은 파일 관련 항목 무효화
+        for (const affectedFile of affectedFileSet) {
           this._emittedFilesCacheMap.delete(affectedFile);
           this._sourceFileCacheMap.delete(affectedFile);
           this._stylesheetBundlingResultMap.delete(affectedFile);
-          this._watchFileSet.delete(affectedFile);
-
-          for (const [key, deps] of this._revDepCacheMap.entries()) {
-            if (key === affectedFile) {
-              this._revDepCacheMap.delete(key);
-              continue;
-            }
-
-            if (deps.has(affectedFile)) {
-              deps.delete(affectedFile);
-              if (deps.size === 0) {
-                this._revDepCacheMap.delete(key);
-              }
-            }
-          }
         }
       });
     }
 
     this._debug(`ts.Program 생성 중...`);
 
+    const compilerHost = this._perf.run("ts.CompilerHost 생성", () => {
+      return this._createCompilerHost(tsconfig.options, modifiedFileSet);
+    });
+
     this._perf.run("ts.Program 생성", () => {
       if (this._isForAngular) {
         this._ngProgram = new NgtscProgram(
-          tsconf.fileNames,
-          tsconf.options,
-          tsconf.compilerHost,
+          tsconfig.fileNames,
+          tsconfig.options,
+          compilerHost,
           this._ngProgram,
         );
         this._program = this._ngProgram.getTsProgram();
       }
       else {
         this._program = ts.createProgram(
-          tsconf.fileNames,
-          tsconf.options,
-          tsconf.compilerHost,
+          tsconfig.fileNames,
+          tsconfig.options,
+          compilerHost,
           this._program,
         );
       }
@@ -373,86 +317,40 @@ export class SdTsCompiler {
 
     this._debug(`새 의존성 분석 중...`);
 
-    const messages: ISdBuildMessage[] = [];
-    const analysed1 = this._perf.run("새 의존성 분석", () => {
-      const analysed = SdTsDependencyAnalyzer.analyze(
+    this._perf.run("새 의존성 분석", () => {
+      // SdTsDependencyAnalyzer를 통해 의존성 분석 및 SdDepCache 업데이트
+      SdDependencyAnalyzer.analyze(
         this._program!,
-        tsconf.compilerHost,
+        compilerHost,
         this._opt.watchScopePaths,
+        this._depCache,
       );
-      messages.push(...analysed.messages);
-
-      for (const sf of analysed.sourceFileSet) {
-        const filePath = PathUtils.norm(sf.fileName);
-        const deps = analysed.allDepMap.get(filePath) ?? new Set<TNormPath>();
-
-        for (const dep of deps) {
-          const depCache = this._revDepCacheMap.getOrCreate(dep, new Set<TNormPath>());
-          depCache.add(filePath);
-        }
-
-        if (this._ngProgram) {
-          if (this._ngProgram.compiler.ignoreForEmit.has(sf)) {
-            continue;
-          }
-
-          for (const dep of this._ngProgram.compiler.getResourceDependencies(sf)) {
-            const ref = this._revDepCacheMap.getOrCreate(
-              PathUtils.norm(dep),
-              new Set<TNormPath>(),
-            );
-            ref.add(filePath);
-          }
-        }
-      }
-
-      return analysed;
-    });
-
-    if (this._modifiedFileSet.size === 0) {
-      this._debug(`영향 받은 파일 추가 중... (새 의존성)`);
 
-      this._perf.run("영향 받은 파일 추가 중 (새 의존성)", () => {
-        for (const sf of analysed1.sourceFileSet) {
-          if (!this._opt.watchScopePaths.some((scopePath) => PathUtils.isChildPath(
-            sf.fileName,
-            scopePath,
-          ))) {
-            continue;
-          }
-
-          this._affectedFileSet.add(PathUtils.norm(sf.fileName));
-        }
-      });
-    }
-
-    for (const dep of this._revDepCacheMap.keys()) {
-      if (this._modifiedFileSet.has(dep)) {
-        this._affectedFileSet.adds(
-          ...Array.from(this._revDepCacheMap.get(dep)!).mapMany((item) =>
-            [
-              item,
-              // .d.ts면 .js파일도 affected에 추가
-              item.endsWith(".d.ts") ? PathUtils.norm(item.replace(/\.d\.ts$/, ".js")) : undefined,
-            ].filterExists(),
-          ),
+      // Angular 리소스 의존성 추가
+      if (this._ngProgram) {
+        SdDependencyAnalyzer.analyzeAngularResources(
+          this._ngProgram,
+          this._opt.watchScopePaths,
+          this._depCache,
         );
       }
+    });
 
-      // dep이 emit된적이 없으면 affected에 추가해야함.
-      // dep파일이 추가된후 기존 파일에서 import하면 dep파일이 affected에 포함이 안되는 현상 때문
-      if (!this._emittedFilesCacheMap.has(dep)) {
-        this._affectedFileSet.add(dep);
-      }
-    }
+    const affectedFileSet = modifiedFileSet.size === 0
+      ? this._depCache.getFiles()
+      : this._depCache.getAffectedFileSet(modifiedFileSet);
+    const watchFileSet = this._depCache.getFiles();
 
     return {
-      messages,
+      tsconfig,
+      compilerHost,
+      affectedFileSet,
+      watchFileSet,
     };
   }
 
-  private async _lintAsync() {
-    const lintFilePaths = Array.from(this._affectedFileSet)
+  private async _lintAsync(prepareResult: IPrepareResult) {
+    const lintFilePaths = Array.from(prepareResult.affectedFileSet)
       .filter((item) => PathUtils.isChildPath(item, this._opt.pkgPath))
       .filter((item) => (
         (!item.endsWith(".d.ts") && item.endsWith(".ts")) ||
@@ -470,7 +368,6 @@ export class SdTsCompiler {
       overrideConfig: {
         languageOptions: {
           parserOptions: {
-            // parser: tseslint.parser,
             project: null,
             programs: [this._program],
           },
@@ -478,16 +375,45 @@ export class SdTsCompiler {
       },
     });
     return await linter.lintFiles(lintFilePaths);
+  }
+
+  private async _buildGlobalStyleAsync() {
+    //-- global style
+    if (
+      this._opt.globalStyleFilePath != null &&
+      FsUtils.exists(this._opt.globalStyleFilePath) &&
+      !this._emittedFilesCacheMap.has(this._opt.globalStyleFilePath)
+    ) {
+      this._debug(`전역 스타일 번들링 중...`);
+
+      await this._perf.run("전역 스타일 번들링", async () => {
+        const data = await FsUtils.readFileAsync(this._opt.globalStyleFilePath!);
+        const stylesheetBundlingResult = await this._bundleStylesheetAsync(
+          data,
+          this._opt.globalStyleFilePath!,
+          this._opt.globalStyleFilePath,
+        );
+        const emitFileInfos = this._emittedFilesCacheMap.getOrCreate(
+          this._opt.globalStyleFilePath!,
+          [],
+        );
+        emitFileInfos.push({
+          outAbsPath: PathUtils.norm(
+            this._opt.pkgPath,
+            path.relative(path.resolve(this._opt.pkgPath, "src"), this._opt.globalStyleFilePath!)
+              .replace(/\.scss$/, ".css"),
+          ),
+          text: stylesheetBundlingResult.contents ?? "",
+        });
+      });
+
+      return this._opt.globalStyleFilePath;
+    }
 
-    // return await this.#lintWorker.run("lint", [
-    //   {
-    //     cwd: this.#pkgPath,
-    //     fileSet: this.#affectedFileSet,
-    //   },
-    // ]);
+    return undefined;
   }
 
-  private async _buildAsync(tsconf: ITsConfigInfo) {
+  private _build(prepareResult: IPrepareResult) {
     const emitFileSet = new Set<TNormPath>();
     const diagnostics: ts.Diagnostic[] = [];
 
@@ -507,7 +433,7 @@ export class SdTsCompiler {
 
     this._debug(`개별 파일 진단 수집 중...`);
 
-    for (const affectedFile of this._affectedFileSet) {
+    for (const affectedFile of prepareResult.affectedFileSet) {
       if (!PathUtils.isChildPath(affectedFile, this._opt.pkgPath)) continue;
 
       const affectedSourceFile = this._program!.getSourceFile(affectedFile);
@@ -566,7 +492,7 @@ export class SdTsCompiler {
       // affected에 새로 추가된 파일은 포함되지 않는 현상이 있어 sourceFileSet으로 바꿈
       // 비교해보니, 딱히 getSourceFiles라서 더 느려지는것 같지는 않음
       // 그래도 affected로 다시 테스트 (조금이라도 더 빠르게)
-      for (const affectedFile of this._affectedFileSet) {
+      for (const affectedFile of prepareResult.affectedFileSet) {
         if (this._emittedFilesCacheMap.has(affectedFile)) continue;
 
         const sf = this._program!.getSourceFile(affectedFile);
@@ -584,7 +510,7 @@ export class SdTsCompiler {
           sf,
           (fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
             if (!sourceFiles || sourceFiles.length === 0) {
-              tsconf.compilerHost.writeFile(
+              prepareResult.compilerHost.writeFile(
                 fileName,
                 text,
                 writeByteOrderMark,
@@ -607,7 +533,11 @@ export class SdTsCompiler {
             );
 
             if (PathUtils.isChildPath(sourceFile.fileName, this._opt.pkgPath)) {
-              const real = this._convertOutputToReal(fileName, tsconf.distPath, text);
+              const real = this._convertOutputToReal(
+                fileName,
+                prepareResult.tsconfig.distPath,
+                text,
+              );
 
               emitFileInfoCaches.push({
                 outAbsPath: real.filePath,
@@ -627,37 +557,6 @@ export class SdTsCompiler {
       }
     });
 
-    //-- global style
-    if (
-      this._opt.globalStyleFilePath != null &&
-      FsUtils.exists(this._opt.globalStyleFilePath) &&
-      !this._emittedFilesCacheMap.has(this._opt.globalStyleFilePath)
-    ) {
-      this._debug(`전역 스타일 번들링 중...`);
-
-      await this._perf.run("전역 스타일 번들링", async () => {
-        const data = FsUtils.readFile(this._opt.globalStyleFilePath!);
-        const stylesheetBundlingResult = await this._bundleStylesheetAsync(
-          data,
-          this._opt.globalStyleFilePath!,
-          this._opt.globalStyleFilePath,
-        );
-        const emitFileInfos = this._emittedFilesCacheMap.getOrCreate(
-          this._opt.globalStyleFilePath!,
-          [],
-        );
-        emitFileInfos.push({
-          outAbsPath: PathUtils.norm(
-            this._opt.pkgPath,
-            path.relative(path.resolve(this._opt.pkgPath, "src"), this._opt.globalStyleFilePath!)
-              .replace(/\.scss$/, ".css"),
-          ),
-          text: stylesheetBundlingResult.contents ?? "",
-        });
-        emitFileSet.add(this._opt.globalStyleFilePath!);
-      });
-    }
-
     return {
       emitFileSet,
       diagnostics,
@@ -693,6 +592,12 @@ export class SdTsCompiler {
 interface ITsConfigInfo {
   fileNames: string[];
   options: ts.CompilerOptions;
-  compilerHost: ts.CompilerHost;
   distPath: string;
+}
+
+interface IPrepareResult {
+  tsconfig: ITsConfigInfo;
+  compilerHost: ts.CompilerHost;
+  affectedFileSet: Set<TNormPath>;
+  watchFileSet: Set<TNormPath>;
 }

package/src/types/worker.types.ts

@@ -1,6 +1,10 @@
 import { ISdBuildRunnerWorkerRequest } from "./build-runner.types";
 import { ISdBuildMessage, ISdBuildRunnerResult } from "./build.types";
 import { ESLint } from "eslint";
+import { TNormPath } from "@simplysm/sd-core-node";
+import {
+  ComponentStylesheetResult,
+} from "@angular/build/src/tools/esbuild/angular/component-stylesheets";
 
 export interface TServerWorkerType {
   methods: {
@@ -35,3 +39,16 @@ export interface TSdBuildRunnerWorkerType {
     complete: ISdBuildRunnerResult;
   };
 }
+
+
+export interface TStyleBundlerWorkerType {
+  methods: {
+    prepare: { params: [string, boolean]; returnType: void },
+    bundle: {
+      params: [string, TNormPath, TNormPath | null],
+      returnType: ComponentStylesheetResult
+    },
+    invalidate: { params: [Set<TNormPath>], returnType: void }
+  };
+  events: {};
+}