@simplysm/sd-cli 12.9.16 → 12.9.18

package/src/pkg-builders/client/sd-client.build-runner.ts

@@ -1,125 +1,46 @@
-import { EventEmitter } from "events";
-import { FsUtils, PathUtils, SdFsWatcher, SdLogger, TNormPath } from "@simplysm/sd-core-node";
+import { FsUtils, PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
 import path from "path";
 import { SdNgBundler } from "./sd-ng.bundler";
-import { SdCliNgRoutesFileGenerator } from "./sd-cli-ng-routes.file-generator";
 import { SdCliCordova } from "../../entry/sd-cli-cordova";
 import { SdCliElectron } from "../../entry/sd-cli-electron";
-import { ISdClientPackageConfig, ISdProjectConfig } from "../../types/config.types";
+import { BuildRunnerBase, IBuildRunnerRunResult } from "../commons/build-runner.base";
+import { SdCliNgRoutesFileGenerator } from "./sd-cli-ng-routes.file-generator";
 import { INpmConfig } from "../../types/common-configs.types";
-import { ISdBuildMessage, ISdBuildRunnerResult } from "../../types/build.types";
 
-export class SdClientBuildRunner extends EventEmitter {
-  private _logger = SdLogger.get(["simplysm", "sd-cli", "SdClientBuildRunner"]);
-  private _pkgConf: ISdClientPackageConfig;
-  private _npmConf: INpmConfig;
+export class SdClientBuildRunner extends BuildRunnerBase<"client"> {
+  protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdClientBuildRunner"]);
+
   private _ngBundlers?: SdNgBundler[];
   private _cordova?: SdCliCordova;
-  private _watchScopePathSet: Set<TNormPath>;
-
-  constructor(
-    private _projConf: ISdProjectConfig,
-    private _pkgPath: TNormPath,
-  ) {
-    super();
-    this._pkgConf = this._projConf.packages[path.basename(_pkgPath)] as ISdClientPackageConfig;
-    this._npmConf = FsUtils.readJson(path.resolve(_pkgPath, "package.json")) as INpmConfig;
-
-    const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {}).mapMany((key) =>
-      FsUtils.glob(path.resolve(this._pkgPath, "../../node_modules", key)),
-    );
-    this._watchScopePathSet = new Set(
-      [
-        path.resolve(this._pkgPath, "../"),
-        ...localUpdatePaths,
-      ].map((item) => PathUtils.norm(item)),
-    );
-  }
-
-  override on(event: "change", listener: () => void): this;
-  override on(event: "complete", listener: (result: ISdBuildRunnerResult) => void): this;
-  override on(event: string | symbol, listener: (...args: any[]) => void): this {
-    super.on(event, listener);
-    return this;
-  }
-
-  async buildAsync(): Promise<ISdBuildRunnerResult> {
-    this._debug("dist 초기화...");
-    FsUtils.remove(path.resolve(this._pkgPath, "dist"));
 
-    this._debug("GEN .config...");
-    const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
-    FsUtils.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
-
-    if (this._npmConf.dependencies && Object.keys(this._npmConf.dependencies)
-      .includes("@angular/router")) {
-      this._debug(`GEN routes.ts...`);
-      SdCliNgRoutesFileGenerator.run(this._pkgPath, undefined, this._pkgConf.noLazyRoute);
+  protected override async _runAsync(
+    dev: boolean,
+    modifiedFileSet?: Set<TNormPath>,
+  ): Promise<IBuildRunnerRunResult> {
+    if (!modifiedFileSet) {
+      this._debug("GEN .config...");
+      const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
+      FsUtils.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
+
+      const npmConf = FsUtils.readJson(path.resolve(this._pkgPath, "package.json")) as INpmConfig;
+
+      if ("@angular/router" in (npmConf.dependencies ?? {})) {
+        if (!dev) {
+          this._debug(`GEN routes.ts...`);
+          SdCliNgRoutesFileGenerator.run(this._pkgPath, this._pkgConf.noLazyRoute);
+        }
+        else {
+          this._debug(`Watch for GEN routes.ts...`);
+          SdCliNgRoutesFileGenerator.watch(this._pkgPath, this._pkgConf.noLazyRoute);
+        }
+      }
     }
-
-    const result = await this._runAsync({ dev: false });
-    return {
-      affectedFilePathSet: result.affectedFileSet,
-      buildMessages: result.buildMessages,
-      emitFileSet: result.emitFileSet,
-    };
-  }
-
-  async watchAsync() {
-    this.emit("change");
-
-    this._debug("dist 초기화...");
-    FsUtils.remove(path.resolve(this._pkgPath, "dist"));
-
-    if (this._npmConf.dependencies && Object.keys(this._npmConf.dependencies)
-      .includes("@angular/router")) {
-      this._debug(`WATCH GEN routes.ts...`);
-      SdCliNgRoutesFileGenerator.watch(this._pkgPath, this._pkgConf.noLazyRoute);
+    else {
+      for (const ngBundler of this._ngBundlers!) {
+        ngBundler.markForChanges(Array.from(modifiedFileSet));
+      }
     }
 
-    this._debug("GEN .config...");
-    const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
-    FsUtils.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
-
-    const result = await this._runAsync({ dev: !this._pkgConf.forceProductionMode });
-    const res: ISdBuildRunnerResult = {
-      affectedFilePathSet: result.affectedFileSet,
-      buildMessages: result.buildMessages,
-      emitFileSet: result.emitFileSet,
-    };
-    this.emit("complete", res);
-
-    this._debug("WATCH...");
-    let lastWatchFileSet = result.watchFileSet;
-    SdFsWatcher.watch(Array.from(this._watchScopePathSet))
-      .onChange({ delay: 100 }, async (changeInfos) => {
-        const currentChangeInfos = changeInfos.filter((item) => lastWatchFileSet.has(item.path));
-        if (currentChangeInfos.length < 1) return;
-
-        this.emit("change");
-
-        for (const ngBundler of this._ngBundlers!) {
-          ngBundler.markForChanges(currentChangeInfos.map((item) => item.path));
-        }
-
-        const watchResult = await this._runAsync({ dev: !this._pkgConf.forceProductionMode });
-        const watchRes: ISdBuildRunnerResult = {
-          affectedFilePathSet: watchResult.affectedFileSet,
-          buildMessages: watchResult.buildMessages,
-          emitFileSet: watchResult.emitFileSet,
-        };
-        this.emit("complete", watchRes);
-
-        lastWatchFileSet = watchResult.watchFileSet;
-      });
-  }
-
-  private async _runAsync(opt: { dev: boolean }): Promise<{
-    watchFileSet: Set<TNormPath>;
-    affectedFileSet: Set<TNormPath>;
-    buildMessages: ISdBuildMessage[];
-    emitFileSet: Set<TNormPath>;
-  }> {
     const ngBundlerBuilderTypes = Object.keys(this._pkgConf.builder ?? { web: {} }) as (
       | "web"
       | "electron"
@@ -140,15 +61,15 @@ export class SdClientBuildRunner extends EventEmitter {
       this._ngBundlers = ngBundlerBuilderTypes.map(
         (ngBundlerBuilderType) =>
           new SdNgBundler({
-            dev: opt.dev,
+            dev,
             builderType: ngBundlerBuilderType,
             pkgPath: this._pkgPath,
             outputPath:
               ngBundlerBuilderType === "web"
                 ? PathUtils.norm(this._pkgPath, "dist")
-                : ngBundlerBuilderType === "electron" && !opt.dev
+                : ngBundlerBuilderType === "electron" && !dev
                   ? PathUtils.norm(this._pkgPath, ".electron/src")
-                  : ngBundlerBuilderType === "cordova" && !opt.dev
+                  : ngBundlerBuilderType === "cordova" && !dev
                     ? PathUtils.norm(this._pkgPath, ".cordova/www")
                     : PathUtils.norm(this._pkgPath, "dist", ngBundlerBuilderType),
             env: {
@@ -162,7 +83,7 @@ export class SdClientBuildRunner extends EventEmitter {
             cordovaConfig: ngBundlerBuilderType === "cordova"
               ? this._pkgConf.builder!.cordova
               : undefined,
-            watchScopePaths: Array.from(this._watchScopePathSet),
+            watchScopePathSet: this._watchScopePathSet,
           }),
       );
     }
@@ -174,12 +95,12 @@ export class SdClientBuildRunner extends EventEmitter {
     const emitFileSet = new Set(buildResults.mapMany((item) => Array.from(item.emitFileSet)));
     const results = buildResults.mapMany((item) => item.results).distinct();
 
-    if (!opt.dev && this._cordova) {
+    if (!dev && this._cordova) {
       this._debug("CORDOVA BUILD...");
       await this._cordova.buildAsync(path.resolve(this._pkgPath, "dist"));
     }
 
-    if (!opt.dev && this._pkgConf.builder?.electron) {
+    if (!dev && this._pkgConf.builder?.electron) {
       this._debug("ELECTRON BUILD...");
       await SdCliElectron.buildAsync({
         pkgPath: this._pkgPath,
@@ -188,20 +109,12 @@ export class SdClientBuildRunner extends EventEmitter {
     }
 
     this._debug(`빌드 완료`);
-    /*const currWatchFileSet = new Set(
-      Array.from(watchFileSet).filter((item) =>
-        Array.from(this._watchScopePathSet).some((scope) => PathUtil.isChildPath(item, scope)),
-      ),
-    );*/
+
     return {
       watchFileSet,
       affectedFileSet,
-      buildMessages: results, //.filter((item) => item.filePath !== path.resolve(this._pkgPath, "src/routes.ts")),
+      buildMessages: results,
       emitFileSet,
     };
   }
-
-  private _debug(msg: string): void {
-    this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
-  }
 }

package/src/pkg-builders/client/sd-ng.bundler.ts

@@ -45,6 +45,7 @@ import { ISdClientBuilderCordovaConfig } from "../../types/config.types";
 import { ISdCliNgPluginResultCache } from "../../types/build-plugin.types";
 import { ISdBuildMessage } from "../../types/build.types";
 import nodeModule from "node:module";
+import { ScopePathSet } from "../commons/scope-path";
 
 export class SdNgBundler {
   private _logger = SdLogger.get(["simplysm", "sd-cli", "SdNgBundler"]);
@@ -78,7 +79,7 @@ export class SdNgBundler {
       env: Record<string, string> | undefined;
       external: string[];
       cordovaConfig: ISdClientBuilderCordovaConfig | undefined;
-      watchScopePaths: TNormPath[];
+      watchScopePathSet: ScopePathSet;
     },
   ) {
     this._pkgNpmConf = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
@@ -243,7 +244,7 @@ export class SdNgBundler {
       for (const outputFile of outputFiles) {
         const distFilePath = PathUtils.norm(this._opt.outputPath, outputFile.path);
         const prevHash = this._outputHashCache.get(distFilePath);
-        const currHash = HashUtils.get(outputFile.contents);
+        const currHash = HashUtils.get(Buffer.from(outputFile.contents));
         if (prevHash !== currHash) {
           FsUtils.writeFile(distFilePath, outputFile.contents);
           this._outputHashCache.set(distFilePath, currHash);
@@ -522,7 +523,7 @@ export class SdNgBundler {
           dev: this._opt.dev,
           pkgPath: this._opt.pkgPath,
           result: this._ngResultCache,
-          watchScopePaths: this._opt.watchScopePaths,
+          watchScopePathSet: this._opt.watchScopePathSet,
         }),
         ...(this._opt.builderType === "electron"
           ? []

package/src/pkg-builders/client/sd-ng.plugin-creator.ts

@@ -8,13 +8,14 @@ import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.uti
 import { ISdCliNgPluginResultCache } from "../../types/build-plugin.types";
 import { ISdTsCompilerResult } from "../../types/ts-compiler.types";
 import { SdTsCompiler } from "../../ts-compiler/sd-ts-compiler";
+import { ScopePathSet } from "../commons/scope-path";
 
 export function createSdNgPlugin(conf: {
   pkgPath: TNormPath;
   dev: boolean;
   modifiedFileSet: Set<TNormPath>;
   result: ISdCliNgPluginResultCache;
-  watchScopePaths: TNormPath[];
+  watchScopePathSet: ScopePathSet;
 }): esbuild.Plugin {
   let perf: SdCliPerformanceTimer;
   const logger = SdLogger.get(["simplysm", "sd-cli", "createSdNgPlugin"]);
@@ -31,7 +32,7 @@ export function createSdNgPlugin(conf: {
         additionalOptions: { declaration: false },
         isDevMode: conf.dev,
         isForBundle: true,
-        watchScopePaths: conf.watchScopePaths,
+        watchScopePathSet: conf.watchScopePathSet,
       });
 
       let tsCompileResult: ISdTsCompilerResult;

package/src/pkg-builders/commons/build-runner.base.ts

@@ -0,0 +1,149 @@
+import { EventEmitter } from "events";
+import {
+  FsUtils,
+  ISdFsWatcherChangeInfo,
+  PathUtils,
+  SdFsWatcher,
+  SdLogger,
+  TNormPath,
+} from "@simplysm/sd-core-node";
+import { ISdProjectConfig, TSdPackageConfig } from "../../types/config.types";
+import { ISdBuildMessage, ISdBuildRunnerResult } from "../../types/build.types";
+import path from "path";
+import { ScopePathSet } from "./scope-path";
+
+export abstract class BuildRunnerBase<T extends "server" | "library" | "client"> extends EventEmitter {
+  protected abstract _logger: SdLogger;
+
+  protected _pkgName: string;
+  protected _pkgConf: TSdPackageConfig<T>;
+
+  protected _watchScopePathSet: ScopePathSet;
+
+  override on(event: "change", listener: () => void): this;
+  override on(event: "complete", listener: (result: ISdBuildRunnerResult) => void): this;
+  override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  constructor(
+    protected _projConf: ISdProjectConfig,
+    protected _pkgPath: TNormPath,
+  ) {
+    super();
+
+    this._pkgName = path.basename(_pkgPath);
+    this._pkgConf = this._projConf.packages[this._pkgName] as TSdPackageConfig<T>;
+
+    const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {}).mapMany((key) =>
+      FsUtils.glob(path.resolve(this._pkgPath, "../../node_modules", key)),
+    );
+    this._watchScopePathSet = new ScopePathSet(
+      [path.resolve(this._pkgPath, "../"), ...localUpdatePaths].map((item) => PathUtils.norm(item)),
+    );
+  }
+
+  async buildAsync(): Promise<ISdBuildRunnerResult> {
+    const distPath = path.resolve(this._pkgPath, "dist");
+    if (FsUtils.exists(distPath)) {
+      this._debug("dist 초기화...");
+      FsUtils.remove(distPath);
+    }
+
+    const result = await this._runAsync(false);
+    return {
+      affectedFilePathSet: result.affectedFileSet,
+      buildMessages: result.buildMessages,
+      emitFileSet: result.emitFileSet,
+    };
+  }
+
+  async watchAsync() {
+    this.emit("change");
+
+    const distPath = path.resolve(this._pkgPath, "dist");
+    if (FsUtils.exists(distPath)) {
+      this._debug("dist 초기화...");
+      FsUtils.remove(distPath);
+    }
+
+    const result = await this._runAsync(!this._pkgConf.forceProductionMode);
+    const res: ISdBuildRunnerResult = {
+      affectedFilePathSet: result.affectedFileSet,
+      buildMessages: result.buildMessages,
+      emitFileSet: result.emitFileSet,
+    };
+    this.emit("complete", res);
+
+    this._debug("WATCH...");
+    let lastWatchFileSet = result.watchFileSet;
+    SdFsWatcher.watch(this._watchScopePathSet.toArray())
+      .onChange({ delay: 100 }, async (changeInfos) => {
+        const modifiedFileSet = this._getModifiedFileSet(changeInfos, lastWatchFileSet);
+        if (modifiedFileSet.size < 1) return;
+
+        this.emit("change");
+
+        let watchResult: IBuildRunnerRunResult;
+        try {
+          watchResult = await this._runAsync(!this._pkgConf.forceProductionMode, modifiedFileSet);
+
+          lastWatchFileSet = watchResult.watchFileSet;
+        }
+        catch (err) {
+          watchResult = {
+            affectedFileSet: modifiedFileSet,
+            buildMessages: [
+              {
+                filePath: undefined,
+                line: undefined,
+                char: undefined,
+                code: undefined,
+                severity: "error",
+                message: `파일 변경 처리 중 오류 발생: ${err}`,
+                type: "watch",
+              },
+            ],
+            emitFileSet: new Set(),
+            watchFileSet: lastWatchFileSet,
+          };
+        }
+
+        this.emit("complete", {
+          affectedFilePathSet: watchResult.affectedFileSet,
+          buildMessages: watchResult.buildMessages,
+          emitFileSet: watchResult.emitFileSet,
+        });
+      });
+  }
+
+  protected _getModifiedFileSet(
+    changeInfos: ISdFsWatcherChangeInfo[],
+    lastWatchFileSet?: Set<TNormPath>,
+  ) {
+    return new Set(
+      (
+        lastWatchFileSet
+          ? changeInfos.filter((item) => lastWatchFileSet.has(item.path))
+          : changeInfos
+      ).map(item => item.path),
+    );
+  }
+
+  protected abstract _runAsync(
+    dev: boolean,
+    modifiedFileSet?: Set<TNormPath>,
+  ): Promise<IBuildRunnerRunResult>;
+
+  protected _debug(msg: string): void {
+    this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
+  }
+}
+
+export interface IBuildRunnerRunResult {
+  watchFileSet?: Set<TNormPath>;
+  affectedFileSet: Set<TNormPath>;
+  buildMessages: ISdBuildMessage[];
+  emitFileSet: Set<TNormPath>;
+}

package/src/pkg-builders/commons/scope-path.ts

@@ -0,0 +1,17 @@
+import { PathUtils, TNormPath } from "@simplysm/sd-core-node";
+
+export class ScopePathSet {
+  private _data: Set<TNormPath>;
+
+  constructor(arr?: TNormPath[]) {
+    this._data = new Set(arr);
+  }
+
+  inScope(filePath: string) {
+    return Array.from(this._data).some((scope) => PathUtils.isChildPath(filePath, scope));
+  }
+
+  toArray() {
+    return Array.from(this._data);
+  }
+}

package/src/pkg-builders/lib/sd-cli-index.file-generator.ts

@@ -26,7 +26,7 @@ export class SdCliIndexFileGenerator {
     }
 
     // 내부 파일들 import
-    const filePaths = this.#getFilePaths(pkgPath);
+    const filePaths = this._getFilePaths(pkgPath);
     for (const filePath of filePaths.orderBy()) {
       const requirePath = PathUtils.posix(path.relative(path.dirname(indexFilePath), filePath))
         .replace(/\.tsx?$/, "")
@@ -47,7 +47,7 @@ export class SdCliIndexFileGenerator {
     return content;
   }
 
-  static #getFilePaths(pkgPath: string): string[] {
+  private static _getFilePaths(pkgPath: string): string[] {
     const indexFilePath = path.resolve(pkgPath, "src/index.ts");
 
     const tsconfig = FsUtils.readJson(path.resolve(pkgPath, "tsconfig.json"));

package/src/pkg-builders/lib/sd-js-lib.build-runner.ts

@@ -1,94 +1,53 @@
-import { FsUtils, SdLogger, PathUtils, SdFsWatcher } from "@simplysm/sd-core-node";
+import {
+  FsUtils,
+  ISdFsWatcherChangeInfo,
+  PathUtils,
+  SdLogger,
+  TNormPath,
+} from "@simplysm/sd-core-node";
 import path from "path";
-import { EventEmitter } from "events";
 import { SdCliConvertMessageUtils } from "../../utils/sd-cli-convert-message.utils";
 // import { TSdLintWorkerType } from "../../types/workers.type";
-import { ISdProjectConfig } from "../../types/config.types";
-import { ISdBuildRunnerResult } from "../../types/build.types";
 import { ESLint } from "eslint";
+import { BuildRunnerBase, IBuildRunnerRunResult } from "../commons/build-runner.base";
 
-export class SdJsLibBuildRunner extends EventEmitter {
-  private readonly _logger = SdLogger.get(["simplysm", "sd-cli", "SdJsLibBuildRunner"]);
-  private readonly _pkgName: string;
+export class SdJsLibBuildRunner extends BuildRunnerBase<"library"> {
+  protected override _logger = SdLogger.get(["simplysm", "sd-cli", "SdJsLibBuildRunner"]);
 
-  // private readonly _lintWorker: SdWorker<TSdLintWorkerType>;
+  protected override async _runAsync(
+    dev: boolean,
+    modifiedFileSet?: Set<TNormPath>,
+  ): Promise<IBuildRunnerRunResult> {
+    const filePathSet = modifiedFileSet ?? new Set(
+      FsUtils.glob(path.resolve(this._pkgPath, "src/**/*.js")).map(item => PathUtils.norm(item)),
+    );
 
-  constructor(
-    private readonly _projConf: ISdProjectConfig,
-    private readonly _pkgPath: string,
-  ) {
-    super();
-    this._pkgName = path.basename(_pkgPath);
-
-    // this._lintWorker = new SdWorker(import.meta.resolve("../../workers/lint-worker"));
-  }
-
-  override on(event: "change", listener: () => void): this;
-  override on(event: "complete", listener: (result: ISdBuildRunnerResult) => void): this;
-  override on(event: string | symbol, listener: (...args: any[]) => void): this {
-    super.on(event, listener);
-    return this;
-  }
-
-  async buildAsync(): Promise<ISdBuildRunnerResult> {
     this._debug("LINT...");
-    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.js");
-    const srcFilePaths = FsUtils.glob(srcGlobPath);
 
-    const lintResults = await this.#lintAsync(new Set(srcFilePaths));
+    const lintResults = await this._lintAsync(filePathSet);
     const messages = SdCliConvertMessageUtils.convertToBuildMessagesFromEslint(lintResults);
 
     this._debug(`LINT 완료`);
+
     return {
-      affectedFilePathSet: new Set(srcFilePaths.map((item) => PathUtils.norm(item))),
+      affectedFileSet: filePathSet,
       buildMessages: messages,
       emitFileSet: new Set(),
     };
   }
 
-  async watchAsync(): Promise<void> {
-    this.emit("change");
-    this._debug("LINT...");
-    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.js");
-    const srcFilePaths = FsUtils.glob(srcGlobPath);
-
-    const lintResults = await this.#lintAsync(new Set(srcFilePaths));
-    const messages = SdCliConvertMessageUtils.convertToBuildMessagesFromEslint(lintResults);
-
-    this._debug(`LINT 완료`);
-    const res: ISdBuildRunnerResult = {
-      affectedFilePathSet: new Set(srcFilePaths.map((item) => PathUtils.norm(item))),
-      buildMessages: messages,
-      emitFileSet: new Set(),
-    };
-    this.emit("complete", res);
-
-    SdFsWatcher.watch([srcGlobPath]).onChange({ delay: 100 }, async (changeInfos) => {
-      const watchFilePaths = changeInfos.filter((item) => FsUtils.exists(item.path)).map((item) => item.path);
-      if (watchFilePaths.length < 1) return;
-
-      this.emit("change");
-
-      this._debug("LINT...");
-
-      const watchLintResults = await this.#lintAsync(new Set(watchFilePaths));
-      const watchMessages = SdCliConvertMessageUtils.convertToBuildMessagesFromEslint(watchLintResults);
-
-      this._debug(`LINT 완료`);
-
-      const watchRes: ISdBuildRunnerResult = {
-        affectedFilePathSet: new Set(changeInfos.map((item) => PathUtils.norm(item.path))),
-        buildMessages: watchMessages,
-        emitFileSet: new Set(),
-      };
-
-      this.emit("complete", watchRes);
-    });
+  protected override _getModifiedFileSet(changeInfos: ISdFsWatcherChangeInfo[]) {
+    return new Set(
+      changeInfos.filter((item) =>
+        FsUtils.exists(item.path)
+        && PathUtils.isChildPath(item.path, path.resolve(this._pkgPath, "src")),
+      ).map(item => item.path),
+    );
   }
 
-  async #lintAsync(fileSet: Set<string>) {
+  private async _lintAsync(fileSet: Set<string>) {
     const lintFilePaths = Array.from(fileSet)
-      .filter((item) => PathUtils.isChildPath(item, this._pkgPath))
+      .filter((item) => PathUtils.isChildPath(item, path.resolve(this._pkgPath, "src")))
       .filter((item) => item.endsWith(".js"))
       .filter((item) => FsUtils.exists(item));
 
@@ -99,8 +58,4 @@ export class SdJsLibBuildRunner extends EventEmitter {
     const linter = new ESLint({ cwd: this._pkgPath, cache: false });
     return await linter.lintFiles(lintFilePaths);
   }
-
-  private _debug(msg: string): void {
-    this._logger.debug(`[${this._pkgName}] ${msg}`);
-  }
 }