@simplysm/sd-cli 7.0.61 → 7.0.62

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

@@ -0,0 +1,220 @@
+import {
+  isAssignmentExpression,
+  isCallExpression,
+  isExpressionStatement,
+  isIdentifier,
+  isMemberExpression,
+  isObjectExpression
+} from "@babel/types";
+import { NeverEntryError } from "@simplysm/sd-core-common";
+import { SdCliBbFileMetadata } from "./SdCliBbFileMetadata";
+import { SdCliBbArrayMetadata, SdCliBbObjectMetadata, 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: []
+    };
+
+    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 _getProviderMetas(meta: TSdCliBbMetadata): TSdCliBbMetadata[] {
+    const result: TSdCliBbMetadata[] = [];
+
+    if (meta instanceof SdCliBbArrayMetadata) {
+      for (const metaItem of meta.value.filterExists()) {
+        result.push(...this._getProviderMetas(metaItem));
+      }
+    }
+    else if (meta instanceof SdCliBbVariableMetadata) {
+      if (meta.value !== undefined) {
+        result.push(...this._getProviderMetas(meta.value));
+      }
+    }
+    else {
+      result.push(meta);
+    }
+
+    return result;
+  }
+}
+
+export class SdCliBbNgInjectableMetadata {
+  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
+                     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 val = SdCliNgMetadataUtil.getDecoPropValue(this._fileMeta, this._className, "ɵdir", "selector");
+    if (typeof val === "string") {
+      this._selectorCache = val;
+      return val;
+    }
+    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 val = SdCliNgMetadataUtil.getDecoPropValue(this._fileMeta, this._className, "ɵcmp", "selector");
+    if (typeof val === "string") {
+      this._selectorCache = val;
+      return val;
+    }
+    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 val = SdCliNgMetadataUtil.getDecoPropValue(this._fileMeta, 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 })
+  & { __TDeclRef__: "__TDeclRef__" };