@simplysm/sd-cli 7.3.2 → 10.0.4

package/src/builder/SdCliTsLibBuilder.ts

@@ -1,450 +0,0 @@
-import { INpmConfig, ISdCliLibPackageConfig, ISdCliPackageBuildResult } from "../commons";
-import { EventEmitter } from "events";
-import ts from "typescript";
-import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
-import path from "path";
-import { createHash } from "crypto";
-import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
-import { NgtscProgram } from "@angular/compiler-cli";
-import * as sass from "sass";
-import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
-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 { SdCliNgModuleGenerator } from "../ng-tools/SdCliNgModuleGenerator";
-import { SdCliIndexFileGenerator } from "../build-tool/SdCliIndexFileGenerator";
-
-export class SdCliTsLibBuilder extends EventEmitter {
-  private readonly _logger: Logger;
-
-  private _moduleResolutionCache?: ts.ModuleResolutionCache;
-
-  private readonly _linter: SdCliPackageLinter;
-
-  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 readonly _ngModuleGenerator?: SdCliNgModuleGenerator;
-
-  private readonly _tsconfigFilePath: string;
-  private readonly _parsedTsconfig: ts.ParsedCommandLine;
-  private readonly _npmConfigMap = new Map<string, INpmConfig>();
-
-  private readonly _isAngular: boolean;
-  private readonly _hasAngularRoute: boolean;
-
-  public constructor(private readonly _rootPath: string,
-                     private readonly _config: ISdCliLibPackageConfig,
-                     private readonly _projRootPath: 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 = !!this._config.angular;
-    this._hasAngularRoute = SdCliNpmConfigUtil.getDependencies(npmConfig).defaults.includes("@angular/router");
-
-    // 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._isAngular ? tsconfig.angularCompilerOptions : undefined);
-
-    if (this._isAngular) {
-      // NgModule 생성기 초기화
-      this._ngModuleGenerator = new SdCliNgModuleGenerator(this._rootPath, [
-        "controls",
-        "directives",
-        "guards",
-        "modals",
-        "providers",
-        "app",
-        "pages",
-        "print-templates",
-        "toasts",
-        "AppPage"
-      ], this._hasAngularRoute ? {
-        glob: "**/*Page.ts",
-        fileEndsWith: "Page",
-        rootClassName: "AppPage"
-      } : undefined);
-    }
-
-    // index 생성기 초기화
-    if (this._config.autoIndex) {
-      this._indexFileGenerator = new SdCliIndexFileGenerator(this._rootPath, this._config.autoIndex);
-    }
-  }
-
-  public override on(event: "change", listener: () => void): this;
-  public override on(event: "complete", listener: (results: ISdCliPackageBuildResult[]) => void): this;
-  public override on(event: string | symbol, listener: (...args: any[]) => void): this {
-    return super.on(event, listener);
-  }
-
-  public async watchAsync(): Promise<void> {
-    this.emit("change");
-
-    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 생성 및 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 (changedInfos) => {
-      const changeFilePaths = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
-      if (changeFilePaths.length === 0) return;
-
-      this._logger.debug("파일 변경 감지", changeFilePaths);
-      this.emit("change");
-
-      this._logger.debug("변경된 파일의 캐쉬 삭제...");
-      for (const changeFilePath of changeFilePaths) {
-        const fileCache = this._fileCache.get(PathUtil.posix(changeFilePath));
-        if (fileCache) {
-          if (fileCache.importerSet) {
-            for (const importer of fileCache.importerSet.values()) {
-              this._fileCache.delete(importer);
-            }
-          }
-
-          this._fileCache.delete(PathUtil.posix(changeFilePath));
-        }
-      }
-
-      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);
-
-      const promises: Promise<ISdCliPackageBuildResult[]>[] = [];
-
-      // 빌드
-      promises.push(this._runBuilderAsync(watchBuildPack.builder, watchBuildPack.ngCompiler));
-      // watchBuildResults.push(...await this._runBuilderAsync(watchBuildPack.builder, watchBuildPack.ngCompiler));
-
-      // 린트
-      const lintFilePaths = [
-        ...watchBuildPack.affectedSourceFiles.map((item) => item.fileName),
-        ...changedInfos.filter((item) => ["add", "change"].includes(item.event)).map((item) => item.path)
-      ];
-      if (lintFilePaths.length > 0) {
-        promises.push(this._linter.lintAsync(lintFilePaths, watchBuildPack.program));
-        // watchBuildResults.push(...await this._linter.lintAsync(lintFilePaths, watchBuildPack.program));
-      }
-
-      this._logger.debug("빌드...");
-      watchBuildResults.push(...(await Promise.all(promises)).mapMany());
-
-      this._logger.debug("변경감지 대상목록 재구성...");
-      const watchRelatedPaths = await this.getAllRelatedPathsAsync();
-      watcher.add(watchRelatedPaths);
-
-      this.emit("complete", watchBuildResults);
-    });
-
-    this._logger.debug("빌드...");
-    const buildResults = (await Promise.all([
-      this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler),
-      this._linter.lintAsync(relatedPaths, buildPack.program)
-    ].filterExists())).mapMany();
-
-    this._logger.debug("변경감지 대상목록 재구성...");
-    const watchRelatedPaths = await this.getAllRelatedPathsAsync();
-    watcher.add(watchRelatedPaths);
-
-    this.emit("complete", buildResults);
-  }
-
-  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
-    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 relatedPaths = await this.getAllRelatedPathsAsync();
-    return (await Promise.all([
-      this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler),
-      this._linter.lintAsync(relatedPaths, buildPack.program)
-    ].filterExists())).mapMany();
-  }
-
-  private async getAllRelatedPathsAsync(): Promise<string[]> {
-    const projNpmConfig = this._getNpmConfig(this._projRootPath)!;
-    const projName = projNpmConfig.name;
-
-    const fileCachePaths = Array.from(this._fileCache.keys())
-      .filter((filePath) => {
-        const projRegex = new RegExp(`node_modules[\\\\/]@${projName}[\\\\/]`);
-        return !filePath.includes("node_modules")
-          || (/node_modules[\\/]@simplysm[\\/]/).test(filePath)
-          || projRegex.test(filePath);
-      });
-    const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts|*.scss)");
-    const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
-      ignore: [
-        "**/node_modules/**",
-        "**/dist/**",
-        "**/.*/**"
-      ]
-    });
-
-    return [...fileCachePaths, ...mySourceFilePaths, path.resolve(this._rootPath, ".eslintrc.cjs")].distinct();
-  }
-
-  private async _runBuilderAsync(builder: ts.EmitAndSemanticDiagnosticsBuilderProgram, ngCompiler?: NgCompiler): Promise<ISdCliPackageBuildResult[]> {
-    try {
-      const results: ISdCliPackageBuildResult[] = [];
-
-      const diagnostics: ts.Diagnostic[] = [];
-
-      if (ngCompiler) {
-        diagnostics.push(...ngCompiler.getOptionDiagnostics());
-      }
-
-      diagnostics.push(
-        ...builder.getOptionsDiagnostics(),
-        ...builder.getGlobalDiagnostics()
-      );
-
-      if (ngCompiler) {
-        await ngCompiler.analyzeAsync();
-      }
-
-      for (const sourceFile of builder.getSourceFiles()) {
-        if (ngCompiler?.ignoreForDiagnostics.has(sourceFile)) continue;
-
-        diagnostics.push(
-          ...builder.getSyntacticDiagnostics(sourceFile),
-          ...builder.getSemanticDiagnostics(sourceFile)
-        );
-
-        if (
-          ngCompiler &&
-          !sourceFile.isDeclarationFile &&
-          !ngCompiler.ignoreForEmit.has(sourceFile) &&
-          !ngCompiler.incrementalDriver.safeToSkipEmit(sourceFile)
-        ) {
-          diagnostics.push(
-            ...ngCompiler.getDiagnosticsForFile(sourceFile, 1)
-          );
-        }
-      }
-
-      results.push(
-        ...diagnostics
-          .filter((item) => [ts.DiagnosticCategory.Error, ts.DiagnosticCategory.Warning].includes(item.category))
-          .map((item) => SdCliBuildResultUtil.convertFromTsDiag(item))
-          .filterExists()
-      );
-
-      if (results.some((item) => item.severity === "error")) {
-        return results;
-      }
-
-      const transformers = ngCompiler?.prepareEmit().transformers;
-      for (const sourceFile of builder.getSourceFiles()) {
-        if (ngCompiler?.ignoreForEmit.has(sourceFile)) continue;
-        builder.emit(sourceFile, undefined, undefined, undefined, transformers);
-      }
-
-      return results;
-    }
-    catch (err) {
-      if (err instanceof sass.Exception) {
-        const matches = (/^(.*\.sd\.scss) ([0-9]*):([0-9]*)/).exec(err.sassStack)!;
-        const filePath = path.resolve(matches[1].replace(/\.sd\.scss/, "").replace(/^\.:/, item => item.toUpperCase()));
-        const scssLine = matches[2];
-        const scssChar = matches[3];
-        const message = err.sassMessage;
-
-        return [{
-          filePath,
-          line: undefined,
-          char: undefined,
-          code: undefined,
-          severity: "error",
-          message: `스타일(${scssLine}:${scssChar}): ${message}\n${err.message}`
-        }];
-      }
-
-      return [{
-        filePath: undefined,
-        line: undefined,
-        char: undefined,
-        code: undefined,
-        severity: "error",
-        message: err.stack
-      }];
-    }
-  }
-
-  private _createSdBuildPack(parsedTsconfig: ts.ParsedCommandLine): ISdBuildPack {
-    const compilerHost = this._createCacheCompilerHost(parsedTsconfig);
-    const { program, ngCompiler } = this._createProgram(parsedTsconfig, compilerHost);
-
-    this._builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(
-      program,
-      compilerHost,
-      this._builder
-    );
-
-    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);
-          if (orgSourceFile) {
-            affectedSourceFileSet.add(orgSourceFile);
-          }
-
-          return true;
-        }
-
-        return false;
-      });
-      if (!result) break;
-
-      // this._logger.debug((result.affected as ts.SourceFile).fileName + " SYNTAX 로딩");
-      affectedSourceFileSet.add(result.affected as ts.SourceFile);
-    }
-
-    return {
-      program,
-      ngCompiler,
-      builder: this._builder,
-      affectedSourceFiles: Array.from(affectedSourceFileSet.values())
-    };
-  }
-
-  private _createProgram(parsedTsconfig: ts.ParsedCommandLine, compilerHost: ts.CompilerHost): { program: ts.Program; ngCompiler?: NgCompiler } {
-    if (this._isAngular) {
-      this._ngProgram = new NgtscProgram(
-        parsedTsconfig.fileNames,
-        parsedTsconfig.options,
-        compilerHost,
-        this._ngProgram
-      );
-      this._program = this._ngProgram.getTsProgram();
-
-      this._configProgramSourceFileVersions(this._program);
-      return {
-        program: this._program,
-        ngCompiler: this._ngProgram.compiler
-      };
-    }
-    else {
-      this._program = ts.createProgram(
-        parsedTsconfig.fileNames,
-        parsedTsconfig.options,
-        compilerHost,
-        this._program
-      );
-
-      this._configProgramSourceFileVersions(this._program);
-
-      return { program: this._program };
-    }
-  }
-
-  private _configProgramSourceFileVersions(program: ts.Program): void {
-    const baseGetSourceFiles = program.getSourceFiles;
-    program.getSourceFiles = function (...parameters) {
-      const files: readonly (ts.SourceFile & { version?: string })[] = baseGetSourceFiles(...parameters);
-
-      for (const file of files) {
-        if (file.version === undefined) {
-          file.version = createHash("sha256").update(file.text).digest("hex");
-        }
-      }
-
-      return files;
-    };
-  }
-
-  private _createCacheCompilerHost(parsedTsconfig: ts.ParsedCommandLine): ts.CompilerHost {
-    if (!this._moduleResolutionCache) {
-      this._moduleResolutionCache = ts.createModuleResolutionCache(this._rootPath, (s) => s, parsedTsconfig.options);
-    }
-
-    const compilerHost = SdCliCacheCompilerHost.create(
-      parsedTsconfig,
-      this._moduleResolutionCache,
-      this._fileCache,
-      this._writeFileCache
-    );
-
-    if (this._isAngular) {
-      return SdCliNgCacheCompilerHost.wrap(compilerHost, this._fileCache);
-    }
-    else {
-      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 {
-  exists?: boolean;
-  sourceFile?: ts.SourceFile;
-  content?: string;
-  styleContent?: string;
-  importerSet?: Set<string>;
-}
-
-interface ISdBuildPack {
-  program: ts.Program;
-  ngCompiler?: NgCompiler;
-  builder: ts.EmitAndSemanticDiagnosticsBuilderProgram;
-  affectedSourceFiles: ts.SourceFile[];
-}

package/src/entry-points/SdCliFileCrypto.ts

@@ -1,87 +0,0 @@
-import readline from "readline";
-import { Writable } from "stream";
-import crypto from "crypto";
-import { FsUtil } from "@simplysm/sd-core-node";
-import os from "os";
-
-export class SdCliFileCrypto {
-  public async encryptAsync(filePath: string): Promise<void> {
-    if (!FsUtil.exists(filePath)) {
-      throw new Error(`파일 '${filePath}'을 찾을 수 없습니다.`);
-    }
-
-    const key = await this._readKeyAsync("password: ");
-    if (!key) {
-      throw new Error("암호화키를 반드시 입력해야 합니다.");
-    }
-
-    const confirmKey = await this._readKeyAsync("confirm password: ");
-    if (key !== confirmKey) {
-      throw new Error("암호화키가 서로 다릅니다.");
-    }
-
-    this._encryptFile(filePath, key, filePath + ".enc");
-  }
-
-  public async decryptAsync(encFilePath: string): Promise<void> {
-    if (!FsUtil.exists(encFilePath)) {
-      throw new Error(`파일 '${encFilePath}'을 찾을 수 없습니다.`);
-    }
-
-    if (!encFilePath.endsWith(".enc")) {
-      throw new Error(`파일 ${encFilePath}의 확장자가 '.enc'가 아닙니다.`);
-    }
-
-    const resultFilePath = encFilePath.slice(0, -4);
-    if (FsUtil.exists(resultFilePath)) {
-      process.stdout.write(`복호화 시, 현재 존재하는 '${resultFilePath}'파일을 덮어씁니다.${os.EOL}`, "utf-8");
-    }
-
-    const key = await this._readKeyAsync("password: ");
-    if (!key) {
-      throw new Error("암호화키를 반드시 입력해야 합니다.");
-    }
-
-    this._decryptFile(encFilePath, key, resultFilePath);
-  }
-
-  private _encryptFile(filePath: string, key: string, encFilePath: string): void {
-    const iv = Buffer.alloc(16, 0);
-    const cipheriv = crypto.createCipheriv("aes-192-cbc", crypto.scryptSync(key, "salt", 24), iv);
-
-    const input = FsUtil.createReadStream(filePath);
-    const output = FsUtil.createWriteStream(encFilePath);
-    input.pipe(cipheriv).pipe(output);
-  }
-
-  private _decryptFile(encFilePath: string, key: string, filePath: string): void {
-    const iv = Buffer.alloc(16, 0);
-    const cipheriv = crypto.createDecipheriv("aes-192-cbc", crypto.scryptSync(key, "salt", 24), iv);
-
-    const input = FsUtil.createReadStream(encFilePath);
-    const output = FsUtil.createWriteStream(filePath);
-    input.pipe(cipheriv).pipe(output);
-  }
-
-  private async _readKeyAsync(message: string): Promise<string> {
-    process.stdout.write(message, "utf-8");
-
-    return await new Promise((resolve) => {
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: new Writable({
-          write: (chunk, encoding, callback) => {
-            callback();
-          }
-        }),
-        terminal: true
-      });
-
-      rl.question(message, (answer) => {
-        process.stdout.write(os.EOL, "utf-8");
-        resolve(answer);
-        rl.close();
-      });
-    });
-  }
-}

package/src/entry-points/SdCliLocalUpdate.ts

@@ -1,121 +0,0 @@
-import { SdCliConfigUtil } from "../utils/SdCliConfigUtil";
-import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
-import path from "path";
-
-export class SdCliLocalUpdate {
-  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
-
-  public constructor(private readonly _rootPath: string) {
-  }
-
-  public async runAsync(opt: { confFileRelPath: string }): Promise<void> {
-    this._logger.debug("프로젝트 설정 가져오기...");
-    const conf = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false);
-    if (!conf.localUpdates) return;
-
-    const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
-    this._logger.debug("로컬 업데이트 구성", updatePathInfos);
-
-    this._logger.log("로컬 라이브러리 업데이트 시작...");
-    for (const updatePathInfo of updatePathInfos) {
-      if (!FsUtil.exists(updatePathInfo.source)) {
-        this._logger.warn(`소스경로를 찾을 수 없어 무시됩니다(${updatePathInfo.source})`);
-        return;
-      }
-
-      // 소스경로에서 대상경로로 파일 복사
-      await FsUtil.copyAsync(updatePathInfo.source, updatePathInfo.target, (src) => {
-        return !src.includes("node_modules") && !src.endsWith("package.json");
-      });
-    }
-    this._logger.info("로컬 라이브러리 업데이트 완료");
-  }
-
-  public async watchAsync(opt: { confFileRelPath: string }): Promise<void> {
-    this._logger.debug("프로젝트 설정 가져오기...");
-    const conf = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false);
-    if (!conf.localUpdates) return;
-
-    const updatePathInfos = await this._getUpdatePathInfosAsync(conf.localUpdates);
-    this._logger.debug("로컬 업데이트 구성");
-
-    const watchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
-
-    const watcher = SdFsWatcher.watch(watchPaths);
-    watcher.onChange({ delay: 1000 }, async (changedInfos) => {
-      const changeFilePaths = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
-      if (changeFilePaths.length === 0) return;
-
-      this._logger.log("로컬 라이브러리 변경감지...");
-      for (const changedFilePath of changeFilePaths) {
-        if (!FsUtil.exists(changedFilePath)) continue;
-
-        for (const updatePathInfo of updatePathInfos) {
-          if (!PathUtil.isChildPath(changedFilePath, updatePathInfo.source)) continue;
-
-          const sourceRelPath = path.relative(updatePathInfo.source, changedFilePath);
-          if (sourceRelPath.includes("node_modules")) continue;
-          if (sourceRelPath.includes("package.json")) continue;
-
-          const targetFilePath = path.resolve(updatePathInfo.target, sourceRelPath);
-
-          this._logger.debug(`변경파일감지(복사): ${changedFilePath} => ${targetFilePath}`);
-          await FsUtil.copyAsync(changedFilePath, targetFilePath);
-        }
-      }
-
-      const watchWatchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
-      watcher.add(watchWatchPaths);
-
-      this._logger.info("로컬 라이브러리 복사 완료");
-    });
-  }
-
-  private async _getUpdatePathInfosAsync(record: Record<string, string>): Promise<IUpdatePathInfo[]> {
-    const result: IUpdatePathInfo[] = [];
-    for (const pkgGlobPath of Object.keys(record)) {
-      // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기
-      const targetPaths = [
-        ...await FsUtil.globAsync(path.resolve(this._rootPath, "node_modules", pkgGlobPath)),
-        ...await FsUtil.globAsync(path.resolve(this._rootPath, "packages", "*", "node_modules", pkgGlobPath))
-      ];
-
-      result.push(
-        ...targetPaths
-          .map((targetPath) => {
-            // 대상의 명칭 추출
-            const regexpText = pkgGlobPath.replace(/[\\/.*]/g, (item) => (
-              item === "/" ? "[\\\\\\/]"
-                : item === "." ? "\\."
-                  : item === "*" ? "(.*)"
-                    : item
-            ));
-            const targetNameMatch = new RegExp(regexpText).exec(targetPath);
-            if (!targetNameMatch || typeof targetNameMatch[1] === "undefined") return undefined;
-            const targetName = targetNameMatch[1];
-
-            // 가져올 소스 경로 추출
-            const sourcePath = path.resolve(record[pkgGlobPath].replace(/\*/g, targetName));
-            return { source: sourcePath, target: targetPath };
-          })
-          .filterExists()
-      );
-    }
-
-    return result;
-  }
-
-  protected async _getWatchPathsAsync(sourcePath: string): Promise<string[]> {
-    return await FsUtil.globAsync(path.resolve(sourcePath, "**"), {
-      ignore: [
-        "**/node_modules/**",
-        "**/package.json"
-      ]
-    });
-  }
-}
-
-interface IUpdatePathInfo {
-  source: string;
-  target: string;
-}