@simplysm/sd-cli 7.0.23 → 7.0.37

package/src/builder/SdCliServerBuilder.ts

@@ -0,0 +1,457 @@
+import { INpmConfig, ISdCliPackageBuildResult, ISdCliServerPackageConfig } from "../commons";
+import { EventEmitter } from "events";
+import { FsUtil, Logger, PathUtil } from "@simplysm/sd-core-node";
+import webpack from "webpack";
+import path from "path";
+import ts from "typescript";
+import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
+import { ErrorInfo } from "ts-loader/dist/interfaces";
+import os from "os";
+import { ESLint } from "eslint";
+import TerserPlugin from "terser-webpack-plugin";
+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 LintResult = ESLint.LintResult;
+
+export class SdCliServerBuilder extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  private readonly _tsconfigFilePath: string;
+  private readonly _parsedTsconfig: ts.ParsedCommandLine;
+  private readonly _npmConfigMap = new Map<string, INpmConfig>();
+
+  public constructor(private readonly _rootPath: string,
+                     private readonly _config: ISdCliServerPackageConfig,
+                     private readonly _workspaceRootPath: string) {
+    super();
+
+    // 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);
+  }
+
+  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> {
+    // DIST 비우기
+    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
+
+    // 빌드 준비
+    const extModuleNames = this._getExternalModuleNames();
+    const webpackConfig = this._getWebpackConfig(true, extModuleNames);
+    const compiler = webpack(webpackConfig);
+    await new Promise<void>((resolve, reject) => {
+      compiler.hooks.watchRun.tapAsync(this.constructor.name, (args, callback) => {
+        this.emit("change");
+        callback();
+
+        this._logger.debug("Webpack 빌드 수행...");
+      });
+
+      compiler.watch({}, async (err, stats) => {
+        if (err != null || stats == null) {
+          reject(err);
+          return;
+        }
+
+        // .config.json 파일 쓰기
+        await this._writeDistConfigFileAsync();
+
+        // 결과 반환
+        const results = SdCliBuildResultUtil.convertFromWebpackStats(stats);
+        this.emit("complete", results);
+
+        // 마무리
+        this._logger.debug("Webpack 빌드 완료");
+        resolve();
+      });
+    });
+  }
+
+  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+    // DIST 비우기
+    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
+
+    // 빌드
+    this._logger.debug("Webpack 빌드 수행...");
+    const extModuleNames = this._getExternalModuleNames();
+    const webpackConfig = this._getWebpackConfig(false, extModuleNames);
+    const compiler = webpack(webpackConfig);
+    const buildResults = await new Promise<ISdCliPackageBuildResult[]>((resolve, reject) => {
+      compiler.run((err, stats) => {
+        if (err != null || stats == null) {
+          reject(err);
+          return;
+        }
+
+        // 결과 반환
+        const results = SdCliBuildResultUtil.convertFromWebpackStats(stats);
+        resolve(results);
+      });
+    });
+
+    // .config.json 파일 쓰기
+    await this._writeDistConfigFileAsync();
+
+    // pm2.json 파일 쓰기
+    await this._writeDistPm2ConfigFileAsync();
+
+    // iis 파일 쓰기
+    await this._writeDistIisConfigFileAsync();
+
+    // 배포용 package.json 파일 생성
+    await this._writeDistNpmConfigFileAsync(extModuleNames);
+
+    // 마무리
+    this._logger.debug("Webpack 빌드 완료");
+    return buildResults;
+  }
+
+  private async _writeDistConfigFileAsync(): Promise<void> {
+    const configDistPath = path.resolve(this._parsedTsconfig.options.outDir!, ".config.json");
+    await FsUtil.writeFileAsync(configDistPath, JSON.stringify(this._config.configs ?? {}, undefined, 2));
+  }
+
+  private async _writeDistPm2ConfigFileAsync(): Promise<void> {
+    if (this._config.pm2 === undefined || this._config.pm2 === false) return;
+
+    const npmConfig = this._getNpmConfig(this._rootPath)!;
+    const pm2DistPath = path.resolve(this._parsedTsconfig.options.outDir!, "pm2.json");
+    await FsUtil.writeFileAsync(
+      pm2DistPath,
+      JSON.stringify(
+        ObjectUtil.merge(
+          {
+            "name": npmConfig.name.replace(/@/g, "").replace(/\//g, "-"),
+            "script": path.basename(path.resolve(this._parsedTsconfig.options.outDir!, "main.mjs")),
+            "watch": true,
+            "watch_delay": 2000,
+            "ignore_watch": [
+              "node_modules",
+              "www"
+            ].distinct(),
+            "interpreter": "node@" + process.versions.node,
+            "env": {
+              NODE_ENV: "production",
+              SD_VERSION: npmConfig.version,
+              TZ: "Asia/Seoul",
+              ...this._config.env ? this._config.env : {}
+            }
+          },
+          (typeof this._config.pm2 !== "boolean") ? this._config.pm2 : {},
+          {
+            arrayProcess: "concat"
+          }),
+        undefined,
+        2
+      )
+    );
+  }
+
+  private async _writeDistIisConfigFileAsync(): Promise<void> {
+    if (this._config.iis === undefined || this._config.iis === false) return;
+
+    const iisDistPath = path.resolve(this._parsedTsconfig.options.outDir!, "web.config");
+    const serverExeFilePath = (this._config.iis !== true && "serverExeFilePath" in this._config.iis)
+      ? (this._config.iis.serverExeFilePath ?? "C:\\Program Files\\nodejs\\node.exe")
+      : "C:\\Program Files\\nodejs\\node.exe";
+    await FsUtil.writeFileAsync(iisDistPath, `
+<configuration>
+  <system.webServer>
+    <webSocket enabled="false" />
+    <handlers>
+      <add name="iisnode" path="main.js" verb="*" modules="iisnode" />
+    </handlers>
+    <iisnode nodeProcessCommandLine="${serverExeFilePath}"
+             watchedFiles="web.config;*.js"
+             loggingEnabled="true"
+             devErrorsEnabled="true" />
+    <rewrite>
+      <rules>
+        <rule name="main">
+          <action type="Rewrite" url="main.mjs" />
+        </rule>
+      </rules>
+    </rewrite>
+    <httpErrors errorMode="Detailed" />
+  </system.webServer>
+</configuration>`.trim());
+  }
+
+  private async _writeDistNpmConfigFileAsync(deps: string[]): Promise<void> {
+    const distNpmConfig = ObjectUtil.clone(this._getNpmConfig(this._rootPath))!;
+    distNpmConfig.dependencies = {};
+    for (const dep of deps) {
+      distNpmConfig.dependencies[dep] = "*";
+    }
+    delete distNpmConfig.optionalDependencies;
+    delete distNpmConfig.devDependencies;
+    delete distNpmConfig.peerDependencies;
+
+    if (this._config.pm2 !== undefined) {
+      distNpmConfig.scripts = { "start": "pm2 start pm2.json" };
+    }
+
+    await FsUtil.writeFileAsync(
+      path.resolve(this._parsedTsconfig.options.outDir!, "package.json"),
+      JSON.stringify(distNpmConfig, undefined, 2)
+    );
+  }
+
+  private _getWebpackConfig(watch: boolean, extModuleNames: string[]): webpack.Configuration {
+    const internalModuleCachePaths = watch
+      ? FsUtil.findAllParentChildDirPaths("node_modules/!(@simplysm)", this._rootPath, this._workspaceRootPath)
+      : undefined;
+
+    return {
+      mode: watch ? "development" : "production",
+      devtool: false,
+      target: ["node", "es2020"],
+      profile: false,
+      resolve: {
+        roots: [this._rootPath],
+        extensions: [".ts", ".js", ".mjs", ".cjs"],
+        symlinks: true,
+        mainFields: ["es2020", "default", "module", "main"]
+      },
+      context: this._workspaceRootPath,
+      entry: {
+        main: [
+          path.resolve(this._rootPath, "src/main.ts")
+        ]
+      },
+      output: {
+        clean: true,
+        path: this._parsedTsconfig.options.outDir,
+        filename: "[name].mjs",
+        chunkFilename: "[name].mjs",
+        assetModuleFilename: "res/[name][ext][query]",
+        libraryTarget: "module"
+      },
+      experiments: {
+        outputModule: true
+      },
+      performance: { hints: false },
+      node: false,
+      stats: "errors-warnings",
+      externals: extModuleNames,
+      ...watch ? {
+        cache: { type: "memory", maxGenerations: 1 },
+        snapshot: {
+          immutablePaths: internalModuleCachePaths,
+          managedPaths: internalModuleCachePaths
+        }
+      } : {
+        cache: false
+      },
+      optimization: {
+        ...watch ? {} : {
+          minimize: true,
+          minimizer: [
+            new TerserPlugin({
+              extractComments: false,
+              terserOptions: {
+                compress: true,
+                ecma: 2020,
+                sourceMap: false,
+                keep_classnames: true,
+                keep_fnames: true,
+                ie8: false,
+                safari10: false,
+                module: true,
+                format: {
+                  comments: false
+                }
+              }
+            })
+          ]
+        },
+        moduleIds: "deterministic",
+        chunkIds: watch ? "named" : "deterministic",
+        emitOnErrors: watch
+      },
+      module: {
+        strictExportPresence: true,
+        rules: [
+          {
+            test: /\.m?js/,
+            resolve: {
+              fullySpecified: false
+            }
+          },
+          ...watch ? [
+            {
+              test: /\.m?js$/,
+              enforce: "pre" as const,
+              loader: "source-map-loader",
+              options: {
+                filterSourceMappingUrl: (mapUri: string, resourcePath: string) => {
+                  return !resourcePath.includes("node_modules") || (/@simplysm[\\/]sd/).test(resourcePath);
+                }
+              }
+            }
+          ] : [],
+          {
+            test: /\.ts$/,
+            exclude: /node_modules/,
+            loader: "ts-loader",
+            options: {
+              configFile: this._tsconfigFilePath,
+              errorFormatter: (msg: ErrorInfo) => {
+                return SdCliBuildResultUtil.getMessage({
+                  filePath: msg.file,
+                  line: msg.line,
+                  char: msg.character,
+                  code: "TS" + msg.code.toString(),
+                  severity: msg.severity,
+                  message: msg.content
+                });
+              }
+            }
+          },
+          {
+            test: /\.(png|jpe?g|gif|svg|woff|woff2|ttf|eot|ico|otf|xlsx?|pptx?|docx?|zip|pfx|pkl)$/,
+            type: "asset/resource"
+          }
+        ]
+      },
+      plugins: [
+        ...watch ? [] : [
+          new LicenseWebpackPlugin({
+            stats: { warnings: false, errors: false },
+            perChunkOutput: false,
+            outputFilename: "3rd_party_licenses.txt",
+            skipChildCompilers: true
+          }) as any
+        ],
+        new CopyWebpackPlugin({
+          patterns: ["assets/"].map((item) => ({
+            context: this._rootPath,
+            to: item,
+            from: `src/${item}`,
+            noErrorOnMissing: true,
+            force: true,
+            globOptions: {
+              dot: true,
+              followSymbolicLinks: false,
+              ignore: [
+                ".gitkeep",
+                "**/.DS_Store",
+                "**/Thumbs.db"
+              ].map((i) => PathUtil.posix(this._rootPath, i))
+            },
+            priority: 0
+          }))
+        }),
+        new webpack.EnvironmentPlugin({
+          SD_VERSION: this._getNpmConfig(this._rootPath)!.version,
+          ...this._config.env
+        }),
+        new ESLintWebpackPlugin({
+          context: this._rootPath,
+          eslintPath: path.resolve(this._workspaceRootPath, "node_modules", "eslint"),
+          exclude: ["node_modules"],
+          extensions: ["ts", "js", "mjs", "cjs"],
+          fix: false,
+          threads: false,
+          formatter: (results: LintResult[]) => {
+            const resultMessages: string[] = [];
+            for (const result of results) {
+              for (const msg of result.messages) {
+                const severity = msg.severity === 1 ? "warning" : msg.severity === 2 ? "error" : undefined;
+                if (severity === undefined) continue;
+
+                resultMessages.push(SdCliBuildResultUtil.getMessage({
+                  filePath: result.filePath,
+                  line: msg.line,
+                  char: msg.column,
+                  code: msg.ruleId?.toString(),
+                  severity,
+                  message: msg.message
+                }));
+              }
+            }
+            return resultMessages.join(os.EOL);
+          }
+        })/*,
+        new webpack.ProgressPlugin({
+          handler: (per: number, msg: string, ...args: string[]) => {
+            const phaseText = msg ? ` - phase: ${msg}` : "";
+            const argsText = args.length > 0 ? ` - args: [${args.join(", ")}]` : "";
+            this._logger.debug(`Webpack 빌드 수행중...(${Math.round(per * 100)}%)${phaseText}${argsText}`);
+          }
+        })*/
+      ]
+    };
+  }
+
+  private _getExternalModuleNames(): string[] {
+    const loadedModuleNames: string[] = [];
+    const resultSet = new Set<string>();
+
+    const fn = (currPath: string): void => {
+      const npmConfig = this._getNpmConfig(currPath);
+      if (!npmConfig) return;
+
+      const moduleNames = [
+        ...Object.keys(npmConfig.dependencies ?? {}),
+        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => !npmConfig.peerDependenciesMeta?.[item].optional)
+      ];
+      const optModuleNames = [
+        ...Object.keys(npmConfig.optionalDependencies ?? {}),
+        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => npmConfig.peerDependenciesMeta?.[item].optional)
+      ].distinct();
+
+      for (const moduleName of moduleNames) {
+        if (loadedModuleNames.includes(moduleName)) continue;
+        loadedModuleNames.push(moduleName);
+
+        const modulePath = FsUtil.findAllParentChildDirPaths("node_modules/" + moduleName, currPath, this._workspaceRootPath).first();
+        if (StringUtil.isNullOrEmpty(modulePath)) {
+          continue;
+        }
+
+        if (FsUtil.exists(path.resolve(modulePath, "binding.gyp"))) {
+          resultSet.add(moduleName);
+        }
+
+        fn(modulePath);
+      }
+
+      for (const optModuleName of optModuleNames) {
+        if (loadedModuleNames.includes(optModuleName)) continue;
+        loadedModuleNames.push(optModuleName);
+
+        const optModulePath = FsUtil.findAllParentChildDirPaths("node_modules/" + optModuleName, currPath, this._workspaceRootPath).first();
+        if (StringUtil.isNullOrEmpty(optModulePath)) {
+          resultSet.add(optModuleName);
+          continue;
+        }
+
+        if (FsUtil.exists(path.resolve(optModulePath, "binding.gyp"))) {
+          resultSet.add(optModuleName);
+        }
+
+        fn(optModulePath);
+      }
+    };
+
+    fn(this._rootPath);
+
+    return Array.from(resultSet.values());
+  }
+
+  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);
+  }
+}

package/src/builder/SdCliTsLibBuilder.ts

@@ -1,4 +1,4 @@
-import { ISdCliPackageBuildResult } from "../commons";
+import { INpmConfig, ISdCliPackageBuildResult } from "../commons";
 import { EventEmitter } from "events";
 import ts from "typescript";
 import { FsUtil, Logger, PathUtil, SdFsWatcher } from "@simplysm/sd-core-node";
@@ -11,6 +11,7 @@ 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";
 
 export class SdCliTsLibBuilder extends EventEmitter {
   private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
@@ -26,10 +27,26 @@ export class SdCliTsLibBuilder extends EventEmitter {
   private _ngProgram?: NgtscProgram;
   private _builder?: ts.EmitAndSemanticDiagnosticsBuilderProgram;
 
-  public constructor(private readonly _rootPath,
-                     private readonly _isAngular: boolean) {
+  private readonly _tsconfigFilePath: string;
+  private readonly _parsedTsconfig: ts.ParsedCommandLine;
+  private readonly _npmConfig: INpmConfig;
+
+  private readonly _isAngular: boolean;
+
+  public constructor(private readonly _rootPath) {
     super();
     this._linter = new SdCliPackageLinter(this._rootPath);
+
+    // 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);
+
+    // package.json
+    this._npmConfig = FsUtil.readJson(path.resolve(this._rootPath, "package.json"));
+
+    // else
+    this._isAngular = SdCliNpmConfigUtil.getDependencies(this._npmConfig).defaults.includes("@angular/core");
   }
 
   public override on(event: "change", listener: () => void): this;
@@ -41,14 +58,11 @@ export class SdCliTsLibBuilder extends EventEmitter {
   public async watchAsync(): Promise<void> {
     this.emit("change");
 
-    // TSCONFIG 읽기
-    const parsedTsconfig = await this._getParsedTsconfigAsync();
-
     // DIST 비우기
-    await FsUtil.removeAsync(parsedTsconfig.options.outDir!);
+    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
     // 프로그램 리로드
-    const buildPack = this._createSdBuildPack(parsedTsconfig);
+    const buildPack = this._createSdBuildPack(this._parsedTsconfig);
 
     const relatedPaths = await this.getAllRelatedPathsAsync();
     const watcher = SdFsWatcher.watch(relatedPaths);
@@ -65,7 +79,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
       }
 
       // 빌드
-      const watchBuildPack = this._createSdBuildPack(parsedTsconfig);
+      const watchBuildPack = this._createSdBuildPack(this._parsedTsconfig);
 
       // 린트
       const watchBuildResults = await this._runBuilderAsync(watchBuildPack.builder, watchBuildPack.ngCompiler);
@@ -90,14 +104,11 @@ export class SdCliTsLibBuilder extends EventEmitter {
   }
 
   public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
-    // TSCONFIG 읽기
-    const parsedTsconfig = await this._getParsedTsconfigAsync();
-
     // DIST 비우기
-    await FsUtil.removeAsync(parsedTsconfig.options.outDir!);
+    await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
     // 프로그램 리로드
-    const buildPack = this._createSdBuildPack(parsedTsconfig);
+    const buildPack = this._createSdBuildPack(this._parsedTsconfig);
 
     // 빌드
     const buildResults = await this._runBuilderAsync(buildPack.builder, buildPack.ngCompiler);
@@ -165,7 +176,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
       results.push(
         ...diagnostics
           .filter((item) => [ts.DiagnosticCategory.Error, ts.DiagnosticCategory.Warning].includes(item.category))
-          .map((item) => SdCliBuildResultUtil.convertDiagsToResult(item))
+          .map((item) => SdCliBuildResultUtil.convertFromTsDiag(item))
           .filterExists()
       );
 
@@ -312,12 +323,6 @@ export class SdCliTsLibBuilder extends EventEmitter {
       return compilerHost;
     }
   }
-
-  private async _getParsedTsconfigAsync(): Promise<ts.ParsedCommandLine> {
-    const tsconfigFilePath = path.resolve(this._rootPath, "tsconfig-build.json");
-    const tsconfig = await FsUtil.readJsonAsync(tsconfigFilePath);
-    return ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._rootPath);
-  }
 }
 
 interface IFileCache {

package/src/commons.ts

@@ -15,6 +15,7 @@ export interface INpmConfig {
   optionalDependencies?: Record<string, string>;
   devDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
+  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
 }
 
 export interface ITsconfig {
@@ -39,17 +40,17 @@ export interface ISdCliConfig {
   localUpdates?: Record<string, string>;
 }
 
-export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliNgLibPackageConfig | ISdCliServerPackageConfig;
+export type TSdCliPackageConfig = ISdCliLibPackageConfig | ISdCliServerPackageConfig;
 
 export interface ISdCliLibPackageConfig {
   type: "library";
   publish?: "npm";
 }
 
-export interface ISdCliNgLibPackageConfig {
-  type: "angular";
-}
-
 export interface ISdCliServerPackageConfig {
   type: "server";
+  env?: Record<string, string>;
+  configs?: Record<string, any>;
+  pm2?: Record<string, any> | boolean;
+  iis?: { serverExeFilePath?: string } | boolean;
 }

package/src/entry-points/SdCliNpm.ts

@@ -0,0 +1,26 @@
+import { Logger, SdProcess } from "@simplysm/sd-core-node";
+import { SdCliPrepare } from "./SdCliPrepare";
+
+export class SdCliNpm {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  public constructor(private readonly _rootPath: string) {
+  }
+
+  public async updateAsync(): Promise<void> {
+    try {
+      this._logger.debug("업데이트할 패키지 확인...");
+      await SdProcess.spawnAsync("npm outdated", { cwd: this._rootPath });
+    }
+    catch (err) {
+    }
+
+    this._logger.debug("업데이트 시작...");
+    await SdProcess.spawnAsync("npm update", { cwd: this._rootPath });
+
+    this._logger.debug("sd-cli 준비...");
+    await new SdCliPrepare().prepareAsync();
+
+    this._logger.info("노드 패키지 업데이트 완료");
+  }
+}

package/src/entry-points/SdCliPrepare.ts

@@ -0,0 +1,54 @@
+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"})`);
+  }
+
+  private async _modifyTypescriptCodeForTypeCheckPerformanceWarning(): Promise<boolean> {
+    const fileUrl = await import.meta.resolve!("typescript");
+    const filePath = fileUrl.replace(/^file:\/\/\//, "");
+    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;
+  }
+}