@simplysm/sd-cli 11.0.6 → 11.0.9

package/src/build-tools/SdCliCordova.ts

@@ -0,0 +1,240 @@
+import {INpmConfig, ISdCliClientBuilderCordovaConfig} from "../commons";
+import * as path from "path";
+import {FsUtil, Logger, SdProcess} from "@simplysm/sd-core-node";
+import xml2js from "xml2js";
+
+const BIN_PATH = path.resolve(process.cwd(), "node_modules/.bin/cordova.cmd");
+
+export class SdCliCordova {
+  protected readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliCordova"]);
+
+  private readonly _platforms: string[];
+  private readonly _npmConfig: INpmConfig;
+
+  public constructor(private readonly _opt: {
+    pkgPath: string;
+    config: ISdCliClientBuilderCordovaConfig;
+    cordovaPath: string;
+  }) {
+    this._platforms = Object.keys(this._opt.config.platform ?? {browser: {}});
+    this._npmConfig = FsUtil.readJson(path.resolve(this._opt.pkgPath, "package.json"));
+    // this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name, this._npmConfig.name]);
+  }
+
+  private async _execAsync(cmd: string, cwd: string): Promise<void> {
+    this._logger.debug(cmd);
+    const msg = await SdProcess.spawnAsync(cmd, {cwd});
+    this._logger.debug(msg);
+  }
+
+  public async initializeAsync(): Promise<void> {
+    if (FsUtil.exists(this._opt.cordovaPath)) {
+      this._logger.log("이미 생성되어있는 '.cordova'를 사용합니다.");
+    }
+    else {
+      await this._execAsync(`${BIN_PATH} telemetry on`, this._opt.pkgPath);
+
+      // 프로젝트 생성
+      await this._execAsync(`${BIN_PATH} create "${this._opt.cordovaPath}" "${this._opt.config.appId}" "${this._opt.config.appName}"`, process.cwd());
+    }
+
+    // platforms 폴더 혹시 없으면 생성
+    await FsUtil.mkdirsAsync(path.resolve(this._opt.cordovaPath, "platforms"));
+
+    // www 폴더 혹시 없으면 생성
+    await FsUtil.mkdirsAsync(path.resolve(this._opt.cordovaPath, "www"));
+
+    // 미설치 빌드 플랫폼 신규 생성
+    const alreadyPlatforms = await FsUtil.readdirAsync(path.resolve(this._opt.cordovaPath, "platforms"));
+    for (const platform of this._platforms) {
+      if (!alreadyPlatforms.includes(platform)) {
+        await this._execAsync(`${BIN_PATH} platform add ${platform}`, this._opt.cordovaPath);
+      }
+    }
+
+    // 설치 미빌드 플랫폼 삭제
+    for (const alreadyPlatform of alreadyPlatforms) {
+      if (!this._platforms.includes(alreadyPlatform)) {
+        await this._execAsync(`${BIN_PATH} platform remove ${alreadyPlatform}`, this._opt.cordovaPath);
+      }
+    }
+
+    // 설치된 미사용 플러그인 삭제
+    const pluginsFetch = FsUtil.exists(path.resolve(this._opt.cordovaPath, "plugins/fetch.json"))
+      ? await FsUtil.readJsonAsync(path.resolve(this._opt.cordovaPath, "plugins/fetch.json"))
+      : undefined;
+    const alreadyPluginIds = pluginsFetch != undefined
+      ? Object.values(pluginsFetch)
+        .map((item: any) => (item.source.id !== undefined ? item.source.id : item.source.url))
+      : [];
+    const usePlugins = ["cordova-plugin-ionic-webview", ...this._opt.config.plugins ?? []].distinct();
+
+    for (const alreadyPluginId of alreadyPluginIds) {
+      let hasPlugin = false;
+      for (const usePlugin of usePlugins) {
+        if (
+          (usePlugin.includes("@") && alreadyPluginId === usePlugin) ||
+          (!usePlugin.includes("@") && alreadyPluginId.replace(/@.*$/, "") === usePlugin)
+        ) {
+          hasPlugin = true;
+          break;
+        }
+      }
+
+      if (!hasPlugin) {
+        await this._execAsync(`${BIN_PATH} plugin remove ${alreadyPluginId.replace(/@.*$/, "")}`, this._opt.cordovaPath);
+      }
+    }
+
+    // 미설치 플러그인들 설치
+    for (const usePlugin of usePlugins) {
+      if (
+        (usePlugin.includes("@") && !alreadyPluginIds.includes(usePlugin)) ||
+        (!usePlugin.includes("@") && !alreadyPluginIds.map((alreadyPluginId) => alreadyPluginId.replace(/@.*$/, "")).includes(usePlugin))
+      ) {
+        await this._execAsync(`${BIN_PATH} plugin add ${usePlugin}`, this._opt.cordovaPath);
+      }
+    }
+
+    // ANDROID SIGN 파일 복사
+    if (this._opt.config.platform?.android?.sign) {
+      await FsUtil.copyAsync(
+        path.resolve(this._opt.pkgPath, this._opt.config.platform.android.sign.keystore),
+        path.resolve(this._opt.cordovaPath, "android.keystore")
+      );
+    }
+    else {
+      await FsUtil.removeAsync(path.resolve(this._opt.cordovaPath, "android.keystore"));
+      // SIGN을 안쓸경우 아래 파일이 생성되어 있으면 오류남
+      await FsUtil.removeAsync(path.resolve(this._opt.cordovaPath, "platforms/android/release-signing.properties"));
+    }
+
+    // 빌드 옵션 파일 생성
+    await FsUtil.writeJsonAsync(
+      path.resolve(this._opt.cordovaPath, "build.json"),
+      {
+        ...this._opt.config.platform?.android ? {
+          android: {
+            release: {
+              packageType: this._opt.config.platform.android.bundle ? "bundle" : "apk",
+              ...this._opt.config.platform.android.sign ? {
+                keystore: path.resolve(this._opt.cordovaPath, "android.keystore"),
+                storePassword: this._opt.config.platform.android.sign.storePassword,
+                alias: this._opt.config.platform.android.sign.alias,
+                password: this._opt.config.platform.android.sign.password,
+                keystoreType: this._opt.config.platform.android.sign.keystoreType
+              } : {}
+            }
+          }
+        } : {}
+      }
+    );
+
+    // ICON 파일 복사
+    if (this._opt.config.icon !== undefined) {
+      await FsUtil.copyAsync(path.resolve(this._opt.cordovaPath, this._opt.config.icon), path.resolve(this._opt.cordovaPath, "res", "icon.png"));
+    }
+    else {
+      await FsUtil.removeAsync(path.resolve(this._opt.cordovaPath, "res", "icon.png"));
+    }
+
+    // CONFIG: 초기값 백업
+    const configFilePath = path.resolve(this._opt.cordovaPath, "config.xml");
+    const configBackFilePath = path.resolve(this._opt.cordovaPath, "config.xml.bak");
+    if (!FsUtil.exists(configBackFilePath)) {
+      await FsUtil.copyAsync(configFilePath, configBackFilePath);
+    }
+
+    // CONFIG: 초기값 읽기
+    const configFileContent = await FsUtil.readFileAsync(configBackFilePath);
+    const configXml = await xml2js.parseStringPromise(configFileContent);
+
+
+    // CONFIG: 버전 설정
+    configXml.widget.$.version = this._npmConfig.version;
+
+    // CONFIG: ICON 설정
+    if (this._opt.config.icon !== undefined) {
+      configXml["widget"]["icon"] = [{"$": {"src": "res/icon.png"}}];
+    }
+
+    // CONFIG: 접근허용 세팅
+    configXml["widget"]["access"] = [{"$": {"origin": "*"}}];
+    configXml["widget"]["allow-navigation"] = [{"$": {"href": "*"}}];
+    configXml["widget"]["allow-intent"] = [{"$": {"href": "*"}}];
+    configXml["widget"]["preference"] = [{"$": {"name": "MixedContentMode", "value": "0"}}];
+
+    // CONFIG: ANDROID usesCleartextTraffic 설정
+    if (this._opt.config.platform?.android) {
+      configXml.widget.$["xmlns:android"] = "http://schemas.android.com/apk/res/android";
+
+      configXml["widget"]["platform"] = configXml["widget"]["platform"] ?? [];
+      configXml["widget"]["platform"].push({
+        "$": {
+          "name": "android"
+        },
+        "edit-config": [{
+          "$": {
+            "file": "app/src/main/AndroidManifest.xml",
+            "mode": "merge",
+            "target": "/manifest/application"
+          },
+          "application": [{
+            "$": {
+              "android:usesCleartextTraffic": "true"
+            }
+          }]
+        }]
+      });
+    }
+
+    // CONFIG: 파일 새로 쓰기
+    const configResultContent = new xml2js.Builder().buildObject(configXml);
+    await FsUtil.writeFileAsync(configFilePath, configResultContent);
+
+    // 각 플랫폼 www 준비
+    await this._execAsync(`${BIN_PATH} prepare`, this._opt.cordovaPath);
+  }
+
+  public async buildAsync(outPath: string): Promise<void> {
+    // 실행
+    const buildType = this._opt.config.debug ? "debug" : "release";
+    for (const platform of this._platforms) {
+      await this._execAsync(`${BIN_PATH} build ${platform} --${buildType}`, this._opt.cordovaPath);
+    }
+
+    // 결과물 복사: ANDROID
+    if (this._opt.config.platform?.android) {
+      const targetOutPath = path.resolve(outPath, "android");
+      const apkFileName = this._opt.config.platform.android.sign ? `app-${buildType}.apk` : `app-${buildType}-unsigned.apk`;
+      const latestDistApkFileName = path.basename(`${this._opt.config.appName}${this._opt.config.platform.android.sign ? "" : "-unsigned"}-latest.apk`);
+      await FsUtil.mkdirsAsync(targetOutPath);
+      await FsUtil.copyAsync(
+        path.resolve(this._opt.cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName),
+        path.resolve(targetOutPath, latestDistApkFileName)
+      );
+      // 자동업데이트를 위한 파일 쓰기
+      await FsUtil.copyAsync(
+        path.resolve(this._opt.cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName),
+        path.resolve(path.resolve(targetOutPath, "updates"), this._npmConfig.version + ".apk")
+      );
+    }
+  }
+
+  public static async runWebviewOnDeviceAsync(opt: {
+    platform: string,
+    pkgName: string,
+    url?: string
+  }): Promise<void> {
+    const cordovaPath = path.resolve(process.cwd(), `packages/${opt.pkgName}/.cache/cordova/`);
+
+    if (opt.url !== undefined) {
+      await FsUtil.removeAsync(path.resolve(cordovaPath, "www"));
+      await FsUtil.mkdirsAsync(path.resolve(cordovaPath, "www"));
+      await FsUtil.writeFileAsync(path.resolve(cordovaPath, "www/index.html"), `'${opt.url}'로 이동중... <script>setTimeout(function () {window.location.href = "${opt.url.replace(/\/$/, "")}/${opt.pkgName}/cordova/"}, 3000);</script>`.trim());
+    }
+
+    const binPath = path.resolve(process.cwd(), "node_modules/.bin/cordova.cmd");
+    await SdProcess.spawnAsync(`${binPath} run ${opt.platform} --device`, {cwd: cordovaPath}, true);
+  }
+}

package/src/build-tools/SdNgBundler.ts

@@ -17,12 +17,13 @@ import {
 import nodeStdLibBrowser from "node-stdlib-browser";
 import nodeStdLibBrowserPlugin from "node-stdlib-browser/helpers/esbuild/plugin";
 import {ExecutionResult} from "@angular-devkit/build-angular/src/tools/esbuild/bundler-execution-result";
-import {INpmConfig, ISdCliPackageBuildResult} from "../commons";
+import {INpmConfig, ISdCliClientPackageConfig, ISdCliPackageBuildResult} from "../commons";
 import {generateIndexHtml} from "@angular-devkit/build-angular/src/tools/esbuild/index-html-generator";
 import {copyAssets} from "@angular-devkit/build-angular/src/utils/copy-assets";
 import {extractLicenses} from "@angular-devkit/build-angular/src/tools/esbuild/license-extractor";
 import {augmentAppWithServiceWorkerEsbuild} from "@angular-devkit/build-angular/src/utils/service-worker";
 import {createGlobalStylesBundleOptions} from "@angular-devkit/build-angular/src/tools/esbuild/global-styles";
+import {Entrypoint} from "@angular-devkit/build-angular/src/utils/index-file/augment-index-html";
 
 export class SdNgBundler {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdNgEsbuildBuilder"]);
@@ -34,8 +35,14 @@ export class SdNgBundler {
 
   private readonly _outputCache = new Map<string, string | number>();
 
-  public constructor(private readonly _opt: { dev: boolean, builderType: string, pkgPath: string }) {
-    this._options = this._getOptions(_opt);
+  public constructor(opt: {
+    dev: boolean,
+    builderType: keyof ISdCliClientPackageConfig["builder"],
+    pkgPath: string,
+    cordovaPlatforms: string[] | undefined,
+    outputPath: string
+  }) {
+    this._options = this._getOptions(opt);
   }
 
   public removeCache(filePaths: string[]): void {
@@ -58,7 +65,7 @@ export class SdNgBundler {
 
     const results = [
       ...bundlingResult.warnings.map((warn) => ({
-        filePath: warn.location?.file !== undefined ? path.resolve(this._opt.pkgPath, warn.location.file) : undefined,
+        filePath: warn.location?.file !== undefined ? path.resolve(this._options.workspaceRoot, warn.location.file) : undefined,
         line: warn.location?.line,
         char: warn.location?.column,
         code: undefined,
@@ -67,7 +74,7 @@ export class SdNgBundler {
         type: "build" as const
       })),
       ...bundlingResult.errors?.map((err) => ({
-        filePath: err.location?.file !== undefined ? path.resolve(this._opt.pkgPath, err.location.file) : undefined,
+        filePath: err.location?.file !== undefined ? path.resolve(this._options.workspaceRoot, err.location.file) : undefined,
         line: err.location?.line,
         char: err.location?.column !== undefined ? err.location.column + 1 : undefined,
         code: undefined,
@@ -77,10 +84,10 @@ export class SdNgBundler {
       })) ?? []
     ];
     const watchFilePaths = [
-      ...this._sourceFileCache.typeScriptFileCache.keys(),
+      ...this._sourceFileCache.keys(),
       ...this._sourceFileCache.babelFileCache.keys()
     ].map((item) => path.resolve(item));
-    let affectedSourceFilePaths = watchFilePaths.filter((item) => PathUtil.isChildPath(item, this._opt.pkgPath));
+    let affectedSourceFilePaths = watchFilePaths.filter((item) => PathUtil.isChildPath(item, this._options.workspaceRoot));
     if (bundlingResult.errors) {
       return {
         filePaths: watchFilePaths,
@@ -92,8 +99,8 @@ export class SdNgBundler {
     const depsMap = new Map<string, Set<string>>();
     for (const entry of Object.entries(bundlingResult.metafile.inputs)) {
       for (const imp of entry[1].imports) {
-        const deps = depsMap.getOrCreate(path.resolve(this._opt.pkgPath, imp.path), new Set<string>());
-        deps.add(path.resolve(this._opt.pkgPath, entry[0]));
+        const deps = depsMap.getOrCreate(path.resolve(this._options.workspaceRoot, imp.path), new Set<string>());
+        deps.add(path.resolve(this._options.workspaceRoot, entry[0]));
       }
     }
 
@@ -115,9 +122,10 @@ export class SdNgBundler {
     if (this._sourceFileCache.modifiedFiles.size > 0) {
       const affectedFilePathSet = new Set<string>();
       for (const modFile of this._sourceFileCache.modifiedFiles) {
+        affectedFilePathSet.add(path.resolve(modFile));
         affectedFilePathSet.adds(...searchAffectedFiles(path.resolve(modFile)));
       }
-      affectedSourceFilePaths = Array.from(affectedFilePathSet.values()).filter((item) => PathUtil.isChildPath(item, this._opt.pkgPath));
+      affectedSourceFilePaths = Array.from(affectedFilePathSet.values()).filter((item) => PathUtil.isChildPath(item, this._options.workspaceRoot));
     }
 
     const executionResult = new ExecutionResult(this._contexts, this._sourceFileCache);
@@ -176,9 +184,8 @@ export class SdNgBundler {
 
     //-- write
 
-    const distPath = path.resolve(this._options.outputPath, "dist", ...(this._opt.builderType === "web" ? [] : [this._opt.builderType]));
     for (const outputFile of executionResult.outputFiles) {
-      const distFilePath = path.resolve(distPath, outputFile.path);
+      const distFilePath = path.resolve(this._options.outputPath, outputFile.path);
 
       const prev = this._outputCache.get(distFilePath);
       if (prev !== Buffer.from(outputFile.contents).toString("base64")) {
@@ -190,7 +197,7 @@ export class SdNgBundler {
       const prev = this._outputCache.get(assetFile.source);
       const curr = FsUtil.lstat(assetFile.source).mtime.getTime();
       if (prev !== curr) {
-        await FsUtil.copyAsync(assetFile.source, path.resolve(distPath, assetFile.destination));
+        await FsUtil.copyAsync(assetFile.source, path.resolve(this._options.outputPath, assetFile.destination));
         this._outputCache.set(assetFile.source, curr);
       }
     }
@@ -276,7 +283,7 @@ export class SdNgBundler {
       minifySyntax: !this._options.watch,
       minifyWhitespace: !this._options.watch,
       pure: ['forwardRef'],
-      outdir: this._options.outputPath,
+      outdir: this._options.workspaceRoot,
       outExtension: undefined,
       sourcemap: this._options.watch,
       splitting: true,
@@ -292,6 +299,7 @@ export class SdNgBundler {
         process: 'process',
         Buffer: 'Buffer',
         'process.env.SD_VERSION': JSON.stringify(pkgNpmConf.version),
+        "process.env.NODE_ENV": JSON.stringify(this._options.watch ? "development" : "production")
       },
       platform: 'browser',
       mainFields: ['es2020', 'es2015', 'browser', 'module', 'main'],
@@ -358,7 +366,13 @@ export class SdNgBundler {
     };
   }
 
-  private _getOptions(opt: { dev: boolean, builderType: string, pkgPath: string }): NormalizedApplicationBuildOptions {
+  private _getOptions(opt: {
+    dev: boolean,
+    builderType: keyof ISdCliClientPackageConfig["builder"],
+    pkgPath: string,
+    cordovaPlatforms: string[] | undefined,
+    outputPath: string,
+  }): NormalizedApplicationBuildOptions {
     const mainFilePath = path.resolve(opt.pkgPath, "src/main.ts");
     const tsconfigFilePath = path.resolve(opt.pkgPath, "tsconfig.json");
     const indexHtmlFilePath = path.resolve(opt.pkgPath, "src/index.html");
@@ -398,20 +412,47 @@ export class SdNgBundler {
       verbose: false,
       watch: opt.dev,
       workspaceRoot: opt.pkgPath,
-      entryPoints: {main: mainFilePath},
+      entryPoints: {
+        main: mainFilePath,
+        ...opt.builderType === "cordova" ? {
+          "cordova-entry": path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../lib/cordova-entry.js`)
+        } : {}
+      },
       optimizationOptions: {
         scripts: !opt.dev,
         styles: {minify: !opt.dev, inlineCritical: !opt.dev},
         fonts: {inline: !opt.dev}
       },
-      outputPath: opt.pkgPath,
+      outputPath: opt.outputPath,
       outExtension: undefined,
       sourcemapOptions: {vendor: false, hidden: false, scripts: opt.dev, styles: opt.dev},
       tsconfig: tsconfigFilePath,
       projectRoot: opt.pkgPath,
       assets: [
-        {glob: 'favicon.ico', input: 'src', output: ''},
-        {glob: '**/*', input: 'src\\assets', output: 'assets'}
+        {input: 'src', glob: 'favicon.ico', output: ''},
+        {input: 'src\\assets', glob: '**/*', output: 'assets'},
+        ...opt.dev && opt.cordovaPlatforms ? opt.cordovaPlatforms.mapMany((platform) => [
+          {
+            input: `.cache\\cordova\\platforms\\${platform}\\platform_www\\plugins`,
+            glob: '**/*',
+            output: `cordova-${platform}/plugins`
+          },
+          {
+            input: `.cache\\cordova\\platforms\\${platform}\\platform_www`,
+            glob: 'cordova.js',
+            output: `cordova-${platform}`
+          },
+          {
+            input: `.cache\\cordova\\platforms\\${platform}\\platform_www`,
+            glob: 'cordova_plugins.js',
+            output: `cordova-${platform}`
+          },
+          {
+            input: `.cache\\cordova\\platforms\\${platform}\\www`,
+            glob: 'config.xml',
+            output: `cordova-${platform}`
+          },
+        ]) : []
       ],
       outputNames: {bundles: '[name]', media: 'media/[name]'},
       fileReplacements: undefined,
@@ -426,7 +467,10 @@ export class SdNgBundler {
           ['polyfills', true],
           ['styles', false],
           ['vendor', true],
-          ['main', true]
+          ['main', true],
+          ...opt.builderType === "cordova" ? [
+            ["cordova-entry", true] as Entrypoint
+          ] : []
         ]
       },
       tailwindConfiguration: undefined

package/src/build-tools/SdTsBundler.ts

@@ -10,7 +10,7 @@ export class SdTsBundler {
     dev: boolean;
     pkgPath: string;
     entryPoints: string[];
-    external?: string[];
+    // external?: string[];
   }) {
   }
 
@@ -64,14 +64,15 @@ export class SdTsBundler {
       },
       platform: "node",
       logLevel: "silent",
-      external: this._opt.external,
+      packages: "external",
+      // external: this._opt.external,
       banner: {
         js: `
 import __path__ from 'path';
 import { fileURLToPath as __fileURLToPath__ } from 'url';
-import { createRequire as __createRequire__ } from 'module';
-
-const require = __createRequire__(import.meta.url);
+// import { createRequire as __createRequire__ } from 'module';
+//
+// const require = __createRequire__(import.meta.url);
 const __filename = __fileURLToPath__(import.meta.url);
 const __dirname = __path__.dirname(__filename);`.trim()
       },

package/src/builders/SdCliClientBuilder.ts

@@ -3,15 +3,16 @@ import {FsUtil, Logger, PathUtil, SdFsWatcher} from "@simplysm/sd-core-node";
 import {ISdCliBuilderResult, ISdCliClientPackageConfig, ISdCliConfig, ISdCliPackageBuildResult} from "../commons";
 import {FunctionQueue, Wait} from "@simplysm/sd-core-common";
 import path from "path";
-import {SdTsCompiler} from "../build-tools/SdTsCompiler";
 import {SdNgBundler} from "../build-tools/SdNgBundler";
 import {SdLinter} from "../build-tools/SdLinter";
+import {SdCliCordova} from "../build-tools/SdCliCordova";
 
+// TODO: ROUTER 자동생성
 export class SdCliClientBuilder extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliClientBuilder"]);
   private readonly _pkgConf: ISdCliClientPackageConfig;
   private _builders?: SdNgBundler[];
-  private _checker?: SdTsCompiler;
+  private _cordova?: SdCliCordova;
 
   public constructor(private readonly _projConf: ISdCliConfig,
                      private readonly _pkgPath: string) {
@@ -73,12 +74,27 @@ export class SdCliClientBuilder extends EventEmitter {
     affectedFilePaths: string[];
     buildResults: ISdCliPackageBuildResult[];
   }> {
+    const builderTypes = (Object.keys(this._pkgConf.builder ?? {web: {}}) as (keyof ISdCliClientPackageConfig["builder"])[]);
+    if (this._pkgConf.builder?.cordova && !this._cordova) {
+      this._debug("CORDOVA 준비...");
+      this._cordova = new SdCliCordova({
+        pkgPath: this._pkgPath,
+        config: this._pkgConf.builder.cordova,
+        cordovaPath: path.resolve(this._pkgPath, ".cache/cordova")
+      });
+      await this._cordova.initializeAsync();
+    }
+
     this._debug(`BUILD 준비...`);
-    const builderTypes = (Object.keys(this._pkgConf.builder ?? {web: {}}) as ("web")[]);
     this._builders = this._builders ?? builderTypes.map((builderType) => new SdNgBundler({
       dev: opt.dev,
       builderType: builderType,
-      pkgPath: this._pkgPath
+      pkgPath: this._pkgPath,
+      cordovaPlatforms: builderType === "cordova" ? Object.keys(this._pkgConf.builder!.cordova!.platform ?? {browser: {}}) : undefined,
+      outputPath: builderType === "web" ? path.resolve(this._pkgPath, "dist")
+        : builderType === "electron" ? path.resolve(this._pkgPath, ".cache/electron/src")
+          : builderType === "cordova" && !opt.dev ? path.resolve(this._pkgPath, ".cache/cordova/www")
+            : path.resolve(this._pkgPath, "dist", builderType)
     }));
 
     this._debug(`BUILD & CHECK...`);
@@ -102,6 +118,11 @@ export class SdCliClientBuilder extends EventEmitter {
       }
     }
 
+    if (!opt.dev && this._cordova) {
+      this._debug("CORDOVA BUILD...");
+      await this._cordova.buildAsync(path.resolve(this._pkgPath, ".cache/cordova"));
+    }
+
     const localUpdatePaths = Object.keys(this._projConf.localUpdates ?? {})
       .mapMany((key) => FsUtil.glob(path.resolve(this._pkgPath, "../../node_modules", key)));
     const watchFilePaths = filePaths

package/src/builders/SdCliServerBuilder.ts

@@ -4,7 +4,7 @@ import {INpmConfig, ISdCliBuilderResult, ISdCliConfig, ISdCliServerPackageConfig
 import path from "path";
 import {SdTsCompiler} from "../build-tools/SdTsCompiler";
 import {SdLinter} from "../build-tools/SdLinter";
-import {FunctionQueue, ObjectUtil, StringUtil} from "@simplysm/sd-core-common";
+import {FunctionQueue, ObjectUtil} from "@simplysm/sd-core-common";
 import {SdTsBundler} from "../build-tools/SdTsBundler";
 
 export class SdCliServerBuilder extends EventEmitter {
@@ -26,7 +26,7 @@ export class SdCliServerBuilder extends EventEmitter {
   }
 
   public async watchAsync(): Promise<void> {
-    const extModules = await this._getExternalModulesAsync();
+    // const extModules = await this._getExternalModulesAsync();
 
     this._debug("dist 초기화...");
     await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
@@ -42,7 +42,7 @@ export class SdCliServerBuilder extends EventEmitter {
       entryPoints: [
         path.resolve(this._pkgPath, "src/main.ts")
       ],
-      external: extModules.map((item) => item.name)
+      // external: extModules.map((item) => item.name)
     });
 
     const checker = new SdTsCompiler({
@@ -73,7 +73,7 @@ export class SdCliServerBuilder extends EventEmitter {
           const checkResult = await checker.buildAsync();
 
           this._debug(`LINT...`);
-          const lintResults = await SdLinter.lintAsync(checkResult.affectedFilePaths, checker.program);
+          const lintResults = !this._withLint ? [] : await SdLinter.lintAsync(checkResult.affectedFilePaths, checker.program);
 
           this._debug(`빌드 완료`);
           this.emit("complete", {
@@ -86,7 +86,7 @@ export class SdCliServerBuilder extends EventEmitter {
 
   public async buildAsync(): Promise<ISdCliBuilderResult> {
     const npmConfig = (await FsUtil.readJsonAsync(path.resolve(this._pkgPath, "package.json"))) as INpmConfig;
-    const extModules = await this._getExternalModulesAsync();
+    // const extModules = await this._getExternalModulesAsync();
 
     this._debug("dist 초기화...");
     await FsUtil.removeAsync(path.resolve(this._pkgPath, "dist"));
@@ -97,13 +97,13 @@ export class SdCliServerBuilder extends EventEmitter {
 
     this._debug("GEN package.json...");
     {
-      const deps = extModules.filter((item) => item.exists).map((item) => item.name);
+      // const deps = extModules.filter((item) => item.exists).map((item) => item.name);
 
       const distNpmConfig = ObjectUtil.clone(npmConfig);
-      distNpmConfig.dependencies = {};
-      for (const dep of deps) {
-        distNpmConfig.dependencies[dep] = "*";
-      }
+      // distNpmConfig.dependencies = {};
+      // for (const dep of deps) {
+      //   distNpmConfig.dependencies[dep] = "*";
+      // }
       delete distNpmConfig.optionalDependencies;
       delete distNpmConfig.devDependencies;
       delete distNpmConfig.peerDependencies;
@@ -184,7 +184,7 @@ export class SdCliServerBuilder extends EventEmitter {
       entryPoints: [
         path.resolve(this._pkgPath, "src/main.ts")
       ],
-      external: extModules.map((item) => item.name)
+      // external: extModules.map((item) => item.name)
     });
 
     const checker = new SdTsCompiler({
@@ -201,7 +201,7 @@ export class SdCliServerBuilder extends EventEmitter {
     const checkResult = await checker.buildAsync();
 
     this._debug(`LINT...`);
-    const lintResults = await SdLinter.lintAsync(checkResult.affectedFilePaths, checker.program);
+    const lintResults = !this._withLint ? [] : await SdLinter.lintAsync(checkResult.affectedFilePaths, checker.program);
 
     this._debug(`빌드 완료`);
     return {
@@ -210,7 +210,7 @@ export class SdCliServerBuilder extends EventEmitter {
     };
   }
 
-  private async _getExternalModulesAsync(): Promise<{
+  /*private async _getExternalModulesAsync(): Promise<{
     name: string;
     exists: boolean
   }[]> {
@@ -245,7 +245,7 @@ export class SdCliServerBuilder extends EventEmitter {
           continue;
         }
 
-        if (FsUtil.glob(path.resolve(modulePath, "**/binding.gyp")).length > 0) {
+        if (FsUtil.glob(path.resolve(modulePath, "**!/binding.gyp")).length > 0) {
           results.push({
             name: moduleName,
             exists: true
@@ -275,7 +275,7 @@ export class SdCliServerBuilder extends EventEmitter {
           continue;
         }
 
-        if (FsUtil.glob(path.resolve(optModulePath, "**/binding.gyp")).length > 0) {
+        if (FsUtil.glob(path.resolve(optModulePath, "**!/binding.gyp")).length > 0) {
           results.push({
             name: optModuleName,
             exists: true
@@ -296,7 +296,7 @@ export class SdCliServerBuilder extends EventEmitter {
     await fn(this._pkgPath);
 
     return results;
-  }
+  }*/
 
   private _debug(msg: string): void {
     this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);

package/src/builders/SdCliTsLibBuilder.ts

@@ -1,6 +1,6 @@
 import {FsUtil, Logger, SdFsWatcher} from "@simplysm/sd-core-node";
 import path from "path";
-import {ISdCliBuilderResult, ISdCliConfig} from "../commons";
+import {ISdCliBuilderResult} from "../commons";
 import {EventEmitter} from "events";
 import {SdTsCompiler} from "../build-tools/SdTsCompiler";
 import {SdLinter} from "../build-tools/SdLinter";
@@ -9,8 +9,7 @@ import {FunctionQueue} from "@simplysm/sd-core-common";
 export class SdCliTsLibBuilder extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", "SdCliTsLibBuilder"]);
 
-  public constructor(private readonly _projConf: ISdCliConfig,
-                     private readonly _pkgPath: string,
+  public constructor(private readonly _pkgPath: string,
                      private readonly _withLint: boolean) {
     super();
   }