@teambit/typescript 0.0.0-004aea01bc027e428dfd0f6583f49a1b8286bdd0

package/dist/transformers/interface-declaration.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InterfaceDeclarationTransformer = void 0;
+function _typescript() {
+  const data = require("typescript");
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+  _semanticsEntities = function () {
+    return data;
+  };
+  return data;
+}
+function _identifier() {
+  const data = require("../identifier");
+  _identifier = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class InterfaceDeclarationTransformer {
+  predicate(node) {
+    return node.kind === _typescript().SyntaxKind.InterfaceDeclaration;
+  }
+  async getIdentifiers(node) {
+    return [new (_identifier().Identifier)(node.name.getText(), node.getSourceFile().fileName)];
+  }
+  async getExpressionWithTypeArgs(node, context) {
+    if (!node.heritageClauses) return [];
+    return (0, _pMapSeries().default)(node.heritageClauses.filter(heritageClause => heritageClause.token === _typescript().SyntaxKind.ExtendsKeyword).flatMap(h => {
+      const {
+        types
+      } = h;
+      const name = h.getText();
+      return types.map(type => _objectSpread(_objectSpread({}, type), {}, {
+        name
+      }));
+    }), async expressionWithTypeArgs => {
+      const {
+        typeArguments,
+        expression,
+        name
+      } = expressionWithTypeArgs;
+      const typeArgsNodes = typeArguments ? await (0, _pMapSeries().default)(typeArguments, t => context.computeSchema(t)) : [];
+      const location = context.getLocation(expression);
+      const expressionNode = (await context.visitDefinition(expression)) || new (_semanticsEntities().UnresolvedSchema)(location, expression.getText());
+      return new (_semanticsEntities().ExpressionWithTypeArgumentsSchema)(typeArgsNodes, expressionNode, name, location);
+    });
+  }
+  async transform(interfaceDec, context) {
+    const members = await (0, _pMapSeries().default)(interfaceDec.members, member => context.computeSchema(member));
+    const doc = await context.jsDocToDocSchema(interfaceDec);
+    const signature = interfaceDec.name ? await context.getQuickInfoDisplayString(interfaceDec.name) : undefined;
+    const extendsNodes = await this.getExpressionWithTypeArgs(interfaceDec, context);
+    const typeParameters = interfaceDec.typeParameters?.map(typeParam => {
+      return typeParam.name.getText();
+    });
+    if (!signature) {
+      throw Error(`Missing signature for interface ${interfaceDec.name.getText()} declaration`);
+    }
+    return new (_semanticsEntities().InterfaceSchema)(context.getLocation(interfaceDec), interfaceDec.name.getText(), signature, extendsNodes, members, doc, typeParameters);
+  }
+}
+exports.InterfaceDeclarationTransformer = InterfaceDeclarationTransformer;
+
+//# sourceMappingURL=interface-declaration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","require","_pMapSeries","_interopRequireDefault","_semanticsEntities","_identifier","e","__esModule","default","ownKeys","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","InterfaceDeclarationTransformer","predicate","node","kind","SyntaxKind","InterfaceDeclaration","getIdentifiers","Identifier","name","getText","getSourceFile","fileName","getExpressionWithTypeArgs","context","heritageClauses","pMapSeries","heritageClause","token","ExtendsKeyword","flatMap","h","types","map","type","expressionWithTypeArgs","typeArguments","expression","typeArgsNodes","computeSchema","location","getLocation","expressionNode","visitDefinition","UnresolvedSchema","ExpressionWithTypeArgumentsSchema","transform","interfaceDec","members","member","doc","jsDocToDocSchema","signature","getQuickInfoDisplayString","undefined","extendsNodes","typeParameters","typeParam","Error","InterfaceSchema","exports"],"sources":["interface-declaration.ts"],"sourcesContent":["import type { Node, InterfaceDeclaration } from 'typescript';\nimport type ts from 'typescript';\nimport { SyntaxKind } from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport {\n  ExpressionWithTypeArgumentsSchema,\n  InterfaceSchema,\n  UnresolvedSchema,\n} from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class InterfaceDeclarationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === SyntaxKind.InterfaceDeclaration;\n  }\n\n  async getIdentifiers(node: InterfaceDeclaration): Promise<Identifier[]> {\n    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  private async getExpressionWithTypeArgs(node: InterfaceDeclaration, context: SchemaExtractorContext) {\n    if (!node.heritageClauses) return [];\n\n    return pMapSeries(\n      node.heritageClauses\n        .filter((heritageClause: ts.HeritageClause) => heritageClause.token === SyntaxKind.ExtendsKeyword)\n        .flatMap((h: ts.HeritageClause) => {\n          const { types } = h;\n          const name = h.getText();\n          return types.map((type) => ({ ...type, name }));\n        }),\n      async (expressionWithTypeArgs: ts.ExpressionWithTypeArguments & { name: string }) => {\n        const { typeArguments, expression, name } = expressionWithTypeArgs;\n        const typeArgsNodes = typeArguments ? await pMapSeries(typeArguments, (t) => context.computeSchema(t)) : [];\n        const location = context.getLocation(expression);\n        const expressionNode =\n          (await context.visitDefinition(expression)) || new UnresolvedSchema(location, expression.getText());\n        return new ExpressionWithTypeArgumentsSchema(typeArgsNodes, expressionNode, name, location);\n      }\n    );\n  }\n\n  async transform(interfaceDec: InterfaceDeclaration, context: SchemaExtractorContext) {\n    const members = await pMapSeries(interfaceDec.members, (member) => context.computeSchema(member));\n    const doc = await context.jsDocToDocSchema(interfaceDec);\n    const signature = interfaceDec.name ? await context.getQuickInfoDisplayString(interfaceDec.name) : undefined;\n    const extendsNodes = await this.getExpressionWithTypeArgs(interfaceDec, context);\n    const typeParameters = interfaceDec.typeParameters?.map((typeParam) => {\n      return typeParam.name.getText();\n    });\n\n    if (!signature) {\n      throw Error(`Missing signature for interface ${interfaceDec.name.getText()} declaration`);\n    }\n\n    return new InterfaceSchema(\n      context.getLocation(interfaceDec),\n      interfaceDec.name.getText(),\n      signature,\n      extendsNodes,\n      members,\n      doc,\n      typeParameters\n    );\n  }\n}\n"],"mappings":"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","ignoreList":[]}

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

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

package/dist/transformers/intersection-type.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IntersectionTypeTransformer = 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;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class IntersectionTypeTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.IntersectionType;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const types = await (0, _pMapSeries().default)(node.types, async type => {
+      const typeSchema = context.computeSchema(type);
+      return typeSchema;
+    });
+    const location = context.getLocation(node);
+    return new (_semanticsEntities().TypeIntersectionSchema)(location, types);
+  }
+}
+exports.IntersectionTypeTransformer = IntersectionTypeTransformer;
+
+//# sourceMappingURL=intersection-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_semanticsEntities","_pMapSeries","e","__esModule","default","IntersectionTypeTransformer","predicate","node","kind","ts","SyntaxKind","IntersectionType","getIdentifiers","transform","context","types","pMapSeries","type","typeSchema","computeSchema","location","getLocation","TypeIntersectionSchema","exports"],"sources":["intersection-type.ts"],"sourcesContent":["import type { Node, IntersectionTypeNode } from 'typescript';\nimport ts from 'typescript';\nimport { TypeIntersectionSchema } from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { Identifier } from '../identifier';\n\nexport class IntersectionTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.IntersectionType;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: IntersectionTypeNode, context: SchemaExtractorContext) {\n    const types = await pMapSeries(node.types, async (type) => {\n      const typeSchema = context.computeSchema(type);\n      return typeSchema;\n    });\n    const location = context.getLocation(node);\n    return new TypeIntersectionSchema(location, types);\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,mBAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,YAAA;EAAA,MAAAJ,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAE,WAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAsC,SAAAC,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAK/B,MAAMG,2BAA2B,CAA8B;EACpEC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,gBAAgB;EACrD;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,CAACN,IAA0B,EAAEO,OAA+B,EAAE;IAC3E,MAAMC,KAAK,GAAG,MAAM,IAAAC,qBAAU,EAACT,IAAI,CAACQ,KAAK,EAAE,MAAOE,IAAI,IAAK;MACzD,MAAMC,UAAU,GAAGJ,OAAO,CAACK,aAAa,CAACF,IAAI,CAAC;MAC9C,OAAOC,UAAU;IACnB,CAAC,CAAC;IACF,MAAME,QAAQ,GAAGN,OAAO,CAACO,WAAW,CAACd,IAAI,CAAC;IAC1C,OAAO,KAAIe,2CAAsB,EAACF,QAAQ,EAAEL,KAAK,CAAC;EACpD;AACF;AAACQ,OAAA,CAAAlB,2BAAA,GAAAA,2BAAA","ignoreList":[]}

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

@@ -0,0 +1,13 @@
+import type { Node } from 'typescript';
+import { KeywordTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+/**
+ * whether it's kind of `ts.KeywordTypeSyntaxKind`
+ */
+export declare class KeywordTypeTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: Node, context: SchemaExtractorContext): Promise<KeywordTypeSchema>;
+}

package/dist/transformers/keyword-type.js

@@ -0,0 +1,54 @@
+"use strict";
+
+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":["_typescript","data","require","_semanticsEntities","KeywordTypeTransformer","predicate","node","kind","SyntaxKind","AnyKeyword","BigIntKeyword","BooleanKeyword","IntrinsicKeyword","NeverKeyword","NumberKeyword","ObjectKeyword","StringKeyword","SymbolKeyword","UndefinedKeyword","UnknownKeyword","VoidKeyword","getIdentifiers","transform","context","location","getLocation","KeywordTypeSchema","getText","exports"],"sources":["keyword-type.ts"],"sourcesContent":["import type { Node } from 'typescript';\nimport { SyntaxKind } from 'typescript';\nimport { KeywordTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,mBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAKA;AACA;AACA;AACO,MAAMG,sBAAsB,CAA8B;EAC/DC,SAASA,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;IAChB;EACF;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,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,CAAC,CAAC,CAAC;EACxD;AACF;AAACC,OAAA,CAAAxB,sBAAA,GAAAA,sBAAA","ignoreList":[]}

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

@@ -0,0 +1,13 @@
+import type { LiteralTypeNode, Node } from 'typescript';
+import { LiteralTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { 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,39 @@
+"use strict";
+
+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;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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":["_typescript","data","_interopRequireDefault","require","_semanticsEntities","e","__esModule","default","LiteralTypeTransformer","predicate","node","kind","ts","SyntaxKind","LiteralType","getIdentifiers","transform","context","location","getLocation","LiteralTypeSchema","getText","exports"],"sources":["literal-type.ts"],"sourcesContent":["import type { LiteralTypeNode, Node } from 'typescript';\nimport ts from 'typescript';\nimport { LiteralTypeSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,mBAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAgF,SAAAC,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAKhF;AACA;AACA;AACO,MAAMG,sBAAsB,CAA8B;EAC/DC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,WAAW;EAChD;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,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,CAAC,CAAC,CAAC;EACxD;AACF;AAACC,OAAA,CAAAd,sBAAA,GAAAA,sBAAA","ignoreList":[]}

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

@@ -0,0 +1,12 @@
+import type { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import type { Node, StringLiteral } from 'typescript';
+import ts from 'typescript';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { Identifier } from '../identifier';
+export type LiteralValueNode = StringLiteral | ts.NumericLiteral | ts.TrueLiteral | ts.FalseLiteral | ts.NullLiteral | ts.BigIntLiteral | ts.RegularExpressionLiteral | ts.NewExpression;
+export declare class LiteralValueTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: LiteralValueNode, context: SchemaExtractorContext): Promise<SchemaNode>;
+}

package/dist/transformers/literal-value.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LiteralValueTransformer = 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 _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class LiteralValueTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.StringLiteral || node.kind === _typescript().default.SyntaxKind.NumericLiteral || node.kind === _typescript().default.SyntaxKind.TrueKeyword || node.kind === _typescript().default.SyntaxKind.FalseKeyword || node.kind === _typescript().default.SyntaxKind.NullKeyword || node.kind === _typescript().default.SyntaxKind.UndefinedKeyword || node.kind === _typescript().default.SyntaxKind.BigIntLiteral || node.kind === _typescript().default.SyntaxKind.RegularExpressionLiteral || node.kind === _typescript().default.SyntaxKind.NewExpression || node.kind === _typescript().default.SyntaxKind.NoSubstitutionTemplateLiteral;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    return new (_semanticsEntities().LiteralValueSchema)(context.getLocation(node), node.getText());
+  }
+}
+exports.LiteralValueTransformer = LiteralValueTransformer;
+
+//# sourceMappingURL=literal-value.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_semanticsEntities","data","require","_typescript","_interopRequireDefault","e","__esModule","default","LiteralValueTransformer","predicate","node","kind","ts","SyntaxKind","StringLiteral","NumericLiteral","TrueKeyword","FalseKeyword","NullKeyword","UndefinedKeyword","BigIntLiteral","RegularExpressionLiteral","NewExpression","NoSubstitutionTemplateLiteral","getIdentifiers","transform","context","LiteralValueSchema","getLocation","getText","exports"],"sources":["literal-value.ts"],"sourcesContent":["import type { SchemaNode } from '@teambit/semantics.entities.semantic-schema';\nimport { LiteralValueSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { Node, StringLiteral } from 'typescript';\nimport ts from 'typescript';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { Identifier } from '../identifier';\n\nexport type LiteralValueNode =\n  | StringLiteral\n  | ts.NumericLiteral\n  | ts.TrueLiteral\n  | ts.FalseLiteral\n  | ts.NullLiteral\n  | ts.BigIntLiteral\n  | ts.RegularExpressionLiteral\n  | ts.NewExpression;\n\nexport class LiteralValueTransformer implements SchemaTransformer {\n  predicate(node: Node): boolean {\n    return (\n      node.kind === ts.SyntaxKind.StringLiteral ||\n      node.kind === ts.SyntaxKind.NumericLiteral ||\n      node.kind === ts.SyntaxKind.TrueKeyword ||\n      node.kind === ts.SyntaxKind.FalseKeyword ||\n      node.kind === ts.SyntaxKind.NullKeyword ||\n      node.kind === ts.SyntaxKind.UndefinedKeyword ||\n      node.kind === ts.SyntaxKind.BigIntLiteral ||\n      node.kind === ts.SyntaxKind.RegularExpressionLiteral ||\n      node.kind === ts.SyntaxKind.NewExpression ||\n      node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral\n    );\n  }\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n  async transform(node: LiteralValueNode, context: SchemaExtractorContext): Promise<SchemaNode> {\n    return new LiteralValueSchema(context.getLocation(node), node.getText());\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,mBAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,kBAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAE,YAAA;EAAA,MAAAF,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAC,WAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA4B,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAerB,MAAMG,uBAAuB,CAA8B;EAChEC,SAASA,CAACC,IAAU,EAAW;IAC7B,OACEA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,aAAa,IACzCJ,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACE,cAAc,IAC1CL,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACG,WAAW,IACvCN,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACI,YAAY,IACxCP,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACK,WAAW,IACvCR,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACM,gBAAgB,IAC5CT,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACO,aAAa,IACzCV,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACQ,wBAAwB,IACpDX,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACS,aAAa,IACzCZ,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACU,6BAA6B;EAE7D;EACA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EACA,MAAMC,SAASA,CAACf,IAAsB,EAAEgB,OAA+B,EAAuB;IAC5F,OAAO,KAAIC,uCAAkB,EAACD,OAAO,CAACE,WAAW,CAAClB,IAAI,CAAC,EAAEA,IAAI,CAACmB,OAAO,CAAC,CAAC,CAAC;EAC1E;AACF;AAACC,OAAA,CAAAtB,uBAAA,GAAAA,uBAAA","ignoreList":[]}

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

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

package/dist/transformers/module-declaration.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ModuleDeclarationTransformer = 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 _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ModuleDeclarationTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.ModuleDeclaration;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const location = context.getLocation(node);
+    return new (_semanticsEntities().UnImplementedSchema)(location, node.getText(), _typescript().default.SyntaxKind[node.kind]);
+  }
+}
+exports.ModuleDeclarationTransformer = ModuleDeclarationTransformer;
+
+//# sourceMappingURL=module-declaration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_semanticsEntities","e","__esModule","default","ModuleDeclarationTransformer","predicate","node","kind","ts","SyntaxKind","ModuleDeclaration","getIdentifiers","transform","context","location","getLocation","UnImplementedSchema","getText","exports"],"sources":["module-declaration.ts"],"sourcesContent":["import type { Node, ModuleDeclaration } from 'typescript';\nimport ts from 'typescript';\nimport { UnImplementedSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { Identifier } from '../identifier';\n\nexport class ModuleDeclarationTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.ModuleDeclaration;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: ModuleDeclaration, context: SchemaExtractorContext) {\n    const location = context.getLocation(node);\n    return new UnImplementedSchema(location, node.getText(), ts.SyntaxKind[node.kind]);\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,mBAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAkF,SAAAC,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAK3E,MAAMG,4BAA4B,CAA8B;EACrEC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,iBAAiB;EACtD;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,CAACN,IAAuB,EAAEO,OAA+B,EAAE;IACxE,MAAMC,QAAQ,GAAGD,OAAO,CAACE,WAAW,CAACT,IAAI,CAAC;IAC1C,OAAO,KAAIU,wCAAmB,EAACF,QAAQ,EAAER,IAAI,CAACW,OAAO,CAAC,CAAC,EAAET,qBAAE,CAACC,UAAU,CAACH,IAAI,CAACC,IAAI,CAAC,CAAC;EACpF;AACF;AAACW,OAAA,CAAAd,4BAAA,GAAAA,4BAAA","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+import type { Node, NamedTupleMember } from 'typescript';
+import { NamedTupleSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { 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,37 @@
+"use strict";
+
+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":["_typescript","data","require","_semanticsEntities","NamedTupleTransformer","predicate","node","kind","SyntaxKind","NamedTupleMember","getIdentifiers","transform","context","name","getText","location","getLocation","type","computeSchema","NamedTupleSchema","exports"],"sources":["named-tuple.ts"],"sourcesContent":["import type { Node, NamedTupleMember } from 'typescript';\nimport { SyntaxKind } from 'typescript';\nimport { NamedTupleSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaTransformer } from '../schema-transformer';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { 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":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,mBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,kBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAKO,MAAMG,qBAAqB,CAA8B;EAC9DC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,wBAAU,CAACC,gBAAgB;EAClD;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,CAACL,IAAsB,EAAEM,OAA+B,EAAE;IACvE,MAAMC,IAAI,GAAGP,IAAI,CAACO,IAAI,CAACC,OAAO,CAAC,CAAC;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;AAACO,OAAA,CAAAhB,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/dist/transformers/object-literal-expression.d.ts

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

package/dist/transformers/object-literal-expression.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ObjectLiteralExpressionTransformer = void 0;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+  _semanticsEntities = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ObjectLiteralExpressionTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.ObjectLiteralExpression;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const properties = await (0, _pMapSeries().default)(node.properties, async prop => {
+      const schema = await context.computeSchema(prop);
+      if (schema instanceof _semanticsEntities().UnImplementedSchema) {
+        const typeRef = await context.resolveType(prop, prop.getText());
+        return typeRef;
+      }
+      return schema;
+    });
+    const location = context.getLocation(node);
+    return new (_semanticsEntities().ObjectLiteralExpressionSchema)(properties, location);
+  }
+}
+exports.ObjectLiteralExpressionTransformer = ObjectLiteralExpressionTransformer;
+
+//# sourceMappingURL=object-literal-expression.js.map

package/dist/transformers/object-literal-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_pMapSeries","_semanticsEntities","e","__esModule","default","ObjectLiteralExpressionTransformer","predicate","node","kind","ts","SyntaxKind","ObjectLiteralExpression","getIdentifiers","transform","context","properties","pMapSeries","prop","schema","computeSchema","UnImplementedSchema","typeRef","resolveType","getText","location","getLocation","ObjectLiteralExpressionSchema","exports"],"sources":["object-literal-expression.ts"],"sourcesContent":["import type { Node, ObjectLiteralExpression } from 'typescript';\nimport ts from 'typescript';\nimport pMapSeries from 'p-map-series';\nimport { ObjectLiteralExpressionSchema, UnImplementedSchema } from '@teambit/semantics.entities.semantic-schema';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport type { SchemaTransformer } from '../schema-transformer';\n\nexport class ObjectLiteralExpressionTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.ObjectLiteralExpression;\n  }\n\n  async getIdentifiers() {\n    return [];\n  }\n\n  async transform(node: ObjectLiteralExpression, context: SchemaExtractorContext) {\n    const properties = await pMapSeries(node.properties, async (prop) => {\n      const schema = await context.computeSchema(prop);\n      if (schema instanceof UnImplementedSchema) {\n        const typeRef = await context.resolveType(prop, prop.getText());\n        return typeRef;\n      }\n      return schema;\n    });\n    const location = context.getLocation(node);\n    return new ObjectLiteralExpressionSchema(properties, location);\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,YAAA;EAAA,MAAAH,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAC,WAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,mBAAA;EAAA,MAAAJ,IAAA,GAAAE,OAAA;EAAAE,kBAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAiH,SAAAC,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAI1G,MAAMG,kCAAkC,CAA8B;EAC3EC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,uBAAuB;EAC5D;EAEA,MAAMC,cAAcA,CAAA,EAAG;IACrB,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,CAACN,IAA6B,EAAEO,OAA+B,EAAE;IAC9E,MAAMC,UAAU,GAAG,MAAM,IAAAC,qBAAU,EAACT,IAAI,CAACQ,UAAU,EAAE,MAAOE,IAAI,IAAK;MACnE,MAAMC,MAAM,GAAG,MAAMJ,OAAO,CAACK,aAAa,CAACF,IAAI,CAAC;MAChD,IAAIC,MAAM,YAAYE,wCAAmB,EAAE;QACzC,MAAMC,OAAO,GAAG,MAAMP,OAAO,CAACQ,WAAW,CAACL,IAAI,EAAEA,IAAI,CAACM,OAAO,CAAC,CAAC,CAAC;QAC/D,OAAOF,OAAO;MAChB;MACA,OAAOH,MAAM;IACf,CAAC,CAAC;IACF,MAAMM,QAAQ,GAAGV,OAAO,CAACW,WAAW,CAAClB,IAAI,CAAC;IAC1C,OAAO,KAAImB,kDAA6B,EAACX,UAAU,EAAES,QAAQ,CAAC;EAChE;AACF;AAACG,OAAA,CAAAtB,kCAAA,GAAAA,kCAAA","ignoreList":[]}

package/dist/transformers/parameter.d.ts

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