@simplysm/sd-cli 11.1.45 → 11.1.51

package/src/bundle-plugins/sdServerPlugin.ts

@@ -1,203 +1,60 @@
 import esbuild from "esbuild";
-import {FsUtil} from "@simplysm/sd-core-node";
 import ts from "typescript";
 import path from "path";
 import {convertTypeScriptDiagnostic} from "@angular-devkit/build-angular/src/tools/esbuild/angular/diagnostics";
+import {ISdTsCompiler2Result, SdTsCompiler} from "../build-tools/SdTsCompiler";
 
 export function sdServerPlugin(conf: {
   pkgPath: string;
   dev: boolean;
   modifiedFileSet: Set<string>;
-  result: IServerBundlerResultCache;
+  result: IServerPluginResultCache;
 }): esbuild.Plugin {
-  const tsConfigPath = path.resolve(conf.pkgPath, "tsconfig.json");
-  const tsConfig = FsUtil.readJson(tsConfigPath);
-  const parsedTsConfig = ts.parseJsonConfigFileContent(tsConfig, ts.sys, conf.pkgPath, {
-    declaration: false
-  });
-
-  const sourceFileCache = new Map<string, ts.SourceFile>();
-  const referencingMap = new Map<string, Set<string>>();
-
-  let program: ts.Program | undefined;
-  let builder: ts.EmitAndSemanticDiagnosticsBuilderProgram | undefined;
-
-  let resultCache: IResultCache = {
-    watchFileSet: new Set<string>(),
-    affectedFileSet: new Set<string>()
-  };
-  const tscPrepareMap = new Map<string, string>();
-
-  function createCompilerHost() {
-    const compilerHost = ts.createIncrementalCompilerHost(parsedTsConfig.options);
-    const baseGetSourceFile = compilerHost.getSourceFile;
-    compilerHost.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile, ...args) => {
-      if (!shouldCreateNewSourceFile && sourceFileCache.has(path.normalize(fileName))) {
-        return sourceFileCache.get(path.normalize(fileName));
-      }
-
-      const file = baseGetSourceFile.call(
-        compilerHost,
-        fileName,
-        languageVersionOrOptions,
-        onError,
-        true,
-        ...args,
-      );
-
-      if (file) {
-        sourceFileCache.set(path.normalize(fileName), file);
-      }
-
-      return file;
-    };
-
-    return compilerHost;
-  }
-
-  function findAffectedFileSet() {
-    const affectedFileSet = new Set<string>();
-
-    while (true) {
-      const result = builder!.getSemanticDiagnosticsOfNextAffectedFile();
-      if (!result) {
-        break;
-      }
-      affectedFileSet.add(path.normalize((result.affected as ts.SourceFile).fileName));
-    }
-
-    return affectedFileSet;
-  }
-
   return {
     name: "sd-server-compiler",
     setup: (build: esbuild.PluginBuild) => {
-      //-- compilerHost
-      const compilerHost = createCompilerHost();
-
-      build.onStart(() => {
-        //-- modified
-        for (const modifiedFile of conf.modifiedFileSet) {
-          sourceFileCache.delete(modifiedFile);
-
-          if (referencingMap.has(modifiedFile)) {
-            for (const referencingFile of referencingMap.get(modifiedFile)!) {
-              sourceFileCache.delete(referencingFile);
-            }
-          }
-        }
-        referencingMap.clear();
-
-        //-- init resultCache
-
-        resultCache = {
-          watchFileSet: new Set<string>(),
-          affectedFileSet: new Set<string>(),
-        };
-
-        program = ts.createProgram(
-          parsedTsConfig.fileNames,
-          parsedTsConfig.options,
-          compilerHost,
-          program
-        );
-        builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
-          program,
-          compilerHost,
-          builder
-        );
-
-        //-- affectedFilePathSet
-        resultCache.affectedFileSet.adds(...findAffectedFileSet());
-
-        // Deps -> refMap
-        builder.getSourceFiles().forEach(sf => {
-          resultCache.watchFileSet.add(path.normalize(sf.fileName));
-
-          const deps = builder!.getAllDependencies(sf);
-          for (const dep of deps) {
-            const ref = referencingMap.getOrCreate(dep, new Set<string>());
-            ref.add(dep);
-
-            resultCache.watchFileSet.add(path.normalize(dep));
-          }
-        });
-
-        // refMap, modFile -> affectedFileSet
-        for (const modifiedFile of conf.modifiedFileSet) {
-          resultCache.affectedFileSet.adds(...referencingMap.get(modifiedFile) ?? []);
-        }
-
-        //-- diagnostics / build
-
-        const diagnostics: ts.Diagnostic[] = [];
+      const compiler = new SdTsCompiler(conf.pkgPath, {declaration: false}, conf.dev);
 
-        diagnostics.push(
-          ...builder.getConfigFileParsingDiagnostics(),
-          ...builder.getOptionsDiagnostics(),
-          ...builder.getGlobalDiagnostics()
-        );
+      let buildResult: ISdTsCompiler2Result;
 
-        for (const affectedFile of resultCache.affectedFileSet) {
-          const affectedSourceFile = sourceFileCache.get(path.normalize(affectedFile));
-          if (!affectedSourceFile) {
-            continue;
-          }
+      build.onStart(async () => {
+        compiler.invalidate(conf.modifiedFileSet);
+        buildResult = await compiler.buildAsync();
 
-          diagnostics.push(
-            ...builder.getSyntacticDiagnostics(affectedSourceFile),
-            ...builder.getSemanticDiagnostics(affectedSourceFile)
-          );
-        }
-
-        //-- prepare emit cache
-        while (true) {
-          const affectedFileResult = builder.emitNextAffectedFile((fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
-            if (!sourceFiles || sourceFiles.length === 0) {
-              compilerHost.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
-              return;
-            }
-
-            const sourceFile = ts.getOriginalNode(sourceFiles[0], ts.isSourceFile);
-            tscPrepareMap.set(path.normalize(sourceFile.fileName), text);
-          });
-
-          if (!affectedFileResult) {
-            break;
-          }
-
-          diagnostics.push(...affectedFileResult.result.diagnostics);
-        }
+        conf.result.watchFileSet = buildResult.watchFileSet;
+        conf.result.affectedFileSet = buildResult.affectedFileSet;
+        conf.result.program = buildResult.program;
 
         //-- return err/warn
 
         return {
-          errors: diagnostics.filter(item => item.category === ts.DiagnosticCategory.Error).map(item => convertTypeScriptDiagnostic(ts, item)),
-          warnings: diagnostics.filter(item => item.category !== ts.DiagnosticCategory.Error).map(item => convertTypeScriptDiagnostic(ts, item)),
+          errors: buildResult.typescriptDiagnostics.filter(item => item.category === ts.DiagnosticCategory.Error).map(item => convertTypeScriptDiagnostic(ts, item)),
+          warnings: buildResult.typescriptDiagnostics.filter(item => item.category !== ts.DiagnosticCategory.Error).map(item => convertTypeScriptDiagnostic(ts, item)),
         };
       });
 
 
       build.onLoad({filter: /\.ts$/}, (args) => {
-        resultCache.watchFileSet.add(path.normalize(args.path));
-        const contents = tscPrepareMap.get(path.normalize(args.path));
+        const contents = buildResult.emittedFilesCacheMap.get(path.normalize(args.path))!.last()!.text;
         return {contents, loader: "js"};
       });
 
+      build.onLoad({filter: /\.[cm]?js$/}, (args) => {
+        conf.result.watchFileSet!.add(path.normalize(args.path));
+        return null;
+      });
+
       build.onLoad(
         {filter: new RegExp("(" + Object.keys(build.initialOptions.loader!).map(item => "\\" + item).join("|") + ")$")},
         (args) => {
-          resultCache.watchFileSet!.add(path.normalize(args.path));
+          conf.result.watchFileSet!.add(path.normalize(args.path));
           return null;
         }
       );
 
       build.onEnd((result) => {
-        conf.result.watchFileSet = resultCache.watchFileSet;
-        conf.result.affectedFileSet = resultCache.affectedFileSet;
         conf.result.outputFiles = result.outputFiles;
         conf.result.metafile = result.metafile;
-        conf.result.program = program;
 
         conf.modifiedFileSet.clear();
       });
@@ -205,15 +62,10 @@ export function sdServerPlugin(conf: {
   };
 }
 
-export interface IServerBundlerResultCache {
+export interface IServerPluginResultCache {
   watchFileSet?: Set<string>;
   affectedFileSet?: Set<string>;
   outputFiles?: esbuild.OutputFile[];
   metafile?: esbuild.Metafile;
   program?: ts.Program;
-}
-
-interface IResultCache {
-  watchFileSet: Set<string>;
-  affectedFileSet: Set<string>;
 }

package/src/commons.ts

@@ -28,6 +28,7 @@ export interface ISdCliBuildClusterReqMessage {
   projConf: ISdCliConfig;
   pkgPath: string;
   // builderKey?: "web" | "electron";
+  execArgs?: string[];
 }
 
 export interface ISdCliBuildClusterResMessage {

package/src/entry/SdCliProject.ts

@@ -2,7 +2,6 @@ import path from "path";
 import {FsUtil, Logger, PathUtil, SdProcess} from "@simplysm/sd-core-node";
 import {
   INpmConfig,
-  ISdCliBuildClusterReqMessage,
   ISdCliBuildClusterResMessage,
   ISdCliConfig,
   ISdCliPackageBuildResult,
@@ -23,6 +22,7 @@ export class SdCliProject {
     confFileRelPath: string;
     optNames: string[];
     pkgNames: string[];
+    inspectNames: string[];
   }): Promise<void> {
     const logger = Logger.get(["simplysm", "sd-cli", "SdCliProject", "watchAsync"]);
 
@@ -87,7 +87,9 @@ export class SdCliProject {
       else if (message.type === "complete") {
         resultCache.delete("none");
         for (const affectedFilePath of message.result!.affectedFilePaths) {
-          resultCache.delete(affectedFilePath);
+          if (PathUtil.isChildPath(affectedFilePath, message.req.pkgPath)) {
+            resultCache.delete(affectedFilePath);
+          }
         }
 
         for (const buildResult of message.result!.buildResults) {
@@ -220,16 +222,7 @@ export class SdCliProject {
     logger.log("빌드를 시작합니다...");
 
     await pkgPaths.parallelAsync(async (pkgPath) => {
-      const pkgConf = projConf.packages[path.basename(pkgPath)]!;
-      if (pkgConf.type === "client") {
-        const builderKeys = Object.keys(pkgConf.builder ?? {web: {}});
-        await builderKeys.parallelAsync(async (builderKey) => {
-          await this._runCommandAsync(cluster, "watch", projConf, pkgPath, builderKey);
-        });
-      }
-      else {
-        await this._runCommandAsync(cluster, "watch", projConf, pkgPath);
-      }
+      await this._runCommandAsync(cluster, "watch", projConf, pkgPath, opt.inspectNames.includes(path.basename(pkgPath)) ? ["--inspect"] : []);
     });
 
     busyReqCntMap.set(
@@ -274,7 +267,7 @@ export class SdCliProject {
     logger.debug("빌드 프로세스 명령 전달...");
     const results = (
       await pkgPaths.parallelAsync(async (pkgPath) => {
-        const pkgConf = projConf.packages[path.basename(pkgPath)]!;
+        /*const pkgConf = projConf.packages[path.basename(pkgPath)]!;
         if (pkgConf.type === "client") {
           const builderKeys = Object.keys(pkgConf.builder ?? {web: {}});
           return (await builderKeys.parallelAsync(async (builderKey) => {
@@ -282,8 +275,8 @@ export class SdCliProject {
           })).mapMany();
         }
         else {
-          return await this._runCommandAsync(cluster, "build", projConf, pkgPath);
-        }
+        }*/
+        return await this._runCommandAsync(cluster, "build", projConf, pkgPath);
       })
     ).mapMany();
 
@@ -342,16 +335,7 @@ export class SdCliProject {
       logger.debug("빌드 프로세스 명령 전달...");
       const results = (
         await pkgPaths.parallelAsync(async (pkgPath) => {
-          const pkgConf = projConf.packages[path.basename(pkgPath)]!;
-          if (pkgConf.type === "client") {
-            const builderKeys = Object.keys(pkgConf.builder ?? {web: {}});
-            return (await builderKeys.parallelAsync(async (builderKey) => {
-              return await this._runCommandAsync(cluster, "build", projConf, pkgPath, builderKey);
-            })).mapMany();
-          }
-          else {
-            return await this._runCommandAsync(cluster, "build", projConf, pkgPath);
-          }
+          return await this._runCommandAsync(cluster, "build", projConf, pkgPath);
         })
       ).mapMany();
 
@@ -577,9 +561,9 @@ export class SdCliProject {
     });
   }
 
-  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch", projConf: ISdCliConfig, pkgPath: string, builderKey?: string): Promise<void>;
-  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "build", projConf: ISdCliConfig, pkgPath: string, builderKey?: string): Promise<ISdCliPackageBuildResult[]>;
-  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch" | "build", projConf: ISdCliConfig, pkgPath: string, builderKey?: string): Promise<ISdCliPackageBuildResult[] | void> {
+  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch", projConf: ISdCliConfig, pkgPath: string, execArgs: string[]): Promise<void>;
+  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "build", projConf: ISdCliConfig, pkgPath: string): Promise<ISdCliPackageBuildResult[]>;
+  private static async _runCommandAsync(cluster: cp.ChildProcess, cmd: "watch" | "build", projConf: ISdCliConfig, pkgPath: string, execArgs?: string[]): Promise<ISdCliPackageBuildResult[] | void> {
     return await new Promise<ISdCliPackageBuildResult[] | void>((resolve) => {
       const cb = (message: ISdCliBuildClusterResMessage): void => {
         if (cmd === "watch" && message.type === "ready" && message.req.cmd === cmd && message.req.pkgPath === pkgPath) {
@@ -597,8 +581,8 @@ export class SdCliProject {
         cmd,
         projConf,
         pkgPath,
-        builderKey
-      } as ISdCliBuildClusterReqMessage);
+        execArgs
+      });
     });
   }
 
@@ -667,4 +651,4 @@ export class SdCliProject {
       });
     });
   }
-}
+}

package/src/index.ts

@@ -1,6 +1,7 @@
 export * from "./build-tools/SdCliCordova";
 export * from "./build-tools/SdCliIndexFileGenerator";
 export * from "./build-tools/SdCliNgRoutesFileGenerator";
+export * from "./build-tools/SdLibBundler";
 export * from "./build-tools/SdLinter";
 export * from "./build-tools/SdNgBundler";
 export * from "./build-tools/SdNgBundlerContext";

package/src/sd-cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node --es-module-specifier-resolution=node --no-warnings --experimental-import-meta-resolve --max-old-space-size=8000
+#!/usr/bin/env node --es-module-specifier-resolution=node --no-warnings --experimental-import-meta-resolve
 
 import yargs from "yargs";
 import {hideBin} from "yargs/helpers";
@@ -57,6 +57,11 @@ const argv = (
             string: true,
             array: true,
             describe: "수행할 패키지 설정"
+          },
+          inspects: {
+            string: true,
+            array: true,
+            describe: "크롬 inspect를 수행할 패키지 설정"
           }
         })
     )
@@ -197,7 +202,8 @@ else if (argv._[0] === "watch") {
     .watchAsync({
       confFileRelPath: argv.config ?? "simplysm.cjs",
       optNames: argv.options ?? [],
-      pkgNames: argv.packages ?? []
+      pkgNames: argv.packages ?? [],
+      inspectNames: argv.inspects ?? []
     });
 }
 else if (argv._[0] === "build") {

package/src/server-worker.ts

@@ -52,14 +52,14 @@ else {
 
 
 server.on("ready", () => {
-  process.send!({port: server!.options.port});
+  process.send!({port: server.options.port});
 });
 
 process.on("message", (message: any) => {
   if (message.type === "setPathProxy") {
-    server!.pathProxy = message.pathProxy;
+    server.pathProxy = message.pathProxy;
   }
   if (message.type === "broadcastReload") {
-    server!.broadcastReload();
+    server.broadcastReload();
   }
 });

package/src/utils/SdCliBuildResultUtil.ts

@@ -2,9 +2,10 @@ import ts from "typescript";
 import os from "os";
 import path from "path";
 import {ISdCliPackageBuildResult} from "../commons";
+import {PartialMessage} from "esbuild";
 
 export class SdCliBuildResultUtil {
-  public static convertFromTsDiag(diag: ts.Diagnostic, type: "build" | "check"): ISdCliPackageBuildResult {
+  static convertFromTsDiag(diag: ts.Diagnostic, type: "build" | "check"): ISdCliPackageBuildResult {
     const severity = diag.category === ts.DiagnosticCategory.Error ? "error" as const
       : diag.category === ts.DiagnosticCategory.Warning ? "warning" as const
         : diag.category === ts.DiagnosticCategory.Suggestion ? "suggestion" as const
@@ -19,7 +20,7 @@ export class SdCliBuildResultUtil {
     const char = position ? position.character + 1 : undefined;
 
     return {
-      filePath: filePath !== undefined ? path.resolve(filePath) : undefined,
+      filePath,
       line,
       char,
       code,
@@ -29,7 +30,25 @@ export class SdCliBuildResultUtil {
     };
   }
 
-  public static getMessage(result: ISdCliPackageBuildResult): string {
+  static convertFromEsbuildResult(msg: PartialMessage, type: "build" | "check", severity: "warning" | "error") {
+    const filePath = msg.location?.file != null ? path.resolve(msg.location.file) : undefined;
+    const line = msg.location?.line;
+    const char = msg.location?.column;
+    const code = msg.text?.slice(0, msg.text.indexOf(":"));
+    const message = `${msg.pluginName != null ? `(${msg.pluginName}) ` : ""} ${msg.text?.slice(msg.text.indexOf(":") + 1)}`;
+
+    return {
+      filePath,
+      line,
+      char,
+      code,
+      severity,
+      message,
+      type
+    };
+  }
+
+  static getMessage(result: ISdCliPackageBuildResult): string {
     let str = "";
     if (result.filePath !== undefined) {
       str += `${result.filePath}(${result.line ?? 0}, ${result.char ?? 0}): `;