@simplysm/sd-cli 12.15.39 → 12.15.41

package/src/entry/SdCliCordova.ts

@@ -6,75 +6,75 @@ import { INpmConfig } from "../types/common-config/INpmConfig";
 
 export class SdCliCordova {
   // 상수 정의
-  #CORDOVA_DIR_NAME = ".cordova";
-  #PLATFORMS_DIR_NAME = "platforms";
-  #WWW_DIR_NAME = "www";
-
-  #PLUGINS_DIR_NAME = "plugins";
-  #PLUGINS_FETCH_FILE = "fetch.json";
-  #ANDROID_SDK_VERSION = "35"; //cordova-android@14
-  #KEYSTORE_FILE_NAME = "android.keystore";
-  #CONFIG_XML_FILE_NAME = "config.xml";
-  #CONFIG_XML_BACKUP_FILE_NAME = "config.xml.bak";
-  #BUILD_JSON_FILE_NAME = "build.json";
-  #ANDROID_SIGNING_PROP_PATH = "platforms/android/release-signing.properties";
-  #ICON_DIR_PATH = "res/icons";
-  #SPLASH_SCREEN_DIR_PATH = "res/screen/android";
-  #SPLASH_SCREEN_XML_FILE = "splashscreen.xml";
-
-  #platforms: string[];
-  #npmConfig: INpmConfig;
+  private readonly _CORDOVA_DIR_NAME = ".cordova";
+  private readonly _PLATFORMS_DIR_NAME = "platforms";
+  private readonly _WWW_DIR_NAME = "www";
+
+  private readonly _PLUGINS_DIR_NAME = "plugins";
+  private readonly _PLUGINS_FETCH_FILE = "fetch.json";
+  private readonly _ANDROID_SDK_VERSION = "35"; //cordova-android@14
+  private readonly _KEYSTORE_FILE_NAME = "android.keystore";
+  private readonly _CONFIG_XML_FILE_NAME = "config.xml";
+  private readonly _CONFIG_XML_BACKUP_FILE_NAME = "config.xml.bak";
+  private readonly _BUILD_JSON_FILE_NAME = "build.json";
+  private readonly _ANDROID_SIGNING_PROP_PATH = "platforms/android/release-signing.properties";
+  private readonly _ICON_DIR_PATH = "res/icons";
+  private readonly _SPLASH_SCREEN_DIR_PATH = "res/screen/android";
+  private readonly _SPLASH_SCREEN_XML_FILE = "splashscreen.xml";
+
+  private readonly _platforms: string[];
+  private readonly _npmConfig: INpmConfig;
 
   constructor(private readonly _opt: { pkgPath: string; config: ISdClientBuilderCordovaConfig }) {
-    this.#platforms = Object.keys(this._opt.config.platform ?? { browser: {} });
-    this.#npmConfig = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
+    this._platforms = Object.keys(this._opt.config.platform ?? { browser: {} });
+    this._npmConfig = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
   }
 
-  static #logger = SdLogger.get(["simplysm", "sd-cli", "SdCliCordova"]);
+  private static readonly _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliCordova"]);
 
-  static async #execAsync(cmd: string, args: string[], cwd: string): Promise<void> {
-    this.#logger.debug(`실행 명령: ${cmd + " " + args.join(" ")}`);
+  private static async _execAsync(cmd: string, args: string[], cwd: string): Promise<void> {
+    this._logger.debug(`실행 명령: ${cmd + " " + args.join(" ")}`);
     const msg = await SdProcess.spawnAsync(cmd, args, { cwd });
-    this.#logger.debug(`실행 결과: ${msg}`);
+    this._logger.debug(`실행 결과: ${msg}`);
   }
 
   async initializeAsync(): Promise<void> {
-    const cordovaPath = path.resolve(this._opt.pkgPath, this.#CORDOVA_DIR_NAME);
+    const cordovaPath = path.resolve(this._opt.pkgPath, this._CORDOVA_DIR_NAME);
 
     // 1. Cordova 프로젝트 초기화
-    await this.#initializeCordovaProjectAsync(cordovaPath);
+    await this._initializeCordovaProjectAsync(cordovaPath);
 
     // 2. 플랫폼 관리
-    await this.#managePlatformsAsync(cordovaPath);
+    await this._managePlatformsAsync(cordovaPath);
 
     // 3. 플러그인 관리
-    await this.#managePluginsAsync(cordovaPath);
+    await this._managePluginsAsync(cordovaPath);
 
     // 4. 안드로이드 서명 설정
-    this.#setupAndroidSign(cordovaPath);
+    this._setupAndroidSign(cordovaPath);
 
     // 5. 빌드 설정 파일 생성
-    this.#createBuildConfig(cordovaPath);
+    this._createBuildConfig(cordovaPath);
 
     // 6. 아이콘 및 스플래시 스크린 설정
-    this.#setupIconAndSplashScreen(cordovaPath);
+    this._setupIconAndSplashScreen(cordovaPath);
 
     // 7. XML 설정 구성
-    this.#configureXml(cordovaPath);
+    this._configureXml(cordovaPath);
 
     // 8. 각 플랫폼 www 준비
-    await SdCliCordova.#execAsync("npx", ["cordova", "prepare"], cordovaPath);
+    await SdCliCordova._execAsync("npx", ["cordova", "prepare"], cordovaPath);
   }
 
   // 1. Cordova 프로젝트 초기화
-  async #initializeCordovaProjectAsync(cordovaPath: string): Promise<void> {
+  private async _initializeCordovaProjectAsync(cordovaPath: string): Promise<void> {
     if (FsUtils.exists(cordovaPath)) {
-      SdCliCordova.#logger.log("이미 생성되어있는 '.cordova'를 사용합니다.");
+      SdCliCordova._logger.log("이미 생성되어있는 '.cordova'를 사용합니다.");
     } else {
       // await SdCliCordova.#execAsync("npx", ["cordova", "telemetry", "on"], this._opt.pkgPath);
 
       // 프로젝트 생성
-      await SdCliCordova.#execAsync(
+      await SdCliCordova._execAsync(
         "npx",
         ["cordova", "create", cordovaPath, this._opt.config.appId, this._opt.config.appName],
         process.cwd(),
@@ -82,30 +82,30 @@ export class SdCliCordova {
     }
 
     // platforms 폴더 혹시 없으면 생성
-    FsUtils.mkdirs(path.resolve(cordovaPath, this.#PLATFORMS_DIR_NAME));
+    FsUtils.mkdirs(path.resolve(cordovaPath, this._PLATFORMS_DIR_NAME));
 
     // www 폴더 혹시 없으면 생성
-    FsUtils.mkdirs(path.resolve(cordovaPath, this.#WWW_DIR_NAME));
+    FsUtils.mkdirs(path.resolve(cordovaPath, this._WWW_DIR_NAME));
   }
 
   // 2. 플랫폼 관리
-  async #managePlatformsAsync(cordovaPath: string): Promise<void> {
-    const alreadyPlatforms = FsUtils.readdir(path.resolve(cordovaPath, this.#PLATFORMS_DIR_NAME));
+  private async _managePlatformsAsync(cordovaPath: string): Promise<void> {
+    const alreadyPlatforms = FsUtils.readdir(path.resolve(cordovaPath, this._PLATFORMS_DIR_NAME));
 
     // 미설치 빌드 플랫폼 신규 생성
-    for (const platform of this.#platforms) {
+    for (const platform of this._platforms) {
       if (alreadyPlatforms.includes(platform)) continue;
 
-      await SdCliCordova.#execAsync("npx", ["cordova", "platform", "add", platform], cordovaPath);
+      await SdCliCordova._execAsync("npx", ["cordova", "platform", "add", platform], cordovaPath);
     }
   }
 
   // 3. 플러그인 관리
-  async #managePluginsAsync(cordovaPath: string): Promise<void> {
+  private async _managePluginsAsync(cordovaPath: string): Promise<void> {
     const pluginsFetchPath = path.resolve(
       cordovaPath,
-      this.#PLUGINS_DIR_NAME,
-      this.#PLUGINS_FETCH_FILE,
+      this._PLUGINS_DIR_NAME,
+      this._PLUGINS_FETCH_FILE,
     );
     const pluginsFetch = FsUtils.exists(pluginsFetchPath) ? FsUtils.readJson(pluginsFetchPath) : {};
 
@@ -122,11 +122,11 @@ export class SdCliCordova {
     const usePlugins = (this._opt.config.plugins ?? []).distinct();
 
     // 사용하지 않는 플러그인 제거 및 새 플러그인 설치 - 의존성 때문에 순차 처리
-    await this.#removeUnusedPluginsAsync(cordovaPath, alreadyPlugins, usePlugins);
-    await this.#installNewPluginsAsync(cordovaPath, alreadyPlugins, usePlugins);
+    await this._removeUnusedPluginsAsync(cordovaPath, alreadyPlugins, usePlugins);
+    await this._installNewPluginsAsync(cordovaPath, alreadyPlugins, usePlugins);
   }
 
-  async #removeUnusedPluginsAsync(
+  private async _removeUnusedPluginsAsync(
     cordovaPath: string,
     alreadyPlugins: Array<{ name: string; id: string; dependencies?: string[] }>,
     usePlugins: string[],
@@ -134,7 +134,7 @@ export class SdCliCordova {
     for (const alreadyPlugin of alreadyPlugins) {
       if (!usePlugins.includes(alreadyPlugin.id) && !usePlugins.includes(alreadyPlugin.name)) {
         try {
-          await SdCliCordova.#execAsync(
+          await SdCliCordova._execAsync(
             "npx",
             ["cordova", "plugin", "remove", alreadyPlugin.name],
             cordovaPath,
@@ -150,7 +150,7 @@ export class SdCliCordova {
     }
   }
 
-  async #installNewPluginsAsync(
+  private async _installNewPluginsAsync(
     cordovaPath: string,
     alreadyPlugins: Array<{ name: string; id: string; dependencies?: string[] }>,
     usePlugins: string[],
@@ -162,15 +162,15 @@ export class SdCliCordova {
       );
 
       if (!isPluginAlreadyInstalled) {
-        await SdCliCordova.#execAsync("npx", ["cordova", "plugin", "add", usePlugin], cordovaPath);
+        await SdCliCordova._execAsync("npx", ["cordova", "plugin", "add", usePlugin], cordovaPath);
       }
     }
   }
 
   // 4. 안드로이드 서명 설정
-  #setupAndroidSign(cordovaPath: string): void {
-    const keystorePath = path.resolve(cordovaPath, this.#KEYSTORE_FILE_NAME);
-    const signingPropsPath = path.resolve(cordovaPath, this.#ANDROID_SIGNING_PROP_PATH);
+  private _setupAndroidSign(cordovaPath: string): void {
+    const keystorePath = path.resolve(cordovaPath, this._KEYSTORE_FILE_NAME);
+    const signingPropsPath = path.resolve(cordovaPath, this._ANDROID_SIGNING_PROP_PATH);
 
     if (this._opt.config.platform?.android?.sign) {
       FsUtils.copy(
@@ -185,9 +185,9 @@ export class SdCliCordova {
   }
 
   // 5. 빌드 설정 파일 생성
-  #createBuildConfig(cordovaPath: string): void {
-    const buildJsonPath = path.resolve(cordovaPath, this.#BUILD_JSON_FILE_NAME);
-    const keystorePath = path.resolve(cordovaPath, this.#KEYSTORE_FILE_NAME);
+  private _createBuildConfig(cordovaPath: string): void {
+    const buildJsonPath = path.resolve(cordovaPath, this._BUILD_JSON_FILE_NAME);
+    const keystorePath = path.resolve(cordovaPath, this._KEYSTORE_FILE_NAME);
 
     const androidConfig = this._opt.config.platform?.android
       ? {
@@ -212,10 +212,10 @@ export class SdCliCordova {
   }
 
   // 6. 아이콘 및 스플래시 스크린 설정
-  #setupIconAndSplashScreen(cordovaPath: string): void {
-    const iconDirPath = path.resolve(cordovaPath, this.#ICON_DIR_PATH);
-    const splashScreenPath = path.resolve(cordovaPath, this.#SPLASH_SCREEN_DIR_PATH);
-    const splashScreenXmlPath = path.resolve(splashScreenPath, this.#SPLASH_SCREEN_XML_FILE);
+  private _setupIconAndSplashScreen(cordovaPath: string): void {
+    const iconDirPath = path.resolve(cordovaPath, this._ICON_DIR_PATH);
+    const splashScreenPath = path.resolve(cordovaPath, this._SPLASH_SCREEN_DIR_PATH);
+    const splashScreenXmlPath = path.resolve(splashScreenPath, this._SPLASH_SCREEN_XML_FILE);
 
     // ICON 파일 복사
     if (this._opt.config.icon != null) {
@@ -247,10 +247,10 @@ export class SdCliCordova {
   }
 
   // 7. XML 설정 구성
-  #configureXml(cordovaPath: string) {
+  private _configureXml(cordovaPath: string) {
     // CONFIG: 초기값 백업
-    const configFilePath = path.resolve(cordovaPath, this.#CONFIG_XML_FILE_NAME);
-    const configBackFilePath = path.resolve(cordovaPath, this.#CONFIG_XML_BACKUP_FILE_NAME);
+    const configFilePath = path.resolve(cordovaPath, this._CONFIG_XML_FILE_NAME);
+    const configBackFilePath = path.resolve(cordovaPath, this._CONFIG_XML_BACKUP_FILE_NAME);
 
     if (!FsUtils.exists(configBackFilePath)) {
       FsUtils.copy(configFilePath, configBackFilePath);
@@ -261,11 +261,11 @@ export class SdCliCordova {
     const configXml = XmlConvert.parse(configFileContent);
 
     // CONFIG: 기본 설정
-    this.#configureBasicXmlSettings(configXml);
+    this._configureBasicXmlSettings(configXml);
 
     // CONFIG: 안드로이드 설정
     if (this._opt.config.platform?.android) {
-      this.#configureAndroidXmlSettings(configXml);
+      this._configureAndroidXmlSettings(configXml);
     }
 
     // CONFIG: 파일 새로 쓰기
@@ -275,16 +275,16 @@ export class SdCliCordova {
     FsUtils.writeFile(configFilePath, configResultContent);
   }
 
-  #configureBasicXmlSettings(configXml: any): void {
+  private _configureBasicXmlSettings(configXml: any): void {
     // 버전 설정
-    configXml.widget.$.version = this.#npmConfig.version;
+    configXml.widget.$.version = this._npmConfig.version;
 
     // ICON 설정
     if (this._opt.config.icon != null) {
       configXml.widget.icon = [
         {
           $: {
-            src: `${this.#ICON_DIR_PATH}/${path.basename(this._opt.config.icon)}`,
+            src: `${this._ICON_DIR_PATH}/${path.basename(this._opt.config.icon)}`,
           },
         },
       ];
@@ -298,7 +298,7 @@ export class SdCliCordova {
     configXml.widget.preference = [{ $: { name: "MixedContentMode", value: "1" } }];
   }
 
-  #configureAndroidXmlSettings(configXml: any) {
+  private _configureAndroidXmlSettings(configXml: any) {
     configXml.widget.$["xmlns:android"] = "http://schemas.android.com/apk/res/android";
     configXml.widget.$["xmlns:tools"] = "http://schemas.android.com/tools";
 
@@ -312,7 +312,7 @@ export class SdCliCordova {
         {
           $: {
             name: "AndroidWindowSplashScreenAnimatedIcon",
-            value: `${this.#SPLASH_SCREEN_DIR_PATH}/${this.#SPLASH_SCREEN_XML_FILE}`,
+            value: `${this._SPLASH_SCREEN_DIR_PATH}/${this._SPLASH_SCREEN_XML_FILE}`,
           },
         },
       ],
@@ -379,7 +379,7 @@ export class SdCliCordova {
           {
             $: {
               name: "android-compileSdkVersion",
-              value: this.#ANDROID_SDK_VERSION,
+              value: this._ANDROID_SDK_VERSION,
             },
           },
         ],
@@ -416,15 +416,15 @@ export class SdCliCordova {
   }
 
   async buildAsync(outPath: string): Promise<void> {
-    const cordovaPath = path.resolve(this._opt.pkgPath, this.#CORDOVA_DIR_NAME);
+    const cordovaPath = path.resolve(this._opt.pkgPath, this._CORDOVA_DIR_NAME);
 
     // 빌드 실행 - 병렬 처리로 개선
     const buildType = this._opt.config.debug ? "debug" : "release";
 
     // 모든 플랫폼 동시에 빌드
     await Promise.all(
-      this.#platforms.map((platform) =>
-        SdCliCordova.#execAsync(
+      this._platforms.map((platform) =>
+        SdCliCordova._execAsync(
           "npx",
           ["cordova", "build", platform, `--${buildType}`],
           cordovaPath,
@@ -435,12 +435,12 @@ export class SdCliCordova {
     // 결과물 복사 및 ZIP 파일 생성 - 병렬 처리
     await Promise.all(
       Object.keys(this._opt.config.platform ?? {}).map(async (platform) => {
-        await this.#processBuildOutputAsync(cordovaPath, outPath, platform, buildType);
+        await this._processBuildOutputAsync(cordovaPath, outPath, platform, buildType);
       }),
     );
   }
 
-  async #processBuildOutputAsync(
+  private async _processBuildOutputAsync(
     cordovaPath: string,
     outPath: string,
     platform: string,
@@ -450,14 +450,14 @@ export class SdCliCordova {
 
     // 결과물 복사: ANDROID
     if (platform === "android") {
-      this.#copyAndroidBuildOutput(cordovaPath, targetOutPath, buildType);
+      this._copyAndroidBuildOutput(cordovaPath, targetOutPath, buildType);
     }
 
     // 자동업데이트를 위한 파일 생성
-    await this.#createUpdateZipAsync(cordovaPath, outPath, platform);
+    await this._createUpdateZipAsync(cordovaPath, outPath, platform);
   }
 
-  #copyAndroidBuildOutput(cordovaPath: string, targetOutPath: string, buildType: string) {
+  private _copyAndroidBuildOutput(cordovaPath: string, targetOutPath: string, buildType: string) {
     const apkFileName = this._opt.config.platform!.android!.sign
       ? `app-${buildType}.apk`
       : `app-${buildType}-unsigned.apk`;
@@ -475,37 +475,37 @@ export class SdCliCordova {
     // 업데이트파일
     FsUtils.copy(
       path.resolve(cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName),
-      path.resolve(targetOutPath, "updates", `${this.#npmConfig.version}.apk`),
+      path.resolve(targetOutPath, "updates", `${this._npmConfig.version}.apk`),
     );
   }
 
-  async #createUpdateZipAsync(
+  private async _createUpdateZipAsync(
     cordovaPath: string,
     outPath: string,
     platform: string,
   ): Promise<void> {
     const zip = new SdZip();
-    const wwwPath = path.resolve(cordovaPath, this.#WWW_DIR_NAME);
+    const wwwPath = path.resolve(cordovaPath, this._WWW_DIR_NAME);
     const platformWwwPath = path.resolve(
       cordovaPath,
-      this.#PLATFORMS_DIR_NAME,
+      this._PLATFORMS_DIR_NAME,
       platform,
       "platform_www",
     );
 
-    this.#addFilesToZip(zip, wwwPath);
-    this.#addFilesToZip(zip, platformWwwPath);
+    this._addFilesToZip(zip, wwwPath);
+    this._addFilesToZip(zip, platformWwwPath);
 
     // ZIP 파일 생성
     const updateDirPath = path.resolve(outPath, platform, "updates");
     FsUtils.mkdirs(updateDirPath);
     FsUtils.writeFile(
-      path.resolve(updateDirPath, this.#npmConfig.version + ".zip"),
+      path.resolve(updateDirPath, this._npmConfig.version + ".zip"),
       await zip.compressAsync(),
     );
   }
 
-  #addFilesToZip(zip: SdZip, dirPath: string) {
+  private _addFilesToZip(zip: SdZip, dirPath: string) {
     const files = FsUtils.glob(path.resolve(dirPath, "**/*"), { nodir: true });
     for (const file of files) {
       const relFilePath = path.relative(dirPath, file);
@@ -544,6 +544,6 @@ export class SdCliCordova {
       );
     }
 
-    await this.#execAsync("npx", ["cordova", "run", opt.platform, "--device"], cordovaPath);
+    await this._execAsync("npx", ["cordova", "run", opt.platform, "--device"], cordovaPath);
   }
 }

package/src/entry/SdCliElectron.ts

@@ -8,42 +8,42 @@ import electronBuilder from "electron-builder";
 import { INpmConfig } from "../types/common-config/INpmConfig";
 
 export class SdCliElectron {
-  static #logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron"]);
+  private static readonly _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron"]);
 
   static async runAsync(opt: { package: string; config: string; options?: string[] }) {
-    this.#logger.log("설정 가져오기...");
-    const { pkgPath, electronPath, electronConfig } = await this.#loadDevConfig(opt);
+    this._logger.log("설정 가져오기...");
+    const { pkgPath, electronPath, electronConfig } = await this._loadDevConfig(opt);
 
-    this.#logger.log("준비...");
-    await this.#prepareAsync({ pkgPath, electronPath, electronConfig });
+    this._logger.log("준비...");
+    await this._prepareAsync({ pkgPath, electronPath, electronConfig });
 
-    this.#logger.log("실행...");
+    this._logger.log("실행...");
     await SdProcess.spawnAsync("npx", ["electron", "."], { cwd: electronPath, showMessage: true });
   }
 
   static async buildForDevAsync(opt: { package: string; config: string; options?: string[] }) {
-    this.#logger.log("설정 가져오기...");
-    const { pkgPath, electronPath, electronConfig } = await this.#loadDevConfig(opt);
+    this._logger.log("설정 가져오기...");
+    const { pkgPath, electronPath, electronConfig } = await this._loadDevConfig(opt);
 
-    this.#logger.log("준비...");
-    const { npmConfig } = await this.#prepareAsync({ pkgPath, electronPath, electronConfig });
+    this._logger.log("준비...");
+    const { npmConfig } = await this._prepareAsync({ pkgPath, electronPath, electronConfig });
 
-    this.#logger.log("빌드...");
+    this._logger.log("빌드...");
     const electronDistPath = path.resolve(pkgPath, ".electron/dist");
-    await this.#buildAsync({ pkgPath, electronPath, electronDistPath, npmConfig, electronConfig });
+    await this._buildAsync({ pkgPath, electronPath, electronDistPath, npmConfig, electronConfig });
   }
 
   static async buildAsync(opt: {
     pkgPath: string;
     electronConfig: ISdClientBuilderElectronConfig;
   }) {
-    this.#logger.log("준비...");
+    this._logger.log("준비...");
     const electronPath = path.resolve(opt.pkgPath, ".electron/src");
-    const { npmConfig } = await this.#prepareAsync({ ...opt, electronPath });
+    const { npmConfig } = await this._prepareAsync({ ...opt, electronPath });
 
-    this.#logger.log("빌드...");
+    this._logger.log("빌드...");
     const electronDistPath = path.resolve(opt.pkgPath, ".electron/dist");
-    await this.#buildAsync({
+    await this._buildAsync({
       pkgPath: opt.pkgPath,
       electronPath,
       electronDistPath,
@@ -52,7 +52,7 @@ export class SdCliElectron {
     });
   }
 
-  static async #loadDevConfig(opt: { package: string; config: string; options?: string[] }) {
+  private static async _loadDevConfig(opt: { package: string; config: string; options?: string[] }) {
     const projConf = await loadProjConfAsync(process.cwd(), true, opt);
     const pkgConf = projConf.packages[opt.package];
     if (pkgConf?.type !== "client" || pkgConf.builder?.electron === undefined) {
@@ -68,7 +68,7 @@ export class SdCliElectron {
     };
   }
 
-  static async #prepareAsync(opt: {
+  private static async _prepareAsync(opt: {
     pkgPath: string;
     electronPath: string;
     electronConfig: ISdClientBuilderElectronConfig;
@@ -105,14 +105,14 @@ export class SdCliElectron {
     return { npmConfig };
   }
 
-  static async #buildAsync(opt: {
+  private static async _buildAsync(opt: {
     pkgPath: string;
     electronPath: string;
     electronDistPath: string;
     npmConfig: INpmConfig;
     electronConfig: ISdClientBuilderElectronConfig;
   }) {
-    if (!this.#canCreateSymlink()) {
+    if (!this._canCreateSymlink()) {
       throw new Error(
         "'Electron 빌드'를 위해서는 'Symlink 생성' 권한이 필요합니다. 윈도우의 개발자모드를 활성화하세요.",
       );
@@ -170,7 +170,7 @@ export class SdCliElectron {
     );
   }
 
-  static #canCreateSymlink() {
+  private static _canCreateSymlink() {
     const tmpDir = os.tmpdir();
     const testTarget = path.join(tmpDir, "symlink-test-target.txt");
     const testLink = path.join(tmpDir, "symlink-test-link.txt");

package/src/entry/SdCliLocalUpdate.ts

@@ -10,7 +10,7 @@ export class SdCliLocalUpdate {
     const projConf = await loadProjConfAsync(process.cwd(), true, opt);
     if (!projConf.localUpdates) return;
 
-    const updatePathInfos = this.#getUpdatePathInfos(projConf.localUpdates);
+    const updatePathInfos = this._getUpdatePathInfos(projConf.localUpdates);
     logger.debug("로컬 업데이트 구성");
 
     logger.log("로컬 라이브러리 업데이트 시작...");
@@ -35,7 +35,7 @@ export class SdCliLocalUpdate {
     const projConf = await loadProjConfAsync(process.cwd(), true, opt);
     if (!projConf.localUpdates) return;
 
-    const updatePathInfos = this.#getUpdatePathInfos(projConf.localUpdates);
+    const updatePathInfos = this._getUpdatePathInfos(projConf.localUpdates);
     logger.debug("로컬 업데이트 구성");
 
     const watcher = await SdFsWatcher.watchAsync(updatePathInfos.map((item) => item.source));
@@ -68,7 +68,7 @@ export class SdCliLocalUpdate {
     });
   }
 
-  static #getUpdatePathInfos(record: Record<string, string>): IUpdatePathInfo[] {
+  private static _getUpdatePathInfos(record: Record<string, string>): IUpdatePathInfo[] {
     const result: IUpdatePathInfo[] = [];
     for (const pkgGlobPath of Object.keys(record)) {
       // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기

package/src/entry/SdCliProject.ts

@@ -68,7 +68,7 @@ export class SdCliProject {
         logger.debug("빌드를 시작합니다...");
       },
       onComplete: (messages) => {
-        this.#logging(messages, logger);
+        this._logging(messages, logger);
       },
     });
   }
@@ -111,7 +111,7 @@ export class SdCliProject {
     }
 
     logger.debug("프로젝트 및 패키지 버전 설정...");
-    this.#upgradeVersion(projNpmConf, allPkgPaths);
+    this._upgradeVersion(projNpmConf, allPkgPaths);
 
     logger.debug("빌드 프로세스 시작...");
     const messages = await SdProjectBuildRunner.buildAsync({
@@ -119,7 +119,7 @@ export class SdCliProject {
       pkgPaths,
       projConf,
     });
-    this.#logging(messages, logger);
+    this._logging(messages, logger);
   }
 
   static async publishAsync(opt: {
@@ -138,7 +138,7 @@ export class SdCliProject {
 
     if (opt.noBuild) {
       logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
-      await this.#waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
+      await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
     } else {
       // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
       if (FsUtils.exists(path.resolve(process.cwd(), ".git"))) {
@@ -184,7 +184,7 @@ export class SdCliProject {
 
     if (!opt.noBuild) {
       logger.debug("프로젝트 및 패키지 버전 설정...");
-      this.#upgradeVersion(projNpmConf, allPkgPaths);
+      this._upgradeVersion(projNpmConf, allPkgPaths);
 
       // 빌드
       try {
@@ -195,7 +195,7 @@ export class SdCliProject {
           projConf,
         });
 
-        this.#logging(messages, logger);
+        this._logging(messages, logger);
       } catch (err) {
         await SdProcess.spawnAsync("git", ["checkout", "."]);
         throw err;
@@ -227,7 +227,7 @@ export class SdCliProject {
       if (pkgConf?.publish == null) return;
 
       logger.debug(`[${pkgName}] 배포 시작...`);
-      await this.#publishPkgAsync(pkgPath, pkgConf.publish);
+      await this._publishPkgAsync(pkgPath, pkgConf.publish);
       logger.debug(`[${pkgName}] 배포 완료`);
     });
 
@@ -260,7 +260,7 @@ export class SdCliProject {
     logger.info(`모든 배포가 완료되었습니다. (v${projNpmConf.version})`);
   }
 
-  static async #publishPkgAsync(
+  private static async _publishPkgAsync(
     pkgPath: string,
     pkgPubConf: TSdPackageConfig["publish"],
   ): Promise<void> {
@@ -314,7 +314,7 @@ export class SdCliProject {
     }
   }
 
-  static async #waitSecMessageAsync(msg: string, sec: number): Promise<void> {
+  private static async _waitSecMessageAsync(msg: string, sec: number): Promise<void> {
     for (let i = sec; i > 0; i--) {
       if (i !== sec) {
         process.stdout.cursorTo(0);
@@ -327,7 +327,7 @@ export class SdCliProject {
     process.stdout.clearLine(0);
   }
 
-  static #upgradeVersion(projNpmConf: INpmConfig, allPkgPaths: string[]) {
+  private static _upgradeVersion(projNpmConf: INpmConfig, allPkgPaths: string[]) {
     // 작업공간 package.json 버전 설정
     const newVersion = semver.inc(projNpmConf.version, "patch")!;
     projNpmConf.version = newVersion;
@@ -379,7 +379,7 @@ export class SdCliProject {
     }
   }
 
-  static #logging(buildResults: ISdBuildMessage[], logger: SdLogger): void {
+  private static _logging(buildResults: ISdBuildMessage[], logger: SdLogger): void {
     const messageMap = buildResults.toSetMap(
       (item) => item.severity,
       (item) => SdCliConvertMessageUtils.getBuildMessageString(item),