@simplysm/sd-cli 12.5.7 → 12.5.8

package/src/builders/SdCliClientBuilder.ts

@@ -1,19 +1,20 @@
-import {EventEmitter} from "events";
-import {FsUtil, Logger, PathUtil, SdFsWatcher} from "@simplysm/sd-core-node";
+import { EventEmitter } from "events";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import {
   INpmConfig,
   ISdCliBuilderResult,
   ISdCliClientPackageConfig,
   ISdCliConfig,
-  ISdCliPackageBuildResult
+  ISdCliPackageBuildResult,
 } from "../commons";
-import {FunctionQueue} from "@simplysm/sd-core-common";
+import { FunctionQueue } from "@simplysm/sd-core-common";
 import path from "path";
-import {SdNgBundler} from "../build-tools/SdNgBundler";
-import {SdCliCordova} from "../build-tools/SdCliCordova";
-import {SdCliNgRoutesFileGenerator} from "../build-tools/SdCliNgRoutesFileGenerator";
-import {SdLinter} from "../build-tools/SdLinter";
-import {SdCliElectron} from "../entry/SdCliElectron";
+import { SdNgBundler } from "../build-tools/SdNgBundler";
+import { SdCliCordova } from "../build-tools/SdCliCordova";
+import { SdCliNgRoutesFileGenerator } from "../build-tools/SdCliNgRoutesFileGenerator";
+import { SdLinter } from "../build-tools/SdLinter";
+import { SdCliElectron } from "../entry/SdCliElectron";
+import { SdReactBundler } from "../build-tools/SdReactBundler";
 
 // import ts from "typescript";
 
@@ -21,13 +22,15 @@ export class SdCliClientBuilder extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliClientBuilder"]);
   private readonly _pkgConf: ISdCliClientPackageConfig;
   private readonly _npmConf: INpmConfig;
-  private _builders?: SdNgBundler[];
+  private _builders?: (SdNgBundler | SdReactBundler)[];
   private _cordova?: SdCliCordova;
 
   // #program?: ts.Program;
 
-  public constructor(private readonly _projConf: ISdCliConfig,
-                     private readonly _pkgPath: string) {
+  public constructor(
+    private readonly _projConf: ISdCliConfig,
+    private readonly _pkgPath: string,
+  ) {
     super();
     this._pkgConf = this._projConf.packages[path.basename(_pkgPath)] as ISdCliClientPackageConfig;
     this._npmConf = FsUtil.readJson(path.resolve(_pkgPath, "package.json")) as INpmConfig;
@@ -46,17 +49,17 @@ export class SdCliClientBuilder extends EventEmitter {
 
     if (this._npmConf.dependencies && Object.keys(this._npmConf.dependencies).includes("@angular/router")) {
       this._debug(`GEN routes.ts...`);
-      await SdCliNgRoutesFileGenerator.runAsync(this._pkgPath);
+      await SdCliNgRoutesFileGenerator.runAsync(this._pkgPath, undefined, this._pkgConf.noLazyRoute);
     }
 
     this._debug("GEN .config...");
     const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
     await FsUtil.writeFileAsync(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
 
-    const result = await this._runAsync({dev: false});
+    const result = await this._runAsync({ dev: false });
     return {
       affectedFilePaths: Array.from(result.affectedFileSet),
-      buildResults: result.buildResults
+      buildResults: result.buildResults,
     };
   }
 
@@ -68,89 +71,116 @@ export class SdCliClientBuilder extends EventEmitter {
 
     if (this._npmConf.dependencies && Object.keys(this._npmConf.dependencies).includes("@angular/router")) {
       this._debug(`WATCH GEN routes.ts...`);
-      await SdCliNgRoutesFileGenerator.watchAsync(this._pkgPath);
+      await SdCliNgRoutesFileGenerator.watchAsync(this._pkgPath, this._pkgConf.noLazyRoute);
     }
 
     this._debug("GEN .config...");
     const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
     await FsUtil.writeFileAsync(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
 
-    const result = await this._runAsync({dev: true});
+    const result = await this._runAsync({ dev: true });
     this.emit("complete", {
       affectedFilePaths: Array.from(result.affectedFileSet),
-      buildResults: result.buildResults
+      buildResults: result.buildResults,
     });
 
     this._debug("WATCH...");
     let changeFiles: string[] = [];
     const fnQ = new FunctionQueue();
-    const watcher = SdFsWatcher
-      .watch(Array.from(result.watchFileSet))
-      .onChange({delay: 100}, (changeInfos) => {
-        changeFiles.push(...changeInfos.map((item) => item.path));
+    const watcher = SdFsWatcher.watch(Array.from(result.watchFileSet)).onChange({ delay: 100 }, (changeInfos) => {
+      changeFiles.push(...changeInfos.map((item) => item.path));
 
-        fnQ.runLast(async () => {
-          const currChangeFiles = [...changeFiles];
-          changeFiles = [];
+      fnQ.runLast(async () => {
+        const currChangeFiles = [...changeFiles];
+        changeFiles = [];
 
-          this.emit("change");
+        this.emit("change");
 
-          for (const builder of this._builders!) {
-            // builder.removeCache(currChangeFiles);
-            builder.markForChanges(currChangeFiles);
-          }
+        for (const builder of this._builders!) {
+          // builder.removeCache(currChangeFiles);
+          builder.markForChanges(currChangeFiles);
+        }
 
-          const watchResult = await this._runAsync({dev: true});
-          this.emit("complete", {
-            affectedFilePaths: Array.from(watchResult.affectedFileSet),
-            buildResults: watchResult.buildResults
-          });
-
-          watcher.add(watchResult.watchFileSet);
+        const watchResult = await this._runAsync({ dev: true });
+        this.emit("complete", {
+          affectedFilePaths: Array.from(watchResult.affectedFileSet),
+          buildResults: watchResult.buildResults,
         });
+
+        watcher.add(watchResult.watchFileSet);
       });
+    });
   }
 
-  private async _runAsync(opt: {
-    dev: boolean;
-  }): Promise<{
+  private async _runAsync(opt: { dev: boolean }): Promise<{
     watchFileSet: Set<string>;
     affectedFileSet: Set<string>;
     buildResults: ISdCliPackageBuildResult[];
   }> {
-    const builderTypes = (Object.keys(this._pkgConf.builder ?? {web: {}}) as ("web" | "electron" | "cordova")[]);
+    const builderTypes = Object.keys(this._pkgConf.builder ?? { web: {} }) as ("web" | "electron" | "cordova")[];
     if (this._pkgConf.builder?.cordova && !this._cordova) {
       this._debug("CORDOVA 준비...");
       this._cordova = new SdCliCordova({
         pkgPath: this._pkgPath,
-        config: this._pkgConf.builder.cordova
+        config: this._pkgConf.builder.cordova,
       });
       await this._cordova.initializeAsync();
     }
 
     if (!this._builders) {
       this._debug(`BUILD 준비...`);
-      this._builders = builderTypes.map((builderType) => new SdNgBundler({
-        dev: opt.dev,
-        builderType: builderType,
-        pkgPath: this._pkgPath,
-        outputPath: builderType === "web" ? path.resolve(this._pkgPath, "dist")
-          : builderType === "electron" && !opt.dev ? path.resolve(this._pkgPath, ".electron/src")
-            : builderType === "cordova" && !opt.dev ? path.resolve(this._pkgPath, ".cordova/www")
-              : path.resolve(this._pkgPath, "dist", builderType),
-        env: {
-          ...this._pkgConf.env,
-          ...this._pkgConf.builder?.[builderType]?.env
-        },
-        browserslist: this._pkgConf.builder?.[builderType]?.browserslist,
-        cordovaConfig: builderType === "cordova" ? this._pkgConf.builder!.cordova : undefined,
-      }));
+
+      if (this._npmConf.dependencies && Object.keys(this._npmConf.dependencies).includes("react")) {
+        this._builders = builderTypes.map(
+          (builderType) =>
+            new SdReactBundler({
+              dev: opt.dev,
+              builderType: builderType,
+              pkgPath: this._pkgPath,
+              outputPath:
+                builderType === "web"
+                  ? path.resolve(this._pkgPath, "dist")
+                  : builderType === "electron" && !opt.dev
+                    ? path.resolve(this._pkgPath, ".electron/src")
+                    : builderType === "cordova" && !opt.dev
+                      ? path.resolve(this._pkgPath, ".cordova/www")
+                      : path.resolve(this._pkgPath, "dist", builderType),
+              env: {
+                ...this._pkgConf.env,
+                ...this._pkgConf.builder?.[builderType]?.env,
+              },
+              cordovaConfig: builderType === "cordova" ? this._pkgConf.builder!.cordova : undefined,
+            }),
+        );
+      } else {
+        this._builders = builderTypes.map(
+          (builderType) =>
+            new SdNgBundler({
+              dev: opt.dev,
+              builderType: builderType,
+              pkgPath: this._pkgPath,
+              outputPath:
+                builderType === "web"
+                  ? path.resolve(this._pkgPath, "dist")
+                  : builderType === "electron" && !opt.dev
+                    ? path.resolve(this._pkgPath, ".electron/src")
+                    : builderType === "cordova" && !opt.dev
+                      ? path.resolve(this._pkgPath, ".cordova/www")
+                      : path.resolve(this._pkgPath, "dist", builderType),
+              env: {
+                ...this._pkgConf.env,
+                ...this._pkgConf.builder?.[builderType]?.env,
+              },
+              cordovaConfig: builderType === "cordova" ? this._pkgConf.builder!.cordova : undefined,
+            }),
+        );
+      }
     }
 
     this._debug(`BUILD & CHECK...`);
     const buildResults = await Promise.all(this._builders.map((builder) => builder.bundleAsync()));
-    const watchFileSet = new Set(buildResults.mapMany(item => Array.from(item.watchFileSet)));
-    const affectedFileSet = new Set(buildResults.mapMany(item => Array.from(item.affectedFileSet)));
+    const watchFileSet = new Set(buildResults.mapMany((item) => Array.from(item.watchFileSet)));
+    const affectedFileSet = new Set(buildResults.mapMany((item) => Array.from(item.affectedFileSet)));
     const results = buildResults.mapMany((item) => item.results).distinct();
     const firstProgram = buildResults.first()?.program;
 
@@ -163,7 +193,10 @@ export class SdCliClientBuilder extends EventEmitter {
     //   oldProgram: this.#program
     // });
     // const pkgFilePaths = filePaths.filter(item => PathUtil.isChildPath(item, this._pkgPath));
-    const lintResults = await SdLinter.lintAsync(Array.from(affectedFileSet).filter(item => PathUtil.isChildPath(item, this._pkgPath)), firstProgram);
+    const lintResults = await SdLinter.lintAsync(
+      Array.from(affectedFileSet).filter((item) => PathUtil.isChildPath(item, this._pkgPath)),
+      firstProgram,
+    );
 
     if (!opt.dev && this._cordova) {
       this._debug("CORDOVA BUILD...");
@@ -174,25 +207,31 @@ export class SdCliClientBuilder extends EventEmitter {
       this._debug("ELECTRON BUILD...");
       await SdCliElectron.buildAsync({
         pkgPath: this._pkgPath,
-        config: this._pkgConf.builder.electron
+        config: this._pkgConf.builder.electron,
       });
     }
 
     this._debug(`빌드 완료`);
-    const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {})
-      .mapMany((key) => FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)));
-    const currWatchFileSet = new Set(Array.from(watchFileSet).filter(item =>
-      PathUtil.isChildPath(item, path.resolve(this._pkgPath, "../")) ||
-      localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu))
-    ));
+    const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {}).mapMany((key) =>
+      FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)),
+    );
+    const currWatchFileSet = new Set(
+      Array.from(watchFileSet).filter(
+        (item) =>
+          PathUtil.isChildPath(item, path.resolve(this._pkgPath, "../")) ||
+          localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu)),
+      ),
+    );
     return {
       watchFileSet: currWatchFileSet,
       affectedFileSet,
-      buildResults: [...results, ...lintResults].filter(item => item.filePath !== path.resolve(this._pkgPath, "src/routes.ts"))
+      buildResults: [...results, ...lintResults].filter(
+        (item) => item.filePath !== path.resolve(this._pkgPath, "src/routes.ts"),
+      ),
     };
   }
 
   private _debug(msg: string): void {
     this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
   }
-}
+}

package/src/builders/SdCliTsLibBuilder.ts

@@ -1,11 +1,11 @@
-import {FsUtil, Logger, PathUtil, SdFsWatcher} from "@simplysm/sd-core-node";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import path from "path";
-import {ISdCliBuilderResult, ISdCliConfig, ISdCliLibPackageConfig, ISdCliPackageBuildResult} from "../commons";
-import {EventEmitter} from "events";
-import {SdTsLibBundler} from "../build-tools/SdTsLibBundler";
-import {SdLinter} from "../build-tools/SdLinter";
-import {FunctionQueue} from "@simplysm/sd-core-common";
-import {SdCliIndexFileGenerator} from "../build-tools/SdCliIndexFileGenerator";
+import { ISdCliBuilderResult, ISdCliConfig, ISdCliLibPackageConfig, ISdCliPackageBuildResult } from "../commons";
+import { EventEmitter } from "events";
+import { SdTsLibBundler } from "../build-tools/SdTsLibBundler";
+import { SdLinter } from "../build-tools/SdLinter";
+import { FunctionQueue } from "@simplysm/sd-core-common";
+import { SdCliIndexFileGenerator } from "../build-tools/SdCliIndexFileGenerator";
 
 export class SdCliTsLibBuilder extends EventEmitter {
   readonly #logger = Logger.get(["simplysm", "sd-cli", "SdCliTsLibBuilder"]);
@@ -16,8 +16,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
 
   #bundler?: SdTsLibBundler;
 
-  public constructor(projConf: ISdCliConfig,
-                     pkgPath: string) {
+  public constructor(projConf: ISdCliConfig, pkgPath: string) {
     super();
     this.#projConf = projConf;
     this.#pkgPath = pkgPath;
@@ -44,7 +43,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
     const result = await this._runAsync(false);
     return {
       affectedFilePaths: Array.from(result.affectedFileSet),
-      buildResults: result.buildResults
+      buildResults: result.buildResults,
     };
   }
 
@@ -62,28 +61,26 @@ export class SdCliTsLibBuilder extends EventEmitter {
     const result = await this._runAsync(true);
     this.emit("complete", {
       affectedFilePaths: Array.from(result.affectedFileSet),
-      buildResults: result.buildResults
+      buildResults: result.buildResults,
     });
 
     this._debug("WATCH...");
     const fnQ = new FunctionQueue();
-    const watcher = SdFsWatcher
-      .watch(Array.from(result.watchFileSet))
-      .onChange({delay: 100,}, (changeInfos) => {
-        this.#bundler!.markChanges(new Set(changeInfos.map((item) => item.path)));
+    const watcher = SdFsWatcher.watch(Array.from(result.watchFileSet)).onChange({ delay: 100 }, (changeInfos) => {
+      this.#bundler!.markChanges(new Set(changeInfos.map((item) => item.path)));
 
-        fnQ.runLast(async () => {
-          this.emit("change");
+      fnQ.runLast(async () => {
+        this.emit("change");
 
-          const watchResult = await this._runAsync(true);
-          this.emit("complete", {
-            affectedFilePaths: Array.from(watchResult.affectedFileSet),
-            buildResults: watchResult.buildResults
-          });
-
-          watcher.add(watchResult.watchFileSet);
+        const watchResult = await this._runAsync(true);
+        this.emit("complete", {
+          affectedFilePaths: Array.from(watchResult.affectedFileSet),
+          buildResults: watchResult.buildResults,
         });
+
+        watcher.add(watchResult.watchFileSet);
       });
+    });
   }
 
   private async _runAsync(dev: boolean): Promise<{
@@ -96,21 +93,27 @@ export class SdCliTsLibBuilder extends EventEmitter {
     const buildResult = await this.#bundler.buildAsync();
 
     this._debug("LINT...");
-    const lintFilePaths = Array.from(buildResult.affectedFileSet).filter(item => PathUtil.isChildPath(item, this.#pkgPath));
+    const lintFilePaths = Array.from(buildResult.affectedFileSet).filter((item) =>
+      PathUtil.isChildPath(item, this.#pkgPath),
+    );
     const lintResults = await SdLinter.lintAsync(lintFilePaths, buildResult.program);
 
     this._debug(`빌드 완료`);
-    const localUpdatePaths = Object.keys(this.#projConf.localUpdates ?? {})
-      .mapMany((key) => FsUtil.glob(path.resolve(this.#pkgPath, "../../node_modules", key)));
-    const watchFileSet = new Set(Array.from(buildResult.watchFileSet).filter(item =>
-      PathUtil.isChildPath(item, path.resolve(this.#pkgPath, "../")) ||
-      localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu))
-    ));
+    const localUpdatePaths = Object.keys(this.#projConf.localUpdates ?? {}).mapMany((key) =>
+      FsUtil.glob(path.resolve(this.#pkgPath, "../../node_modules", key)),
+    );
+    const watchFileSet = new Set(
+      Array.from(buildResult.watchFileSet).filter(
+        (item) =>
+          PathUtil.isChildPath(item, path.resolve(this.#pkgPath, "../")) ||
+          localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu)),
+      ),
+    );
 
     return {
       watchFileSet,
       affectedFileSet: buildResult.affectedFileSet,
-      buildResults: [...buildResult.results, ...lintResults]
+      buildResults: [...buildResult.results, ...lintResults],
     };
   }
 

package/src/bundle-plugins/sdNgPlugin.ts

@@ -2,9 +2,9 @@ import esbuild from "esbuild";
 import ts from "typescript";
 import path from "path";
 import os from "os";
-import {ISdTsCompilerResult, SdTsCompiler} from "../build-tools/SdTsCompiler";
-import {JavaScriptTransformer} from "@angular/build/src/tools/esbuild/javascript-transformer";
-import {convertTypeScriptDiagnostic} from "@angular/build/src/tools/esbuild/angular/diagnostics";
+import { ISdTsCompilerResult, SdTsCompiler } from "../build-tools/SdTsCompiler";
+import { JavaScriptTransformer } from "@angular/build/src/tools/esbuild/javascript-transformer";
+import { convertTypeScriptDiagnostic } from "@angular/build/src/tools/esbuild/angular/diagnostics";
 
 export function sdNgPlugin(conf: {
   pkgPath: string;
@@ -15,18 +15,21 @@ export function sdNgPlugin(conf: {
   return {
     name: "sd-ng-compiler",
     setup: (build: esbuild.PluginBuild) => {
-      const compiler = new SdTsCompiler(conf.pkgPath, {declaration: false}, conf.dev);
+      const compiler = new SdTsCompiler(conf.pkgPath, { declaration: false }, conf.dev);
 
       let buildResult: ISdTsCompilerResult;
       const outputContentsCacheMap = new Map<string, Uint8Array>();
 
       //-- js babel transformer
-      const javascriptTransformer = new JavaScriptTransformer({
-        thirdPartySourcemaps: conf.dev,
-        sourcemap: true, //conf.dev,
-        jit: false,
-        advancedOptimizations: true
-      }, os.cpus().length);
+      const javascriptTransformer = new JavaScriptTransformer(
+        {
+          thirdPartySourcemaps: conf.dev,
+          sourcemap: true, //conf.dev,
+          jit: false,
+          advancedOptimizations: true,
+        },
+        os.cpus().length,
+      );
 
       //---------------------------
 
@@ -45,20 +48,24 @@ export function sdNgPlugin(conf: {
         //-- return err/warn
         return {
           errors: [
-            ...buildResult.typescriptDiagnostics.filter(item => item.category === ts.DiagnosticCategory.Error).map(item => convertTypeScriptDiagnostic(ts, item)),
-            ...Array.from(buildResult.stylesheetBundlingResultMap.values()).flatMap(item => item.errors)
+            ...buildResult.typescriptDiagnostics
+              .filter((item) => item.category === ts.DiagnosticCategory.Error)
+              .map((item) => convertTypeScriptDiagnostic(ts, item)),
+            ...Array.from(buildResult.stylesheetBundlingResultMap.values()).flatMap((item) => item.errors),
           ].filterExists(),
           warnings: [
-            ...buildResult.typescriptDiagnostics.filter(item => item.category !== ts.DiagnosticCategory.Error).map(item => convertTypeScriptDiagnostic(ts, item)),
+            ...buildResult.typescriptDiagnostics
+              .filter((item) => item.category !== ts.DiagnosticCategory.Error)
+              .map((item) => convertTypeScriptDiagnostic(ts, item)),
             // ...Array.from(buildResult.stylesheetResultMap.values()).flatMap(item => item.warnings)
           ],
         };
       });
 
-      build.onLoad({filter: /\.ts$/}, async (args) => {
+      build.onLoad({ filter: /\.ts$/ }, async (args) => {
         const output = outputContentsCacheMap.get(path.normalize(args.path));
         if (output != null) {
-          return {contents: output, loader: "js"};
+          return { contents: output, loader: "js" };
         }
 
         const emittedJsFile = buildResult.emittedFilesCacheMap.get(path.normalize(args.path))?.last();
@@ -68,69 +75,65 @@ export function sdNgPlugin(conf: {
 
         const contents = emittedJsFile.text;
 
-        const {sideEffects} = await build.resolve(args.path, {
-          kind: 'import-statement',
-          resolveDir: build.initialOptions.absWorkingDir ?? '',
+        const { sideEffects } = await build.resolve(args.path, {
+          kind: "import-statement",
+          resolveDir: build.initialOptions.absWorkingDir ?? "",
         });
 
-        const newContents = await javascriptTransformer.transformData(
-          args.path,
-          contents,
-          true,
-          sideEffects
-        );
+        const newContents = await javascriptTransformer.transformData(args.path, contents, true, sideEffects);
 
         outputContentsCacheMap.set(path.normalize(args.path), newContents);
 
-        return {contents: newContents, loader: "js"};
+        return { contents: newContents, loader: "js" };
       });
 
-      build.onLoad(
-        {filter: /\.[cm]?js$/},
-        async (args) => {
-          conf.result.watchFileSet!.add(path.normalize(args.path));
+      build.onLoad({ filter: /\.[cm]?js$/ }, async (args) => {
+        conf.result.watchFileSet!.add(path.normalize(args.path));
 
-          const output = outputContentsCacheMap.get(path.normalize(args.path));
-          if (output != null) {
-            return {contents: output, loader: "js"};
-          }
+        const output = outputContentsCacheMap.get(path.normalize(args.path));
+        if (output != null) {
+          return { contents: output, loader: "js" };
+        }
 
-          const {sideEffects} = await build.resolve(args.path, {
-            kind: 'import-statement',
-            resolveDir: build.initialOptions.absWorkingDir ?? '',
-          });
+        const { sideEffects } = await build.resolve(args.path, {
+          kind: "import-statement",
+          resolveDir: build.initialOptions.absWorkingDir ?? "",
+        });
 
-          const newContents = await javascriptTransformer.transformFile(
-            args.path,
-            false,
-            sideEffects
-          );
+        const newContents = await javascriptTransformer.transformFile(args.path, false, sideEffects);
 
-          outputContentsCacheMap.set(path.normalize(args.path), newContents);
+        outputContentsCacheMap.set(path.normalize(args.path), newContents);
 
-          return {
-            contents: newContents,
-            loader: 'js',
-          };
-        }
-      );
+        return {
+          contents: newContents,
+          loader: "js",
+        };
+      });
 
       build.onLoad(
-        {filter: new RegExp("(" + Object.keys(build.initialOptions.loader!).map(item => "\\" + item).join("|") + ")$")},
+        {
+          filter: new RegExp(
+            "(" +
+              Object.keys(build.initialOptions.loader!)
+                .map((item) => "\\" + item)
+                .join("|") +
+              ")$",
+          ),
+        },
         (args) => {
           conf.result.watchFileSet!.add(path.normalize(args.path));
           return null;
-        }
+        },
       );
 
       build.onEnd((result) => {
-        for (const {outputFiles, metafile} of buildResult.stylesheetBundlingResultMap.values()) {
+        for (const { outputFiles, metafile } of buildResult.stylesheetBundlingResultMap.values()) {
           result.outputFiles = result.outputFiles ?? [];
           result.outputFiles.push(...outputFiles);
 
           if (result.metafile && metafile) {
-            result.metafile.inputs = {...result.metafile.inputs, ...metafile.inputs};
-            result.metafile.outputs = {...result.metafile.outputs, ...metafile.outputs};
+            result.metafile.inputs = { ...result.metafile.inputs, ...metafile.inputs };
+            result.metafile.outputs = { ...result.metafile.outputs, ...metafile.outputs };
           }
         }
 
@@ -139,7 +142,7 @@ export function sdNgPlugin(conf: {
 
         conf.modifiedFileSet.clear();
       });
-    }
+    },
   };
 }
 
@@ -149,4 +152,4 @@ export interface INgPluginResultCache {
   program?: ts.Program;
   outputFiles?: esbuild.OutputFile[];
   metafile?: esbuild.Metafile;
-}
+}