@teambit/typescript 0.0.588 → 0.0.592

package/package.json

@@ -1,36 +1,40 @@
 {
   "name": "@teambit/typescript",
-  "version": "0.0.588",
+  "version": "0.0.592",
   "homepage": "https://bit.dev/teambit/typescript/typescript",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.typescript",
     "name": "typescript",
-    "version": "0.0.588"
+    "version": "0.0.592"
   },
   "dependencies": {
+    "lodash": "4.17.21",
+    "tsutils": "3.21.0",
+    "typescript": "4.4.2",
     "@teambit/harmony": "0.2.11",
     "fs-extra": "10.0.0",
-    "typescript": "4.4.2",
-    "typedoc": "0.22.5",
     "p-map-series": "2.1.0",
     "chalk": "2.4.2",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/compiler": "0.0.588",
-    "@teambit/typescript.modules.ts-config-mutator": "0.0.61",
-    "@teambit/bit-error": "0.0.390",
-    "@teambit/builder": "0.0.588",
-    "@teambit/isolator": "0.0.588",
-    "@teambit/logger": "0.0.492",
-    "@teambit/component": "0.0.588",
-    "@teambit/schema": "0.0.588",
-    "@teambit/cli": "0.0.404",
-    "@teambit/pkg": "0.0.588",
-    "@teambit/ts-server": "0.0.27",
-    "@teambit/workspace": "0.0.588"
+    "@teambit/compiler": "0.0.592",
+    "@teambit/typescript.modules.ts-config-mutator": "0.0.63",
+    "@teambit/component": "0.0.592",
+    "@teambit/semantics.entities.semantic-schema": "0.0.3",
+    "@teambit/ts-server": "0.0.30",
+    "@teambit/aspect-loader": "0.0.592",
+    "@teambit/bit-error": "0.0.392",
+    "@teambit/builder": "0.0.592",
+    "@teambit/isolator": "0.0.592",
+    "@teambit/logger": "0.0.494",
+    "@teambit/schema": "0.0.592",
+    "@teambit/cli": "0.0.406",
+    "@teambit/pkg": "0.0.592",
+    "@teambit/workspace": "0.0.592"
   },
   "devDependencies": {
+    "@types/lodash": "4.14.165",
     "chai": "4.3.0",
     "@types/chai": "4.2.15",
     "@types/fs-extra": "9.0.7",
@@ -40,10 +44,10 @@
     "@types/jest": "^26.0.0",
     "@types/react-dom": "^17.0.5",
     "@types/node": "12.20.4",
-    "@teambit/typescript.aspect-docs.typescript": "0.0.126"
+    "@teambit/typescript.aspect-docs.typescript": "0.0.128"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.190",
+    "@teambit/legacy": "1.0.192",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -71,7 +75,7 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.190",
+        "@teambit/legacy": "1.0.192",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }

package/transformers/export-declaration.ts

@@ -0,0 +1,53 @@
+import ts, { Node, SyntaxKind, ExportDeclaration as ExportDeclarationNode, NamedExports } from 'typescript';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+
+export class ExportDeclaration implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.ExportDeclaration;
+  }
+
+  async getIdentifiers(exportDec: ExportDeclarationNode, context: SchemaExtractorContext) {
+    if (exportDec.exportClause?.kind === ts.SyntaxKind.NamedExports) {
+      exportDec.exportClause as NamedExports;
+      return exportDec.exportClause.elements.map((elm) => {
+        return new ExportIdentifier(elm.name.getText(), elm.getSourceFile().fileName);
+      });
+    }
+
+    if (exportDec.exportClause?.kind === ts.SyntaxKind.NamespaceExport) {
+      return [new ExportIdentifier(exportDec.exportClause.name.getText(), exportDec.getSourceFile().fileName)];
+    }
+
+    if (exportDec.moduleSpecifier) {
+      return context.getFileExports(exportDec);
+    }
+
+    return [];
+  }
+
+  async transform(node: Node, context: SchemaExtractorContext) {
+    const exportDec = node as ExportDeclarationNode;
+    // sourceFile.sear
+    const exportClause = exportDec.exportClause;
+    if (exportClause?.kind === SyntaxKind.NamedExports) {
+      exportClause as NamedExports;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const exports = await Promise.all(
+        exportClause.elements.map(async (element) => {
+          // const sig = await context.visitDefinition(element.name);
+          await context.visitDefinition(element.name);
+          return element.name;
+        })
+      );
+
+      return [];
+      // return exports.map((identifier) => {
+      //   // const type = context.resolveType(identifier);
+      // });
+    }
+
+    return {};
+  }
+}

package/transformers/function-declaration.ts

@@ -0,0 +1,54 @@
+import { SchemaNode, FunctionSchema } from '@teambit/semantics.entities.semantic-schema';
+import ts, { Node, FunctionDeclaration as FunctionDeclarationNode } from 'typescript';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+
+export class FunctionDeclaration implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.FunctionDeclaration;
+  }
+
+  // need to check for anonymous functions assigned for vars, const and let.
+  async getIdentifiers(funcDec: FunctionDeclarationNode) {
+    return [new ExportIdentifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];
+  }
+
+  private getName(funcDec: FunctionDeclarationNode) {
+    return funcDec.name?.getText() || '';
+  }
+
+  private async getArgs(funcDec: FunctionDeclarationNode, context: SchemaExtractorContext) {
+    return Promise.all(
+      funcDec.parameters.map(async (param) => {
+        const type = param.type;
+        return {
+          name: param.name.getText(),
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          type: await context.resolveType(type!, type?.getText() || 'any'),
+        };
+      })
+    );
+  }
+
+  private parseReturnValue(displayString?: string) {
+    if (!displayString) return '';
+    const array = displayString.split(':');
+    return array[array.length - 1].trim();
+  }
+
+  async transform(node: Node, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const funcDec = node as FunctionDeclarationNode;
+    const name = this.getName(funcDec);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const info = await context.getQuickInfo(funcDec.name!);
+    const displaySig = info?.body?.displayString;
+    const returnTypeStr = this.parseReturnValue(displaySig);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const args = await this.getArgs(funcDec, context);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const returnType = await context.resolveType(funcDec.name!, returnTypeStr);
+
+    return new FunctionSchema(name || '', [], returnType);
+  }
+}

package/transformers/index.ts

@@ -0,0 +1,5 @@
+export { ExportDeclaration } from './export-declaration';
+export { FunctionDeclaration } from './function-declaration';
+export { VariableStatementTransformer } from './variable-statement';
+export { SourceFileTransformer } from './source-file-transformer';
+export { TypeAliasTransformer } from './type-alias';

package/transformers/source-file-transformer.ts

@@ -0,0 +1,60 @@
+import ts, { Node, SourceFile } from 'typescript';
+import { compact, flatten } from 'lodash';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+
+export class SourceFileTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.SourceFile;
+  }
+
+  async getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext) {
+    const exports = this.listExports(sourceFile);
+
+    const exportNames = await Promise.all(
+      exports.map((node: Node) => {
+        return context.getExportedIdentifiers(node);
+      })
+    );
+
+    const exportIds = flatten(exportNames).reduce<ExportIdentifier[]>((acc, current) => {
+      const item = acc.find((exportName) => exportName.id === current.id);
+      if (!item) acc.push(current);
+      return acc;
+    }, []);
+
+    return exportIds;
+  }
+
+  async transform(node: SourceFile, context: SchemaExtractorContext) {
+    const exports = this.listExports(node);
+    const schemas = await Promise.all(
+      exports.map((exportNode) => {
+        return context.computeSchema(exportNode);
+      })
+    );
+
+    return schemas;
+  }
+
+  /**
+   * list all exports of a source file.
+   */
+  private listExports(ast: SourceFile): Node[] {
+    return compact(
+      ast.statements.map((statement) => {
+        if (statement.kind === ts.SyntaxKind.ExportDeclaration) return statement;
+        const isExport = Boolean(
+          statement.modifiers?.find((modifier) => {
+            return modifier.kind === ts.SyntaxKind.ExportKeyword;
+          })
+        );
+
+        // eslint-disable-next-line consistent-return
+        if (!isExport) return;
+        return statement;
+      })
+    );
+  }
+}

package/transformers/type-alias.ts

@@ -0,0 +1,17 @@
+import ts, { Node, TypeAliasDeclaration } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+
+export class TypeAliasTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeAliasDeclaration;
+  }
+
+  async getIdentifiers(node: TypeAliasDeclaration) {
+    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform() {
+    return {};
+  }
+}

package/transformers/variable-statement.ts

@@ -0,0 +1,19 @@
+import ts, { Node, VariableStatement } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { ExportIdentifier } from '../export-identifier';
+
+export class VariableStatementTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.VariableStatement;
+  }
+
+  async getIdentifiers(node: VariableStatement) {
+    return node.declarationList.declarations.map((dec) => {
+      return new ExportIdentifier(dec.name.getText(), dec.getSourceFile().fileName);
+    });
+  }
+
+  async transform() {
+    return {};
+  }
+}