@teambit/typescript 0.0.1101 → 0.0.1103

package/dist/sourceFileTransformers/index.js

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "classNamesTransformer", {
+  enumerable: true,
+  get: function () {
+    return _class().classNamesTransformer;
+  }
+});
+Object.defineProperty(exports, "exportTransformer", {
+  enumerable: true,
+  get: function () {
+    return _export().exportTransformer;
+  }
+});
+Object.defineProperty(exports, "functionNamesTransformer", {
+  enumerable: true,
+  get: function () {
+    return _function().functionNamesTransformer;
+  }
+});
+Object.defineProperty(exports, "identifierTransformer", {
+  enumerable: true,
+  get: function () {
+    return _identifier().identifierTransformer;
+  }
+});
+Object.defineProperty(exports, "importTransformer", {
+  enumerable: true,
+  get: function () {
+    return _import().importTransformer;
+  }
+});
+Object.defineProperty(exports, "interfaceNamesTransformer", {
+  enumerable: true,
+  get: function () {
+    return _interface().interfaceNamesTransformer;
+  }
+});
+Object.defineProperty(exports, "transformSourceFile", {
+  enumerable: true,
+  get: function () {
+    return _transform().transformSourceFile;
+  }
+});
+Object.defineProperty(exports, "typeAliasNamesTransformer", {
+  enumerable: true,
+  get: function () {
+    return _typeAlias().typeAliasNamesTransformer;
+  }
+});
+Object.defineProperty(exports, "variableNamesTransformer", {
+  enumerable: true,
+  get: function () {
+    return _variable().variableNamesTransformer;
+  }
+});
+function _class() {
+  const data = require("./class");
+  _class = function () {
+    return data;
+  };
+  return data;
+}
+function _interface() {
+  const data = require("./interface");
+  _interface = function () {
+    return data;
+  };
+  return data;
+}
+function _variable() {
+  const data = require("./variable");
+  _variable = function () {
+    return data;
+  };
+  return data;
+}
+function _function() {
+  const data = require("./function");
+  _function = function () {
+    return data;
+  };
+  return data;
+}
+function _typeAlias() {
+  const data = require("./typeAlias");
+  _typeAlias = function () {
+    return data;
+  };
+  return data;
+}
+function _import() {
+  const data = require("./import");
+  _import = function () {
+    return data;
+  };
+  return data;
+}
+function _identifier() {
+  const data = require("./identifier");
+  _identifier = function () {
+    return data;
+  };
+  return data;
+}
+function _export() {
+  const data = require("./export");
+  _export = function () {
+    return data;
+  };
+  return data;
+}
+function _transform() {
+  const data = require("./transform");
+  _transform = function () {
+    return data;
+  };
+  return data;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/sourceFileTransformers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["import ts from 'typescript';\n\nexport type SourceFileTransformer = (mapping: Record<string, string>) => ts.TransformerFactory<ts.SourceFile>;\n\nexport { classNamesTransformer } from './class';\nexport { interfaceNamesTransformer } from './interface';\nexport { variableNamesTransformer } from './variable';\nexport { functionNamesTransformer } from './function';\nexport { typeAliasNamesTransformer } from './typeAlias';\nexport { importTransformer } from './import';\nexport { identifierTransformer } from './identifier';\nexport { exportTransformer } from './export';\nexport { transformSourceFile } from './transform';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA"}

package/dist/sourceFileTransformers/interface.d.ts

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

package/dist/sourceFileTransformers/interface.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.interfaceNamesTransformer = interfaceNamesTransformer;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function interfaceNamesTransformer(nameMapping) {
+  return context => {
+    const {
+      factory
+    } = context;
+    const visit = node => {
+      if (_typescript().default.isInterfaceDeclaration(node)) {
+        const oldName = node.name.text;
+        const newName = Object.keys(nameMapping).find(key => oldName.startsWith(key) || oldName.endsWith(key));
+        if (newName) {
+          const replacedName = oldName.startsWith(newName) ? oldName.replace(newName, nameMapping[newName]) : oldName.replace(new RegExp(`${newName}$`), nameMapping[newName]);
+          return factory.updateInterfaceDeclaration(node, node.decorators, node.modifiers, factory.createIdentifier(replacedName), node.typeParameters, node.heritageClauses, node.members);
+        }
+      }
+      return _typescript().default.visitEachChild(node, child => visit(child), context);
+    };
+    return node => _typescript().default.visitNode(node, visit);
+  };
+}
+
+//# sourceMappingURL=interface.js.map

package/dist/sourceFileTransformers/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["interfaceNamesTransformer","nameMapping","context","factory","visit","node","ts","isInterfaceDeclaration","oldName","name","text","newName","Object","keys","find","key","startsWith","endsWith","replacedName","replace","RegExp","updateInterfaceDeclaration","decorators","modifiers","createIdentifier","typeParameters","heritageClauses","members","visitEachChild","child","visitNode"],"sources":["interface.ts"],"sourcesContent":["import ts from 'typescript';\n\nexport function interfaceNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {\n  return (context) => {\n    const { factory } = context;\n    const visit: ts.Visitor = (node) => {\n      if (ts.isInterfaceDeclaration(node)) {\n        const oldName = node.name.text;\n        const newName = Object.keys(nameMapping).find((key) => oldName.startsWith(key) || oldName.endsWith(key));\n        if (newName) {\n          const replacedName = oldName.startsWith(newName)\n            ? oldName.replace(newName, nameMapping[newName])\n            : oldName.replace(new RegExp(`${newName}$`), nameMapping[newName]);\n          return factory.updateInterfaceDeclaration(\n            node,\n            node.decorators,\n            node.modifiers,\n            factory.createIdentifier(replacedName),\n            node.typeParameters,\n            node.heritageClauses,\n            node.members\n          );\n        }\n      }\n      return ts.visitEachChild(node, (child) => visit(child), context);\n    };\n    return (node) => ts.visitNode(node, visit);\n  };\n}\n"],"mappings":";;;;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEO,SAASA,yBAAyB,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,GAAGC,MAAM,CAACC,IAAI,CAACZ,WAAW,CAAC,CAACa,IAAI,CAAEC,GAAG,IAAKP,OAAO,CAACQ,UAAU,CAACD,GAAG,CAAC,IAAIP,OAAO,CAACS,QAAQ,CAACF,GAAG,CAAC,CAAC;QACxG,IAAIJ,OAAO,EAAE;UACX,MAAMO,YAAY,GAAGV,OAAO,CAACQ,UAAU,CAACL,OAAO,CAAC,GAC5CH,OAAO,CAACW,OAAO,CAACR,OAAO,EAAEV,WAAW,CAACU,OAAO,CAAC,CAAC,GAC9CH,OAAO,CAACW,OAAO,CAAC,IAAIC,MAAM,CAAE,GAAET,OAAQ,GAAE,CAAC,EAAEV,WAAW,CAACU,OAAO,CAAC,CAAC;UACpE,OAAOR,OAAO,CAACkB,0BAA0B,CACvChB,IAAI,EACJA,IAAI,CAACiB,UAAU,EACfjB,IAAI,CAACkB,SAAS,EACdpB,OAAO,CAACqB,gBAAgB,CAACN,YAAY,CAAC,EACtCb,IAAI,CAACoB,cAAc,EACnBpB,IAAI,CAACqB,eAAe,EACpBrB,IAAI,CAACsB,OAAO,CACb;QACH;MACF;MACA,OAAOrB,qBAAE,CAACsB,cAAc,CAACvB,IAAI,EAAGwB,KAAK,IAAKzB,KAAK,CAACyB,KAAK,CAAC,EAAE3B,OAAO,CAAC;IAClE,CAAC;IACD,OAAQG,IAAI,IAAKC,qBAAE,CAACwB,SAAS,CAACzB,IAAI,EAAED,KAAK,CAAC;EAC5C,CAAC;AACH"}

package/dist/sourceFileTransformers/transform.d.ts

@@ -0,0 +1,12 @@
+import { Formatter } from '@teambit/formatter';
+import ts from 'typescript';
+/**
+ * Transforms a TypeScript source file using the provided transformer.
+ *
+ * @param sourceFilePath Path to the TypeScript source file.
+ * @param sourceFileContent The content of the source file.
+ * @param transformers The transformers to be applied on the source file.
+ * @param formatter (Optional) An optional formatter to format the transformed code. If no formatter is provided, the function returns the transformed source file as a string without any formatting.
+ * @returns A promise that resolves to the transformed source file as a string.
+ */
+export declare function transformSourceFile(sourceFilePath: string, sourceFileContent: string, transformers: ts.TransformerFactory<ts.SourceFile>[], formatter?: Formatter, updates?: Record<string, string>): Promise<string>;

package/dist/sourceFileTransformers/transform.js

@@ -0,0 +1,113 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformSourceFile = transformSourceFile;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function path() {
+  const data = _interopRequireWildcard(require("path"));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _emptyLineEncoder() {
+  const data = require("./empty-line-encoder");
+  _emptyLineEncoder = 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; }
+/**
+ * Transforms a TypeScript source file using the provided transformer.
+ *
+ * @param sourceFilePath Path to the TypeScript source file.
+ * @param sourceFileContent The content of the source file.
+ * @param transformers The transformers to be applied on the source file.
+ * @param formatter (Optional) An optional formatter to format the transformed code. If no formatter is provided, the function returns the transformed source file as a string without any formatting.
+ * @returns A promise that resolves to the transformed source file as a string.
+ */
+async function transformSourceFile(sourceFilePath, sourceFileContent, transformers, formatter, updates) {
+  const ext = path().extname(sourceFilePath);
+  const compatibleExts = ['.ts', '.tsx', '.js', '.jsx'];
+  if (!compatibleExts.includes(ext)) {
+    if (!updates) return sourceFileContent;
+    let transformed = sourceFileContent;
+    Object.entries(updates).forEach(([oldStr, newStr]) => {
+      const oldStringRegex = new RegExp(oldStr, 'g');
+      transformed = transformed.replace(oldStringRegex, newStr);
+    });
+    return transformed;
+  }
+  const encoder = new (_emptyLineEncoder().EmptyLineEncoder)();
+  sourceFileContent = encoder.encode(sourceFileContent);
+  const sourceFile = _typescript().default.createSourceFile(sourceFilePath, sourceFileContent, _typescript().default.ScriptTarget.Latest, true, _typescript().default.ScriptKind.TSX);
+  const transformedResult = _typescript().default.transform(sourceFile, transformers);
+  const transformedSourceFile = transformedResult.transformed[0];
+
+  // const _identifierTransformer = identifierTransformer(updates || {});
+
+  // const transformedResultWithIdentifiers: ts.TransformationResult<ts.SourceFile> =
+  // ts.transform<ts.SourceFile>(transformedSourceFile, []);
+  // const transformedSourceFileWithIdentifiers: ts.SourceFile
+  // = transformedResultWithIdentifiers.transformed[0] as ts.SourceFile;
+
+  const printer = _typescript().default.createPrinter({
+    removeComments: false
+  });
+  let transformedSourceFileStr = printer.printFile(transformedSourceFile);
+  transformedSourceFileStr = encoder.decode(transformedSourceFileStr);
+  // Remove trailing empty line markers
+  const emptyLineComment = `\\s*\\/\\*${encoder.emptyLineMarker}\\*\\/\\s*$`;
+  const regex = new RegExp(emptyLineComment, 'g');
+  transformedSourceFileStr = transformedSourceFileStr.replace(regex, '');
+  const formattedSourceFileStr = await (formatter === null || formatter === void 0 ? void 0 : formatter.formatSnippet(transformedSourceFileStr));
+  return formattedSourceFileStr || transformedSourceFileStr;
+}
+
+// function createMarkingTransformer<T extends ts.Node>(innerTransformer: ts.TransformerFactory<T>)
+// : ts.TransformerFactory<T> {
+//     return context => {
+//       const innerTransform = innerTransformer(context);
+
+//       return node => {
+//         const result = innerTransform(node);
+
+//         // Add a custom property to the node to mark it as transformed
+//         // Note: this relies on TypeScript's internal behavior and may not be stable across versions
+//         (result as any).__transformed = true;
+
+//         return result;
+//       };
+//     };
+//   }
+
+//   const defaultTransformer: ts.TransformerFactory<ts.SourceFile> = () => {
+//     const visit: ts.Visitor = node => {
+//       // If the node has been marked as transformed by a specific transformer, don't transform it
+//       if ((node as any).__transformed) {
+//         return node;
+//       }
+
+//       // Your transformation logic goes here...
+//     };
+
+//     return node => ts.visitNode(node, visit);
+//   };
+
+//# sourceMappingURL=transform.js.map

package/dist/sourceFileTransformers/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["transformSourceFile","sourceFilePath","sourceFileContent","transformers","formatter","updates","ext","path","extname","compatibleExts","includes","transformed","Object","entries","forEach","oldStr","newStr","oldStringRegex","RegExp","replace","encoder","EmptyLineEncoder","encode","sourceFile","ts","createSourceFile","ScriptTarget","Latest","ScriptKind","TSX","transformedResult","transform","transformedSourceFile","printer","createPrinter","removeComments","transformedSourceFileStr","printFile","decode","emptyLineComment","emptyLineMarker","regex","formattedSourceFileStr","formatSnippet"],"sources":["transform.ts"],"sourcesContent":["import { Formatter } from '@teambit/formatter';\nimport ts from 'typescript';\nimport * as path from 'path';\nimport { EmptyLineEncoder } from './empty-line-encoder';\n/**\n * Transforms a TypeScript source file using the provided transformer.\n *\n * @param sourceFilePath Path to the TypeScript source file.\n * @param sourceFileContent The content of the source file.\n * @param transformers The transformers to be applied on the source file.\n * @param formatter (Optional) An optional formatter to format the transformed code. If no formatter is provided, the function returns the transformed source file as a string without any formatting.\n * @returns A promise that resolves to the transformed source file as a string.\n */\nexport async function transformSourceFile(\n  sourceFilePath: string,\n  sourceFileContent: string,\n  transformers: ts.TransformerFactory<ts.SourceFile>[],\n  formatter?: Formatter,\n  updates?: Record<string, string>\n): Promise<string> {\n  const ext = path.extname(sourceFilePath);\n  const compatibleExts = ['.ts', '.tsx', '.js', '.jsx'];\n  if (!compatibleExts.includes(ext)) {\n    if (!updates) return sourceFileContent;\n    let transformed = sourceFileContent;\n    Object.entries(updates).forEach(([oldStr, newStr]) => {\n      const oldStringRegex = new RegExp(oldStr, 'g');\n      transformed = transformed.replace(oldStringRegex, newStr);\n    });\n    return transformed;\n  }\n\n  const encoder = new EmptyLineEncoder();\n  sourceFileContent = encoder.encode(sourceFileContent);\n\n  const sourceFile = ts.createSourceFile(\n    sourceFilePath,\n    sourceFileContent,\n    ts.ScriptTarget.Latest,\n    true,\n    ts.ScriptKind.TSX\n  );\n\n  const transformedResult: ts.TransformationResult<ts.SourceFile> = ts.transform<ts.SourceFile>(\n    sourceFile,\n    transformers\n  );\n  const transformedSourceFile: ts.SourceFile = transformedResult.transformed[0] as ts.SourceFile;\n\n  // const _identifierTransformer = identifierTransformer(updates || {});\n\n  // const transformedResultWithIdentifiers: ts.TransformationResult<ts.SourceFile> =\n  // ts.transform<ts.SourceFile>(transformedSourceFile, []);\n  // const transformedSourceFileWithIdentifiers: ts.SourceFile\n  // = transformedResultWithIdentifiers.transformed[0] as ts.SourceFile;\n\n  const printer: ts.Printer = ts.createPrinter({\n    removeComments: false,\n  });\n\n  let transformedSourceFileStr = printer.printFile(transformedSourceFile);\n  transformedSourceFileStr = encoder.decode(transformedSourceFileStr);\n  // Remove trailing empty line markers\n  const emptyLineComment = `\\\\s*\\\\/\\\\*${encoder.emptyLineMarker}\\\\*\\\\/\\\\s*$`;\n  const regex = new RegExp(emptyLineComment, 'g');\n  transformedSourceFileStr = transformedSourceFileStr.replace(regex, '');\n\n  const formattedSourceFileStr = await formatter?.formatSnippet(transformedSourceFileStr);\n  return formattedSourceFileStr || transformedSourceFileStr;\n}\n\n// function createMarkingTransformer<T extends ts.Node>(innerTransformer: ts.TransformerFactory<T>)\n// : ts.TransformerFactory<T> {\n//     return context => {\n//       const innerTransform = innerTransformer(context);\n\n//       return node => {\n//         const result = innerTransform(node);\n\n//         // Add a custom property to the node to mark it as transformed\n//         // Note: this relies on TypeScript's internal behavior and may not be stable across versions\n//         (result as any).__transformed = true;\n\n//         return result;\n//       };\n//     };\n//   }\n\n//   const defaultTransformer: ts.TransformerFactory<ts.SourceFile> = () => {\n//     const visit: ts.Visitor = node => {\n//       // If the node has been marked as transformed by a specific transformer, don't transform it\n//       if ((node as any).__transformed) {\n//         return node;\n//       }\n\n//       // Your transformation logic goes here...\n//     };\n\n//     return node => ts.visitNode(node, visit);\n//   };\n"],"mappings":";;;;;;;;;;;;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAAwD;AAAA;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAeA,mBAAmB,CACvCC,cAAsB,EACtBC,iBAAyB,EACzBC,YAAoD,EACpDC,SAAqB,EACrBC,OAAgC,EACf;EACjB,MAAMC,GAAG,GAAGC,IAAI,GAACC,OAAO,CAACP,cAAc,CAAC;EACxC,MAAMQ,cAAc,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC;EACrD,IAAI,CAACA,cAAc,CAACC,QAAQ,CAACJ,GAAG,CAAC,EAAE;IACjC,IAAI,CAACD,OAAO,EAAE,OAAOH,iBAAiB;IACtC,IAAIS,WAAW,GAAGT,iBAAiB;IACnCU,MAAM,CAACC,OAAO,CAACR,OAAO,CAAC,CAACS,OAAO,CAAC,CAAC,CAACC,MAAM,EAAEC,MAAM,CAAC,KAAK;MACpD,MAAMC,cAAc,GAAG,IAAIC,MAAM,CAACH,MAAM,EAAE,GAAG,CAAC;MAC9CJ,WAAW,GAAGA,WAAW,CAACQ,OAAO,CAACF,cAAc,EAAED,MAAM,CAAC;IAC3D,CAAC,CAAC;IACF,OAAOL,WAAW;EACpB;EAEA,MAAMS,OAAO,GAAG,KAAIC,oCAAgB,GAAE;EACtCnB,iBAAiB,GAAGkB,OAAO,CAACE,MAAM,CAACpB,iBAAiB,CAAC;EAErD,MAAMqB,UAAU,GAAGC,qBAAE,CAACC,gBAAgB,CACpCxB,cAAc,EACdC,iBAAiB,EACjBsB,qBAAE,CAACE,YAAY,CAACC,MAAM,EACtB,IAAI,EACJH,qBAAE,CAACI,UAAU,CAACC,GAAG,CAClB;EAED,MAAMC,iBAAyD,GAAGN,qBAAE,CAACO,SAAS,CAC5ER,UAAU,EACVpB,YAAY,CACb;EACD,MAAM6B,qBAAoC,GAAGF,iBAAiB,CAACnB,WAAW,CAAC,CAAC,CAAkB;;EAE9F;;EAEA;EACA;EACA;EACA;;EAEA,MAAMsB,OAAmB,GAAGT,qBAAE,CAACU,aAAa,CAAC;IAC3CC,cAAc,EAAE;EAClB,CAAC,CAAC;EAEF,IAAIC,wBAAwB,GAAGH,OAAO,CAACI,SAAS,CAACL,qBAAqB,CAAC;EACvEI,wBAAwB,GAAGhB,OAAO,CAACkB,MAAM,CAACF,wBAAwB,CAAC;EACnE;EACA,MAAMG,gBAAgB,GAAI,aAAYnB,OAAO,CAACoB,eAAgB,aAAY;EAC1E,MAAMC,KAAK,GAAG,IAAIvB,MAAM,CAACqB,gBAAgB,EAAE,GAAG,CAAC;EAC/CH,wBAAwB,GAAGA,wBAAwB,CAACjB,OAAO,CAACsB,KAAK,EAAE,EAAE,CAAC;EAEtE,MAAMC,sBAAsB,GAAG,OAAMtC,SAAS,aAATA,SAAS,uBAATA,SAAS,CAAEuC,aAAa,CAACP,wBAAwB,CAAC;EACvF,OAAOM,sBAAsB,IAAIN,wBAAwB;AAC3D;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA"}

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,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeAliasNamesTransformer = typeAliasNamesTransformer;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function typeAliasNamesTransformer(nameMapping) {
+  return context => {
+    const {
+      factory
+    } = context;
+    const visit = node => {
+      if (_typescript().default.isTypeAliasDeclaration(node)) {
+        const oldName = node.name.text;
+        const newName = Object.keys(nameMapping).find(key => oldName.startsWith(key) || oldName.endsWith(key));
+        if (newName) {
+          const replacedName = oldName.startsWith(newName) ? oldName.replace(newName, nameMapping[newName]) : oldName.replace(new RegExp(`${newName}$`), nameMapping[newName]);
+          return factory.updateTypeAliasDeclaration(node, node.decorators, node.modifiers, factory.createIdentifier(replacedName), 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":["typeAliasNamesTransformer","nameMapping","context","factory","visit","node","ts","isTypeAliasDeclaration","oldName","name","text","newName","Object","keys","find","key","startsWith","endsWith","replacedName","replace","RegExp","updateTypeAliasDeclaration","decorators","modifiers","createIdentifier","typeParameters","type","visitEachChild","child","visitNode"],"sources":["typeAlias.ts"],"sourcesContent":["import ts from 'typescript';\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 = Object.keys(nameMapping).find((key) => oldName.startsWith(key) || oldName.endsWith(key));\n        if (newName) {\n          const replacedName = oldName.startsWith(newName)\n            ? oldName.replace(newName, nameMapping[newName])\n            : oldName.replace(new RegExp(`${newName}$`), nameMapping[newName]);\n          return factory.updateTypeAliasDeclaration(\n            node,\n            node.decorators,\n            node.modifiers,\n            factory.createIdentifier(replacedName),\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);\n  };\n}\n"],"mappings":";;;;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEO,SAASA,yBAAyB,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,GAAGC,MAAM,CAACC,IAAI,CAACZ,WAAW,CAAC,CAACa,IAAI,CAAEC,GAAG,IAAKP,OAAO,CAACQ,UAAU,CAACD,GAAG,CAAC,IAAIP,OAAO,CAACS,QAAQ,CAACF,GAAG,CAAC,CAAC;QACxG,IAAIJ,OAAO,EAAE;UACX,MAAMO,YAAY,GAAGV,OAAO,CAACQ,UAAU,CAACL,OAAO,CAAC,GAC5CH,OAAO,CAACW,OAAO,CAACR,OAAO,EAAEV,WAAW,CAACU,OAAO,CAAC,CAAC,GAC9CH,OAAO,CAACW,OAAO,CAAC,IAAIC,MAAM,CAAE,GAAET,OAAQ,GAAE,CAAC,EAAEV,WAAW,CAACU,OAAO,CAAC,CAAC;UACpE,OAAOR,OAAO,CAACkB,0BAA0B,CACvChB,IAAI,EACJA,IAAI,CAACiB,UAAU,EACfjB,IAAI,CAACkB,SAAS,EACdpB,OAAO,CAACqB,gBAAgB,CAACN,YAAY,CAAC,EACtCb,IAAI,CAACoB,cAAc,EACnBpB,IAAI,CAACqB,IAAI,CACV;QACH;MACF;MACA,OAAOpB,qBAAE,CAACqB,cAAc,CAACtB,IAAI,EAAGuB,KAAK,IAAKxB,KAAK,CAACwB,KAAK,CAAC,EAAE1B,OAAO,CAAC;IAClE,CAAC;IACD,OAAQG,IAAI,IAAKC,qBAAE,CAACuB,SAAS,CAACxB,IAAI,EAAED,KAAK,CAAC;EAC5C,CAAC;AACH"}

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,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.replace.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.variableNamesTransformer = variableNamesTransformer;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+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 = Object.keys(nameMapping).find(key => oldName.startsWith(key) || oldName.endsWith(key));
+        if (newName) {
+          const replacedName = oldName.startsWith(newName) ? oldName.replace(newName, nameMapping[newName]) : oldName.replace(new RegExp(`${newName}$`), nameMapping[newName]);
+          return factory.updateVariableDeclaration(node, factory.createIdentifier(replacedName), 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":["variableNamesTransformer","nameMapping","context","factory","visit","node","ts","isVariableDeclaration","name","kind","SyntaxKind","Identifier","oldName","text","newName","Object","keys","find","key","startsWith","endsWith","replacedName","replace","RegExp","updateVariableDeclaration","createIdentifier","exclamationToken","type","initializer","visitEachChild","child","visitNode"],"sources":["variable.ts"],"sourcesContent":["import ts from 'typescript';\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 = Object.keys(nameMapping).find((key) => oldName.startsWith(key) || oldName.endsWith(key));\n        if (newName) {\n          const replacedName = oldName.startsWith(newName)\n            ? oldName.replace(newName, nameMapping[newName])\n            : oldName.replace(new RegExp(`${newName}$`), nameMapping[newName]);\n\n          return factory.updateVariableDeclaration(\n            node,\n            factory.createIdentifier(replacedName),\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);\n  };\n}\n"],"mappings":";;;;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEO,SAASA,wBAAwB,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,GAAGC,MAAM,CAACC,IAAI,CAACf,WAAW,CAAC,CAACgB,IAAI,CAAEC,GAAG,IAAKN,OAAO,CAACO,UAAU,CAACD,GAAG,CAAC,IAAIN,OAAO,CAACQ,QAAQ,CAACF,GAAG,CAAC,CAAC;QACxG,IAAIJ,OAAO,EAAE;UACX,MAAMO,YAAY,GAAGT,OAAO,CAACO,UAAU,CAACL,OAAO,CAAC,GAC5CF,OAAO,CAACU,OAAO,CAACR,OAAO,EAAEb,WAAW,CAACa,OAAO,CAAC,CAAC,GAC9CF,OAAO,CAACU,OAAO,CAAC,IAAIC,MAAM,CAAE,GAAET,OAAQ,GAAE,CAAC,EAAEb,WAAW,CAACa,OAAO,CAAC,CAAC;UAEpE,OAAOX,OAAO,CAACqB,yBAAyB,CACtCnB,IAAI,EACJF,OAAO,CAACsB,gBAAgB,CAACJ,YAAY,CAAC,EACtChB,IAAI,CAACqB,gBAAgB,EACrBrB,IAAI,CAACsB,IAAI,EACTtB,IAAI,CAACuB,WAAW,CACjB;QACH;MACF;MACA,OAAOtB,qBAAE,CAACuB,cAAc,CAACxB,IAAI,EAAGyB,KAAK,IAAK1B,KAAK,CAAC0B,KAAK,CAAC,EAAE5B,OAAO,CAAC;IAClE,CAAC;IACD,OAAQG,IAAI,IAAKC,qBAAE,CAACyB,SAAS,CAAC1B,IAAI,EAAED,KAAK,CAAC;EAC5C,CAAC;AACH"}

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

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

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

@@ -0,0 +1,109 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.promise.js");
+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 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);
+      expect(normalizedResult).toBe(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";'
+  }];
+  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);
+    expect(normalizedResult).toBe(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);
+    expect(normalizedResult).toBe(normalizedExpectedCode);
+  });
+});
+
+//# sourceMappingURL=transform-source-file.spec.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["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","toBe","testCases","classNamesTransformer","TestClass","functionNamesTransformer","testFunction","importTransformer","interfaceNamesTransformer","TestInterface","typeAliasNamesTransformer","TestType","variableNamesTransformer","testVariable","normalizedSourceCode"],"sources":["transform-source-file.spec.ts"],"sourcesContent":["import ts from 'typescript';\nimport {\n  transformSourceFile,\n  classNamesTransformer,\n  functionNamesTransformer,\n  importTransformer,\n  interfaceNamesTransformer,\n  typeAliasNamesTransformer,\n  variableNamesTransformer,\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).toBe(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\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).toBe(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).toBe(normalizedExpectedCode);\n  });\n});\n"],"mappings":"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"}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/typescript",
-  "version": "0.0.1101",
+  "version": "0.0.1103",
   "homepage": "https://bit.cloud/teambit/typescript/typescript",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.typescript",
     "name": "typescript",
-    "version": "0.0.1101"
+    "version": "0.0.1103"
   },
   "dependencies": {
     "get-tsconfig": "4.2.0",
@@ -21,26 +21,26 @@
     "core-js": "^3.0.0",
     "@babel/runtime": "7.20.0",
     "@teambit/harmony": "0.4.6",
-    "@teambit/compiler": "0.0.1101",
+    "@teambit/compiler": "0.0.1103",
     "@teambit/typescript.modules.ts-config-mutator": "0.0.76",
-    "@teambit/builder": "0.0.1101",
-    "@teambit/isolator": "0.0.1101",
-    "@teambit/component": "0.0.1101",
-    "@teambit/dependency-resolver": "0.0.1101",
-    "@teambit/formatter": "0.0.652",
+    "@teambit/builder": "0.0.1103",
+    "@teambit/isolator": "0.0.1103",
+    "@teambit/component": "0.0.1103",
+    "@teambit/dependency-resolver": "0.0.1103",
+    "@teambit/formatter": "0.0.654",
     "@teambit/semantics.entities.semantic-schema": "0.0.53",
     "@teambit/ts-server": "0.0.48",
-    "@teambit/aspect-loader": "0.0.1101",
-    "@teambit/envs": "0.0.1101",
-    "@teambit/logger": "0.0.831",
-    "@teambit/workspace-config-files": "0.0.81",
-    "@teambit/workspace": "0.0.1101",
+    "@teambit/aspect-loader": "0.0.1103",
+    "@teambit/envs": "0.0.1103",
+    "@teambit/logger": "0.0.832",
+    "@teambit/workspace-config-files": "0.0.83",
+    "@teambit/workspace": "0.0.1103",
     "@teambit/bit-error": "0.0.402",
-    "@teambit/schema": "0.0.1101",
-    "@teambit/scope": "0.0.1101",
-    "@teambit/cli": "0.0.738",
-    "@teambit/pkg": "0.0.1101",
-    "@teambit/watcher": "0.0.113"
+    "@teambit/schema": "0.0.1103",
+    "@teambit/scope": "0.0.1103",
+    "@teambit/cli": "0.0.739",
+    "@teambit/pkg": "0.0.1103",
+    "@teambit/watcher": "0.0.115"
   },
   "devDependencies": {
     "@types/lodash": "4.14.165",
@@ -56,7 +56,7 @@
     "@teambit/typescript.aspect-docs.typescript": "0.0.153"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.519",
+    "@teambit/legacy": "1.0.520",
     "react": "^16.8.0 || ^17.0.0",
     "react-dom": "^16.8.0 || ^17.0.0"
   },