@simplysm/sd-cli 11.0.3 → 11.0.5

package/src/builders/SdCliClientBuilder.ts

@@ -1,29 +1,17 @@
 import {EventEmitter} from "events";
 import {FsUtil, Logger, PathUtil, SdFsWatcher} from "@simplysm/sd-core-node";
 import {ISdCliBuilderResult, ISdCliClientPackageConfig, ISdCliConfig, ISdCliPackageBuildResult} from "../commons";
-import {FunctionQueue, NotImplementError} from "@simplysm/sd-core-common";
+import {FunctionQueue, Wait} from "@simplysm/sd-core-common";
 import path from "path";
-import esbuild from "esbuild";
-import {createVirtualModulePlugin} from "@angular-devkit/build-angular/src/tools/esbuild/virtual-module-plugin";
-import {
-  createSourcemapIgnorelistPlugin
-} from "@angular-devkit/build-angular/src/tools/esbuild/sourcemap-ignorelist-plugin";
-import {
-  createCompilerPlugin,
-  SourceFileCache
-} from "@angular-devkit/build-angular/src/tools/esbuild/angular/compiler-plugin";
-import {createCompilerPluginOptions} from "@angular-devkit/build-angular/src/tools/esbuild/compiler-plugin-options";
-import {CrossOrigin} from "@angular-devkit/build-angular/src/builders/application/schema";
-
-import nodeStdLibBrowserPlugin from "node-stdlib-browser/helpers/esbuild/plugin";
-import nodeStdLibBrowser from "node-stdlib-browser";
-import {fileURLToPath} from "url";
-import {SdTsIncrementalBuilder} from "../build-tools/SdTsIncrementalBuilder";
+import {SdTsCompiler} from "../build-tools/SdTsCompiler";
+import {SdNgBundler} from "../build-tools/SdNgBundler";
 import {SdLinter} from "../build-tools/SdLinter";
 
 export class SdCliClientBuilder extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliClientBuilder"]);
   private readonly _pkgConf: ISdCliClientPackageConfig;
+  private _builders?: SdNgBundler[];
+  private _checker?: SdTsCompiler;
 
   public constructor(private readonly _projConf: ISdCliConfig,
                      private readonly _pkgPath: string) {
@@ -38,337 +26,102 @@ export class SdCliClientBuilder extends EventEmitter {
     return this;
   }
 
-  public async watchAsync(): Promise<void> {
-    this._debug("빌드 준비...");
-    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, () => ({emitJs: false}));
-
+  public async buildAsync(): Promise<ISdCliBuilderResult> {
     this._debug("dist 초기화...");
     await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
 
-    this.emit("change");
-
-    if (this._pkgConf.server !== undefined) {
-      this._debug("GEN .config...");
-      const confDistPath = path.resolve(this._pkgPath, "../../packages", this._pkgConf.server, "dist/www", path.basename(this._pkgPath), ".config.json");
-      await FsUtil.writeFileAsync(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
-    }
-
-    this._debug("BUILD...");
-    const builderTypes = (Object.keys(this._pkgConf.builder ?? {web: {}}) as ("web")[]);
-    const cache = new SourceFileCache();
-    const options = await Promise.all(builderTypes.map((builderType) => this._getEsBuildOptionsAsync({
-      dev: true,
-      builderType,
-      cache
-    })));
-    const contexts = await Promise.all(options.map((esbuildOption) => esbuild.context(esbuildOption)));
-    const results = await Promise.all(contexts.map(async (ctx) => {
-      try {
-        return await ctx.rebuild();
-      }
-      catch (err) {
-        if (typeof err === "object" && "errors" in err && "warnings" in err) {
-          return {
-            errors: err.errors,
-            warnings: err.warnings
-          };
-        }
-        throw new err;
-      }
-    }));
-
-    const buildResults: ISdCliPackageBuildResult[] = results.mapMany((esbuildResult) => [
-      ...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,
-        type: "build" as const
-      })),
-      ...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,
-        type: "build" as const
-      }))
-    ]);
+    return await this._runAsync({dev: false, genConf: true});
+  }
 
-    this._debug("CHECK...");
-    const checkResult = await sdTsProgram.buildAsync();
+  public async watchAsync(): Promise<void> {
+    this.emit("change");
 
-    this._debug("LINT...");
-    const lintResults = await SdLinter.lintAsync(checkResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+    this._debug("dist 초기화...");
+    await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
 
-    this._debug(`빌드 완료`);
-    this.emit("complete", {
-      affectedFilePaths: checkResult.affectedFilePaths,
-      buildResults: [...buildResults, ...checkResult.results, ...lintResults]
-    });
+    const result = await this._runAsync({dev: true, genConf: true});
+    this.emit("complete", result);
 
     this._debug("WATCH...");
     const fnQ = new FunctionQueue();
-    SdFsWatcher
+    const watcher = SdFsWatcher
       .watch([
-        ...sdTsProgram.builderProgram!.getSourceFiles().map((item) => item.fileName),
-        path.resolve(this._pkgPath, "src/**/*.{ts,tsx}")
+        ...result.watchFilePaths,
+        path.resolve(this._pkgPath, "src/**/*.*")
       ])
-      .onChange({
-        delay: 100
-      }, (changeInfos) => {
-        for (const changeInfo of changeInfos) {
-          cache.delete(PathUtil.posix(changeInfo.path));
+      .onChange({delay: 100}, (changeInfos) => {
+        for (const builder of this._builders!) {
+          builder.removeCache(changeInfos.map((item) => item.path));
         }
 
         fnQ.runLast(async () => {
           this.emit("change");
 
-          this._debug(`BUILD...`);
-          const watchResults = await Promise.all(contexts.map(async (ctx) => {
-            try {
-              return await ctx.rebuild();
-            }
-            catch (err) {
-              if (typeof err === "object" && "errors" in err && "warnings" in err) {
-                return {
-                  errors: err.errors,
-                  warnings: err.warnings
-                };
-              }
-              throw new err;
-            }
-          }));
-
-          const watchBuildResults: ISdCliPackageBuildResult[] = watchResults.mapMany((esbuildResult) => [
-            ...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,
-              type: "build" as const
-            })),
-            ...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,
-              type: "build" as const
-            }))
-          ]);
+          const watchResult = await this._runAsync({dev: true, genConf: false});
+          this.emit("complete", watchResult);
 
-          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", {
-            affectedFilePaths: watchCheckResult.affectedFilePaths,
-            buildResults: [...watchBuildResults, ...watchCheckResult.results, ...watchLintResults]
-          });
+          watcher.add(watchResult.watchFilePaths);
         });
       });
   }
 
-  // eslint-disable-next-line @typescript-eslint/require-await
-  public async buildAsync(): Promise<ISdCliBuilderResult> {
-    throw new NotImplementError();
-  }
-
-  private async _getEsBuildOptionsAsync(opt: {
+  private async _runAsync(opt: {
     dev: boolean;
-    builderType: "web",
-    cache: SourceFileCache
-  }): Promise<esbuild.BuildOptions> {
-    // const projPath = path.resolve(this._pkgPath, "../../");
-    const tsconfigFilePath = path.resolve(this._pkgPath, "tsconfig.json");
-    const mainFilePath = path.resolve(this._pkgPath, "src/main.ts");
-    const indexHtmlFilePath = path.resolve(this._pkgPath, "src/index.html");
+    genConf: boolean;
+  }): Promise<{
+    watchFilePaths: string[];
+    affectedFilePaths: string[];
+    buildResults: ISdCliPackageBuildResult[];
+  }> {
+    this._debug(`BUILD 준비...`);
+    const builderTypes = (Object.keys(this._pkgConf.builder ?? {web: {}}) as ("web")[]);
+    this._builders = this._builders ?? builderTypes.map((builderType) => new SdNgBundler({
+      dev: opt.dev,
+      builderType: builderType,
+      pkgPath: this._pkgPath
+    }));
+
+    this._checker = this._checker ?? new SdTsCompiler({
+      pkgPath: this._pkgPath,
+      emit: false,
+      emitDts: false,
+      globalStyle: false
+    });
+
+    this._debug(`BUILD...`);
+    const buildResults = await Promise.all(this._builders.map((builder) => builder.bundleAsync()));
 
-    const cacheBasePath = path.resolve(this._pkgPath, ".cache");
-    const distBasePath = path.resolve(this._pkgPath, "dist");
+    this._debug("CHECK...");
+    const checkResult = await this._checker.buildAsync();
 
-    const {pluginOptions, styleOptions} = createCompilerPluginOptions(
-      {
-        advancedOptimizations: true,
-        allowedCommonJsDependencies: [],
-        baseHref: undefined,
-        cacheOptions: {
-          enabled: true,
-          basePath: cacheBasePath,
-          path: path.resolve(cacheBasePath, opt.builderType)
-        },
-        crossOrigin: CrossOrigin.None,
-        deleteOutputPath: true,
-        externalDependencies: [],
-        extractLicenses: false,
-        inlineStyleLanguage: 'scss',
-        jit: false,
-        stats: false,
-        polyfills: ["./src/polyfills.ts"],
-        poll: undefined,
-        progress: true,
-        externalPackages: true,
-        preserveSymlinks: true,
-        stylePreprocessorOptions: {includePaths: []},
-        subresourceIntegrity: false,
-        serverEntryPoint: undefined,
-        prerenderOptions: undefined,
-        appShellOptions: undefined,
-        ssrOptions: undefined,
-        verbose: false,
-        watch: true,
-        workspaceRoot: this._pkgPath,
-        entryPoints: {main: mainFilePath},
-        optimizationOptions: {
-          scripts: false,
-          styles: {minify: false, inlineCritical: false},
-          fonts: {inline: false}
-        },
-        outputPath: distBasePath,
-        outExtension: undefined,
-        sourcemapOptions: {vendor: false, hidden: false, scripts: true, styles: true},
-        tsconfig: tsconfigFilePath,
-        projectRoot: this._pkgPath,
-        assets: [
-          {glob: 'favicon.ico', input: 'src', output: ''},
-          {glob: '**/*', input: 'src\\assets', output: 'assets'}
-        ],
-        outputNames: {bundles: '[name]', media: 'media/[name]'},
-        fileReplacements: undefined,
-        globalStyles: [{name: 'styles', files: ["src/styles.scss"], initial: true}],
-        globalScripts: [],
-        serviceWorker: undefined,
-        indexHtmlOptions: {
-          input: indexHtmlFilePath,
-          output: 'index.html',
-          insertionOrder: [
-            ['runtime', true],
-            ['polyfills', true],
-            ['styles', false],
-            ['vendor', true],
-            ['main', true]
-          ]
-        },
-        tailwindConfiguration: undefined
-      },
-      [
-        'chrome117.0', 'chrome116.0',
-        'edge117.0', 'edge116.0',
-        'firefox118.0', 'firefox115.0',
-        'ios17.0', 'ios16.6',
-        'ios16.5', 'ios16.4',
-        'ios16.3', 'ios16.2',
-        'ios16.1', 'ios16.0',
-        'safari17.0', 'safari16.6',
-        'safari16.5', 'safari16.4',
-        'safari16.3', 'safari16.2',
-        'safari16.1', 'safari16.0'
-      ],
-      opt.cache,
-    );
+    this._debug(`LINT...`);
+    const lintResults = await SdLinter.lintAsync(checkResult.affectedFilePaths, this._checker.program);
 
+    if (opt.genConf) {
+      this._debug("GEN .config...");
+      if (opt.dev && this._pkgConf.server !== undefined) {
+        const serverDistPath = path.resolve(this._pkgPath, "../", this._pkgConf.server, "dist");
+        await Wait.until(() => FsUtil.exists(serverDistPath));
+        await FsUtil.writeJsonAsync(path.resolve(serverDistPath, "www", path.basename(this._pkgPath), ".config.json"), this._pkgConf.configs ?? {}, {space: 2});
+      }
+      else {
+        await FsUtil.writeJsonAsync(path.resolve(this._pkgPath, "dist/.config.json"), this._pkgConf.configs ?? {}, {space: 2});
+      }
+    }
+
+    const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {})
+      .mapMany((key) => FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)));
+    const watchFilePaths = buildResults.mapMany((item) => item.filePaths)
+      .filter((item) =>
+        PathUtil.isChildPath(item, path.resolve(this._pkgPath, "../")) ||
+        localUpdatePaths.some((lu) => PathUtil.isChildPath(item, lu))
+      );
+
+    this._debug(`빌드 완료`);
     return {
-      absWorkingDir: this._pkgPath,
-      bundle: true,
-      format: 'esm',
-      assetNames: 'media/[name]',
-      conditions: ['es2020', 'es2015', 'module'],
-      resolveExtensions: ['.ts', '.tsx', '.mjs', '.js'],
-      metafile: true,
-      legalComments: 'eof',
-      logLevel: 'silent',
-      minifyIdentifiers: false,
-      minifySyntax: false,
-      minifyWhitespace: false,
-      pure: ['forwardRef'],
-      outdir: distBasePath,
-      outExtension: undefined,
-      sourcemap: true,
-      splitting: true,
-      chunkNames: 'chunk-[hash]',
-      tsconfig: tsconfigFilePath,
-      external: [],
-      write: true,
-      preserveSymlinks: true,
-      define: {
-        ngJitMode: 'false',
-        global: 'global',
-        process: 'process',
-        Buffer: 'Buffer'
-      },
-      platform: 'browser',
-      mainFields: ['es2020', 'es2015', 'browser', 'module', 'main'],
-      entryNames: '[name]',
-      entryPoints: {
-        main: mainFilePath,
-        polyfills: 'angular:polyfills'
-      },
-      target: [
-        'chrome117.0', 'chrome116.0',
-        'edge117.0', 'edge116.0',
-        'firefox118.0', 'firefox115.0',
-        'ios17.0', 'ios16.6',
-        'ios16.5', 'ios16.4',
-        'ios16.3', 'ios16.2',
-        'ios16.1', 'ios16.0',
-        'safari17.0', 'safari16.6',
-        'safari16.5', 'safari16.4',
-        'safari16.3', 'safari16.2',
-        'safari16.1', 'safari16.0'
-      ],
-      supported: {'async-await': false, 'object-rest-spread': false},
-      loader: {
-        ".png": "file",
-        ".jpeg": "file",
-        ".jpg": "file",
-        ".jfif": "file",
-        ".gif": "file",
-        ".svg": "file",
-        ".woff": "file",
-        ".woff2": "file",
-        ".ttf": "file",
-        ".eot": "file",
-        ".ico": "file",
-        ".otf": "file",
-        ".csv": "file",
-        ".xlsx": "file",
-        ".xls": "file",
-        ".pptx": "file",
-        ".ppt": "file",
-        ".docx": "file",
-        ".doc": "file",
-        ".zip": "file",
-        ".pfx": "file",
-        ".pkl": "file"
-      },
-      inject: [PathUtil.posix(fileURLToPath(await import.meta.resolve!("node-stdlib-browser/helpers/esbuild/shim")))],
-      plugins: [
-        createVirtualModulePlugin({
-          namespace: "angular:polyfills",
-          loadContent: () => ({
-            contents: `import "./src/polyfills.ts";`,
-            loader: 'js',
-            resolveDir: this._pkgPath
-          })
-        }) as esbuild.Plugin,
-        createSourcemapIgnorelistPlugin() as esbuild.Plugin,
-        createCompilerPlugin(
-          pluginOptions,
-          styleOptions
-        ) as esbuild.Plugin,
-        // createExternalPackagesPlugin() as esbuild.Plugin,
-        nodeStdLibBrowserPlugin(nodeStdLibBrowser)
-      ]
+      watchFilePaths: watchFilePaths,
+      affectedFilePaths: checkResult.affectedFilePaths,
+      buildResults: [...buildResults.mapMany((item) => item.results), ...checkResult.results, ...lintResults]
     };
   }