@teambit/typescript 0.0.1101 → 0.0.1102

package/sourceFileTransformers/class.ts

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+
+export function classNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {
+  return (context) => {
+    const { factory } = context;
+    const visit: ts.Visitor = (node) => {
+      if (ts.isClassDeclaration(node) && node.name) {
+        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.updateClassDeclaration(
+            node,
+            node.decorators,
+            node.modifiers,
+            factory.createIdentifier(replacedName),
+            node.typeParameters,
+            node.heritageClauses,
+            node.members
+          );
+        }
+      }
+      return ts.visitEachChild(node, (child) => visit(child), context);
+    };
+    return (node) => ts.visitNode(node, visit);
+  };
+}

package/sourceFileTransformers/empty-line-encoder.ts

@@ -0,0 +1,56 @@
+import ts from 'typescript';
+
+export class EmptyLineEncoder {
+  static readonly defaultEmptyLineMarker: string = '!--empty-line--!';
+  static readonly defaultNewLine: string = '\r\n';
+  constructor(emptyLineMarker?: string, newLine?: string) {
+    this.emptyLineMarker = emptyLineMarker || EmptyLineEncoder.defaultEmptyLineMarker;
+    this.newLine = newLine || EmptyLineEncoder.defaultNewLine;
+  }
+  emptyLineMarker: string;
+  newLine: string;
+
+  encode(text: string) {
+    return encodeEmptyLines(text, this.emptyLineMarker, this.newLine);
+  }
+  decode(text: string) {
+    return decodeEmptyLines(text, this.emptyLineMarker, this.newLine);
+  }
+  addLeadingEmptyLineMarker<T extends ts.Node>(node: T) {
+    return addLeadingEmptyLineMarker(node, this.emptyLineMarker);
+  }
+}
+
+export function encodeEmptyLines(text: string, emptyLineMarker?: string, newLine?: string) {
+  const marker = toComment(emptyLineMarker || EmptyLineEncoder.defaultEmptyLineMarker);
+
+  const lines = text.split(/\r?\n/);
+
+  const commentedLines = lines.map((line) => (line.trim() === '' ? marker : line));
+
+  return commentedLines.join(newLine || EmptyLineEncoder.defaultNewLine);
+}
+
+export function decodeEmptyLines(text: string, emptyLineMarker?: string, newLine?: string) {
+  const marker = toComment(emptyLineMarker || EmptyLineEncoder.defaultEmptyLineMarker);
+
+  const lines = text.split(/\r?\n/);
+
+  const uncommentedLines = lines.map((line) => (line === marker ? '' : line));
+
+  return uncommentedLines.join(newLine || EmptyLineEncoder.defaultNewLine);
+}
+
+export function addLeadingEmptyLineMarker<T extends ts.Node>(node: T, emptyLineMarker?: string) {
+  return ts.addSyntheticLeadingComment(
+    node,
+    ts.SyntaxKind.MultiLineCommentTrivia,
+    emptyLineMarker || EmptyLineEncoder.defaultEmptyLineMarker,
+    // hasTrailingNewLine
+    true
+  );
+}
+
+function toComment(marker: string) {
+  return `/*${marker}*/`;
+}

package/sourceFileTransformers/export.ts

@@ -0,0 +1,65 @@
+import ts from 'typescript';
+import { SourceFileTransformer } from '.';
+
+export const exportTransformer: SourceFileTransformer = (mapping: Record<string, string>) => {
+  return (context) => {
+    const visit: ts.Visitor = (node) => {
+      if (ts.isExportDeclaration(node)) {
+        let moduleSpecifier = node.moduleSpecifier?.getText().slice(1, -1);
+        for (const [oldName, newName] of Object.entries(mapping)) {
+          if (moduleSpecifier && moduleSpecifier.includes(oldName)) {
+            moduleSpecifier = moduleSpecifier.replace(oldName, newName);
+          }
+        }
+
+        if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+          const transformedElements = node.exportClause.elements.map((element) => {
+            let newElementName = element.name.text;
+
+            for (const [oldName, newName] of Object.entries(mapping)) {
+              if (newElementName.startsWith(oldName) || newElementName.endsWith(oldName)) {
+                newElementName = newElementName.replace(oldName, newName);
+              }
+            }
+
+            return ts.factory.updateExportSpecifier(
+              element,
+              false,
+              element.propertyName,
+              ts.factory.createIdentifier(newElementName)
+            );
+          });
+
+          const updatedExportClause = ts.factory.updateNamedExports(node.exportClause, transformedElements);
+
+          return ts.factory.updateExportDeclaration(
+            node,
+            node.decorators,
+            node.modifiers,
+            node.isTypeOnly,
+            updatedExportClause,
+            node.moduleSpecifier ? ts.factory.createStringLiteral(moduleSpecifier || '') : undefined,
+            undefined
+          );
+        }
+      }
+
+      if (ts.isExportAssignment(node)) {
+        let expression = node.expression;
+
+        if (ts.isIdentifier(expression)) {
+          for (const [oldName, newName] of Object.entries(mapping)) {
+            if (expression.getText().startsWith(oldName) || expression.getText().endsWith(oldName)) {
+              expression = ts.factory.createIdentifier(expression.getText().replace(oldName, newName));
+            }
+          }
+        }
+
+        return ts.factory.updateExportAssignment(node, node.decorators, node.modifiers, expression);
+      }
+
+      return ts.visitEachChild(node, visit, context);
+    };
+    return (node) => ts.visitNode(node, visit);
+  };
+};

package/sourceFileTransformers/function.ts

@@ -0,0 +1,164 @@
+import ts from 'typescript';
+import { SourceFileTransformer } from '.';
+
+export const functionNamesTransformer: SourceFileTransformer = (mapping: Record<string, string>) => {
+  return (context) => {
+    const updateTypeReference: ts.Visitor = (node) => {
+      if (ts.isTypeReferenceNode(node)) {
+        const typeName = node.typeName.getText();
+        const newTypeName = mapping[typeName];
+        if (newTypeName) {
+          return ts.factory.updateTypeReferenceNode(node, ts.factory.createIdentifier(newTypeName), node.typeArguments);
+        }
+      }
+      return ts.visitEachChild(node, updateTypeReference, context);
+    };
+
+    const visit: ts.Visitor = (node) => {
+      if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        const functionName = node.name?.getText() ?? '';
+        const newName = Object.entries(mapping).find(([key]) => functionName.includes(key))?.[1] ?? functionName;
+        const parameters = node.parameters.map((param) => {
+          const newParamType = param.type ? ts.visitNode(param.type, updateTypeReference) : param.type;
+          if (ts.isIdentifier(param.name)) {
+            const oldName = param.name.getText();
+            const newParamName = Object.keys(mapping).find((key) => oldName.includes(key));
+            if (newParamName) {
+              return ts.factory.updateParameterDeclaration(
+                param,
+                param.decorators,
+                param.modifiers,
+                param.dotDotDotToken,
+                ts.factory.createIdentifier(newParamName),
+                param.questionToken,
+                newParamType,
+                param.initializer
+              );
+            }
+          } else if (ts.isObjectBindingPattern(param.name)) {
+            const elements = param.name.elements.map((element) => {
+              const newElementName = mapping[element.name.getText()];
+              if (newElementName) {
+                return ts.factory.updateBindingElement(
+                  element,
+                  element.dotDotDotToken,
+                  element.propertyName,
+                  ts.factory.createIdentifier(newElementName),
+                  element.initializer
+                );
+              }
+              return element;
+            });
+            const newParamName = ts.factory.createObjectBindingPattern(elements);
+            return ts.factory.updateParameterDeclaration(
+              param,
+              param.decorators,
+              param.modifiers,
+              param.dotDotDotToken,
+              newParamName,
+              param.questionToken,
+              newParamType,
+              param.initializer
+            );
+          }
+          return param;
+        });
+
+        if (ts.isFunctionDeclaration(node)) {
+          const updatedBody = node.body && ts.isBlock(node.body) ? updateReturnStatement(node.body) : node.body;
+          return ts.factory.updateFunctionDeclaration(
+            node,
+            node.decorators,
+            node.modifiers,
+            node.asteriskToken,
+            newName ? ts.factory.createIdentifier(newName) : node.name,
+            node.typeParameters,
+            parameters,
+            node.type,
+            updatedBody
+          );
+        }
+        if (ts.isArrowFunction(node)) {
+          const updatedBody = node.body && ts.isBlock(node.body) ? updateReturnStatement(node.body) : node.body;
+          return ts.factory.updateArrowFunction(
+            node,
+            node.modifiers,
+            node.typeParameters,
+            parameters,
+            node.type,
+            node.equalsGreaterThanToken,
+            updatedBody
+          );
+        }
+        if (ts.isFunctionExpression(node)) {
+          const updatedBody = node.body && ts.isBlock(node.body) ? updateReturnStatement(node.body) : node.body;
+          return ts.factory.updateFunctionExpression(
+            node,
+            node.modifiers,
+            node.asteriskToken,
+            newName ? ts.factory.createIdentifier(newName) : node.name,
+            node.typeParameters,
+            parameters,
+            node.type,
+            updatedBody
+          );
+        }
+      }
+      return ts.visitEachChild(node, visit, context);
+    };
+
+    function updateReturnStatement(body: ts.ConciseBody): ts.Block {
+      if (ts.isBlock(body)) {
+        const updatedStatements: ts.Statement[] = [];
+        for (const statement of body.statements) {
+          if (ts.isReturnStatement(statement) && statement.expression && ts.isJsxElement(statement.expression)) {
+            const jsxElement = statement.expression;
+            const openingElement = jsxElement.openingElement;
+            const tagName = openingElement.tagName.getText();
+            const newTagName = mapping[tagName];
+            if (newTagName) {
+              const updatedTagName = ts.factory.createIdentifier(newTagName);
+              const updatedOpeningElement = ts.factory.updateJsxOpeningElement(
+                openingElement,
+                updatedTagName,
+                openingElement.typeArguments,
+                openingElement.attributes
+              );
+              const updatedClosingElement = jsxElement.closingElement
+                ? ts.factory.updateJsxClosingElement(jsxElement.closingElement, updatedTagName)
+                : ts.factory.createJsxClosingElement(updatedTagName);
+              const updatedJsxElement = ts.factory.createJsxElement(
+                updatedOpeningElement,
+                jsxElement.children,
+                updatedClosingElement
+              );
+              const updatedStatement = ts.factory.createReturnStatement(updatedJsxElement);
+              updatedStatements.push(updatedStatement);
+            } else {
+              updatedStatements.push(statement);
+            }
+          } else {
+            updatedStatements.push(statement);
+          }
+        }
+        return ts.factory.updateBlock(body, updatedStatements);
+      }
+      if (
+        ts.isExpressionStatement(body) &&
+        ts.isReturnStatement(body.expression) &&
+        body.expression.expression &&
+        ts.isIdentifier(body.expression.expression)
+      ) {
+        const oldName = body.expression.expression.text;
+        const newName = mapping[oldName];
+        if (newName) {
+          const updatedExpression = ts.factory.createIdentifier(newName);
+          const updatedReturnStatement = ts.factory.createReturnStatement(updatedExpression);
+          return ts.factory.createBlock([updatedReturnStatement], true);
+        }
+      }
+      return ts.factory.createBlock([], true);
+    }
+    return (node) => ts.visitNode(node, visit);
+  };
+};

package/sourceFileTransformers/identifier.ts

@@ -0,0 +1,24 @@
+import ts from 'typescript';
+import { SourceFileTransformer } from '.';
+
+export const identifierTransformer: SourceFileTransformer = (mapping: Record<string, string>) => {
+  return (context) => {
+    const visit: ts.Visitor = (node) => {
+      if (ts.isIdentifier(node)) {
+        const identifierName = node.text;
+        let newIdentifierName = mapping[identifierName] || identifierName;
+
+        for (const [oldName, newName] of Object.entries(mapping)) {
+          if (identifierName.startsWith(oldName) || identifierName.endsWith(oldName)) {
+            newIdentifierName = identifierName.replace(oldName, newName);
+          }
+        }
+
+        return ts.factory.createIdentifier(newIdentifierName);
+      }
+
+      return ts.visitEachChild(node, visit, context);
+    };
+    return (node) => ts.visitNode(node, visit);
+  };
+};

package/sourceFileTransformers/import.ts

@@ -0,0 +1,103 @@
+import ts from 'typescript';
+import { SourceFileTransformer } from '.';
+
+export const importTransformer: SourceFileTransformer = (mapping: Record<string, string>) => {
+  return (context) => {
+    const visit: ts.Visitor = (node) => {
+      if (ts.isImportDeclaration(node)) {
+        let moduleSpecifier = node.moduleSpecifier.getText().slice(1, -1);
+        for (const [oldName, newName] of Object.entries(mapping)) {
+          if (moduleSpecifier.includes(oldName)) {
+            moduleSpecifier = moduleSpecifier.replace(oldName, newName);
+          }
+        }
+
+        if (node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+          const transformedBindings = node.importClause.namedBindings.elements.map((element) => {
+            let newElementName = element.name.text;
+
+            for (const [oldName, newName] of Object.entries(mapping)) {
+              if (newElementName.startsWith(oldName) || newElementName.endsWith(oldName)) {
+                newElementName = newElementName.replace(oldName, newName);
+              }
+            }
+
+            return ts.factory.updateImportSpecifier(
+              element,
+              false,
+              element.propertyName ? ts.factory.createIdentifier(newElementName) : undefined,
+              ts.factory.createIdentifier(newElementName)
+            );
+          });
+
+          const updatedImportClause = ts.factory.updateImportClause(
+            node.importClause,
+            node.importClause.isTypeOnly,
+            node.importClause.name,
+            ts.factory.createNamedImports(transformedBindings)
+          );
+
+          return ts.factory.updateImportDeclaration(
+            node,
+            node.decorators,
+            node.modifiers,
+            updatedImportClause,
+            ts.factory.createStringLiteral(moduleSpecifier),
+            undefined
+          );
+        }
+
+        return ts.factory.updateImportDeclaration(
+          node,
+          node.decorators,
+          node.modifiers,
+          node.importClause,
+          ts.factory.createStringLiteral(moduleSpecifier),
+          undefined
+        );
+      }
+      if (ts.isImportEqualsDeclaration(node)) {
+        let moduleSpecifier = node.moduleReference.getText().slice(1, -1);
+        for (const [oldName, newName] of Object.entries(mapping)) {
+          if (moduleSpecifier.includes(oldName)) {
+            moduleSpecifier = moduleSpecifier.replace(oldName, newName);
+          }
+        }
+
+        const updatedImportEqualsDeclaration = ts.factory.updateImportEqualsDeclaration(
+          node,
+          node.decorators,
+          node.modifiers,
+          node.isTypeOnly,
+          node.name,
+          ts.factory.createExternalModuleReference(ts.factory.createStringLiteral(moduleSpecifier))
+        );
+
+        return updatedImportEqualsDeclaration;
+      }
+
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'require') {
+        const [firstArg] = node.arguments;
+
+        if (ts.isStringLiteral(firstArg)) {
+          let moduleSpecifier = firstArg.text;
+
+          for (const [oldName, newName] of Object.entries(mapping)) {
+            if (moduleSpecifier.includes(oldName)) {
+              moduleSpecifier = moduleSpecifier.replace(oldName, newName);
+            }
+          }
+
+          const updatedArg = ts.factory.createStringLiteral(moduleSpecifier);
+          return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+            updatedArg,
+            ...node.arguments.slice(1),
+          ]);
+        }
+      }
+
+      return ts.visitEachChild(node, visit, context);
+    };
+    return (node) => ts.visitNode(node, visit);
+  };
+};

package/sourceFileTransformers/index.ts

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+
+export type SourceFileTransformer = (mapping: Record<string, string>) => ts.TransformerFactory<ts.SourceFile>;
+
+export { classNamesTransformer } from './class';
+export { interfaceNamesTransformer } from './interface';
+export { variableNamesTransformer } from './variable';
+export { functionNamesTransformer } from './function';
+export { typeAliasNamesTransformer } from './typeAlias';
+export { importTransformer } from './import';
+export { identifierTransformer } from './identifier';
+export { exportTransformer } from './export';
+export { transformSourceFile } from './transform';

package/sourceFileTransformers/interface.ts

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+
+export function interfaceNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {
+  return (context) => {
+    const { factory } = context;
+    const visit: ts.Visitor = (node) => {
+      if (ts.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 ts.visitEachChild(node, (child) => visit(child), context);
+    };
+    return (node) => ts.visitNode(node, visit);
+  };
+}

package/sourceFileTransformers/transform.ts

@@ -0,0 +1,100 @@
+import { Formatter } from '@teambit/formatter';
+import ts from 'typescript';
+import * as path from 'path';
+import { EmptyLineEncoder } from './empty-line-encoder';
+/**
+ * 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 async function transformSourceFile(
+  sourceFilePath: string,
+  sourceFileContent: string,
+  transformers: ts.TransformerFactory<ts.SourceFile>[],
+  formatter?: Formatter,
+  updates?: Record<string, string>
+): Promise<string> {
+  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();
+  sourceFileContent = encoder.encode(sourceFileContent);
+
+  const sourceFile = ts.createSourceFile(
+    sourceFilePath,
+    sourceFileContent,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TSX
+  );
+
+  const transformedResult: ts.TransformationResult<ts.SourceFile> = ts.transform<ts.SourceFile>(
+    sourceFile,
+    transformers
+  );
+  const transformedSourceFile: ts.SourceFile = transformedResult.transformed[0] as ts.SourceFile;
+
+  // 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: ts.Printer = ts.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?.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);
+//   };

package/sourceFileTransformers/typeAlias.ts

@@ -0,0 +1,28 @@
+import ts from 'typescript';
+
+export function typeAliasNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {
+  return (context) => {
+    const { factory } = context;
+    const visit: ts.Visitor = (node) => {
+      if (ts.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 ts.visitEachChild(node, (child) => visit(child), context);
+    };
+    return (node) => ts.visitNode(node, visit);
+  };
+}

package/sourceFileTransformers/variable.ts

@@ -0,0 +1,28 @@
+import ts from 'typescript';
+
+export function variableNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile> {
+  return (context) => {
+    const { factory } = context;
+    const visit: ts.Visitor = (node) => {
+      if (ts.isVariableDeclaration(node) && node.name.kind === ts.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 ts.visitEachChild(node, (child) => visit(child), context);
+    };
+    return (node) => ts.visitNode(node, visit);
+  };
+}