@simplysm/sd-cli 7.3.4 → 10.0.21

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

@@ -1,212 +0,0 @@
-import {
-  ArrayExpression,
-  ClassDeclaration,
-  ConditionalExpression,
-  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 |
-  SdCliBbConditionMetadata;
-
-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;
-  }
-}
-
-export class SdCliBbConditionMetadata {
-  public constructor(private readonly _fileMeta: SdCliBbFileMetadata,
-                     private readonly _metadata: ConditionalExpression) {
-  }
-
-  private _testCache?: TSdCliBbMetadata | undefined;
-
-  public get test(): TSdCliBbMetadata | undefined {
-    if (this._testCache === undefined) {
-      this._testCache = this._fileMeta.getMetaFromRaw(this._metadata.test);
-    }
-    return this._testCache;
-  }
-
-  private _consequentCache?: TSdCliBbMetadata | undefined;
-
-  public get consequent(): TSdCliBbMetadata | undefined {
-    if (this._consequentCache === undefined) {
-      this._consequentCache = this._fileMeta.getMetaFromRaw(this._metadata.consequent);
-    }
-    return this._consequentCache;
-  }
-
-  private _alternateCache?: TSdCliBbMetadata | undefined;
-
-  public get alternate(): TSdCliBbMetadata | undefined {
-    if (this._alternateCache === undefined) {
-      this._alternateCache = this._fileMeta.getMetaFromRaw(this._metadata.alternate);
-    }
-    return this._alternateCache;
-  }
-}

package/src/ng-tools/commons.ts

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

package/src/ng-tools/typescript/SdCliTsFileMetadata.ts

@@ -1,384 +0,0 @@
-import { FsUtil } from "@simplysm/sd-core-node";
-import ts from "typescript";
-import { NeverEntryError } from "@simplysm/sd-core-common";
-import { TSdCliMetaRef } from "../commons";
-import path from "path";
-
-export class SdCliTsFileMetadata {
-  public readonly sourceFile: ts.SourceFile;
-
-  public constructor(public readonly filePath: string) {
-    const fileContent = FsUtil.readFile(filePath);
-    this.sourceFile = ts.createSourceFile(filePath, fileContent, ts.ScriptTarget.ES2017);
-  }
-
-  private _directExportClassesCache?: { exportedName: string; target: SdCliTsClassMetadata }[];
-
-  public get directExportClasses(): { exportedName: string; target: SdCliTsClassMetadata }[] {
-    if (this._directExportClassesCache) return this._directExportClassesCache;
-
-    const result: { exportedName: string; target: SdCliTsClassMetadata }[] = [];
-    this.sourceFile.forEachChild((node) => {
-      if (!ts.canHaveModifiers(node) || !ts.getModifiers(node)?.some((item) => item.kind === ts.SyntaxKind.ExportKeyword)) return;
-      if (!ts.isClassDeclaration(node)) return;
-      if (node.name === undefined) {
-        throw new NeverEntryError();
-      }
-      result.push({ exportedName: node.name.text, target: new SdCliTsClassMetadata(this, node) });
-    });
-
-    this._directExportClassesCache = result;
-    return result;
-  }
-
-  public get imports(): TSdCliMetaRef[] {
-    const result: TSdCliMetaRef[] = [];
-
-    ts.forEachChild(this.sourceFile, (node) => {
-      if (ts.isImportDeclaration(node)) {
-        if (ts.isStringLiteral(node.moduleSpecifier)) {
-          if (node.importClause) {
-            if (node.moduleSpecifier.text.startsWith(".")) {
-              const moduleFilePath = path.resolve(path.dirname(this.filePath), node.moduleSpecifier.text);
-
-              if (node.importClause.namedBindings) {
-                if (ts.isNamedImports(node.importClause.namedBindings)) {
-                  for (const el of node.importClause.namedBindings.elements) {
-                    result.push({
-                      filePath: moduleFilePath,
-                      name: el.name.text,
-                      __TSdCliMetaRef__: "__TSdCliMetaRef__" as const
-                    });
-                  }
-                }
-                else {
-                  // throw SdCliTsUtil.error("'import * as [name] from ...'을 'import [name] from ...'로 변경하세요.", this.sourceFile, node);
-                }
-              }
-              else {
-                result.push({
-                  filePath: moduleFilePath,
-                  name: "default",
-                  __TSdCliMetaRef__: "__TSdCliMetaRef__" as const
-                });
-              }
-            }
-            else {
-              const moduleName = node.moduleSpecifier.text;
-              if (node.importClause.namedBindings) {
-                if (ts.isNamedImports(node.importClause.namedBindings)) {
-                  for (const el of node.importClause.namedBindings.elements) {
-                    result.push({
-                      moduleName,
-                      name: el.propertyName?.text ?? el.name.text,
-                      __TSdCliMetaRef__: "__TSdCliMetaRef__" as const
-                    });
-                  }
-                }
-                else {
-                  const nsUseList = this._findNamespaceUse(node.importClause.namedBindings.name.text);
-                  for (const nsUse of nsUseList) {
-                    result.push({
-                      moduleName,
-                      name: nsUse,
-                      __TSdCliMetaRef__: "__TSdCliMetaRef__" as const
-                    });
-                  }
-                }
-              }
-              else if (node.importClause.name) {
-                const nsUseList = this._findNamespaceUse(node.importClause.name.text);
-                for (const nsUse of nsUseList) {
-                  result.push({
-                    moduleName: moduleName,
-                    name: nsUse,
-                    __TSdCliMetaRef__: "__TSdCliMetaRef__" as const
-                  });
-                }
-              }
-              else {
-                throw new NeverEntryError();
-              }
-            }
-          }
-          else {
-            // 무시
-          }
-        }
-        else {
-          throw new NeverEntryError();
-        }
-      }
-      else if (ts.isExportDeclaration(node)) {
-        if (
-          node.exportClause &&
-          ts.isNamedExports(node.exportClause) &&
-          node.moduleSpecifier &&
-          ts.isStringLiteral(node.moduleSpecifier)
-        ) {
-          if (node.moduleSpecifier.text.startsWith(".")) {
-            const moduleFilePath = path.resolve(path.dirname(this.filePath), node.moduleSpecifier.text);
-            for (const el of node.exportClause.elements) {
-              if (el.propertyName && el.name.text !== el.propertyName.text) {
-                throw new NeverEntryError();
-              }
-
-              result.push({
-                filePath: moduleFilePath,
-                name: el.name.text,
-                __TSdCliMetaRef__: "__TSdCliMetaRef__" as const
-              });
-            }
-          }
-          else {
-            throw new NeverEntryError();
-          }
-        }
-        else {
-          throw new NeverEntryError();
-        }
-      }
-    });
-
-    return result;
-  }
-
-  private _findNamespaceUse(localName: string): string[] {
-    const fn = (parent: ts.Node): string[] => {
-      const result: string[] = [];
-      ts.forEachChild(parent, (node) => {
-        if (ts.isPropertyAccessExpression(node)) {
-          if (
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === localName &&
-            ts.isIdentifier(node.name)
-          ) {
-            result.push(node.name.text);
-          }
-        }
-        else {
-          result.push(...fn(node));
-        }
-      });
-
-      return result;
-    };
-
-    return fn(this.sourceFile);
-  }
-
-  public getMetaFromNode(node: ts.Node): TSdCliTsMetadata {
-    if (ts.isClassDeclaration(node)) {
-      return new SdCliTsClassMetadata(this, node);
-    }
-    else if (ts.isStringLiteral(node)) {
-      return node.text;
-    }
-    else if (ts.isNoSubstitutionTemplateLiteral(node)) {
-      return node.text;
-    }
-    else if (node.kind === ts.SyntaxKind.NullKeyword) {
-      return null;
-    }
-
-    throw new NeverEntryError();
-  }
-}
-
-export class SdCliTsClassMetadata {
-  public constructor(private readonly _fileMeta: SdCliTsFileMetadata,
-                     private readonly _node: ts.ClassDeclaration) {
-  }
-
-  private _ngDeclCache?: TSdCliTsNgMetadata;
-
-  public get ngDecl(): TSdCliTsNgMetadata | undefined {
-    if (this._ngDeclCache !== undefined) return this._ngDeclCache;
-
-    if (!ts.canHaveDecorators(this._node)) return undefined;
-
-    for (const deco of ts.getDecorators(this._node) ?? []) {
-      if (!ts.isCallExpression(deco.expression)) continue;
-      if (!ts.isIdentifier(deco.expression.expression)) {
-        throw new NeverEntryError();
-      }
-
-      if (deco.expression.expression.text === "Injectable") {
-        this._ngDeclCache = new SdCliTsNgInjectableMetadata(this._fileMeta, deco);
-        return this._ngDeclCache;
-      }
-      else if (deco.expression.expression.text === "Directive") {
-        this._ngDeclCache = new SdCliTsNgDirectiveMetadata(this._fileMeta, deco);
-        return this._ngDeclCache;
-      }
-      else if (deco.expression.expression.text === "Component") {
-        this._ngDeclCache = new SdCliTsNgComponentMetadata(this._fileMeta, deco);
-        return this._ngDeclCache;
-      }
-      else if (deco.expression.expression.text === "Pipe") {
-        this._ngDeclCache = new SdCliTsNgPipeMetadata(this._fileMeta, deco);
-        return this._ngDeclCache;
-      }
-    }
-
-    return undefined;
-  }
-}
-
-export class SdCliTsObjectMetadata {
-  public constructor(private readonly _fileMeta: SdCliTsFileMetadata,
-                     private readonly _node: ts.ObjectLiteralExpression) {
-  }
-
-  private readonly _getPropValueCache = new Map<string, TSdCliTsMetadata | undefined>();
-
-  public getPropValue(propName: string): TSdCliTsMetadata | undefined {
-    if (this._getPropValueCache.has(propName)) {
-      return this._getPropValueCache.get(propName);
-    }
-
-    const prop = this._node.properties.single((item) => (
-      ts.isPropertyAssignment(item) &&
-      ts.isIdentifier(item.name) &&
-      item.name.text === propName
-    )) as ts.PropertyAssignment | undefined;
-    if (!prop) {
-      this._getPropValueCache.set(propName, undefined);
-      return undefined;
-    }
-
-    const result = this._fileMeta.getMetaFromNode(prop.initializer);
-    this._getPropValueCache.set(propName, result);
-    return result;
-  }
-}
-
-export type TSdCliTsMetadata = SdCliTsClassMetadata
-  | SdCliTsObjectMetadata
-  | TSdCliMetaRef
-  | string
-  | null;
-
-export class SdCliTsNgInjectableMetadata {
-  public constructor(private readonly _fileMeta: SdCliTsFileMetadata,
-                     private readonly _node: ts.Decorator) {
-  }
-
-  private _providedInCache?: string;
-
-  public get providedIn(): string | undefined {
-    if (this._providedInCache !== undefined) return this._providedInCache;
-
-    if (!ts.isCallExpression(this._node.expression)) throw new NeverEntryError();
-
-    if (this._node.expression.arguments.length > 0 && ts.isObjectLiteralExpression(this._node.expression.arguments[0])) {
-      const decoArg = new SdCliTsObjectMetadata(this._fileMeta, this._node.expression.arguments[0]);
-      const decoArgSelectorVal = decoArg.getPropValue("providedIn");
-      if (typeof decoArgSelectorVal === "string") {
-        this._providedInCache = decoArgSelectorVal;
-        return decoArgSelectorVal;
-      }
-    }
-
-    return undefined;
-  }
-}
-
-export class SdCliTsNgDirectiveMetadata {
-  public constructor(private readonly _fileMeta: SdCliTsFileMetadata,
-                     private readonly _node: ts.Decorator) {
-  }
-
-  private _selectorCache?: string;
-
-  public get selector(): string {
-    if (this._selectorCache !== undefined) return this._selectorCache;
-
-    if (!ts.isCallExpression(this._node.expression)) throw new NeverEntryError();
-
-    if (this._node.expression.arguments.length > 0 && ts.isObjectLiteralExpression(this._node.expression.arguments[0])) {
-      const decoArg = new SdCliTsObjectMetadata(this._fileMeta, this._node.expression.arguments[0]);
-      const decoArgSelectorVal = decoArg.getPropValue("selector");
-      if (typeof decoArgSelectorVal === "string") {
-        this._selectorCache = decoArgSelectorVal;
-        return decoArgSelectorVal;
-      }
-    }
-
-    throw new NeverEntryError();
-  }
-}
-
-export class SdCliTsNgComponentMetadata {
-  public constructor(private readonly _fileMeta: SdCliTsFileMetadata,
-                     private readonly _node: ts.Decorator) {
-  }
-
-  private _selectorCache?: string;
-
-  public get selector(): string {
-    if (this._selectorCache !== undefined) return this._selectorCache;
-
-    if (!ts.isCallExpression(this._node.expression)) throw new NeverEntryError();
-
-    if (this._node.expression.arguments.length > 0 && ts.isObjectLiteralExpression(this._node.expression.arguments[0])) {
-      const decoArg = new SdCliTsObjectMetadata(this._fileMeta, this._node.expression.arguments[0]);
-      const decoArgSelectorVal = decoArg.getPropValue("selector");
-      if (typeof decoArgSelectorVal === "string") {
-        this._selectorCache = decoArgSelectorVal;
-        return decoArgSelectorVal;
-      }
-    }
-
-    throw new NeverEntryError();
-  }
-
-  private _templateCache?: string;
-
-  public get template(): string {
-    if (this._templateCache !== undefined) return this._templateCache;
-
-    if (!ts.isCallExpression(this._node.expression)) throw new NeverEntryError();
-
-    if (this._node.expression.arguments.length > 0 && ts.isObjectLiteralExpression(this._node.expression.arguments[0])) {
-      const decoArg = new SdCliTsObjectMetadata(this._fileMeta, this._node.expression.arguments[0]);
-      const decoArgSelectorVal = decoArg.getPropValue("template");
-      if (typeof decoArgSelectorVal === "string") {
-        this._templateCache = decoArgSelectorVal;
-        return decoArgSelectorVal;
-      }
-    }
-
-    throw new NeverEntryError();
-  }
-}
-
-export class SdCliTsNgPipeMetadata {
-  public constructor(private readonly _fileMeta: SdCliTsFileMetadata,
-                     private readonly _node: ts.Decorator) {
-  }
-
-  private _pipeNameCache?: string;
-
-  public get pipeName(): string {
-    if (this._pipeNameCache !== undefined) return this._pipeNameCache;
-
-    if (!ts.isCallExpression(this._node.expression)) throw new NeverEntryError();
-
-    if (this._node.expression.arguments.length > 0 && ts.isObjectLiteralExpression(this._node.expression.arguments[0])) {
-      const decoArg = new SdCliTsObjectMetadata(this._fileMeta, this._node.expression.arguments[0]);
-      const decoArgSelectorVal = decoArg.getPropValue("name");
-      if (typeof decoArgSelectorVal === "string") {
-        this._pipeNameCache = decoArgSelectorVal;
-        return decoArgSelectorVal;
-      }
-    }
-
-    throw new NeverEntryError();
-  }
-}
-
-export type TSdCliTsNgMetadata = SdCliTsNgInjectableMetadata
-  | SdCliTsNgDirectiveMetadata
-  | SdCliTsNgComponentMetadata
-  | SdCliTsNgPipeMetadata;

package/src/ng-tools/typescript/SdCliTsRootMetadata.ts

@@ -1,32 +0,0 @@
-import path from "path";
-import ts from "typescript";
-import { FsUtil } from "@simplysm/sd-core-node";
-import { SdCliTsFileMetadata } from "./SdCliTsFileMetadata";
-
-export class SdCliTsRootMetadata {
-  private readonly _fileMetaCache = new Map<string, SdCliTsFileMetadata>();
-
-  public constructor(private readonly _packagePath: string) {
-  }
-
-  public removeCaches(filePaths: string[]): void {
-    for (const filePath of filePaths) {
-      this._fileMetaCache.delete(filePath);
-    }
-  }
-
-  public getFileMetas(): SdCliTsFileMetadata[] {
-    const tsconfigPath = path.resolve(this._packagePath, "tsconfig-build.json");
-    const tsconfig = FsUtil.readJson(tsconfigPath);
-    const parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this._packagePath, tsconfig.angularCompilerOptions);
-
-    const result: SdCliTsFileMetadata[] = [];
-    for (const fileName of parsedTsconfig.fileNames) {
-      const filePath = path.resolve(fileName);
-      const fileMeta = this._fileMetaCache.getOrCreate(filePath, () => new SdCliTsFileMetadata(filePath));
-      result.push(fileMeta);
-    }
-
-    return result;
-  }
-}

package/src/ng-tools/typescript/SdCliTsUtil.ts

@@ -1,29 +0,0 @@
-import ts from "typescript";
-import { SdCliBuildResultError } from "../../SdCliBuildResultError";
-import path from "path";
-
-export class SdCliTsUtil {
-  public static error(message: string, sourceFile: ts.SourceFile, meta?: ts.Node): SdCliBuildResultError {
-    if (meta) {
-      const pos = sourceFile.getLineAndCharacterOfPosition(meta.getStart());
-      return new SdCliBuildResultError({
-        filePath: path.resolve(sourceFile.fileName),
-        line: pos.line,
-        char: pos.character,
-        code: undefined,
-        severity: "error",
-        message: message
-      });
-    }
-    else {
-      return new SdCliBuildResultError({
-        filePath: path.resolve(sourceFile.fileName),
-        line: undefined,
-        char: undefined,
-        code: undefined,
-        severity: "error",
-        message: message
-      });
-    }
-  }
-}