@teambit/typescript 0.0.965 → 0.0.966

package/dist/transformers/utils/type-node-to-schema.js

@@ -1,274 +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.typeNodeToSchema = typeNodeToSchema;
-function _typescript() {
-  const data = require("typescript");
-  _typescript = function () {
-    return data;
-  };
-  return data;
-}
-function _semanticsEntities() {
-  const data = require("@teambit/semantics.entities.semantic-schema");
-  _semanticsEntities = function () {
-    return data;
-  };
-  return data;
-}
-function _pMapSeries() {
-  const data = _interopRequireDefault(require("p-map-series"));
-  _pMapSeries = function () {
-    return data;
-  };
-  return data;
-}
-function _getParams() {
-  const data = require("./get-params");
-  _getParams = function () {
-    return data;
-  };
-  return data;
-}
-function _typeElementToSchema() {
-  const data = require("./type-element-to-schema");
-  _typeElementToSchema = function () {
-    return data;
-  };
-  return data;
-}
-// eslint-disable-next-line complexity
-async function typeNodeToSchema(node, context) {
-  const location = context.getLocation(node);
-  if (isKeywordType(node)) {
-    return new (_semanticsEntities().KeywordTypeSchema)(location, node.getText());
-  }
-  switch (node.kind) {
-    case _typescript().SyntaxKind.IntersectionType:
-      return intersectionType(node, context);
-    case _typescript().SyntaxKind.UnionType:
-      return unionType(node, context);
-    case _typescript().SyntaxKind.TypeReference:
-      return typeReference(node, context);
-    case _typescript().SyntaxKind.TypeLiteral:
-      return typeLiteral(node, context);
-    case _typescript().SyntaxKind.LiteralType:
-      // e.g. string/boolean
-      return new (_semanticsEntities().LiteralTypeSchema)(location, node.getText());
-    case _typescript().SyntaxKind.FunctionType:
-      return functionType(node, context);
-    case _typescript().SyntaxKind.TypeQuery:
-      return typeQuery(node, context);
-    case _typescript().SyntaxKind.ArrayType:
-      return arrayType(node, context);
-    case _typescript().SyntaxKind.TypeOperator:
-      return typeOperator(node, context);
-    case _typescript().SyntaxKind.TupleType:
-      return tupleType(node, context);
-    case _typescript().SyntaxKind.ParenthesizedType:
-      return parenthesizedType(node, context);
-    case _typescript().SyntaxKind.TypePredicate:
-      return typePredicate(node, context);
-    case _typescript().SyntaxKind.IndexedAccessType:
-      return indexedAccessType(node, context);
-    case _typescript().SyntaxKind.TemplateLiteralTypeSpan:
-      return templateLiteralTypeSpan(node, context);
-    case _typescript().SyntaxKind.TemplateLiteralType:
-      return templateLiteralType(node, context);
-    case _typescript().SyntaxKind.ThisType:
-      return thisType(node, context);
-    case _typescript().SyntaxKind.ConditionalType:
-      return conditionalType(node, context);
-    case _typescript().SyntaxKind.NamedTupleMember:
-      return namedTupleType(node, context);
-    case _typescript().SyntaxKind.ConstructorType:
-    case _typescript().SyntaxKind.OptionalType:
-    case _typescript().SyntaxKind.RestType:
-    case _typescript().SyntaxKind.InferType:
-    case _typescript().SyntaxKind.MappedType:
-    case _typescript().SyntaxKind.ImportType:
-    case _typescript().SyntaxKind.ExpressionWithTypeArguments:
-    case _typescript().SyntaxKind.JSDocTypeExpression:
-    case _typescript().SyntaxKind.JSDocAllType:
-    case _typescript().SyntaxKind.JSDocUnknownType:
-    case _typescript().SyntaxKind.JSDocNonNullableType:
-    case _typescript().SyntaxKind.JSDocNullableType:
-    case _typescript().SyntaxKind.JSDocOptionalType:
-    case _typescript().SyntaxKind.JSDocFunctionType:
-    case _typescript().SyntaxKind.JSDocVariadicType:
-    case _typescript().SyntaxKind.JSDocNamepathType:
-    case _typescript().SyntaxKind.JSDocSignature:
-    case _typescript().SyntaxKind.JSDocTypeLiteral:
-      return unimplementedSchema(node, context);
-    default:
-      return unimplementedSchema(node, context);
-  }
-}
-function unimplementedSchema(node, context) {
-  return new (_semanticsEntities().UnImplementedSchema)(context.getLocation(node), node.getText(), _typescript().SyntaxKind[node.kind]);
-}
-/**
- * whether it's kind of `ts.KeywordTypeSyntaxKind`
- */
-function isKeywordType(node) {
-  switch (node.kind) {
-    case _typescript().SyntaxKind.AnyKeyword:
-    case _typescript().SyntaxKind.BigIntKeyword:
-    case _typescript().SyntaxKind.BooleanKeyword:
-    case _typescript().SyntaxKind.IntrinsicKeyword:
-    case _typescript().SyntaxKind.NeverKeyword:
-    case _typescript().SyntaxKind.NumberKeyword:
-    case _typescript().SyntaxKind.ObjectKeyword:
-    case _typescript().SyntaxKind.StringKeyword:
-    case _typescript().SyntaxKind.SymbolKeyword:
-    case _typescript().SyntaxKind.UndefinedKeyword:
-    case _typescript().SyntaxKind.UnknownKeyword:
-    case _typescript().SyntaxKind.VoidKeyword:
-      return true;
-    default:
-      return false;
-  }
-}
-async function intersectionType(node, context) {
-  const types = await (0, _pMapSeries().default)(node.types, async type => {
-    const typeSchema = await typeNodeToSchema(type, context);
-    return typeSchema;
-  });
-  const location = context.getLocation(node);
-  return new (_semanticsEntities().TypeIntersectionSchema)(location, types);
-}
-async function unionType(node, context) {
-  const types = await (0, _pMapSeries().default)(node.types, async type => {
-    const typeSchema = await typeNodeToSchema(type, context);
-    return typeSchema;
-  });
-  const location = context.getLocation(node);
-  return new (_semanticsEntities().TypeUnionSchema)(location, types);
-}
-
-/**
- * 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.
- */
-async function typeLiteral(node, context) {
-  const members = await (0, _pMapSeries().default)(node.members, member => (0, _typeElementToSchema().typeElementToSchema)(member, context));
-  const location = context.getLocation(node);
-  return new (_semanticsEntities().TypeLiteralSchema)(location, members);
-}
-
-/**
- * In the following example, `AriaButtonProps` is a type reference
- * ```ts
- * import type { AriaButtonProps } from '@react-types/button';
- * export type ButtonProps = AriaButtonProps & { a: string };
- * ```
- */
-async function typeReference(node, context) {
-  const name = node.typeName.getText();
-  const type = await context.resolveType(node, name, false);
-  if (node.typeArguments && type instanceof _semanticsEntities().TypeRefSchema) {
-    const args = await (0, _pMapSeries().default)(node.typeArguments, arg => typeNodeToSchema(arg, context));
-    type.typeArgs = args;
-  }
-  return type;
-}
-async function functionType(node, context) {
-  var _node$name, _node$modifiers;
-  const name = ((_node$name = node.name) === null || _node$name === void 0 ? void 0 : _node$name.getText()) || '';
-  const params = await (0, _getParams().getParams)(node.parameters, context);
-  const returnType = await typeNodeToSchema(node.type, context);
-  const location = context.getLocation(node);
-  const modifiers = ((_node$modifiers = node.modifiers) === null || _node$modifiers === void 0 ? void 0 : _node$modifiers.map(modifier => modifier.getText())) || [];
-  const doc = await context.jsDocToDocSchema(node);
-  return new (_semanticsEntities().FunctionLikeSchema)(location, name, params, returnType, '', modifiers, doc);
-}
-
-/**
- * e.g. `typeof Foo`
- */
-async function typeQuery(node, context) {
-  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 (_semanticsEntities().TypeQuerySchema)(location, type, displaySig);
-}
-async function arrayType(node, context) {
-  const type = await typeNodeToSchema(node.elementType, context);
-  const location = context.getLocation(node);
-  return new (_semanticsEntities().TypeArraySchema)(location, type);
-}
-
-/**
- * e.g. keyof typeof Foo
- */
-async function typeOperator(node, context) {
-  const operatorName = getOperatorName(node.operator);
-  const type = await typeNodeToSchema(node.type, context);
-  return new (_semanticsEntities().TypeOperatorSchema)(context.getLocation(node), operatorName, type);
-}
-function getOperatorName(operator) {
-  switch (operator) {
-    case _typescript().SyntaxKind.KeyOfKeyword:
-      return 'keyof';
-    case _typescript().SyntaxKind.UniqueKeyword:
-      return 'unique';
-    case _typescript().SyntaxKind.ReadonlyKeyword:
-      return 'readonly';
-    default:
-      throw new Error(`getOperatorName: unable to find operator name for ${operator}`);
-  }
-}
-async function tupleType(node, context) {
-  const elements = await (0, _pMapSeries().default)(node.elements, async elem => {
-    const typeSchema = await typeNodeToSchema(elem, context);
-    return typeSchema;
-  });
-  return new (_semanticsEntities().TupleTypeSchema)(context.getLocation(node), elements);
-}
-async function parenthesizedType(node, context) {
-  const type = await typeNodeToSchema(node.type, context);
-  return new (_semanticsEntities().ParenthesizedTypeSchema)(context.getLocation(node), type);
-}
-async function typePredicate(node, context) {
-  const parameterName = (0, _typescript().isIdentifier)(node.parameterName) ? node.parameterName.getText() : 'this';
-  const type = node.type ? await typeNodeToSchema(node.type, context) : undefined;
-  const hasAssertsModifier = Boolean(node.assertsModifier);
-  return new (_semanticsEntities().TypePredicateSchema)(context.getLocation(node), parameterName, type, hasAssertsModifier);
-}
-async function indexedAccessType(node, context) {
-  const objectType = await typeNodeToSchema(node.objectType, context);
-  const indexType = await typeNodeToSchema(node.indexType, context);
-  return new (_semanticsEntities().IndexedAccessSchema)(context.getLocation(node), objectType, indexType);
-}
-async function templateLiteralType(node, context) {
-  const templateSpans = await (0, _pMapSeries().default)(node.templateSpans, span => templateLiteralTypeSpan(span, context));
-  const head = node.head.text;
-  return new (_semanticsEntities().TemplateLiteralTypeSchema)(context.getLocation(node), head, templateSpans);
-}
-async function templateLiteralTypeSpan(node, context) {
-  const type = await typeNodeToSchema(node.type, context);
-  const literal = node.literal.text;
-  return new (_semanticsEntities().TemplateLiteralTypeSpanSchema)(context.getLocation(node), literal, type);
-}
-async function thisType(node, context) {
-  return new (_semanticsEntities().ThisTypeSchema)(context.getLocation(node));
-}
-async function conditionalType(node, context) {
-  const checkType = await typeNodeToSchema(node.checkType, context);
-  const extendsType = await typeNodeToSchema(node.extendsType, context);
-  const trueType = await typeNodeToSchema(node.trueType, context);
-  const falseType = await typeNodeToSchema(node.falseType, context);
-  return new (_semanticsEntities().ConditionalTypeSchema)(context.getLocation(node), checkType, extendsType, trueType, falseType);
-}
-async function namedTupleType(node, context) {
-  const name = node.name.getText();
-  const location = context.getLocation(node);
-  const type = await typeNodeToSchema(node.type, context);
-  return new (_semanticsEntities().NamedTupleSchema)(location, type, name);
-}
-
-//# sourceMappingURL=type-node-to-schema.js.map

package/dist/transformers/utils/type-node-to-schema.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["typeNodeToSchema","node","context","location","getLocation","isKeywordType","KeywordTypeSchema","getText","kind","SyntaxKind","IntersectionType","intersectionType","UnionType","unionType","TypeReference","typeReference","TypeLiteral","typeLiteral","LiteralType","LiteralTypeSchema","FunctionType","functionType","TypeQuery","typeQuery","ArrayType","arrayType","TypeOperator","typeOperator","TupleType","tupleType","ParenthesizedType","parenthesizedType","TypePredicate","typePredicate","IndexedAccessType","indexedAccessType","TemplateLiteralTypeSpan","templateLiteralTypeSpan","TemplateLiteralType","templateLiteralType","ThisType","thisType","ConditionalType","conditionalType","NamedTupleMember","namedTupleType","ConstructorType","OptionalType","RestType","InferType","MappedType","ImportType","ExpressionWithTypeArguments","JSDocTypeExpression","JSDocAllType","JSDocUnknownType","JSDocNonNullableType","JSDocNullableType","JSDocOptionalType","JSDocFunctionType","JSDocVariadicType","JSDocNamepathType","JSDocSignature","JSDocTypeLiteral","unimplementedSchema","UnImplementedSchema","AnyKeyword","BigIntKeyword","BooleanKeyword","IntrinsicKeyword","NeverKeyword","NumberKeyword","ObjectKeyword","StringKeyword","SymbolKeyword","UndefinedKeyword","UnknownKeyword","VoidKeyword","types","pMapSeries","type","typeSchema","TypeIntersectionSchema","TypeUnionSchema","members","member","typeElementToSchema","TypeLiteralSchema","name","typeName","resolveType","typeArguments","TypeRefSchema","args","arg","typeArgs","params","getParams","parameters","returnType","modifiers","map","modifier","doc","jsDocToDocSchema","FunctionLikeSchema","displaySig","getQuickInfoDisplayString","exprName","TypeQuerySchema","elementType","TypeArraySchema","operatorName","getOperatorName","operator","TypeOperatorSchema","KeyOfKeyword","UniqueKeyword","ReadonlyKeyword","Error","elements","elem","TupleTypeSchema","ParenthesizedTypeSchema","parameterName","isIdentifier","undefined","hasAssertsModifier","Boolean","assertsModifier","TypePredicateSchema","objectType","indexType","IndexedAccessSchema","templateSpans","span","head","text","TemplateLiteralTypeSchema","literal","TemplateLiteralTypeSpanSchema","ThisTypeSchema","checkType","extendsType","trueType","falseType","ConditionalTypeSchema","NamedTupleSchema"],"sources":["type-node-to-schema.ts"],"sourcesContent":["import {\n  TypeNode,\n  SyntaxKind,\n  KeywordTypeNode,\n  FunctionTypeNode,\n  TypeQueryNode,\n  TypeReferenceNode,\n  ArrayTypeNode,\n  TypeOperatorNode,\n  TupleTypeNode,\n  IntersectionTypeNode,\n  UnionTypeNode,\n  TypeLiteralNode,\n  ParenthesizedTypeNode,\n  TypePredicateNode,\n  isIdentifier,\n  IndexedAccessTypeNode,\n  TemplateLiteralTypeNode,\n  TemplateLiteralTypeSpan,\n  ThisTypeNode,\n  ConditionalTypeNode,\n  NamedTupleMember,\n} from 'typescript';\nimport {\n  SchemaNode,\n  TypeRefSchema,\n  TypeIntersectionSchema,\n  TypeUnionSchema,\n  TypeLiteralSchema,\n  TypeQuerySchema,\n  LiteralTypeSchema,\n  KeywordTypeSchema,\n  TypeArraySchema,\n  TypeOperatorSchema,\n  TupleTypeSchema,\n  FunctionLikeSchema,\n  ParenthesizedTypeSchema,\n  TypePredicateSchema,\n  IndexedAccessSchema,\n  TemplateLiteralTypeSpanSchema,\n  TemplateLiteralTypeSchema,\n  ThisTypeSchema,\n  Modifier,\n  ConditionalTypeSchema,\n  NamedTupleSchema,\n  UnImplementedSchema,\n} from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { getParams } from './get-params';\nimport { typeElementToSchema } from './type-element-to-schema';\n\n// eslint-disable-next-line complexity\nexport async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n  const location = context.getLocation(node);\n  if (isKeywordType(node)) {\n    return new KeywordTypeSchema(location, node.getText());\n  }\n  switch (node.kind) {\n    case SyntaxKind.IntersectionType:\n      return intersectionType(node as IntersectionTypeNode, context);\n    case SyntaxKind.UnionType:\n      return unionType(node as UnionTypeNode, context);\n    case SyntaxKind.TypeReference:\n      return typeReference(node as TypeReferenceNode, context);\n    case SyntaxKind.TypeLiteral:\n      return typeLiteral(node as TypeLiteralNode, context);\n    case SyntaxKind.LiteralType: // e.g. string/boolean\n      return new LiteralTypeSchema(location, node.getText());\n    case SyntaxKind.FunctionType:\n      return functionType(node as FunctionTypeNode, context);\n    case SyntaxKind.TypeQuery:\n      return typeQuery(node as TypeQueryNode, context);\n    case SyntaxKind.ArrayType:\n      return arrayType(node as ArrayTypeNode, context);\n    case SyntaxKind.TypeOperator:\n      return typeOperator(node as TypeOperatorNode, context);\n    case SyntaxKind.TupleType:\n      return tupleType(node as TupleTypeNode, context);\n    case SyntaxKind.ParenthesizedType:\n      return parenthesizedType(node as ParenthesizedTypeNode, context);\n    case SyntaxKind.TypePredicate:\n      return typePredicate(node as TypePredicateNode, context);\n    case SyntaxKind.IndexedAccessType:\n      return indexedAccessType(node as IndexedAccessTypeNode, context);\n    case SyntaxKind.TemplateLiteralTypeSpan:\n      return templateLiteralTypeSpan(node as TemplateLiteralTypeSpan, context);\n    case SyntaxKind.TemplateLiteralType:\n      return templateLiteralType(node as TemplateLiteralTypeNode, context);\n    case SyntaxKind.ThisType:\n      return thisType(node as ThisTypeNode, context);\n    case SyntaxKind.ConditionalType:\n      return conditionalType(node as ConditionalTypeNode, context);\n    case SyntaxKind.NamedTupleMember:\n      return namedTupleType(node as NamedTupleMember, context);\n    case SyntaxKind.ConstructorType:\n    case SyntaxKind.OptionalType:\n    case SyntaxKind.RestType:\n    case SyntaxKind.InferType:\n    case SyntaxKind.MappedType:\n    case SyntaxKind.ImportType:\n    case SyntaxKind.ExpressionWithTypeArguments:\n    case SyntaxKind.JSDocTypeExpression:\n    case SyntaxKind.JSDocAllType:\n    case SyntaxKind.JSDocUnknownType:\n    case SyntaxKind.JSDocNonNullableType:\n    case SyntaxKind.JSDocNullableType:\n    case SyntaxKind.JSDocOptionalType:\n    case SyntaxKind.JSDocFunctionType:\n    case SyntaxKind.JSDocVariadicType:\n    case SyntaxKind.JSDocNamepathType:\n    case SyntaxKind.JSDocSignature:\n    case SyntaxKind.JSDocTypeLiteral:\n      return unimplementedSchema(node, context);\n    default:\n      return unimplementedSchema(node, context);\n  }\n}\n\nfunction unimplementedSchema(node: TypeNode, context: SchemaExtractorContext) {\n  return new UnImplementedSchema(context.getLocation(node), node.getText(), SyntaxKind[node.kind]);\n}\n/**\n * whether it's kind of `ts.KeywordTypeSyntaxKind`\n */\nfunction isKeywordType(node: TypeNode): node is KeywordTypeNode {\n  switch (node.kind) {\n    case SyntaxKind.AnyKeyword:\n    case SyntaxKind.BigIntKeyword:\n    case SyntaxKind.BooleanKeyword:\n    case SyntaxKind.IntrinsicKeyword:\n    case SyntaxKind.NeverKeyword:\n    case SyntaxKind.NumberKeyword:\n    case SyntaxKind.ObjectKeyword:\n    case SyntaxKind.StringKeyword:\n    case SyntaxKind.SymbolKeyword:\n    case SyntaxKind.UndefinedKeyword:\n    case SyntaxKind.UnknownKeyword:\n    case SyntaxKind.VoidKeyword:\n      return true;\n    default:\n      return false;\n  }\n}\n\nasync function intersectionType(node: IntersectionTypeNode, context: SchemaExtractorContext) {\n  const types = await pMapSeries(node.types, async (type) => {\n    const typeSchema = await typeNodeToSchema(type, context);\n    return typeSchema;\n  });\n  const location = context.getLocation(node);\n  return new TypeIntersectionSchema(location, types);\n}\n\nasync function unionType(node: UnionTypeNode, context: SchemaExtractorContext) {\n  const types = await pMapSeries(node.types, async (type) => {\n    const typeSchema = await typeNodeToSchema(type, context);\n    return typeSchema;\n  });\n  const location = context.getLocation(node);\n  return new TypeUnionSchema(location, types);\n}\n\n/**\n * not to be confused with \"LiteralType\", which is string/boolean/null.\n * this \"TypeLiteral\" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.\n */\nasync function typeLiteral(node: TypeLiteralNode, context: SchemaExtractorContext) {\n  const members = await pMapSeries(node.members, (member) => typeElementToSchema(member, context));\n  const location = context.getLocation(node);\n  return new TypeLiteralSchema(location, members);\n}\n\n/**\n * In the following example, `AriaButtonProps` is a type reference\n * ```ts\n * import type { AriaButtonProps } from '@react-types/button';\n * export type ButtonProps = AriaButtonProps & { a: string };\n * ```\n */\nasync function typeReference(node: TypeReferenceNode, context: SchemaExtractorContext) {\n  const name = node.typeName.getText();\n  const type = await context.resolveType(node, name, false);\n  if (node.typeArguments && type instanceof TypeRefSchema) {\n    const args = await pMapSeries(node.typeArguments, (arg) => typeNodeToSchema(arg, context));\n    type.typeArgs = args;\n  }\n  return type;\n}\n\nasync function functionType(node: FunctionTypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n  const name = node.name?.getText() || '';\n  const params = await getParams(node.parameters, context);\n  const returnType = await typeNodeToSchema(node.type, context);\n  const location = context.getLocation(node);\n  const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];\n  const doc = await context.jsDocToDocSchema(node);\n  return new FunctionLikeSchema(location, name, params, returnType, '', modifiers as Modifier[], doc);\n}\n\n/**\n * e.g. `typeof Foo`\n */\nasync function typeQuery(node: TypeQueryNode, context: SchemaExtractorContext) {\n  const displaySig = await context.getQuickInfoDisplayString(node.exprName);\n  const type = await context.resolveType(node.exprName, node.exprName.getText(), false);\n  const location = context.getLocation(node);\n  return new TypeQuerySchema(location, type, displaySig);\n}\n\nasync function arrayType(node: ArrayTypeNode, context: SchemaExtractorContext) {\n  const type = await typeNodeToSchema(node.elementType, context);\n  const location = context.getLocation(node);\n  return new TypeArraySchema(location, type);\n}\n\n/**\n * e.g. keyof typeof Foo\n */\nasync function typeOperator(node: TypeOperatorNode, context: SchemaExtractorContext) {\n  const operatorName = getOperatorName(node.operator);\n  const type = await typeNodeToSchema(node.type, context);\n  return new TypeOperatorSchema(context.getLocation(node), operatorName, type);\n}\n\nfunction getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {\n  switch (operator) {\n    case SyntaxKind.KeyOfKeyword:\n      return 'keyof';\n    case SyntaxKind.UniqueKeyword:\n      return 'unique';\n    case SyntaxKind.ReadonlyKeyword:\n      return 'readonly';\n    default:\n      throw new Error(`getOperatorName: unable to find operator name for ${operator}`);\n  }\n}\n\nasync function tupleType(node: TupleTypeNode, context: SchemaExtractorContext) {\n  const elements = await pMapSeries(node.elements, async (elem) => {\n    const typeSchema = await typeNodeToSchema(elem, context);\n    return typeSchema;\n  });\n  return new TupleTypeSchema(context.getLocation(node), elements);\n}\n\nasync function parenthesizedType(node: ParenthesizedTypeNode, context: SchemaExtractorContext) {\n  const type = await typeNodeToSchema(node.type, context);\n  return new ParenthesizedTypeSchema(context.getLocation(node), type);\n}\n\nasync function typePredicate(node: TypePredicateNode, context: SchemaExtractorContext) {\n  const parameterName = isIdentifier(node.parameterName) ? node.parameterName.getText() : 'this';\n  const type = node.type ? await typeNodeToSchema(node.type, context) : undefined;\n  const hasAssertsModifier = Boolean(node.assertsModifier);\n  return new TypePredicateSchema(context.getLocation(node), parameterName, type, hasAssertsModifier);\n}\n\nasync function indexedAccessType(node: IndexedAccessTypeNode, context: SchemaExtractorContext) {\n  const objectType = await typeNodeToSchema(node.objectType, context);\n  const indexType = await typeNodeToSchema(node.indexType, context);\n  return new IndexedAccessSchema(context.getLocation(node), objectType, indexType);\n}\n\nasync function templateLiteralType(node: TemplateLiteralTypeNode, context: SchemaExtractorContext) {\n  const templateSpans = await pMapSeries(node.templateSpans, (span) => templateLiteralTypeSpan(span, context));\n  const head = node.head.text;\n  return new TemplateLiteralTypeSchema(context.getLocation(node), head, templateSpans);\n}\n\nasync function templateLiteralTypeSpan(node: TemplateLiteralTypeSpan, context: SchemaExtractorContext) {\n  const type = await typeNodeToSchema(node.type, context);\n  const literal = node.literal.text;\n  return new TemplateLiteralTypeSpanSchema(context.getLocation(node), literal, type);\n}\n\nasync function thisType(node: ThisTypeNode, context: SchemaExtractorContext) {\n  return new ThisTypeSchema(context.getLocation(node));\n}\n\nasync function conditionalType(node: ConditionalTypeNode, context: SchemaExtractorContext) {\n  const checkType = await typeNodeToSchema(node.checkType, context);\n  const extendsType = await typeNodeToSchema(node.extendsType, context);\n  const trueType = await typeNodeToSchema(node.trueType, context);\n  const falseType = await typeNodeToSchema(node.falseType, context);\n  return new ConditionalTypeSchema(context.getLocation(node), checkType, extendsType, trueType, falseType);\n}\n\nasync function namedTupleType(node: NamedTupleMember, context: SchemaExtractorContext) {\n  const name = node.name.getText();\n  const location = context.getLocation(node);\n  const type = await typeNodeToSchema(node.type, context);\n  return new NamedTupleSchema(location, type, name);\n}\n"],"mappings":"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"}

package/transformers/function-declaration.ts

@@ -1,25 +0,0 @@
-import { SchemaNode } 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';
-import { toFunctionLikeSchema } from './utils/to-function-like-schema';
-
-export class FunctionDeclaration implements SchemaTransformer {
-  predicate(node: Node) {
-    return node.kind === ts.SyntaxKind.FunctionDeclaration || node.kind === ts.SyntaxKind.ArrowFunction;
-  }
-
-  // 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() || '';
-  }
-
-  async transform(funcDec: FunctionDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
-    return toFunctionLikeSchema(funcDec, context);
-  }
-}

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

@@ -1,64 +0,0 @@
-import {
-  ClassElement,
-  ConstructorDeclaration,
-  GetAccessorDeclaration,
-  IndexSignatureDeclaration,
-  MethodDeclaration,
-  PropertyDeclaration,
-  SetAccessorDeclaration,
-  SyntaxKind,
-} from 'typescript';
-import { ConstructorSchema, SchemaNode, VariableLikeSchema } 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-like-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);
-  const info = await context.getQuickInfo(node);
-  const displaySig = info?.body?.displayString;
-  return new ConstructorSchema(context.getLocation(node), args, displaySig);
-}
-
-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);
-  const isOptional = Boolean(node.questionToken);
-  const doc = await context.jsDocToDocSchema(node);
-  return new VariableLikeSchema(context.getLocation(node), name, displaySig || '', type, isOptional, doc);
-}
-
-async function methodDeclaration(node: MethodDeclaration, context: SchemaExtractorContext) {
-  return toFunctionLikeSchema(node, context);
-}

package/transformers/utils/get-params.ts

@@ -1,92 +0,0 @@
-import {
-  InferenceTypeSchema,
-  ParameterSchema,
-  TupleTypeSchema,
-  TypeLiteralSchema,
-  SchemaNode,
-} from '@teambit/semantics.entities.semantic-schema';
-import pMapSeries from 'p-map-series';
-import {
-  SyntaxKind,
-  ParameterDeclaration,
-  NodeArray,
-  isIdentifier,
-  BindingElement,
-  ArrayBindingElement,
-} from 'typescript';
-import { SchemaExtractorContext } from '../../schema-extractor-context';
-import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
-import { typeNodeToSchema } from './type-node-to-schema';
-
-export async function getParams(
-  parameterNodes: NodeArray<ParameterDeclaration>,
-  context: SchemaExtractorContext
-): Promise<ParameterSchema[]> {
-  return pMapSeries(parameterNodes, async (param) => {
-    return new ParameterSchema(
-      context.getLocation(param),
-      getParamName(param),
-      await getParamType(param, context),
-      Boolean(param.questionToken),
-      param.initializer ? param.initializer.getText() : undefined,
-      undefined,
-      await getParamObjectBindingNodes(param, context)
-    );
-  });
-}
-
-function getParamName(param: ParameterDeclaration): string {
-  if (isIdentifier(param.name)) {
-    return param.name.getText();
-  }
-  // it's binding pattern, either an array or an object
-  const elements = param.name.elements.map((elem) => elem.getText());
-  const elementsStr = elements.join(', ');
-  if (param.name.kind === SyntaxKind.ArrayBindingPattern) {
-    return `[ ${elementsStr} ]`;
-  }
-  // it's an object binding
-  return `{ ${elementsStr} }`;
-}
-
-async function getParamObjectBindingNodes(
-  param: ParameterDeclaration,
-  context: SchemaExtractorContext
-): Promise<SchemaNode[] | undefined> {
-  if (param.name.kind !== SyntaxKind.ObjectBindingPattern) return undefined;
-  return pMapSeries(param.name.elements, async (elem: BindingElement) => {
-    const info = await context.getQuickInfo(elem.name);
-    const parsed = parseTypeFromQuickInfo(info);
-    return new InferenceTypeSchema(context.getLocation(param), parsed, elem.name.getText());
-  });
-}
-
-async function getParamType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {
-  if (param.type) {
-    const type = param.type;
-    return typeNodeToSchema(type, context);
-  }
-  if (isIdentifier(param.name)) {
-    const info = await context.getQuickInfo(param.name);
-    const parsed = parseTypeFromQuickInfo(info);
-    return new InferenceTypeSchema(context.getLocation(param), parsed);
-  }
-  // it's binding pattern, either an array or an object
-  if (param.name.kind === SyntaxKind.ArrayBindingPattern) {
-    const elements = await pMapSeries(param.name.elements, async (elem: ArrayBindingElement) => {
-      const info = await context.getQuickInfo(elem);
-      const parsed = parseTypeFromQuickInfo(info);
-      return new InferenceTypeSchema(context.getLocation(param), parsed);
-    });
-    return new TupleTypeSchema(context.getLocation(param), elements);
-  }
-  if (param.name.kind === SyntaxKind.ObjectBindingPattern) {
-    const elements = await pMapSeries(param.name.elements, async (elem: BindingElement) => {
-      const info = await context.getQuickInfo(elem.name);
-      const parsed = parseTypeFromQuickInfo(info);
-      return new InferenceTypeSchema(context.getLocation(param), parsed, elem.name.getText());
-    });
-    return new TypeLiteralSchema(context.getLocation(param), elements);
-  }
-  throw new Error(`unknown param type`);
-}

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

@@ -1,39 +0,0 @@
-import { SignatureDeclaration, SyntaxKind } from 'typescript';
-import { FunctionLikeSchema, Modifier } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaExtractorContext } from '../../schema-extractor-context';
-import { getParams } from './get-params';
-import { parseTypeFromQuickInfo } from './parse-type-from-quick-info';
-
-export async function toFunctionLikeSchema(
-  node: SignatureDeclaration,
-  context: SchemaExtractorContext,
-  funcName?: string
-) {
-  const name = funcName || node.name?.getText() || '';
-  const getQuickInfoFromDefaultModifier = async () => {
-    const defaultModifier = node.modifiers?.find((modifier) => modifier.kind === SyntaxKind.DefaultKeyword);
-    if (defaultModifier) return context.getQuickInfo(defaultModifier);
-    if (node.kind === SyntaxKind.ArrowFunction) return context.getQuickInfo(node.equalsGreaterThanToken);
-    return null;
-  };
-  const info = node.name ? await context.getQuickInfo(node.name) : await getQuickInfoFromDefaultModifier();
-  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, Boolean(info));
-  const modifiers = node.modifiers?.map((modifier) => modifier.getText()) || [];
-  const typeParameters = node.typeParameters?.map((typeParam) => typeParam.name.getText());
-  const location = context.getLocation(node);
-  const doc = await context.jsDocToDocSchema(node);
-  return new FunctionLikeSchema(
-    location,
-    name,
-    args,
-    returnType,
-    displaySig,
-    modifiers as Modifier[],
-    doc,
-    typeParameters
-  );
-}

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

@@ -1,79 +0,0 @@
-import ts, {
-  SyntaxKind,
-  TypeElement,
-  MethodSignature,
-  isComputedPropertyName,
-  IndexSignatureDeclaration,
-  GetAccessorDeclaration,
-  SetAccessorDeclaration,
-  ConstructSignatureDeclaration,
-  CallSignatureDeclaration,
-} from 'typescript';
-import {
-  GetAccessorSchema,
-  IndexSignatureSchema,
-  SchemaNode,
-  SetAccessorSchema,
-  VariableLikeSchema,
-} from '@teambit/semantics.entities.semantic-schema';
-import { toFunctionLikeSchema } from './to-function-like-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:
-      return callSignature(node as CallSignatureDeclaration, context);
-    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);
-  const isOptional = Boolean(node.questionToken);
-  const doc = await context.jsDocToDocSchema(node);
-  return new VariableLikeSchema(context.getLocation(node), name, displaySig, type, isOptional, doc);
-}
-
-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);
-}
-
-async function callSignature(node: CallSignatureDeclaration, context: SchemaExtractorContext) {
-  return toFunctionLikeSchema(node, context);
-}