@simplysm/sd-cli 7.0.59 → 7.0.66

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

@@ -0,0 +1,211 @@
+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" && "__TSdCliMetaRef__" 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 (meta === undefined) {
+        throw new NeverEntryError();
+      }
+
+      if (typeof meta !== "string" && "__TSdCliMetaRef__" 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 === "*") {
+            return { moduleName, name: localRef.name };
+          }
+          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 (typeof entryFilePath === "string") {
+        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(".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 (typeof expEntryFilePath === "string") {
+            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: message
+    });
+  }
+}

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

@@ -0,0 +1,234 @@
+import { NeverEntryError } from "@simplysm/sd-core-common";
+import { SdCliBbFileMetadata } from "./SdCliBbFileMetadata";
+import { SdCliBbArrayMetadata, SdCliBbVariableMetadata } from "./TSdCliBbTypeMetadata";
+import { TSdCliBbMetadata } from "./SdCliBbRootMetadata";
+
+export type TSdCliBbNgMetadata =
+  SdCliBbNgModuleMetadata
+  | SdCliBbNgInjectableMetadata
+  | SdCliBbNgDirectiveMetadata
+  | SdCliBbNgComponentMetadata
+  | SdCliBbNgPipeMetadata;
+
+export class SdCliBbNgModuleMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     private readonly _className: string) {
+  }
+
+  private _defCache?: ISdCliBbNgModuleDef;
+
+  public get def(): ISdCliBbNgModuleDef {
+    if (this._defCache) return this._defCache;
+
+    const result: ISdCliBbNgModuleDef = {
+      exports: [],
+      providers: []
+    };
+
+    const argObjMeta = this._fileMeta.getNgDecoArg(this._className);
+
+    const expVal = argObjMeta.getPropValue("exports") ?? this._fileMeta.getNgDecoPropValue(this._className, "ɵmod", "exports");
+    if (expVal !== undefined) {
+      const expMetas = this._getExportAndProviderMetas(expVal);
+      result.exports.push(...expMetas);
+    }
+
+    const provVal = argObjMeta.getPropValue("providers") ?? this._fileMeta.getNgDecoPropValue(this._className, "ɵmod", "providers");
+    if (provVal !== undefined) {
+      const provMetas = this._getExportAndProviderMetas(provVal);
+      result.providers.push(...provMetas);
+    }
+
+    /*for (const meta of this._fileMeta.rawMetas) {
+      if (
+        isExpressionStatement(meta) &&
+        isAssignmentExpression(meta.expression) &&
+        isMemberExpression(meta.expression.left) &&
+        isIdentifier(meta.expression.left.object) &&
+        meta.expression.left.object.name === this._className &&
+        isIdentifier(meta.expression.left.property)
+      ) {
+        if (meta.expression.left.property.name === "ɵmod") {
+          if (
+            isCallExpression(meta.expression.right) &&
+            meta.expression.right.arguments.length > 0 &&
+            isObjectExpression(meta.expression.right.arguments[0])
+          ) {
+            const expObjMeta = new SdCliBbObjectMetadata(this._fileMeta, meta.expression.right.arguments[0]);
+            const expVal = expObjMeta.getPropValue("exports");
+            if (expVal !== undefined) {
+              if (expVal instanceof SdCliBbArrayMetadata) {
+                for (const expMeta of expVal.value.filterExists()) {
+                  result.exports.push(expMeta);
+                }
+              }
+              else {
+                throw new NeverEntryError();
+              }
+            }
+          }
+          else {
+            throw new NeverEntryError();
+          }
+        }
+
+        if (meta.expression.left.property.name === "ɵinj") {
+          if (
+            isCallExpression(meta.expression.right) &&
+            meta.expression.right.arguments.length > 0 &&
+            isObjectExpression(meta.expression.right.arguments[0])
+          ) {
+            const provObjMeta = new SdCliBbObjectMetadata(this._fileMeta, meta.expression.right.arguments[0]);
+            const provVal = provObjMeta.getPropValue("providers");
+            if (provVal !== undefined) {
+              const provMetas = this._getProviderMetas(provVal);
+              for (const provMeta of provMetas) {
+                result.providers.push(provMeta);
+              }
+            }
+          }
+          else {
+            throw new NeverEntryError();
+          }
+        }
+      }
+    }*/
+
+    this._defCache = result;
+    return result;
+  }
+
+  private _getExportAndProviderMetas(meta: TSdCliBbMetadata): TSdCliBbMetadata[] {
+    const result: TSdCliBbMetadata[] = [];
+
+    if (meta instanceof SdCliBbArrayMetadata) {
+      for (const metaItem of meta.value.filterExists()) {
+        result.push(...this._getExportAndProviderMetas(metaItem));
+      }
+    }
+    else if (meta instanceof SdCliBbVariableMetadata) {
+      if (meta.value !== undefined) {
+        result.push(...this._getExportAndProviderMetas(meta.value));
+      }
+    }
+    else {
+      result.push(meta);
+    }
+
+    return result;
+  }
+}
+
+export class SdCliBbNgInjectableMetadata {
+
+  public constructor(
+    // @ts-expect-error
+    private readonly _fileMeta: SdCliBbFileMetadata,
+    // @ts-expect-error
+    private readonly _className: string) {
+  }
+}
+
+export class SdCliBbNgDirectiveMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     private readonly _className: string) {
+  }
+
+  private _selectorCache?: string;
+
+  public get selector(): string {
+    if (this._selectorCache !== undefined) return this._selectorCache;
+
+    const argObjMeta = this._fileMeta.getNgDecoArg(this._className);
+    const val = argObjMeta.getPropValue("selector") ?? this._fileMeta.getNgDecoPropValue(this._className, "ɵdir", "selector");
+    if (typeof val === "string") {
+      this._selectorCache = val;
+      return this._selectorCache;
+    }
+    else {
+      throw new NeverEntryError();
+    }
+  }
+}
+
+export class SdCliBbNgComponentMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     private readonly _className: string) {
+  }
+
+  private _selectorCache?: string;
+
+  public get selector(): string {
+    if (this._selectorCache !== undefined) return this._selectorCache;
+
+    const argObjMeta = this._fileMeta.getNgDecoArg(this._className);
+    const val = argObjMeta.getPropValue("selector") ?? this._fileMeta.getNgDecoPropValue(this._className, "ɵcmp", "selector");
+    if (typeof val === "string") {
+      this._selectorCache = val;
+      return this._selectorCache;
+    }
+    else {
+      throw new NeverEntryError();
+    }
+  }
+}
+
+export class SdCliBbNgPipeMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     private readonly _className: string) {
+  }
+
+  private _pipeNameCache?: string;
+
+  public get pipeName(): string {
+    if (this._pipeNameCache !== undefined) return this._pipeNameCache;
+
+    const argObjMeta = this._fileMeta.getNgDecoArg(this._className);
+    const val = argObjMeta.getPropValue("name") ?? this._fileMeta.getNgDecoPropValue(this._className, "ɵpipe", "name");
+    if (typeof val === "string") {
+      this._pipeNameCache = val;
+      return val;
+    }
+    else {
+      throw new NeverEntryError();
+    }
+  }
+}
+
+interface ISdCliBbNgModuleDef {
+  exports: TSdCliBbMetadata[];
+  providers: TSdCliBbMetadata[];
+}
+
+/*
+class SdCliNgMetadataUtil {
+  public static getDecoPropValue(fileMeta: SdCliBbFileMetadata, className: string, decoName: string, propName: string): TSdCliBbMetadata | undefined {
+    for (const meta of fileMeta.rawMetas) {
+      if (
+        isExpressionStatement(meta) &&
+        isAssignmentExpression(meta.expression) &&
+        isMemberExpression(meta.expression.left) &&
+        isIdentifier(meta.expression.left.object) &&
+        meta.expression.left.object.name === className &&
+        isIdentifier(meta.expression.left.property)
+      ) {
+        if (meta.expression.left.property.name === decoName) {
+          if (
+            isCallExpression(meta.expression.right) &&
+            meta.expression.right.arguments.length > 0 &&
+            isObjectExpression(meta.expression.right.arguments[0])
+          ) {
+            const dirObjMeta = new SdCliBbObjectMetadata(fileMeta, meta.expression.right.arguments[0]);
+            return dirObjMeta.getPropValue(propName);
+          }
+          else {
+            throw new NeverEntryError();
+          }
+        }
+      }
+    }
+
+    throw new NeverEntryError();
+  }
+}
+*/

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

@@ -0,0 +1,177 @@
+import {
+  ArrayExpression,
+  ClassDeclaration,
+  FunctionDeclaration,
+  isAssignmentExpression,
+  isExpressionStatement,
+  isIdentifier,
+  isMemberExpression,
+  isObjectProperty,
+  ObjectExpression,
+  VariableDeclarator
+} from "@babel/types";
+import { NeverEntryError } from "@simplysm/sd-core-common";
+import { SdCliBbFileMetadata } from "./SdCliBbFileMetadata";
+import {
+  SdCliBbNgComponentMetadata,
+  SdCliBbNgDirectiveMetadata,
+  SdCliBbNgInjectableMetadata,
+  SdCliBbNgModuleMetadata,
+  SdCliBbNgPipeMetadata,
+  TSdCliBbNgMetadata
+} from "./TSdCliBbNgMetadata";
+import { TSdCliBbMetadata } from "./SdCliBbRootMetadata";
+
+export type TSdCliBbTypeMetadata = SdCliBbClassMetadata |
+  SdCliBbVariableMetadata |
+  SdCliBbFunctionMetadata |
+  SdCliBbObjectMetadata |
+  SdCliBbArrayMetadata;
+
+export class SdCliBbClassMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     private readonly _rawMeta: ClassDeclaration) {
+  }
+
+  public get filePath(): string {
+    return this._fileMeta.filePath;
+  }
+
+  public get name(): string {
+    return this._rawMeta.id.name;
+  }
+
+  private _ngDeclCache?: TSdCliBbNgMetadata | "none";
+
+  public get ngDecl(): TSdCliBbNgMetadata | undefined {
+    if (this._ngDeclCache !== undefined) {
+      return this._ngDeclCache === "none" ? undefined : this._ngDeclCache;
+    }
+
+    for (const meta of this._fileMeta.rawMetas) {
+      if (
+        isExpressionStatement(meta) &&
+        isAssignmentExpression(meta.expression) &&
+        isMemberExpression(meta.expression.left) &&
+        isIdentifier(meta.expression.left.object) &&
+        meta.expression.left.object.name === this._rawMeta.id.name &&
+        isIdentifier(meta.expression.left.property)
+      ) {
+        if (meta.expression.left.property.name === "ɵmod") {
+          this._ngDeclCache = new SdCliBbNgModuleMetadata(this._fileMeta, this._rawMeta.id.name);
+          return this._ngDeclCache;
+        }
+        else if (meta.expression.left.property.name === "ɵprov") {
+          this._ngDeclCache = new SdCliBbNgInjectableMetadata(this._fileMeta, this._rawMeta.id.name);
+          return this._ngDeclCache;
+        }
+        else if (meta.expression.left.property.name === "ɵdir") {
+          this._ngDeclCache = new SdCliBbNgDirectiveMetadata(this._fileMeta, this._rawMeta.id.name);
+          return this._ngDeclCache;
+        }
+        else if (meta.expression.left.property.name === "ɵcmp") {
+          this._ngDeclCache = new SdCliBbNgComponentMetadata(this._fileMeta, this._rawMeta.id.name);
+          return this._ngDeclCache;
+        }
+        else if (meta.expression.left.property.name === "ɵpipe") {
+          this._ngDeclCache = new SdCliBbNgPipeMetadata(this._fileMeta, this._rawMeta.id.name);
+          return this._ngDeclCache;
+        }
+      }
+    }
+
+    this._ngDeclCache = "none";
+    return undefined;
+  }
+}
+
+export class SdCliBbVariableMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     private readonly _rawMeta: VariableDeclarator) {
+  }
+
+  public get filePath(): string {
+    return this._fileMeta.filePath;
+  }
+
+  public get name(): string {
+    if (!isIdentifier(this._rawMeta.id)) throw new NeverEntryError();
+    return this._rawMeta.id.name;
+  }
+
+  private _valueCache?: TSdCliBbMetadata;
+
+  public get value(): TSdCliBbMetadata | undefined {
+    if (this._valueCache === undefined) {
+      this._valueCache = this._rawMeta.init == null ? undefined : this._fileMeta.getMetaFromRaw(this._rawMeta.init);
+    }
+
+    return this._valueCache;
+  }
+}
+
+export class SdCliBbFunctionMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     private readonly _rawMeta: FunctionDeclaration) {
+  }
+
+  public get filePath(): string {
+    return this._fileMeta.filePath;
+  }
+
+  public get name(): string {
+    if (!isIdentifier(this._rawMeta.id)) throw new NeverEntryError();
+    return this._rawMeta.id.name;
+  }
+}
+
+export class SdCliBbObjectMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     private readonly _metadata: ObjectExpression) {
+  }
+
+  private readonly _getPropValueCache = new Map<string, TSdCliBbMetadata | undefined>();
+
+  public getPropValue(propName: string): TSdCliBbMetadata | undefined {
+    if (this._getPropValueCache.has(propName)) {
+      return this._getPropValueCache.get(propName);
+    }
+
+    const prop = this._metadata.properties
+      .single((item) => (
+        isObjectProperty(item) &&
+        isIdentifier(item.key) &&
+        item.key.name === propName
+      ));
+    if (prop && !isObjectProperty(prop)) {
+      throw new NeverEntryError();
+    }
+
+    if (!prop) {
+      this._getPropValueCache.set(propName, undefined);
+      return undefined;
+    }
+
+    const result = this._fileMeta.getMetaFromRaw(prop.value);
+    this._getPropValueCache.set(propName, result);
+    return result;
+  }
+}
+
+export class SdCliBbArrayMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     private readonly _metadata: ArrayExpression) {
+  }
+
+  private _valueCache?: (TSdCliBbMetadata | undefined)[];
+
+  public get value(): (TSdCliBbMetadata | undefined)[] {
+    if (this._valueCache === undefined) {
+      this._valueCache = [];
+      for (const el of this._metadata.elements) {
+        this._valueCache.push(el ? this._fileMeta.getMetaFromRaw(el) : undefined);
+      }
+    }
+    return this._valueCache;
+  }
+}

package/src/ng-tools/commons.ts

@@ -0,0 +1,3 @@
+export type TSdCliMetaRef =
+  ({ filePath: string; name: string } | { moduleName: string; name: string })
+  & { __TSdCliMetaRef__: "__TSdCliMetaRef__" };