@simplysm/sd-cli 7.3.4 → 10.0.21

package/src/build-cluster.ts

@@ -0,0 +1,133 @@
+import cluster from "node:cluster";
+import { SdCliTsLibBuilder } from "./builders/SdCliTsLibBuilder";
+import { FsUtil, Logger, LoggerSeverity } from "@simplysm/sd-core-node";
+import path from "path";
+import { SdCliJsLibLinter } from "./builders/SdCliJsLibLinter";
+import { EventEmitter } from "events";
+import { ISdCliBuildClusterReqMessage, ISdCliBuildClusterResMessage } from "./commons";
+import { NeverEntryError } from "@simplysm/sd-core-common";
+import { SdCliServerBuilder } from "./builders/SdCliServerBuilder";
+import { SdCliClientBuilder } from "./builders/SdCliClientBuilder";
+
+Error.stackTraceLimit = Infinity;
+EventEmitter.defaultMaxListeners = 0;
+
+if (Boolean(process.env["SD_DEBUG"])) {
+  Logger.setConfig({
+    console: {
+      level: LoggerSeverity.debug
+    }
+  });
+}
+else {
+  Logger.setConfig({
+    dot: true
+  });
+}
+
+const logger = Logger.get(["simplysm", "sd-cli", "build-cluster"]);
+
+if (cluster.isPrimary) {
+  logger.debug(`메인 프로세스 ${process.pid} 시작`);
+
+  cluster.on("exit", (worker, code) => {
+    logger.debug(`워커 프로세스 ${worker.process.pid} 종료 (code: ${code})`);
+  });
+
+  cluster.on("message", (worker, message) => {
+    sendMessage(message);
+  });
+
+  process.on("message", (message) => {
+    cluster.fork({
+      "SD_CLUSTER_MESSAGE": JSON.stringify(message)
+    });
+  });
+  process.send!("ready");
+}
+else {
+  const message = JSON.parse(process.env["SD_CLUSTER_MESSAGE"]!) as ISdCliBuildClusterReqMessage;
+
+  if (message.cmd === "watch") {
+    // [library] javascript
+    if (message.pkgConf.type === "library" && !FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
+      await new SdCliJsLibLinter(message.pkgPath)
+        .on("change", () => {
+          sendMessage({ type: "change", req: message });
+        })
+        .on("complete", (result) => {
+          sendMessage({ type: "complete", result, req: message });
+        })
+        .watchAsync();
+      sendMessage({ type: "ready", req: message });
+    }
+    // [library] typescript
+    else if (message.pkgConf.type === "library" && FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
+      await new SdCliTsLibBuilder(message.pkgPath)
+        .on("change", () => {
+          sendMessage({ type: "change", req: message });
+        })
+        .on("complete", (result) => {
+          sendMessage({ type: "complete", result, req: message });
+        })
+        .watchAsync();
+      sendMessage({ type: "ready", req: message });
+    }
+    // [server]
+    else if (message.pkgConf.type === "server") {
+      await new SdCliServerBuilder(message.pkgPath, message.pkgConf)
+        .on("change", () => {
+          sendMessage({ type: "change", req: message });
+        })
+        .on("complete", (result) => {
+          sendMessage({ type: "complete", result, req: message });
+        })
+        .watchAsync();
+      sendMessage({ type: "ready", req: message });
+    }
+    // [client]
+    else if (message.pkgConf.type === "client") {
+      await new SdCliClientBuilder(message.pkgPath)
+        .on("change", () => {
+          sendMessage({ type: "change", req: message });
+        })
+        .on("complete", (result) => {
+          sendMessage({ type: "complete", result, req: message });
+        })
+        .watchAsync();
+      sendMessage({ type: "ready", req: message });
+    }
+    else {
+      throw new NeverEntryError();
+    }
+  }
+  else { // build
+    // [library] javascript
+    if (message.pkgConf.type === "library" && !FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
+      const result = await new SdCliJsLibLinter(message.pkgPath).buildAsync();
+      sendMessage({ type: "complete", result, req: message });
+    }
+    // [library] typescript
+    else if (message.pkgConf.type === "library" && FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
+      const result = await new SdCliTsLibBuilder(message.pkgPath).buildAsync();
+      sendMessage({ type: "complete", result, req: message });
+    }
+    // [server]
+    else if (message.pkgConf.type === "server") {
+      const result = await new SdCliServerBuilder(message.pkgPath, message.pkgConf).buildAsync();
+      sendMessage({ type: "complete", result, req: message });
+    }
+    // [server]
+    else if (message.pkgConf.type === "client") {
+      const result = await new SdCliClientBuilder(message.pkgPath).buildAsync();
+      sendMessage({ type: "complete", result, req: message });
+    }
+    else {
+      throw new NeverEntryError();
+    }
+  }
+}
+
+function sendMessage(message: ISdCliBuildClusterResMessage): void {
+  process.send!(message);
+}

package/src/builders/SdCliClientBuilder.ts

@@ -0,0 +1,189 @@
+import { EventEmitter } from "events";
+import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
+import { ISdCliBuilderResult, ISdCliPackageBuildResult } from "../commons";
+import { FunctionQueue, MathUtil } from "@simplysm/sd-core-common";
+import * as vite from "vite";
+import { createLogger } from "vite";
+import vitePluginReact from "@vitejs/plugin-react";
+import vitePluginPaths from "vite-tsconfig-paths";
+import path from "path";
+import { SdTsIncrementalBuilder } from "../SdTsIncrementalBuilder";
+import { SdLinter } from "../SdLinter";
+
+export class SdCliClientBuilder extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliClientBuilder"]);
+
+  public constructor(private readonly _pkgPath: string) {
+    super();
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: ISdCliBuilderResult) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  public async watchAsync(): Promise<number> {
+    this._debug("빌드 준비...");
+    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, false);
+
+    this.emit("change");
+
+    this._debug("BUILD...");
+    const viteServerPort = MathUtil.getRandomInt(60000, 65535);
+    const viteServer = await vite.createServer({
+      mode: "development",
+      root: path.resolve(this._pkgPath, "src"),
+      cacheDir: path.resolve(this._pkgPath, ".cache", "vite"),
+      base: "/" + path.basename(this._pkgPath) + "/",
+      server: {
+        hmr: {
+          port: viteServerPort
+        }
+      },
+      customLogger: {
+        ...createLogger(),
+        info: (msg) => {
+          this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
+        },
+        warn: (msg) => {
+          this._logger.warn(`[${path.basename(this._pkgPath)}] ${msg}`);
+        },
+        error: (msg) => {
+          this._logger.error(`[${path.basename(this._pkgPath)}] ${msg}`);
+        }
+      },
+      plugins: [
+        vitePluginReact(),
+        vitePluginPaths(),
+        {
+          name: "simplysm",
+          configureServer: (server: vite.ViteDevServer) => {
+            (server.watcher.options.ignored as string[]).remove("**/node_modules/**");
+          }
+        }
+      ]
+    });
+    await viteServer.listen(viteServerPort);
+
+    this._debug("CHECK...");
+    const checkResult = await sdTsProgram.buildAsync();
+
+    this._debug("LINT...");
+    const lintResults = await SdLinter.lintAsync(checkResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+    this._debug("WATCH...");
+    const fnQ = new FunctionQueue();
+    SdFsWatcher
+      .watch([
+        ...sdTsProgram.builderProgram!.getSourceFiles().map((item) => item.fileName),
+        path.resolve(this._pkgPath, "src/**/*.{ts,tsx}")
+      ])
+      .onChange({
+        delay: 100
+      }, () => {
+        fnQ.runLast(async () => {
+          this.emit("change");
+
+          this._debug(`CHECK...`);
+          const watchCheckResult = await sdTsProgram.buildAsync();
+
+          this._debug(`LINT...`);
+          const watchLintResults = await SdLinter.lintAsync(watchCheckResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+          this._debug(`빌드 완료`);
+          this.emit("complete", {
+            port: viteServerPort,
+            affectedFilePaths: watchCheckResult.affectedFilePaths,
+            buildResults: [...watchCheckResult.results, ...watchLintResults]
+          });
+        });
+      });
+
+    this._debug(`빌드 완료`);
+    this.emit("complete", {
+      port: viteServerPort,
+      affectedFilePaths: checkResult.affectedFilePaths,
+      buildResults: [...checkResult.results, ...lintResults]
+    });
+
+    return viteServerPort;
+  }
+
+  public async buildAsync(): Promise<ISdCliBuilderResult> {
+    this._debug("빌드 준비...");
+    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, false);
+
+    this._debug("dist 초기화...");
+    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
+
+    this._debug("BUILD...");
+    const buildResults: ISdCliPackageBuildResult[] = [];
+    try {
+      await vite.build({
+        mode: "production",
+        root: path.resolve(this._pkgPath, "src"),
+        cacheDir: path.resolve(this._pkgPath, ".cache", "vite"),
+        base: "/" + path.basename(this._pkgPath) + "/",
+        build: {
+          outDir: path.resolve(this._pkgPath, "dist")
+        },
+        customLogger: {
+          ...createLogger(),
+          info: (msg) => {
+            this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
+          },
+          warn: (msg) => {
+            this._logger.warn(`[${path.basename(this._pkgPath)}] ${msg}`);
+          },
+          error: (msg) => {
+            this._logger.error(`[${path.basename(this._pkgPath)}] ${msg}`);
+          }
+        },
+        plugins: [
+          vitePluginReact(),
+          vitePluginPaths()
+        ],
+      });
+    }
+    catch (err) {
+      if ("errors" in err && err.errors instanceof Array) {
+        buildResults.push(...err.errors.map((item) => ({
+          filePath: item.location.file,
+          line: item.location.line,
+          char: item.location.column,
+          code: undefined,
+          severity: "error" as const,
+          message: item.text
+        })));
+      }
+      if ("warnings" in err && err.warnings instanceof Array) {
+        buildResults.push(...err.warnings.map((item) => ({
+          filePath: item.location.file,
+          line: item.location.line,
+          char: item.location.column,
+          code: undefined,
+          severity: "warning" as const,
+          message: item.text
+        })));
+      }
+    }
+
+    this._debug("CHECK...");
+    const checkResult = await sdTsProgram.buildAsync();
+
+    this._debug("LINT...");
+    const lintResults = await SdLinter.lintAsync(checkResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+    this._debug(`빌드 완료`);
+    return {
+      affectedFilePaths: checkResult.affectedFilePaths,
+      buildResults: [...buildResults, ...checkResult.results, ...lintResults]
+    };
+  }
+
+  private _debug(msg: string): void {
+    this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
+  }
+}

package/src/builders/SdCliJsLibLinter.ts

@@ -0,0 +1,72 @@
+import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
+import path from "path";
+import { ISdCliBuilderResult } from "../commons";
+import { EventEmitter } from "events";
+import { SdLinter } from "../SdLinter";
+
+export class SdCliJsLibLinter extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliJsLibLinter"]);
+  private readonly _pkgName: string;
+
+  public constructor(private readonly _pkgPath: string) {
+    super();
+    this._pkgName = path.basename(_pkgPath);
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: ISdCliBuilderResult) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  public async buildAsync(): Promise<ISdCliBuilderResult> {
+    this._debug("LINT...");
+    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.+(js|cjs|mjs)");
+    const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
+    const lintResults = await SdLinter.lintAsync(srcFilePaths);
+
+    this._debug(`LINT 완료`);
+    return {
+      affectedFilePaths: srcFilePaths,
+      buildResults: lintResults
+    };
+  }
+
+  public async watchAsync(): Promise<void> {
+    this.emit("change");
+    this._debug("LINT...");
+    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.+(js|cjs|mjs)");
+    const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
+    const lintResults = await SdLinter.lintAsync(srcFilePaths);
+
+    this._debug(`LINT 완료`);
+    this.emit("complete", {
+      affectedFilePaths: srcFilePaths,
+      buildResults: lintResults
+    });
+
+    SdFsWatcher
+      .watch([srcGlobPath])
+      .onChange({
+        delay: 100
+      }, async (changeInfos) => {
+        const watchFilePaths = changeInfos.filter((item) => FsUtil.exists(item.path)).map((item) => item.path);
+        if (watchFilePaths.length < 1) return;
+
+        this.emit("change");
+        this._debug("LINT...");
+        const watchLintResults = await SdLinter.lintAsync(watchFilePaths);
+
+        this._debug(`LINT 완료`);
+        this.emit("complete", {
+          affectedFilePaths: changeInfos.map((item) => item.path),
+          buildResults: watchLintResults
+        });
+      });
+  }
+
+  private _debug(msg: string): void {
+    this._logger.debug(`[${this._pkgName}] ${msg}`);
+  }
+}

package/src/builders/SdCliServerBuilder.ts

@@ -0,0 +1,191 @@
+import { EventEmitter } from "events";
+import { FsUtil, Logger } from "@simplysm/sd-core-node";
+import { ISdCliBuilderResult, ISdCliServerPackageConfig } from "../commons";
+import esbuild from "esbuild";
+import path from "path";
+import { SdTsIncrementalBuilder } from "../SdTsIncrementalBuilder";
+import { SdLinter } from "../SdLinter";
+
+export class SdCliServerBuilder extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliServerBuilder"]);
+
+  public constructor(private readonly _pkgPath: string,
+                     private readonly _pkgConf: ISdCliServerPackageConfig) {
+    super();
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: ISdCliBuilderResult) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  public async watchAsync(): Promise<void> {
+    this._debug("빌드 준비...");
+    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, false);
+
+    this._debug("dist 초기화...");
+    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
+
+    this.emit("change");
+
+    this._debug(`BUILD...`);
+    let isFirst = true;
+    const ctx = await esbuild.context({
+      entryPoints: {
+        index: path.resolve(this._pkgPath, "src", "main.ts")
+      },
+      bundle: true,
+      target: "node20",
+      mainFields: ["es2021", "es2020", "module", "main"],
+      conditions: ["es2021", "es2020", "es2015", "module"],
+      tsconfig: path.resolve(this._pkgPath, "tsconfig.json"),
+      write: true,
+      format: "esm",
+      outExtension: { ".js": ".mjs" },
+      platform: "node",
+      logLevel: "silent",
+      outfile: path.resolve(this._pkgPath, "dist", "main.mjs"),
+      external: [
+        ...this._pkgConf.externals ?? []
+      ],
+      banner: {
+        js: `
+import __path__ from 'path';
+import { fileURLToPath as __fileURLToPath__ } from 'url';
+import { createRequire as __createRequire__ } from 'module';
+
+const require = __createRequire__(import.meta.url);
+const __filename = __fileURLToPath__(import.meta.url);
+const __dirname = __path__.dirname(__filename);`.trim()
+      },
+      plugins: [
+        {
+          name: "sd-additional",
+          setup: ({ onEnd, onStart }) => {
+            onStart(() => {
+              if (!isFirst) {
+                this.emit("change");
+                this._debug(`BUILD...`);
+              }
+              isFirst = false;
+            });
+
+            onEnd(async (result) => {
+              try {
+                const buildResults = [
+                  ...result.warnings.map((warn) => ({
+                    filePath: warn.location?.file !== undefined ? path.resolve(warn.location.file) : undefined,
+                    line: warn.location?.line,
+                    char: warn.location?.column,
+                    code: undefined,
+                    severity: "warning" as const,
+                    message: warn.text
+                  })),
+                  ...result.errors.map((err) => ({
+                    filePath: err.location?.file !== undefined ? path.resolve(err.location.file) : undefined,
+                    line: err.location?.line,
+                    char: err.location?.column !== undefined ? err.location.column + 1 : undefined,
+                    code: undefined,
+                    severity: "error" as const,
+                    message: err.text
+                  }))
+                ];
+
+                this._debug("CHECK...");
+                const checkResult = await sdTsProgram.buildAsync();
+
+                this._debug("LINT...");
+                const lintResults = await SdLinter.lintAsync(checkResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+                this._debug(`빌드 완료`);
+                this.emit("complete", {
+                  affectedFilePaths: checkResult.affectedFilePaths,
+                  buildResults: [...buildResults, ...checkResult.results, ...lintResults]
+                });
+              }
+              catch (err) {
+                this._logger.error(err);
+              }
+            });
+          }
+        }
+      ]
+    });
+    await ctx.watch();
+  }
+
+  public async buildAsync(): Promise<ISdCliBuilderResult> {
+    this._debug("빌드 준비...");
+    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, false);
+
+    this._debug("dist 초기화...");
+    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
+
+    this._debug("BUILD...");
+    const esbuildResult = await esbuild.build({
+      entryPoints: {
+        index: path.resolve(this._pkgPath, "src", "main.ts")
+      },
+      bundle: true,
+      target: "node20",
+      mainFields: ["es2021", "es2020", "module", "main"],
+      conditions: ["es2021", "es2020", "es2015", "module"],
+      tsconfig: path.resolve(this._pkgPath, "tsconfig.json"),
+      write: true,
+      format: "esm",
+      outExtension: { ".js": ".mjs" },
+      platform: "node",
+      logLevel: "silent",
+      outfile: path.resolve(this._pkgPath, "dist", "main.mjs"),
+      external: [
+        ...this._pkgConf.externals ?? []
+      ],
+      banner: {
+        js: `
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire as topLevelCreateRequire } from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);`.trim()
+      },
+    });
+
+    const buildResults = [
+      ...esbuildResult.warnings.map((warn) => ({
+        filePath: warn.location?.file !== undefined ? path.resolve(warn.location.file) : undefined,
+        line: warn.location?.line,
+        char: warn.location?.column,
+        code: undefined,
+        severity: "warning" as const,
+        message: warn.text
+      })),
+      ...esbuildResult.errors.map((err) => ({
+        filePath: err.location?.file !== undefined ? path.resolve(err.location.file) : undefined,
+        line: err.location?.line,
+        char: err.location?.column !== undefined ? err.location.column + 1 : undefined,
+        code: undefined,
+        severity: "warning" as const,
+        message: err.text
+      }))
+    ];
+
+    this._debug("CHECK...");
+    const checkResult = await sdTsProgram.buildAsync();
+
+    this._debug("LINT...");
+    const lintResults = await SdLinter.lintAsync(checkResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+    this._debug(`빌드 완료`);
+    return {
+      affectedFilePaths: checkResult.affectedFilePaths,
+      buildResults: [...buildResults, ...checkResult.results, ...lintResults]
+    };
+  }
+
+  private _debug(msg: string): void {
+    this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
+  }
+}

package/src/builders/SdCliTsLibBuilder.ts

@@ -0,0 +1,96 @@
+import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
+import path from "path";
+import { ISdCliBuilderResult } from "../commons";
+import { EventEmitter } from "events";
+import { FunctionQueue } from "@simplysm/sd-core-common";
+import { SdTsIncrementalBuilder } from "../SdTsIncrementalBuilder";
+import { SdLinter } from "../SdLinter";
+
+export class SdCliTsLibBuilder extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliTsLibBuilder"]);
+
+  public constructor(private readonly _pkgPath: string) {
+    super();
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: ISdCliBuilderResult) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  public async buildAsync(): Promise<ISdCliBuilderResult> {
+    this._debug("빌드 준비...");
+    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, true);
+
+    this._debug("dist 초기화...");
+    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
+
+    this._debug("BUILD...");
+    const buildResult = await sdTsProgram.buildAsync();
+
+
+    this._debug("LINT...");
+    const lintResults = await SdLinter.lintAsync(buildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+    this._debug(`빌드 완료`);
+    return {
+      affectedFilePaths: buildResult.affectedFilePaths,
+      buildResults: [...buildResult.results, ...lintResults]
+    };
+  }
+
+  public async watchAsync(): Promise<void> {
+    this._debug("빌드 준비...");
+    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, true);
+
+    this._debug("dist 초기화...");
+    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
+
+    this.emit("change");
+
+    this._debug("BUILD...");
+    const buildResult = await sdTsProgram.buildAsync();
+
+    this._debug("LINT...");
+    const lintResults = await SdLinter.lintAsync(buildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+    this._debug(`빌드 완료`);
+    this.emit("complete", {
+      affectedFilePaths: buildResult.affectedFilePaths,
+      buildResults: [...buildResult.results, ...lintResults]
+    });
+
+    this._debug("WATCH...");
+    const fnQ = new FunctionQueue();
+    SdFsWatcher
+      .watch([
+        ...sdTsProgram.builderProgram!.getSourceFiles().map((item) => item.fileName),
+        path.resolve(this._pkgPath, "src/**/*.{ts,tsx}")
+      ])
+      .onChange({
+        delay: 100
+      }, () => {
+        fnQ.runLast(async () => {
+          this.emit("change");
+
+          this._debug(`BUILD...`);
+          const watchBuildResult = await sdTsProgram.buildAsync();
+
+          this._debug(`LINT...`);
+          const watchLintResults = await SdLinter.lintAsync(watchBuildResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+          this._debug(`빌드 완료`);
+          this.emit("complete", {
+            affectedFilePaths: watchBuildResult.affectedFilePaths,
+            buildResults: [...watchBuildResult.results, ...watchLintResults]
+          });
+        });
+      });
+  }
+
+  private _debug(msg: string): void {
+    this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);
+  }
+}