@simplysm/sd-cli 12.5.21 → 12.5.22

package/src/entry/SdCliElectron.ts

@@ -1,64 +1,69 @@
-import {FsUtil, Logger, SdProcess} from "@simplysm/sd-core-node";
-import {pathToFileURL} from "url";
+import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
+import { pathToFileURL } from "url";
 import path from "path";
-import {INpmConfig, ISdCliClientBuilderElectronConfig, ISdCliConfig} from "../commons";
 import electronBuilder from "electron-builder";
+import { ISdClientBuilderElectronConfig, ISdProjectConfig } from "../types/sd-configs.type";
+import { INpmConfig } from "../types/common-configs.type";
 
 export class SdCliElectron {
-  public static async runAsync(opt: {
-    confFileRelPath: string;
-    optNames: string[];
-    pkgName: string;
-  }): Promise<void> {
+  static async runAsync(opt: { confFileRelPath: string; optNames: string[]; pkgName: string }): Promise<void> {
     const logger = Logger.get(["simplysm", "sd-cli", "SdCliElectron", "runAsync"]);
 
     const pkgPath = path.resolve(process.cwd(), `packages/${opt.pkgName}`);
     const electronPath = path.resolve(pkgPath, "dist/electron");
 
     logger.log("설정 가져오기...");
-    const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(true, opt.optNames) as ISdCliConfig;
+    const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(
+      true,
+      opt.optNames,
+    ) as ISdProjectConfig;
     const pkgConf = projConf.packages[opt.pkgName];
     if (pkgConf?.type !== "client" || pkgConf.builder?.electron === undefined) {
       throw new Error();
     }
 
     logger.log("package.json 파일 쓰기...");
-    const npmConfig = (await FsUtil.readJsonAsync(path.resolve(pkgPath, `package.json`))) as INpmConfig;
+    const npmConfig = FsUtil.readJson(path.resolve(pkgPath, `package.json`)) as INpmConfig;
 
     const externalPkgNames = pkgConf.builder.electron.reinstallDependencies ?? [];
 
-    await FsUtil.writeJsonAsync(path.resolve(electronPath, `package.json`), {
+    FsUtil.writeJson(path.resolve(electronPath, `package.json`), {
       name: npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
       version: npmConfig.version,
       description: npmConfig.description,
       main: "electron-main.js",
-      ...pkgConf.builder.electron.postInstallScript !== undefined ? {
-        scripts: {
-          "postinstall": pkgConf.builder.electron.postInstallScript
-        },
-      } : {},
-      dependencies: externalPkgNames.toObject((item) => item, (item) => npmConfig.dependencies![item])
+      ...(pkgConf.builder.electron.postInstallScript !== undefined
+        ? {
+            scripts: {
+              postinstall: pkgConf.builder.electron.postInstallScript,
+            },
+          }
+        : {}),
+      dependencies: externalPkgNames.toObject(
+        (item) => item,
+        (item) => npmConfig.dependencies![item],
+      ),
     });
 
     logger.log("npm install...");
-    await SdProcess.spawnAsync(`npm install`, {cwd: electronPath}, true);
+    await SdProcess.spawnAsync(`npm install`, { cwd: electronPath }, true);
 
     for (const externalPkgName of externalPkgNames) {
       if (FsUtil.exists(path.resolve(electronPath, "node_modules", externalPkgName, "binding.gyp"))) {
         logger.log(`electron rebuild (${externalPkgName})...`);
-        await SdProcess.spawnAsync(`electron-rebuild -m ./node_modules/${externalPkgName}`, {cwd: electronPath}, true);
+        await SdProcess.spawnAsync(
+          `electron-rebuild -m ./node_modules/${externalPkgName}`,
+          { cwd: electronPath },
+          true,
+        );
       }
     }
 
     logger.log("electron...");
-    await SdProcess.spawnAsync(`electron .`, {cwd: electronPath}, true);
+    await SdProcess.spawnAsync(`electron .`, { cwd: electronPath }, true);
   }
 
-  public static async buildForDevAsync(opt: {
-    confFileRelPath: string;
-    optNames: string[];
-    pkgName: string;
-  }): Promise<void> {
+  static async buildForDevAsync(opt: { confFileRelPath: string; optNames: string[]; pkgName: string }): Promise<void> {
     const logger = Logger.get(["simplysm", "sd-cli", "SdCliElectron", "buildForDevAsync"]);
 
     const pkgPath = path.resolve(process.cwd(), `packages/${opt.pkgName}`);
@@ -66,37 +71,49 @@ export class SdCliElectron {
     const electronDistPath = path.resolve(pkgPath, ".electron/dist");
 
     logger.log("설정 가져오기...");
-    const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(true, opt.optNames) as ISdCliConfig;
+    const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(
+      true,
+      opt.optNames,
+    ) as ISdProjectConfig;
     const pkgConf = projConf.packages[opt.pkgName];
     if (pkgConf?.type !== "client" || pkgConf.builder?.electron === undefined) {
       throw new Error();
     }
 
     logger.log("package.json 파일 쓰기...");
-    const npmConfig = (await FsUtil.readJsonAsync(path.resolve(pkgPath, `package.json`))) as INpmConfig;
+    const npmConfig = FsUtil.readJson(path.resolve(pkgPath, `package.json`)) as INpmConfig;
 
     const externalPkgNames = pkgConf.builder.electron.reinstallDependencies ?? [];
 
-    await FsUtil.writeJsonAsync(path.resolve(electronPath, `package.json`), {
+    FsUtil.writeJson(path.resolve(electronPath, `package.json`), {
       name: npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
       version: npmConfig.version,
       description: npmConfig.description,
       main: "electron-main.js",
-      ...pkgConf.builder.electron.postInstallScript !== undefined ? {
-        scripts: {
-          "postinstall": pkgConf.builder.electron.postInstallScript
-        },
-      } : {},
-      dependencies: externalPkgNames.toObject((item) => item, (item) => npmConfig.dependencies![item])
+      ...(pkgConf.builder.electron.postInstallScript !== undefined
+        ? {
+            scripts: {
+              postinstall: pkgConf.builder.electron.postInstallScript,
+            },
+          }
+        : {}),
+      dependencies: externalPkgNames.toObject(
+        (item) => item,
+        (item) => npmConfig.dependencies![item],
+      ),
     });
 
     logger.log("npm install...");
-    await SdProcess.spawnAsync(`npm install`, {cwd: electronPath}, true);
+    await SdProcess.spawnAsync(`npm install`, { cwd: electronPath }, true);
 
     for (const externalPkgName of externalPkgNames) {
       if (FsUtil.exists(path.resolve(electronPath, "node_modules", externalPkgName, "binding.gyp"))) {
         logger.log(`electron rebuild (${externalPkgName})...`);
-        await SdProcess.spawnAsync(`electron-rebuild -m ./node_modules/${externalPkgName}`, {cwd: electronPath}, true);
+        await SdProcess.spawnAsync(
+          `electron-rebuild -m ./node_modules/${externalPkgName}`,
+          { cwd: electronPath },
+          true,
+        );
       }
     }
 
@@ -109,60 +126,68 @@ export class SdCliElectron {
         productName: npmConfig.description,
         asar: false,
         win: {
-          target: "nsis"
+          target: "nsis",
         },
         nsis: {},
         directories: {
           app: electronPath,
-          output: electronDistPath
+          output: electronDistPath,
         },
-        ...pkgConf.builder.electron.installerIcon !== undefined ? {
-          icon: path.resolve(pkgPath, "src", pkgConf.builder.electron.installerIcon)
-        } : {},
-        removePackageScripts: false
-      }
+        ...(pkgConf.builder.electron.installerIcon !== undefined
+          ? {
+              icon: path.resolve(pkgPath, "src", pkgConf.builder.electron.installerIcon),
+            }
+          : {}),
+        removePackageScripts: false,
+      },
     });
 
-    await FsUtil.copyAsync(
+    FsUtil.copy(
       path.resolve(electronDistPath, `${npmConfig.description} Setup ${npmConfig.version}.exe`),
-      path.resolve(pkgPath, `dist/electron/${npmConfig.description}-dev.exe`)
+      path.resolve(pkgPath, `dist/electron/${npmConfig.description}-dev.exe`),
     );
   }
 
-  public static async buildAsync(opt: {
-    pkgPath: string;
-    config: ISdCliClientBuilderElectronConfig;
-  }): Promise<void> {
+  static async buildAsync(opt: { pkgPath: string; config: ISdClientBuilderElectronConfig }): Promise<void> {
     const logger = Logger.get(["simplysm", "sd-cli", "SdCliElectron", "buildAsync"]);
 
     const electronSrcPath = path.resolve(opt.pkgPath, ".electron/src");
     const electronDistPath = path.resolve(opt.pkgPath, ".electron/dist");
 
     logger.log("package.json 파일 쓰기...");
-    const npmConfig = (await FsUtil.readJsonAsync(path.resolve(opt.pkgPath, `package.json`))) as INpmConfig;
+    const npmConfig = FsUtil.readJson(path.resolve(opt.pkgPath, `package.json`)) as INpmConfig;
 
     const externalPkgNames = opt.config.reinstallDependencies ?? [];
 
-    await FsUtil.writeJsonAsync(path.resolve(electronSrcPath, `package.json`), {
+    FsUtil.writeJson(path.resolve(electronSrcPath, `package.json`), {
       name: npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
       version: npmConfig.version,
       description: npmConfig.description,
       main: "electron-main.js",
-      ...opt.config.postInstallScript !== undefined ? {
-        scripts: {
-          "postinstall": opt.config.postInstallScript
-        },
-      } : {},
-      dependencies: externalPkgNames.toObject((item) => item, (item) => npmConfig.dependencies![item])
+      ...(opt.config.postInstallScript !== undefined
+        ? {
+            scripts: {
+              postinstall: opt.config.postInstallScript,
+            },
+          }
+        : {}),
+      dependencies: externalPkgNames.toObject(
+        (item) => item,
+        (item) => npmConfig.dependencies![item],
+      ),
     });
 
     logger.log("npm install...");
-    await SdProcess.spawnAsync(`npm install`, {cwd: electronSrcPath}, true);
+    await SdProcess.spawnAsync(`npm install`, { cwd: electronSrcPath }, true);
 
     for (const externalPkgName of externalPkgNames) {
       if (FsUtil.exists(path.resolve(electronSrcPath, "node_modules", externalPkgName, "binding.gyp"))) {
         logger.log(`electron rebuild (${externalPkgName})...`);
-        await SdProcess.spawnAsync(`electron-rebuild -m ./node_modules/${externalPkgName}`, {cwd: electronSrcPath}, true);
+        await SdProcess.spawnAsync(
+          `electron-rebuild -m ./node_modules/${externalPkgName}`,
+          { cwd: electronSrcPath },
+          true,
+        );
       }
     }
 
@@ -175,23 +200,25 @@ export class SdCliElectron {
         productName: npmConfig.description,
         asar: false,
         win: {
-          target: "nsis"
+          target: "nsis",
         },
         nsis: {},
         directories: {
           app: electronSrcPath,
-          output: electronDistPath
+          output: electronDistPath,
         },
-        ...opt.config.installerIcon !== undefined ? {
-          icon: path.resolve(opt.pkgPath, "src", opt.config.installerIcon)
-        } : {},
-        removePackageScripts: false
-      }
+        ...(opt.config.installerIcon !== undefined
+          ? {
+              icon: path.resolve(opt.pkgPath, "src", opt.config.installerIcon),
+            }
+          : {}),
+        removePackageScripts: false,
+      },
     });
 
-    await FsUtil.copyAsync(
+    FsUtil.copy(
       path.resolve(electronDistPath, `${npmConfig.description} Setup ${npmConfig.version}.exe`),
-      path.resolve(opt.pkgPath, `dist/electron/${npmConfig.description}-latest.exe`)
+      path.resolve(opt.pkgPath, `dist/electron/${npmConfig.description}-latest.exe`),
     );
   }
-}
+}

package/src/entry/SdCliLocalUpdate.ts

@@ -1,20 +1,20 @@
-import {FsUtil, Logger, PathUtil, SdFsWatcher} from "@simplysm/sd-core-node";
+import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
 import path from "path";
-import {pathToFileURL} from "url";
-import {ISdCliConfig} from "../commons";
+import { pathToFileURL } from "url";
+import { ISdProjectConfig } from "../types/sd-configs.type";
 
 export class SdCliLocalUpdate {
-  public static async runAsync(opt: {
-    confFileRelPath: string;
-    optNames: string[];
-  }): Promise<void> {
+  static async runAsync(opt: { confFileRelPath: string; optNames: string[] }): Promise<void> {
     const logger = Logger.get(["simplysm", "sd-cli", "SdCliLocalUpdate", "runAsync"]);
 
     logger.debug("프로젝트 설정 가져오기...");
-    const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(true, opt.optNames) as ISdCliConfig;
+    const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(
+      true,
+      opt.optNames,
+    ) as ISdProjectConfig;
     if (!projConf.localUpdates) return;
 
-    const updatePathInfos = await this._getUpdatePathInfosAsync(projConf.localUpdates);
+    const updatePathInfos = this.#getUpdatePathInfos(projConf.localUpdates);
     logger.debug("로컬 업데이트 구성", updatePathInfos);
 
     logger.log("로컬 라이브러리 업데이트 시작...");
@@ -25,94 +25,93 @@ export class SdCliLocalUpdate {
       }
 
       // 소스경로에서 대상경로로 파일 복사
-      await FsUtil.copyAsync(updatePathInfo.source, updatePathInfo.target, (src) => {
+      FsUtil.copy(updatePathInfo.source, updatePathInfo.target, (src) => {
         return !src.includes("node_modules") && !src.endsWith("package.json");
       });
     }
     logger.info("로컬 라이브러리 업데이트 완료");
   }
 
-  public static async watchAsync(opt: {
-    confFileRelPath: string;
-    optNames: string[];
-  }): Promise<void> {
+  static async watchAsync(opt: { confFileRelPath: string; optNames: string[] }): Promise<void> {
     const logger = Logger.get(["simplysm", "sd-cli", "SdCliLocalUpdate", "watchAsync"]);
 
     logger.debug("프로젝트 설정 가져오기...");
-    const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(true, opt.optNames) as ISdCliConfig;
+    const projConf = (await import(pathToFileURL(path.resolve(process.cwd(), opt.confFileRelPath)).href)).default(
+      true,
+      opt.optNames,
+    ) as ISdProjectConfig;
     if (!projConf.localUpdates) return;
 
-    const updatePathInfos = await this._getUpdatePathInfosAsync(projConf.localUpdates);
+    const updatePathInfos = this.#getUpdatePathInfos(projConf.localUpdates);
     logger.debug("로컬 업데이트 구성");
 
-    const watchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
+    const watchPaths = updatePathInfos.mapMany((item) => this.#getWatchPaths(item.source)).distinct();
 
     const watcher = SdFsWatcher.watch(watchPaths);
-    watcher.onChange({delay: 1000}, async (changedInfos) => {
-      const changeFilePaths = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
-      if (changeFilePaths.length === 0) return;
+    watcher.onChange({ delay: 1000 }, (changedInfos) => {
+      const changedFileInfos = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event));
+      if (changedFileInfos.length === 0) return;
 
       logger.log("로컬 라이브러리 변경감지...");
-      for (const changedFilePath of changeFilePaths) {
-        if (!FsUtil.exists(changedFilePath)) continue;
 
+      for (const changedFileInfo of changedFileInfos) {
         for (const updatePathInfo of updatePathInfos) {
-          if (!PathUtil.isChildPath(changedFilePath, updatePathInfo.source)) continue;
-
-          const sourceRelPath = path.relative(updatePathInfo.source, changedFilePath);
-          // if (sourceRelPath.includes("node_modules")) continue;
-          // if (sourceRelPath.includes("package.json")) continue;
+          if (!PathUtil.isChildPath(changedFileInfo.path, updatePathInfo.source)) continue;
 
+          const sourceRelPath = path.relative(updatePathInfo.source, changedFileInfo.path);
           const targetFilePath = path.resolve(updatePathInfo.target, sourceRelPath);
 
-          logger.debug(`변경파일감지(복사): ${changedFilePath} => ${targetFilePath}`);
-          await FsUtil.copyAsync(changedFilePath, targetFilePath);
+          if (changedFileInfo.event === "unlink") {
+            logger.debug(`변경파일감지(삭제): ${targetFilePath}`);
+            FsUtil.remove(targetFilePath);
+          } else {
+            logger.debug(`변경파일감지(복사): ${changedFileInfo.path} => ${targetFilePath}`);
+            FsUtil.copy(changedFileInfo.path, targetFilePath);
+          }
         }
       }
 
-      const watchFileSet = new Set(await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source)));
-      watcher.add(watchFileSet);
+      const watchFileSet = new Set(updatePathInfos.mapMany((item) => this.#getWatchPaths(item.source)));
+
+      watcher.replaceWatchPaths(watchFileSet);
 
       logger.info("로컬 라이브러리 복사 완료");
     });
   }
 
-  private static async _getUpdatePathInfosAsync(record: Record<string, string>): Promise<IUpdatePathInfo[]> {
+  static #getUpdatePathInfos(record: Record<string, string>): IUpdatePathInfo[] {
     const result: IUpdatePathInfo[] = [];
     for (const pkgGlobPath of Object.keys(record)) {
       // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기
       const targetPaths = [
-        ...await FsUtil.globAsync(path.resolve(process.cwd(), "node_modules", pkgGlobPath)),
-        ...await FsUtil.globAsync(path.resolve(process.cwd(), "packages", "*", "node_modules", pkgGlobPath))
+        ...FsUtil.glob(path.resolve(process.cwd(), "node_modules", pkgGlobPath)),
+        ...FsUtil.glob(path.resolve(process.cwd(), "packages", "*", "node_modules", pkgGlobPath)),
       ];
 
       result.push(
         ...targetPaths
           .map((targetPath) => {
             // 대상의 명칭 추출
-            const regexpText = pkgGlobPath.replace(/[\\/.*]/g, (item) => (
-              item === "/" ? "[\\\\\\/]"
-                : item === "." ? "\\."
-                  : item === "*" ? "(.*)"
-                    : item
-            ));
+            const regexpText = pkgGlobPath.replace(/[\\/.*]/g, (item) =>
+              item === "/" ? "[\\\\\\/]" : item === "." ? "\\." : item === "*" ? "(.*)" : item,
+            );
             const targetNameMatch = new RegExp(regexpText).exec(targetPath);
             if (!targetNameMatch || typeof targetNameMatch[1] === "undefined") return undefined;
             const targetName = targetNameMatch[1];
 
             // 가져올 소스 경로 추출
             const sourcePath = path.resolve(record[pkgGlobPath].replace(/\*/g, targetName));
-            return {source: sourcePath, target: targetPath};
+            return { source: sourcePath, target: targetPath };
           })
-          .filterExists()
+          .filterExists(),
       );
     }
 
     return result;
   }
 
-  private static async _getWatchPathsAsync(sourcePath: string): Promise<string[]> {
-    return await FsUtil.globAsync(path.resolve(sourcePath, "**"));
+  static #getWatchPaths(sourcePath: string): string[] {
+    return FsUtil.glob(path.resolve(sourcePath, "**"));
   }
 }