@simplysm/sd-cli 7.0.65 → 7.0.75

package/src/builder/SdCliClientBuilder.ts

@@ -34,24 +34,55 @@ import { CssOptimizerPlugin } from "@angular-devkit/build-angular/src/webpack/pl
 import browserslist from "browserslist";
 import { augmentAppWithServiceWorker } from "@angular-devkit/build-angular/src/utils/service-worker";
 import { StringUtil } from "@simplysm/sd-core-common";
+import { SdCliNgModuleGenerator } from "../ng-tools/SdCliNgModuleGenerator";
+import { SdCliCordova } from "../build-tool/SdCliCordova";
 import LintResult = ESLint.LintResult;
 
 export class SdCliClientBuilder extends EventEmitter {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+  private readonly _logger: Logger;
 
   private readonly _tsconfigFilePath: string;
   private readonly _parsedTsconfig: ts.ParsedCommandLine;
   private readonly _npmConfigMap = new Map<string, INpmConfig>();
+  private readonly _ngModuleGenerator: SdCliNgModuleGenerator;
+
+  private readonly _cordova?: SdCliCordova;
 
   public constructor(private readonly _rootPath: string,
                      private readonly _config: ISdCliClientPackageConfig,
                      private readonly _workspaceRootPath: string) {
     super();
 
+    const npmConfig = this._getNpmConfig(this._rootPath)!;
+    this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name, npmConfig.name]);
+
     // tsconfig
     this._tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
     const tsconfig = FsUtil.readJson(this._tsconfigFilePath) as ITsconfig;
     this._parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath, tsconfig.angularCompilerOptions);
+
+    // NgModule 생성기 초기화
+    this._ngModuleGenerator = new SdCliNgModuleGenerator(this._rootPath, [
+      "controls",
+      "directives",
+      "guards",
+      "modals",
+      "providers",
+      "app",
+      "pages",
+      "print-templates",
+      "toasts",
+      "AppPage"
+    ], {
+      glob: "**/*Page.ts",
+      fileEndsWith: "Page",
+      rootClassName: "AppPage"
+    });
+
+    // CORDOVA
+    if (this._config.cordova) {
+      this._cordova = new SdCliCordova(this._rootPath, this._config.cordova);
+    }
   }
 
   public override on(event: "change", listener: () => void): this;
@@ -64,18 +95,47 @@ export class SdCliClientBuilder extends EventEmitter {
     // DIST 비우기
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
+    // NgModule 생성
+    await this._ngModuleGenerator.runAsync();
+
+    // CORDOVA
+    if (this._cordova) {
+      this._logger.debug("CORDOVA 구성...");
+      await this._cordova.initializeAsync();
+    }
+
     // 빌드 준비
     const webpackConfig = this._getWebpackConfig(true);
     const compiler = webpack(webpackConfig);
     return await new Promise<NextHandleFunction[]>((resolve, reject) => {
-      compiler.hooks.watchRun.tapAsync(this.constructor.name, (args, callback) => {
+      compiler.hooks.invalid.tap(this.constructor.name, (fileName) => {
+        if (fileName != null) {
+          this._logger.debug("파일변경 감지", fileName);
+          // NgModule 캐시 삭제
+          this._ngModuleGenerator.removeCaches([path.resolve(fileName)]);
+        }
+      });
+
+      compiler.hooks.watchRun.tapAsync(this.constructor.name, async (args, callback) => {
         this.emit("change");
+
+        // NgModule 생성
+        await this._ngModuleGenerator.runAsync();
+
         callback();
 
         this._logger.debug("Webpack 빌드 수행...");
       });
 
       compiler.hooks.failed.tap(this.constructor.name, (err) => {
+        this.emit("complete", [{
+          filePath: undefined,
+          line: undefined,
+          char: undefined,
+          code: undefined,
+          severity: "error",
+          message: err.stack
+        }]);
         reject(err);
         return;
       });
@@ -83,7 +143,6 @@ export class SdCliClientBuilder extends EventEmitter {
       compiler.hooks.done.tap(this.constructor.name, async (stats) => {
         // 결과 반환
         const results = SdCliBuildResultUtil.convertFromWebpackStats(stats);
-        this.emit("complete", results);
 
         // .config.json 파일 쓰기
         const npmConfig = this._getNpmConfig(this._rootPath)!;
@@ -97,6 +156,8 @@ export class SdCliClientBuilder extends EventEmitter {
         // 마무리
         this._logger.debug("Webpack 빌드 완료");
         resolve([devMiddleware, hotMiddleware]);
+
+        this.emit("complete", results);
       });
 
       const devMiddleware = wdm(compiler, {
@@ -116,6 +177,9 @@ export class SdCliClientBuilder extends EventEmitter {
     // DIST 비우기
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
+    // NgModule 생성
+    await this._ngModuleGenerator.runAsync();
+
     // 빌드
     this._logger.debug("Webpack 빌드 수행...");
     const webpackConfig = this._getWebpackConfig(false);
@@ -148,6 +212,15 @@ export class SdCliClientBuilder extends EventEmitter {
       );
     }
 
+    // CORDOVA
+    if (this._cordova) {
+      this._logger.debug("CORDOVA 구성...");
+      await this._cordova.initializeAsync();
+
+      this._logger.debug("CORDOVA 빌드...");
+      await this._cordova.buildAsync(this._parsedTsconfig.options.outDir!);
+    }
+
     // 마무리
     this._logger.debug("Webpack 빌드 완료");
     return buildResults;
@@ -176,7 +249,7 @@ export class SdCliClientBuilder extends EventEmitter {
     const cacheBasePath = path.resolve(this._rootPath, ".cache");
     const cachePath = path.resolve(cacheBasePath, pkgVersion);
 
-    const distPath = this._parsedTsconfig.options.outDir;
+    const distPath = (this._cordova && !watch) ? path.resolve(this._cordova.cordovaPath, "www") : this._parsedTsconfig.options.outDir;
 
     const sassImplementation = new SassWorkerImplementation();
 
@@ -250,6 +323,7 @@ export class SdCliClientBuilder extends EventEmitter {
           .update(watch.toString())
           .digest("hex")
       },
+      // cache: { type: "memory", maxGenerations: 1 },
       ...watch ? {
         snapshot: {
           immutablePaths: internalModuleCachePaths,
@@ -462,7 +536,12 @@ export class SdCliClientBuilder extends EventEmitter {
                 ].map((i) => PathUtil.posix(this._rootPath, i))
               },
               priority: 0
-            }))
+            })),
+            ...this._cordova ? this._cordova.platforms.map((platform) => ({
+              context: this._cordova!.cordovaPath,
+              to: `cordova-${platform}`,
+              from: `platforms/${platform}/platform_www`
+            })) : []
           ]
         }),
         ...watch ? [

package/src/builder/SdCliServerBuilder.ts

@@ -13,8 +13,8 @@ import { ObjectUtil, StringUtil } from "@simplysm/sd-core-common";
 import ESLintWebpackPlugin from "eslint-webpack-plugin";
 import CopyWebpackPlugin from "copy-webpack-plugin";
 import { LicenseWebpackPlugin } from "license-webpack-plugin";
-import { createHash } from "crypto";
 import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
+import { createHash } from "crypto";
 import LintResult = ESLint.LintResult;
 
 export class SdCliServerBuilder extends EventEmitter {
@@ -47,7 +47,7 @@ export class SdCliServerBuilder extends EventEmitter {
 
     // 빌드 준비
     const extModules = this._getExternalModules();
-    const webpackConfig = this._getWebpackConfig(true, extModules.map((item) => item.name));
+    const webpackConfig = this._getWebpackConfig(true, extModules);
     const compiler = webpack(webpackConfig);
     await new Promise<void>((resolve, reject) => {
       compiler.hooks.watchRun.tapAsync(this.constructor.name, (args, callback) => {
@@ -81,7 +81,7 @@ export class SdCliServerBuilder extends EventEmitter {
     // 빌드
     this._logger.debug("Webpack 빌드 수행...");
     const extModules = this._getExternalModules();
-    const webpackConfig = this._getWebpackConfig(false, extModules.map((item) => item.name));
+    const webpackConfig = this._getWebpackConfig(false, extModules);
     const compiler = webpack(webpackConfig);
     const buildResults = await new Promise<ISdCliPackageBuildResult[]>((resolve, reject) => {
       compiler.run((err, stats) => {
@@ -130,6 +130,7 @@ export class SdCliServerBuilder extends EventEmitter {
           {
             "name": npmConfig.name.replace(/@/g, "").replace(/\//g, "-"),
             "script": path.basename(path.resolve(this._parsedTsconfig.options.outDir!, "main.mjs")),
+            "node_args": "--experimental-specifier-resolution=node --experimental-import-meta-resolve",
             "watch": true,
             "watch_delay": 2000,
             "ignore_watch": [
@@ -211,7 +212,7 @@ export class SdCliServerBuilder extends EventEmitter {
     ].map((p) => path.dirname(p));
   }
 
-  private _getWebpackConfig(watch: boolean, extModuleNames: string[]): webpack.Configuration {
+  private _getWebpackConfig(watch: boolean, extModules: { name: string; exists: boolean }[]): webpack.Configuration {
     const workspaceNpmConfig = this._getNpmConfig(this._workspaceRootPath)!;
     const workspaceName = workspaceNpmConfig.name;
 
@@ -256,17 +257,18 @@ export class SdCliServerBuilder extends EventEmitter {
         assetModuleFilename: "res/[name][ext][query]",
         library: {
           type: "module"
-        }
+        },
+        module: true
       },
-      watch: false,
-      watchOptions: { poll: undefined, ignored: undefined },
-      performance: { hints: false },
       experiments: {
         outputModule: true
       },
+      watch: false,
+      watchOptions: { poll: undefined, ignored: undefined },
+      performance: { hints: false },
       infrastructureLogging: { level: "error" },
       stats: "errors-warnings",
-      externals: extModuleNames.toObject((item) => item, (item) => "commonjs2 " + item),
+      externals: extModules.toObject((item) => item.name, (item) => "node-commonjs " + item.name),
       cache: {
         type: "filesystem",
         profile: watch ? undefined : false,
@@ -281,6 +283,7 @@ export class SdCliServerBuilder extends EventEmitter {
           .update(watch.toString())
           .digest("hex")
       },
+      // cache: { type: "memory", maxGenerations: 1 },
       ...watch ? {
         snapshot: {
           immutablePaths: internalModuleCachePaths,
@@ -457,6 +460,10 @@ export class SdCliServerBuilder extends EventEmitter {
           results.push({ name: moduleName, exists: true });
         }
 
+        if (this._config.externalNodeModules?.includes(moduleName)) {
+          results.push({ name: moduleName, exists: true });
+        }
+
         fn(modulePath);
       }
 
@@ -474,6 +481,10 @@ export class SdCliServerBuilder extends EventEmitter {
           results.push({ name: optModuleName, exists: true });
         }
 
+        if (this._config.externalNodeModules?.includes(optModuleName)) {
+          results.push({ name: optModuleName, exists: true });
+        }
+
         fn(optModulePath);
       }
     };

package/src/builder/SdCliTsLibBuilder.ts

@@ -1,4 +1,4 @@
-import { INpmConfig, ISdCliPackageBuildResult } from "../commons";
+import { INpmConfig, ISdCliLibPackageConfig, ISdCliPackageBuildResult } from "../commons";
 import { EventEmitter } from "events";
 import ts from "typescript";
 import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
@@ -12,10 +12,11 @@ import { SdCliCacheCompilerHost } from "../build-tool/SdCliCacheCompilerHost";
 import { SdCliNgCacheCompilerHost } from "../build-tool/SdCliNgCacheCompilerHost";
 import { NgCompiler } from "@angular/compiler-cli/src/ngtsc/core";
 import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
-import { NgModuleGenerator } from "../ng-tools/NgModuleGenerator";
+import { SdCliNgModuleGenerator } from "../ng-tools/SdCliNgModuleGenerator";
+import { SdCliIndexFileGenerator } from "../build-tool/SdCliIndexFileGenerator";
 
 export class SdCliTsLibBuilder extends EventEmitter {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+  private readonly _logger: Logger;
 
   private _moduleResolutionCache?: ts.ModuleResolutionCache;
 
@@ -24,31 +25,63 @@ export class SdCliTsLibBuilder extends EventEmitter {
   private readonly _fileCache = new Map<string, IFileCache>();
   private readonly _writeFileCache = new Map<string, string>();
 
+  private readonly _indexFileGenerator?: SdCliIndexFileGenerator;
+
   private _program?: ts.Program;
   private _ngProgram?: NgtscProgram;
   private _builder?: ts.EmitAndSemanticDiagnosticsBuilderProgram;
-  private _ngModuleGenerator?: NgModuleGenerator;
+  private readonly _ngModuleGenerator?: SdCliNgModuleGenerator;
 
   private readonly _tsconfigFilePath: string;
   private readonly _parsedTsconfig: ts.ParsedCommandLine;
-  private readonly _npmConfig: INpmConfig;
+  private readonly _npmConfigMap = new Map<string, INpmConfig>();
 
   private readonly _isAngular: boolean;
 
-  public constructor(private readonly _rootPath: string) {
+  public constructor(private readonly _rootPath: string,
+                     private readonly _config: ISdCliLibPackageConfig,
+                     private readonly _workspaceRootPath: string) {
     super();
+    const npmConfig = this._getNpmConfig(this._rootPath)!;
+
+    // linter
     this._linter = new SdCliPackageLinter(this._rootPath);
 
+    // logger
+    this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name, npmConfig.name]);
+
+    // isAngular
+    this._isAngular = SdCliNpmConfigUtil.getDependencies(npmConfig).defaults.includes("@angular/core");
+
     // tsconfig
     this._tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
     const tsconfig = FsUtil.readJson(this._tsconfigFilePath);
-    this._parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath);
+    this._parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath, this._isAngular ? tsconfig.angularCompilerOptions : undefined);
 
-    // package.json
-    this._npmConfig = FsUtil.readJson(path.resolve(this._rootPath, "package.json"));
+    if (this._isAngular) {
+      // NgModule 생성기 초기화
+      this._ngModuleGenerator = new SdCliNgModuleGenerator(this._rootPath, [
+        "controls",
+        "directives",
+        "guards",
+        "modals",
+        "providers",
+        "app",
+        "pages",
+        "print-templates",
+        "toasts",
+        "AppPage"
+      ], {
+        glob: "**/*Page.ts",
+        fileEndsWith: "Page",
+        rootClassName: "AppPage"
+      });
+    }
 
-    // else
-    this._isAngular = SdCliNpmConfigUtil.getDependencies(this._npmConfig).defaults.includes("@angular/core");
+    // index 생성기 초기화
+    if (this._config.autoIndex) {
+      this._indexFileGenerator = new SdCliIndexFileGenerator(this._rootPath, this._config.autoIndex);
+    }
   }
 
   public override on(event: "change", listener: () => void): this;
@@ -60,32 +93,24 @@ export class SdCliTsLibBuilder extends EventEmitter {
   public async watchAsync(): Promise<void> {
     this.emit("change");
 
-    // DIST 비우기
+    this._logger.debug("dist 폴더 삭제...");
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
-    if (this._isAngular) {
-      // NgModule 생성기 초기화
-      this._ngModuleGenerator = new NgModuleGenerator(this._rootPath, [
-        "controls",
-        "directives",
-        "guards",
-        "modals",
-        "providers",
-        "pages",
-        "print-templates",
-        "toasts"
-      ]);
-
-      // NgModule 타겟 디렉토리 삭제
-      await this._ngModuleGenerator.clearModulesAsync();
-
-      // NgModule 생성
+    if (this._ngModuleGenerator) {
+      this._logger.debug("NgModule 생성...");
       await this._ngModuleGenerator.runAsync();
     }
 
-    // 프로그램 리로드
+    if (this._indexFileGenerator) {
+      this._logger.debug("index.js 생성 및 index.js용 변경감지 시작...");
+      await this._indexFileGenerator.runAsync();
+      await this._indexFileGenerator.watchAsync();
+    }
+
+    this._logger.debug("프로그램 로딩...");
     const buildPack = this._createSdBuildPack(this._parsedTsconfig);
 
+    this._logger.debug("변경감지 구성...");
     const relatedPaths = await this.getAllRelatedPathsAsync();
     const watcher = SdFsWatcher.watch(relatedPaths);
     watcher.onChange({}, async (changeInfos) => {
@@ -95,24 +120,26 @@ export class SdCliTsLibBuilder extends EventEmitter {
       this._logger.debug("파일 변경 감지", changeInfos);
       this.emit("change");
 
-      // 캐쉬 삭제
+      this._logger.debug("변경된 파일의 캐쉬 삭제...");
       for (const changeFilePath of changeFilePaths) {
         this._fileCache.delete(PathUtil.posix(changeFilePath));
       }
 
-      if (this._isAngular) {
-        // NgModule 생성
-        this._ngModuleGenerator!.removeCaches(changeFilePaths);
-        await this._ngModuleGenerator!.runAsync();
+      if (this._ngModuleGenerator) {
+        this._logger.debug("NgModule 생성...");
+        this._ngModuleGenerator.removeCaches(changeFilePaths);
+        await this._ngModuleGenerator.runAsync();
       }
 
       const watchBuildResults: ISdCliPackageBuildResult[] = [];
 
-      // 빌드
+      this._logger.debug("프로그램 로딩...");
       const watchBuildPack = this._createSdBuildPack(this._parsedTsconfig);
+
+      this._logger.debug("빌드...");
       watchBuildResults.push(...await this._runBuilderAsync(watchBuildPack.builder, watchBuildPack.ngCompiler));
 
-      // 린트
+      this._logger.debug("린트...");
       const lintFilePaths = [
         ...watchBuildPack.affectedSourceFiles.map((item) => item.fileName),
         ...changeInfos.filter((item) => ["add", "change"].includes(item.event)).map((item) => item.path)
@@ -121,32 +148,43 @@ export class SdCliTsLibBuilder extends EventEmitter {
         watchBuildResults.push(...await this._linter.lintAsync(lintFilePaths, watchBuildPack.program));
       }
 
+      this._logger.debug("변경감지 대상목록 재구성...");
       const watchRelatedPaths = await this.getAllRelatedPathsAsync();
       watcher.add(watchRelatedPaths);
 
       this.emit("complete", watchBuildResults);
     });
 
-    // 빌드
+    this._logger.debug("빌드...");
     const buildResults = await this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler);
 
-    // 린트
+    this._logger.debug("린트...");
     buildResults.push(...await this._linter.lintAsync(relatedPaths, buildPack.program));
 
     this.emit("complete", buildResults);
   }
 
   public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
-    // DIST 비우기
+    this._logger.debug("dist 폴더 삭제...");
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
-    // 프로그램 리로드
+    if (this._ngModuleGenerator) {
+      this._logger.debug("NgModule 생성...");
+      await this._ngModuleGenerator.runAsync();
+    }
+
+    if (this._indexFileGenerator) {
+      this._logger.debug("index.js 생성...");
+      await this._indexFileGenerator.runAsync();
+    }
+
+    this._logger.debug("프로그램 로딩...");
     const buildPack = this._createSdBuildPack(this._parsedTsconfig);
 
-    // 빌드
+    this._logger.debug("빌드...");
     const buildResults = await this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler);
 
-    // 린트
+    this._logger.debug("린트...");
     const relatedPaths = await this.getAllRelatedPathsAsync();
     buildResults.push(...await this._linter.lintAsync(relatedPaths, buildPack.program));
 
@@ -154,7 +192,16 @@ export class SdCliTsLibBuilder extends EventEmitter {
   }
 
   private async getAllRelatedPathsAsync(): Promise<string[]> {
-    const fileCachePaths = Array.from(this._fileCache.keys());
+    const workspaceNpmConfig = this._getNpmConfig(this._workspaceRootPath)!;
+    const workspaceName = workspaceNpmConfig.name;
+
+    const fileCachePaths = Array.from(this._fileCache.keys())
+      .filter((filePath) => {
+        const workspaceRegex = new RegExp(`node_modules[\\\\/]@${workspaceName}[\\\\/]`);
+        return !filePath.includes("node_modules")
+          || (/node_modules[\\/]@simplysm[\\/]/).test(filePath)
+          || workspaceRegex.test(filePath);
+      });
     const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts)");
     const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
       ignore: [
@@ -249,7 +296,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
         char: undefined,
         code: undefined,
         severity: "error",
-        message: err.message
+        message: err.stack
       }];
     }
   }
@@ -267,6 +314,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
     const affectedSourceFileSet: Set<ts.SourceFile> = new Set<ts.SourceFile>();
     while (true) {
       const result = this._builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+        // this._logger.debug(sourceFile.fileName + " SYNTAX 로딩...");
         if (ngCompiler?.ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith(".ngtypecheck.ts")) {
           const orgFileName = sourceFile.fileName.slice(0, -15) + ".ts";
           const orgSourceFile = this._builder!.getSourceFile(orgFileName);
@@ -281,6 +329,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
       });
       if (!result) break;
 
+      // this._logger.debug((result.affected as ts.SourceFile).fileName + " SYNTAX 로딩");
       affectedSourceFileSet.add(result.affected as ts.SourceFile);
     }
 
@@ -356,6 +405,13 @@ export class SdCliTsLibBuilder extends EventEmitter {
       return compilerHost;
     }
   }
+
+  private _getNpmConfig(pkgPath: string): INpmConfig | undefined {
+    if (!this._npmConfigMap.has(pkgPath)) {
+      this._npmConfigMap.set(pkgPath, FsUtil.readJson(path.resolve(pkgPath, "package.json")));
+    }
+    return this._npmConfigMap.get(pkgPath);
+  }
 }
 
 interface IFileCache {

package/src/commons.ts

@@ -57,11 +57,54 @@ export interface ISdCliServerPackageConfig {
   configs?: Record<string, any>;
   pm2?: Record<string, any> | boolean;
   iis?: { serverExeFilePath?: string } | boolean;
+  externalNodeModules?: string[];
+  publish?: TSdCliPublishConfig;
 }
 
 export interface ISdCliClientPackageConfig {
   type: "client";
+  cordova?: ISdCliClientPackageCordovaConfig;
   server: string;
   env?: Record<string, string>;
   configs?: Record<string, any>;
+  publish?: TSdCliPublishConfig;
 }
+
+export type TSdCliPublishConfig = ISdCliFtpPublishConfig | ISdCliLocalDirectoryPublishConfig;
+
+export interface ISdCliFtpPublishConfig {
+  type: "ftp" | "ftps" | "sftp";
+  host: string;
+  port?: number;
+  path: string;
+  user: string;
+  pass: string;
+}
+
+export interface ISdCliLocalDirectoryPublishConfig {
+  type: "local-directory";
+  path: string;
+}
+
+export interface ISdCliClientPackageCordovaConfig {
+  platforms: TSdCliCordovaPlatform[];
+  appId: string;
+  appName: string;
+  plugins?: string[];
+  icon?: string;
+  buildOption?: {
+    debug?: boolean;
+    bundle?: boolean;
+    sign?: {
+      android?: {
+        keystore: string;
+        storePassword: string;
+        alias: string;
+        password: string;
+        keystoreType: string;
+      };
+    };
+  };
+}
+
+export type TSdCliCordovaPlatform = "browser" | "ios" | "android" | "windows";

package/src/entry-points/SdCliPrepare.ts

@@ -50,6 +50,6 @@ export class SdCliPrepare {
             }
         }`);
     await FsUtil.writeFileAsync(filePath, modifiedFileContent);
-    return fileContent !== modifiedFileContent;
+    return modifiedFileContent.includes("const prevUsage = process.cpuUsage();");
   }
 }