@simplysm/sd-cli 12.15.39 → 12.15.40

package/dist/entry/SdCliCordova.d.ts

@@ -1,13 +1,45 @@
 import { ISdClientBuilderCordovaConfig } from "../types/config/ISdProjectConfig";
 export declare class SdCliCordova {
-    #private;
     private readonly _opt;
+    private readonly _CORDOVA_DIR_NAME;
+    private readonly _PLATFORMS_DIR_NAME;
+    private readonly _WWW_DIR_NAME;
+    private readonly _PLUGINS_DIR_NAME;
+    private readonly _PLUGINS_FETCH_FILE;
+    private readonly _ANDROID_SDK_VERSION;
+    private readonly _KEYSTORE_FILE_NAME;
+    private readonly _CONFIG_XML_FILE_NAME;
+    private readonly _CONFIG_XML_BACKUP_FILE_NAME;
+    private readonly _BUILD_JSON_FILE_NAME;
+    private readonly _ANDROID_SIGNING_PROP_PATH;
+    private readonly _ICON_DIR_PATH;
+    private readonly _SPLASH_SCREEN_DIR_PATH;
+    private readonly _SPLASH_SCREEN_XML_FILE;
+    private readonly _platforms;
+    private readonly _npmConfig;
     constructor(_opt: {
         pkgPath: string;
         config: ISdClientBuilderCordovaConfig;
     });
+    private static readonly _logger;
+    private static _execAsync;
     initializeAsync(): Promise<void>;
+    private _initializeCordovaProjectAsync;
+    private _managePlatformsAsync;
+    private _managePluginsAsync;
+    private _removeUnusedPluginsAsync;
+    private _installNewPluginsAsync;
+    private _setupAndroidSign;
+    private _createBuildConfig;
+    private _setupIconAndSplashScreen;
+    private _configureXml;
+    private _configureBasicXmlSettings;
+    private _configureAndroidXmlSettings;
     buildAsync(outPath: string): Promise<void>;
+    private _processBuildOutputAsync;
+    private _copyAndroidBuildOutput;
+    private _createUpdateZipAsync;
+    private _addFilesToZip;
     static runWebviewOnDeviceAsync(opt: {
         platform: string;
         package: string;

package/dist/entry/SdCliCordova.js

@@ -1,83 +1,80 @@
-var _a;
 import * as path from "path";
 import { FsUtils, PathUtils, SdLogger, SdProcess } from "@simplysm/sd-core-node";
 import { SdZip, XmlConvert } from "@simplysm/sd-core-common";
 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;
-    #npmConfig;
     constructor(_opt) {
         this._opt = _opt;
-        this.#platforms = Object.keys(this._opt.config.platform ?? { browser: {} });
-        this.#npmConfig = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
+        // 상수 정의
+        this._CORDOVA_DIR_NAME = ".cordova";
+        this._PLATFORMS_DIR_NAME = "platforms";
+        this._WWW_DIR_NAME = "www";
+        this._PLUGINS_DIR_NAME = "plugins";
+        this._PLUGINS_FETCH_FILE = "fetch.json";
+        this._ANDROID_SDK_VERSION = "35"; //cordova-android@14
+        this._KEYSTORE_FILE_NAME = "android.keystore";
+        this._CONFIG_XML_FILE_NAME = "config.xml";
+        this._CONFIG_XML_BACKUP_FILE_NAME = "config.xml.bak";
+        this._BUILD_JSON_FILE_NAME = "build.json";
+        this._ANDROID_SIGNING_PROP_PATH = "platforms/android/release-signing.properties";
+        this._ICON_DIR_PATH = "res/icons";
+        this._SPLASH_SCREEN_DIR_PATH = "res/screen/android";
+        this._SPLASH_SCREEN_XML_FILE = "splashscreen.xml";
+        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"]);
-    static async #execAsync(cmd, args, cwd) {
-        this.#logger.debug(`실행 명령: ${cmd + " " + args.join(" ")}`);
+    static { this._logger = SdLogger.get(["simplysm", "sd-cli", "SdCliCordova"]); }
+    static async _execAsync(cmd, args, cwd) {
+        this._logger.debug(`실행 명령: ${cmd + " " + args.join(" ")}`);
         const msg = await SdProcess.spawnAsync(cmd, args, { cwd });
-        this.#logger.debug(`실행 결과: ${msg}`);
+        this._logger.debug(`실행 결과: ${msg}`);
     }
     async initializeAsync() {
-        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 _a.#execAsync("npx", ["cordova", "prepare"], cordovaPath);
+        await SdCliCordova._execAsync("npx", ["cordova", "prepare"], cordovaPath);
     }
     // 1. Cordova 프로젝트 초기화
-    async #initializeCordovaProjectAsync(cordovaPath) {
+    async _initializeCordovaProjectAsync(cordovaPath) {
         if (FsUtils.exists(cordovaPath)) {
-            _a.#logger.log("이미 생성되어있는 '.cordova'를 사용합니다.");
+            SdCliCordova._logger.log("이미 생성되어있는 '.cordova'를 사용합니다.");
         }
         else {
             // await SdCliCordova.#execAsync("npx", ["cordova", "telemetry", "on"], this._opt.pkgPath);
             // 프로젝트 생성
-            await _a.#execAsync("npx", ["cordova", "create", cordovaPath, this._opt.config.appId, this._opt.config.appName], process.cwd());
+            await SdCliCordova._execAsync("npx", ["cordova", "create", cordovaPath, this._opt.config.appId, this._opt.config.appName], process.cwd());
         }
         // 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) {
-        const alreadyPlatforms = FsUtils.readdir(path.resolve(cordovaPath, this.#PLATFORMS_DIR_NAME));
+    async _managePlatformsAsync(cordovaPath) {
+        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 _a.#execAsync("npx", ["cordova", "platform", "add", platform], cordovaPath);
+            await SdCliCordova._execAsync("npx", ["cordova", "platform", "add", platform], cordovaPath);
         }
     }
     // 3. 플러그인 관리
-    async #managePluginsAsync(cordovaPath) {
-        const pluginsFetchPath = path.resolve(cordovaPath, this.#PLUGINS_DIR_NAME, this.#PLUGINS_FETCH_FILE);
+    async _managePluginsAsync(cordovaPath) {
+        const pluginsFetchPath = path.resolve(cordovaPath, this._PLUGINS_DIR_NAME, this._PLUGINS_FETCH_FILE);
         const pluginsFetch = FsUtils.exists(pluginsFetchPath) ? FsUtils.readJson(pluginsFetchPath) : {};
         const alreadyPlugins = Object.keys(pluginsFetch).map((key) => ({
             name: key,
@@ -86,14 +83,14 @@ 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(cordovaPath, alreadyPlugins, usePlugins) {
+    async _removeUnusedPluginsAsync(cordovaPath, alreadyPlugins, usePlugins) {
         for (const alreadyPlugin of alreadyPlugins) {
             if (!usePlugins.includes(alreadyPlugin.id) && !usePlugins.includes(alreadyPlugin.name)) {
                 try {
-                    await _a.#execAsync("npx", ["cordova", "plugin", "remove", alreadyPlugin.name], cordovaPath);
+                    await SdCliCordova._execAsync("npx", ["cordova", "plugin", "remove", alreadyPlugin.name], cordovaPath);
                 }
                 catch (err) {
                     // 의존성으로 인한 skip 메시지는 무시 (로그 생략)
@@ -105,19 +102,19 @@ export class SdCliCordova {
             }
         }
     }
-    async #installNewPluginsAsync(cordovaPath, alreadyPlugins, usePlugins) {
+    async _installNewPluginsAsync(cordovaPath, alreadyPlugins, usePlugins) {
         // 병렬로 플러그인을 설치하면 충돌이 발생할 수 있으므로 순차 처리
         for (const usePlugin of usePlugins) {
             const isPluginAlreadyInstalled = alreadyPlugins.some((plugin) => usePlugin === plugin.id || usePlugin === plugin.name);
             if (!isPluginAlreadyInstalled) {
-                await _a.#execAsync("npx", ["cordova", "plugin", "add", usePlugin], cordovaPath);
+                await SdCliCordova._execAsync("npx", ["cordova", "plugin", "add", usePlugin], cordovaPath);
             }
         }
     }
     // 4. 안드로이드 서명 설정
-    #setupAndroidSign(cordovaPath) {
-        const keystorePath = path.resolve(cordovaPath, this.#KEYSTORE_FILE_NAME);
-        const signingPropsPath = path.resolve(cordovaPath, this.#ANDROID_SIGNING_PROP_PATH);
+    _setupAndroidSign(cordovaPath) {
+        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(path.resolve(this._opt.pkgPath, this._opt.config.platform.android.sign.keystore), keystorePath);
         }
@@ -128,9 +125,9 @@ export class SdCliCordova {
         }
     }
     // 5. 빌드 설정 파일 생성
-    #createBuildConfig(cordovaPath) {
-        const buildJsonPath = path.resolve(cordovaPath, this.#BUILD_JSON_FILE_NAME);
-        const keystorePath = path.resolve(cordovaPath, this.#KEYSTORE_FILE_NAME);
+    _createBuildConfig(cordovaPath) {
+        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
             ? {
                 android: {
@@ -152,10 +149,10 @@ export class SdCliCordova {
         FsUtils.writeJson(buildJsonPath, androidConfig);
     }
     // 6. 아이콘 및 스플래시 스크린 설정
-    #setupIconAndSplashScreen(cordovaPath) {
-        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);
+    _setupIconAndSplashScreen(cordovaPath) {
+        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) {
             FsUtils.mkdirs(iconDirPath);
@@ -179,10 +176,10 @@ export class SdCliCordova {
         }
     }
     // 7. XML 설정 구성
-    #configureXml(cordovaPath) {
+    _configureXml(cordovaPath) {
         // 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);
         }
@@ -190,10 +187,10 @@ export class SdCliCordova {
         const configFileContent = FsUtils.readFile(configBackFilePath);
         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: 파일 새로 쓰기
         const configResultContent = XmlConvert.stringify(configXml, {
@@ -201,15 +198,15 @@ export class SdCliCordova {
         });
         FsUtils.writeFile(configFilePath, configResultContent);
     }
-    #configureBasicXmlSettings(configXml) {
+    _configureBasicXmlSettings(configXml) {
         // 버전 설정
-        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)}`,
                     },
                 },
             ];
@@ -221,7 +218,7 @@ export class SdCliCordova {
         configXml.widget["allow-intent"] = [{ $: { href: "*" } }];
         configXml.widget.preference = [{ $: { name: "MixedContentMode", value: "1" } }];
     }
-    #configureAndroidXmlSettings(configXml) {
+    _configureAndroidXmlSettings(configXml) {
         configXml.widget.$["xmlns:android"] = "http://schemas.android.com/apk/res/android";
         configXml.widget.$["xmlns:tools"] = "http://schemas.android.com/tools";
         configXml.widget.platform = configXml.widget.platform ?? [];
@@ -233,7 +230,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}`,
                     },
                 },
             ],
@@ -295,7 +292,7 @@ export class SdCliCordova {
                 {
                     $: {
                         name: "android-compileSdkVersion",
-                        value: this.#ANDROID_SDK_VERSION,
+                        value: this._ANDROID_SDK_VERSION,
                     },
                 },
             ]);
@@ -328,26 +325,26 @@ export class SdCliCordova {
         configXml.widget.platform.push(androidPlatform);
     }
     async buildAsync(outPath) {
-        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) => _a.#execAsync("npx", ["cordova", "build", platform, `--${buildType}`], cordovaPath)));
+        await Promise.all(this._platforms.map((platform) => SdCliCordova._execAsync("npx", ["cordova", "build", platform, `--${buildType}`], cordovaPath)));
         // 결과물 복사 및 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(cordovaPath, outPath, platform, buildType) {
+    async _processBuildOutputAsync(cordovaPath, outPath, platform, buildType) {
         const targetOutPath = path.resolve(outPath, platform);
         // 결과물 복사: 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, targetOutPath, buildType) {
+    _copyAndroidBuildOutput(cordovaPath, targetOutPath, buildType) {
         const apkFileName = this._opt.config.platform.android.sign
             ? `app-${buildType}.apk`
             : `app-${buildType}-unsigned.apk`;
@@ -355,20 +352,20 @@ export class SdCliCordova {
         FsUtils.mkdirs(targetOutPath);
         FsUtils.copy(path.resolve(cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName), path.resolve(targetOutPath, latestDistApkFileName));
         // 업데이트파일
-        FsUtils.copy(path.resolve(cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName), path.resolve(targetOutPath, "updates", `${this.#npmConfig.version}.apk`));
+        FsUtils.copy(path.resolve(cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName), path.resolve(targetOutPath, "updates", `${this._npmConfig.version}.apk`));
     }
-    async #createUpdateZipAsync(cordovaPath, outPath, platform) {
+    async _createUpdateZipAsync(cordovaPath, outPath, platform) {
         const zip = new SdZip();
-        const wwwPath = path.resolve(cordovaPath, this.#WWW_DIR_NAME);
-        const platformWwwPath = path.resolve(cordovaPath, this.#PLATFORMS_DIR_NAME, platform, "platform_www");
-        this.#addFilesToZip(zip, wwwPath);
-        this.#addFilesToZip(zip, platformWwwPath);
+        const wwwPath = path.resolve(cordovaPath, this._WWW_DIR_NAME);
+        const platformWwwPath = path.resolve(cordovaPath, this._PLATFORMS_DIR_NAME, platform, "platform_www");
+        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"), await zip.compressAsync());
+        FsUtils.writeFile(path.resolve(updateDirPath, this._npmConfig.version + ".zip"), await zip.compressAsync());
     }
-    #addFilesToZip(zip, dirPath) {
+    _addFilesToZip(zip, dirPath) {
         const files = FsUtils.glob(path.resolve(dirPath, "**/*"), { nodir: true });
         for (const file of files) {
             const relFilePath = path.relative(dirPath, file);
@@ -391,7 +388,6 @@ export class SdCliCordova {
   }, 3000);
 </script>`.trim());
         }
-        await this.#execAsync("npx", ["cordova", "run", opt.platform, "--device"], cordovaPath);
+        await this._execAsync("npx", ["cordova", "run", opt.platform, "--device"], cordovaPath);
     }
 }
-_a = SdCliCordova;

package/dist/entry/SdCliElectron.d.ts

@@ -1,6 +1,6 @@
 import { ISdClientBuilderElectronConfig } from "../types/config/ISdProjectConfig";
 export declare class SdCliElectron {
-    #private;
+    private static readonly _logger;
     static runAsync(opt: {
         package: string;
         config: string;
@@ -15,4 +15,8 @@ export declare class SdCliElectron {
         pkgPath: string;
         electronConfig: ISdClientBuilderElectronConfig;
     }): Promise<void>;
+    private static _loadDevConfig;
+    private static _prepareAsync;
+    private static _buildAsync;
+    private static _canCreateSymlink;
 }

package/dist/entry/SdCliElectron.js

@@ -4,31 +4,31 @@ import os from "os";
 import path from "path";
 import { loadProjConfAsync } from "../utils/loadProjConfAsync";
 export class SdCliElectron {
-    static #logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron"]);
+    static { this._logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron"]); }
     static async runAsync(opt) {
-        this.#logger.log("설정 가져오기...");
-        const { pkgPath, electronPath, electronConfig } = await this.#loadDevConfig(opt);
-        this.#logger.log("준비...");
-        await this.#prepareAsync({ pkgPath, electronPath, electronConfig });
-        this.#logger.log("실행...");
+        this._logger.log("설정 가져오기...");
+        const { pkgPath, electronPath, electronConfig } = await this._loadDevConfig(opt);
+        this._logger.log("준비...");
+        await this._prepareAsync({ pkgPath, electronPath, electronConfig });
+        this._logger.log("실행...");
         await SdProcess.spawnAsync("npx", ["electron", "."], { cwd: electronPath, showMessage: true });
     }
     static async buildForDevAsync(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("빌드...");
+        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 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) {
-        this.#logger.log("준비...");
+        this._logger.log("준비...");
         const electronPath = path.resolve(opt.pkgPath, ".electron/src");
-        const { npmConfig } = await this.#prepareAsync({ ...opt, electronPath });
-        this.#logger.log("빌드...");
+        const { npmConfig } = await this._prepareAsync({ ...opt, electronPath });
+        this._logger.log("빌드...");
         const electronDistPath = path.resolve(opt.pkgPath, ".electron/dist");
-        await this.#buildAsync({
+        await this._buildAsync({
             pkgPath: opt.pkgPath,
             electronPath,
             electronDistPath,
@@ -36,7 +36,7 @@ export class SdCliElectron {
             electronConfig: opt.electronConfig,
         });
     }
-    static async #loadDevConfig(opt) {
+    static async _loadDevConfig(opt) {
         const projConf = await loadProjConfAsync(process.cwd(), true, opt);
         const pkgConf = projConf.packages[opt.package];
         if (pkgConf?.type !== "client" || pkgConf.builder?.electron === undefined) {
@@ -50,7 +50,7 @@ export class SdCliElectron {
             electronConfig: pkgConf.builder.electron,
         };
     }
-    static async #prepareAsync(opt) {
+    static async _prepareAsync(opt) {
         const npmConfig = FsUtils.readJson(path.resolve(opt.pkgPath, `package.json`));
         const reinstallPkgNames = opt.electronConfig.reinstallDependencies ?? [];
         FsUtils.writeJson(path.resolve(opt.electronPath, `package.json`), {
@@ -74,8 +74,8 @@ export class SdCliElectron {
         });
         return { npmConfig };
     }
-    static async #buildAsync(opt) {
-        if (!this.#canCreateSymlink()) {
+    static async _buildAsync(opt) {
+        if (!this._canCreateSymlink()) {
             throw new Error("'Electron 빌드'를 위해서는 'Symlink 생성' 권한이 필요합니다. 윈도우의 개발자모드를 활성화하세요.");
         }
         const electronConfig = {
@@ -105,7 +105,7 @@ export class SdCliElectron {
         FsUtils.copy(path.resolve(opt.electronDistPath, `${opt.npmConfig.description} ${opt.electronConfig.portable ? "" : "Setup "}${opt.npmConfig.version}.exe`), path.resolve(opt.pkgPath, `dist/electron/${opt.npmConfig.description}${opt.electronConfig.portable ? "-portable" : ""}-latest.exe`));
         FsUtils.copy(path.resolve(opt.electronDistPath, `${opt.npmConfig.description} ${opt.electronConfig.portable ? "" : "Setup "}${opt.npmConfig.version}.exe`), path.resolve(opt.pkgPath, `dist/electron/updates/${opt.npmConfig.version}.exe`));
     }
-    static #canCreateSymlink() {
+    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/dist/entry/SdCliLocalUpdate.d.ts

@@ -1,5 +1,4 @@
 export declare class SdCliLocalUpdate {
-    #private;
     static runAsync(opt: {
         config: string;
         options?: string[];
@@ -8,4 +7,5 @@ export declare class SdCliLocalUpdate {
         config: string;
         options?: string[];
     }): Promise<void>;
+    private static _getUpdatePathInfos;
 }

package/dist/entry/SdCliLocalUpdate.js

@@ -8,7 +8,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("로컬 라이브러리 업데이트 시작...");
         await updatePathInfos.parallelAsync(async (updatePathInfo) => {
@@ -29,7 +29,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));
         watcher.onChange({ delay: 300 }, async (changedInfos) => {
@@ -56,7 +56,7 @@ export class SdCliLocalUpdate {
             logger.info("로컬 라이브러리 복사 완료");
         });
     }
-    static #getUpdatePathInfos(record) {
+    static _getUpdatePathInfos(record) {
         const result = [];
         for (const pkgGlobPath of Object.keys(record)) {
             // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기

package/dist/entry/SdCliProject.d.ts

@@ -1,5 +1,4 @@
 export declare class SdCliProject {
-    #private;
     static watchAsync(opt: {
         config: string;
         options?: string[];
@@ -18,4 +17,8 @@ export declare class SdCliProject {
         packages?: string[];
         noBuild?: boolean;
     }): Promise<void>;
+    private static _publishPkgAsync;
+    private static _waitSecMessageAsync;
+    private static _upgradeVersion;
+    private static _logging;
 }

package/dist/entry/SdCliProject.js

@@ -46,7 +46,7 @@ export class SdCliProject {
                 logger.debug("빌드를 시작합니다...");
             },
             onComplete: (messages) => {
-                this.#logging(messages, logger);
+                this._logging(messages, logger);
             },
         });
     }
@@ -73,14 +73,14 @@ export class SdCliProject {
             throw new Error("패키지를 찾을 수 없습니다. (" + notExistsPkgs.join(", ") + ")");
         }
         logger.debug("프로젝트 및 패키지 버전 설정...");
-        this.#upgradeVersion(projNpmConf, allPkgPaths);
+        this._upgradeVersion(projNpmConf, allPkgPaths);
         logger.debug("빌드 프로세스 시작...");
         const messages = await SdProjectBuildRunner.buildAsync({
             allPkgPaths,
             pkgPaths,
             projConf,
         });
-        this.#logging(messages, logger);
+        this._logging(messages, logger);
     }
     static async publishAsync(opt) {
         const logger = SdLogger.get(["simplysm", "sd-cli", "SdCliProject", "publishAsync"]);
@@ -90,7 +90,7 @@ export class SdCliProject {
         const projNpmConf = FsUtils.readJson(path.resolve(process.cwd(), "package.json"));
         if (opt.noBuild) {
             logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
-            await this.#waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
+            await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
         }
         else {
             // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
@@ -132,7 +132,7 @@ export class SdCliProject {
         }
         if (!opt.noBuild) {
             logger.debug("프로젝트 및 패키지 버전 설정...");
-            this.#upgradeVersion(projNpmConf, allPkgPaths);
+            this._upgradeVersion(projNpmConf, allPkgPaths);
             // 빌드
             try {
                 logger.debug("빌드 프로세스 시작...");
@@ -141,7 +141,7 @@ export class SdCliProject {
                     pkgPaths,
                     projConf,
                 });
-                this.#logging(messages, logger);
+                this._logging(messages, logger);
             }
             catch (err) {
                 await SdProcess.spawnAsync("git", ["checkout", "."]);
@@ -171,7 +171,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}] 배포 완료`);
         });
         if (projConf.postPublish && projConf.postPublish.length > 0) {
@@ -200,7 +200,7 @@ export class SdCliProject {
         }
         logger.info(`모든 배포가 완료되었습니다. (v${projNpmConf.version})`);
     }
-    static async #publishPkgAsync(pkgPath, pkgPubConf) {
+    static async _publishPkgAsync(pkgPath, pkgPubConf) {
         if (pkgPubConf === "npm") {
             await SdProcess.spawnAsync("yarn", ["npm", "publish", "--access", "public"], {
                 cwd: pkgPath,
@@ -244,7 +244,7 @@ export class SdCliProject {
             throw new NeverEntryError();
         }
     }
-    static async #waitSecMessageAsync(msg, sec) {
+    static async _waitSecMessageAsync(msg, sec) {
         for (let i = sec; i > 0; i--) {
             if (i !== sec) {
                 process.stdout.cursorTo(0);
@@ -255,7 +255,7 @@ export class SdCliProject {
         process.stdout.cursorTo(0);
         process.stdout.clearLine(0);
     }
-    static #upgradeVersion(projNpmConf, allPkgPaths) {
+    static _upgradeVersion(projNpmConf, allPkgPaths) {
         // 작업공간 package.json 버전 설정
         const newVersion = semver.inc(projNpmConf.version, "patch");
         projNpmConf.version = newVersion;
@@ -296,7 +296,7 @@ export class SdCliProject {
             }
         }
     }
-    static #logging(buildResults, logger) {
+    static _logging(buildResults, logger) {
         const messageMap = buildResults.toSetMap((item) => item.severity, (item) => SdCliConvertMessageUtils.getBuildMessageString(item));
         if (messageMap.has("message")) {
             logger.log(`알림\n${Array.from(messageMap.get("message")).join("\n")}`);