@simplysm/sd-cli 10.0.65 → 11.0.3

package/src/builders/SdCliClientBuilder.ts

@@ -1,31 +1,34 @@
 import {EventEmitter} from "events";
-import {FsUtil, Logger, SdFsWatcher, SdProcess} from "@simplysm/sd-core-node";
-import {INpmConfig, ISdCliBuilderResult, ISdCliClientPackageConfig, ISdCliPackageBuildResult} from "../commons";
-import {FunctionQueue, MathUtil} from "@simplysm/sd-core-common";
-import * as vite from "vite";
-import {defineConfig, InlineConfig} from "vite";
-import vitePluginPaths from "vite-tsconfig-paths";
+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 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 {SdLinter} from "../build-tools/SdLinter";
-import {VitePWA} from 'vite-plugin-pwa';
-import {SdCliViteNodeGlobalPlugin} from "../utils/SdCliViteNodeGlobalPlugin";
-import {SdCliViteLoggerPlugin} from "../utils/SdCliViteLoggerPlugin";
-import {SdCliViteReactSwcPlugin} from "../utils/SdCliViteReactSwcPlugin";
-import {SdCliViteExternalPlugin} from "../utils/SdCliViteExternalPlugin";
-import {SdCliViteElectronMainPlugin} from "../utils/SdCliViteElectronMainPlugin";
-import electronBuilder from "electron-builder";
-import {SdCliViteServeOptimizeExcludePlugin} from "../utils/SdCliViteServeOptimizeExcludePlugin";
-import {SdCliViteLazyImportPlugin} from "../utils/SdCliViteLazyImportPlugin";
 
 export class SdCliClientBuilder extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliClientBuilder"]);
+  private readonly _pkgConf: ISdCliClientPackageConfig;
 
-  public constructor(private readonly _pkgPath: string,
-                     private readonly _pkgConf: ISdCliClientPackageConfig,
-                     private readonly _builderKey: "web" | "electron",
-                     private readonly _withLint: boolean) {
+  public constructor(private readonly _projConf: ISdCliConfig,
+                     private readonly _pkgPath: string) {
     super();
+    this._pkgConf = this._projConf.packages[path.basename(_pkgPath)] as ISdCliClientPackageConfig;
   }
 
   public override on(event: "change", listener: () => void): this;
@@ -35,27 +38,77 @@ export class SdCliClientBuilder extends EventEmitter {
     return this;
   }
 
-  public async watchAsync(): Promise<number> {
-    const cachePath = path.resolve(this._pkgPath, ".cache", "dev", ...this._builderKey !== "web" ? [this._builderKey] : []);
+  public async watchAsync(): Promise<void> {
+    this._debug("빌드 준비...");
+    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, () => ({emitJs: false}));
+
+    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 viteServerPort = this._pkgConf.builder?.[this._builderKey]?.["devServerPort"] ?? MathUtil.getRandomInt(60000, 65535);
-    const viteServer = await vite.createServer(this._getViteConfig({
+    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,
-      pkgConf: this._pkgConf,
-      cachePath: cachePath,
-      port: viteServerPort,
+      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;
+      }
     }));
-    await viteServer.listen(viteServerPort);
+
+    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
+      }))
+    ]);
 
     this._debug("CHECK...");
-    const sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, () => ({emitJs: false}));
     const checkResult = await sdTsProgram.buildAsync();
 
     this._debug("LINT...");
-    const lintResults = !this._withLint ? [] : await SdLinter.lintAsync(checkResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+    const lintResults = await SdLinter.lintAsync(checkResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+
+    this._debug(`빌드 완료`);
+    this.emit("complete", {
+      affectedFilePaths: checkResult.affectedFilePaths,
+      buildResults: [...buildResults, ...checkResult.results, ...lintResults]
+    });
 
     this._debug("WATCH...");
     const fnQ = new FunctionQueue();
@@ -66,285 +119,257 @@ export class SdCliClientBuilder extends EventEmitter {
       ])
       .onChange({
         delay: 100
-      }, () => {
+      }, (changeInfos) => {
+        for (const changeInfo of changeInfos) {
+          cache.delete(PathUtil.posix(changeInfo.path));
+        }
+
         fnQ.runLast(async () => {
           this.emit("change");
 
-          this._debug(`CHECK...`);
+          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
+            }))
+          ]);
+
+          this._debug("CHECK...");
           const watchCheckResult = await sdTsProgram.buildAsync();
 
           this._debug(`LINT...`);
-          const watchLintResults = !this._withLint ? [] : await SdLinter.lintAsync(watchCheckResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
+          const watchLintResults = await SdLinter.lintAsync(watchCheckResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
 
           this._debug(`빌드 완료`);
           this.emit("complete", {
-            port: viteServerPort,
             affectedFilePaths: watchCheckResult.affectedFilePaths,
-            buildResults: [...watchCheckResult.results, ...watchLintResults]
+            buildResults: [...watchBuildResults, ...watchCheckResult.results, ...watchLintResults]
           });
         });
       });
-
-    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(`빌드 완료`);
-    this.emit("complete", {
-      port: viteServerPort,
-      affectedFilePaths: checkResult.affectedFilePaths,
-      buildResults: [...checkResult.results, ...lintResults]
-    });
-
-    return viteServerPort;
   }
 
+  // eslint-disable-next-line @typescript-eslint/require-await
   public async buildAsync(): Promise<ISdCliBuilderResult> {
-    this._debug("dist 초기화...");
-    const cachePath = path.resolve(this._pkgPath, ".cache", "prod", ...this._builderKey !== "web" ? [this._builderKey] : []);
-    const distPath = path.resolve(this._pkgPath, "dist", ...this._builderKey !== "web" ? [this._builderKey] : []);
-    await FsUtil.removeAsync(cachePath);
-    await FsUtil.removeAsync(distPath);
-
-    this._debug("BUILD...");
-    const buildResults: ISdCliPackageBuildResult[] = [];
-    try {
-      await vite.build(this._getViteConfig({
-        dev: false,
-        pkgConf: this._pkgConf,
-        cachePath: cachePath,
-        distPath: distPath,
-      }));
-    }
-    catch (err) {
-      if ("errors" in err && err.errors instanceof Array) {
-        buildResults.push(...err.errors.map((item: any) => ({
-          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: any) => ({
-          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 sdTsProgram = await SdTsIncrementalBuilder.createAsync(this._pkgPath, () => ({emitJs: false}));
-    const checkResult = await sdTsProgram.buildAsync();
-
-    this._debug("LINT...");
-    const lintResults = !this._withLint ? [] : await SdLinter.lintAsync(checkResult.affectedFilePaths, sdTsProgram.builderProgram!.getProgram());
-
-    if (this._pkgConf.server !== undefined) {
-      const confDistPath = path.resolve(this._pkgPath, "dist/.config.json");
-      this._debug("GEN .config...");
-      await FsUtil.writeFileAsync(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
-    }
-
-    if (this._builderKey === "electron") {
-      const electronSrcPath = path.resolve(this._pkgPath, ".cache/prod/electron/src");
-      const electronDistPath = path.resolve(this._pkgPath, ".cache/prod/electron/dist");
-      const pkgNpmConfig = (await FsUtil.readJsonAsync(path.resolve(this._pkgPath, `package.json`))) as INpmConfig;
-
-      this._debug("package.json 파일 쓰기...");
-      const externalPkgNames = this._pkgConf.builder!.electron!.reinstallDependencies ?? [];
-
-      await FsUtil.writeJsonAsync(path.resolve(electronSrcPath, `package.json`), {
-        name: pkgNpmConfig.name,
-        version: pkgNpmConfig.version,
-        description: pkgNpmConfig.description,
-        main: "electron-main.js",
-        ...this._pkgConf.builder!.electron!.postInstallScript !== undefined ? {
-          scripts: {
-            "postinstall": this._pkgConf.builder!.electron!.postInstallScript
-          },
-        } : {},
-        dependencies: externalPkgNames.toObject((item) => item, (item) => pkgNpmConfig.dependencies![item] ?? "*")
-      });
-
-      this._debug("npm install...");
-      await SdProcess.spawnAsync(`npm install`, {cwd: electronSrcPath}, true);
-
-      for (const externalPkgName of externalPkgNames) {
-        if (FsUtil.exists(path.resolve(electronSrcPath, "node_modules", externalPkgName, "binding.gyp"))) {
-          this._debug(`electron rebuild (${externalPkgName})...`);
-          await SdProcess.spawnAsync(`electron-rebuild -m ./node_modules/${externalPkgName}`, {cwd: electronSrcPath}, true);
-        }
-      }
-
-      await electronBuilder.build({
-        targets: electronBuilder.Platform.WINDOWS.createTarget(),
-        config: {
-          appId: this._pkgConf.builder!.electron!.appId,
-          productName: pkgNpmConfig.description,
-          // asar: false,
-          win: {
-            target: "nsis"
-          },
-          nsis: {},
-          directories: {
-            app: electronSrcPath,
-            output: electronDistPath
-          },
-          ...this._pkgConf.builder!.electron!.installerIcon !== undefined ? {
-            icon: path.resolve(this._pkgPath, "src", this._pkgConf.builder!.electron!.installerIcon)
-          } : {},
-          removePackageScripts: false
-        }
-      });
-
-      await FsUtil.copyAsync(
-        path.resolve(electronDistPath, `${pkgNpmConfig.description} Setup ${pkgNpmConfig.version}.exe`),
-        path.resolve(distPath, `electron/${pkgNpmConfig.description}-latest.exe`)
-      );
-
-      await FsUtil.copyAsync(
-        path.resolve(electronDistPath, `${pkgNpmConfig.description} Setup ${pkgNpmConfig.version}.exe`),
-        path.resolve(distPath, `electron/updates/${pkgNpmConfig.version}.exe`)
-      );
-    }
-
-
-    this._debug(`빌드 완료`);
-    return {
-      affectedFilePaths: checkResult.affectedFilePaths,
-      buildResults: [...buildResults, ...checkResult.results, ...lintResults]
-    };
+    throw new NotImplementError();
   }
 
-  private _getViteConfig(opt: {
-    dev: boolean,
-    cachePath: string,
-    distPath?: string,
-    port?: number,
-    pkgConf: ISdCliClientPackageConfig
-  }): InlineConfig {
-    const pkgNpmConf: INpmConfig = FsUtil.readJson(path.resolve(this._pkgPath, "package.json"));
-
-    const basePath = this._builderKey === "electron" ? "" : (!opt.dev || this._pkgConf.server !== undefined) ? ("/" + path.basename(this._pkgPath) + "/") : "/";
-
-    const serverHost = this._pkgConf.builder?.[this._builderKey]?.devServerHost ?? "localhost";
-
-    const define = {
-      ...opt.dev ? {
-        "import.meta.env.SD_SERVER_URL": JSON.stringify(`http://${serverHost}:${opt.port}` + basePath)
-      } : {},
-      "import.meta.env.SD_VERSION": JSON.stringify(pkgNpmConf.version),
-      ...this._pkgConf.env
-        ? Object.keys(this._pkgConf.env)
-          .toObject(
-            (key) => "import.meta.env." + key,
-            (key) => JSON.stringify(this._pkgConf.env![key])
-          )
-        : {},
-      ...this._pkgConf.builder?.[this._builderKey]?.env
-        ? Object.keys(this._pkgConf.builder[this._builderKey]!.env!)
-          .toObject(
-            (key) => "import.meta.env." + key,
-            (key) => JSON.stringify(this._pkgConf.builder![this._builderKey]!.env![key])
-          )
-        : {}
-    };
+  private async _getEsBuildOptionsAsync(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");
+
+    const cacheBasePath = path.resolve(this._pkgPath, ".cache");
+    const distBasePath = path.resolve(this._pkgPath, "dist");
+
+    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,
+    );
 
-    return defineConfig({
-      mode: opt.dev ? "development" : "production",
-      root: path.resolve(this._pkgPath, "src"),
-      cacheDir: path.resolve(opt.cachePath, "vite"),
-      base: basePath,
-      assetsInclude: [
-        "**/*.xlsx",
-        "**/*.xls",
-        "**/*.docx",
-        "**/*.doc",
-        "**/*.pptx",
-        "**/*.ppt",
-        "**/*.woff",
-        "**/*.woff2",
-        "**/*.ttf",
-        "**/*.eot",
-        "**/*.otf",
-        "**/*.csv",
-        "**/*.zip",
-        "**/*.pfx",
-        "**/*.pkl"
+    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'
       ],
-      define: define,
-      ...opt.dev ? {
-        server: {
-          host: serverHost,
-          port: opt.port,
-          hmr: {
-            host: serverHost,
-            port: opt.port
-          }
-        },
-      } : {},
-      optimizeDeps: {
-        force: true
+      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"
       },
-      ...!opt.dev ? {
-        build: {
-          outDir: this._builderKey === "electron" ? path.resolve(opt.cachePath, "src") : opt.distPath,
-          rollupOptions: {
-            output: {
-              entryFileNames: `assets/[name].js`,
-              chunkFileNames: `assets/[name].js`,
-              assetFileNames: `assets/[name].[ext]`
-            }
-          }
-        }
-      } : {},
+      inject: [PathUtil.posix(fileURLToPath(await import.meta.resolve!("node-stdlib-browser/helpers/esbuild/shim")))],
       plugins: [
-        SdCliViteReactSwcPlugin(),
-        SdCliViteLoggerPlugin({
-          logger: this._logger,
-          name: path.basename(this._pkgPath)
-        }),
-        vitePluginPaths(),
-        ...opt.dev ? [
-          SdCliViteLazyImportPlugin()
-        ] : [],
-        ...opt.dev ? [
-          SdCliViteServeOptimizeExcludePlugin([
-            "@simplysm/*"
-          ])
-        ] : [],
-        ...!opt.dev && this._builderKey === "web" ? [
-          VitePWA({
-            registerType: 'autoUpdate',
-            manifest: FsUtil.readJson(path.resolve(this._pkgPath, "src/manifest.json"))
-          }),
-        ] : [],
-        ...this._builderKey === "web" ? [
-          SdCliViteNodeGlobalPlugin()
-        ] : [],
-        ...this._builderKey === "electron" ? [
-          SdCliViteElectronMainPlugin({
-            entry: path.resolve(this._pkgPath, "src/electron-main.ts"),
-            distPath: path.resolve(opt.cachePath, "src"),
-            cachePath: path.resolve(opt.cachePath, "electron-main")
-          }),
-          SdCliViteExternalPlugin({
-            target: "browser",
-            cachePath: path.resolve(opt.cachePath, "external"),
-            includes: opt.pkgConf.builder?.electron?.reinstallDependencies
+        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)
+      ]
+    };
   }
 
   private _debug(msg: string): void {