@simplysm/sd-cli 10.0.37 → 10.0.39

package/src/index.ts

@@ -0,0 +1 @@
+export { TSdCliConfigFn, ISdCliConfig } from "./commons";

package/src/sd-cli.ts

@@ -1,138 +1,201 @@
-#!/usr/bin/env node --no-warnings --experimental-import-meta-resolve
+#!/usr/bin/env node --es-module-specifier-resolution=node --no-warnings --experimental-import-meta-resolve
 
 import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { SdCliProject } from "./entry/SdCliProject";
-import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
-import { EventEmitter } from "events";
+import {hideBin} from "yargs/helpers";
+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;
 
 const argv = (
-  await yargs(hideBin(process.argv))
-    .help("help", "도움말")
-    .alias("help", "h")
-    .options({
-      debug: {
-        type: "boolean",
-        describe: "디버그 로그를 표시할 것인지 여부",
-        default: false
-      }
-    })
-    .command(
-      "watch",
-      "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.",
-      (cmd) => cmd.version(false).hide("help").hide("debug")
+    await yargs(hideBin(process.argv))
+        .help("help", "도움말")
+        .alias("help", "h")
         .options({
-          config: {
-            string: true,
-            describe: "simplysm.json 파일 경로"
-          },
-          options: {
-            string: true,
-            array: true,
-            describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
-          },
-          packages: {
-            string: true,
-            array: true,
-            describe: "수행할 패키지 설정"
-          }
+            debug: {
+                type: "boolean",
+                describe: "디버그 로그를 표시할 것인지 여부",
+                default: false
+            }
         })
-    )
-    .command(
-      "build",
-      "프로젝트의 각 패키지에 대한 빌드를 수행합니다.",
-      (cmd) => cmd.version(false).hide("help").hide("debug")
-        .options({
-          config: {
-            string: true,
-            describe: "simplysm.json 파일 경로"
-          },
-          options: {
-            string: true,
-            array: true,
-            describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
-          },
-          packages: {
-            string: true,
-            array: true,
-            describe: "수행할 패키지 설정"
-          }
-        })
-    )
-    .command(
-      "publish",
-      "프로젝트의 각 패키지를 배포합니다.",
-      (cmd) => cmd.version(false).hide("help").hide("debug")
-        .options({
-          noBuild: {
-            type: "boolean",
-            describe: "빌드를 하지않고 배포합니다.",
-            default: false
-          },
-          config: {
-            type: "string",
-            describe: "simplysm.json 파일 경로"
-          },
-          options: {
-            type: "string",
-            array: true,
-            describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
-          },
-          packages: {
-            type: "string",
-            array: true,
-            describe: "수행할 패키지 설정"
-          }
-        })
-    )
-    .parseAsync()
+        .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",
+            "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.",
+            (cmd) => cmd.version(false).hide("help").hide("debug")
+                .options({
+                    config: {
+                        string: true,
+                        describe: "simplysm.cjs 파일 경로"
+                    },
+                    options: {
+                        string: true,
+                        array: true,
+                        describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
+                    },
+                    packages: {
+                        string: true,
+                        array: true,
+                        describe: "수행할 패키지 설정"
+                    },
+                    withoutLint: {
+                        type: "boolean",
+                        default: false,
+                        describe: "린트 수행 여부"
+                    }
+                })
+        )
+        .command(
+            "build",
+            "프로젝트의 각 패키지에 대한 빌드를 수행합니다.",
+            (cmd) => cmd.version(false).hide("help").hide("debug")
+                .options({
+                    config: {
+                        string: true,
+                        describe: "simplysm.cjs 파일 경로"
+                    },
+                    options: {
+                        string: true,
+                        array: true,
+                        describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
+                    },
+                    packages: {
+                        string: true,
+                        array: true,
+                        describe: "수행할 패키지 설정"
+                    },
+                    withoutLint: {
+                        type: "boolean",
+                        default: false,
+                        describe: "린트 수행 여부"
+                    }
+                })
+        )
+        .command(
+            "publish",
+            "프로젝트의 각 패키지를 배포합니다.",
+            (cmd) => cmd.version(false).hide("help").hide("debug")
+                .options({
+                    noBuild: {
+                        type: "boolean",
+                        describe: "빌드를 하지않고 배포합니다.",
+                        default: false
+                    },
+                    config: {
+                        type: "string",
+                        describe: "simplysm.cjs 파일 경로"
+                    },
+                    options: {
+                        type: "string",
+                        array: true,
+                        describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
+                    },
+                    packages: {
+                        type: "string",
+                        array: true,
+                        describe: "수행할 패키지 설정"
+                    },
+                    withoutLint: {
+                        type: "boolean",
+                        default: false,
+                        describe: "린트 수행 여부"
+                    }
+                })
+        )
+        .command(
+            "run-electron <package>",
+            "변경감지중인 플랫폼을 ELECTRON 앱 형태로 띄웁니다.",
+            (cmd) => cmd
+                .positional("package", {
+                    type: "string",
+                    describe: "패키지명",
+                    demandOption: true
+                })
+                .options({
+                    config: {
+                        type: "string",
+                        describe: "simplysm.json 파일 경로"
+                    },
+                    options: {
+                        type: "string",
+                        array: true,
+                        describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)"
+                    }
+                })
+        )
+        .parseAsync()
 ) as any;
 
 if (Boolean(argv.debug)) {
-  process.env["SD_DEBUG"] = "true";
-  Logger.setConfig({
-    console: {
-      level: LoggerSeverity.debug
-    }
-  });
-}
-else {
-  Logger.setConfig({
-    dot: true
-  });
-}
-
-if (argv._[0] === "watch") {
-  await SdCliProject
-    .watchAsync({
-      rootPath: process.cwd(),
-      confFileRelPath: argv.config ?? "simplysm.json",
-      optNames: argv.options ?? [],
-      pkgNames: argv.packages ?? []
-    });
-}
-else if (argv._[0] === "build") {
-  await SdCliProject
-    .buildAsync({
-      rootPath: process.cwd(),
-      confFileRelPath: argv.config ?? "simplysm.json",
-      optNames: argv.options ?? [],
-      pkgNames: argv.packages ?? []
+    process.env["SD_DEBUG"] = "true";
+    Logger.setConfig({
+        console: {
+            level: LoggerSeverity.debug
+        }
     });
-}
-else if (argv._[0] === "publish") {
-  await SdCliProject
-    .publishAsync({
-      rootPath: process.cwd(),
-      noBuild: argv.noBuild,
-      confFileRelPath: argv.config ?? "simplysm.json",
-      optNames: argv.options ?? [],
-      pkgNames: argv.packages ?? []
+} else {
+    Logger.setConfig({
+        dot: true
     });
 }
-else {
-  throw new Error(`명령어가 잘못 되었습니다.\n\t${argv._[0]}\n`);
+
+if (argv._[0] === "watch") {
+    await SdCliProject
+        .watchAsync({
+            confFileRelPath: argv.config ?? "simplysm.cjs",
+            optNames: argv.options ?? [],
+            pkgNames: argv.packages ?? [],
+            withLint: argv.withoutLint !== true
+        });
+} else if (argv._[0] === "build") {
+    await SdCliProject
+        .buildAsync({
+            confFileRelPath: argv.config ?? "simplysm.cjs",
+            optNames: argv.options ?? [],
+            pkgNames: argv.packages ?? [],
+            withLint: argv.withoutLint !== true
+        });
+} else if (argv._[0] === "publish") {
+    await SdCliProject
+        .publishAsync({
+            noBuild: argv.noBuild,
+            confFileRelPath: argv.config ?? "simplysm.cjs",
+            optNames: argv.options ?? [],
+            pkgNames: argv.packages ?? [],
+            withLint: argv.withoutLint !== true
+        });
+} else if (argv._[0] === "run-electron") {
+    await SdCliElectron
+        .runAsync({
+            confFileRelPath: argv.config ?? "simplysm.cjs",
+            optNames: argv.options ?? [],
+            pkgName: argv.package
+        });
+} else if (argv._[0] === "local-update") {
+    await SdCliLocalUpdate
+        .runAsync({
+            confFileRelPath: argv.config ?? "simplysm.cjs",
+            optNames: argv.options ?? []
+        });
+} else {
+    throw new Error(`명령어가 잘못 되었습니다.\n\t${argv._[0]}\n`);
 }

package/src/utils/SdCliBuildResultUtil.ts

@@ -13,14 +13,13 @@ export class SdCliBuildResultUtil {
     const code = `TS${diag.code}`;
     const message = ts.flattenDiagnosticMessageText(diag.messageText, os.EOL);
 
-
     const filePath = diag.file ? path.resolve(diag.file.fileName) : undefined;
     const position = diag.file && diag.start !== undefined ? diag.file.getLineAndCharacterOfPosition(diag.start) : undefined;
     const line = position ? position.line + 1 : undefined;
     const char = position ? position.character + 1 : undefined;
 
     return {
-      filePath,
+      filePath: filePath !== undefined ? path.resolve(filePath) : undefined,
       line,
       char,
       code,

package/src/utils/SdCliViteElectronMainPlugin.ts

@@ -0,0 +1,86 @@
+import {build, defineConfig, PluginOption, UserConfig} from "vite";
+import {SdCliViteExternalPlugin} from "./SdCliViteExternalPlugin";
+import path from "path";
+
+export const SdCliViteElectronMainPlugin = (opt: {
+    entry: string;
+    distPath: string;
+    cachePath: string;
+}): PluginOption[] => {
+    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"
+                            }
+                        },
+                        customLogger: server.config.customLogger,
+                        plugins: [
+                            SdCliViteExternalPlugin({
+                                cachePath: path.resolve(opt.cachePath, "externals"),
+                                nodeBuiltinModules: true,
+                                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,
+                    resolve: {
+                        alias: config.resolve?.alias
+                    },
+                    optimizeDeps: {
+                        force: config.optimizeDeps?.force
+                    },
+                    build: {
+                        sourcemap: false,
+                        minify: true,
+                        outDir: opt.distPath,
+                        lib: {
+                            entry: opt.entry,
+                            formats: ["cjs"],
+                            fileName: () => "[name].js"
+                        }
+                    },
+                    customLogger: config.customLogger
+                });
+            },
+            closeBundle: async () => {
+                await build(mainConfig);
+            }
+        }
+    ];
+};

package/src/utils/SdCliViteExternalPlugin.ts

@@ -0,0 +1,112 @@
+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: {
+    cachePath: string;
+    nodeBuiltinModules?: boolean;
+    dependencies?: boolean;
+    includes?: string[];
+}): PluginOption[] => {
+    const externals = opt.includes ?? [];
+
+    const builtins =[
+        ...builtinModules,
+        ...builtinModules.map((item) => `node:${item}`)
+    ];
+
+    return [
+        {
+            name: "sd-cli:vite:external",
+            enforce: "pre",
+            apply: "build",
+            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, ...builtins].includes(source)) {
+                    return {
+                        id: source,
+                        external: true
+                    };
+                }
+
+                return;
+            }
+        },
+        {
+            name: "sd-cli:vite:external",
+            enforce: "pre",
+            apply: "serve",
+            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));
+                    }
+                }
+
+                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
+                    });
+
+                    return outfile;
+                }
+
+                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};
+                            }
+                        }],
+                    }
+                };
+            }
+        }
+    ];
+};

package/src/utils/SdCliViteLoggerPlugin.ts

@@ -0,0 +1,29 @@
+import * as vite from "vite";
+import {PluginOption} from "vite";
+import {Logger} from "@simplysm/sd-core-node";
+
+export const SdCliViteLoggerPlugin = (opt: {
+    logger: Logger,
+    name: string
+}): PluginOption[] => {
+    return [
+        {
+            name: "sd-cli:vite:logger",
+            enforce: "pre",
+            config: () => ({
+                customLogger: {
+                    ...vite.createLogger(),
+                    info: (msg) => {
+                        opt.logger.debug(`[${opt.name}] ${msg}`);
+                    },
+                    warn: (msg) => {
+                        opt.logger.warn(`[${opt.name}] ${msg}`);
+                    },
+                    error: (msg) => {
+                        opt.logger.error(`[${opt.name}] ${msg}`);
+                    }
+                },
+            })
+        }
+    ];
+};

package/src/utils/SdCliViteNodeGlobalPlugin.ts

@@ -0,0 +1,31 @@
+import { PluginOption } from "vite";
+import stdLibBrowser from "node-stdlib-browser";
+import inject from "@rollup/plugin-inject";
+import { fileURLToPath } from "url";
+
+const esbuildShim = fileURLToPath(await import.meta.resolve!("node-stdlib-browser/helpers/esbuild/shim"));
+
+export const SdCliViteNodeGlobalPlugin = (): PluginOption[] => {
+  return [
+    {
+      name: "sd-cli:vite:node-global",
+      enforce: "pre",
+      config: () => ({
+        optimizeDeps: {
+          include: ["buffer", "process"]
+        },
+        resolve: {
+          alias: stdLibBrowser
+        }
+      }),
+    },
+    {
+      ...inject({
+        global: [esbuildShim, 'global'],
+        process: [esbuildShim, 'process'],
+        Buffer: [esbuildShim, 'Buffer']
+      }),
+      enforce: 'post'
+    }
+  ];
+};