@simplysm/sd-cli 12.11.6 → 12.11.8

package/src/entry/sd-cli-cordova.ts

@@ -6,36 +6,36 @@ import { SdZip, XmlConvert } from "@simplysm/sd-core-common";
 
 export class SdCliCordova {
   // 상수 정의
-  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 = "33";
-  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 _platforms: string[];
-  private _npmConfig: INpmConfig;
-
-  constructor(private _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"));
+  #CORDOVA_DIR_NAME = ".cordova";
+  #PLATFORMS_DIR_NAME = "platforms";
+  #WWW_DIR_NAME = "www";
+
+  #PLUGINS_DIR_NAME = "plugins";
+  #PLUGINS_FETCH_FILE = "fetch.json";
+  #ANDROID_SDK_VERSION = "33";
+  #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;
+
+  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"));
   }
 
-  private static _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliCordova"]);
+  static #logger = SdLogger.get(["simplysm", "sd-cli", "SdCliCordova"]);
 
-  private static async _execAsync(cmd: string, cwd: string): Promise<void> {
-    this._logger.debug(`실행 명령: ${cmd}`);
+  static async #execAsync(cmd: string, cwd: string): Promise<void> {
+    this.#logger.debug(`실행 명령: ${cmd}`);
     const msg = await SdProcess.spawnAsync(cmd, { cwd });
-    this._logger.debug(`실행 결과: ${msg}`);
+    this.#logger.debug(`실행 결과: ${msg}`);
 
     /*try {
       this._logger.debug(`실행 명령: ${cmd}`);
@@ -50,72 +50,72 @@ export class SdCliCordova {
   }
 
   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 프로젝트 초기화
-  private async _initializeCordovaProjectAsync(cordovaPath: string): Promise<void> {
+  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(`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(),
       );
     }
 
     // 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. 플랫폼 관리
-  private async _managePlatformsAsync(cordovaPath: string): Promise<void> {
-    const alreadyPlatforms = FsUtils.readdir(path.resolve(cordovaPath, this.PLATFORMS_DIR_NAME));
+  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. 플러그인 관리
-  private async _managePluginsAsync(cordovaPath: string): Promise<void> {
+  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) : {};
 
@@ -132,11 +132,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);
   }
 
-  private async _removeUnusedPluginsAsync(
+  async #removeUnusedPluginsAsync(
     cordovaPath: string,
     alreadyPlugins: Array<{ name: string; id: string; dependencies?: string[] }>,
     usePlugins: string[],
@@ -144,7 +144,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,
           );
@@ -159,7 +159,7 @@ export class SdCliCordova {
     }
   }
 
-  private async _installNewPluginsAsync(
+  async #installNewPluginsAsync(
     cordovaPath: string,
     alreadyPlugins: Array<{ name: string; id: string; dependencies?: string[] }>,
     usePlugins: string[],
@@ -171,15 +171,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. 안드로이드 서명 설정
-  private _setupAndroidSign(cordovaPath: string): void {
-    const keystorePath = path.resolve(cordovaPath, this.KEYSTORE_FILE_NAME);
-    const signingPropsPath = path.resolve(cordovaPath, this.ANDROID_SIGNING_PROP_PATH);
+  #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(
@@ -194,9 +194,9 @@ export class SdCliCordova {
   }
 
   // 5. 빌드 설정 파일 생성
-  private _createBuildConfig(cordovaPath: string): void {
-    const buildJsonPath = path.resolve(cordovaPath, this.BUILD_JSON_FILE_NAME);
-    const keystorePath = path.resolve(cordovaPath, this.KEYSTORE_FILE_NAME);
+  #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
       ? {
@@ -221,10 +221,10 @@ export class SdCliCordova {
   }
 
   // 6. 아이콘 및 스플래시 스크린 설정
-  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);
+  #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) {
@@ -256,10 +256,10 @@ export class SdCliCordova {
   }
 
   // 7. XML 설정 구성
-  private _configureXml(cordovaPath: string) {
+  #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);
@@ -270,11 +270,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: 파일 새로 쓰기
@@ -284,16 +284,16 @@ export class SdCliCordova {
     FsUtils.writeFile(configFilePath, configResultContent);
   }
 
-  private _configureBasicXmlSettings(configXml: any): void {
+  #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)}`,
           },
         },
       ];
@@ -307,7 +307,7 @@ export class SdCliCordova {
     configXml.widget.preference = [{ $: { name: "MixedContentMode", value: "1" } }];
   }
 
-  private _configureAndroidXmlSettings(configXml: any) {
+  #configureAndroidXmlSettings(configXml: any) {
     configXml.widget.$["xmlns:android"] = "http://schemas.android.com/apk/res/android";
     configXml.widget.$["xmlns:tools"] = "http://schemas.android.com/tools";
 
@@ -321,7 +321,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}`,
           },
         },
       ],
@@ -388,7 +388,7 @@ export class SdCliCordova {
           {
             $: {
               name: "android-compileSdkVersion",
-              value: this.ANDROID_SDK_VERSION,
+              value: this.#ANDROID_SDK_VERSION,
             },
           },
         ],
@@ -425,27 +425,27 @@ 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(`npx cordova build ${platform} --${buildType}`, cordovaPath),
+      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);
       }),
     );
   }
 
-  private async _processBuildOutputAsync(
+  async #processBuildOutputAsync(
     cordovaPath: string,
     outPath: string,
     platform: string,
@@ -455,14 +455,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);
   }
 
-  private _copyAndroidBuildOutput(cordovaPath: string, targetOutPath: string, buildType: string) {
+  #copyAndroidBuildOutput(cordovaPath: string, targetOutPath: string, buildType: string) {
     const apkFileName = this._opt.config.platform!.android!.sign
       ? `app-${buildType}.apk`
       : `app-${buildType}-unsigned.apk`;
@@ -482,37 +482,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`),
     );
   }
 
-  private async _createUpdateZipAsync(
+  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(),
     );
   }
 
-  private _addFilesToZip(zip: SdZip, dirPath: string) {
+  #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);
@@ -551,6 +551,6 @@ export class SdCliCordova {
       );
     }
 
-    await SdCliCordova._execAsync(`npx cordova run ${opt.platform} --device`, cordovaPath);
+    await this.#execAsync(`npx cordova run ${opt.platform} --device`, cordovaPath);
   }
 }

package/src/entry/sd-cli-electron.ts

@@ -8,42 +8,42 @@ import { loadProjConfAsync } from "./utils/loadProjConfAsync";
 import electronBuilder from "electron-builder";
 
 export class SdCliElectron {
-  private static _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron"]);
+  static #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 {
     });
   }
 
-  private static async _loadDevConfig(opt: {
+  static async #loadDevConfig(opt: {
     package: string;
     config: string;
     options?: string[];
@@ -72,7 +72,7 @@ export class SdCliElectron {
     };
   }
 
-  private static async _prepareAsync(opt: {
+  static async #prepareAsync(opt: {
     pkgPath: string;
     electronPath: string;
     electronConfig: ISdClientBuilderElectronConfig;
@@ -109,14 +109,14 @@ export class SdCliElectron {
     return { npmConfig };
   }
 
-  private static async _buildAsync(opt: {
+  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 생성' 권한이 필요합니다. 윈도우의 개발자모드를 활성화하세요.",
       );
@@ -173,7 +173,7 @@ export class SdCliElectron {
     );
   }
 
-  private 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/src/entry/sd-cli-local-update.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("로컬 업데이트 구성", updatePathInfos);
 
     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("로컬 업데이트 구성", updatePathInfos);
 
     const watcher = SdFsWatcher.watch(updatePathInfos.map((item) => item.source));
@@ -68,7 +68,7 @@ export class SdCliLocalUpdate {
     });
   }
 
-  private static _getUpdatePathInfos(record: Record<string, string>): IUpdatePathInfo[] {
+  static #getUpdatePathInfos(record: Record<string, string>): IUpdatePathInfo[] {
     const result: IUpdatePathInfo[] = [];
     for (const pkgGlobPath of Object.keys(record)) {
       // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기

package/src/entry/sd-cli-project.ts

@@ -58,7 +58,7 @@ export class SdCliProject {
         logger.debug("빌드를 시작합니다...");
       })
       .on("complete", (messages) => {
-        this._logging(messages, logger);
+        this.#logging(messages, logger);
       });
 
     await pkgPaths.parallelAsync(async (pkgPath) => {
@@ -97,7 +97,7 @@ export class SdCliProject {
     }
 
     logger.debug("프로젝트 및 패키지 버전 설정...");
-    this._upgradeVersion(projNpmConf, allPkgPaths);
+    this.#upgradeVersion(projNpmConf, allPkgPaths);
 
     logger.debug("빌드 프로세스 시작...");
     const multiBuildRunner = new SdMultiBuildRunner();
@@ -110,7 +110,7 @@ export class SdCliProject {
         workspaces: projNpmConf.workspaces!,
       });
     });
-    this._logging(messages.mapMany(), logger);
+    this.#logging(messages.mapMany(), logger);
   }
 
   static async publishAsync(opt: {
@@ -129,7 +129,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"))) {
@@ -156,7 +156,7 @@ export class SdCliProject {
 
     if (!opt.noBuild) {
       logger.debug("프로젝트 및 패키지 버전 설정...");
-      this._upgradeVersion(projNpmConf, allPkgPaths);
+      this.#upgradeVersion(projNpmConf, allPkgPaths);
 
       // 빌드
       try {
@@ -172,7 +172,7 @@ export class SdCliProject {
           });
         });
 
-        this._logging(messages.mapMany(), logger);
+        this.#logging(messages.mapMany(), logger);
       } catch (err) {
         await SdProcess.spawnAsync("git checkout .");
         throw err;
@@ -200,7 +200,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}] 배포 완료`);
     });
 
@@ -229,7 +229,7 @@ export class SdCliProject {
     logger.info(`모든 배포가 완료되었습니다. (v${projNpmConf.version})`);
   }
 
-  private static async _publishPkgAsync(
+  static async #publishPkgAsync(
     pkgPath: string,
     pkgPubConf: TSdPackageConfig["publish"],
   ): Promise<void> {
@@ -281,7 +281,7 @@ export class SdCliProject {
     }
   }
 
-  private static async _waitSecMessageAsync(msg: string, sec: number): Promise<void> {
+  static async #waitSecMessageAsync(msg: string, sec: number): Promise<void> {
     for (let i = sec; i > 0; i--) {
       if (i !== sec) {
         process.stdout.cursorTo(0);
@@ -294,7 +294,7 @@ export class SdCliProject {
     process.stdout.clearLine(0);
   }
 
-  private static _upgradeVersion(projNpmConf: INpmConfig, allPkgPaths: string[]) {
+  static #upgradeVersion(projNpmConf: INpmConfig, allPkgPaths: string[]) {
     // 작업공간 package.json 버전 설정
     const newVersion = semver.inc(projNpmConf.version, "patch")!;
     projNpmConf.version = newVersion;
@@ -346,7 +346,7 @@ export class SdCliProject {
     }
   }
 
-  private static _logging(buildResults: ISdBuildMessage[], logger: SdLogger): void {
+  static #logging(buildResults: ISdBuildMessage[], logger: SdLogger): void {
     const messageMap = buildResults.toSetMap(
       (item) => item.severity,
       (item) => SdCliConvertMessageUtils.getBuildMessageString(item),