@simplysm/sd-cli 12.5.21 → 12.5.22

package/src/{bundle-plugins/sdNgPlugin.ts → pkg-builders/client/createSdNgPlugin.ts}

@@ -1,31 +1,32 @@
 import esbuild from "esbuild";
-import ts from "typescript";
 import path from "path";
 import os from "os";
-import { ISdTsCompilerResult, SdTsCompiler } from "../build-tools/SdTsCompiler";
 import { JavaScriptTransformer } from "@angular/build/src/tools/esbuild/javascript-transformer";
-import { convertTypeScriptDiagnostic } from "@angular/build/src/tools/esbuild/angular/diagnostics";
-import { SdCliPerformanceTimer } from "../utils/SdCliPerformanceTime";
-import { Logger } from "@simplysm/sd-core-node";
-
-export function sdNgPlugin(conf: {
-  pkgPath: string;
+import { Logger, PathUtil, TNormPath } from "@simplysm/sd-core-node";
+import { SdCliPerformanceTimer } from "../../utils/SdCliPerformanceTime";
+import { SdCliConvertMessageUtil } from "../../utils/SdCliConvertMessageUtil";
+import { ISdCliNgPluginResultCache } from "../../types/build-plugin.type";
+import { ISdTsCompilerResult } from "../../types/ts-compiler.type";
+import { SdTsCompileWorker } from "../../ts-builder/SdTsCompileWorker";
+
+export function createSdNgPlugin(conf: {
+  pkgPath: TNormPath;
   dev: boolean;
-  modifiedFileSet: Set<string>;
-  result: INgPluginResultCache;
-  watchScopePaths: string[];
+  modifiedFileSet: Set<TNormPath>;
+  result: ISdCliNgPluginResultCache;
+  watchScopePaths: TNormPath[];
 }): esbuild.Plugin {
   let perf: SdCliPerformanceTimer;
-  const logger = Logger.get(["simplysm", "sd-cli", "sdNgPlugin"]);
+  const logger = Logger.get(["simplysm", "sd-cli", "createSdNgPlugin"]);
 
   function debug(...msg: any[]): void {
     logger.debug(`[${path.basename(conf.pkgPath)}]`, ...msg);
   }
 
   return {
-    name: "sd-ng-compiler",
-    setup: (build: esbuild.PluginBuild) => {
-      const compiler = new SdTsCompiler({
+    name: "sd-ng-compile",
+    setup: async (build: esbuild.PluginBuild) => {
+      const tsCompiler = await SdTsCompileWorker.new({
         pkgPath: conf.pkgPath,
         additionalOptions: { declaration: false },
         isDevMode: conf.dev,
@@ -33,9 +34,10 @@ export function sdNgPlugin(conf: {
         watchScopePaths: conf.watchScopePaths,
       });
 
-      let buildResult: ISdTsCompilerResult;
-      const outputContentsCacheMap = new Map<string, Uint8Array>();
+      let tsCompileResult: ISdTsCompilerResult;
+      const outputContentsCacheMap = new Map<TNormPath, Uint8Array>();
 
+      // const cacheStore = new LmbdCacheStore(path.join(process.cwd(), "angular-compiler.db"));
       //-- js babel transformer
       const javascriptTransformer = new JavaScriptTransformer(
         {
@@ -45,6 +47,7 @@ export function sdNgPlugin(conf: {
           advancedOptimizations: true,
         },
         os.cpus().length,
+        // cacheStore.createCache("jstransformer"),
       );
 
       //---------------------------
@@ -53,30 +56,32 @@ export function sdNgPlugin(conf: {
         perf = new SdCliPerformanceTimer("esbuild");
 
         const res = await perf.run("typescript build", async () => {
-          compiler.invalidate(conf.modifiedFileSet);
           for (const modifiedFile of conf.modifiedFileSet) {
             outputContentsCacheMap.delete(modifiedFile);
           }
 
-          buildResult = await compiler.buildAsync();
+          tsCompileResult = await tsCompiler.compileAsync(conf.modifiedFileSet);
 
-          conf.result.watchFileSet = buildResult.watchFileSet;
-          conf.result.affectedFileSet = buildResult.affectedFileSet;
-          conf.result.program = buildResult.program;
+          conf.result.watchFileSet = tsCompileResult.watchFileSet;
+          conf.result.affectedFileSet = tsCompileResult.affectedFileSet;
 
+          const tsEsbuildResult = SdCliConvertMessageUtil.convertToEsbuildFromBuildMessages(
+            tsCompileResult.messages,
+            conf.pkgPath,
+          );
           //-- return err/warn
           return {
             errors: [
-              ...buildResult.typescriptDiagnostics
-                .filter((item) => item.category === ts.DiagnosticCategory.Error)
-                .map((item) => convertTypeScriptDiagnostic(ts, item)),
-              ...Array.from(buildResult.stylesheetBundlingResultMap.values()).flatMap((item) => item.errors),
+              ...tsEsbuildResult.errors,
+              ...Array.from(tsCompileResult.stylesheetBundlingResultMap.values())
+                .flatMap((item) => item.errors)
+                .filterExists(),
             ].filterExists(),
             warnings: [
-              ...buildResult.typescriptDiagnostics
-                .filter((item) => item.category !== ts.DiagnosticCategory.Error)
-                .map((item) => convertTypeScriptDiagnostic(ts, item)),
-              // ...Array.from(buildResult.stylesheetResultMap.values()).flatMap(item => item.warnings)
+              ...tsEsbuildResult.warnings,
+              ...Array.from(tsCompileResult.stylesheetBundlingResultMap.values())
+                .flatMap((item) => item.warnings)
+                .filterExists(),
             ],
           };
         });
@@ -86,12 +91,12 @@ export function sdNgPlugin(conf: {
       });
 
       build.onLoad({ filter: /\.ts$/ }, async (args) => {
-        const output = outputContentsCacheMap.get(path.normalize(args.path));
+        const output = outputContentsCacheMap.get(PathUtil.norm(args.path));
         if (output != null) {
           return { contents: output, loader: "js" };
         }
 
-        const emittedJsFile = buildResult.emittedFilesCacheMap.get(path.normalize(args.path))?.last();
+        const emittedJsFile = tsCompileResult.emittedFilesCacheMap.get(PathUtil.norm(args.path))?.last();
         if (!emittedJsFile) {
           throw new Error(`ts 빌더 결과 emit 파일이 존재하지 않습니다. ${args.path}`);
         }
@@ -105,15 +110,15 @@ export function sdNgPlugin(conf: {
 
         const newContents = await javascriptTransformer.transformData(args.path, contents, true, sideEffects);
 
-        outputContentsCacheMap.set(path.normalize(args.path), newContents);
+        outputContentsCacheMap.set(PathUtil.norm(args.path), newContents);
 
         return { contents: newContents, loader: "js" };
       });
 
       build.onLoad({ filter: /\.[cm]?js$/ }, async (args) => {
-        conf.result.watchFileSet!.add(path.normalize(args.path));
+        conf.result.watchFileSet!.add(PathUtil.norm(args.path));
 
-        const output = outputContentsCacheMap.get(path.normalize(args.path));
+        const output = outputContentsCacheMap.get(PathUtil.norm(args.path));
         if (output != null) {
           return { contents: output, loader: "js" };
         }
@@ -125,7 +130,7 @@ export function sdNgPlugin(conf: {
 
         const newContents = await javascriptTransformer.transformFile(args.path, false, sideEffects);
 
-        outputContentsCacheMap.set(path.normalize(args.path), newContents);
+        outputContentsCacheMap.set(PathUtil.norm(args.path), newContents);
 
         return {
           contents: newContents,
@@ -144,7 +149,7 @@ export function sdNgPlugin(conf: {
           ),
         },
         (args) => {
-          conf.result.watchFileSet!.add(path.normalize(args.path));
+          conf.result.watchFileSet!.add(PathUtil.norm(args.path));
           return null;
         },
       );
@@ -153,7 +158,7 @@ export function sdNgPlugin(conf: {
         perf.end("transform & bundling");
         debug(perf.toString());
 
-        for (const { outputFiles, metafile } of buildResult.stylesheetBundlingResultMap.values()) {
+        for (const { outputFiles, metafile } of tsCompileResult.stylesheetBundlingResultMap.values()) {
           result.outputFiles = result.outputFiles ?? [];
           result.outputFiles.push(...outputFiles);
 
@@ -171,11 +176,3 @@ export function sdNgPlugin(conf: {
     },
   };
 }
-
-export interface INgPluginResultCache {
-  watchFileSet?: Set<string>;
-  affectedFileSet?: Set<string>;
-  program?: ts.Program;
-  outputFiles?: esbuild.OutputFile[];
-  metafile?: esbuild.Metafile;
-}

package/src/{build-tools → pkg-builders/lib}/SdCliIndexFileGenerator.ts

@@ -2,18 +2,18 @@ import { FsUtil, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import path from "path";
 
 export class SdCliIndexFileGenerator {
-  public static async watchAsync(pkgPath: string, polyfills?: string[]): Promise<void> {
+  static watch(pkgPath: string, polyfills?: string[]) {
     const indexFilePath = path.resolve(pkgPath, "src/index.ts");
     let cache = FsUtil.exists(indexFilePath) ? FsUtil.readFile(indexFilePath) : undefined;
 
-    SdFsWatcher.watch([path.resolve(pkgPath, "src")]).onChange({}, async () => {
-      cache = await this.runAsync(pkgPath, polyfills, cache);
+    SdFsWatcher.watch([path.resolve(pkgPath, "src")]).onChange({ delay: 100 }, () => {
+      cache = this.run(pkgPath, polyfills, cache);
     });
 
-    cache = await this.runAsync(pkgPath, polyfills, cache);
+    cache = this.run(pkgPath, polyfills, cache);
   }
 
-  public static async runAsync(pkgPath: string, polyfills?: string[], cache?: string): Promise<string> {
+  static run(pkgPath: string, polyfills?: string[], cache?: string): string {
     const indexFilePath = path.resolve(pkgPath, "src/index.ts");
 
     const importTexts: string[] = [];
@@ -26,13 +26,13 @@ export class SdCliIndexFileGenerator {
     }
 
     // 내부 파일들 import
-    const filePaths = await this._getFilePathsAsync(pkgPath);
+    const filePaths = this.#getFilePaths(pkgPath);
     for (const filePath of filePaths.orderBy()) {
       const requirePath = PathUtil.posix(path.relative(path.dirname(indexFilePath), filePath))
         .replace(/\.tsx?$/, "")
         .replace(/\/index$/, "");
 
-      const sourceTsFileContent = await FsUtil.readFileAsync(filePath);
+      const sourceTsFileContent = FsUtil.readFile(filePath);
       if (sourceTsFileContent.split("\n").some((line) => line.startsWith("export "))) {
         importTexts.push(`export * from "./${requirePath}";`);
       } else {
@@ -42,18 +42,18 @@ export class SdCliIndexFileGenerator {
 
     const content = importTexts.join("\n") + "\n";
     if (content.trim() !== cache?.trim()) {
-      await FsUtil.writeFileAsync(indexFilePath, content);
+      FsUtil.writeFile(indexFilePath, content);
     }
     return content;
   }
 
-  private static async _getFilePathsAsync(pkgPath: string): Promise<string[]> {
+  static #getFilePaths(pkgPath: string): string[] {
     const indexFilePath = path.resolve(pkgPath, "src/index.ts");
 
-    const tsconfig = await FsUtil.readJsonAsync(path.resolve(pkgPath, "tsconfig.json"));
+    const tsconfig = FsUtil.readJson(path.resolve(pkgPath, "tsconfig.json"));
     const entryFilePaths: string[] = tsconfig.files?.map((item) => path.resolve(pkgPath, item)) ?? [];
 
-    return (await FsUtil.globAsync(path.resolve(pkgPath, "src/**/*{.ts,.tsx}"), { nodir: true })).filter(
+    return FsUtil.glob(path.resolve(pkgPath, "src/**/*{.ts,.tsx}"), { nodir: true }).filter(
       (item) => !entryFilePaths.includes(item) && item !== indexFilePath && !item.endsWith(".d.ts"),
     );
   }

package/src/pkg-builders/lib/SdJsLibBuildRunner.ts

@@ -0,0 +1,105 @@
+import { FsUtil, Logger, PathUtil, SdFsWatcher, SdWorker } from "@simplysm/sd-core-node";
+import path from "path";
+import { EventEmitter } from "events";
+import { SdCliConvertMessageUtil } from "../../utils/SdCliConvertMessageUtil";
+import { TSdLintWorkerType } from "../../types/workers.type";
+import { ISdProjectConfig } from "../../types/sd-configs.type";
+import { ISdBuildRunnerResult } from "../../types/build.type";
+
+export class SdJsLibBuildRunner extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdJsLibBuildRunner"]);
+  private readonly _pkgName: string;
+  private readonly _lintWorker: SdWorker<TSdLintWorkerType>;
+
+  public 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"));
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: ISdBuildRunnerResult) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  public async buildAsync(): Promise<ISdBuildRunnerResult> {
+    this._debug("LINT...");
+    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.js");
+    const srcFilePaths = FsUtil.glob(srcGlobPath);
+
+    const lintResults = await this._lintWorker.run("lint", [
+      {
+        cwd: this._pkgPath,
+        fileSet: new Set(srcFilePaths),
+      },
+    ]);
+    const messages = SdCliConvertMessageUtil.convertToBuildMessagesFromEslint(lintResults);
+
+    this._debug(`LINT 완료`);
+    return {
+      affectedFilePathSet: new Set(srcFilePaths.map((item) => PathUtil.norm(item))),
+      buildMessages: messages,
+      emitFileSet: new Set(),
+    };
+  }
+
+  public async watchAsync(): Promise<void> {
+    this.emit("change");
+    this._debug("LINT...");
+    const srcGlobPath = path.resolve(this._pkgPath, "src/**/*.js");
+    const srcFilePaths = FsUtil.glob(srcGlobPath);
+
+    const lintResults = await this._lintWorker.run("lint", [
+      {
+        cwd: this._pkgPath,
+        fileSet: new Set(srcFilePaths),
+      },
+    ]);
+    const messages = SdCliConvertMessageUtil.convertToBuildMessagesFromEslint(lintResults);
+
+    this._debug(`LINT 완료`);
+    const res: ISdBuildRunnerResult = {
+      affectedFilePathSet: new Set(srcFilePaths.map((item) => PathUtil.norm(item))),
+      buildMessages: messages,
+      emitFileSet: new Set(),
+    };
+    this.emit("complete", res);
+
+    SdFsWatcher.watch([srcGlobPath]).onChange({ delay: 300 }, 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 this._lintWorker.run("lint", [
+        {
+          cwd: this._pkgPath,
+          fileSet: new Set(watchFilePaths),
+        },
+      ]);
+      const watchMessages = SdCliConvertMessageUtil.convertToBuildMessagesFromEslint(watchLintResults);
+
+      this._debug(`LINT 완료`);
+
+      const watchRes: ISdBuildRunnerResult = {
+        affectedFilePathSet: new Set(changeInfos.map((item) => PathUtil.norm(item.path))),
+        buildMessages: watchMessages,
+        emitFileSet: new Set(),
+      };
+
+      this.emit("complete", watchRes);
+    });
+  }
+
+  private _debug(msg: string): void {
+    this._logger.debug(`[${this._pkgName}] ${msg}`);
+  }
+}

package/src/pkg-builders/lib/SdTsLibBuildRunner.ts

@@ -0,0 +1,128 @@
+import { FsUtil, Logger, PathUtil, SdFsWatcher, TNormPath } from "@simplysm/sd-core-node";
+import path from "path";
+import { EventEmitter } from "events";
+import { SdCliIndexFileGenerator } from "./SdCliIndexFileGenerator";
+import { SdTsLibBuilder } from "./SdTsLibBuilder";
+import { ISdLibPackageConfig, ISdProjectConfig } from "../../types/sd-configs.type";
+import { ISdBuildMessage, ISdBuildRunnerResult } from "../../types/build.type";
+
+export class SdTsLibBuildRunner extends EventEmitter {
+  readonly #logger = Logger.get(["simplysm", "sd-cli", "SdCliTsLibBuilder"]);
+
+  readonly #projConf: ISdProjectConfig;
+  readonly #pkgPath: string;
+  readonly #pkgConf: ISdLibPackageConfig;
+
+  #builder?: SdTsLibBuilder;
+
+  public constructor(projConf: ISdProjectConfig, pkgPath: string) {
+    super();
+    this.#projConf = projConf;
+    this.#pkgPath = pkgPath;
+
+    this.#pkgConf = projConf.packages[path.basename(pkgPath)] as ISdLibPackageConfig;
+  }
+
+  public override on(event: "change", listener: () => void): this;
+  public override on(event: "complete", listener: (result: ISdBuildRunnerResult) => void): this;
+  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
+    super.on(event, listener);
+    return this;
+  }
+
+  public async buildAsync(): Promise<ISdBuildRunnerResult> {
+    this._debug("dist 초기화...");
+    FsUtil.remove(path.resolve(this.#pkgPath, "dist"));
+
+    if (!this.#pkgConf.noGenIndex) {
+      this._debug("GEN index.ts...");
+      SdCliIndexFileGenerator.run(this.#pkgPath, this.#pkgConf.polyfills);
+    }
+
+    const result = await this._runAsync(false);
+    return {
+      affectedFilePathSet: result.affectedFileSet,
+      buildMessages: result.buildMessages,
+      emitFileSet: result.emitFileSet,
+    };
+  }
+
+  public async watchAsync(): Promise<void> {
+    this.emit("change");
+
+    this._debug("dist 초기화...");
+    FsUtil.remove(path.resolve(this.#pkgPath, "dist"));
+
+    if (!this.#pkgConf.noGenIndex) {
+      this._debug("WATCH GEN index.ts...");
+      SdCliIndexFileGenerator.watch(this.#pkgPath, this.#pkgConf.polyfills);
+    }
+
+    const result = await this._runAsync(true);
+    const res: ISdBuildRunnerResult = {
+      affectedFilePathSet: result.affectedFileSet,
+      buildMessages: result.buildMessages,
+      emitFileSet: result.emitFileSet,
+    };
+    this.emit("complete", res);
+
+    this._debug("WATCH...");
+    const watcher = SdFsWatcher.watch(Array.from(result.watchFileSet)).onChange({ delay: 300 }, async (changeInfos) => {
+      this.emit("change");
+
+      const changeFileSet = new Set(changeInfos.map((item) => PathUtil.norm(item.path)));
+
+      const watchResult = await this._runAsync(true, changeFileSet);
+      const watchRes: ISdBuildRunnerResult = {
+        affectedFilePathSet: watchResult.affectedFileSet,
+        buildMessages: watchResult.buildMessages,
+        emitFileSet: watchResult.emitFileSet,
+      };
+
+      this.emit("complete", watchRes);
+
+      watcher.replaceWatchPaths(watchResult.watchFileSet);
+    });
+  }
+
+  private async _runAsync(
+    dev: boolean,
+    modifiedFileSet?: Set<TNormPath>,
+  ): Promise<{
+    watchFileSet: Set<TNormPath>;
+    affectedFileSet: Set<TNormPath>;
+    buildMessages: ISdBuildMessage[];
+    emitFileSet: Set<TNormPath>;
+  }> {
+    const localUpdatePaths = Object.keys(this.#projConf.localUpdates ?? {})
+      .mapMany((key) => FsUtil.glob(path.resolve(this.#pkgPath, "../../node_modules", key)))
+      .map((item) => PathUtil.norm(item));
+
+    this._debug(`BUILD...`);
+    this.#builder ??= await SdTsLibBuilder.new(PathUtil.norm(this.#pkgPath), dev, [
+      PathUtil.norm(this.#pkgPath, "../"),
+      ...localUpdatePaths,
+    ]);
+    const buildResult = await this.#builder.buildAsync(modifiedFileSet);
+
+    this._debug(`빌드 완료`);
+    const watchFileSet = new Set(
+      Array.from(buildResult.watchFileSet).filter(
+        (item) =>
+          PathUtil.isChildPath(item, path.resolve(this.#pkgPath, "../")) ||
+          localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu)),
+      ),
+    );
+
+    return {
+      watchFileSet,
+      affectedFileSet: buildResult.affectedFileSet,
+      buildMessages: buildResult.results,
+      emitFileSet: buildResult.emitFileSet,
+    };
+  }
+
+  private _debug(msg: string): void {
+    this.#logger.debug(`[${path.basename(this.#pkgPath)}] ${msg}`);
+  }
+}

package/src/pkg-builders/lib/SdTsLibBuilder.ts

@@ -0,0 +1,69 @@
+import path from "path";
+import { SdCliConvertMessageUtil } from "../../utils/SdCliConvertMessageUtil";
+import { FsUtil, PathUtil, TNormPath } from "@simplysm/sd-core-node";
+import { ISdBuildMessage } from "../../types/build.type";
+import { SdTsCompileWorker } from "../../ts-builder/SdTsCompileWorker";
+
+export class SdTsLibBuilder {
+  static async new(pkgPath: TNormPath, dev: boolean, watchScopePaths: TNormPath[]) {
+    const tsCompiler = await SdTsCompileWorker.new({
+      pkgPath,
+      additionalOptions: { declaration: true },
+      isDevMode: dev,
+      globalStyleFilePath: PathUtil.norm(pkgPath, "src/styles.scss"),
+      isForBundle: false,
+      watchScopePaths: watchScopePaths,
+    });
+
+    return new SdTsLibBuilder(tsCompiler, pkgPath);
+  }
+
+  private constructor(
+    private _compiler: SdTsCompileWorker,
+    private _pkgPath: string,
+  ) {}
+
+  public async buildAsync(modifiedFileSet?: Set<TNormPath>): Promise<{
+    watchFileSet: Set<TNormPath>;
+    affectedFileSet: Set<TNormPath>;
+    results: ISdBuildMessage[];
+    emitFileSet: Set<TNormPath>;
+  }> {
+    const tsCompileResult = await this._compiler.compileAsync(modifiedFileSet);
+
+    const emitFileSet = new Set<TNormPath>();
+    for (const emitFile of tsCompileResult.emitFileSet) {
+      const emitFileInfos = tsCompileResult.emittedFilesCacheMap.get(emitFile);
+      if (emitFileInfos) {
+        for (const emitFileInfo of emitFileInfos) {
+          if (emitFileInfo.outAbsPath != null) {
+            FsUtil.writeFile(emitFileInfo.outAbsPath, emitFileInfo.text);
+            emitFileSet.add(emitFileInfo.outAbsPath);
+          }
+        }
+      }
+
+      const globalStylesheetBundlingResult = tsCompileResult.stylesheetBundlingResultMap.get(emitFile);
+      if (globalStylesheetBundlingResult) {
+        for (const outputFile of globalStylesheetBundlingResult.outputFiles) {
+          const distPath = PathUtil.norm(this._pkgPath, "dist", path.relative(this._pkgPath, outputFile.path));
+          if (PathUtil.isChildPath(distPath, path.resolve(this._pkgPath, "dist"))) {
+            FsUtil.writeFile(distPath, outputFile.text);
+            emitFileSet.add(distPath);
+          }
+        }
+      }
+    }
+
+    const styleResults = Array.from(tsCompileResult.stylesheetBundlingResultMap.values()).mapMany((item) =>
+      SdCliConvertMessageUtil.convertToBuildMessagesFromEsbuild(item, this._pkgPath),
+    );
+
+    return {
+      watchFileSet: tsCompileResult.watchFileSet,
+      affectedFileSet: tsCompileResult.affectedFileSet,
+      results: [...tsCompileResult.messages, ...styleResults],
+      emitFileSet,
+    };
+  }
+}