@teambit/typescript 0.0.965 → 0.0.967

package/dist/transformers/keyword-type.js

@@ -0,0 +1,55 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KeywordTypeTransformer = void 0;
+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;
+}
+/**
+ * whether it's kind of `ts.KeywordTypeSyntaxKind`
+ */
+class KeywordTypeTransformer {
+  predicate(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 getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const location = context.getLocation(node);
+    return new (_semanticsEntities().KeywordTypeSchema)(location, node.getText());
+  }
+}
+exports.KeywordTypeTransformer = KeywordTypeTransformer;
+
+//# sourceMappingURL=keyword-type.js.map

package/dist/transformers/keyword-type.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["KeywordTypeTransformer","predicate","node","kind","SyntaxKind","AnyKeyword","BigIntKeyword","BooleanKeyword","IntrinsicKeyword","NeverKeyword","NumberKeyword","ObjectKeyword","StringKeyword","SymbolKeyword","UndefinedKeyword","UnknownKeyword","VoidKeyword","getIdentifiers","transform","context","location","getLocation","KeywordTypeSchema","getText"],"sources":["keyword-type.ts"],"sourcesContent":["import { Node, SyntaxKind } from 'typescript';\nimport { KeywordTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\n/**\n * whether it's kind of `ts.KeywordTypeSyntaxKind`\n */\nexport class KeywordTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\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\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: Node, context: SchemaExtractorContext) {\n    const location = context.getLocation(node);\n    return new KeywordTypeSchema(location, node.getText());\n  }\n}\n"],"mappings":";;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKA;AACA;AACA;AACO,MAAMA,sBAAsB,CAA8B;EAC/DC,SAAS,CAACC,IAAU,EAAE;IACpB,QAAQA,IAAI,CAACC,IAAI;MACf,KAAKC,wBAAU,CAACC,UAAU;MAC1B,KAAKD,wBAAU,CAACE,aAAa;MAC7B,KAAKF,wBAAU,CAACG,cAAc;MAC9B,KAAKH,wBAAU,CAACI,gBAAgB;MAChC,KAAKJ,wBAAU,CAACK,YAAY;MAC5B,KAAKL,wBAAU,CAACM,aAAa;MAC7B,KAAKN,wBAAU,CAACO,aAAa;MAC7B,KAAKP,wBAAU,CAACQ,aAAa;MAC7B,KAAKR,wBAAU,CAACS,aAAa;MAC7B,KAAKT,wBAAU,CAACU,gBAAgB;MAChC,KAAKV,wBAAU,CAACW,cAAc;MAC9B,KAAKX,wBAAU,CAACY,WAAW;QACzB,OAAO,IAAI;MACb;QACE,OAAO,KAAK;IAAC;EAEnB;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAAChB,IAAU,EAAEiB,OAA+B,EAAE;IAC3D,MAAMC,QAAQ,GAAGD,OAAO,CAACE,WAAW,CAACnB,IAAI,CAAC;IAC1C,OAAO,KAAIoB,sCAAiB,EAACF,QAAQ,EAAElB,IAAI,CAACqB,OAAO,EAAE,CAAC;EACxD;AACF;AAAC"}

package/dist/transformers/literal-type.d.ts

@@ -0,0 +1,13 @@
+import { LiteralTypeNode, Node } from 'typescript';
+import { LiteralTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+/**
+ * e.g. string/boolean
+ */
+export declare class LiteralTypeTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: LiteralTypeNode, context: SchemaExtractorContext): Promise<LiteralTypeSchema>;
+}

package/dist/transformers/literal-type.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LiteralTypeTransformer = void 0;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+  _semanticsEntities = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * e.g. string/boolean
+ */
+class LiteralTypeTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.LiteralType;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const location = context.getLocation(node);
+    return new (_semanticsEntities().LiteralTypeSchema)(location, node.getText());
+  }
+}
+exports.LiteralTypeTransformer = LiteralTypeTransformer;
+
+//# sourceMappingURL=literal-type.js.map

package/dist/transformers/literal-type.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LiteralTypeTransformer","predicate","node","kind","ts","SyntaxKind","LiteralType","getIdentifiers","transform","context","location","getLocation","LiteralTypeSchema","getText"],"sources":["literal-type.ts"],"sourcesContent":["import ts, { LiteralTypeNode, Node } from 'typescript';\nimport { LiteralTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\n/**\n * e.g. string/boolean\n */\nexport class LiteralTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.LiteralType;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: LiteralTypeNode, context: SchemaExtractorContext) {\n    const location = context.getLocation(node);\n    return new LiteralTypeSchema(location, node.getText());\n  }\n}\n"],"mappings":";;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKA;AACA;AACA;AACO,MAAMA,sBAAsB,CAA8B;EAC/DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,WAAW;EAChD;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACN,IAAqB,EAAEO,OAA+B,EAAE;IACtE,MAAMC,QAAQ,GAAGD,OAAO,CAACE,WAAW,CAACT,IAAI,CAAC;IAC1C,OAAO,KAAIU,sCAAiB,EAACF,QAAQ,EAAER,IAAI,CAACW,OAAO,EAAE,CAAC;EACxD;AACF;AAAC"}

package/dist/transformers/named-tuple.d.ts

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

package/dist/transformers/named-tuple.js

@@ -0,0 +1,38 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NamedTupleTransformer = void 0;
+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;
+}
+class NamedTupleTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.NamedTupleMember;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const name = node.name.getText();
+    const location = context.getLocation(node);
+    const type = await context.computeSchema(node.type);
+    return new (_semanticsEntities().NamedTupleSchema)(location, type, name);
+  }
+}
+exports.NamedTupleTransformer = NamedTupleTransformer;
+
+//# sourceMappingURL=named-tuple.js.map

package/dist/transformers/named-tuple.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NamedTupleTransformer","predicate","node","kind","SyntaxKind","NamedTupleMember","getIdentifiers","transform","context","name","getText","location","getLocation","type","computeSchema","NamedTupleSchema"],"sources":["named-tuple.ts"],"sourcesContent":["import { Node, SyntaxKind, NamedTupleMember } from 'typescript';\nimport { NamedTupleSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class NamedTupleTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.NamedTupleMember;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: NamedTupleMember, context: SchemaExtractorContext) {\n    const name = node.name.getText();\n    const location = context.getLocation(node);\n    const type = await context.computeSchema(node.type);\n    return new NamedTupleSchema(location, type, name);\n  }\n}\n"],"mappings":";;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKO,MAAMA,qBAAqB,CAA8B;EAC9DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,gBAAgB;EAClD;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACL,IAAsB,EAAEM,OAA+B,EAAE;IACvE,MAAMC,IAAI,GAAGP,IAAI,CAACO,IAAI,CAACC,OAAO,EAAE;IAChC,MAAMC,QAAQ,GAAGH,OAAO,CAACI,WAAW,CAACV,IAAI,CAAC;IAC1C,MAAMW,IAAI,GAAG,MAAML,OAAO,CAACM,aAAa,CAACZ,IAAI,CAACW,IAAI,CAAC;IACnD,OAAO,KAAIE,qCAAgB,EAACJ,QAAQ,EAAEE,IAAI,EAAEJ,IAAI,CAAC;EACnD;AACF;AAAC"}

package/dist/transformers/parameter.d.ts

@@ -0,0 +1,13 @@
+import { Node, ParameterDeclaration } from 'typescript';
+import { ParameterSchema, SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class ParameterTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: ParameterDeclaration, context: SchemaExtractorContext): Promise<ParameterSchema>;
+    getName(param: ParameterDeclaration): string;
+    getType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode>;
+    getObjectBindingNodes(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode[] | undefined>;
+}

package/dist/transformers/parameter.js

@@ -0,0 +1,112 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParameterTransformer = void 0;
+function _typescript() {
+  const data = _interopRequireWildcard(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 _parseTypeFromQuickInfo() {
+  const data = require("./utils/parse-type-from-quick-info");
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+  return data;
+}
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+class ParameterTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.Parameter;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    return new (_semanticsEntities().ParameterSchema)(context.getLocation(node), this.getName(node), await this.getType(node, context), Boolean(node.questionToken), node.initializer ? node.initializer.getText() : undefined, undefined, await this.getObjectBindingNodes(node, context));
+  }
+  getName(param) {
+    if ((0, _typescript().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 === _typescript().SyntaxKind.ArrayBindingPattern) {
+      return `[ ${elementsStr} ]`;
+    }
+    // it's an object binding
+    return `{ ${elementsStr} }`;
+  }
+  async getType(param, context) {
+    if (param.type) {
+      return context.computeSchema(param.type);
+    }
+    if ((0, _typescript().isIdentifier)(param.name)) {
+      const info = await context.getQuickInfo(param.name);
+      const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+      return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed);
+    }
+    // it's binding pattern, either an array or an object
+    if (param.name.kind === _typescript().SyntaxKind.ArrayBindingPattern) {
+      const elements = await (0, _pMapSeries().default)(param.name.elements, async elem => {
+        const info = await context.getQuickInfo(elem);
+        const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+        return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed);
+      });
+      return new (_semanticsEntities().TupleTypeSchema)(context.getLocation(param), elements);
+    }
+    if (param.name.kind === _typescript().SyntaxKind.ObjectBindingPattern) {
+      const elements = await (0, _pMapSeries().default)(param.name.elements, async elem => {
+        const info = await context.getQuickInfo(elem.name);
+        const parsed = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+        return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed, elem.name.getText());
+      });
+      return new (_semanticsEntities().TypeLiteralSchema)(context.getLocation(param), elements);
+    }
+    throw new Error(`unknown param type`);
+  }
+  async getObjectBindingNodes(param, context) {
+    if (param.name.kind !== _typescript().SyntaxKind.ObjectBindingPattern) return undefined;
+    return (0, _pMapSeries().default)(param.name.elements, async elem => {
+      const info = elem.name.kind === _typescript().SyntaxKind.ObjectBindingPattern ? undefined : await context.getQuickInfo(elem.name);
+      // @todo look into extracting nested objected binding patters
+      /**
+         * apiNode: {
+            api: {
+              name,
+              signature: defaultSignature,
+              doc, 
+              location: { filePath },
+            },
+          },
+         */
+      const parsed = info ? (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info) : elem.getText();
+      return new (_semanticsEntities().InferenceTypeSchema)(context.getLocation(param), parsed, elem.name.getText());
+    });
+  }
+}
+exports.ParameterTransformer = ParameterTransformer;
+
+//# sourceMappingURL=parameter.js.map

package/dist/transformers/parameter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ParameterTransformer","predicate","node","kind","ts","SyntaxKind","Parameter","getIdentifiers","transform","context","ParameterSchema","getLocation","getName","getType","Boolean","questionToken","initializer","getText","undefined","getObjectBindingNodes","param","isIdentifier","name","elements","map","elem","elementsStr","join","ArrayBindingPattern","type","computeSchema","info","getQuickInfo","parsed","parseTypeFromQuickInfo","InferenceTypeSchema","pMapSeries","TupleTypeSchema","ObjectBindingPattern","TypeLiteralSchema","Error"],"sources":["parameter.ts"],"sourcesContent":["import ts, {\n  BindingElement,\n  isIdentifier,\n  Node,\n  ParameterDeclaration,\n  SyntaxKind,\n  ArrayBindingElement,\n} from 'typescript';\nimport {\n  InferenceTypeSchema,\n  ParameterSchema,\n  SchemaNode,\n  TupleTypeSchema,\n  TypeLiteralSchema,\n} from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\nimport { Identifier } from '../identifier';\n\nexport class ParameterTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.Parameter;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: ParameterDeclaration, context: SchemaExtractorContext) {\n    return new ParameterSchema(\n      context.getLocation(node),\n      this.getName(node),\n      await this.getType(node, context),\n      Boolean(node.questionToken),\n      node.initializer ? node.initializer.getText() : undefined,\n      undefined,\n      await this.getObjectBindingNodes(node, context)\n    );\n  }\n\n  getName(param: ParameterDeclaration): string {\n    if (isIdentifier(param.name)) {\n      return param.name.getText();\n    }\n    // it's binding pattern, either an array or an object\n    const elements = param.name.elements.map((elem) => elem.getText());\n    const elementsStr = elements.join(', ');\n    if (param.name.kind === SyntaxKind.ArrayBindingPattern) {\n      return `[ ${elementsStr} ]`;\n    }\n    // it's an object binding\n    return `{ ${elementsStr} }`;\n  }\n\n  async getType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode> {\n    if (param.type) {\n      return context.computeSchema(param.type);\n    }\n\n    if (isIdentifier(param.name)) {\n      const info = await context.getQuickInfo(param.name);\n      const parsed = parseTypeFromQuickInfo(info);\n      return new InferenceTypeSchema(context.getLocation(param), parsed);\n    }\n    // it's binding pattern, either an array or an object\n    if (param.name.kind === SyntaxKind.ArrayBindingPattern) {\n      const elements = await pMapSeries(param.name.elements, async (elem: ArrayBindingElement) => {\n        const info = await context.getQuickInfo(elem);\n        const parsed = parseTypeFromQuickInfo(info);\n        return new InferenceTypeSchema(context.getLocation(param), parsed);\n      });\n      return new TupleTypeSchema(context.getLocation(param), elements);\n    }\n    if (param.name.kind === SyntaxKind.ObjectBindingPattern) {\n      const elements = await pMapSeries(param.name.elements, async (elem: BindingElement) => {\n        const info = await context.getQuickInfo(elem.name);\n        const parsed = parseTypeFromQuickInfo(info);\n        return new InferenceTypeSchema(context.getLocation(param), parsed, elem.name.getText());\n      });\n      return new TypeLiteralSchema(context.getLocation(param), elements);\n    }\n    throw new Error(`unknown param type`);\n  }\n\n  async getObjectBindingNodes(\n    param: ParameterDeclaration,\n    context: SchemaExtractorContext\n  ): Promise<SchemaNode[] | undefined> {\n    if (param.name.kind !== SyntaxKind.ObjectBindingPattern) return undefined;\n    return pMapSeries(param.name.elements, async (elem: BindingElement) => {\n      const info =\n        elem.name.kind === SyntaxKind.ObjectBindingPattern ? undefined : await context.getQuickInfo(elem.name);\n      // @todo look into extracting nested objected binding patters\n      /**\n         * apiNode: {\n            api: {\n              name,\n              signature: defaultSignature,\n              doc, \n              location: { filePath },\n            },\n          },\n         */\n      const parsed = info ? parseTypeFromQuickInfo(info) : elem.getText();\n      return new InferenceTypeSchema(context.getLocation(param), parsed, elem.name.getText());\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/transformers/parenthesized-type.d.ts

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

package/dist/transformers/parenthesized-type.js

@@ -0,0 +1,36 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParenthesizedTypeTransformer = void 0;
+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;
+}
+class ParenthesizedTypeTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.ParenthesizedType;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const type = await context.computeSchema(node.type);
+    return new (_semanticsEntities().ParenthesizedTypeSchema)(context.getLocation(node), type);
+  }
+}
+exports.ParenthesizedTypeTransformer = ParenthesizedTypeTransformer;
+
+//# sourceMappingURL=parenthesized-type.js.map

package/dist/transformers/parenthesized-type.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ParenthesizedTypeTransformer","predicate","node","kind","SyntaxKind","ParenthesizedType","getIdentifiers","transform","context","type","computeSchema","ParenthesizedTypeSchema","getLocation"],"sources":["parenthesized-type.ts"],"sourcesContent":["import { Node, ParenthesizedTypeNode, SyntaxKind } from 'typescript';\nimport { ParenthesizedTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class ParenthesizedTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.ParenthesizedType;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: ParenthesizedTypeNode, context: SchemaExtractorContext) {\n    const type = await context.computeSchema(node.type);\n    return new ParenthesizedTypeSchema(context.getLocation(node), type);\n  }\n}\n"],"mappings":";;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKO,MAAMA,4BAA4B,CAA8B;EACrEC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,iBAAiB;EACnD;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACL,IAA2B,EAAEM,OAA+B,EAAE;IAC5E,MAAMC,IAAI,GAAG,MAAMD,OAAO,CAACE,aAAa,CAACR,IAAI,CAACO,IAAI,CAAC;IACnD,OAAO,KAAIE,4CAAuB,EAACH,OAAO,CAACI,WAAW,CAACV,IAAI,CAAC,EAAEO,IAAI,CAAC;EACrE;AACF;AAAC"}

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

@@ -0,0 +1,11 @@
+import { Node, PropertyDeclaration, PropertySignature } from 'typescript';
+import { VariableLikeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class PropertyDeclarationTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    private isComputedProperty;
+    transform(node: PropertyDeclaration | PropertySignature, context: SchemaExtractorContext): Promise<VariableLikeSchema>;
+}

package/dist/transformers/property-declaration.js

@@ -0,0 +1,57 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PropertyDeclarationTransformer = void 0;
+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 _parseTypeFromQuickInfo() {
+  const data = require("./utils/parse-type-from-quick-info");
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+  return data;
+}
+class PropertyDeclarationTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.PropertyDeclaration || node.kind === _typescript().SyntaxKind.PropertySignature;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+
+  // [computedName]: string
+  isComputedProperty(node) {
+    return node.name.kind === _typescript().SyntaxKind.ComputedPropertyName;
+  }
+
+  // @todo - handle arrow function objects
+  async transform(node, context) {
+    var _info$body;
+    const name = node.name.getText();
+    const info = this.isComputedProperty(node) ? undefined : await context.getQuickInfo(node.name);
+    const displaySig = (info === null || info === void 0 ? void 0 : (_info$body = info.body) === null || _info$body === void 0 ? void 0 : _info$body.displayString) || node.getText();
+    const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    const type = await context.resolveType(node, typeStr);
+    const isOptional = Boolean(node.questionToken);
+    const doc = await context.jsDocToDocSchema(node);
+    return new (_semanticsEntities().VariableLikeSchema)(context.getLocation(node), name, displaySig, type, isOptional, doc);
+  }
+}
+exports.PropertyDeclarationTransformer = PropertyDeclarationTransformer;
+
+//# sourceMappingURL=property-declaration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["PropertyDeclarationTransformer","predicate","node","kind","SyntaxKind","PropertyDeclaration","PropertySignature","getIdentifiers","isComputedProperty","name","ComputedPropertyName","transform","context","getText","info","undefined","getQuickInfo","displaySig","body","displayString","typeStr","parseTypeFromQuickInfo","type","resolveType","isOptional","Boolean","questionToken","doc","jsDocToDocSchema","VariableLikeSchema","getLocation"],"sources":["property-declaration.ts"],"sourcesContent":["import { Node, PropertyDeclaration, PropertySignature, SyntaxKind } from 'typescript';\nimport { VariableLikeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';\nimport { Identifier } from '../identifier';\n\nexport class PropertyDeclarationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  // [computedName]: string\n  private isComputedProperty(node: PropertyDeclaration | PropertySignature) {\n    return node.name.kind === SyntaxKind.ComputedPropertyName;\n  }\n\n  // @todo - handle arrow function objects\n  async transform(node: PropertyDeclaration | PropertySignature, context: SchemaExtractorContext) {\n    const name = node.name.getText();\n    const info = this.isComputedProperty(node) ? undefined : await context.getQuickInfo(node.name);\n    const displaySig = info?.body?.displayString || node.getText();\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(node, typeStr);\n    const isOptional = Boolean(node.questionToken);\n    const doc = await context.jsDocToDocSchema(node);\n    return new VariableLikeSchema(context.getLocation(node), name, displaySig, type, isOptional, doc);\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;AAGO,MAAMA,8BAA8B,CAA8B;EACvEC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,mBAAmB,IAAIH,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACE,iBAAiB;EACnG;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;;EAEA;EACQC,kBAAkB,CAACN,IAA6C,EAAE;IACxE,OAAOA,IAAI,CAACO,IAAI,CAACN,IAAI,KAAKC,wBAAU,CAACM,oBAAoB;EAC3D;;EAEA;EACA,MAAMC,SAAS,CAACT,IAA6C,EAAEU,OAA+B,EAAE;IAAA;IAC9F,MAAMH,IAAI,GAAGP,IAAI,CAACO,IAAI,CAACI,OAAO,EAAE;IAChC,MAAMC,IAAI,GAAG,IAAI,CAACN,kBAAkB,CAACN,IAAI,CAAC,GAAGa,SAAS,GAAG,MAAMH,OAAO,CAACI,YAAY,CAACd,IAAI,CAACO,IAAI,CAAC;IAC9F,MAAMQ,UAAU,GAAG,CAAAH,IAAI,aAAJA,IAAI,qCAAJA,IAAI,CAAEI,IAAI,+CAAV,WAAYC,aAAa,KAAIjB,IAAI,CAACW,OAAO,EAAE;IAC9D,MAAMO,OAAO,GAAG,IAAAC,gDAAsB,EAACP,IAAI,CAAC;IAC5C,MAAMQ,IAAI,GAAG,MAAMV,OAAO,CAACW,WAAW,CAACrB,IAAI,EAAEkB,OAAO,CAAC;IACrD,MAAMI,UAAU,GAAGC,OAAO,CAACvB,IAAI,CAACwB,aAAa,CAAC;IAC9C,MAAMC,GAAG,GAAG,MAAMf,OAAO,CAACgB,gBAAgB,CAAC1B,IAAI,CAAC;IAChD,OAAO,KAAI2B,uCAAkB,EAACjB,OAAO,CAACkB,WAAW,CAAC5B,IAAI,CAAC,EAAEO,IAAI,EAAEQ,UAAU,EAAEK,IAAI,EAAEE,UAAU,EAAEG,GAAG,CAAC;EACnG;AACF;AAAC"}

package/dist/transformers/set-accessor.d.ts

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

package/dist/transformers/set-accessor.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SetAccessorTransformer = void 0;
+function _typescript() {
+  const data = _interopRequireDefault(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;
+}
+class SetAccessorTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.SetAccessor;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const params = await (0, _pMapSeries().default)(node.parameters, async param => context.computeSchema(param));
+    const displaySig = await context.getQuickInfoDisplayString(node.name);
+    return new (_semanticsEntities().SetAccessorSchema)(context.getLocation(node), node.name.getText(), params[0], displaySig);
+  }
+}
+exports.SetAccessorTransformer = SetAccessorTransformer;
+
+//# sourceMappingURL=set-accessor.js.map

package/dist/transformers/set-accessor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SetAccessorTransformer","predicate","node","kind","ts","SyntaxKind","SetAccessor","getIdentifiers","transform","context","params","pMapSeries","parameters","param","computeSchema","displaySig","getQuickInfoDisplayString","name","SetAccessorSchema","getLocation","getText"],"sources":["set-accessor.ts"],"sourcesContent":["import ts, { Node, SetAccessorDeclaration } from 'typescript';\nimport { ParameterSchema, SetAccessorSchema } from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class SetAccessorTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.SetAccessor;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: SetAccessorDeclaration, context: SchemaExtractorContext) {\n    const params = (await pMapSeries(node.parameters, async (param) =>\n      context.computeSchema(param)\n    )) as ParameterSchema[];\n\n    const displaySig = await context.getQuickInfoDisplayString(node.name);\n    return new SetAccessorSchema(context.getLocation(node), node.name.getText(), params[0], displaySig);\n  }\n}\n"],"mappings":";;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKO,MAAMA,sBAAsB,CAA8B;EAC/DC,SAAS,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,WAAW;EAChD;EAEA,MAAMC,cAAc,GAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAAS,CAACN,IAA4B,EAAEO,OAA+B,EAAE;IAC7E,MAAMC,MAAM,GAAI,MAAM,IAAAC,qBAAU,EAACT,IAAI,CAACU,UAAU,EAAE,MAAOC,KAAK,IAC5DJ,OAAO,CAACK,aAAa,CAACD,KAAK,CAAC,CACP;IAEvB,MAAME,UAAU,GAAG,MAAMN,OAAO,CAACO,yBAAyB,CAACd,IAAI,CAACe,IAAI,CAAC;IACrE,OAAO,KAAIC,sCAAiB,EAACT,OAAO,CAACU,WAAW,CAACjB,IAAI,CAAC,EAAEA,IAAI,CAACe,IAAI,CAACG,OAAO,EAAE,EAAEV,MAAM,CAAC,CAAC,CAAC,EAAEK,UAAU,CAAC;EACrG;AACF;AAAC"}

package/dist/transformers/source-file-transformer.d.ts

@@ -1,14 +1,15 @@
 import { Node, SourceFile } from 'typescript';
 import { ModuleSchema } from '@teambit/semantics.entities.semantic-schema';
 import { SchemaTransformer } from '../schema-transformer';
-import { ExportIdentifier } from '../export-identifier';
 import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
 export declare class SourceFileTransformer implements SchemaTransformer {
     predicate(node: Node): boolean;
-    getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext): Promise<ExportIdentifier[]>;
+    getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext): Promise<Identifier[]>;
     transform(node: SourceFile, context: SchemaExtractorContext): Promise<ModuleSchema>;
     /**
      * list all exports of a source file.
      */
     private listExports;
+    private listInternalNodes;
 }

package/dist/transformers/source-file-transformer.js

@@ -35,45 +35,74 @@ function _semanticsEntities() {
   };
   return data;
 }
+function _exportIdentifier() {
+  const data = require("../export-identifier");
+  _exportIdentifier = function () {
+    return data;
+  };
+  return data;
+}
 class SourceFileTransformer {
   predicate(node) {
     return node.kind === _typescript().default.SyntaxKind.SourceFile;
   }
   async getIdentifiers(sourceFile, context) {
     const exports = this.listExports(sourceFile);
-    const exportNames = await Promise.all(exports.map(node => {
-      return context.getExportedIdentifiers(node);
-    }));
-    const exportIds = (0, _lodash().flatten)(exportNames).reduce((acc, current) => {
-      const item = acc.find(exportName => exportName.id === current.id);
+    const internals = this.listInternalNodes(sourceFile);
+
+    // change to pMap series
+    const exportIdentifiers = (0, _lodash().flatten)(await (0, _pMapSeries().default)(exports, node => {
+      return context.getIdentifiers(node);
+    })).reduce((acc, current) => {
+      const item = acc.find(exportIdentifier => exportIdentifier.isEqual(current));
+      if (!item) acc.push(new (_exportIdentifier().ExportIdentifier)(current.id, current.filePath, current.aliasId, current.sourceFilePath));
+      return acc;
+    }, []);
+    const internalIdentifiers = (0, _lodash().flatten)(await (0, _pMapSeries().default)(internals, node => {
+      return context.getIdentifiers(node);
+    })).reduce((acc, current) => {
+      const item = acc.find(internalIdentifier => internalIdentifier.isEqual(current));
       if (!item) acc.push(current);
       return acc;
     }, []);
-    return exportIds;
+    const identifiers = [...exportIdentifiers, ...internalIdentifiers];
+    return identifiers;
   }
   async transform(node, context) {
     const exports = this.listExports(node);
-    const schemas = await (0, _pMapSeries().default)(exports, exportNode => {
+    const internals = this.listInternalNodes(node).filter(internal => internal.kind !== _typescript().default.SyntaxKind.ImportDeclaration);
+    const exportDeclarations = await (0, _pMapSeries().default)(exports, exportNode => {
       return context.computeSchema(exportNode);
     });
-    return new (_semanticsEntities().ModuleSchema)(context.getLocation(node), schemas);
+    const internalDeclarations = await (0, _pMapSeries().default)(internals, internalNode => {
+      return context.computeSchema(internalNode);
+    });
+    return new (_semanticsEntities().ModuleSchema)(context.getLocation(node), exportDeclarations, internalDeclarations);
   }
 
   /**
    * list all exports of a source file.
    */
   listExports(ast) {
-    return (0, _lodash().compact)(ast.statements.map(statement => {
+    return ast.statements.filter(statement => {
       var _statement$modifiers;
-      if (statement.kind === _typescript().default.SyntaxKind.ExportDeclaration) return statement;
+      if (statement.kind === _typescript().default.SyntaxKind.ExportDeclaration || statement.kind === _typescript().default.SyntaxKind.ExportAssignment) return true;
       const isExport = Boolean((_statement$modifiers = statement.modifiers) === null || _statement$modifiers === void 0 ? void 0 : _statement$modifiers.find(modifier => {
         return modifier.kind === _typescript().default.SyntaxKind.ExportKeyword;
       }));
-
-      // eslint-disable-next-line consistent-return
-      if (!isExport) return;
-      return statement;
-    }));
+      return isExport;
+    });
+  }
+  listInternalNodes(ast) {
+    return ast.statements.filter(statement => {
+      var _statement$modifiers2;
+      if (!(statement.kind === _typescript().default.SyntaxKind.ExportDeclaration || statement.kind === _typescript().default.SyntaxKind.ExportAssignment) && !((_statement$modifiers2 = statement.modifiers) !== null && _statement$modifiers2 !== void 0 && _statement$modifiers2.find(modifier => {
+        return modifier.kind === _typescript().default.SyntaxKind.ExportKeyword;
+      }))) {
+        return true;
+      }
+      return false;
+    });
   }
 }
 exports.SourceFileTransformer = SourceFileTransformer;