@simplysm/sd-cli 10.0.36 → 10.0.39

package/src/SdTsIncrementalBuilder.ts

@@ -1,103 +1,125 @@
 import path from "path";
 import ts from "typescript";
-import { SdCliBuildResultUtil } from "./utils/SdCliBuildResultUtil";
-import { FsUtil, Logger, PathUtil } from "@simplysm/sd-core-node";
-import { ISdCliPackageBuildResult } from "./commons";
+import {SdCliBuildResultUtil} from "./utils/SdCliBuildResultUtil";
+import {FsUtil, Logger, PathUtil} from "@simplysm/sd-core-node";
+import {ISdCliPackageBuildResult} from "./commons";
+
+
+interface IOptTransform<T> {
+    fn: (_: ts.Program, arg: T) => ts.TransformerFactory<ts.SourceFile>,
+    args: T
+}
 
 export class SdTsIncrementalBuilder {
-  public builderProgram?: ts.SemanticDiagnosticsBuilderProgram;
-  private readonly _writeFileCache = new Map<string, string>();
-
-  public constructor(private readonly _pkgPath: string,
-                     private readonly _options: ts.CompilerOptions,
-                     private readonly _host: ts.CompilerHost,
-                     private readonly _emitJs: boolean) {
-  }
-
-  public static async createAsync(pkgPath: string, emitJs: boolean): Promise<SdTsIncrementalBuilder> {
-    const tsConfigFilePath = path.resolve(pkgPath, "tsconfig.json");
-    const parsedTsConfig = ts.parseJsonConfigFileContent(await FsUtil.readJsonAsync(tsConfigFilePath), ts.sys, pkgPath);
-    const host = ts.createIncrementalCompilerHost(parsedTsConfig.options);
-    return new SdTsIncrementalBuilder(pkgPath, parsedTsConfig.options, host, emitJs);
-  }
-
-  public async buildAsync(): Promise<{
-    affectedFilePaths: string[];
-    results: ISdCliPackageBuildResult[];
-  }> {
-    const logger = Logger.get(["simplysm", "sd-cli", "SdTsIncrementalBuilder", "buildAsync"]);
-
-    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.{ts,tsx}");
-    const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
-    this.builderProgram = ts.createSemanticDiagnosticsBuilderProgram(
-      srcFilePaths,
-      this._options,
-      this._host,
-      this.builderProgram
-    );
-
-    const diagnostics: ts.Diagnostic[] = [];
-    const affectedFilePaths: string[] = [];
-
-    diagnostics.push(
-      ...this.builderProgram.getOptionsDiagnostics(),
-      ...this.builderProgram.getGlobalDiagnostics(),
-    );
-
-    logger.debug(`[${path.basename(this._pkgPath)}] 영향받는 파일 확인 및 처리중...`);
-    const srcFilePathSet = new Set<string>(srcFilePaths);
-    while (true) {
-      const semanticResult = this.builderProgram.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
-        return !srcFilePathSet.has(path.resolve(sourceFile.fileName));
-      });
-      if (!semanticResult) break;
-      diagnostics.push(...semanticResult.result);
-
-      if ("fileName" in semanticResult.affected) {
-        const emitResult = this.builderProgram.emit(semanticResult.affected, (filePath, data, writeByteOrderMark) => {
-          let realFilePath = filePath; //.replace(/\.js$/, ".mjs");
-          if (PathUtil.isChildPath(realFilePath, path.resolve(this._pkgPath, "dist", path.basename(this._pkgPath), "src"))) {
-            realFilePath = path.resolve(this._pkgPath, "dist", path.relative(path.resolve(this._pkgPath, "dist", path.basename(this._pkgPath), "src"), realFilePath));
-          }
-
-          if (this._writeFileCache.get(realFilePath) !== data) {
-            this._host.writeFile(realFilePath, data, writeByteOrderMark);
-          }
-          this._writeFileCache.set(realFilePath, data);
-        }, undefined, !this._emitJs);
-        diagnostics.push(...emitResult.diagnostics);
-
-        diagnostics.push(...this.builderProgram.getSyntacticDiagnostics(semanticResult.affected));
-        affectedFilePaths.push(path.resolve(semanticResult.affected.fileName));
-      }
-
-      /*const result = this.builderProgram.emitNextAffectedFile((filePath, data, writeByteOrderMark) => {
-        let realFilePath = filePath.replace(/\.js$/, ".mjs");
-        if (PathUtil.isChildPath(realFilePath, path.resolve(this._pkgPath, "dist", path.basename(this._pkgPath), "src"))) {
-          realFilePath = path.resolve(this._pkgPath, "dist", path.relative(path.resolve(this._pkgPath, "dist", path.basename(this._pkgPath), "src"), realFilePath));
-        }
+    public builderProgram?: ts.SemanticDiagnosticsBuilderProgram;
+    private readonly _writeFileCache = new Map<string, string>();
+
+    public constructor(private readonly _pkgPath: string,
+                       private readonly _compilerOptions: ts.CompilerOptions,
+                       private readonly _host: ts.CompilerHost,
+                       private readonly _opt: {
+                           emitJs: boolean | string[],
+                           compilerOptions?: ts.CompilerOptions,
+                           transforms?: IOptTransform<any>[]
+                       }) {
+    }
 
-        if (this._writeFileCache.get(realFilePath) !== data) {
-          ts.sys.writeFile(realFilePath, data, writeByteOrderMark);
-        }
-        this._writeFileCache.set(realFilePath, data);
-      }, undefined, !this._emitJs);
-      if (!result) break;
-      diagnostics.push(...result.result.diagnostics);
-
-      if ("fileName" in result.affected && srcFilePathSet.has(path.resolve(result.affected.fileName))) {
-        diagnostics.push(...this.builderProgram.getSemanticDiagnostics(result.affected));
-        diagnostics.push(...this.builderProgram.getSyntacticDiagnostics(result.affected));
-        affectedFilePaths.push(path.resolve(result.affected.fileName));
-      }*/
+    public static async createAsync(pkgPath: string, optFn: (compilerOptions: ts.CompilerOptions) => {
+        emitJs: boolean | string[],
+        compilerOptions?: ts.CompilerOptions,
+        transforms?: IOptTransform<any>[]
+    }): Promise<SdTsIncrementalBuilder> {
+        const tsConfigFilePath = path.resolve(pkgPath, "tsconfig.json");
+        const parsedTsConfig = ts.parseJsonConfigFileContent(await FsUtil.readJsonAsync(tsConfigFilePath), ts.sys, pkgPath);
+        const opt = optFn(parsedTsConfig.options);
+        const compilerOptions = {
+            ...parsedTsConfig.options,
+            ...opt?.compilerOptions
+        };
+        const host = ts.createIncrementalCompilerHost(compilerOptions);
+        return new SdTsIncrementalBuilder(
+            pkgPath,
+            compilerOptions,
+            host,
+            opt
+        );
     }
-    logger.debug(`[${path.basename(this._pkgPath)}] 영향받는 파일 확인 및 처리 완료`, affectedFilePaths);
 
-    const buildResults = diagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item));
+    public async buildAsync(): Promise<{
+        affectedFilePaths: string[];
+        results: ISdCliPackageBuildResult[];
+    }> {
+        const logger = Logger.get(["simplysm", "sd-cli", "SdTsIncrementalBuilder", "buildAsync"]);
+
+        const distPath = this._compilerOptions.outDir ?? path.resolve(this._pkgPath, "dist");
+        const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.{ts,tsx}");
+        const srcFilePaths = await FsUtil.globAsync(srcGlobPath);
+        this.builderProgram = ts.createSemanticDiagnosticsBuilderProgram(
+            srcFilePaths,
+            this._compilerOptions,
+            this._host,
+            this.builderProgram
+        );
+
+        const diagnostics: ts.Diagnostic[] = [];
+        const affectedFilePaths: string[] = [];
+
+        diagnostics.push(
+            ...this.builderProgram.getOptionsDiagnostics(),
+            ...this.builderProgram.getGlobalDiagnostics(),
+        );
+
+        const program = this.builderProgram.getProgram();
+
+        logger.debug(`[${path.basename(this._pkgPath)}] 영향받는 파일 확인 및 처리중...`);
+        const srcFilePathSet = new Set<string>(srcFilePaths);
+        while (true) {
+            const semanticResult = this.builderProgram.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+                return !srcFilePathSet.has(path.resolve(sourceFile.fileName));
+            });
+            if (!semanticResult) break;
+            diagnostics.push(...semanticResult.result);
+
+            if ("fileName" in semanticResult.affected) {
+                const emitResult = this.builderProgram.emit
+                (semanticResult.affected,
+                    (filePath, data, writeByteOrderMark) => {
+                        let realFilePath = filePath;
+                        let realData = data;
+                        if (PathUtil.isChildPath(realFilePath, path.resolve(distPath, path.basename(this._pkgPath), "src"))) {
+                            realFilePath = path.resolve(distPath, path.relative(path.resolve(distPath, path.basename(this._pkgPath), "src"), realFilePath));
+
+                            if (filePath.endsWith(".js.map")) {
+                                const sourceMapContents = JSON.parse(realData);
+                                sourceMapContents.sources[0] = sourceMapContents.sources[0].slice(6);
+                                realData = JSON.stringify(sourceMapContents);
+                            }
+                        }
+
+                        if (this._writeFileCache.get(realFilePath) !== realData) {
+                            this._host.writeFile(realFilePath, realData, writeByteOrderMark);
+                        }
+                        this._writeFileCache.set(realFilePath, realData);
+                    },
+                    undefined,
+                    Array.isArray(this._opt.emitJs) ? !this._opt.emitJs.includes(path.resolve(semanticResult.affected.fileName)) : !this._opt.emitJs,
+                    this._opt.transforms ? {
+                        before: this._opt.transforms.map((item) => typeof item.fn === "function" ? item.fn(program, item.args) : (item.fn["default"] as any)(program, item.args))
+                    } : undefined
+                );
+                diagnostics.push(...emitResult.diagnostics);
+
+                diagnostics.push(...this.builderProgram.getSyntacticDiagnostics(semanticResult.affected));
+                affectedFilePaths.push(path.resolve(semanticResult.affected.fileName));
+            }
+        }
+        logger.debug(`[${path.basename(this._pkgPath)}] 영향받는 파일 확인 및 처리 완료`, affectedFilePaths);
+
+        const buildResults = diagnostics.map((item) => SdCliBuildResultUtil.convertFromTsDiag(item));
 
-    return {
-      affectedFilePaths,
-      results: buildResults
-    };
-  }
+        return {
+            affectedFilePaths,
+            results: buildResults
+        };
+    }
 }

package/src/build-cluster.ts

@@ -1,133 +1,195 @@
 import cluster from "node:cluster";
-import { SdCliTsLibBuilder } from "./builders/SdCliTsLibBuilder";
-import { FsUtil, Logger, LoggerSeverity } from "@simplysm/sd-core-node";
+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";
+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
-  });
+    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.schedulingPolicy = cluster.SCHED_RR;
+    logger.debug(`메인 프로세스 ${process.pid} 시작`);
 
-  cluster.on("exit", (worker, code) => {
-    logger.debug(`워커 프로세스 ${worker.process.pid} 종료 (code: ${code})`);
-  });
+    cluster.on("exit", (worker, code) => {
+        logger.debug(`워커 프로세스 ${worker.process.pid} 종료 (code: ${code})`);
+    });
 
-  cluster.on("message", (worker, message) => {
-    sendMessage(message);
-  });
+    cluster.on("message", (worker, message) => {
+        sendMessage(message);
+    });
 
-  process.on("message", (message) => {
-    cluster.fork({
-      "SD_CLUSTER_MESSAGE": JSON.stringify(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;
+    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();
+    if (message.cmd === "watch") {
+        // [library] javascript
+        if (message.pkgConf.type === "library" && !FsUtil.exists(path.resolve(message.pkgPath, "tsconfig.json"))) {
+            if (message.withLint) {
+                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, message.pkgConf, message.withLint)
+                .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, message.withLint)
+                .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, message.pkgConf, message.builderKey ?? "web", message.withLint)
+                .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"))) {
+            if (message.withLint) {
+                const result = await new SdCliJsLibLinter(message.pkgPath).buildAsync();
+                sendMessage({
+                    type: "complete",
+                    result,
+                    req: message
+                });
+            } else {
+                sendMessage({
+                    type: "complete",
+                    result: undefined,
+                    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, message.pkgConf, message.withLint).buildAsync();
+            sendMessage({
+                type: "complete",
+                result,
+                req: message
+            });
+        }
+        // [server]
+        else if (message.pkgConf.type === "server") {
+            const result = await new SdCliServerBuilder(message.pkgPath, message.pkgConf, message.withLint).buildAsync();
+            sendMessage({
+                type: "complete",
+                result,
+                req: message
+            });
+        }
+        // [client]
+        else if (message.pkgConf.type === "client") {
+            const result = await new SdCliClientBuilder(message.pkgPath, message.pkgConf, message.builderKey ?? "web", message.withLint).buildAsync();
+            sendMessage({
+                type: "complete",
+                result,
+                req: message
+            });
+        } else {
+            throw new NeverEntryError();
+        }
     }
-  }
 }
 
 function sendMessage(message: ISdCliBuildClusterResMessage): void {
-  process.send!(message);
+    process.send!(message);
 }