@teambit/typescript 0.0.0-02c0c8ffc2ebaf66ef5cbfc2e31c48e2b4acbfc7

package/dist/sourceFileTransformers/type-reference.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeReferenceTransformer = typeReferenceTransformer;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _replaceName() {
+  const data = require("./replaceName");
+  _replaceName = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function typeReferenceTransformer(mapping) {
+  return context => {
+    const visit = node => {
+      if (_typescript().default.isTypeReferenceNode(node)) {
+        const oldName = node.typeName.getText();
+        const newName = (0, _replaceName().replaceName)(oldName, mapping);
+        if (newName) {
+          return _typescript().default.factory.updateTypeReferenceNode(node, _typescript().default.factory.createIdentifier(newName), node.typeArguments);
+        }
+      }
+      return _typescript().default.visitEachChild(node, visit, context);
+    };
+    return node => _typescript().default.visitNode(node, visit);
+  };
+}
+
+//# sourceMappingURL=type-reference.js.map

package/dist/sourceFileTransformers/type-reference.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_replaceName","e","__esModule","default","typeReferenceTransformer","mapping","context","visit","node","ts","isTypeReferenceNode","oldName","typeName","getText","newName","replaceName","factory","updateTypeReferenceNode","createIdentifier","typeArguments","visitEachChild","visitNode"],"sources":["type-reference.ts"],"sourcesContent":["import ts from 'typescript';\nimport { replaceName } from './replaceName';\n\nexport function typeReferenceTransformer(mapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {\n  return (context) => {\n    const visit: ts.Visitor = (node) => {\n      if (ts.isTypeReferenceNode(node)) {\n        const oldName = node.typeName.getText();\n        const newName = replaceName(oldName, mapping);\n        if (newName) {\n          return ts.factory.updateTypeReferenceNode(node, ts.factory.createIdentifier(newName), node.typeArguments);\n        }\n      }\n      return ts.visitEachChild(node, visit, context);\n    };\n\n    return (node) => ts.visitNode(node, visit) as ts.SourceFile;\n  };\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,aAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,YAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA4C,SAAAC,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAErC,SAASG,wBAAwBA,CAACC,OAA+B,EAAwC;EAC9G,OAAQC,OAAO,IAAK;IAClB,MAAMC,KAAiB,GAAIC,IAAI,IAAK;MAClC,IAAIC,qBAAE,CAACC,mBAAmB,CAACF,IAAI,CAAC,EAAE;QAChC,MAAMG,OAAO,GAAGH,IAAI,CAACI,QAAQ,CAACC,OAAO,CAAC,CAAC;QACvC,MAAMC,OAAO,GAAG,IAAAC,0BAAW,EAACJ,OAAO,EAAEN,OAAO,CAAC;QAC7C,IAAIS,OAAO,EAAE;UACX,OAAOL,qBAAE,CAACO,OAAO,CAACC,uBAAuB,CAACT,IAAI,EAAEC,qBAAE,CAACO,OAAO,CAACE,gBAAgB,CAACJ,OAAO,CAAC,EAAEN,IAAI,CAACW,aAAa,CAAC;QAC3G;MACF;MACA,OAAOV,qBAAE,CAACW,cAAc,CAACZ,IAAI,EAAED,KAAK,EAAED,OAAO,CAAC;IAChD,CAAC;IAED,OAAQE,IAAI,IAAKC,qBAAE,CAACY,SAAS,CAACb,IAAI,EAAED,KAAK,CAAkB;EAC7D,CAAC;AACH","ignoreList":[]}

package/dist/sourceFileTransformers/typeAlias.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function typeAliasNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile>;

package/dist/sourceFileTransformers/typeAlias.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeAliasNamesTransformer = typeAliasNamesTransformer;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _replaceName() {
+  const data = require("./replaceName");
+  _replaceName = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function typeAliasNamesTransformer(nameMapping) {
+  return context => {
+    const {
+      factory
+    } = context;
+    const visit = node => {
+      if (_typescript().default.isTypeAliasDeclaration(node)) {
+        const oldName = node.name.text;
+        const newName = (0, _replaceName().replaceName)(oldName, nameMapping);
+        if (newName) {
+          return factory.updateTypeAliasDeclaration(node, node.modifiers, factory.createIdentifier(newName), node.typeParameters, node.type);
+        }
+      }
+      return _typescript().default.visitEachChild(node, child => visit(child), context);
+    };
+    return node => _typescript().default.visitNode(node, visit);
+  };
+}
+
+//# sourceMappingURL=typeAlias.js.map

package/dist/sourceFileTransformers/typeAlias.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_replaceName","e","__esModule","default","typeAliasNamesTransformer","nameMapping","context","factory","visit","node","ts","isTypeAliasDeclaration","oldName","name","text","newName","replaceName","updateTypeAliasDeclaration","modifiers","createIdentifier","typeParameters","type","visitEachChild","child","visitNode"],"sources":["typeAlias.ts"],"sourcesContent":["import ts from 'typescript';\nimport { replaceName } from './replaceName';\n\nexport function typeAliasNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {\n  return (context) => {\n    const { factory } = context;\n    const visit: ts.Visitor = (node) => {\n      if (ts.isTypeAliasDeclaration(node)) {\n        const oldName = node.name.text;\n        const newName = replaceName(oldName, nameMapping);\n        if (newName) {\n          return factory.updateTypeAliasDeclaration(\n            node,\n            node.modifiers,\n            factory.createIdentifier(newName),\n            node.typeParameters,\n            node.type\n          );\n        }\n      }\n      return ts.visitEachChild(node, (child) => visit(child), context);\n    };\n    return (node) => ts.visitNode(node, visit) as ts.SourceFile;\n  };\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,aAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,YAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA4C,SAAAC,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAErC,SAASG,yBAAyBA,CAACC,WAAmC,EAAwC;EACnH,OAAQC,OAAO,IAAK;IAClB,MAAM;MAAEC;IAAQ,CAAC,GAAGD,OAAO;IAC3B,MAAME,KAAiB,GAAIC,IAAI,IAAK;MAClC,IAAIC,qBAAE,CAACC,sBAAsB,CAACF,IAAI,CAAC,EAAE;QACnC,MAAMG,OAAO,GAAGH,IAAI,CAACI,IAAI,CAACC,IAAI;QAC9B,MAAMC,OAAO,GAAG,IAAAC,0BAAW,EAACJ,OAAO,EAAEP,WAAW,CAAC;QACjD,IAAIU,OAAO,EAAE;UACX,OAAOR,OAAO,CAACU,0BAA0B,CACvCR,IAAI,EACJA,IAAI,CAACS,SAAS,EACdX,OAAO,CAACY,gBAAgB,CAACJ,OAAO,CAAC,EACjCN,IAAI,CAACW,cAAc,EACnBX,IAAI,CAACY,IACP,CAAC;QACH;MACF;MACA,OAAOX,qBAAE,CAACY,cAAc,CAACb,IAAI,EAAGc,KAAK,IAAKf,KAAK,CAACe,KAAK,CAAC,EAAEjB,OAAO,CAAC;IAClE,CAAC;IACD,OAAQG,IAAI,IAAKC,qBAAE,CAACc,SAAS,CAACf,IAAI,EAAED,KAAK,CAAkB;EAC7D,CAAC;AACH","ignoreList":[]}

package/dist/sourceFileTransformers/variable.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function variableNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile>;

package/dist/sourceFileTransformers/variable.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.variableNamesTransformer = variableNamesTransformer;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _replaceName() {
+  const data = require("./replaceName");
+  _replaceName = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function variableNamesTransformer(nameMapping) {
+  return context => {
+    const {
+      factory
+    } = context;
+    const visit = node => {
+      if (_typescript().default.isVariableDeclaration(node) && node.name.kind === _typescript().default.SyntaxKind.Identifier) {
+        const oldName = node.name.text;
+        const newName = (0, _replaceName().replaceName)(oldName, nameMapping);
+        if (newName) {
+          return factory.updateVariableDeclaration(node, factory.createIdentifier(newName), node.exclamationToken, node.type, node.initializer);
+        }
+      }
+      return _typescript().default.visitEachChild(node, child => visit(child), context);
+    };
+    return node => _typescript().default.visitNode(node, visit);
+  };
+}
+
+//# sourceMappingURL=variable.js.map

package/dist/sourceFileTransformers/variable.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_replaceName","e","__esModule","default","variableNamesTransformer","nameMapping","context","factory","visit","node","ts","isVariableDeclaration","name","kind","SyntaxKind","Identifier","oldName","text","newName","replaceName","updateVariableDeclaration","createIdentifier","exclamationToken","type","initializer","visitEachChild","child","visitNode"],"sources":["variable.ts"],"sourcesContent":["import ts from 'typescript';\nimport { replaceName } from './replaceName';\n\nexport function variableNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {\n  return (context) => {\n    const { factory } = context;\n    const visit: ts.Visitor = (node) => {\n      if (ts.isVariableDeclaration(node) && node.name.kind === ts.SyntaxKind.Identifier) {\n        const oldName = node.name.text;\n        const newName = replaceName(oldName, nameMapping);\n        if (newName) {\n          return factory.updateVariableDeclaration(\n            node,\n            factory.createIdentifier(newName),\n            node.exclamationToken,\n            node.type,\n            node.initializer\n          );\n        }\n      }\n      return ts.visitEachChild(node, (child) => visit(child), context);\n    };\n    return (node) => ts.visitNode(node, visit) as ts.SourceFile;\n  };\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,aAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,YAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA4C,SAAAC,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAErC,SAASG,wBAAwBA,CAACC,WAAmC,EAAwC;EAClH,OAAQC,OAAO,IAAK;IAClB,MAAM;MAAEC;IAAQ,CAAC,GAAGD,OAAO;IAC3B,MAAME,KAAiB,GAAIC,IAAI,IAAK;MAClC,IAAIC,qBAAE,CAACC,qBAAqB,CAACF,IAAI,CAAC,IAAIA,IAAI,CAACG,IAAI,CAACC,IAAI,KAAKH,qBAAE,CAACI,UAAU,CAACC,UAAU,EAAE;QACjF,MAAMC,OAAO,GAAGP,IAAI,CAACG,IAAI,CAACK,IAAI;QAC9B,MAAMC,OAAO,GAAG,IAAAC,0BAAW,EAACH,OAAO,EAAEX,WAAW,CAAC;QACjD,IAAIa,OAAO,EAAE;UACX,OAAOX,OAAO,CAACa,yBAAyB,CACtCX,IAAI,EACJF,OAAO,CAACc,gBAAgB,CAACH,OAAO,CAAC,EACjCT,IAAI,CAACa,gBAAgB,EACrBb,IAAI,CAACc,IAAI,EACTd,IAAI,CAACe,WACP,CAAC;QACH;MACF;MACA,OAAOd,qBAAE,CAACe,cAAc,CAAChB,IAAI,EAAGiB,KAAK,IAAKlB,KAAK,CAACkB,KAAK,CAAC,EAAEpB,OAAO,CAAC;IAClE,CAAC;IACD,OAAQG,IAAI,IAAKC,qBAAE,CAACiB,SAAS,CAAClB,IAAI,EAAED,KAAK,CAAkB;EAC7D,CAAC;AACH","ignoreList":[]}

package/dist/transform-source-file.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transform-source-file.spec.js

@@ -0,0 +1,182 @@
+"use strict";
+
+function _chai() {
+  const data = require("chai");
+  _chai = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _sourceFileTransformers() {
+  const data = require("./sourceFileTransformers");
+  _sourceFileTransformers = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function normalizeFormatting(code) {
+  const sourceFile = _typescript().default.createSourceFile('temp.ts', code, _typescript().default.ScriptTarget.Latest, true);
+  const printer = _typescript().default.createPrinter({
+    newLine: _typescript().default.NewLineKind.LineFeed,
+    removeComments: false
+  });
+  return printer.printFile(sourceFile);
+}
+describe('transformSourceFile', () => {
+  const createTransformerTest = (sourceCode, nameMapping, transformer, expectedCode) => {
+    it(`should correctly transform source code with ${transformer.name}`, async () => {
+      const result = await (0, _sourceFileTransformers().transformSourceFile)('test.ts', sourceCode, [transformer(nameMapping)]);
+      const normalizedResult = normalizeFormatting(result);
+      const normalizedExpectedCode = normalizeFormatting(expectedCode);
+      (0, _chai().expect)(normalizedResult).to.equal(normalizedExpectedCode);
+    });
+  };
+  const testCases = [{
+    transformer: _sourceFileTransformers().classNamesTransformer,
+    sourceCode: 'class TestClass {}',
+    nameMapping: {
+      TestClass: 'NewClassName'
+    },
+    expectedCode: 'class NewClassName {}'
+  }, {
+    transformer: _sourceFileTransformers().functionNamesTransformer,
+    sourceCode: 'function testFunction() {}',
+    nameMapping: {
+      testFunction: 'newFunctionName'
+    },
+    expectedCode: 'function newFunctionName() {}'
+  }, {
+    transformer: _sourceFileTransformers().importTransformer,
+    sourceCode: 'import { Test } from "./test";',
+    nameMapping: {
+      './test': './newTest'
+    },
+    expectedCode: 'import { Test } from "./newTest";'
+  }, {
+    transformer: _sourceFileTransformers().interfaceNamesTransformer,
+    sourceCode: 'interface TestInterface {}',
+    nameMapping: {
+      TestInterface: 'NewInterfaceName'
+    },
+    expectedCode: 'interface NewInterfaceName {}'
+  }, {
+    transformer: _sourceFileTransformers().typeAliasNamesTransformer,
+    sourceCode: 'type TestType = string;',
+    nameMapping: {
+      TestType: 'NewTypeName'
+    },
+    expectedCode: 'type NewTypeName = string;'
+  }, {
+    transformer: _sourceFileTransformers().variableNamesTransformer,
+    sourceCode: 'let testVariable = "test";',
+    nameMapping: {
+      testVariable: 'newVariableName'
+    },
+    expectedCode: 'let newVariableName = "test";'
+  }, {
+    transformer: _sourceFileTransformers().classNamesTransformer,
+    sourceCode: 'class TestClass { oldMethod() {} }',
+    nameMapping: {
+      TestClass: 'NewClassName',
+      oldMethod: 'newMethodName'
+    },
+    expectedCode: 'class NewClassName { newMethodName() {} }'
+  }, {
+    transformer: _sourceFileTransformers().classNamesTransformer,
+    sourceCode: 'class TestClass { oldMember: string; }',
+    nameMapping: {
+      TestClass: 'NewClassName',
+      oldMember: 'newMember'
+    },
+    expectedCode: 'class NewClassName { newMember: string; }'
+  }, {
+    transformer: _sourceFileTransformers().expressionStatementTransformer,
+    sourceCode: 'TestClass.staticMethod();',
+    nameMapping: {
+      TestClass: 'NewClassName',
+      staticMethod: 'newMethodName'
+    },
+    expectedCode: 'NewClassName.newMethodName();'
+  }, {
+    transformer: _sourceFileTransformers().expressionStatementTransformer,
+    sourceCode: 'let instance = new TestClass(); instance.method();',
+    nameMapping: {
+      TestClass: 'NewClassName',
+      method: 'newMethodName'
+    },
+    expectedCode: 'let instance = new NewClassName(); instance.newMethodName();'
+  }, {
+    transformer: _sourceFileTransformers().interfaceNamesTransformer,
+    sourceCode: 'interface TestInterface { oldMember: string; }',
+    nameMapping: {
+      TestInterface: 'NewInterfaceName',
+      oldMember: 'newMember'
+    },
+    expectedCode: 'interface NewInterfaceName { newMember: string; }'
+  }, {
+    transformer: _sourceFileTransformers().importTransformer,
+    sourceCode: 'const UI = require("@xxx/ui-library");',
+    nameMapping: {
+      '@xxx/ui-library': '@abc/ui-library'
+    },
+    expectedCode: 'const UI = require("@abc/ui-library");'
+  }, {
+    transformer: _sourceFileTransformers().exportTransformer,
+    sourceCode: 'export { Component } from "@xxx/ui-library";',
+    nameMapping: {
+      '@xxx/ui-library': '@abc/ui-library'
+    },
+    expectedCode: 'export { Component } from "@abc/ui-library";'
+  }, {
+    transformer: _sourceFileTransformers().exportTransformer,
+    sourceCode: 'export * from "@xxx/ui-library";',
+    nameMapping: {
+      '@xxx/ui-library': '@abc/ui-library'
+    },
+    expectedCode: 'export * from "@abc/ui-library";'
+  }, {
+    transformer: _sourceFileTransformers().exportTransformer,
+    sourceCode: 'export { default as UI } from "@xxx/ui-library";',
+    nameMapping: {
+      '@xxx/ui-library': '@abc/ui-library'
+    },
+    expectedCode: 'export { default as UI } from "@abc/ui-library";'
+  }];
+  for (const {
+    transformer,
+    sourceCode,
+    nameMapping,
+    expectedCode
+  } of testCases) {
+    createTransformerTest(sourceCode, nameMapping, transformer, expectedCode);
+  }
+  it('should return original source code if no transformations are applied', async () => {
+    const sourceCode = 'class TestClass {} function testFunction() {}';
+    const result = await (0, _sourceFileTransformers().transformSourceFile)('test.ts', sourceCode, []);
+    const normalizedResult = normalizeFormatting(result);
+    const normalizedSourceCode = normalizeFormatting(sourceCode);
+    (0, _chai().expect)(normalizedResult).to.equal(normalizedSourceCode);
+  });
+  it('should handle multiple transformers', async () => {
+    const sourceCode = 'class TestClass {} function testFunction() {}';
+    const expectedCode = 'class NewClassName {} function newFunctionName() {}';
+    const result = await (0, _sourceFileTransformers().transformSourceFile)('test.ts', sourceCode, [(0, _sourceFileTransformers().classNamesTransformer)({
+      TestClass: 'NewClassName'
+    }), (0, _sourceFileTransformers().functionNamesTransformer)({
+      testFunction: 'newFunctionName'
+    })]);
+    const normalizedResult = normalizeFormatting(result);
+    const normalizedExpectedCode = normalizeFormatting(expectedCode);
+    (0, _chai().expect)(normalizedResult).to.equal(normalizedExpectedCode);
+  });
+});
+
+//# sourceMappingURL=transform-source-file.spec.js.map

package/dist/transform-source-file.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chai","data","require","_typescript","_interopRequireDefault","_sourceFileTransformers","e","__esModule","default","normalizeFormatting","code","sourceFile","ts","createSourceFile","ScriptTarget","Latest","printer","createPrinter","newLine","NewLineKind","LineFeed","removeComments","printFile","describe","createTransformerTest","sourceCode","nameMapping","transformer","expectedCode","it","name","result","transformSourceFile","normalizedResult","normalizedExpectedCode","expect","to","equal","testCases","classNamesTransformer","TestClass","functionNamesTransformer","testFunction","importTransformer","interfaceNamesTransformer","TestInterface","typeAliasNamesTransformer","TestType","variableNamesTransformer","testVariable","oldMethod","oldMember","expressionStatementTransformer","staticMethod","method","exportTransformer","normalizedSourceCode"],"sources":["transform-source-file.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport ts from 'typescript';\nimport {\n  transformSourceFile,\n  classNamesTransformer,\n  functionNamesTransformer,\n  importTransformer,\n  interfaceNamesTransformer,\n  typeAliasNamesTransformer,\n  variableNamesTransformer,\n  expressionStatementTransformer,\n  exportTransformer,\n} from './sourceFileTransformers';\n\nfunction normalizeFormatting(code: string): string {\n  const sourceFile = ts.createSourceFile('temp.ts', code, ts.ScriptTarget.Latest, true);\n  const printer = ts.createPrinter({\n    newLine: ts.NewLineKind.LineFeed,\n    removeComments: false,\n  });\n  return printer.printFile(sourceFile);\n}\n\ndescribe('transformSourceFile', () => {\n  const createTransformerTest = (\n    sourceCode: string,\n    nameMapping: any,\n    transformer: (nameMapping: any) => ts.TransformerFactory<ts.SourceFile>,\n    expectedCode: string\n  ) => {\n    it(`should correctly transform source code with ${transformer.name}`, async () => {\n      const result = await transformSourceFile('test.ts', sourceCode, [transformer(nameMapping)]);\n      const normalizedResult = normalizeFormatting(result);\n      const normalizedExpectedCode = normalizeFormatting(expectedCode);\n\n      expect(normalizedResult).to.equal(normalizedExpectedCode);\n    });\n  };\n\n  const testCases = [\n    {\n      transformer: classNamesTransformer,\n      sourceCode: 'class TestClass {}',\n      nameMapping: { TestClass: 'NewClassName' },\n      expectedCode: 'class NewClassName {}',\n    },\n    {\n      transformer: functionNamesTransformer,\n      sourceCode: 'function testFunction() {}',\n      nameMapping: { testFunction: 'newFunctionName' },\n      expectedCode: 'function newFunctionName() {}',\n    },\n    {\n      transformer: importTransformer,\n      sourceCode: 'import { Test } from \"./test\";',\n      nameMapping: { './test': './newTest' },\n      expectedCode: 'import { Test } from \"./newTest\";',\n    },\n    {\n      transformer: interfaceNamesTransformer,\n      sourceCode: 'interface TestInterface {}',\n      nameMapping: { TestInterface: 'NewInterfaceName' },\n      expectedCode: 'interface NewInterfaceName {}',\n    },\n    {\n      transformer: typeAliasNamesTransformer,\n      sourceCode: 'type TestType = string;',\n      nameMapping: { TestType: 'NewTypeName' },\n      expectedCode: 'type NewTypeName = string;',\n    },\n    {\n      transformer: variableNamesTransformer,\n      sourceCode: 'let testVariable = \"test\";',\n      nameMapping: { testVariable: 'newVariableName' },\n      expectedCode: 'let newVariableName = \"test\";',\n    },\n    {\n      transformer: classNamesTransformer,\n      sourceCode: 'class TestClass { oldMethod() {} }',\n      nameMapping: { TestClass: 'NewClassName', oldMethod: 'newMethodName' },\n      expectedCode: 'class NewClassName { newMethodName() {} }',\n    },\n    {\n      transformer: classNamesTransformer,\n      sourceCode: 'class TestClass { oldMember: string; }',\n      nameMapping: { TestClass: 'NewClassName', oldMember: 'newMember' },\n      expectedCode: 'class NewClassName { newMember: string; }',\n    },\n    {\n      transformer: expressionStatementTransformer,\n      sourceCode: 'TestClass.staticMethod();',\n      nameMapping: { TestClass: 'NewClassName', staticMethod: 'newMethodName' },\n      expectedCode: 'NewClassName.newMethodName();',\n    },\n    {\n      transformer: expressionStatementTransformer,\n      sourceCode: 'let instance = new TestClass(); instance.method();',\n      nameMapping: { TestClass: 'NewClassName', method: 'newMethodName' },\n      expectedCode: 'let instance = new NewClassName(); instance.newMethodName();',\n    },\n    {\n      transformer: interfaceNamesTransformer,\n      sourceCode: 'interface TestInterface { oldMember: string; }',\n      nameMapping: { TestInterface: 'NewInterfaceName', oldMember: 'newMember' },\n      expectedCode: 'interface NewInterfaceName { newMember: string; }',\n    },\n    {\n      transformer: importTransformer,\n      sourceCode: 'const UI = require(\"@xxx/ui-library\");',\n      nameMapping: { '@xxx/ui-library': '@abc/ui-library' },\n      expectedCode: 'const UI = require(\"@abc/ui-library\");',\n    },\n    {\n      transformer: exportTransformer,\n      sourceCode: 'export { Component } from \"@xxx/ui-library\";',\n      nameMapping: { '@xxx/ui-library': '@abc/ui-library' },\n      expectedCode: 'export { Component } from \"@abc/ui-library\";',\n    },\n    {\n      transformer: exportTransformer,\n      sourceCode: 'export * from \"@xxx/ui-library\";',\n      nameMapping: { '@xxx/ui-library': '@abc/ui-library' },\n      expectedCode: 'export * from \"@abc/ui-library\";',\n    },\n    {\n      transformer: exportTransformer,\n      sourceCode: 'export { default as UI } from \"@xxx/ui-library\";',\n      nameMapping: { '@xxx/ui-library': '@abc/ui-library' },\n      expectedCode: 'export { default as UI } from \"@abc/ui-library\";',\n    },\n  ];\n\n  for (const { transformer, sourceCode, nameMapping, expectedCode } of testCases) {\n    createTransformerTest(sourceCode, nameMapping, transformer, expectedCode);\n  }\n\n  it('should return original source code if no transformations are applied', async () => {\n    const sourceCode = 'class TestClass {} function testFunction() {}';\n    const result = await transformSourceFile('test.ts', sourceCode, []);\n    const normalizedResult = normalizeFormatting(result);\n    const normalizedSourceCode = normalizeFormatting(sourceCode);\n    expect(normalizedResult).to.equal(normalizedSourceCode);\n  });\n\n  it('should handle multiple transformers', async () => {\n    const sourceCode = 'class TestClass {} function testFunction() {}';\n    const expectedCode = 'class NewClassName {} function newFunctionName() {}';\n    const result = await transformSourceFile('test.ts', sourceCode, [\n      classNamesTransformer({ TestClass: 'NewClassName' }),\n      functionNamesTransformer({ testFunction: 'newFunctionName' }),\n    ]);\n    const normalizedResult = normalizeFormatting(result);\n    const normalizedExpectedCode = normalizeFormatting(expectedCode);\n    expect(normalizedResult).to.equal(normalizedExpectedCode);\n  });\n});\n"],"mappings":"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","ignoreList":[]}

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

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

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

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrayLiteralExpressionTransformer = void 0;
+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 _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ArrayLiteralExpressionTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.ArrayLiteralExpression;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const members = await (0, _pMapSeries().default)(node.elements, async element => {
+      const schema = await context.computeSchema(element);
+      if (schema instanceof _semanticsEntities().UnImplementedSchema) {
+        const typeRef = await context.resolveType(element, element.getText());
+        return typeRef;
+      }
+      return schema;
+    });
+    const location = context.getLocation(node);
+    return new (_semanticsEntities().ArrayLiteralExpressionSchema)(members, location);
+  }
+}
+exports.ArrayLiteralExpressionTransformer = ArrayLiteralExpressionTransformer;
+
+//# sourceMappingURL=array-literal-expression.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_semanticsEntities","data","require","_pMapSeries","_interopRequireDefault","_typescript","e","__esModule","default","ArrayLiteralExpressionTransformer","predicate","node","kind","ts","SyntaxKind","ArrayLiteralExpression","getIdentifiers","transform","context","members","pMapSeries","elements","element","schema","computeSchema","UnImplementedSchema","typeRef","resolveType","getText","location","getLocation","ArrayLiteralExpressionSchema","exports"],"sources":["array-literal-expression.ts"],"sourcesContent":["import {\n  ArrayLiteralExpressionSchema,\n  SchemaNode,\n  UnImplementedSchema,\n} from '@teambit/semantics.entities.semantic-schema';\nimport pMapSeries from 'p-map-series';\nimport ts, { ArrayLiteralExpression, Node } from 'typescript';\nimport type { SchemaExtractorContext } from '../schema-extractor-context';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { Identifier } from '../identifier';\n\nexport class ArrayLiteralExpressionTransformer implements SchemaTransformer {\n  predicate(node: Node): boolean {\n    return node.kind === ts.SyntaxKind.ArrayLiteralExpression;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: ArrayLiteralExpression, context: SchemaExtractorContext): Promise<SchemaNode> {\n    const members = await pMapSeries(node.elements, async (element) => {\n      const schema = await context.computeSchema(element);\n      if (schema instanceof UnImplementedSchema) {\n        const typeRef = await context.resolveType(element, element.getText());\n        return typeRef;\n      }\n      return schema;\n    });\n    const location = context.getLocation(node);\n    return new ArrayLiteralExpressionSchema(members, location);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,mBAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,kBAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAKA,SAAAE,YAAA;EAAA,MAAAF,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAC,WAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,YAAA;EAAA,MAAAJ,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAG,WAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA8D,SAAAG,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAKvD,MAAMG,iCAAiC,CAA8B;EAC1EC,SAASA,CAACC,IAAU,EAAW;IAC7B,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,sBAAsB;EAC3D;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,CAACN,IAA4B,EAAEO,OAA+B,EAAuB;IAClG,MAAMC,OAAO,GAAG,MAAM,IAAAC,qBAAU,EAACT,IAAI,CAACU,QAAQ,EAAE,MAAOC,OAAO,IAAK;MACjE,MAAMC,MAAM,GAAG,MAAML,OAAO,CAACM,aAAa,CAACF,OAAO,CAAC;MACnD,IAAIC,MAAM,YAAYE,wCAAmB,EAAE;QACzC,MAAMC,OAAO,GAAG,MAAMR,OAAO,CAACS,WAAW,CAACL,OAAO,EAAEA,OAAO,CAACM,OAAO,CAAC,CAAC,CAAC;QACrE,OAAOF,OAAO;MAChB;MACA,OAAOH,MAAM;IACf,CAAC,CAAC;IACF,MAAMM,QAAQ,GAAGX,OAAO,CAACY,WAAW,CAACnB,IAAI,CAAC;IAC1C,OAAO,KAAIoB,iDAA4B,EAACZ,OAAO,EAAEU,QAAQ,CAAC;EAC5D;AACF;AAACG,OAAA,CAAAvB,iCAAA,GAAAA,iCAAA","ignoreList":[]}

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

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

package/dist/transformers/array-type.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrayTypeTransformer = 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 ArrayTypeTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.ArrayType;
+  }
+  async getIdentifiers() {
+    return [];
+  }
+  async transform(node, context) {
+    const type = await context.computeSchema(node.elementType);
+    const location = context.getLocation(node);
+    return new (_semanticsEntities().TypeArraySchema)(location, type);
+  }
+}
+exports.ArrayTypeTransformer = ArrayTypeTransformer;
+
+//# sourceMappingURL=array-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_semanticsEntities","e","__esModule","default","ArrayTypeTransformer","predicate","node","kind","ts","SyntaxKind","ArrayType","getIdentifiers","transform","context","type","computeSchema","elementType","location","getLocation","TypeArraySchema","exports"],"sources":["array-type.ts"],"sourcesContent":["import ts, { ArrayTypeNode, Node } from 'typescript';\nimport { TypeArraySchema } from '@teambit/semantics.entities.semantic-schema';\nimport { SchemaTransformer } from '../schema-transformer';\nimport { SchemaExtractorContext } from '../schema-extractor-context';\nimport { Identifier } from '../identifier';\n\nexport class ArrayTypeTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.ArrayType;\n  }\n\n  async getIdentifiers(): Promise<Identifier[]> {\n    return [];\n  }\n\n  async transform(node: ArrayTypeNode, context: SchemaExtractorContext) {\n    const type = await context.computeSchema(node.elementType);\n    const location = context.getLocation(node);\n    return new TypeArraySchema(location, type);\n  }\n}\n"],"mappings":";;;;;;AAAA,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;AAA8E,SAAAC,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAKvE,MAAMG,oBAAoB,CAA8B;EAC7DC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,SAAS;EAC9C;EAEA,MAAMC,cAAcA,CAAA,EAA0B;IAC5C,OAAO,EAAE;EACX;EAEA,MAAMC,SAASA,CAACN,IAAmB,EAAEO,OAA+B,EAAE;IACpE,MAAMC,IAAI,GAAG,MAAMD,OAAO,CAACE,aAAa,CAACT,IAAI,CAACU,WAAW,CAAC;IAC1D,MAAMC,QAAQ,GAAGJ,OAAO,CAACK,WAAW,CAACZ,IAAI,CAAC;IAC1C,OAAO,KAAIa,oCAAe,EAACF,QAAQ,EAAEH,IAAI,CAAC;EAC5C;AACF;AAACM,OAAA,CAAAhB,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/dist/transformers/binding-element.d.ts

@@ -0,0 +1,17 @@
+import { BindingElement, Node } 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';
+/**
+ * for example:
+ *
+ * const objBindingElem = { elem1: 1, elem2: 2 };
+ * const { elem1 } = objBindingElem;
+ * export { elem1 };
+ */
+export declare class BindingElementTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(node: BindingElement): Promise<Identifier[]>;
+    transform(node: BindingElement, context: SchemaExtractorContext): Promise<VariableLikeSchema>;
+}

package/dist/transformers/binding-element.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BindingElementTransformer = 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 _parseTypeFromQuickInfo() {
+  const data = require("./utils/parse-type-from-quick-info");
+  _parseTypeFromQuickInfo = 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 }; }
+/**
+ * for example:
+ *
+ * const objBindingElem = { elem1: 1, elem2: 2 };
+ * const { elem1 } = objBindingElem;
+ * export { elem1 };
+ */
+class BindingElementTransformer {
+  predicate(node) {
+    return node.kind === _typescript().default.SyntaxKind.BindingElement;
+  }
+  async getIdentifiers(node) {
+    return [new (_identifier().Identifier)(node.name.getText(), node.getSourceFile().fileName)];
+  }
+  async transform(node, context) {
+    const name = node.name.getText();
+    const info = await context.getQuickInfo(node.name);
+    const displaySig = info?.body?.displayString || '';
+    const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    const type = await context.resolveType(node, typeStr);
+    const doc = await context.jsDocToDocSchema(node);
+    const defaultValue = node.initializer ? node.initializer.getText() : undefined;
+    return new (_semanticsEntities().VariableLikeSchema)(context.getLocation(node), name, displaySig, type, false, doc, defaultValue);
+  }
+}
+exports.BindingElementTransformer = BindingElementTransformer;
+
+//# sourceMappingURL=binding-element.js.map

package/dist/transformers/binding-element.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_typescript","data","_interopRequireDefault","require","_semanticsEntities","_parseTypeFromQuickInfo","_identifier","e","__esModule","default","BindingElementTransformer","predicate","node","kind","ts","SyntaxKind","BindingElement","getIdentifiers","Identifier","name","getText","getSourceFile","fileName","transform","context","info","getQuickInfo","displaySig","body","displayString","typeStr","parseTypeFromQuickInfo","type","resolveType","doc","jsDocToDocSchema","defaultValue","initializer","undefined","VariableLikeSchema","getLocation","exports"],"sources":["binding-element.ts"],"sourcesContent":["import ts, { BindingElement, Node } 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\n/**\n * for example:\n *\n * const objBindingElem = { elem1: 1, elem2: 2 };\n * const { elem1 } = objBindingElem;\n * export { elem1 };\n */\nexport class BindingElementTransformer implements SchemaTransformer {\n  predicate(node: Node) {\n    return node.kind === ts.SyntaxKind.BindingElement;\n  }\n\n  async getIdentifiers(node: BindingElement) {\n    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];\n  }\n\n  async transform(node: BindingElement, context: SchemaExtractorContext) {\n    const name = node.name.getText();\n    const info = await context.getQuickInfo(node.name);\n    const displaySig = info?.body?.displayString || '';\n    const typeStr = parseTypeFromQuickInfo(info);\n    const type = await context.resolveType(node, typeStr);\n    const doc = await context.jsDocToDocSchema(node);\n    const defaultValue = node.initializer ? node.initializer.getText() : undefined;\n    return new VariableLikeSchema(context.getLocation(node), name, displaySig, type, false, doc, defaultValue);\n  }\n}\n"],"mappings":";;;;;;AAAA,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;AAGA,SAAAI,wBAAA;EAAA,MAAAJ,IAAA,GAAAE,OAAA;EAAAE,uBAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAK,YAAA;EAAA,MAAAL,IAAA,GAAAE,OAAA;EAAAG,WAAA,YAAAA,CAAA;IAAA,OAAAL,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA2C,SAAAC,uBAAAK,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMG,yBAAyB,CAA8B;EAClEC,SAASA,CAACC,IAAU,EAAE;IACpB,OAAOA,IAAI,CAACC,IAAI,KAAKC,qBAAE,CAACC,UAAU,CAACC,cAAc;EACnD;EAEA,MAAMC,cAAcA,CAACL,IAAoB,EAAE;IACzC,OAAO,CAAC,KAAIM,wBAAU,EAACN,IAAI,CAACO,IAAI,CAACC,OAAO,CAAC,CAAC,EAAER,IAAI,CAACS,aAAa,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC;EAC7E;EAEA,MAAMC,SAASA,CAACX,IAAoB,EAAEY,OAA+B,EAAE;IACrE,MAAML,IAAI,GAAGP,IAAI,CAACO,IAAI,CAACC,OAAO,CAAC,CAAC;IAChC,MAAMK,IAAI,GAAG,MAAMD,OAAO,CAACE,YAAY,CAACd,IAAI,CAACO,IAAI,CAAC;IAClD,MAAMQ,UAAU,GAAGF,IAAI,EAAEG,IAAI,EAAEC,aAAa,IAAI,EAAE;IAClD,MAAMC,OAAO,GAAG,IAAAC,gDAAsB,EAACN,IAAI,CAAC;IAC5C,MAAMO,IAAI,GAAG,MAAMR,OAAO,CAACS,WAAW,CAACrB,IAAI,EAAEkB,OAAO,CAAC;IACrD,MAAMI,GAAG,GAAG,MAAMV,OAAO,CAACW,gBAAgB,CAACvB,IAAI,CAAC;IAChD,MAAMwB,YAAY,GAAGxB,IAAI,CAACyB,WAAW,GAAGzB,IAAI,CAACyB,WAAW,CAACjB,OAAO,CAAC,CAAC,GAAGkB,SAAS;IAC9E,OAAO,KAAIC,uCAAkB,EAACf,OAAO,CAACgB,WAAW,CAAC5B,IAAI,CAAC,EAAEO,IAAI,EAAEQ,UAAU,EAAEK,IAAI,EAAE,KAAK,EAAEE,GAAG,EAAEE,YAAY,CAAC;EAC5G;AACF;AAACK,OAAA,CAAA/B,yBAAA,GAAAA,yBAAA","ignoreList":[]}

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

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