@teambit/typescript 0.0.965 → 0.0.967

package/transformers/source-file-transformer.ts

@@ -1,10 +1,11 @@
 import ts, { Node, SourceFile } from 'typescript';
-import { compact, flatten } from 'lodash';
+import { flatten } from 'lodash';
 import pMapSeries from 'p-map-series';
 import { ModuleSchema } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
 import { ExportIdentifier } from '../export-identifier';
 import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
 
 export class SourceFileTransformer implements SchemaTransformer {
   predicate(node: Node) {
@@ -13,48 +14,79 @@ export class SourceFileTransformer implements SchemaTransformer {
 
   async getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext) {
     const exports = this.listExports(sourceFile);
+    const internals = this.listInternalNodes(sourceFile);
 
-    const exportNames = await Promise.all(
-      exports.map((node: Node) => {
-        return context.getExportedIdentifiers(node);
+    // change to pMap series
+    const exportIdentifiers = flatten(
+      await pMapSeries(exports, (node) => {
+        return context.getIdentifiers(node);
       })
-    );
+    ).reduce<ExportIdentifier[]>((acc, current) => {
+      const item = acc.find((exportIdentifier) => exportIdentifier.isEqual(current));
+      if (!item) acc.push(new ExportIdentifier(current.id, current.filePath, current.aliasId, current.sourceFilePath));
+      return acc;
+    }, []);
 
-    const exportIds = flatten(exportNames).reduce<ExportIdentifier[]>((acc, current) => {
-      const item = acc.find((exportName) => exportName.id === current.id);
+    const internalIdentifiers = flatten(
+      await pMapSeries(internals, (node) => {
+        return context.getIdentifiers(node);
+      })
+    ).reduce<Identifier[]>((acc, current) => {
+      const item = acc.find((internalIdentifier) => internalIdentifier.isEqual(current));
       if (!item) acc.push(current);
       return acc;
     }, []);
 
-    return exportIds;
+    const identifiers = [...exportIdentifiers, ...internalIdentifiers];
+
+    return identifiers;
   }
 
   async transform(node: SourceFile, context: SchemaExtractorContext) {
     const exports = this.listExports(node);
-    const schemas = await pMapSeries(exports, (exportNode) => {
+    const internals = this.listInternalNodes(node).filter(
+      (internal) => internal.kind !== ts.SyntaxKind.ImportDeclaration
+    );
+
+    const exportDeclarations = await pMapSeries(exports, (exportNode) => {
       return context.computeSchema(exportNode);
     });
 
-    return new ModuleSchema(context.getLocation(node), schemas);
+    const internalDeclarations = await pMapSeries(internals, (internalNode) => {
+      return context.computeSchema(internalNode);
+    });
+
+    return new ModuleSchema(context.getLocation(node), exportDeclarations, internalDeclarations);
   }
 
   /**
    * 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;
-      })
-    );
+    return ast.statements.filter((statement) => {
+      if (statement.kind === ts.SyntaxKind.ExportDeclaration || statement.kind === ts.SyntaxKind.ExportAssignment)
+        return true;
+      const isExport = Boolean(
+        statement.modifiers?.find((modifier) => {
+          return modifier.kind === ts.SyntaxKind.ExportKeyword;
+        })
+      );
+      return isExport;
+    });
+  }
+
+  private listInternalNodes(ast: SourceFile): Node[] {
+    return ast.statements.filter((statement) => {
+      if (
+        !(statement.kind === ts.SyntaxKind.ExportDeclaration || statement.kind === ts.SyntaxKind.ExportAssignment) &&
+        !statement.modifiers?.find((modifier) => {
+          return modifier.kind === ts.SyntaxKind.ExportKeyword;
+        })
+      ) {
+        return true;
+      }
+
+      return false;
+    });
   }
 }

package/transformers/template-literal-type-span.ts

@@ -0,0 +1,21 @@
+import { Node, SyntaxKind, TemplateLiteralTypeSpan } from 'typescript';
+import { TemplateLiteralTypeSpanSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class TemplateLiteralTypeSpanTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TemplateLiteralTypeSpan;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TemplateLiteralTypeSpan, context: SchemaExtractorContext) {
+    const type = await context.computeSchema(node.type);
+    const literal = node.literal.text;
+    return new TemplateLiteralTypeSpanSchema(context.getLocation(node), literal, type);
+  }
+}

package/transformers/template-literal-type.ts

@@ -0,0 +1,24 @@
+import { Node, SyntaxKind, TemplateLiteralTypeNode } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { TemplateLiteralTypeSchema, TemplateLiteralTypeSpanSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class TemplateLiteralTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TemplateLiteralType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TemplateLiteralTypeNode, context: SchemaExtractorContext) {
+    const templateSpans = (await pMapSeries(node.templateSpans, (span) =>
+      context.computeSchema(span)
+    )) as TemplateLiteralTypeSpanSchema[];
+    const head = node.head.text;
+    return new TemplateLiteralTypeSchema(context.getLocation(node), head, templateSpans);
+  }
+}

package/transformers/this-type.ts

@@ -0,0 +1,19 @@
+import { Node, SyntaxKind, ThisTypeNode } from 'typescript';
+import { ThisTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class ThisTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.ThisType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: ThisTypeNode, context: SchemaExtractorContext) {
+    return new ThisTypeSchema(context.getLocation(node));
+  }
+}

package/transformers/tuple-type.ts

@@ -0,0 +1,24 @@
+import { Node, SyntaxKind, TupleTypeNode } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { TupleTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class TupleTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TupleType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TupleTypeNode, context: SchemaExtractorContext) {
+    const elements = await pMapSeries(node.elements, async (elem) => {
+      const typeSchema = await context.computeSchema(elem);
+      return typeSchema;
+    });
+    return new TupleTypeSchema(context.getLocation(node), elements);
+  }
+}

package/transformers/type-alias.ts

@@ -2,8 +2,7 @@ import ts, { Node, TypeAliasDeclaration } from 'typescript';
 import { TypeSchema } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
 import { SchemaExtractorContext } from '../schema-extractor-context';
-import { ExportIdentifier } from '../export-identifier';
-import { typeNodeToSchema } from './utils/type-node-to-schema';
+import { Identifier } from '../identifier';
 
 export class TypeAliasTransformer implements SchemaTransformer {
   predicate(node: Node) {
@@ -11,7 +10,7 @@ export class TypeAliasTransformer implements SchemaTransformer {
   }
 
   async getIdentifiers(node: TypeAliasDeclaration) {
-    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
+    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];
   }
 
   private getName(node: TypeAliasDeclaration): string {
@@ -19,7 +18,7 @@ export class TypeAliasTransformer implements SchemaTransformer {
   }
 
   async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {
-    const type = await typeNodeToSchema(typeAlias.type, context);
+    const type = await context.computeSchema(typeAlias.type);
     const displaySig = await context.getQuickInfoDisplayString(typeAlias.name);
     const doc = await context.jsDocToDocSchema(typeAlias);
     return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig, doc);

package/transformers/type-literal.ts

@@ -0,0 +1,26 @@
+import ts, { Node, TypeLiteralNode } from 'typescript';
+import { TypeLiteralSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+/**
+ * not to be confused with "LiteralType", which is string/boolean/null.
+ * this "TypeLiteral" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.
+ */
+export class TypeLiteralTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeLiteral;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypeLiteralNode, context: SchemaExtractorContext) {
+    const members = await pMapSeries(node.members, (member) => context.computeSchema(member));
+    const location = context.getLocation(node);
+    return new TypeLiteralSchema(location, members);
+  }
+}

package/transformers/type-operator.ts

@@ -0,0 +1,37 @@
+import { Node, TypeOperatorNode, SyntaxKind } from 'typescript';
+import { TypeOperatorSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+/**
+ * e.g. keyof typeof Foo
+ */
+export class TypeOperatorTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TypeOperator;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypeOperatorNode, context: SchemaExtractorContext) {
+    const operatorName = this.getOperatorName(node.operator);
+    const type = await context.computeSchema(node.type);
+    return new TypeOperatorSchema(context.getLocation(node), operatorName, type);
+  }
+
+  getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
+    switch (operator) {
+      case SyntaxKind.KeyOfKeyword:
+        return 'keyof';
+      case SyntaxKind.UniqueKeyword:
+        return 'unique';
+      case SyntaxKind.ReadonlyKeyword:
+        return 'readonly';
+      default:
+        throw new Error(`getOperatorName: unable to find operator name for ${operator}`);
+    }
+  }
+}

package/transformers/type-predicate.ts

@@ -0,0 +1,22 @@
+import { isIdentifier, Node, SyntaxKind, TypePredicateNode } from 'typescript';
+import { TypePredicateSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class TypePredicateTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TypePredicate;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypePredicateNode, context: SchemaExtractorContext) {
+    const parameterName = isIdentifier(node.parameterName) ? node.parameterName.getText() : 'this';
+    const type = node.type ? await context.computeSchema(node.type) : undefined;
+    const hasAssertsModifier = Boolean(node.assertsModifier);
+    return new TypePredicateSchema(context.getLocation(node), parameterName, type, hasAssertsModifier);
+  }
+}

package/transformers/type-query.ts

@@ -0,0 +1,25 @@
+import ts, { Node, TypeQueryNode } from 'typescript';
+import { TypeQuerySchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+/**
+ * e.g. `typeof Foo`
+ */
+export class TypeQueryTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeQuery;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypeQueryNode, context: SchemaExtractorContext) {
+    const displaySig = await context.getQuickInfoDisplayString(node.exprName);
+    const type = await context.resolveType(node.exprName, node.exprName.getText(), false);
+    const location = context.getLocation(node);
+    return new TypeQuerySchema(location, type, displaySig);
+  }
+}

package/transformers/type-reference.ts

@@ -0,0 +1,33 @@
+import ts, { Node, TypeReferenceNode } from 'typescript';
+import { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+/**
+ * In the following example, `AriaButtonProps` is a type reference
+ * ```ts
+ * import type { AriaButtonProps } from '@react-types/button';
+ * export type ButtonProps = AriaButtonProps & { a: string };
+ * ```
+ */
+export class TypeReferenceTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeReference;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypeReferenceNode, context: SchemaExtractorContext) {
+    const name = node.typeName.getText();
+    const type = await context.resolveType(node, name, false);
+    if (node.typeArguments && type instanceof TypeRefSchema) {
+      const args = await pMapSeries(node.typeArguments, (arg) => context.computeSchema(arg));
+      type.typeArgs = args;
+    }
+    return type;
+  }
+}

package/transformers/union-type.ts

@@ -0,0 +1,25 @@
+import ts, { Node, UnionTypeNode } from 'typescript';
+import { TypeUnionSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class UnionTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.UnionType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: UnionTypeNode, context: SchemaExtractorContext) {
+    const types = await pMapSeries(node.types, async (type) => {
+      const typeSchema = context.computeSchema(type);
+      return typeSchema;
+    });
+    const location = context.getLocation(node);
+    return new TypeUnionSchema(location, types);
+  }
+}

package/transformers/utils/jsdoc-to-doc-schema.ts

@@ -16,7 +16,6 @@ import {
 } from '@teambit/semantics.entities.semantic-schema';
 import { Formatter } from '@teambit/formatter';
 import { SchemaExtractorContext } from '../../schema-extractor-context';
-import { typeNodeToSchema } from './type-node-to-schema';
 
 export async function tagParser(
   tag: JSDocTag,
@@ -24,7 +23,6 @@ export async function tagParser(
   formatter?: Formatter
 ): Promise<TagSchema> {
   // for some reason, in some cases, if `tag.getSourceFile()` is not provided to the `getText()`, it throws "Cannot read property 'text' of undefined"
-
   switch (tag.kind) {
     case SyntaxKind.JSDocReturnTag:
       return returnTag(tag as JSDocReturnTag, context);
@@ -88,12 +86,12 @@ function simpleTag(tag: JSDocTag, tagName: TagName | string, context: SchemaExtr
 }
 
 async function returnTag(tag: JSDocReturnTag, context: SchemaExtractorContext) {
-  const type = tag.typeExpression?.type ? await typeNodeToSchema(tag.typeExpression?.type, context) : undefined;
+  const type = tag.typeExpression?.type ? await context.computeSchema(tag.typeExpression?.type) : undefined;
   return new ReturnTagSchema(context.getLocation(tag), getTextOfJSDocComment(tag.comment), type);
 }
 
 async function propertyLikeTag(tag: JSDocPropertyLikeTag, context: SchemaExtractorContext) {
-  const type = tag.typeExpression?.type ? await typeNodeToSchema(tag.typeExpression?.type, context) : undefined;
+  const type = tag.typeExpression?.type ? await context.computeSchema(tag.typeExpression?.type) : undefined;
   return new PropertyLikeTagSchema(
     context.getLocation(tag),
     tag.name.getText(),

package/transformers/variable-declaration.ts

@@ -3,13 +3,14 @@ import {
   VariableLikeSchema,
   FunctionLikeSchema,
   Modifier,
+  ParameterSchema,
 } from '@teambit/semantics.entities.semantic-schema';
 import ts, { Node, VariableDeclaration as VariableDeclarationNode, ArrowFunction } from 'typescript';
+import pMapSeries from 'p-map-series';
 import { SchemaTransformer } from '../schema-transformer';
 import { SchemaExtractorContext } from '../schema-extractor-context';
-import { ExportIdentifier } from '../export-identifier';
-import { getParams } from './utils/get-params';
 import { parseReturnTypeFromQuickInfo, parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+import { Identifier } from '../identifier';
 
 export class VariableDeclaration implements SchemaTransformer {
   predicate(node: Node) {
@@ -21,7 +22,7 @@ export class VariableDeclaration implements SchemaTransformer {
   }
 
   async getIdentifiers(node: VariableDeclarationNode) {
-    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];
+    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];
   }
 
   async transform(varDec: VariableDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
@@ -32,7 +33,9 @@ export class VariableDeclaration implements SchemaTransformer {
     const doc = await context.jsDocToDocSchema(varDec);
     const modifiers = varDec.modifiers?.map((modifier) => modifier.getText()) || [];
     if (varDec.initializer?.kind === ts.SyntaxKind.ArrowFunction) {
-      const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);
+      const args = (await pMapSeries((varDec.initializer as ArrowFunction).parameters, async (param) =>
+        context.computeSchema(param)
+      )) as ParameterSchema[];
       // example => export const useLanesContext: () => LanesContextModel | undefined = () => {
       if (varDec.type) {
         const funcType = await context.resolveType(varDec, '');

package/transformers/variable-statement.ts

@@ -4,7 +4,7 @@ import pMapSeries from 'p-map-series';
 import ts, { Node, VariableStatement } from 'typescript';
 import { SchemaTransformer } from '../schema-transformer';
 import { SchemaExtractorContext } from '../schema-extractor-context';
-import { ExportIdentifier } from '../export-identifier';
+import { Identifier } from '../identifier';
 
 /**
  * variable statement is a collection of variable declarations.
@@ -17,7 +17,7 @@ export class VariableStatementTransformer implements SchemaTransformer {
 
   async getIdentifiers(node: VariableStatement) {
     return node.declarationList.declarations.map((dec) => {
-      return new ExportIdentifier(dec.name.getText(), dec.getSourceFile().fileName);
+      return new Identifier(dec.name.getText(), dec.getSourceFile().fileName);
     });
   }
 
@@ -27,6 +27,6 @@ export class VariableStatementTransformer implements SchemaTransformer {
       const schema = await context.visitDefinition(dec.name);
       return schema;
     });
-    return new ModuleSchema(context.getLocation(node), compact(schemas));
+    return new ModuleSchema(context.getLocation(node), compact(schemas), []);
   }
 }

package/dist/export-list.d.ts

@@ -1,6 +0,0 @@
-import { ExportIdentifier } from './export-identifier';
-export declare class ExportList {
-    readonly exports: ExportIdentifier[];
-    constructor(exports: ExportIdentifier[]);
-    includes(id: string): boolean;
-}

package/dist/export-list.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ExportList = void 0;
-class ExportList {
-  constructor(exports) {
-    this.exports = exports;
-  }
-  includes(id) {
-    return Boolean(this.exports.find(exportId => exportId.id === id));
-  }
-}
-exports.ExportList = ExportList;
-
-//# sourceMappingURL=export-list.js.map

package/dist/export-list.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["ExportList","constructor","exports","includes","id","Boolean","find","exportId"],"sources":["export-list.ts"],"sourcesContent":["import { ExportIdentifier } from './export-identifier';\n\nexport class ExportList {\n  constructor(readonly exports: ExportIdentifier[]) {}\n\n  includes(id: string) {\n    return Boolean(this.exports.find((exportId) => exportId.id === id));\n  }\n}\n"],"mappings":";;;;;;AAEO,MAAMA,UAAU,CAAC;EACtBC,WAAW,CAAUC,OAA2B,EAAE;IAAA,KAA7BA,OAA2B,GAA3BA,OAA2B;EAAG;EAEnDC,QAAQ,CAACC,EAAU,EAAE;IACnB,OAAOC,OAAO,CAAC,IAAI,CAACH,OAAO,CAACI,IAAI,CAAEC,QAAQ,IAAKA,QAAQ,CAACH,EAAE,KAAKA,EAAE,CAAC,CAAC;EACrE;AACF;AAAC"}

package/dist/transformers/export-assignment-declaration.js

@@ -1,29 +0,0 @@
-"use strict";
-
-require("core-js/modules/es.promise.js");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ExportAssignmentDeclaration = void 0;
-function _typescript() {
-  const data = require("typescript");
-  _typescript = function () {
-    return data;
-  };
-  return data;
-}
-class ExportAssignmentDeclaration {
-  predicate(node) {
-    return node.kind === _typescript().SyntaxKind.ExportAssignment;
-  }
-  async getIdentifiers(exportDec, context) {
-    return context.getFileExports(exportDec);
-  }
-  async transform(exportDec, context) {
-    const specifier = exportDec.expression;
-    return context.computeSchema(specifier);
-  }
-}
-exports.ExportAssignmentDeclaration = ExportAssignmentDeclaration;
-
-//# sourceMappingURL=export-assignment-declaration.js.map

package/dist/transformers/export-assignment-declaration.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["ExportAssignmentDeclaration","predicate","node","kind","SyntaxKind","ExportAssignment","getIdentifiers","exportDec","context","getFileExports","transform","specifier","expression","computeSchema"],"sources":["export-assignment-declaration.ts"],"sourcesContent":["import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';\nimport { Node, SyntaxKind, ExportAssignment as ExportAssignmentNode } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\n\nexport class ExportAssignmentDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.ExportAssignment;\n  }\n\n  async getIdentifiers(exportDec: ExportAssignmentNode, context: SchemaExtractorContext) {\n    return context.getFileExports(exportDec);\n  }\n\n  async transform(exportDec: ExportAssignmentNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const specifier = exportDec.expression;\n    return context.computeSchema(specifier);\n  }\n}\n"],"mappings":";;;;;;;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAIO,MAAMA,2BAA2B,CAA8B;EACpEC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,gBAAgB;EAClD;EAEA,MAAMC,cAAc,CAACC,SAA+B,EAAEC,OAA+B,EAAE;IACrF,OAAOA,OAAO,CAACC,cAAc,CAACF,SAAS,CAAC;EAC1C;EAEA,MAAMG,SAAS,CAACH,SAA+B,EAAEC,OAA+B,EAAuB;IACrG,MAAMG,SAAS,GAAGJ,SAAS,CAACK,UAAU;IACtC,OAAOJ,OAAO,CAACK,aAAa,CAACF,SAAS,CAAC;EACzC;AACF;AAAC"}

package/dist/transformers/function-declaration.d.ts

@@ -1,11 +0,0 @@
-import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
-import { Node, FunctionDeclaration as FunctionDeclarationNode } from 'typescript';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { SchemaTransformer } from '../schema-transformer';
-import { ExportIdentifier } from '../export-identifier';
-export declare class FunctionDeclaration implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(funcDec: FunctionDeclarationNode): Promise<ExportIdentifier[]>;
-    private getName;
-    transform(funcDec: FunctionDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode>;
-}

package/dist/transformers/function-declaration.js

@@ -1,49 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-require("core-js/modules/es.promise.js");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.FunctionDeclaration = void 0;
-function _typescript() {
-  const data = _interopRequireDefault(require("typescript"));
-  _typescript = function () {
-    return data;
-  };
-  return data;
-}
-function _exportIdentifier() {
-  const data = require("../export-identifier");
-  _exportIdentifier = function () {
-    return data;
-  };
-  return data;
-}
-function _toFunctionLikeSchema() {
-  const data = require("./utils/to-function-like-schema");
-  _toFunctionLikeSchema = function () {
-    return data;
-  };
-  return data;
-}
-class FunctionDeclaration {
-  predicate(node) {
-    return node.kind === _typescript().default.SyntaxKind.FunctionDeclaration || node.kind === _typescript().default.SyntaxKind.ArrowFunction;
-  }
-
-  // need to check for anonymous functions assigned for vars, const and let.
-  async getIdentifiers(funcDec) {
-    return [new (_exportIdentifier().ExportIdentifier)(this.getName(funcDec), funcDec.getSourceFile().fileName)];
-  }
-  getName(funcDec) {
-    var _funcDec$name;
-    return ((_funcDec$name = funcDec.name) === null || _funcDec$name === void 0 ? void 0 : _funcDec$name.getText()) || '';
-  }
-  async transform(funcDec, context) {
-    return (0, _toFunctionLikeSchema().toFunctionLikeSchema)(funcDec, context);
-  }
-}
-exports.FunctionDeclaration = FunctionDeclaration;
-
-//# sourceMappingURL=function-declaration.js.map

package/dist/transformers/function-declaration.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["FunctionDeclaration","predicate","node","kind","ts","SyntaxKind","ArrowFunction","getIdentifiers","funcDec","ExportIdentifier","getName","getSourceFile","fileName","name","getText","transform","context","toFunctionLikeSchema"],"sources":["function-declaration.ts"],"sourcesContent":["import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, FunctionDeclaration as FunctionDeclarationNode } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { toFunctionLikeSchema } from './utils/to-function-like-schema';\n\nexport class FunctionDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.FunctionDeclaration || node.kind === ts.SyntaxKind.ArrowFunction;\n  }\n\n  // need to check for anonymous functions assigned for vars, const and let.\n  async getIdentifiers(funcDec: FunctionDeclarationNode) {\n    return [new ExportIdentifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];\n  }\n\n  private getName(funcDec: FunctionDeclarationNode) {\n    return funcDec.name?.getText() || '';\n  }\n\n  async transform(funcDec: FunctionDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    return toFunctionLikeSchema(funcDec, context);\n  }\n}\n"],"mappings":";;;;;;;;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAGA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEO,MAAMA,mBAAmB,CAA8B;EAC5DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACL,mBAAmB,IAAIE,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,aAAa;EACrG;;EAEA;EACA,MAAMC,cAAc,CAACC,OAAgC,EAAE;IACrD,OAAO,CAAC,KAAIC,oCAAgB,EAAC,IAAI,CAACC,OAAO,CAACF,OAAO,CAAC,EAAEA,OAAO,CAACG,aAAa,EAAE,CAACC,QAAQ,CAAC,CAAC;EACxF;EAEQF,OAAO,CAACF,OAAgC,EAAE;IAAA;IAChD,OAAO,kBAAAA,OAAO,CAACK,IAAI,kDAAZ,cAAcC,OAAO,EAAE,KAAI,EAAE;EACtC;EAEA,MAAMC,SAAS,CAACP,OAAgC,EAAEQ,OAA+B,EAAuB;IACtG,OAAO,IAAAC,4CAAoB,EAACT,OAAO,EAAEQ,OAAO,CAAC;EAC/C;AACF;AAAC"}

package/dist/transformers/utils/class-element-to-schema.d.ts

@@ -1,4 +0,0 @@
-import { ClassElement } from 'typescript';
-import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaExtractorContext } from '../../schema-extractor-context';
-export declare function classElementToSchema(node: ClassElement, context: SchemaExtractorContext): Promise<SchemaNode | null>;