@simplysm/sd-cli 7.0.59 → 7.0.66

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

@@ -0,0 +1,385 @@
+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";
+import { SdCliTsUtil } from "./SdCliTsUtil";
+
+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 (!node.modifiers || !node.modifiers.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.includes(".")) {
+              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.includes(".")) {
+            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 (!this._node.decorators) return undefined;
+
+    for (const deco of this._node.decorators) {
+      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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,29 @@
+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
+      });
+    }
+  }
+}

package/src/packages/SdCliPackage.ts

@@ -96,8 +96,7 @@ export class SdCliPackage extends EventEmitter {
     }
 
     if (this.config.type === "library") {
-      // const isAngular = isTs && this.allDependencies.includes("@angular/core");
-      return isTs ? new SdCliTsLibBuilder(this.rootPath) : new SdCliJsLibBuilder(this.rootPath);
+      return isTs ? new SdCliTsLibBuilder(this.rootPath, this.config, this._workspaceRootPath) : new SdCliJsLibBuilder(this.rootPath);
     }
     else if (this.config.type === "server") {
       return new SdCliServerBuilder(this.rootPath, this.config, this._workspaceRootPath);

package/src/utils/SdCliNpmConfigUtil.ts

@@ -5,11 +5,11 @@ export class SdCliNpmConfigUtil {
     return {
       defaults: [
         ...Object.keys(npmConfig.dependencies ?? {}),
-        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => !npmConfig.peerDependenciesMeta?.[item].optional)
+        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => !npmConfig.peerDependenciesMeta?.[item]?.optional)
       ].distinct(),
       optionals: [
         ...Object.keys(npmConfig.optionalDependencies ?? {}),
-        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => npmConfig.peerDependenciesMeta?.[item].optional)
+        ...Object.keys(npmConfig.peerDependencies ?? {}).filter((item) => npmConfig.peerDependenciesMeta?.[item]?.optional)
       ].distinct()
     };
   }

package/tsconfig-build.json

@@ -5,6 +5,10 @@
       "ES2020"
     ],
     "outDir": "./dist",
-    "declaration": false
-  }
+    "declaration": true
+  },
+  "files": [
+    "src/bin/sd-cli.ts",
+    "src/index.ts"
+  ]
 }

package/tsconfig.json

@@ -20,5 +20,9 @@
         "../sd-service-server/src/index.ts"
       ]
     }
-  }
+  },
+  "files": [
+    "src/bin/sd-cli.ts",
+    "src/index.ts"
+  ]
 }