@simplysm/sd-cli 10.0.47 → 10.0.50

package/src/sd-cli.ts

@@ -6,6 +6,7 @@ import {SdCliProject} from "./entry/SdCliProject";
 import {Logger, LoggerSeverity} from "@simplysm/sd-core-node";
 import {EventEmitter} from "events";
 import {SdCliElectron} from "./entry/SdCliElectron";
+import {SdCliLocalUpdate} from "./entry/SdCliLocalUpdate";
 
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 0;
@@ -21,6 +22,22 @@ const argv = (
         default: false
       }
     })
+    .command(
+      "local-update",
+      "로컬 라이브러리 업데이트를 수행합니다.",
+      (cmd) => cmd.version(false).hide("help").hide("debug")
+        .options({
+          config: {
+            string: true,
+            describe: "simplysm.cjs 파일 경로"
+          },
+          options: {
+            string: true,
+            array: true,
+            describe: "옵션 설정"
+          }
+        })
+    )
     .command(
       "watch",
       "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.",
@@ -163,7 +180,13 @@ else {
   });
 }
 
-if (argv._[0] === "watch") {
+if (argv._[0] === "local-update") {
+  await SdCliLocalUpdate.runAsync({
+    confFileRelPath: argv.config ?? "simplysm.cjs",
+    optNames: argv.options ?? [],
+  });
+}
+else if (argv._[0] === "watch") {
   await SdCliProject
     .watchAsync({
       confFileRelPath: argv.config ?? "simplysm.cjs",

package/src/utils/SdCliViteElectronMainPlugin.ts

@@ -5,100 +5,98 @@ import {SdCliViteLoggerPlugin} from "./SdCliViteLoggerPlugin";
 import {Logger} from "@simplysm/sd-core-node";
 
 export const SdCliViteElectronMainPlugin = (opt: {
-    entry: string;
-    distPath: string;
-    cachePath: string;
+  entry: string;
+  distPath: string;
+  cachePath: string;
 }): PluginOption[] => {
-    const logger = Logger.get(["simplysm", "sd-cli", "SdCliViteElectronMainPlugin"]);
+  const logger = Logger.get(["simplysm", "sd-cli", "SdCliViteElectronMainPlugin"]);
 
-    let mainConfig: UserConfig;
+  let mainConfig: UserConfig;
 
-    return [
-        {
-            name: "sd-cli:vite:electron-main",
-            apply: "serve",
-            configureServer: (server) => {
-                server.httpServer?.on("listening", async () => {
-                    mainConfig = defineConfig({
-                        mode: server.config.mode,
-                        define: server.config.define,
-                        root: server.config.root,
-                        optimizeDeps: {
-                            force: server.config.optimizeDeps?.force
-                        },
-                        build: {
-                            sourcemap: true,
-                            minify: false,
-                            outDir: opt.distPath,
-                            lib: {
-                                entry: opt.entry,
-                                formats: ["cjs"],
-                                fileName: () => "[name].js"
-                            },
-                            emptyOutDir: false
-                        },
-                        plugins: [
-                            SdCliViteLoggerPlugin({
-                                logger,
-                                name: path.basename(opt.entry)
-                            }),
-                            SdCliViteExternalPlugin({
-                                target: "node",
-                                cachePath: path.resolve(opt.cachePath, "externals"),
-                                nodeBuiltinModules: true,
-                                includes: ["electron"]
-                            }),
-                            {
-                                name: ":startup",
-                                closeBundle: () => {
-                                    server.ws.send({type: "full-reload"});
-                                }
-                            }
-                        ]
-                    });
-                    await build(mainConfig);
-                });
+  return [
+    {
+      name: "sd-cli:vite:electron-main",
+      apply: "serve",
+      configureServer: (server) => {
+        server.httpServer?.on("listening", async () => {
+          mainConfig = defineConfig({
+            mode: server.config.mode,
+            define: server.config.define,
+            root: server.config.root,
+            optimizeDeps: {
+              force: server.config.optimizeDeps?.force
             },
-        },
-        {
-            name: "sd-cli:vite:electron-main",
-            apply: "build",
-            config: (config) => {
-                mainConfig = defineConfig({
-                    mode: config.mode,
-                    define: config.define,
-                    root: config.root,
-                    optimizeDeps: {
-                        force: config.optimizeDeps?.force
-                    },
-                    build: {
-                        sourcemap: false,
-                        minify: true,
-                        outDir: opt.distPath,
-                        lib: {
-                            entry: opt.entry,
-                            formats: ["cjs"],
-                            fileName: () => "[name].js"
-                        },
-                        emptyOutDir: false
-                    },
-                    plugins: [
-                        SdCliViteLoggerPlugin({
-                            logger,
-                            name: path.basename(opt.entry)
-                        }),
-                        SdCliViteExternalPlugin({
-                            target: "node",
-                            cachePath: path.resolve(opt.cachePath, "externals"),
-                            nodeBuiltinModules: true,
-                            includes: ["electron"]
-                        }),
-                    ]
-                });
+            build: {
+              sourcemap: true,
+              minify: false,
+              outDir: opt.distPath,
+              lib: {
+                entry: opt.entry,
+                formats: ["cjs"],
+                fileName: () => "[name].js"
+              },
+              emptyOutDir: false
             },
-            closeBundle: async () => {
-                await build(mainConfig);
-            }
-        }
-    ];
+            plugins: [
+              SdCliViteLoggerPlugin({
+                logger,
+                name: path.basename(opt.entry)
+              }),
+              SdCliViteExternalPlugin({
+                target: "node",
+                cachePath: path.resolve(opt.cachePath, "externals"),
+                includes: ["electron"]
+              }),
+              {
+                name: ":startup",
+                closeBundle: () => {
+                  server.ws.send({type: "full-reload"});
+                }
+              }
+            ]
+          });
+          await build(mainConfig);
+        });
+      },
+    },
+    {
+      name: "sd-cli:vite:electron-main",
+      apply: "build",
+      config: (config) => {
+        mainConfig = defineConfig({
+          mode: config.mode,
+          define: config.define,
+          root: config.root,
+          optimizeDeps: {
+            force: config.optimizeDeps?.force
+          },
+          build: {
+            sourcemap: false,
+            minify: true,
+            outDir: opt.distPath,
+            lib: {
+              entry: opt.entry,
+              formats: ["cjs"],
+              fileName: () => "[name].js"
+            },
+            emptyOutDir: false
+          },
+          plugins: [
+            SdCliViteLoggerPlugin({
+              logger,
+              name: path.basename(opt.entry)
+            }),
+            SdCliViteExternalPlugin({
+              target: "node",
+              cachePath: path.resolve(opt.cachePath, "externals"),
+              includes: ["electron"]
+            }),
+          ]
+        });
+      },
+      closeBundle: async () => {
+        await build(mainConfig);
+      }
+    }
+  ];
 };

package/src/utils/SdCliViteExternalPlugin.ts

@@ -1,117 +1,98 @@
 import {PluginOption} from "vite";
 import {builtinModules, createRequire} from "node:module";
 import {FsUtil, PathUtil} from "@simplysm/sd-core-node";
-import {INpmConfig} from "../commons";
 import path from "path";
 import {pathToFileURL} from "url";
 import libEsm from "lib-esm";
 import esbuild from "esbuild";
 
 export const SdCliViteExternalPlugin = (opt: {
-    target: "browser" | "node";
-    cachePath: string;
-    nodeBuiltinModules?: boolean;
-    dependencies?: boolean;
-    includes?: string[];
+  target: "browser" | "node";
+  cachePath: string;
+  includes?: string[];
 }): PluginOption[] => {
-    const externals = opt.includes ?? [];
+  const externals = opt.includes ?? [];
 
-    const builtins = [
-        ...builtinModules,
-        ...builtinModules.map((item) => `node:${item}`)
-    ];
+  const builtins = [
+    ...builtinModules,
+    ...builtinModules.map((item) => `node:${item}`)
+  ];
 
-    return [
-        opt.target === "node" ? {
-            name: "sd-cli:vite:external",
-            enforce: "pre",
-            config: (conf) => {
-                if (opt.dependencies) {
-                    const npmConfigPath = FsUtil.findAllParentChildPaths("package.json", conf.root ?? opt.cachePath).first()!;
-                    const npmConfig = FsUtil.readJson(npmConfigPath) as INpmConfig;
-                    if (npmConfig.dependencies) {
-                        externals.push(...Object.keys(npmConfig.dependencies));
-                    }
-                }
-            },
-            resolveId: (source, importer) => {
-                if (importer === undefined) return;
-
-                if (externals.includes(source)) {
-                    return {
-                        id: source,
-                        external: true
-                    };
-                }
+  return [
+    opt.target === "node" ? {
+      name: "sd-cli:vite:external",
+      enforce: "pre",
+      resolveId: (source, importer) => {
+        if (importer === undefined) return;
 
-                if (builtins.includes(source)) {
-                    return {
-                        id: `node:${source}`,
-                        external: true
-                    };
-                }
+        if (externals.includes(source)) {
+          return {
+            id: source,
+            external: true
+          };
+        }
 
-                return;
-            }
-        } : {
-            name: "sd-cli:vite:external",
-            enforce: "pre",
-            config: (conf) => {
-                if (opt.dependencies) {
-                    const npmConfigPath = FsUtil.findAllParentChildPaths("package.json", conf.root ?? opt.cachePath).first()!;
-                    const npmConfig = FsUtil.readJson(npmConfigPath) as INpmConfig;
-                    if (npmConfig.dependencies) {
-                        externals.push(...Object.keys(npmConfig.dependencies));
-                    }
-                }
+        if (builtins.includes(source)) {
+          return {
+            id: `node:${source}`,
+            external: true
+          };
+        }
 
-                async function _getSnippetsAsync(moduleName: string, importer?: string): Promise<string> {
-                    const myRequire = createRequire(pathToFileURL(importer ?? process.cwd()).toString());
-                    let realModuleName: string;
-                    try {
-                        realModuleName = moduleName;
-                    } catch {
-                        realModuleName = await _getPreBundleAsync(moduleName);
-                    }
-                    const module = myRequire(realModuleName);
-                    const members = Object.getOwnPropertyNames(module);
-                    const {exports} = libEsm({exports: members});
-                    return `const avoid_parse_require = require; const _M_ = avoid_parse_require("${PathUtil.posix(realModuleName)}"); ${exports}`;
-                }
+        return;
+      }
+    } : {
+      name: "sd-cli:vite:external",
+      enforce: "pre",
+      config: () => {
+        async function _getSnippetsAsync(moduleName: string, importer?: string): Promise<string> {
+          const myRequire = createRequire(pathToFileURL(importer ?? process.cwd()).toString());
+          let realModuleName: string;
+          try {
+            realModuleName = moduleName;
+          }
+          catch {
+            realModuleName = await _getPreBundleAsync(moduleName);
+          }
+          const module = myRequire(realModuleName);
+          const members = Object.getOwnPropertyNames(module);
+          const {exports} = libEsm({exports: members});
+          return `const avoid_parse_require = require; const _M_ = avoid_parse_require("${PathUtil.posix(realModuleName)}"); ${exports}`;
+        }
 
-                async function _getPreBundleAsync(moduleName: string): Promise<string> {
-                    const outfile = path.posix.join(opt.cachePath, moduleName) + ".cjs";
-                    await esbuild.build({
-                        entryPoints: [moduleName],
-                        outfile,
-                        target: 'node18',
-                        format: 'cjs',
-                        bundle: true,
-                        sourcemap: 'inline',
-                        platform: 'node',
-                        external: builtins
-                    });
+        async function _getPreBundleAsync(moduleName: string): Promise<string> {
+          const outfile = path.posix.join(opt.cachePath, moduleName) + ".cjs";
+          await esbuild.build({
+            entryPoints: [moduleName],
+            outfile,
+            target: 'node18',
+            format: 'cjs',
+            bundle: true,
+            sourcemap: 'inline',
+            platform: 'node',
+            external: builtins
+          });
 
-                    return outfile;
-                }
+          return outfile;
+        }
 
-                return {
-                    resolve: {
-                        alias: [{
-                            find: new RegExp(`^(${[...externals, ...builtins].join("|")})$`),
-                            replacement: "$1",
+        return {
+          resolve: {
+            alias: [{
+              find: new RegExp(`^(${[...externals, ...builtins].join("|")})$`),
+              replacement: "$1",
 
-                            customResolver: async (source, importer) => {
-                                const id = path.posix.join(opt.cachePath, source) + ".mjs";
-                                if (!FsUtil.exists(id)) {
-                                    await FsUtil.writeFileAsync(id, await _getSnippetsAsync(source, importer));
-                                }
-                                return {id};
-                            }
-                        }],
-                    }
-                };
-            }
-        }
-    ];
+              customResolver: async (source, importer) => {
+                const id = path.posix.join(opt.cachePath, source) + ".mjs";
+                if (!FsUtil.exists(id)) {
+                  await FsUtil.writeFileAsync(id, await _getSnippetsAsync(source, importer));
+                }
+                return {id};
+              }
+            }],
+          }
+        };
+      }
+    }
+  ];
 };

package/src/utils/SdCliViteReactSwcPlugin.ts

@@ -24,13 +24,13 @@ export const SdCliViteReactSwcPlugin = (): PluginOption[] => {
       config: () => ({
         esbuild: false,
         optimizeDeps: {
-          include: [`react/jsx-dev-runtime`],
+          include: [`react/jsx-dev-runtime`, `react/jsx-runtime`],
         },
       }),
       transformIndexHtml: (html, ctx) => [
         {
           tag: "script",
-          attrs: { type: "module" },
+          attrs: {type: "module"},
           children: `import { injectIntoGlobalHook } from "${ctx.server!.config.base + runtimePublicPath.slice(1)}";
 injectIntoGlobalHook(window);
 window.$RefreshReg$ = () => {};
@@ -70,7 +70,7 @@ RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
 
         const sourceMap: SourceMapPayload = JSON.parse(result.map!);
         sourceMap.mappings = ";;;;;;;;" + sourceMap.mappings;
-        return { code: result.code, map: sourceMap };
+        return {code: result.code, map: sourceMap};
       },
     },
     {
@@ -106,9 +106,9 @@ const transformWithOptions = async (
   dev: boolean
 ) => {
   const parser: ParserConfig | undefined =
-    id.endsWith(".tsx") ? { syntax: "typescript", tsx: true, decorators: true }
-      : id.endsWith(".ts") ? { syntax: "typescript", tsx: false, decorators: true }
-        : id.endsWith(".jsx") ? { syntax: "ecmascript", jsx: true }
+    id.endsWith(".tsx") ? {syntax: "typescript", tsx: true, decorators: true}
+      : id.endsWith(".ts") ? {syntax: "typescript", tsx: false, decorators: true}
+        : id.endsWith(".jsx") ? {syntax: "ecmascript", jsx: true}
           : undefined;
   if (!parser) return;
 

package/src/utils/SdCliViteServeOptimizeExcludePlugin.ts

@@ -0,0 +1,42 @@
+import {PluginOption} from "vite";
+import path from "path";
+import {FsUtil} from "@simplysm/sd-core-node";
+import {INpmConfig} from "../commons";
+
+export const SdCliViteServeOptimizeExcludePlugin = (moduleGlobs: string[]): PluginOption[] => {
+  return [{
+    name: "sd-cli:vite:serve-optimize-exclude",
+    apply: "serve",
+    enforce: "pre",
+    config: (conf) => {
+      const pkgPath = path.resolve(conf.root!, "..");
+
+      const pkgNpmConf = FsUtil.readJson(path.resolve(pkgPath, "package.json")) as INpmConfig;
+      const pkgDeps = Object.keys(pkgNpmConf.dependencies ?? {});
+
+      const modulePaths = moduleGlobs.mapMany(item => FsUtil.glob(path.resolve(process.cwd(), "node_modules", item))).distinct();
+      const moduleNames = modulePaths.map(item => item.match(/[\\\/]node_modules[\\\/](.*)/)![1].replace(/\\/g, "/"))
+        .filter(item => pkgDeps.includes(item))
+        .distinct();
+
+      const subDeps: string[] = [];
+      for (const moduleName of moduleNames) {
+        const moduleNpmConf = FsUtil.readJson(path.resolve(process.cwd(), "node_modules", moduleName, "package.json")) as INpmConfig;
+        const depNames = Object.keys(moduleNpmConf.dependencies ?? {});
+        subDeps.push(...depNames.filter(item => !moduleNames.includes(item)));
+      }
+
+      return {
+        server: {
+          watch: {
+            ignored: moduleNames.map(item => `!**/node_modules/${item}/**`)
+          }
+        },
+        optimizeDeps: {
+          exclude: moduleNames,
+          include: subDeps
+        }
+      };
+    }
+  }];
+};