@simplysm/sd-cli 6.4.6 → 7.0.6

package/src/entry-points/SdCliPrepare.ts

@@ -1,104 +0,0 @@
-import { FsUtil, Logger } from "@simplysm/sd-core-node";
-
-export class SdCliPrepare {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
-
-  public async prepareAsync(): Promise<void> {
-    // 타입체크 속도 지연 메시지 추가
-    const r1 = await this._modifyTypescriptCodeForTypeCheckPerformanceWarning();
-    this._logger.log(`[모듈수정] 타입체크 속도 지연 메시지 추가 (${r1 ? "O" : "X"})`);
-
-    //-- 결굴 프로세싱중에 자꾸 'processModule'이 불려서... 문제가 생김
-    // ngcc 동시작업 관련: ng-packagr 무조건 Async
-    // const r2 = await this._modifyNgccProcessorNgPackagrCodeForAsync();
-    // this._logger.log(`[모듈수정] ngcc: 비동기 처리 (${r2 ? "O" : "X"})`);
-
-    // ngcc 동시작업 관련: 대기시간 늘림
-    // const r3 = await this._modifyNgccProcessorConfigurationCodeForLongWaitTime();
-    // this._logger.log(`[모듈수정] ngcc: 대기시간 늘림 (${r3 ? "O" : "X"})`);
-
-    // ngcc 동시작업 관련: 디버깅 메시지 끄기
-    // const r4 = await this._modifyNgccProcessorAsyncLockerCodeForRemoveWaitingMessage();
-    // this._logger.log(`[모듈수정] ngcc: 불필요 메시지 제거 (${r4 ? "O" : "X"})`);
-  }
-
-  private async _modifyTypescriptCodeForTypeCheckPerformanceWarning(): Promise<boolean> {
-    const filePath = require.resolve("typescript");
-    const fileContent = await FsUtil.readFileAsync(filePath);
-    const modifiedFileContent = fileContent.replace(`
-        function checkSourceElement(node) {
-            if (node) {
-                var saveCurrentNode = currentNode;
-                currentNode = node;
-                instantiationCount = 0;
-                checkSourceElementWorker(node);
-                currentNode = saveCurrentNode;
-            }
-        }`, `
-        function checkSourceElement(node) {
-            if (node) {
-                const prevUsage = process.cpuUsage();
-
-                var saveCurrentNode = currentNode;
-                currentNode = node;
-                instantiationCount = 0;
-                checkSourceElementWorker(node);
-                currentNode = saveCurrentNode;
-
-                const usage = process.cpuUsage(prevUsage);
-                if (node.hasChildPerformanceWarning) {
-                    node.parent.hasChildPerformanceWarning = true;
-                }
-                else if (usage.user + usage.system > 2000 * 1000 && node.kind !== 253) {
-                    error(node, {
-                        code: 9000,
-                        category: ts.DiagnosticCategory.Warning,
-                        key: "simplysm_check_source_element_performance_slow",
-                        message: "소스코드 타입분석에 너무 오랜 시간이 소요됩니다. [" + Math.round((usage.user + usage.system) / 1000) + "ms/cpu, KIND: " + node.kind + "]"
-                    });
-                    node.parent.hasChildPerformanceWarning = true;
-                }
-            }
-        }`);
-    await FsUtil.writeFileAsync(filePath, modifiedFileContent);
-    return fileContent !== modifiedFileContent;
-  }
-
-  /*private async _modifyNgccProcessorNgPackagrCodeForAsync(): Promise<boolean> {
-    const filePath = require.resolve("ng-packagr/lib/ngc/ngcc-processor.js");
-    const fileContent = await FsUtil.readFileAsync(filePath);
-    const modifiedFileContent = fileContent.replace(`
-        ngcc_1.process({
-            basePath: this._nodeModulesDirectory`, `
-        ngcc_1.process({
-            async: true,
-            basePath: this._nodeModulesDirectory`);
-    await FsUtil.writeFileAsync(filePath, modifiedFileContent);
-    return fileContent !== modifiedFileContent;
-  }
-
-  private async _modifyNgccProcessorConfigurationCodeForLongWaitTime(): Promise<boolean> {
-    const filePath = require.resolve("@angular/compiler-cli/ngcc/src/packages/configuration.js");
-    const fileContent = await FsUtil.readFileAsync(filePath);
-    const modifiedFileContent = fileContent.replace(`
-        locking: {
-            retryDelay: 500,
-            retryAttempts: 500`, `
-        locking: {
-            retryDelay: 1000,
-            retryAttempts: 10 * 60`); // 10분
-    await FsUtil.writeFileAsync(filePath, modifiedFileContent);
-    return fileContent !== modifiedFileContent;
-  }
-
-  private async _modifyNgccProcessorAsyncLockerCodeForRemoveWaitingMessage(): Promise<boolean> {
-    const filePath = require.resolve("@angular/compiler-cli/ngcc/src/locking/async_locker.js");
-    const fileContent = await FsUtil.readFileAsync(filePath);
-    const modifiedFileContent = fileContent.replace(`
-                                this.logger.info("Another process, with id " + pid + ", is currently running ngcc.\\n" +
-                                    ("Waiting up to " + this.retryDelay * this.retryAttempts / 1000 + "s for it to finish.\\n") +
-                                    ("(If you are sure no ngcc process is running then you should delete the lock-file at " + this.lockFile.path + ".)"));`, ``);
-    await FsUtil.writeFileAsync(filePath, modifiedFileContent);
-    return fileContent !== modifiedFileContent;
-  }*/
-}

package/src/entry-points/SdCliProject.ts

@@ -1,405 +0,0 @@
-import { SdProjectConfigUtil } from "../utils/SdProjectConfigUtil";
-import { FsUtil, Logger, SdProcessManager, SdProcessWorkManager } from "@simplysm/sd-core-node";
-import {
-  INpmConfig,
-  ISdClientPackageConfig,
-  ISdPackageBuildResult,
-  ISdProjectConfig,
-  TSdPackageConfig
-} from "../commons";
-import * as path from "path";
-import { FunctionQueue, StringUtil, Wait } from "@simplysm/sd-core-common";
-import * as os from "os";
-import { NextHandleFunction } from "connect";
-import { SdCliLibraryPackage } from "../packages/SdCliLibraryPackage";
-import { SdCliServerPackage } from "../packages/SdCliServerPackage";
-import { SdCliClientPackage } from "../packages/SdCliClientPackage";
-import { SdCliUnknownPackage } from "../packages/SdCliUnknownPackage";
-import { SdCliLocalUpdater } from "./SdCliLocalUpdater";
-import * as semver from "semver";
-
-// TODO: Cordova
-// TODO: Electron
-export class SdCliProject {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
-
-  public readonly npmConfig: INpmConfig;
-  public readonly npmConfigFilePath: string;
-
-  private readonly _fnQueue = new FunctionQueue();
-  private readonly _serverInfoMap = new Map<string, { middlewares: NextHandleFunction[]; clients: { name: string; platform: string }[]; port?: number; ssl?: boolean }>();
-
-  public constructor(private readonly _rootPath: string) {
-    this.npmConfigFilePath = path.resolve(this._rootPath, "package.json");
-    this.npmConfig = FsUtil.readJson(this.npmConfigFilePath);
-  }
-
-  public async buildAsync(opt: { watch?: boolean; packages?: string[]; options?: string[]; config?: string; skipProcesses?: string[] }): Promise<{ hasError: boolean }> {
-    this._logger.debug("프로젝트 설정 가져오기...");
-    const config = await SdProjectConfigUtil.loadConfigAsync(
-      this._rootPath,
-      opt.watch,
-      opt.options,
-      opt.config
-    );
-
-    if (opt.watch && config.localUpdates) {
-      this._logger.debug("로컬 라이브러리 업데이트 변경감지 시작...");
-      await new SdCliLocalUpdater(this._rootPath).localUpdateAsync(true, opt);
-    }
-
-    this._logger.debug("프로젝트 패키지 목록 구성...");
-    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, opt.skipProcesses ?? []);
-    const pkgs = allPkgs.filter((item) => !(item instanceof SdCliUnknownPackage)) as TSdCliBuildablePackage[];
-
-    this._logger.debug("프로젝트 및 패키지 버전 설정...");
-    if (!opt.watch) {
-      const newVersion = await this._upgradeVersionAsync();
-      await allPkgs.parallelAsync(async (pkg) => {
-        await pkg.setNewVersionAsync(this.npmConfig.name, newVersion);
-      });
-    }
-
-    this._logger.debug("패키지 빌드 이벤트 설정...");
-    let changeCount = 0;
-    const totalResultMap = new Map<string, (ISdPackageBuildResult & { pkgName: string })[]>();
-    for (const pkg of pkgs) {
-      pkg
-        .on("change", (target) => {
-          this._logger.debug(`[${pkg.npmConfig.name}${target !== undefined ? `(${target})` : ""}] 빌드를 시작합니다.`);
-
-          this._fnQueue.run(() => {
-            if (changeCount === 0) {
-              this._logger.log(`빌드를 시작합니다...`);
-            }
-            changeCount++;
-          });
-        })
-        .on("complete", (target, results) => {
-          this._logger.debug(`[${pkg.npmConfig.name}${target !== undefined ? `(${target})` : ""}] 빌드가 완료되었습니다.`);
-
-          this._fnQueue.run(() => {
-            totalResultMap.set(pkg.npmConfig.name + "|_|" + target, results.map((item) => ({
-              ...item,
-              pkgName: pkg.npmConfig.name
-            })));
-
-            setTimeout(() => {
-              changeCount--;
-              if (changeCount === 0) {
-                this._loggingResults(totalResultMap);
-                this._logger.info(`모든 빌드가 완료되었습니다.`);
-                this._loggingOpenClientHrefs();
-              }
-            }, 100);
-          });
-        });
-
-      if (pkg instanceof SdCliServerPackage) {
-        pkg.on("complete", (target, results, server) => {
-          if (server) {
-            const serverInfo = this._serverInfoMap.getOrCreate(pkg.npmConfig.name, {
-              middlewares: [],
-              clients: []
-            });
-            server.middlewares = serverInfo.middlewares;
-            serverInfo.port = server.options.port;
-            serverInfo.ssl = server.options.ssl !== undefined;
-          }
-        });
-      }
-    }
-
-    this._logger.debug("패키지 빌드...");
-    const pkgNames = pkgs.map((item) => item.npmConfig.name);
-
-    this._logger.log(`빌드를 시작합니다...`);
-    changeCount++;
-    const buildCompletedPackageNames: string[] = [];
-
-    let isOnBuildingNgPackage = false; // NGCC 동시오류를 막기위해, 빌드자체를 동시에 못돌게함..
-
-    await pkgs.parallelAsync(async (pkg) => {
-      await this._waitPackageDepCompleteAsync(pkg, pkgNames, buildCompletedPackageNames);
-
-      if (pkg instanceof SdCliClientPackage || (pkg instanceof SdCliLibraryPackage && pkg.config.targets?.includes("angular"))) {
-        await Wait.true(() => !isOnBuildingNgPackage);
-        isOnBuildingNgPackage = true;
-      }
-
-      if (opt.watch) {
-        if (pkg instanceof SdCliClientPackage) {
-          const middlewares = await pkg.watchAsync();
-          if (!StringUtil.isNullOrEmpty(pkg.config.server)) {
-            const serverInfo = this._serverInfoMap.getOrCreate(pkg.config.server, { middlewares: [], clients: [] });
-            serverInfo.middlewares.push(...middlewares);
-            const platforms = pkg.config.platforms?.map((item) => item.type) ?? ["browser"];
-            serverInfo.clients = serverInfo.clients.concat(platforms.map((platform) => ({
-              name: pkg.npmConfig.name.split("/").last()!,
-              platform
-            }))).distinct();
-          }
-        }
-        else {
-          await pkg.watchAsync();
-        }
-      }
-      else {
-        await pkg.buildAsync();
-      }
-      buildCompletedPackageNames.push(pkg.npmConfig.name);
-
-      if (pkg instanceof SdCliClientPackage || (pkg instanceof SdCliLibraryPackage && pkg.config.targets?.includes("angular"))) {
-        isOnBuildingNgPackage = false;
-      }
-    });
-    changeCount--;
-    this._loggingResults(totalResultMap);
-    this._logger.info(`모든 빌드가 완료되었습니다.`);
-    this._loggingOpenClientHrefs();
-
-    return {
-      hasError: Array.from(totalResultMap.values()).mapMany().some((item) => item.severity === "error")
-    };
-  }
-
-
-  public async publishAsync(opt: { build: boolean; packages?: string[]; options?: string[]; config?: string }): Promise<void> {
-    if (!opt.build) {
-      this._logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
-      await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
-    }
-
-    // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
-    if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
-      this._logger.debug(`GIT 커밋여부 확인...`);
-      await SdProcessManager.spawnAsync(
-        "git status",
-        undefined,
-        (message) => {
-          if (message.includes("Changes") || message.includes("Untracked")) {
-            throw new Error("커밋되지 않은 정보가 있습니다.");
-          }
-        },
-        false
-      );
-    }
-
-    this._logger.debug("프로젝트 설정 가져오기...");
-    const config = await SdProjectConfigUtil.loadConfigAsync(
-      this._rootPath,
-      false,
-      opt.options,
-      opt.config
-    );
-
-    this._logger.debug("프로젝트 패키지 목록 구성...");
-    const allPkgs = await this._getAllPackagesAsync(config, opt.packages, []);
-    const pkgs = allPkgs.filter((item) => !(item instanceof SdCliUnknownPackage) && item.config.publish) as TSdCliBuildablePackage[];
-
-    // 빌드가 필요하면 빌드함
-    if (opt.build) {
-      this._logger.debug("빌드 수행...");
-      const buildResult = await this.buildAsync({
-        watch: false,
-        packages: opt.packages,
-        options: opt.options,
-        config: opt.config
-      });
-      if (buildResult.hasError) {
-        throw new Error("빌드중 에러가 발생했습니다.");
-      }
-    }
-
-    // 빌드시엔 빌드에서 버전업했고, 빌드가 아닌경우 여기서 버전업
-    if (!opt.build) {
-      this._logger.debug("프로젝트 및 패키지 버전 설정...");
-      const newVersion = await this._upgradeVersionAsync();
-      await allPkgs.parallelAsync(async (pkg) => {
-        await pkg.setNewVersionAsync(this.npmConfig.name, newVersion);
-      });
-    }
-
-    // GIT 사용중일경우, 새 버전 커밋 및 TAG 생성
-    if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
-      this._logger.debug("새 버전 커밋 및 TAG 생성...");
-      await SdProcessManager.spawnAsync(`git add .`, undefined, false, false);
-      await SdProcessManager.spawnAsync(`git commit -m "v${this.npmConfig.version}"`, undefined, false, false);
-      await SdProcessManager.spawnAsync(`git tag -a "v${this.npmConfig.version}" -m "v${this.npmConfig.version}"`, undefined, false, false);
-    }
-
-    this._logger.debug(`배포 시작...`);
-
-    await pkgs.filter((item) => item.config.publish === "npm").parallelAsync(async (pkg) => {
-      await pkg.publishAsync();
-    });
-
-    for (const pkg of pkgs.filter((item) => item.config.publish !== "npm")) {
-      await pkg.publishAsync();
-    }
-
-    this._logger.info(`배포 프로세스가 완료되었습니다.(v${this.npmConfig.version})`);
-  }
-
-  private async _waitSecMessageAsync(msg: string, sec: number): Promise<void> {
-    for (let i = sec; i > 0; i--) {
-      if (i !== sec) {
-        process.stdout.cursorTo(0);
-      }
-      process.stdout.write(msg + " " + i);
-      await Wait.time(1000);
-    }
-
-    process.stdout.cursorTo(0);
-    process.stdout.clearLine(0);
-  }
-
-  private _loggingOpenClientHrefs(): void {
-    const clientHrefs = Array.from(this._serverInfoMap.values()).mapMany((serverInfo) => serverInfo.clients.map((client) => {
-      const protocolStr = serverInfo.ssl ? "https://" : "http://";
-      const portStr = serverInfo.port !== undefined ? `:${serverInfo.port}` : "";
-      let result = protocolStr + "localhost" + portStr + "/";
-      if (client.platform !== "browser") {
-        result += `__${client.platform}/`;
-      }
-      return result + client.name + "/";
-    }));
-    if (clientHrefs.length > 0) {
-      this._logger.log(`오픈된 클라이언트: ${clientHrefs.join(", ")}`);
-    }
-  }
-
-  private async _getAllPackagesAsync(config: ISdProjectConfig, packages: string[] | undefined, skipProcesses: string[]): Promise<TSdCliPackage[]> {
-    // package.json에서 workspaces를 통해 패키지 경로 목록 가져오기
-    const allPkgPaths = await this.npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
-    if (!allPkgPaths) {
-      throw new Error("프로젝트의 'package.json'에서 'workspaces'를 찾을 수 없습니다.");
-    }
-
-    // 모든 패키지의 설정 가져오기
-    const allPackageInfos: { rootPath: string; name: string; config: TSdPackageConfig | undefined }[] = [];
-    for (const pkgPath of allPkgPaths) {
-      // 패키지 package.json
-      const pkgNpmConfigFilePath = path.resolve(pkgPath, "package.json");
-      if (!FsUtil.exists(pkgNpmConfigFilePath)) continue; // package.json파일이 없는 폴더는 무시
-      const pkgNpmConfig: INpmConfig = await FsUtil.readJsonAsync(pkgNpmConfigFilePath);
-
-      // 패키지 설정
-      const pkgName = pkgNpmConfig.name;
-      const pkgConfig = config.packages[pkgName];
-
-      // 사용할 패키지로 설정하지 않은 패키지면 타입을 'none'으로 강제
-      if (packages && packages.length > 0 && !packages.includes(pkgName)) {
-        allPackageInfos.push({ rootPath: pkgPath, name: pkgName, config: undefined });
-      }
-      else {
-        allPackageInfos.push({ rootPath: pkgPath, name: pkgName, config: pkgConfig });
-      }
-    }
-
-    // 각 package를 위한 worker 준비
-    /*const workerCount = allPackageInfos.sum((item) => {
-      if (item.config && item.config.type === "library") {
-        return item.config.targets?.length ?? 1;
-      }
-      return 0;
-    });*/
-
-    const processWorkManager = await SdProcessWorkManager.createAsync(
-      path.resolve(__dirname, `../workers/lib-build-worker`),
-      [],
-      this._logger,
-      undefined,
-      Math.max(os.cpus().length / 2, 1)
-    );
-
-    // 패키지 목록 구성
-    const pkgs: TSdCliPackage[] = [];
-    for (const pkgInfo of allPackageInfos) {
-      if (pkgInfo.config?.type === "library") {
-        pkgs.push(new SdCliLibraryPackage(pkgInfo.rootPath, pkgInfo.config, skipProcesses as any, processWorkManager));
-      }
-      else if (pkgInfo.config?.type === "client") {
-        const serverPkgInfo = allPackageInfos.single((item) => item.name === (pkgInfo.config as ISdClientPackageConfig).server);
-        pkgs.push(new SdCliClientPackage(pkgInfo.rootPath, pkgInfo.config, skipProcesses as any, serverPkgInfo?.rootPath));
-      }
-      else if (pkgInfo.config?.type === "server") {
-        pkgs.push(new SdCliServerPackage(pkgInfo.rootPath, pkgInfo.config, skipProcesses as any));
-      }
-      else {
-        pkgs.push(new SdCliUnknownPackage(pkgInfo.rootPath));
-      }
-    }
-
-    return pkgs;
-  }
-
-  private async _waitPackageDepCompleteAsync(pkg: TSdCliPackage, pkgNames: string[], completedPkgNames: string[]): Promise<void> {
-    // 패키지의 의존성 패키지 중에 빌드해야할 패키지 목록에 이미 있는 의존성 패키지만 추리기
-    const depNames = [
-      ...Object.keys(pkg.npmConfig.dependencies ?? {}),
-      ...Object.keys(pkg.npmConfig.optionalDependencies ?? {}),
-      ...Object.keys(pkg.npmConfig.devDependencies ?? {}),
-      ...Object.keys(pkg.npmConfig.peerDependencies ?? {})
-    ].distinct().filter((dep) => pkgNames.includes(dep));
-
-    // 추려진 의존성 패키지별로 의존성 패키지의 빌드가 완료될때까지 기다리기
-    await depNames.parallelAsync(async (depName) => {
-      await Wait.true(() => completedPkgNames.includes(depName));
-    });
-  }
-
-  private _loggingResults(totalResultMap: Map<string, (ISdPackageBuildResult & { pkgName: string })[]>): void {
-    const totalResults = Array.from(totalResultMap.values()).mapMany();
-
-    const warnings = totalResults
-      .filter((item) => item.severity === "warning")
-      .map((item) => item.message.trim() + " (" + item.pkgName + ")")
-      .distinct();
-
-    const errors = totalResults
-      .filter((item) => item.severity === "error")
-      .map((item) => item.message.trim() + " (" + item.pkgName + ")")
-      .distinct();
-
-    if (warnings.length > 0) {
-      this._logger.warn(`경고 발생${os.EOL}`, warnings.join(os.EOL));
-    }
-    if (errors.length > 0) {
-      this._logger.error(`오류 발생${os.EOL}`, errors.join(os.EOL));
-    }
-
-    if (errors.length > 0) {
-      this._logger.error(`경고: ${warnings.length}건, 오류: ${errors.length}건`);
-    }
-    else if (warnings.length > 0) {
-      this._logger.warn(`경고: ${warnings.length}건, 오류: ${errors.length}건`);
-    }
-  }
-
-  private async _upgradeVersionAsync(): Promise<string> {
-    // 프로젝트 및 패키지 버전 업
-    const newVersion = semver.inc(this.npmConfig.version, "patch")!;
-    this.npmConfig.version = newVersion;
-
-    const updateDepVersion = (deps: Record<string, string> | undefined): void => {
-      if (!deps) return;
-      for (const dependencyName of Object.keys(deps)) {
-        if (dependencyName.startsWith("@" + this.npmConfig.name + "/")) {
-          deps[dependencyName] = newVersion;
-        }
-      }
-    };
-    updateDepVersion(this.npmConfig.dependencies);
-    updateDepVersion(this.npmConfig.optionalDependencies);
-    updateDepVersion(this.npmConfig.devDependencies);
-    updateDepVersion(this.npmConfig.peerDependencies);
-
-    await FsUtil.writeJsonAsync(this.npmConfigFilePath, this.npmConfig, { space: 2 });
-
-    return newVersion;
-  }
-}
-
-type TSdCliPackage = SdCliLibraryPackage | SdCliServerPackage | SdCliClientPackage | SdCliUnknownPackage;
-type TSdCliBuildablePackage = SdCliLibraryPackage | SdCliServerPackage | SdCliClientPackage;

package/src/packages/SdCliClientPackage.ts

@@ -1,111 +0,0 @@
-import { FsUtil } from "@simplysm/sd-core-node";
-import { ISdClientPackageConfig, ISdPackageBuildResult, ITsconfig } from "../commons";
-import * as path from "path";
-import { ObjectUtil } from "@simplysm/sd-core-common";
-import { SdCliNgClientBuilder } from "../builders/SdCliNgClientBuilder";
-import { NextHandleFunction } from "connect";
-import { SdCliPackageBase } from "./SdCliPackageBase";
-import { SdCliPublisher } from "../builders/SdCliPublisher";
-
-export class SdCliClientPackage extends SdCliPackageBase {
-  public on(event: "change", listener: (target: "node" | "browser" | undefined) => void): this;
-  public on(event: "complete", listener: (target: "node" | "browser" | undefined, results: ISdPackageBuildResult[]) => void): this;
-  public on(event: string | symbol, listener: (...args: any[]) => void): this {
-    return super.on(event, listener);
-  }
-
-  public constructor(public readonly rootPath: string,
-                     public readonly config: ISdClientPackageConfig,
-                     public readonly skipProcesses: ("lint" | "genNgModule")[],
-                     public readonly _serverPath?: string) {
-    super(rootPath);
-  }
-
-  public async buildAsync(): Promise<void> {
-    await this._genBuildTsconfigAsync();
-
-    const targets = this.config.platforms?.map((item) => item.type) ?? ["browser"];
-
-    const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);
-
-    await targets.parallelAsync(async (target) => {
-      const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, target, this.skipProcesses);
-
-      await builder
-        .on("change", () => {
-          this.emit("change", target);
-        })
-        .on("complete", (results) => {
-          this.emit("complete", target, results);
-        })
-        .buildAsync();
-    });
-  }
-
-  public async watchAsync(): Promise<NextHandleFunction[]> {
-    await this._genBuildTsconfigAsync();
-
-    const targets = this.config.platforms?.map((item) => item.type) ?? ["browser"];
-
-    const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);
-    const handlersArray = await targets.parallelAsync(async (target) => {
-      const builder = new SdCliNgClientBuilder(this.rootPath, buildTsconfigFilePath, process.cwd(), this.config, target, this.skipProcesses);
-
-      return await builder
-        .on("change", () => {
-          this.emit("change", target);
-        })
-        .on("complete", (results) => {
-          this.emit("complete", target, results);
-        })
-        .watchAsync(this._serverPath);
-    });
-
-    return handlersArray.mapMany();
-  }
-
-  public async publishAsync(): Promise<void> {
-    if (this.config.publish) {
-      const publisher = new SdCliPublisher(
-        this.config.publish,
-        path.resolve(this.rootPath, "dist"),
-        this.npmConfig.version
-      );
-      await publisher.runAsync();
-    }
-  }
-
-  private async _genBuildTsconfigAsync(): Promise<void> {
-    const baseTsconfigFilePath = path.resolve(this.rootPath, "tsconfig.json");
-    const baseTsconfig: ITsconfig = await FsUtil.readJsonAsync(baseTsconfigFilePath);
-
-    const buildTsconfig: ITsconfig = ObjectUtil.clone(baseTsconfig);
-
-    buildTsconfig.compilerOptions = buildTsconfig.compilerOptions ?? {};
-    delete buildTsconfig.compilerOptions.baseUrl;
-    delete buildTsconfig.compilerOptions.paths;
-    delete buildTsconfig.compilerOptions.declarationDir;
-    buildTsconfig.compilerOptions = {
-      ...buildTsconfig.compilerOptions,
-      module: "es2020",
-      target: "es2015",
-      lib: ["es2015", "dom"],
-      outDir: "dist",
-      declaration: false,
-      baseUrl: this.rootPath
-    };
-
-    buildTsconfig.angularCompilerOptions = {
-      ...buildTsconfig.angularCompilerOptions ?? {},
-      enableI18nLegacyMessageIdFormat: false,
-      strictInjectionParameters: true,
-      strictInputAccessModifiers: true,
-      strictTemplates: true,
-      strictInputTypes: false,
-      strictOutputEventTypes: false
-    };
-
-    const buildTsconfigFilePath = path.resolve(this.rootPath, `sd-tsconfig.json`);
-    await FsUtil.writeJsonAsync(buildTsconfigFilePath, buildTsconfig, { space: 2 });
-  }
-}