@simplysm/sd-cli 6.4.4 → 7.0.8

package/src/bin/sd-cli.ts

@@ -1,235 +1,69 @@
-#!/usr/bin/env node
-
-process.setMaxListeners(0);
-
-import * as os from "os";
-import * as yargs from "yargs";
-import { EventEmitter } from "events";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
 import { Logger, LoggerSeverity } from "@simplysm/sd-core-node";
-import { SdCliProject } from "../entry-points/SdCliProject";
-import { SdCliLocalUpdater } from "../entry-points/SdCliLocalUpdater";
-import { SdCliFileCrypto } from "../utils/SdCliFileCrypto";
-import { SdCliCordova } from "../build-tools/SdCliCordova";
-import { SdCliPrepare } from "../entry-points/SdCliPrepare";
+import { SdCliWorkspace } from "../entry-points/SdCliWorkspace";
 
-EventEmitter.defaultMaxListeners = 0;
+Error.stackTraceLimit = Infinity;
 
-const logger = Logger.get(["simplysm", "sd-cli"]);
+const argv = yargs(hideBin(process.argv))
+  .version(false)
+  .help("help", "도움말")
+  .alias("help", "h")
+  .options({
+    debug: {
+      type: "boolean",
+      describe: "디버그 로그를 표시할 것인지 여부",
+      default: false
+    }
+  })
+  .command("watch", "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.")
+  .command("build", "프로젝트의 각 패키지에 대한 빌드를 수행합니다.")
+  .command(
+    "publish",
+    "프로젝트의 각 패키지를 배포합니다.",
+    (cmd) => cmd
+      .options({
+        "noBuild":{
+          type: "boolean",
+          describe: "빌드를 하지않고 배포합니다.",
+          default: false
+        }
+      })
+  )
+  .parseSync();
 
-(async (): Promise<void> => {
-  const argv = await yargs.version(false)
-    .help("help", "도움말")
-    .alias("help", "h")
-    .options({
-      debug: {
-        type: "boolean",
-        describe: "디버그 로그를 표시할 것인지 여부",
-        default: false
-      }
-    })
-    .command(
-      "watch",
-      "프로젝트의 각 패키지에 대한 변경감지 빌드를 수행합니다.",
-      (cmd) => cmd
-        .options({
-          packages: {
-            type: "string",
-            describe: "수행할 패키지 설정",
-            array: true
-          },
-          config: {
-            type: "string",
-            describe: "simplysm.json 파일 경로"
-          },
-          noLint: {
-            type: "boolean",
-            describe: `lint 작업을 수행하지 않음`
-          },
-          options: {
-            type: "string",
-            describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)",
-            array: true
-          }
-        })
-    )
-    .command(
-      "run-device <cordovaPath> <target> <url>",
-      "변경감지중인 플랫폼을 디바이스에 앱 형태로 띄웁니다.",
-      (cmd) => cmd
-        .positional("cordovaPath", {
-          type: "string",
-          describe: "CORDOVA 프로젝트 경로",
-          demandOption: true
-        })
-        .positional("target", {
-          type: "string",
-          describe: "빌드타겟(android,...)",
-          demandOption: true
-        })
-        .positional("url", {
-          type: "string",
-          describe: "Webview로 오픈할 URL",
-          demandOption: true
-        })
-    )
-    .command(
-      "build",
-      "프로젝트의 각 패키지에 대한 빌드를 수행합니다.",
-      (cmd) => cmd
-        .options({
-          packages: {
-            type: "string",
-            describe: "수행할 패키지 설정",
-            array: true
-          },
-          config: {
-            type: "string",
-            describe: "simplysm.json 파일 경로"
-          },
-          noLint: {
-            type: "boolean",
-            describe: `lint 작업을 수행하지 않음`
-          },
-          options: {
-            type: "string",
-            describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)",
-            array: true
-          }
-        })
-    )
-    .command(
-      "publish",
-      "프로젝트의 각 패키지를 배포합니다.",
-      (cmd) => cmd.version(false)
-        .options({
-          build: {
-            type: "boolean",
-            describe: "새로 빌드한 후에 배포합니다",
-            default: false
-          },
-          noLint: {
-            type: "boolean",
-            describe: `빌드시, lint 작업을 수행하지 않음`
-          },
-          packages: {
-            type: "string",
-            describe: "수행할 패키지 설정",
-            array: true
-          },
-          config: {
-            type: "string",
-            describe: "simplysm.json 파일 경로"
-          },
-          options: {
-            type: "string",
-            describe: "옵션 설정 (설정파일에서 @로 시작하는 부분)",
-            array: true
-          }
-        })
-    )
-    .command(
-      "local-update",
-      "로컬 라이브러리 업데이트를 수행합니다.",
-      (cmd) => cmd.version(false)
-        .options({
-          config: {
-            type: "string",
-            describe: "simplysm.json 파일 경로"
-          }
-        })
-    )
-    .command(
-      "enc-file <file>",
-      "파일을 암호화 합니다.",
-      (cmd) => cmd.version(false)
-        .positional("file", {
-          type: "string",
-          describe: "암호화할 파일명"
-        })
-    )
-    .command(
-      "dec-file <file>",
-      "파일을 복호화 합니다.",
-      (cmd) => cmd.version(false)
-        .positional("file", {
-          type: "string",
-          describe: "암호화된 파일명"
-        })
-    )
-    .command(
-      "prepare",
-      "sd-cli 준비"
-    )
-    .parse();
+if (argv.debug) {
+  process.env["SD_CLI_LOGGER_SEVERITY"] = "DEBUG";
 
-  if (argv.debug) {
-    Error.stackTraceLimit = 100; //Infinity;
+  Logger.setConfig({
+    console: {
+      level: LoggerSeverity.debug
+    }
+  });
+}
+else {
+  Logger.setConfig({
+    dot: true
+  });
+}
 
-    process.env.SD_CLI_LOGGER_SEVERITY = "DEBUG";
+const logger = Logger.get(["simplysm", "sd-cli", "bin", "sd-cli"]);
 
-    Logger.setConfig(["simplysm", "sd-cli"], {
-      console: {
-        level: LoggerSeverity.debug
-      }
-    });
-  }
-  else {
-    Logger.setConfig(["simplysm", "sd-cli"], {
-      dot: true
-    });
+(async () => {
+  if (argv._[0] === "watch") {
+    await new SdCliWorkspace(process.cwd()).watchAsync();
   }
-
-  const args = argv._;
-
-  if (args[0] === "build") {
-    await new SdCliProject(process.cwd())
-      .buildAsync({
-        packages: argv.packages,
-        config: argv.config,
-        options: argv.options,
-        skipProcesses: argv.noLint ? ["lint"] : undefined
-      });
-    process.exit(0);
+  else if (argv._[0] === "build") {
+    await new SdCliWorkspace(process.cwd()).buildAsync();
   }
-  else if (args[0] === "watch") {
-    await new SdCliProject(process.cwd())
-      .buildAsync({
-        watch: true,
-        packages: argv.packages,
-        config: argv.config,
-        options: argv.options,
-        skipProcesses: argv.noLint ? ["lint"] : undefined
-      });
-  }
-  else if (args[0] === "run-device") {
-    await SdCliCordova.runWebviewOnDeviceAsync(argv.cordovaPath, argv.target, argv.url);
-  }
-  else if (args[0] === "local-update") {
-    await new SdCliLocalUpdater(process.cwd()).localUpdateAsync(false, { config: argv.config });
-  }
-  else if (args[0] === "publish") {
-    await new SdCliProject(process.cwd())
-      .publishAsync({
-        build: argv.build,
-        packages: argv.packages,
-        config: argv.config,
-        options: argv.options
-      });
-    process.exit(0);
-  }
-  else if (args[0] === "enc-file") {
-    await new SdCliFileCrypto().encryptAsync(argv.file!);
-  }
-  else if (args[0] === "dec-file") {
-    await new SdCliFileCrypto().decryptAsync(argv.file!);
-  }
-  else if (args[0] === "prepare") {
-    await new SdCliPrepare().prepareAsync();
+  else if (argv._[0] === "publish") {
+    await new SdCliWorkspace(process.cwd()).publishAsync({
+      noBuild: argv.noBuild
+    });
   }
   else {
-    throw new Error(`명령어가 잘못되었습니다.${os.EOL + os.EOL}\t${argv._[0]}${os.EOL}`);
+    throw new Error(`명령어가 잘못 되었습니다.\n\t${argv._[0]}\n`);
   }
 })().catch((err) => {
   logger.error(err);
-  process.exit(1);
 });

package/src/build-tool/SdCliCacheCompilerHost.ts

@@ -0,0 +1,71 @@
+import ts from "typescript";
+import { PathUtil } from "@simplysm/sd-core-node";
+
+export class SdCliCacheCompilerHost {
+  public static create(parsedTsconfig: ts.ParsedCommandLine,
+                       moduleResolutionCache: ts.ModuleResolutionCache,
+                       sourceFileCache: Map<string, IFileCache>,
+                       outputFileCache: Map<string, string>): ts.CompilerHost {
+    const compilerHost = ts.createIncrementalCompilerHost(parsedTsconfig.options);
+
+    const cacheCompilerHost = { ...compilerHost };
+
+    cacheCompilerHost.fileExists = (fileName: string) => {
+      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+      if (cache.exists === undefined) {
+        cache.exists = compilerHost.fileExists.call(cacheCompilerHost, fileName);
+      }
+      return cache.exists;
+    };
+
+    cacheCompilerHost.getSourceFile = (fileName: string, languageVersion: ts.ScriptTarget) => {
+      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+      if (!cache.sourceFile) {
+        cache.sourceFile = compilerHost.getSourceFile.call(cacheCompilerHost, fileName, languageVersion);
+      }
+      return cache.sourceFile;
+    };
+
+    cacheCompilerHost.writeFile = (fileName: string,
+                                   data: string,
+                                   writeByteOrderMark: boolean,
+                                   onError?: (message: string) => void,
+                                   sourceFiles?: readonly ts.SourceFile[]) => {
+      fileName = fileName.replace(/\.js(\.map)?$/, ".mjs$1");
+
+      const writeCache = outputFileCache.get(PathUtil.posix(fileName));
+      if (writeCache !== data) {
+        outputFileCache.set(PathUtil.posix(fileName), data);
+        compilerHost.writeFile.call(cacheCompilerHost, fileName, data, writeByteOrderMark, onError, sourceFiles);
+      }
+    };
+
+    cacheCompilerHost.readFile = (fileName: string) => {
+      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+      if (cache.content === undefined) {
+        cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
+      }
+      return cache.content;
+    };
+
+    cacheCompilerHost.resolveModuleNames = (moduleNames: string[], containingFile: string) => {
+      return moduleNames.map((moduleName) => {
+        return ts.resolveModuleName(
+          moduleName,
+          PathUtil.posix(containingFile),
+          parsedTsconfig.options,
+          compilerHost,
+          moduleResolutionCache
+        ).resolvedModule;
+      });
+    };
+
+    return cacheCompilerHost;
+  }
+}
+
+interface IFileCache {
+  exists?: boolean;
+  sourceFile?: ts.SourceFile;
+  content?: string;
+}

package/src/build-tool/SdCliNgCacheCompilerHost.ts

@@ -0,0 +1,50 @@
+import ts from "typescript";
+import { PathUtil } from "@simplysm/sd-core-node";
+import sass from "sass";
+import { pathToFileURL, URL } from "url";
+
+export class SdCliNgCacheCompilerHost {
+  public static wrap(compilerHost: ts.CompilerHost,
+                     sourceFileCache: Map<string, IFileCache>): ts.CompilerHost {
+    const cacheCompilerHost = { ...compilerHost };
+
+    cacheCompilerHost["readResource"] = (fileName: string) => {
+      const cache = sourceFileCache.getOrCreate(PathUtil.posix(fileName), {});
+      if (cache.content === undefined) {
+        cache.content = compilerHost.readFile.call(cacheCompilerHost, fileName);
+      }
+      return cache.content;
+    };
+
+    cacheCompilerHost["transformResource"] = async (data, context) => {
+      if (context.resourceFile || context.type !== "style") {
+        return null;
+      }
+
+      const cache = sourceFileCache.getOrCreate(PathUtil.posix(context.containingFile), {});
+      if (cache.styleContent === undefined) {
+        cache.styleContent = (
+          await sass.compileStringAsync(data, {
+            url: new URL(context.containingFile + ".sd.scss"),
+            importer: {
+              findFileUrl: (url) => {
+                if (!url.startsWith("~")) return undefined;
+                return new URL(url.substring(1), pathToFileURL("node_modules"));
+              }
+            }
+          })
+        ).css.toString();
+      }
+      return { content: cache.styleContent };
+    };
+
+    return cacheCompilerHost;
+  }
+}
+
+interface IFileCache {
+  exists?: boolean;
+  sourceFile?: ts.SourceFile;
+  content?: string;
+  styleContent?: string;
+}

package/src/build-tool/SdCliPackageLinter.ts

@@ -0,0 +1,54 @@
+import { ISdCliPackageBuildResult } from "../commons";
+import ts from "typescript";
+import { FsUtil } from "@simplysm/sd-core-node";
+import path from "path";
+import { ESLint } from "eslint";
+
+export class SdCliPackageLinter {
+  private readonly _lintResultCache = new Map<string, ISdCliPackageBuildResult[]>();
+
+  public constructor(private readonly _rootPath: string) {
+  }
+
+  public async lintAsync(filePaths: string[], program?: ts.Program): Promise<ISdCliPackageBuildResult[]> {
+    if (!FsUtil.exists(path.resolve(this._rootPath, ".eslintrc.cjs"))) return [];
+
+    const linter = new ESLint(
+      program && filePaths.some((item) => item.endsWith(".ts")) ? {
+        overrideConfig: {
+          parserOptions: { program }
+        }
+      } : {}
+    );
+
+    const lintFilePaths = await filePaths
+      .filterAsync(async (filePath) => (
+        !filePath.endsWith(".d.ts") &&
+        !(await linter.isPathIgnored(filePath))
+      ));
+    for (const lintFilePath of lintFilePaths) {
+      this._lintResultCache.delete(lintFilePath);
+    }
+
+    const lintResults = await linter.lintFiles(lintFilePaths);
+
+
+    const result = lintResults.map((lintResult) => ({
+      filePath: lintResult.filePath,
+      results: lintResult.messages.map((msg) => ({
+        filePath: lintResult.filePath,
+        line: msg.line,
+        char: msg.column,
+        code: msg.ruleId ?? undefined,
+        severity: msg.severity === 1 ? "warning" as const : "error" as const,
+        message: msg.message
+      }))
+    }));
+
+    for (const resultItem of result) {
+      this._lintResultCache.set(resultItem.filePath, resultItem.results);
+    }
+
+    return Array.from(this._lintResultCache.values()).mapMany();
+  }
+}

package/src/builder/SdCliJsLibBuilder.ts

@@ -0,0 +1,66 @@
+import { ISdCliPackageBuildResult } from "../commons";
+import { EventEmitter } from "events";
+import { FsUtil, Logger, SdFsWatcher } from "@simplysm/sd-core-node";
+import * as path from "path";
+import { SdCliPackageLinter } from "../build-tool/SdCliPackageLinter";
+
+export class SdCliJsLibBuilder extends EventEmitter {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  private readonly _linter: SdCliPackageLinter;
+
+  public constructor(private readonly _rootPath: string) {
+    super();
+    this._linter = new SdCliPackageLinter(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> {
+    this.emit("change");
+
+    const relatedPaths = await this.getRelatedPathsAsync();
+    const watcher = SdFsWatcher.watch(relatedPaths);
+    watcher.onChange(async (changeInfos) => {
+      const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+      if(changeFilePaths.length === 0) return;
+
+      this._logger.debug("파일 변경 감지", changeInfos);
+      this.emit("change");
+
+      const watchBuildResults = await this._linter.lintAsync(changeFilePaths);
+
+      const watchRelatedPaths = await this.getRelatedPathsAsync();
+      watcher.add(watchRelatedPaths);
+
+      this.emit("complete", watchBuildResults);
+    });
+
+    // 빌드
+    const buildResults = await this._linter.lintAsync(relatedPaths);
+
+    this.emit("complete", buildResults);
+  }
+
+  public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
+    const relatedPaths = await this.getRelatedPathsAsync();
+    return await this._linter.lintAsync(relatedPaths);
+  }
+
+  private async getRelatedPathsAsync(): Promise<string[]> {
+    const mySourceGlobPath = path.resolve(this._rootPath, "**", "+(*.js|*.cjs|*.mjs|*.ts)");
+    const mySourceFilePaths = await FsUtil.globAsync(mySourceGlobPath, {
+      ignore: [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/.*/**"
+      ]
+    });
+
+    return [...mySourceFilePaths, path.resolve(this._rootPath, ".eslintrc.cjs")].distinct();
+  }
+}