@simplysm/sd-cli 10.0.4 → 10.0.21

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

@@ -1,8 +1,8 @@
 import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
 import path from "path";
-import { ISdCliPackageBuildResult } from "../commons";
+import { ISdCliBuilderResult } from "../commons";
 import { EventEmitter } from "events";
-import { ESLint } from "eslint";
+import { SdLinter } from "../SdLinter";
 
 export class SdCliJsLibLinter extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliJsLibLinter"]);
@@ -14,20 +14,23 @@ export class SdCliJsLibLinter extends EventEmitter {
   }
 
   public override on(event: "change", listener: () => void): this;
-  public override on(event: "complete", listener: (result: { affectedFilePaths: string[]; buildResults: ISdCliPackageBuildResult[] }) => 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<ISdCliPackageBuildResult[]> {
+  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 this._lintAsync(srcFilePaths);
+    const lintResults = await SdLinter.lintAsync(srcFilePaths);
 
     this._debug(`LINT 완료`);
-    return lintResults;
+    return {
+      affectedFilePaths: srcFilePaths,
+      buildResults: lintResults
+    };
   }
 
   public async watchAsync(): Promise<void> {
@@ -35,7 +38,7 @@ export class SdCliJsLibLinter extends EventEmitter {
     this._debug("LINT...");
     const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.+(js|cjs|mjs)");
     const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
-    const lintResults = await this._lintAsync(srcFilePaths);
+    const lintResults = await SdLinter.lintAsync(srcFilePaths);
 
     this._debug(`LINT 완료`);
     this.emit("complete", {
@@ -53,7 +56,7 @@ export class SdCliJsLibLinter extends EventEmitter {
 
         this.emit("change");
         this._debug("LINT...");
-        const watchLintResults = await this._lintAsync(watchFilePaths);
+        const watchLintResults = await SdLinter.lintAsync(watchFilePaths);
 
         this._debug(`LINT 완료`);
         this.emit("complete", {
@@ -63,21 +66,6 @@ export class SdCliJsLibLinter extends EventEmitter {
       });
   }
 
-  private async _lintAsync(srcFilePaths: string[]): Promise<ISdCliPackageBuildResult[]> {
-    const linter = new ESLint();
-
-    const lintResults = await linter.lintFiles(srcFilePaths);
-
-    return lintResults.mapMany((lintResult) => lintResult.messages.map((msg) => ({
-      filePath: lintResult.filePath,
-      line: msg.line,
-      char: msg.column,
-      code: msg.ruleId ?? undefined,
-      severity: msg.severity === 1 ? "warning" as const : "error" as const,
-      message: msg.message
-    })));
-  }
-
   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}`);
+  }
+}