@teambit/typescript 0.0.728 → 0.0.731

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

@@ -0,0 +1,251 @@
+"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;
+}
+
+// eslint-disable-next-line complexity
+async function typeNodeToSchema(node, context) {
+  if (isKeywordType(node)) {
+    return new (_semanticsEntities().KeywordTypeSchema)(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)(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.TypePredicate:
+    case _typescript().SyntaxKind.ConstructorType:
+    case _typescript().SyntaxKind.NamedTupleMember:
+    case _typescript().SyntaxKind.OptionalType:
+    case _typescript().SyntaxKind.RestType:
+    case _typescript().SyntaxKind.ConditionalType:
+    case _typescript().SyntaxKind.InferType:
+    case _typescript().SyntaxKind.ParenthesizedType:
+    case _typescript().SyntaxKind.ThisType:
+    case _typescript().SyntaxKind.IndexedAccessType:
+    case _typescript().SyntaxKind.MappedType:
+    case _typescript().SyntaxKind.TemplateLiteralType:
+    case _typescript().SyntaxKind.TemplateLiteralTypeSpan:
+    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:
+      throw new Error(`TypeNode "${_typescript().SyntaxKind[node.kind]}" was not implemented yet.
+context: ${node.getText()}`);
+
+    default:
+      throw new Error(`Node "${_typescript().SyntaxKind[node.kind]}" is not a TypeNode.
+context: ${node.getText()}`);
+  }
+}
+/**
+ * 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;
+  });
+  return new (_semanticsEntities().TypeIntersectionSchema)(types);
+}
+
+async function unionType(node, context) {
+  const types = await (0, _pMapSeries().default)(node.types, async type => {
+    const typeSchema = await typeNodeToSchema(type, context);
+    return typeSchema;
+  });
+  return new (_semanticsEntities().TypeUnionSchema)(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, async member => {
+    const typeSchema = await context.computeSchema(member);
+    return typeSchema;
+  });
+  return new (_semanticsEntities().TypeLiteralSchema)(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);
+  return type;
+}
+
+async function functionType(node, context) {
+  var _node$name;
+
+  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);
+  return new (_semanticsEntities().FunctionSchema)(name, params, returnType, '');
+}
+/**
+ * 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);
+  return new (_semanticsEntities().TypeQuerySchema)(type, displaySig);
+}
+
+async function arrayType(node, context) {
+  const type = await typeNodeToSchema(node.elementType, context);
+  return new (_semanticsEntities().TypeArraySchema)(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)(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)(elements);
+}
+
+//# sourceMappingURL=type-node-to-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["type-node-to-schema.ts"],"names":["typeNodeToSchema","node","context","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","TypePredicate","ConstructorType","NamedTupleMember","OptionalType","RestType","ConditionalType","InferType","ParenthesizedType","ThisType","IndexedAccessType","MappedType","TemplateLiteralType","TemplateLiteralTypeSpan","ImportType","ExpressionWithTypeArguments","JSDocTypeExpression","JSDocAllType","JSDocUnknownType","JSDocNonNullableType","JSDocNullableType","JSDocOptionalType","JSDocFunctionType","JSDocVariadicType","JSDocNamepathType","JSDocSignature","JSDocTypeLiteral","Error","AnyKeyword","BigIntKeyword","BooleanKeyword","IntrinsicKeyword","NeverKeyword","NumberKeyword","ObjectKeyword","StringKeyword","SymbolKeyword","UndefinedKeyword","UnknownKeyword","VoidKeyword","types","type","typeSchema","TypeIntersectionSchema","TypeUnionSchema","members","member","computeSchema","TypeLiteralSchema","name","typeName","resolveType","params","parameters","returnType","FunctionSchema","displaySig","getQuickInfoDisplayString","exprName","TypeQuerySchema","elementType","TypeArraySchema","operatorName","getOperatorName","operator","TypeOperatorSchema","KeyOfKeyword","UniqueKeyword","ReadonlyKeyword","elements","elem","TupleTypeSchema"],"mappings":"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","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} from 'typescript';\nimport {\n  SchemaNode,\n  TypeIntersectionSchema,\n  TypeUnionSchema,\n  TypeLiteralSchema,\n  FunctionSchema,\n  TypeQuerySchema,\n  LiteralTypeSchema,\n  KeywordTypeSchema,\n  TypeArraySchema,\n  TypeOperatorSchema,\n  TupleTypeSchema,\n} from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport { SchemaExtractorContext } from '../../schema-extractor-context';\nimport { getParams } from './get-params';\n\n// eslint-disable-next-line complexity\nexport async function typeNodeToSchema(node: TypeNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n  if (isKeywordType(node)) {\n    return new KeywordTypeSchema(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(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.TypePredicate:\n    case SyntaxKind.ConstructorType:\n    case SyntaxKind.NamedTupleMember:\n    case SyntaxKind.OptionalType:\n    case SyntaxKind.RestType:\n    case SyntaxKind.ConditionalType:\n    case SyntaxKind.InferType:\n    case SyntaxKind.ParenthesizedType:\n    case SyntaxKind.ThisType:\n    case SyntaxKind.IndexedAccessType:\n    case SyntaxKind.MappedType:\n    case SyntaxKind.TemplateLiteralType:\n    case SyntaxKind.TemplateLiteralTypeSpan:\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      throw new Error(`TypeNode \"${SyntaxKind[node.kind]}\" was not implemented yet.\ncontext: ${node.getText()}`);\n    default:\n      throw new Error(`Node \"${SyntaxKind[node.kind]}\" is not a TypeNode.\ncontext: ${node.getText()}`);\n  }\n}\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  return new TypeIntersectionSchema(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  return new TypeUnionSchema(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, async (member) => {\n    const typeSchema = await context.computeSchema(member);\n    return typeSchema;\n  });\n  return new TypeLiteralSchema(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  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  return new FunctionSchema(name, params, returnType, '');\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  return new TypeQuerySchema(type, displaySig);\n}\n\nasync function arrayType(node: ArrayTypeNode, context: SchemaExtractorContext) {\n  const type = await typeNodeToSchema(node.elementType, context);\n  return new TypeArraySchema(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(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(elements);\n}\n"]}

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

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

package/dist/transformers/variable-declaration.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VariableDeclaration = 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;
+}
+
+function _parseTypeFromQuickInfo() {
+  const data = require("./utils/parse-type-from-quick-info");
+
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class VariableDeclaration {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.VariableDeclaration;
+  }
+
+  getName(node) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers(node) {
+    return [new (_exportIdentifier().ExportIdentifier)(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(varDec, context) {
+    var _info$body, _varDec$initializer;
+
+    const name = this.getName(varDec);
+    const info = await context.getQuickInfo(varDec.name);
+    const displaySig = (info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString) || '';
+
+    if (((_varDec$initializer = varDec.initializer) === null || _varDec$initializer === void 0 ? void 0 : _varDec$initializer.kind) === _typescript().default.SyntaxKind.ArrowFunction) {
+      const args = await (0, _getParams().getParams)(varDec.initializer.parameters, context);
+      const typeStr = (0, _parseTypeFromQuickInfo().parseReturnTypeFromQuickInfo)(info);
+      const returnType = await context.resolveType(varDec, typeStr);
+      return new (_semanticsEntities().FunctionSchema)(name, args, returnType, displaySig);
+    }
+
+    const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    const type = await context.resolveType(varDec, typeStr);
+    return new (_semanticsEntities().VariableSchema)(name, displaySig, type);
+  }
+
+}
+
+exports.VariableDeclaration = VariableDeclaration;
+
+//# sourceMappingURL=variable-declaration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["variable-declaration.ts"],"names":["VariableDeclaration","predicate","node","kind","ts","SyntaxKind","getName","name","getText","getIdentifiers","ExportIdentifier","getSourceFile","fileName","transform","varDec","context","info","getQuickInfo","displaySig","body","displayString","initializer","ArrowFunction","args","parameters","typeStr","returnType","resolveType","FunctionSchema","type","VariableSchema"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,mBAAN,CAAuD;AAC5DC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcL,mBAAnC;AACD;;AAEDM,EAAAA,OAAO,CAACJ,IAAD,EAAgC;AACrC,WAAOA,IAAI,CAACK,IAAL,CAAUC,OAAV,EAAP;AACD;;AAEmB,QAAdC,cAAc,CAACP,IAAD,EAAgC;AAClD,WAAO,CAAC,KAAIQ,oCAAJ,EAAqBR,IAAI,CAACK,IAAL,CAAUC,OAAV,EAArB,EAA0CN,IAAI,CAACS,aAAL,GAAqBC,QAA/D,CAAD,CAAP;AACD;;AAEc,QAATC,SAAS,CAACC,MAAD,EAAkCC,OAAlC,EAAwF;AAAA;;AACrG,UAAMR,IAAI,GAAG,KAAKD,OAAL,CAAaQ,MAAb,CAAb;AACA,UAAME,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAR,CAAqBH,MAAM,CAACP,IAA5B,CAAnB;AACA,UAAMW,UAAU,GAAG,CAAAF,IAAI,SAAJ,IAAAA,IAAI,WAAJ,0BAAAA,IAAI,CAAEG,IAAN,0DAAYC,aAAZ,KAA6B,EAAhD;;AACA,QAAI,wBAAAN,MAAM,CAACO,WAAP,4EAAoBlB,IAApB,MAA6BC,sBAAGC,UAAH,CAAciB,aAA/C,EAA8D;AAC5D,YAAMC,IAAI,GAAG,MAAM,4BAAWT,MAAM,CAACO,WAAR,CAAsCG,UAAhD,EAA4DT,OAA5D,CAAnB;AACA,YAAMU,OAAO,GAAG,4DAA6BT,IAA7B,CAAhB;AACA,YAAMU,UAAU,GAAG,MAAMX,OAAO,CAACY,WAAR,CAAoBb,MAApB,EAA4BW,OAA5B,CAAzB;AACA,aAAO,KAAIG,mCAAJ,EAAmBrB,IAAnB,EAAyBgB,IAAzB,EAA+BG,UAA/B,EAA2CR,UAA3C,CAAP;AACD;;AACD,UAAMO,OAAO,GAAG,sDAAuBT,IAAvB,CAAhB;AACA,UAAMa,IAAI,GAAG,MAAMd,OAAO,CAACY,WAAR,CAAoBb,MAApB,EAA4BW,OAA5B,CAAnB;AACA,WAAO,KAAIK,mCAAJ,EAAmBvB,IAAnB,EAAyBW,UAAzB,EAAqCW,IAArC,CAAP;AACD;;AA1B2D","sourcesContent":["import { SchemaNode, VariableSchema, FunctionSchema } from '@teambit/semantics.entities.semantic-schema';\nimport ts, { Node, VariableDeclaration as VariableDeclarationNode, ArrowFunction } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\nimport { getParams } from './utils/get-params';\nimport { parseReturnTypeFromQuickInfo, parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\n\nexport class VariableDeclaration implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.VariableDeclaration;\n  }\n\n  getName(node: VariableDeclarationNode) {\n    return node.name.getText();\n  }\n\n  async getIdentifiers(node: VariableDeclarationNode) {\n    return [new ExportIdentifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  async transform(varDec: VariableDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const name = this.getName(varDec);\n    const info = await context.getQuickInfo(varDec.name);\n    const displaySig = info?.body?.displayString || '';\n    if (varDec.initializer?.kind === ts.SyntaxKind.ArrowFunction) {\n      const args = await getParams((varDec.initializer as ArrowFunction).parameters, context);\n      const typeStr = parseReturnTypeFromQuickInfo(info);\n      const returnType = await context.resolveType(varDec, typeStr);\n      return new FunctionSchema(name, args, returnType, displaySig);\n    }\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(varDec, typeStr);\n    return new VariableSchema(name, displaySig, type);\n  }\n}\n"]}

package/dist/transformers/variable-statement.d.ts

@@ -1,8 +1,14 @@
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
 import { Node, VariableStatement } from 'typescript';
 import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
 import { ExportIdentifier } from '../export-identifier';
+/**
+ * variable statement is a collection of variable declarations.
+ * e.g. `export const a = 1, b = () => {}, c = {};`
+ */
 export declare class VariableStatementTransformer implements SchemaTransformer {
     predicate(node: Node): boolean;
     getIdentifiers(node: VariableStatement): Promise<ExportIdentifier[]>;
-    transform(): Promise<{}>;
+    transform(node: VariableStatement, context: SchemaExtractorContext): Promise<SchemaNode>;
 }

package/dist/transformers/variable-statement.js

@@ -9,6 +9,36 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.VariableStatementTransformer = void 0;
 
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+
+  _semanticsEntities = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash() {
+  const data = require("lodash");
+
+  _lodash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+
+  _pMapSeries = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _typescript() {
   const data = _interopRequireDefault(require("typescript"));
 
@@ -29,6 +59,10 @@ function _exportIdentifier() {
   return data;
 }
 
+/**
+ * variable statement is a collection of variable declarations.
+ * e.g. `export const a = 1, b = () => {}, c = {};`
+ */
 class VariableStatementTransformer {
   predicate(node) {
     return node.kind === _typescript().default.SyntaxKind.VariableStatement;
@@ -40,8 +74,14 @@ class VariableStatementTransformer {
     });
   }
 
-  async transform() {
-    return {};
+  async transform(node, context) {
+    const schemas = await (0, _pMapSeries().default)(node.declarationList.declarations, async dec => {
+      // this will get the schema from variable-declaration
+      const schema = await context.visitDefinition(dec.name);
+      return schema;
+    }); // @todo: find a better way to return an array of SchemaNode. this is not really a module
+
+    return new (_semanticsEntities().Module)((0, _lodash().compact)(schemas));
   }
 
 }

package/dist/transformers/variable-statement.js.map

@@ -1 +1 @@
-{"version":3,"sources":["variable-statement.ts"],"names":["VariableStatementTransformer","predicate","node","kind","ts","SyntaxKind","VariableStatement","getIdentifiers","declarationList","declarations","map","dec","ExportIdentifier","name","getText","getSourceFile","fileName","transform"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEO,MAAMA,4BAAN,CAAgE;AACrEC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,iBAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACL,IAAD,EAA0B;AAC5C,WAAOA,IAAI,CAACM,eAAL,CAAqBC,YAArB,CAAkCC,GAAlC,CAAuCC,GAAD,IAAS;AACpD,aAAO,KAAIC,oCAAJ,EAAqBD,GAAG,CAACE,IAAJ,CAASC,OAAT,EAArB,EAAyCH,GAAG,CAACI,aAAJ,GAAoBC,QAA7D,CAAP;AACD,KAFM,CAAP;AAGD;;AAEc,QAATC,SAAS,GAAG;AAChB,WAAO,EAAP;AACD;;AAboE","sourcesContent":["import ts, { Node, VariableStatement } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { ExportIdentifier } from '../export-identifier';\n\nexport class VariableStatementTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.VariableStatement;\n  }\n\n  async getIdentifiers(node: VariableStatement) {\n    return node.declarationList.declarations.map((dec) => {\n      return new ExportIdentifier(dec.name.getText(), dec.getSourceFile().fileName);\n    });\n  }\n\n  async transform() {\n    return {};\n  }\n}\n"]}
+{"version":3,"sources":["variable-statement.ts"],"names":["VariableStatementTransformer","predicate","node","kind","ts","SyntaxKind","VariableStatement","getIdentifiers","declarationList","declarations","map","dec","ExportIdentifier","name","getText","getSourceFile","fileName","transform","context","schemas","schema","visitDefinition","Module"],"mappings":";;;;;;;;;;;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AACA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAGA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAEA;AACA;AACA;AACA;AACO,MAAMA,4BAAN,CAAgE;AACrEC,EAAAA,SAAS,CAACC,IAAD,EAAa;AACpB,WAAOA,IAAI,CAACC,IAAL,KAAcC,sBAAGC,UAAH,CAAcC,iBAAnC;AACD;;AAEmB,QAAdC,cAAc,CAACL,IAAD,EAA0B;AAC5C,WAAOA,IAAI,CAACM,eAAL,CAAqBC,YAArB,CAAkCC,GAAlC,CAAuCC,GAAD,IAAS;AACpD,aAAO,KAAIC,oCAAJ,EAAqBD,GAAG,CAACE,IAAJ,CAASC,OAAT,EAArB,EAAyCH,GAAG,CAACI,aAAJ,GAAoBC,QAA7D,CAAP;AACD,KAFM,CAAP;AAGD;;AAEc,QAATC,SAAS,CAACf,IAAD,EAA0BgB,OAA1B,EAAgF;AAC7F,UAAMC,OAAO,GAAG,MAAM,2BAAWjB,IAAI,CAACM,eAAL,CAAqBC,YAAhC,EAA8C,MAAOE,GAAP,IAAe;AACjF;AACA,YAAMS,MAAM,GAAG,MAAMF,OAAO,CAACG,eAAR,CAAwBV,GAAG,CAACE,IAA5B,CAArB;AACA,aAAOO,MAAP;AACD,KAJqB,CAAtB,CAD6F,CAM7F;;AACA,WAAO,KAAIE,2BAAJ,EAAW,uBAAQH,OAAR,CAAX,CAAP;AACD;;AAnBoE","sourcesContent":["import { SchemaNode, Module } from '@teambit/semantics.entities.semantic-schema';\nimport { compact } from 'lodash';\nimport pMapSeries from 'p-map-series';\nimport ts, { Node, VariableStatement } from 'typescript';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { ExportIdentifier } from '../export-identifier';\n\n/**\n * variable statement is a collection of variable declarations.\n * e.g. `export const a = 1, b = () => {}, c = {};`\n */\nexport class VariableStatementTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.VariableStatement;\n  }\n\n  async getIdentifiers(node: VariableStatement) {\n    return node.declarationList.declarations.map((dec) => {\n      return new ExportIdentifier(dec.name.getText(), dec.getSourceFile().fileName);\n    });\n  }\n\n  async transform(node: VariableStatement, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const schemas = await pMapSeries(node.declarationList.declarations, async (dec) => {\n      // this will get the schema from variable-declaration\n      const schema = await context.visitDefinition(dec.name);\n      return schema;\n    });\n    // @todo: find a better way to return an array of SchemaNode. this is not really a module\n    return new Module(compact(schemas));\n  }\n}\n"]}

package/dist/typescript.extractor.d.ts

@@ -1,6 +1,6 @@
 import ts, { Node } from 'typescript';
 import { SchemaExtractor } from '@teambit/schema';
-import { SchemaNode, SemanticSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaNode, APISchema } from '@teambit/semantics.entities.semantic-schema';
 import { Component } from '@teambit/component';
 import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
 import { TypescriptMain, SchemaTransformerSlot } from './typescript.main.runtime';
@@ -15,12 +15,12 @@ export declare class TypeScriptExtractor implements SchemaExtractor {
     /**
      * extract a component schema.
      */
-    extract(component: Component): Promise<SemanticSchema>;
+    extract(component: Component): Promise<APISchema>;
     computeExportedIdentifiers(node: Node, context: SchemaExtractorContext): Promise<import("./export-identifier").ExportIdentifier[]>;
     private createContext;
     private tsserver;
     private getTsServer;
-    computeSchema(node: Node, context: SchemaExtractorContext): Promise<SchemaNode | undefined>;
+    computeSchema(node: Node, context: SchemaExtractorContext): Promise<SchemaNode>;
     /**
      * select the correct transformer for a node.
      */

package/dist/typescript.extractor.js

@@ -105,9 +105,11 @@ class TypeScriptExtractor {
     const context = this.createContext(tsserver, component);
     const exportNames = await this.computeExportedIdentifiers(mainAst, context);
     context.setExports(new (_exportList().ExportList)(exportNames));
-    await this.computeSchema(mainAst, context); // TODO: create the schema
+    const moduleSchema = await this.computeSchema(mainAst, context);
+    moduleSchema.flatExportsRecursively();
+    const apiScheme = moduleSchema; // return APISchema.from({ });
 
-    return _semanticsEntities().SemanticSchema.from({});
+    return new (_semanticsEntities().APISchema)(apiScheme);
   }
 
   async computeExportedIdentifiers(node, context) {
@@ -137,8 +139,9 @@ class TypeScriptExtractor {
   }
 
   async computeSchema(node, context) {
-    const transformer = this.getTransformer(node, context.component);
-    if (!transformer) return undefined;
+    const transformer = this.getTransformer(node, context.component); // leave the next line commented out, it is used for debugging
+    // console.log('transformer', transformer.constructor.name, node.getText());
+
     return transformer.transform(node, context);
   }
   /**

package/dist/typescript.extractor.js.map

@@ -1 +1 @@
-{"version":3,"sources":["typescript.extractor.ts"],"names":["TypeScriptExtractor","constructor","tsconfig","schemaTransformerSlot","tsMain","rootPath","undefined","parseSourceFile","file","ts","createSourceFile","path","contents","toString","ScriptTarget","Latest","compilerOptions","extract","component","tsserver","getTsServer","mainFile","mainAst","context","createContext","exportNames","computeExportedIdentifiers","setExports","ExportList","computeSchema","SemanticSchema","from","node","transformer","getTransformer","getIdentifiers","TransformerNotFound","SchemaExtractorContext","getTsserverClient","initTsserverClient","transform","transformers","values","find","singleTransformer","predicate"],"mappings":"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","sourcesContent":["import ts, { Node } from 'typescript';\nimport { SchemaExtractor } from '@teambit/schema';\nimport { TsserverClient } from '@teambit/ts-server';\nimport { SchemaNode, SemanticSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { Component } from '@teambit/component';\n// @ts-ignore david what to do?\nimport { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';\nimport { flatten } from 'lodash';\nimport { TypescriptMain, SchemaTransformerSlot } from './typescript.main.runtime';\nimport { TransformerNotFound } from './exceptions';\nimport { SchemaExtractorContext } from './schema-extractor-context';\nimport { ExportList } from './export-list';\n\nexport class TypeScriptExtractor implements SchemaExtractor {\n  constructor(\n    private tsconfig: any,\n    private schemaTransformerSlot: SchemaTransformerSlot,\n    private tsMain: TypescriptMain,\n    private rootPath: string\n  ) {}\n\n  parseSourceFile(file: AbstractVinyl) {\n    return ts.createSourceFile(\n      file.path,\n      file.contents.toString('utf8'),\n      ts.ScriptTarget.Latest,\n      true,\n      this.tsconfig.compilerOptions\n    );\n  }\n\n  /**\n   * extract a component schema.\n   */\n  async extract(component: Component) {\n    const tsserver = await this.getTsServer();\n    const mainFile = component.mainFile;\n    const mainAst = this.parseSourceFile(mainFile);\n    const context = this.createContext(tsserver, component);\n    const exportNames = await this.computeExportedIdentifiers(mainAst, context);\n    context.setExports(new ExportList(exportNames));\n    await this.computeSchema(mainAst, context); // TODO: create the schema\n\n    return SemanticSchema.from({});\n  }\n\n  async computeExportedIdentifiers(node: Node, context: SchemaExtractorContext) {\n    const transformer = this.getTransformer(node, context.component);\n    if (!transformer || !transformer.getIdentifiers) throw new TransformerNotFound(node, context.component);\n    return transformer.getIdentifiers(node, context);\n  }\n\n  private createContext(tsserver: TsserverClient, component: Component): SchemaExtractorContext {\n    return new SchemaExtractorContext(tsserver, component, this);\n  }\n\n  private tsserver: TsserverClient | undefined = undefined;\n\n  private async getTsServer() {\n    if (!this.tsserver) {\n      const tsserver = this.tsMain.getTsserverClient();\n      if (tsserver) {\n        this.tsserver = tsserver;\n        return tsserver;\n      }\n\n      this.tsserver = await this.tsMain.initTsserverClient(this.rootPath);\n      return this.tsserver;\n    }\n\n    return this.tsserver;\n  }\n\n  async computeSchema(node: Node, context: SchemaExtractorContext): Promise<SchemaNode | undefined> {\n    const transformer = this.getTransformer(node, context.component);\n    if (!transformer) return undefined;\n    return transformer.transform(node, context);\n  }\n\n  /**\n   * select the correct transformer for a node.\n   */\n  private getTransformer(node: Node, component: Component) {\n    const transformers = flatten(this.schemaTransformerSlot.values());\n    const transformer = transformers.find((singleTransformer) => singleTransformer.predicate(node));\n\n    if (!transformer) throw new TransformerNotFound(node, component);\n\n    return transformer;\n  }\n}\n"]}
+{"version":3,"sources":["typescript.extractor.ts"],"names":["TypeScriptExtractor","constructor","tsconfig","schemaTransformerSlot","tsMain","rootPath","undefined","parseSourceFile","file","ts","createSourceFile","path","contents","toString","ScriptTarget","Latest","compilerOptions","extract","component","tsserver","getTsServer","mainFile","mainAst","context","createContext","exportNames","computeExportedIdentifiers","setExports","ExportList","moduleSchema","computeSchema","flatExportsRecursively","apiScheme","APISchema","node","transformer","getTransformer","getIdentifiers","TransformerNotFound","SchemaExtractorContext","getTsserverClient","initTsserverClient","transform","transformers","values","find","singleTransformer","predicate"],"mappings":"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","sourcesContent":["import ts, { Node } from 'typescript';\nimport { SchemaExtractor } from '@teambit/schema';\nimport { TsserverClient } from '@teambit/ts-server';\nimport { SchemaNode, APISchema, Module } from '@teambit/semantics.entities.semantic-schema';\nimport { Component } from '@teambit/component';\n// @ts-ignore david what to do?\nimport { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';\nimport { flatten } from 'lodash';\nimport { TypescriptMain, SchemaTransformerSlot } from './typescript.main.runtime';\nimport { TransformerNotFound } from './exceptions';\nimport { SchemaExtractorContext } from './schema-extractor-context';\nimport { ExportList } from './export-list';\n\nexport class TypeScriptExtractor implements SchemaExtractor {\n  constructor(\n    private tsconfig: any,\n    private schemaTransformerSlot: SchemaTransformerSlot,\n    private tsMain: TypescriptMain,\n    private rootPath: string\n  ) {}\n\n  parseSourceFile(file: AbstractVinyl) {\n    return ts.createSourceFile(\n      file.path,\n      file.contents.toString('utf8'),\n      ts.ScriptTarget.Latest,\n      true,\n      this.tsconfig.compilerOptions\n    );\n  }\n\n  /**\n   * extract a component schema.\n   */\n  async extract(component: Component): Promise<APISchema> {\n    const tsserver = await this.getTsServer();\n    const mainFile = component.mainFile;\n    const mainAst = this.parseSourceFile(mainFile);\n    const context = this.createContext(tsserver, component);\n    const exportNames = await this.computeExportedIdentifiers(mainAst, context);\n    context.setExports(new ExportList(exportNames));\n    const moduleSchema = (await this.computeSchema(mainAst, context)) as Module;\n    moduleSchema.flatExportsRecursively();\n    const apiScheme = moduleSchema;\n\n    // return APISchema.from({ });\n    return new APISchema(apiScheme);\n  }\n\n  async computeExportedIdentifiers(node: Node, context: SchemaExtractorContext) {\n    const transformer = this.getTransformer(node, context.component);\n    if (!transformer || !transformer.getIdentifiers) throw new TransformerNotFound(node, context.component);\n    return transformer.getIdentifiers(node, context);\n  }\n\n  private createContext(tsserver: TsserverClient, component: Component): SchemaExtractorContext {\n    return new SchemaExtractorContext(tsserver, component, this);\n  }\n\n  private tsserver: TsserverClient | undefined = undefined;\n\n  private async getTsServer() {\n    if (!this.tsserver) {\n      const tsserver = this.tsMain.getTsserverClient();\n      if (tsserver) {\n        this.tsserver = tsserver;\n        return tsserver;\n      }\n\n      this.tsserver = await this.tsMain.initTsserverClient(this.rootPath);\n      return this.tsserver;\n    }\n\n    return this.tsserver;\n  }\n\n  async computeSchema(node: Node, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const transformer = this.getTransformer(node, context.component);\n    // leave the next line commented out, it is used for debugging\n    // console.log('transformer', transformer.constructor.name, node.getText());\n    return transformer.transform(node, context);\n  }\n\n  /**\n   * select the correct transformer for a node.\n   */\n  private getTransformer(node: Node, component: Component) {\n    const transformers = flatten(this.schemaTransformerSlot.values());\n    const transformer = transformers.find((singleTransformer) => singleTransformer.predicate(node));\n\n    if (!transformer) throw new TransformerNotFound(node, component);\n\n    return transformer;\n  }\n}\n"]}

package/dist/typescript.main.runtime.js

@@ -380,7 +380,7 @@ class TypescriptMain {
     const logger = loggerExt.createLogger(_typescript3().TypescriptAspect.id);
     aspectLoader.registerPlugins([new (_schemaTransformer().SchemaTransformerPlugin)(schemaTransformerSlot)]);
     const tsMain = new TypescriptMain(logger, schemaTransformerSlot, workspace);
-    schemaTransformerSlot.register([new (_transformers().ExportDeclaration)(), new (_transformers().FunctionDeclaration)(), new (_transformers().VariableStatementTransformer)(), new (_transformers().SourceFileTransformer)(), new (_transformers().TypeAliasTransformer)()]);
+    schemaTransformerSlot.register([new (_transformers().ExportDeclaration)(), new (_transformers().FunctionDeclaration)(), new (_transformers().MethodDeclaration)(), new (_transformers().PropertyDeclaration)(), new (_transformers().VariableStatementTransformer)(), new (_transformers().VariableDeclaration)(), new (_transformers().Constructor)(), new (_transformers().SourceFileTransformer)(), new (_transformers().TypeAliasTransformer)(), new (_transformers().ClassDecelerationTransformer)(), new (_transformers().PropertySignature)(), new (_transformers().LiteralTypeTransformer)(), new (_transformers().IndexSignature)(), new (_transformers().InterfaceDeclarationTransformer)(), new (_transformers().MethodSignatureTransformer)()]);
 
     if (workspace) {
       workspace.registerOnPreWatch(tsMain.onPreWatch.bind(this));