@simplysm/sd-cli 7.0.61 → 7.0.62

package/src/ng-tools/babel/SdCliBbFileMetadata.ts

@@ -0,0 +1,372 @@
+import {
+  Declaration,
+  Expression,
+  isArrayExpression,
+  isClassDeclaration,
+  isExportDeclaration,
+  isExportDefaultDeclaration,
+  isExportNamedDeclaration,
+  isExportSpecifier,
+  isFunctionDeclaration,
+  isIdentifier,
+  isImportDeclaration,
+  isImportSpecifier,
+  isObjectExpression,
+  isSpreadElement,
+  isStringLiteral,
+  isVariableDeclaration,
+  PatternLike,
+  SpreadElement,
+  Statement
+} from "@babel/types";
+import babelParser from "@babel/parser";
+import { FsUtil } from "@simplysm/sd-core-node";
+import path from "path";
+import { TSdCliBbMetadata } from "./SdCliBbRootMetadata";
+import {
+  SdCliBbArrayMetadata,
+  SdCliBbClassMetadata,
+  SdCliBbFunctionMetadata,
+  SdCliBbObjectMetadata,
+  SdCliBbVariableMetadata
+} from "./TSdCliBbTypeMetadata";
+import { SdCliBbUtil } from "./SdCliBbUtil";
+
+export class SdCliBbFileMetadata {
+  public readonly rawMetas: Statement[] = [];
+
+  public constructor(public readonly filePath: string) {
+    let realFilePath: string | undefined;
+    for (const ext of ["", ".mjs", ".cjs", ".js"]) {
+      if (FsUtil.exists(filePath + ext) && !FsUtil.isDirectory(filePath + ext)) {
+        realFilePath = filePath + ext;
+        break;
+      }
+    }
+    if (realFilePath === undefined) {
+      throw SdCliBbUtil.error("파일을 찾을 수 없습니다.", filePath);
+    }
+
+    const fileContent = FsUtil.readFile(realFilePath);
+    this.rawMetas = babelParser.parse(fileContent, { sourceType: "module" }).program.body;
+  }
+
+  private _exportsCache?: { exportedName: string; target: TSdCliBbMetadata }[];
+
+  public get exports(): { exportedName: string; target: TSdCliBbMetadata }[] {
+    if (this._exportsCache) return this._exportsCache;
+
+    const result: { exportedName: string; target: TSdCliBbMetadata }[] = [];
+    for (const rawMeta of this.rawMetas) {
+      if (!isExportDeclaration(rawMeta)) continue;
+
+      if (isExportNamedDeclaration(rawMeta)) {
+        for (const specifier of rawMeta.specifiers) {
+          if (isExportSpecifier(specifier)) {
+            const exportedName = isIdentifier(specifier.exported) ? specifier.exported.name : undefined;
+            if (exportedName === undefined) {
+              throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+            }
+
+            if (rawMeta.source) {
+              if (rawMeta.source.value.includes(".")) {
+                const moduleFilePath = path.resolve(path.dirname(this.filePath), rawMeta.source.value);
+                result.push({
+                  exportedName,
+                  target: {
+                    filePath: moduleFilePath,
+                    name: specifier.local.name,
+                    __TDeclRef__: "__TDeclRef__"
+                  }
+                });
+              }
+              else {
+                const moduleName = rawMeta.source.value;
+                result.push({
+                  exportedName,
+                  target: { moduleName, name: specifier.local.name, __TDeclRef__: "__TDeclRef__" }
+                });
+              }
+            }
+            else {
+              result.push({
+                exportedName,
+                target: this._findMetaFromInside(specifier.local.name)
+              });
+            }
+          }
+          else {
+            throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+          }
+        }
+      }
+      else if (isExportDefaultDeclaration(rawMeta)) {
+        result.push({
+          exportedName: "default",
+          target: this.getMetaFromRaw(rawMeta.declaration)
+        });
+      }
+      else {
+        if (rawMeta.source.value.includes(".")) {
+          const moduleFilePath = path.resolve(path.dirname(this.filePath), rawMeta.source.value);
+          result.push({
+            exportedName: "*",
+            target: {
+              filePath: moduleFilePath,
+              name: "*",
+              __TDeclRef__: "__TDeclRef__"
+            }
+          });
+        }
+        else {
+          throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+        }
+      }
+    }
+
+    this._exportsCache = result;
+    return result;
+  }
+
+  private readonly _findMetaFromOutsideCache = new Map<string, TSdCliBbMetadata>();
+
+  public findMetaFromOutside(name: string): TSdCliBbMetadata {
+    const cache = this._findMetaFromOutsideCache.get(name);
+    if (cache !== undefined) return cache;
+
+    for (const rawMeta of this.rawMetas) {
+      if (isExportNamedDeclaration(rawMeta)) {
+        if (rawMeta.declaration) {
+          if (isVariableDeclaration(rawMeta.declaration)) {
+            for (const decl of rawMeta.declaration.declarations) {
+              if (isIdentifier(decl.id)) {
+                if (decl.id.name === name) {
+                  const result = new SdCliBbVariableMetadata(this, decl);
+                  this._findMetaFromOutsideCache.set(name, result);
+                  return result;
+                }
+              }
+              else {
+                throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+              }
+            }
+          }
+          else if (isClassDeclaration(rawMeta.declaration)) {
+            if (rawMeta.declaration.id.name === name) {
+              const result = new SdCliBbClassMetadata(this, rawMeta.declaration);
+              this._findMetaFromOutsideCache.set(name, result);
+              return result;
+            }
+          }
+          else if (isFunctionDeclaration(rawMeta.declaration)) {
+            if (rawMeta.declaration.id) {
+              if (rawMeta.declaration.id.name === name) {
+                const result = new SdCliBbFunctionMetadata(this, rawMeta.declaration);
+                this._findMetaFromOutsideCache.set(name, result);
+                return result;
+              }
+            }
+            else {
+              throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+            }
+          }
+          else {
+            throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+          }
+        }
+        else {
+          for (const specifier of rawMeta.specifiers) {
+            if (isExportSpecifier(specifier)) {
+              const exportedName = isIdentifier(specifier.exported) ? specifier.exported.name : undefined;
+              if (exportedName === undefined) {
+                throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+              }
+              else if (exportedName === name) {
+                if (rawMeta.source) {
+                  if (rawMeta.source.value.includes(".")) {
+                    const moduleFilePath = path.resolve(path.dirname(this.filePath), rawMeta.source.value);
+                    const result = {
+                      filePath: moduleFilePath,
+                      name: specifier.local.name,
+                      __TDeclRef__: "__TDeclRef__" as const
+                    };
+                    this._findMetaFromOutsideCache.set(name, result);
+                    return result;
+                  }
+                  else {
+                    const moduleName = rawMeta.source.value;
+                    const result = {
+                      moduleName,
+                      name: specifier.local.name,
+                      __TDeclRef__: "__TDeclRef__" as const
+                    };
+                    this._findMetaFromOutsideCache.set(name, result);
+                    return result;
+                  }
+                }
+                else {
+                  const result = this._findMetaFromInside(specifier.local.name);
+                  this._findMetaFromOutsideCache.set(name, result);
+                  return result;
+                }
+              }
+            }
+          }
+        }
+      }
+      else if (isExportDefaultDeclaration(rawMeta) && name === "default") {
+        const result = this.getMetaFromRaw(rawMeta.declaration);
+        if (Array.isArray(result)) {
+          throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+        }
+        this._findMetaFromOutsideCache.set(name, result);
+        return result;
+      }
+    }
+
+    throw SdCliBbUtil.error(`'${name}'에 대한 'export'를 찾을 수 없습니다.`, this.filePath);
+  }
+
+  private readonly _findMetaFromInsideCache = new Map<string, TSdCliBbMetadata>();
+
+  private _findMetaFromInside(localName: string): TSdCliBbMetadata {
+    const cache = this._findMetaFromInsideCache.get(localName);
+    if (cache !== undefined) return cache;
+
+    for (const rawMeta of this.rawMetas) {
+      if (isClassDeclaration(rawMeta) && rawMeta.id.name === localName) {
+        return new SdCliBbClassMetadata(this, rawMeta);
+      }
+      else if (isExportNamedDeclaration(rawMeta)) {
+        for (const specifier of rawMeta.specifiers) {
+          if (isExportSpecifier(specifier)) {
+            const exportedName = isIdentifier(specifier.exported) ? specifier.exported.name : undefined;
+            if (exportedName === undefined) {
+              throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+            }
+            else if (exportedName === localName) {
+              if (rawMeta.source) {
+                if (rawMeta.source.value.includes(".")) {
+                  const moduleFilePath = path.resolve(path.dirname(this.filePath), rawMeta.source.value);
+                  const result = {
+                    filePath: moduleFilePath,
+                    name: specifier.local.name,
+                    __TDeclRef__: "__TDeclRef__" as const
+                  };
+                  this._findMetaFromInsideCache.set(localName, result);
+                  return result;
+                }
+                else {
+                  const moduleName = rawMeta.source.value;
+                  const result = {
+                    moduleName,
+                    name: specifier.local.name,
+                    __TDeclRef__: "__TDeclRef__" as const
+                  };
+                  this._findMetaFromInsideCache.set(localName, result);
+                  return result;
+                }
+              }
+            }
+          }
+        }
+      }
+      /*else if (isExportDefaultDeclaration(rawMeta) && localName === "default") {
+        const result = this.getMetaFromRaw(rawMeta.declaration);
+        if (Array.isArray(result)) {
+          throw new NeverEntryError();
+        }
+        this._findMetaFromInsideCache.set(localName, result);
+        return result;
+      }*/
+      else if (isImportDeclaration(rawMeta)) {
+        for (const specifier of rawMeta.specifiers) {
+          if (isImportSpecifier(specifier)) {
+            const impLocalName = isIdentifier(specifier.local) ? specifier.local.name : undefined;
+            if (impLocalName === undefined) {
+              throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+            }
+            else if (impLocalName === localName) {
+              if (isIdentifier(specifier.imported)) {
+                if (rawMeta.source.value.includes(".")) {
+                  const moduleFilePath = path.resolve(path.dirname(this.filePath), rawMeta.source.value);
+                  const result = {
+                    filePath: moduleFilePath,
+                    name: specifier.imported.name,
+                    __TDeclRef__: "__TDeclRef__" as const
+                  };
+                  this._findMetaFromInsideCache.set(localName, result);
+                  return result;
+                }
+                else {
+                  const moduleName = rawMeta.source.value;
+                  const result = {
+                    moduleName,
+                    name: specifier.imported.name,
+                    __TDeclRef__: "__TDeclRef__" as const
+                  };
+                  this._findMetaFromInsideCache.set(localName, result);
+                  return result;
+                }
+              }
+              else {
+                throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+              }
+            }
+          }
+        }
+      }
+      else if (isVariableDeclaration(rawMeta)) {
+        for (const decl of rawMeta.declarations) {
+          if (isIdentifier(decl.id)) {
+            if (decl.id.name === localName) {
+              const result = new SdCliBbVariableMetadata(this, decl);
+              this._findMetaFromInsideCache.set(localName, result);
+              return result;
+            }
+          }
+          else {
+            throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+          }
+        }
+      }
+      else if (isFunctionDeclaration(rawMeta)) {
+        if (rawMeta.id) {
+          if (rawMeta.id.name === localName) {
+            const result = new SdCliBbFunctionMetadata(this, rawMeta);
+            this._findMetaFromInsideCache.set(localName, result);
+            return result;
+          }
+        }
+        else {
+          throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+        }
+      }
+    }
+
+    throw SdCliBbUtil.error(`'${localName}'에 대한 내부선언을 찾을 수 없습니다.`, this.filePath);
+  }
+
+  public getMetaFromRaw(rawMeta: Declaration | Expression | PatternLike | SpreadElement): TSdCliBbMetadata {
+    if (isIdentifier(rawMeta)) {
+      return this._findMetaFromInside(rawMeta.name);
+    }
+    else if (isClassDeclaration(rawMeta)) {
+      return new SdCliBbClassMetadata(this, rawMeta);
+    }
+    else if (isArrayExpression(rawMeta)) {
+      return new SdCliBbArrayMetadata(this, rawMeta);
+    }
+    else if (isObjectExpression(rawMeta)) {
+      return new SdCliBbObjectMetadata(this, rawMeta);
+    }
+    else if (isStringLiteral(rawMeta)) {
+      return rawMeta.value;
+    }
+    else if (isSpreadElement(rawMeta)) {
+      return this.getMetaFromRaw(rawMeta.argument);
+    }
+
+    throw SdCliBbUtil.error("예상치 못한 방식의 코드가 발견되었습니다.", this.filePath, rawMeta);
+  }
+}

package/src/ng-tools/babel/SdCliBbRootMetadata.ts

@@ -0,0 +1,207 @@
+import { SdCliBbFileMetadata } from "./SdCliBbFileMetadata";
+import path from "path";
+import { INpmConfig } from "../../commons";
+import { SdCliNpmConfigUtil } from "../../utils/SdCliNpmConfigUtil";
+import { NeverEntryError, StringUtil } from "@simplysm/sd-core-common";
+import { FsUtil, PathUtil } from "@simplysm/sd-core-node";
+import { TSdCliBbTypeMetadata } from "./TSdCliBbTypeMetadata";
+import { TSdCliMetaRef } from "../commons";
+
+export class SdCliBbRootMetadata {
+  private readonly _entryMap: Map<string, string>;
+  private readonly _fileMetaCache = new Map<string, SdCliBbFileMetadata>();
+
+  public constructor(packagePath: string) {
+    const allDepPaths = this._getAllDepPaths(packagePath);
+    this._entryMap = this._getEntryMap(allDepPaths);
+    // const ngDepPaths = this._getNgDepPaths(allDepPaths);
+    // this._entryMap = this._getEntryMap(ngDepPaths);
+  }
+
+  public removeCaches(filePaths: string[]): void {
+    for (const filePath of filePaths) {
+      this._fileMetaCache.delete(filePath);
+    }
+  }
+
+  public getEntryFileMetaRecord(): Record<string, SdCliBbFileMetadata> {
+    const result: Record<string, SdCliBbFileMetadata> = {};
+    for (const moduleName of this._entryMap.keys()) {
+      const entryFilePath = this._entryMap.get(moduleName)!;
+      result[moduleName] = this._fileMetaCache.getOrCreate(entryFilePath, () => new SdCliBbFileMetadata(entryFilePath))!;
+    }
+    return result;
+  }
+
+  public findMeta(ref: TSdCliMetaRef): TSdCliBbMetadata | TSdCliBbMetadata[] {
+    const filePath = "moduleName" in ref ? this._entryMap.get(ref.moduleName) : ref.filePath;
+    if (filePath === undefined) {
+      throw new NeverEntryError();
+    }
+    const fileMeta = this._fileMetaCache.getOrCreate(filePath, () => new SdCliBbFileMetadata(filePath));
+    if (ref.name === "*") {
+      const result: TSdCliBbMetadata[] = [];
+      for (const exp of fileMeta.exports) {
+        const meta = exp.target;
+        if (typeof meta !== "string" && "__TDeclRef__" in meta) {
+          const resultMeta = this.findMeta(meta);
+          if (resultMeta instanceof Array) {
+            result.push(...resultMeta);
+          }
+          else {
+            result.push(resultMeta);
+          }
+        }
+        else {
+          result.push(meta);
+        }
+      }
+      return result;
+    }
+    else {
+      const meta = fileMeta.findMetaFromOutside(ref.name);
+      if (typeof meta !== "string" && "__TDeclRef__" in meta) {
+        return this.findMeta(meta);
+      }
+      return meta;
+    }
+  }
+
+  public findExportRef(localRef: { filePath: string; name: string }): { moduleName: string; name: string } | undefined {
+    const record = this.getEntryFileMetaRecord();
+    for (const moduleName of Object.keys(record)) {
+      const entryFileMeta = record[moduleName];
+      for (const exp of entryFileMeta.exports) {
+        if (
+          typeof exp.target !== "string" &&
+          "filePath" in exp.target &&
+          exp.target.filePath === localRef.filePath
+        ) {
+          if (exp.target.name === "*") {
+            throw new NeverEntryError();
+          }
+          else if (exp.target.name === localRef.name) {
+            return { moduleName, name: exp.exportedName };
+          }
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  private _getAllDepPaths(packagePath: string): string[] {
+    const loadedModuleNames: string[] = [];
+    const results: string[] = [];
+
+    const fn = (currPath: string): void => {
+      const npmConfig = FsUtil.readJson(path.resolve(currPath, "package.json")) as INpmConfig;
+
+      const deps = SdCliNpmConfigUtil.getDependencies(npmConfig);
+
+      for (const moduleName of deps.defaults) {
+        if (loadedModuleNames.includes(moduleName)) continue;
+        loadedModuleNames.push(moduleName);
+
+        const modulePath = FsUtil.findAllParentChildDirPaths("node_modules/" + moduleName, currPath, process.cwd()).first();
+        if (StringUtil.isNullOrEmpty(modulePath)) {
+          continue;
+        }
+
+        results.push(modulePath);
+
+        fn(modulePath);
+      }
+    };
+
+    fn(packagePath);
+
+    return results;
+  }
+
+  // private _getNgDepPaths(allDepPaths: string[]): string[] {
+  //   const results: string[] = [];
+  //
+  //   for (const depPath of allDepPaths) {
+  //     const npmConfig = FsUtil.readJson(path.resolve(depPath, "package.json")) as INpmConfig;
+  //     const defaultDeps = SdCliNpmConfigUtil.getDependencies(npmConfig).defaults;
+  //     if (npmConfig.name === "@angular/core" || defaultDeps.includes("@angular/core")) {
+  //       results.push(depPath);
+  //     }
+  //   }
+  //
+  //   return results;
+  // }
+
+  private _getEntryMap(ngDepPaths: string[]): Map<string, string> {
+    const entryMap = new Map<string, string>();
+    for (const ngDepPath of ngDepPaths) {
+      const npmConfig = FsUtil.readJson(path.resolve(ngDepPath, "package.json")) as INpmConfig;
+
+      const entryFilePath = npmConfig["es2015"] ?? npmConfig["browser"] ?? npmConfig["module"] ?? npmConfig["main"] ?? npmConfig["default"];
+      if (entryFilePath !== undefined) {
+        entryMap.set(npmConfig.name, path.resolve(ngDepPath, entryFilePath));
+      }
+
+      if (npmConfig.exports) {
+        const exportKeys = Object.keys(npmConfig.exports);
+        for (const exportKey of exportKeys) {
+          if (
+            exportKey.includes("/locales") ||
+            exportKey.endsWith("/package.json") ||
+            exportKey.endsWith("/testing") ||
+            exportKey.endsWith("/upgrade")
+          ) {
+            continue;
+          }
+
+          const expEntryFilePath = npmConfig.exports[exportKey]["es2015"] ??
+            npmConfig.exports[exportKey]["browser"] ??
+            npmConfig.exports[exportKey]["module"] ??
+            npmConfig.exports[exportKey]["main"] ??
+            npmConfig.exports[exportKey]["default"];
+          if (expEntryFilePath !== undefined) {
+            const exportPath = path.resolve(ngDepPath, expEntryFilePath);
+            const exportResult = this._getGlobExportResult(PathUtil.posix(npmConfig.name, exportKey), exportPath);
+            for (const exportResultItem of exportResult) {
+              entryMap.set(exportResultItem.name, exportResultItem.target);
+            }
+          }
+        }
+      }
+    }
+
+    return entryMap;
+  }
+
+  private _getGlobExportResult(globName: string, globTarget: string): { name: string; target: string }[] {
+    if (globName.includes("*") && globTarget.includes("*")) {
+      const result: { name: string; target: string }[] = [];
+
+      const regexpText = globTarget.replace(/[\\/.*]/g, (item) => (
+        item === "/" || item === "\\" ? "[\\\\/]"
+          : item === "." ? "\\."
+            : item === "*" ? "(.*)"
+              : item
+      ));
+
+      const targets = FsUtil.glob(globTarget);
+      for (const target of targets) {
+        const targetNameMatch = new RegExp(regexpText).exec(target);
+        if (!targetNameMatch || typeof targetNameMatch[1] === "undefined") {
+          throw new NeverEntryError();
+        }
+        const targetName = targetNameMatch[1];
+        const name = globName.replace("*", targetName);
+        result.push({ name, target });
+      }
+
+      return result;
+    }
+    else {
+      return [{ name: globName, target: globTarget }];
+    }
+  }
+}
+
+export type TSdCliBbMetadata = TSdCliBbTypeMetadata | TSdCliMetaRef | string;

package/src/ng-tools/babel/SdCliBbUtil.ts

@@ -0,0 +1,15 @@
+import { Node } from "@babel/types";
+import { SdCliBuildResultError } from "../../SdCliBuildResultError";
+
+export class SdCliBbUtil {
+  public static error(message: string, filePath?: string, meta?: Node): SdCliBuildResultError {
+    return new SdCliBuildResultError({
+      filePath,
+      line: meta?.loc?.start.line,
+      char: meta?.loc?.start.column,
+      code: undefined,
+      severity: "error",
+      message: "예상치 못한 방식의 코드가 발견되었습니다."
+    });
+  }
+}