Merge pull request #7 from jaredmcateer/upgrade-typescript

feat: upgrade typescript

Author: jaredmcateer

package.json

@@ -28,7 +28,7 @@
     "@types/inquirer": "^7.3.0",
     "@types/jest": "^26.0.8",
     "@types/node": "^14.0.27",
-    "@types/prettier": "^2.0.2",
+    "@types/prettier": "^2.6.1",
     "@typescript-eslint/eslint-plugin": "^3.7.1",
     "@typescript-eslint/parser": "^3.7.1",
     "codecov": "^3.7.2",
@@ -42,7 +42,7 @@
     "prettier": "^2.6.2",
     "semantic-release": "^17.2.3",
     "ts-jest": "^26.1.4",
-    "typescript": "3.9.7",
+    "typescript": "^4.6.4",
     "vue": "^2.6.11"
   },
   "scripts": {

src/convert.ts

@@ -55,7 +55,8 @@ export function convertAST(
 
   log("output result code");
   const printer = tsModule.createPrinter();
-  const result = printer.printFile(tsModule.updateSourceFileNode(sourceFile, resultStatements));
+  const { factory } = tsModule;
+  const result = printer.printFile(factory.updateSourceFile(sourceFile, resultStatements));
 
   return result;
 }

src/file.ts

@@ -30,7 +30,7 @@ export function readVueSFCOrTsFile(filePath: string, options: UncouthOptions): F
   if (isVueFile(fileFsPath)) {
     const scriptContent = parseVueFile(options.vueTemplateCompiler, fileContent).script;
     if (scriptContent) {
-      log(`Readed Vue file: ${fileFsPath}`);
+      log(`Read Vue file: ${fileFsPath}`);
       return {
         fsPath: fileFsPath,
         kind: FileKind.VUE,
@@ -40,9 +40,9 @@ export function readVueSFCOrTsFile(filePath: string, options: UncouthOptions): F
         fileContent,
       };
     }
-    throw new Error("The Vue SFC don't have sciprt element.");
+    throw new Error("The Vue SFC doesn't have script element.");
   } else {
-    log(`Readed TS file: ${fileFsPath}`);
+    log(`Read TS file: ${fileFsPath}`);
     return {
       fsPath: fileFsPath,
       kind: FileKind.TS,

src/helpers/TsHelper.ts

@@ -0,0 +1,233 @@
+import ts from "typescript";
+import { UncouthOptions } from "../options";
+import { isString } from "../utils";
+
+export class TsHelper {
+  public module: typeof ts;
+  private compatible: boolean;
+
+  constructor(options: UncouthOptions) {
+    this.module = options.typescript;
+    this.compatible = options.compatible;
+  }
+
+  get factory(): ts.NodeFactory {
+    return this.module.factory;
+  }
+
+  namedImports(names: string[]): { named: string[]; external: string }[] {
+    return [
+      {
+        named: names,
+        external: this.compatible ? "@vue/composition-api" : "vue",
+      },
+    ];
+  }
+
+  createIdentifier(name: string): ts.Identifier {
+    return this.factory.createIdentifier(name);
+  }
+
+  createPropertyAccess(
+    expr: ts.Expression | string,
+    name: string | ts.MemberName
+  ): ts.PropertyAccessExpression {
+    const eIdentifier = isString(expr) ? this.createIdentifier(expr) : expr;
+    const nIdentifier = isString(name) ? this.createIdentifier(name) : name;
+    return this.factory.createPropertyAccessExpression(eIdentifier, nIdentifier);
+  }
+
+  createNonNullPropertyAccess(
+    expression: ts.Expression | string,
+    name: string | ts.MemberName
+  ): ts.NonNullExpression {
+    return this.factory.createNonNullExpression(this.createPropertyAccess(expression, name));
+  }
+
+  addTodoComment<T extends ts.Node>(node: T, comment: string, multiline: boolean): T {
+    const kind = multiline
+      ? this.module.SyntaxKind.MultiLineCommentTrivia
+      : this.module.SyntaxKind.SingleLineCommentTrivia;
+
+    return this.module.addSyntheticLeadingComment(node, kind, ` TODO: ${comment}`);
+  }
+
+  createObjectPropertyAssignment(
+    name: string | ts.Identifier,
+    properties: ts.ObjectLiteralElementLike[]
+  ): ts.PropertyAssignment {
+    name = isString(name) ? this.factory.createIdentifier(name) : name;
+    return this.factory.createPropertyAssignment(
+      name,
+      this.factory.createObjectLiteralExpression(properties, true)
+    );
+  }
+
+  createExpressionStatement(expression: ts.Expression): ts.ExpressionStatement;
+  /**
+   * Create a call expression and wrap in an expression statement
+   * @param expression
+   * @param typeArguments
+   * @param argumentsArray
+   */
+  createExpressionStatement(
+    expression: string | ts.Identifier,
+    typeArguments?: ts.TypeNode[],
+    argumentsArray?: ts.Expression[]
+  ): ts.ExpressionStatement;
+  createExpressionStatement(
+    expression: string | ts.Identifier | ts.Expression,
+    typeArguments?: ts.TypeNode[],
+    argumentsArray?: ts.Expression[]
+  ): ts.ExpressionStatement {
+    if (isString(expression) || ts.isIdentifier(expression)) {
+      expression = this.createCallExpression(expression, typeArguments, argumentsArray);
+    }
+    return this.factory.createExpressionStatement(expression);
+  }
+
+  copySyntheticComments<T extends ts.Node>(node: T, copyNode: ts.Node): T {
+    const fullText = copyNode.getSourceFile().getFullText();
+    const leadingComments = this.getLeadingComments(fullText, copyNode.pos);
+    const trailingComments = this.getTrailingComments(fullText, copyNode.end);
+
+    let result = node;
+    for (const { pos, end, kind, hasTrailingNewLine } of leadingComments) {
+      const text = this.getCommentText(fullText, { pos, end });
+      result = this.module.addSyntheticLeadingComment(result, kind, text, hasTrailingNewLine);
+    }
+
+    for (const { pos, end, kind, hasTrailingNewLine } of trailingComments) {
+      const text = this.getCommentText(fullText, { pos, end });
+      result = this.module.addSyntheticTrailingComment(result, kind, text, hasTrailingNewLine);
+    }
+
+    return node;
+  }
+
+  createThis(): ts.ThisExpression {
+    return this.factory.createThis();
+  }
+
+  createCallExpression(
+    expr: string | ts.Identifier | ts.PropertyAccessExpression,
+    typeArguments?: ts.TypeNode[],
+    argumentsArray?: ts.Expression[]
+  ): ts.CallExpression {
+    const expression = isString(expr) ? this.createIdentifier(expr) : expr;
+    return this.factory.createCallExpression(expression, typeArguments, argumentsArray);
+  }
+
+  createArrowFunctionFromNode(
+    node: ts.MethodDeclaration | ts.AccessorDeclaration,
+    bodyStatements?: ts.Statement[],
+    multiline?: boolean
+  ): ts.ArrowFunction {
+    const { modifiers, typeParameters, type, body, parameters } = node;
+    const rocketToken = this.factory.createToken(this.module.SyntaxKind.EqualsGreaterThanToken);
+    const fnBody = bodyStatements
+      ? this.factory.createBlock(bodyStatements, multiline)
+      : body ?? this.factory.createBlock([], multiline);
+
+    return this.factory.createArrowFunction(
+      modifiers,
+      typeParameters,
+      parameters,
+      type,
+      rocketToken,
+      fnBody
+    );
+  }
+
+  createConstStatement(
+    name: string | ts.BindingName,
+    expression: ts.Expression
+  ): ts.VariableStatement {
+    return this.factory.createVariableStatement(
+      undefined,
+      this.factory.createVariableDeclarationList(
+        [this.factory.createVariableDeclaration(name, undefined, undefined, expression)],
+        this.module.NodeFlags.Const
+      )
+    );
+  }
+
+  removeComments<T extends ts.Node>(node: T): T | ts.StringLiteral {
+    if (this.module.isStringLiteral(node)) {
+      return this.factory.createStringLiteral(node.text);
+    }
+
+    return node;
+  }
+
+  isPrimitiveType(returnType: ts.Type): boolean {
+    return (
+      !!(returnType.flags & this.module.TypeFlags.NumberLike) ||
+      !!(returnType.flags & this.module.TypeFlags.StringLike) ||
+      !!(returnType.flags & this.module.TypeFlags.BooleanLike) ||
+      !!(returnType.flags & this.module.TypeFlags.Null) ||
+      !!(returnType.flags & this.module.TypeFlags.Undefined)
+    );
+  }
+
+  makeIife(fn: ts.ArrowFunction): ts.CallExpression {
+    return this.factory.createCallExpression(
+      this.factory.createParenthesizedExpression(fn),
+      undefined,
+      []
+    );
+  }
+
+  createMethod(name: string, parameters: string[], body: ts.Statement[]): ts.MethodDeclaration {
+    const params = parameters.map((param) =>
+      this.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        undefined,
+        param,
+        undefined,
+        undefined,
+        undefined
+      )
+    );
+    return this.factory.createMethodDeclaration(
+      undefined,
+      undefined,
+      undefined,
+      name,
+      undefined,
+      undefined,
+      params,
+      undefined,
+      this.factory.createBlock(body, true)
+    );
+  }
+
+  private getLeadingComments(text: string, pos: number): ts.CommentRange[] {
+    return this.getCommentRange(text, pos, "Leading");
+  }
+
+  private getTrailingComments(text: string, pos: number): ts.CommentRange[] {
+    return this.getCommentRange(text, pos, "Trailing");
+  }
+
+  private getCommentRange(
+    text: string,
+    pos: number,
+    type: "Leading" | "Trailing"
+  ): ts.CommentRange[] {
+    const method = `get${type}CommentRanges` as const;
+    return this.module[method](text, pos) || [];
+  }
+
+  private getCommentText(text: string, { pos, end }: { pos: number; end: number }) {
+    return text
+      .slice(pos, end)
+      .replace(/\/\//g, "")
+      .replace(/\/\*/g, "")
+      .replace(/\*\//g, "")
+      .replace(/ {2}\* ?/g, "* ")
+      .replace(/ \*\//g, "*/")
+      .replace(/ {2}$/g, "");
+  }
+}