@simplysm/sd-cli 7.0.65 → 7.0.66

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: [
@@ -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

@@ -61,7 +61,31 @@ export interface ISdCliServerPackageConfig {
 
 export interface ISdCliClientPackageConfig {
   type: "client";
+  cordova?: ISdCliClientPackageCordovaConfig;
   server: string;
   env?: Record<string, string>;
   configs?: Record<string, any>;
 }
+
+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/SdCliWorkspace.ts

@@ -11,7 +11,6 @@ import { SdServiceServer } from "@simplysm/sd-service-server";
 import { SdCliNpm } from "./SdCliNpm";
 import { SdCliLocalUpdate } from "./SdCliLocalUpdate";
 import { NextHandleFunction } from "connect";
-import { SdCliIndexFileGenerator } from "./SdCliIndexFileGenerator";
 
 export class SdCliWorkspace {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -36,13 +35,6 @@ export class SdCliWorkspace {
     this._logger.debug("패키지 목록 구성...");
     const pkgs = await this._getPackagesAsync(config);
 
-    this._logger.debug("패키지 인덱스 생성기 실행...");
-    await pkgs.parallelAsync(async (pkg) => {
-      if (pkg.config.type === "library" && pkg.config.autoIndex) {
-        await new SdCliIndexFileGenerator(pkg.rootPath, pkg.config.autoIndex).watchAsync();
-      }
-    });
-
     this._logger.debug("패키지 이벤트 설정...");
     let changeCount = 0;
     const totalResultMap = new Map<string, ISdCliPackageBuildResult[]>();
@@ -74,7 +66,12 @@ export class SdCliWorkspace {
         });
     }
 
-    this._logger.debug("빌드를 시작합니다...");
+
+    if (changeCount === 0) {
+      this._logger.log("빌드를 시작합니다...");
+    }
+    changeCount++;
+
     const pkgNames = pkgs.map((item) => item.name);
     const buildCompletedPackageNames: string[] = [];
     await pkgs.parallelAsync(async (pkg) => {
@@ -91,6 +88,13 @@ export class SdCliWorkspace {
       }
       buildCompletedPackageNames.push(pkg.name);
     });
+
+    changeCount--;
+    if (changeCount === 0) {
+      this._loggingResults(totalResultMap);
+      this._loggingOpenClientHrefs();
+      this._logger.info("모든 빌드가 완료되었습니다.");
+    }
   }
 
   private _isServerRestarting = false;
@@ -118,7 +122,7 @@ export class SdCliWorkspace {
         delete serverInfo.server;
       }
 
-      serverInfo.server = (await import("file:///" + entryFilePath + "?update=" + Uuid.new().toString())).default as SdServiceServer | undefined;
+      serverInfo.server = (await import("file:///" + entryFilePath + "?update=" + Uuid.new().toString())).default.default as SdServiceServer | undefined;
       if (!serverInfo.server) {
         this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
         this._isServerRestarting = false;
@@ -143,13 +147,6 @@ export class SdCliWorkspace {
     this._logger.debug("패키지 목록 구성...");
     const pkgs = await this._getPackagesAsync(config);
 
-    this._logger.debug("패키지 인덱스 생성기 실행...");
-    await pkgs.parallelAsync(async (pkg) => {
-      if (pkg.config.type === "library" && pkg.config.autoIndex) {
-        await new SdCliIndexFileGenerator(pkg.rootPath, pkg.config.autoIndex).runAsync();
-      }
-    });
-
     this._logger.debug("프로젝트 및 패키지 버전 설정...");
     await this._upgradeVersionAsync(pkgs);
 

package/src/index.ts

@@ -1,4 +1,6 @@
 export * from "./build-tool/SdCliCacheCompilerHost";
+export * from "./build-tool/SdCliCordova";
+export * from "./build-tool/SdCliIndexFileGenerator";
 export * from "./build-tool/SdCliNgCacheCompilerHost";
 export * from "./build-tool/SdCliPackageLinter";
 export * from "./builder/SdCliClientBuilder";
@@ -6,7 +8,6 @@ export * from "./builder/SdCliJsLibBuilder";
 export * from "./builder/SdCliServerBuilder";
 export * from "./builder/SdCliTsLibBuilder";
 export * from "./commons";
-export * from "./entry-points/SdCliIndexFileGenerator";
 export * from "./entry-points/SdCliLocalUpdate";
 export * from "./entry-points/SdCliNpm";
 export * from "./entry-points/SdCliPrepare";
@@ -17,9 +18,10 @@ export * from "./ng-tools/babel/SdCliBbUtil";
 export * from "./ng-tools/babel/TSdCliBbNgMetadata";
 export * from "./ng-tools/babel/TSdCliBbTypeMetadata";
 export * from "./ng-tools/commons";
-export * from "./ng-tools/NgModuleGenerator";
+export * from "./ng-tools/SdCliNgModuleGenerator";
 export * from "./ng-tools/typescript/SdCliTsFileMetadata";
 export * from "./ng-tools/typescript/SdCliTsRootMetadata";
+export * from "./ng-tools/typescript/SdCliTsUtil";
 export * from "./packages/SdCliPackage";
 export * from "./SdCliBuildResultError";
 export * from "./utils/SdCliBuildResultUtil";