@teambit/typescript 0.0.740 → 0.0.743

package/transformers/interface-declaration.ts

@@ -1,13 +1,14 @@
-import ts, { Node, InterfaceDeclaration } from 'typescript';
+import { Node, InterfaceDeclaration, SyntaxKind } from 'typescript';
 import pMapSeries from 'p-map-series';
 import { InterfaceSchema } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
 import { SchemaExtractorContext } from '../schema-extractor-context';
 import { ExportIdentifier } from '../export-identifier';
+import { typeElementToSchema } from './utils/type-element-to-schema';
 
 export class InterfaceDeclarationTransformer implements SchemaTransformer {
   predicate(node: Node) {
-    return node.kind === ts.SyntaxKind.InterfaceDeclaration;
+    return node.kind === SyntaxKind.InterfaceDeclaration;
   }
 
   async getIdentifiers(node: InterfaceDeclaration): Promise<ExportIdentifier[]> {
@@ -15,10 +16,7 @@ export class InterfaceDeclarationTransformer implements SchemaTransformer {
   }
 
   async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {
-    const members = await pMapSeries(interfaceDec.members, async (member) => {
-      const typeSchema = await context.computeSchema(member);
-      return typeSchema;
-    });
+    const members = await pMapSeries(interfaceDec.members, (member) => typeElementToSchema(member, context));
     return new InterfaceSchema(context.getLocation(interfaceDec), interfaceDec.name.getText(), members);
   }
 }

package/transformers/type-alias.ts

@@ -20,8 +20,7 @@ export class TypeAliasTransformer implements SchemaTransformer {
 
   async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {
     const type = await typeNodeToSchema(typeAlias.type, context);
-    const info = await context.getQuickInfo(typeAlias.name);
-    const displaySig = info?.body?.displayString;
-    return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig || '');
+    const displaySig = await context.getQuickInfoDisplayString(typeAlias.name);
+    return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig);
   }
 }

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

@@ -0,0 +1,61 @@
+import {
+  ClassElement,
+  ConstructorDeclaration,
+  GetAccessorDeclaration,
+  IndexSignatureDeclaration,
+  MethodDeclaration,
+  PropertyDeclaration,
+  SetAccessorDeclaration,
+  SyntaxKind,
+} from 'typescript';
+import { ConstructorSchema, SchemaNode, VariableSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { getParams } from './get-params';
+import { getAccessor, indexSignature, setAccessor } from './type-element-to-schema';
+import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
+import { toFunctionLikeSchema } from './to-function-schema';
+
+export async function classElementToSchema(
+  node: ClassElement,
+  context: SchemaExtractorContext
+): Promise<SchemaNode | null> {
+  switch (node.kind) {
+    case SyntaxKind.Constructor:
+      return constructor(node as ConstructorDeclaration, context);
+    case SyntaxKind.PropertyDeclaration:
+      return propertyDeclaration(node as PropertyDeclaration, context);
+    case SyntaxKind.MethodDeclaration:
+      return methodDeclaration(node as MethodDeclaration, context);
+    case SyntaxKind.GetAccessor:
+      return getAccessor(node as GetAccessorDeclaration, context);
+    case SyntaxKind.SetAccessor:
+      return setAccessor(node as SetAccessorDeclaration, context);
+    case SyntaxKind.IndexSignature:
+      return indexSignature(node as IndexSignatureDeclaration, context);
+    case SyntaxKind.ClassStaticBlockDeclaration: // not sure what is it, but the name sounds like not something we need
+    case SyntaxKind.SemicolonClassElement: // seems to be just a semicolon
+      return null;
+    default:
+      // should never be here unless typescript added new class elements
+      throw new Error(`unrecognized ClassElement type. got ${node.kind}`);
+  }
+}
+
+async function constructor(node: ConstructorDeclaration, context: SchemaExtractorContext) {
+  const args = await getParams(node.parameters, context);
+  return new ConstructorSchema(context.getLocation(node), args);
+}
+
+async function propertyDeclaration(node: PropertyDeclaration, context: SchemaExtractorContext) {
+  const name = node.name.getText();
+  const info = await context.getQuickInfo(node.name);
+  const displaySig = info?.body?.displayString;
+  const typeStr = parseTypeFromQuickInfo(info);
+  const type = await context.resolveType(node, typeStr);
+
+  return new VariableSchema(context.getLocation(node), name, displaySig || '', type);
+}
+
+async function methodDeclaration(node: MethodDeclaration, context: SchemaExtractorContext) {
+  return toFunctionLikeSchema(node, context);
+}

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

@@ -0,0 +1,81 @@
+/* eslint-disable no-fallthrough */
+import { getTextOfJSDocComment, JSDocReturnTag, JSDocTag, Node, SyntaxKind } from 'typescript';
+import { getJsDoc, canHaveJsDoc } from 'tsutils';
+import pMapSeries from 'p-map-series';
+import { DocSchema, ReturnTagSchema, TagName, TagSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { typeNodeToSchema } from './type-node-to-schema';
+
+export async function jsDocToDocSchema(node: Node, context: SchemaExtractorContext): Promise<DocSchema | undefined> {
+  if (!canHaveJsDoc(node)) {
+    return undefined;
+  }
+  const jsDocs = getJsDoc(node);
+  if (!jsDocs.length) {
+    return undefined;
+  }
+  // not sure how common it is to have multiple JSDocs. never seen it before.
+  // regardless, in typescript implementation of methods like `getJSDocDeprecatedTag()`, they use the first one. (`getFirstJSDocTag()`)
+  const jsDoc = jsDocs[0];
+  const location = context.getLocation(jsDoc);
+  const comment = getTextOfJSDocComment(jsDoc.comment);
+  const tags = jsDoc.tags ? await pMapSeries(jsDoc.tags, (tag) => tagParser(tag, context)) : undefined;
+  return new DocSchema(location, comment, tags);
+}
+
+async function tagParser(tag: JSDocTag, context: SchemaExtractorContext): Promise<TagSchema> {
+  let tagName: TagName | string = tag.tagName.getText();
+  switch (tag.kind) {
+    case SyntaxKind.JSDocReturnTag:
+      return returnTag(tag as JSDocReturnTag, context);
+    case SyntaxKind.JSDocAugmentsTag:
+      tagName = TagName.augments;
+    case SyntaxKind.JSDocAuthorTag:
+      tagName = TagName.author;
+    case SyntaxKind.JSDocClassTag:
+      tagName = TagName.class;
+    case SyntaxKind.JSDocCallbackTag:
+      tagName = TagName.callback;
+    case SyntaxKind.JSDocPublicTag:
+      tagName = TagName.public;
+    case SyntaxKind.JSDocPrivateTag:
+      tagName = TagName.private;
+    case SyntaxKind.JSDocProtectedTag:
+      tagName = TagName.protected;
+    case SyntaxKind.JSDocReadonlyTag:
+      tagName = TagName.readonly;
+    case SyntaxKind.JSDocOverrideTag:
+      tagName = TagName.override;
+    case SyntaxKind.JSDocDeprecatedTag:
+      tagName = TagName.deprecated;
+    case SyntaxKind.JSDocSeeTag:
+      tagName = TagName.see;
+    case SyntaxKind.JSDocEnumTag:
+      tagName = TagName.enum;
+    case SyntaxKind.JSDocParameterTag:
+      tagName = TagName.parameter;
+    case SyntaxKind.JSDocThisTag:
+      tagName = TagName.this;
+    case SyntaxKind.JSDocTypeTag:
+      tagName = TagName.type;
+    case SyntaxKind.JSDocTemplateTag:
+      tagName = TagName.template;
+    case SyntaxKind.JSDocTypedefTag:
+      tagName = TagName.typedef;
+    case SyntaxKind.JSDocPropertyTag:
+      tagName = TagName.property;
+    case SyntaxKind.JSDocImplementsTag:
+      tagName = TagName.implements;
+    default:
+      return simpleTag(tag, tagName, context);
+  }
+}
+
+function simpleTag(tag: JSDocTag, tagName: TagName | string, context: SchemaExtractorContext): TagSchema {
+  return new TagSchema(context.getLocation(tag), tagName, getTextOfJSDocComment(tag.comment));
+}
+
+async function returnTag(tag: JSDocReturnTag, context: SchemaExtractorContext) {
+  const type = tag.typeExpression?.type ? await typeNodeToSchema(tag.typeExpression?.type, context) : undefined;
+  return new ReturnTagSchema(context.getLocation(tag), TagName.return, getTextOfJSDocComment(tag.comment), type);
+}

package/transformers/utils/to-function-schema.ts

@@ -3,17 +3,21 @@ import { FunctionLikeSchema, Modifier } from '@teambit/semantics.entities.semant
 import { SchemaExtractorContext } from '../../schema-extractor-context';
 import { getParams } from './get-params';
 import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
+import { jsDocToDocSchema } from './jsdoc-to-doc-schema';
 
-export async function toFunctionLikeSchema(node: SignatureDeclaration, context: SchemaExtractorContext) {
-  const name = node.name?.getText() || '';
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const info = await context.getQuickInfo(node.name!);
-  const returnTypeStr = parseTypeFromQuickInfo(info);
+export async function toFunctionLikeSchema(
+  node: SignatureDeclaration,
+  context: SchemaExtractorContext,
+  funcName?: string
+) {
+  const name = funcName || node.name?.getText() || '';
+  const info = node.name ? await context.getQuickInfo(node.name) : null;
+  const returnTypeStr = info ? parseTypeFromQuickInfo(info) : 'any';
   const displaySig = info?.body?.displayString || '';
   const args = await getParams(node.parameters, context);
-  const returnType = await context.resolveType(node, returnTypeStr);
+  const returnType = await context.resolveType(node, returnTypeStr, Boolean(info));
   const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];
   const location = context.getLocation(node);
-
-  return new FunctionLikeSchema(location, name, args, returnType, displaySig, modifiers as Modifier[]);
+  const doc = await jsDocToDocSchema(node, context);
+  return new FunctionLikeSchema(location, name, args, returnType, displaySig, modifiers as Modifier[], doc);
 }

package/transformers/utils/type-element-to-schema.ts

@@ -0,0 +1,72 @@
+import ts, {
+  SyntaxKind,
+  TypeElement,
+  MethodSignature,
+  isComputedPropertyName,
+  IndexSignatureDeclaration,
+  GetAccessorDeclaration,
+  SetAccessorDeclaration,
+  ConstructSignatureDeclaration,
+} from 'typescript';
+import {
+  GetAccessorSchema,
+  IndexSignatureSchema,
+  SchemaNode,
+  SetAccessorSchema,
+  VariableSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import { toFunctionLikeSchema } from './to-function-schema';
+import { SchemaExtractorContext } from '../../schema-extractor-context';
+import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
+import { typeNodeToSchema } from './type-node-to-schema';
+import { getParams } from './get-params';
+
+export async function typeElementToSchema(node: TypeElement, context: SchemaExtractorContext): Promise<SchemaNode> {
+  switch (node.kind) {
+    case SyntaxKind.MethodSignature:
+      return toFunctionLikeSchema(node as MethodSignature, context);
+    case SyntaxKind.ConstructSignature:
+      return toFunctionLikeSchema(node as ConstructSignatureDeclaration, context, 'new');
+    case SyntaxKind.CallSignature:
+      throw new Error(`CallSignature was not implemented yet`);
+    case SyntaxKind.PropertySignature:
+      return propertySignature(node as ts.PropertySignature, context);
+    case SyntaxKind.IndexSignature:
+      return indexSignature(node as IndexSignatureDeclaration, context);
+    case SyntaxKind.GetAccessor:
+      return getAccessor(node as GetAccessorDeclaration, context);
+    case SyntaxKind.SetAccessor:
+      return setAccessor(node as SetAccessorDeclaration, context);
+    default:
+      throw new Error(`typeElementToSchema expect type-element node. got ${node.kind}`);
+  }
+}
+
+async function propertySignature(node: ts.PropertySignature, context: SchemaExtractorContext) {
+  const name = node.name.getText();
+  const info = isComputedPropertyName(node.name) ? undefined : await context.getQuickInfo(node.name);
+  const displaySig = info?.body?.displayString || '';
+  const typeStr = parseTypeFromQuickInfo(info);
+  const type = await context.resolveType(node, typeStr);
+  return new VariableSchema(context.getLocation(node), name, displaySig, type);
+}
+
+export async function indexSignature(node: IndexSignatureDeclaration, context: SchemaExtractorContext) {
+  const params = await getParams(node.parameters, context);
+  const type = await typeNodeToSchema(node.type, context);
+  return new IndexSignatureSchema(context.getLocation(node), params, type);
+}
+
+export async function getAccessor(node: GetAccessorDeclaration, context: SchemaExtractorContext) {
+  const info = await context.getQuickInfo(node.name);
+  const displaySig = info?.body?.displayString || '';
+  const typeStr = parseTypeFromQuickInfo(info);
+  const type = await context.resolveType(node, typeStr);
+  return new GetAccessorSchema(context.getLocation(node), node.name.getText(), type, displaySig);
+}
+
+export async function setAccessor(node: SetAccessorDeclaration, context: SchemaExtractorContext) {
+  const params = await getParams(node.parameters, context);
+  const displaySig = await context.getQuickInfoDisplayString(node.name);
+  return new SetAccessorSchema(context.getLocation(node), node.name.getText(), params[0], displaySig);
+}

package/transformers/utils/type-node-to-schema.ts

@@ -15,6 +15,9 @@ import {
   TypePredicateNode,
   isIdentifier,
   IndexedAccessTypeNode,
+  TemplateLiteralTypeNode,
+  TemplateLiteralTypeSpan,
+  ThisTypeNode,
 } from 'typescript';
 import {
   SchemaNode,
@@ -32,10 +35,16 @@ import {
   ParenthesizedTypeSchema,
   TypePredicateSchema,
   IndexedAccessSchema,
+  TemplateLiteralTypeSpanSchema,
+  TemplateLiteralTypeSchema,
+  ThisTypeSchema,
+  Modifier,
 } from '@teambit/semantics.entities.semantic-schema';
 import pMapSeries from 'p-map-series';
 import { SchemaExtractorContext } from '../../schema-extractor-context';
 import { getParams } from './get-params';
+import { typeElementToSchema } from './type-element-to-schema';
+import { jsDocToDocSchema } from './jsdoc-to-doc-schema';
 
 // eslint-disable-next-line complexity
 export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {
@@ -70,16 +79,19 @@ export async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorC
       return typePredicate(node as TypePredicateNode, context);
     case SyntaxKind.IndexedAccessType:
       return indexedAccessType(node as IndexedAccessTypeNode, context);
+    case SyntaxKind.TemplateLiteralTypeSpan:
+      return templateLiteralTypeSpan(node as TemplateLiteralTypeSpan, context);
+    case SyntaxKind.TemplateLiteralType:
+      return templateLiteralType(node as TemplateLiteralTypeNode, context);
+    case SyntaxKind.ThisType:
+      return thisType(node as ThisTypeNode, context);
     case SyntaxKind.ConstructorType:
     case SyntaxKind.NamedTupleMember:
     case SyntaxKind.OptionalType:
     case SyntaxKind.RestType:
     case SyntaxKind.ConditionalType:
     case SyntaxKind.InferType:
-    case SyntaxKind.ThisType:
     case SyntaxKind.MappedType:
-    case SyntaxKind.TemplateLiteralType:
-    case SyntaxKind.TemplateLiteralTypeSpan:
     case SyntaxKind.ImportType:
     case SyntaxKind.ExpressionWithTypeArguments:
     case SyntaxKind.JSDocTypeExpression:
@@ -147,10 +159,7 @@ async function unionType(node: UnionTypeNode, context: SchemaExtractorContext) {
  * this "TypeLiteral" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.
  */
 async function typeLiteral(node: TypeLiteralNode, context: SchemaExtractorContext) {
-  const members = await pMapSeries(node.members, async (member) => {
-    const typeSchema = await context.computeSchema(member);
-    return typeSchema;
-  });
+  const members = await pMapSeries(node.members, (member) => typeElementToSchema(member, context));
   const location = context.getLocation(node);
   return new TypeLiteralSchema(location, members);
 }
@@ -177,7 +186,9 @@ async function functionType(node: FunctionTypeNode, context: SchemaExtractorCont
   const params = await getParams(node.parameters, context);
   const returnType = await typeNodeToSchema(node.type, context);
   const location = context.getLocation(node);
-  return new FunctionLikeSchema(location, name, params, returnType, '');
+  const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];
+  const doc = await jsDocToDocSchema(node, context);
+  return new FunctionLikeSchema(location, name, params, returnType, '', modifiers as Modifier[], doc);
 }
 
 /**
@@ -243,3 +254,19 @@ async function indexedAccessType(node: IndexedAccessTypeNode, context: SchemaExt
   const indexType = await typeNodeToSchema(node.indexType, context);
   return new IndexedAccessSchema(context.getLocation(node), objectType, indexType);
 }
+
+async function templateLiteralType(node: TemplateLiteralTypeNode, context: SchemaExtractorContext) {
+  const templateSpans = await pMapSeries(node.templateSpans, (span) => templateLiteralTypeSpan(span, context));
+  const head = node.head.text;
+  return new TemplateLiteralTypeSchema(context.getLocation(node), head, templateSpans);
+}
+
+async function templateLiteralTypeSpan(node: TemplateLiteralTypeSpan, context: SchemaExtractorContext) {
+  const type = await typeNodeToSchema(node.type, context);
+  const literal = node.literal.text;
+  return new TemplateLiteralTypeSpanSchema(context.getLocation(node), literal, type);
+}
+
+async function thisType(node: ThisTypeNode, context: SchemaExtractorContext) {
+  return new ThisTypeSchema(context.getLocation(node));
+}

package/transformers/variable-declaration.ts

@@ -1,10 +1,11 @@
-import { SchemaNode, VariableSchema, FunctionLikeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaNode, VariableSchema, FunctionLikeSchema, Modifier } from '@teambit/semantics.entities.semantic-schema';
 import ts, { Node, VariableDeclaration as VariableDeclarationNode, ArrowFunction } from 'typescript';
 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 { jsDocToDocSchema } from './utils/jsdoc-to-doc-schema';
 
 export class VariableDeclaration implements SchemaTransformer {
   predicate(node: Node) {
@@ -28,7 +29,9 @@ export class VariableDeclaration implements SchemaTransformer {
       const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);
       const typeStr = parseReturnTypeFromQuickInfo(info);
       const returnType = await context.resolveType(varDec, typeStr);
-      return new FunctionLikeSchema(location, name, args, returnType, displaySig);
+      const modifiers = varDec.modifiers?.map((modifier) => modifier.getText()) || [];
+      const doc = await jsDocToDocSchema(varDec, context);
+      return new FunctionLikeSchema(location, name, args, returnType, displaySig, modifiers as Modifier[], doc);
     }
     const typeStr = parseTypeFromQuickInfo(info);
     const type = await context.resolveType(varDec, typeStr);

package/dist/transformers/constructor.d.ts

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

package/dist/transformers/constructor.js

@@ -1,70 +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.Constructor = void 0;
-
-function _semanticsEntities() {
-  const data = require("@teambit/semantics.entities.semantic-schema");
-
-  _semanticsEntities = function () {
-    return data;
-  };
-
-  return data;
-}
-
-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 _getParams() {
-  const data = require("./utils/get-params");
-
-  _getParams = function () {
-    return data;
-  };
-
-  return data;
-}
-
-class Constructor {
-  predicate(node) {
-    return node.kind === _typescript().default.SyntaxKind.Constructor;
-  }
-
-  async getIdentifiers(node) {
-    return [new (_exportIdentifier().ExportIdentifier)('constructor', node.getSourceFile().fileName)];
-  }
-
-  async transform(constructorDec, context) {
-    const args = await (0, _getParams().getParams)(constructorDec.parameters, context);
-    return new (_semanticsEntities().ConstructorSchema)(context.getLocation(constructorDec), args);
-  }
-
-}
-
-exports.Constructor = Constructor;
-
-//# sourceMappingURL=constructor.js.map

package/dist/transformers/constructor.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["Constructor","predicate","node","kind","ts","SyntaxKind","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","constructorDec","context","args","getParams","parameters","ConstructorSchema","getLocation"],"sources":["constructor.ts"],"sourcesContent":["import { SchemaNode, ConstructorSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, ConstructorDeclaration } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { getParams } from './utils/get-params';\n\nexport class Constructor implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.Constructor;\n  }\n\n  async getIdentifiers(node: ConstructorDeclaration) {\n    return [new ExportIdentifier('constructor', node.getSourceFile().fileName)];\n  }\n\n  async transform(constructorDec: ConstructorDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const args = await getParams(constructorDec.parameters, context);\n\n    return new ConstructorSchema(context.getLocation(constructorDec), args);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,WAAN,CAA+C;EACpDC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcL,WAAnC;EACD;;EAEmB,MAAdM,cAAc,CAACJ,IAAD,EAA+B;IACjD,OAAO,CAAC,KAAIK,oCAAJ,EAAqB,aAArB,EAAoCL,IAAI,CAACM,aAAL,GAAqBC,QAAzD,CAAD,CAAP;EACD;;EAEc,MAATC,SAAS,CAACC,cAAD,EAAyCC,OAAzC,EAA+F;IAC5G,MAAMC,IAAI,GAAG,MAAM,IAAAC,sBAAA,EAAUH,cAAc,CAACI,UAAzB,EAAqCH,OAArC,CAAnB;IAEA,OAAO,KAAII,sCAAJ,EAAsBJ,OAAO,CAACK,WAAR,CAAoBN,cAApB,CAAtB,EAA2DE,IAA3D,CAAP;EACD;;AAbmD"}

package/dist/transformers/index-signature.d.ts

@@ -1,9 +0,0 @@
-import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
-import { Node, IndexSignatureDeclaration } from 'typescript';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-export declare class IndexSignature implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<never[]>;
-    transform(indexSig: IndexSignatureDeclaration, context: SchemaExtractorContext): Promise<SchemaNode>;
-}

package/dist/transformers/index-signature.js

@@ -1,71 +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.IndexSignature = void 0;
-
-function _semanticsEntities() {
-  const data = require("@teambit/semantics.entities.semantic-schema");
-
-  _semanticsEntities = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _typescript() {
-  const data = _interopRequireDefault(require("typescript"));
-
-  _typescript = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _getParams() {
-  const data = require("./utils/get-params");
-
-  _getParams = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _typeNodeToSchema() {
-  const data = require("./utils/type-node-to-schema");
-
-  _typeNodeToSchema = function () {
-    return data;
-  };
-
-  return data;
-}
-
-class IndexSignature {
-  predicate(node) {
-    return node.kind === _typescript().default.SyntaxKind.IndexSignature;
-  }
-
-  async getIdentifiers() {
-    return [];
-  }
-
-  async transform(indexSig, context) {
-    const params = await (0, _getParams().getParams)(indexSig.parameters, context);
-    const type = await (0, _typeNodeToSchema().typeNodeToSchema)(indexSig.type, context);
-    return new (_semanticsEntities().IndexSignatureSchema)(context.getLocation(indexSig), params, type);
-  }
-
-}
-
-exports.IndexSignature = IndexSignature;
-
-//# sourceMappingURL=index-signature.js.map

package/dist/transformers/index-signature.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["IndexSignature","predicate","node","kind","ts","SyntaxKind","getIdentifiers","transform","indexSig","context","params","getParams","parameters","type","typeNodeToSchema","IndexSignatureSchema","getLocation"],"sources":["index-signature.ts"],"sourcesContent":["import { SchemaNode, IndexSignatureSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, IndexSignatureDeclaration } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { getParams } from './utils/get-params';\nimport { typeNodeToSchema } from './utils/type-node-to-schema';\n\nexport class IndexSignature implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.IndexSignature;\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(indexSig: IndexSignatureDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const params = await getParams(indexSig.parameters, context);\n    const type = await typeNodeToSchema(indexSig.type, context);\n    return new IndexSignatureSchema(context.getLocation(indexSig), params, type);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAAA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAGA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AACA;EAAA;;EAAA;IAAA;EAAA;;EAAA;AAAA;;AAEO,MAAMA,cAAN,CAAkD;EACvDC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcL,cAAnC;EACD;;EAEmB,MAAdM,cAAc,GAAG;IACrB,OAAO,EAAP;EACD;;EAEc,MAATC,SAAS,CAACC,QAAD,EAAsCC,OAAtC,EAA4F;IACzG,MAAMC,MAAM,GAAG,MAAM,IAAAC,sBAAA,EAAUH,QAAQ,CAACI,UAAnB,EAA+BH,OAA/B,CAArB;IACA,MAAMI,IAAI,GAAG,MAAM,IAAAC,oCAAA,EAAiBN,QAAQ,CAACK,IAA1B,EAAgCJ,OAAhC,CAAnB;IACA,OAAO,KAAIM,yCAAJ,EAAyBN,OAAO,CAACO,WAAR,CAAoBR,QAApB,CAAzB,EAAwDE,MAAxD,EAAgEG,IAAhE,CAAP;EACD;;AAbsD"}

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

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

package/dist/transformers/method-declaration.js

@@ -1,65 +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.MethodDeclaration = 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 _toFunctionSchema() {
-  const data = require("./utils/to-function-schema");
-
-  _toFunctionSchema = function () {
-    return data;
-  };
-
-  return data;
-}
-
-class MethodDeclaration {
-  predicate(node) {
-    return node.kind === _typescript().default.SyntaxKind.MethodDeclaration;
-  }
-
-  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(methodDec, context) {
-    return (0, _toFunctionSchema().toFunctionLikeSchema)(methodDec, context);
-  }
-
-}
-
-exports.MethodDeclaration = MethodDeclaration;
-
-//# sourceMappingURL=method-declaration.js.map

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

@@ -1 +0,0 @@
-{"version":3,"names":["MethodDeclaration","predicate","node","kind","ts","SyntaxKind","getIdentifiers","funcDec","ExportIdentifier","getName","getSourceFile","fileName","name","getText","transform","methodDec","context","toFunctionLikeSchema"],"sources":["method-declaration.ts"],"sourcesContent":["import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, MethodDeclaration as MethodDeclarationNode } from 'typescript';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\nimport { toFunctionLikeSchema } from './utils/to-function-schema';\n\nexport class MethodDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.MethodDeclaration;\n  }\n\n  async getIdentifiers(funcDec: MethodDeclarationNode) {\n    return [new ExportIdentifier(this.getName(funcDec), funcDec.getSourceFile().fileName)];\n  }\n\n  private getName(funcDec: MethodDeclarationNode) {\n    return funcDec.name?.getText() || '';\n  }\n\n  async transform(methodDec: MethodDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    return toFunctionLikeSchema(methodDec, 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,iBAAN,CAAqD;EAC1DC,SAAS,CAACC,IAAD,EAAa;IACpB,OAAOA,IAAI,CAACC,IAAL,KAAcC,qBAAA,CAAGC,UAAH,CAAcL,iBAAnC;EACD;;EAEmB,MAAdM,cAAc,CAACC,OAAD,EAAiC;IACnD,OAAO,CAAC,KAAIC,oCAAJ,EAAqB,KAAKC,OAAL,CAAaF,OAAb,CAArB,EAA4CA,OAAO,CAACG,aAAR,GAAwBC,QAApE,CAAD,CAAP;EACD;;EAEOF,OAAO,CAACF,OAAD,EAAiC;IAAA;;IAC9C,OAAO,kBAAAA,OAAO,CAACK,IAAR,gEAAcC,OAAd,OAA2B,EAAlC;EACD;;EAEc,MAATC,SAAS,CAACC,SAAD,EAAmCC,OAAnC,EAAyF;IACtG,OAAO,IAAAC,wCAAA,EAAqBF,SAArB,EAAgCC,OAAhC,CAAP;EACD;;AAfyD"}