Refactor

Author: fisker

src/transform-visitor.ts

@@ -2,42 +2,43 @@ import * as angular from '@angular/compiler';
 import type * as babel from '@babel/types';
 
 import { type Transformer } from './transform-ast.ts';
+import { visitCall, visitSafeCall } from './transforms/transform-call.ts';
+import {
+  visitKeyedRead,
+  visitPropertyRead,
+  visitSafeKeyedRead,
+  visitSafePropertyRead,
+} from './transforms/transform-member-expression.ts';
+import {
+  visitPrefixNot,
+  visitTypeofExpression,
+  visitUnary,
+  visitVoidExpression,
+} from './transforms/transform-unary-expression.ts';
 import type {
   NGChainedExpression,
   NGNode,
   NGPipeExpression,
   RawNGSpan,
 } from './types.ts';
 
-function isParenthesized(node: NGNode) {
-  return Boolean(node.extra?.parenthesized);
-}
-
-function isOptionalObjectOrCallee(node: NGNode): boolean {
-  if (node.type === 'TSNonNullExpression' && !isParenthesized(node)) {
-    return isOptionalObjectOrCallee(node.expression);
-  }
-
-  return (
-    (node.type === 'OptionalCallExpression' ||
-      node.type === 'OptionalMemberExpression') &&
-    !isParenthesized(node)
-  );
-}
-
 type AstVisitor = Required<
   Omit<angular.AstVisitor, 'visit' | 'visitASTWithSource'>
 >;
 
 export const transformVisitor: AstVisitor = {
-  visitUnary(node: angular.Unary, transformer: Transformer) {
-    return transformer.createNode<babel.UnaryExpression>({
-      type: 'UnaryExpression',
-      prefix: true,
-      argument: transformer.transformChild<babel.Expression>(node.expr),
-      operator: node.operator as '-' | '+',
-    });
-  },
+  visitCall,
+  visitSafeCall,
+
+  visitKeyedRead,
+  visitPropertyRead,
+  visitSafeKeyedRead,
+  visitSafePropertyRead,
+
+  visitPrefixNot,
+  visitTypeofExpression,
+  visitVoidExpression,
+  visitUnary,
 
   visitBinary(node: angular.Binary, transformer: Transformer) {
     const { operation: operator } = node;
@@ -219,48 +220,6 @@ export const transformVisitor: AstVisitor = {
     });
   },
 
-  visitPrefixNot(node: angular.PrefixNot, transformer: Transformer) {
-    return transformer.createNode<babel.UnaryExpression>(
-      {
-        type: 'UnaryExpression',
-        prefix: true,
-        operator: '!',
-        argument: transformer.transformChild<babel.Expression>(node.expression),
-      },
-      node.sourceSpan,
-    );
-  },
-
-  visitTypeofExpression(
-    node: angular.TypeofExpression,
-    transformer: Transformer,
-  ) {
-    return transformer.createNode<babel.UnaryExpression>(
-      {
-        type: 'UnaryExpression',
-        prefix: true,
-        operator: 'typeof',
-        argument: transformer.transformChild<babel.Expression>(node.expression),
-      },
-      node.sourceSpan,
-    );
-  },
-
-  visitVoidExpression(
-    node: angular.TypeofExpression,
-    transformer: Transformer,
-  ) {
-    return transformer.createNode<babel.UnaryExpression>(
-      {
-        type: 'UnaryExpression',
-        prefix: true,
-        operator: 'void',
-        argument: transformer.transformChild<babel.Expression>(node.expression),
-      },
-      node.sourceSpan,
-    );
-  },
-
   visitTaggedTemplateLiteral(
     node: angular.TaggedTemplateLiteral,
     transformer: Transformer,
@@ -314,36 +273,6 @@ export const transformVisitor: AstVisitor = {
     return transformer.transformChild(node.expression);
   },
 
-  visitKeyedRead(node: angular.KeyedRead, transformer: Transformer) {
-    return transformMemberExpression(node, transformer, { computed: true });
-  },
-
-  visitSafeKeyedRead(node: angular.SafeKeyedRead, transformer: Transformer) {
-    return transformMemberExpression(node, transformer, {
-      computed: true,
-      optional: true,
-    });
-  },
-
-  visitPropertyRead(node: angular.PropertyRead, transformer: Transformer) {
-    return transformMemberExpression(node, transformer);
-  },
-
-  visitSafePropertyRead(
-    node: angular.SafePropertyRead,
-    transformer: Transformer,
-  ) {
-    return transformMemberExpression(node, transformer, { optional: true });
-  },
-
-  visitCall(node: angular.Call, transformer: Transformer) {
-    return transformCall(node, transformer);
-  },
-
-  visitSafeCall(node: angular.SafeCall, transformer: Transformer) {
-    return transformCall(node, transformer, { optional: true });
-  },
-
   visitInterpolation(node: angular.Interpolation, transformer: Transformer) {
     const { expressions } = node;
 
@@ -357,85 +286,3 @@ export const transformVisitor: AstVisitor = {
 
   visitImplicitReceiver() {},
 };
-
-function transformCall(
-  node: angular.Call | angular.SafeCall,
-  transformer: Transformer,
-  { optional = false } = {},
-) {
-  const arguments_ = transformer.transformChildren<babel.Expression>(node.args);
-  const callee = transformer.transformChild<babel.Expression>(node.receiver);
-  const isOptionalReceiver = isOptionalObjectOrCallee(callee);
-  const nodeType =
-    optional || isOptionalReceiver
-      ? 'OptionalCallExpression'
-      : 'CallExpression';
-  return transformer.createNode<
-    babel.CallExpression | babel.OptionalCallExpression
-  >({
-    type: nodeType,
-    callee,
-    arguments: arguments_,
-    ...(nodeType === 'OptionalCallExpression' ? { optional } : undefined),
-  });
-}
-
-function transformMemberExpression(
-  node:
-    | angular.KeyedRead
-    | angular.SafeKeyedRead
-    | angular.PropertyRead
-    | angular.SafePropertyRead,
-  transformer: Transformer,
-) {
-  const { receiver } = node;
-  const object = transformer.transformChild<babel.Expression>(receiver);
-  const computed =
-    node instanceof angular.KeyedRead || node instanceof angular.SafeKeyedRead;
-  const optional =
-    node instanceof angular.SafeKeyedRead ||
-    node instanceof angular.SafePropertyRead;
-
-  let property;
-  if (computed) {
-    property = transformer.transformChild<babel.Expression>(node.key);
-  } else {
-    property = transformer.createNode<babel.Identifier>(
-      { type: 'Identifier', name: node.name },
-      node.nameSpan,
-      object ? [] : transformer.ancestors,
-    );
-  }
-
-  if (!object) {
-    return property;
-  }
-
-  const isOptionalObject = isOptionalObjectOrCallee(object);
-
-  if (optional || isOptionalObject) {
-    return transformer.createNode<babel.OptionalMemberExpression>({
-      type: 'OptionalMemberExpression',
-      optional: optional || !isOptionalObject,
-      computed,
-      property,
-      object,
-    });
-  }
-
-  if (computed) {
-    return transformer.createNode<babel.MemberExpressionComputed>({
-      type: 'MemberExpression',
-      property,
-      object,
-      computed: true,
-    });
-  }
-
-  return transformer.createNode<babel.MemberExpressionNonComputed>({
-    type: 'MemberExpression',
-    object,
-    property: property as babel.MemberExpressionNonComputed['property'],
-    computed: false,
-  });
-}

src/transform.ts

@@ -10,14 +10,7 @@ function transformAstResult({
   text,
   comments,
 }: AstParseResult) {
-  try {
-    return Object.assign(transformNode(ast, text), { comments });
-  } catch {
-    console.log({
-      ast,
-      es: transformNode(ast, text),
-    });
-  }
+  return Object.assign(transformNode(ast, text), { comments });
 }
 
 function transformMicrosyntaxResult({

src/transforms/transform-call.ts

@@ -0,0 +1,44 @@
+import { type Call, type SafeCall } from '@angular/compiler';
+import type * as babel from '@babel/types';
+
+import { type Transformer } from '../transform-ast.ts';
+import { isOptionalObjectOrCallee } from './utilities.ts';
+
+const callOptions = { optional: false } as const;
+const safeCallOptions = { optional: true } as const;
+
+type VisitorCall = {
+  node: Call;
+  options: typeof callOptions;
+};
+type VisitorSafeCall = {
+  node: SafeCall;
+  options: typeof safeCallOptions;
+};
+
+const transformCall =
+  <Visitor extends VisitorCall | VisitorSafeCall>({
+    optional,
+  }: Visitor['options']) =>
+  (node: Visitor['node'], transformer: Transformer) => {
+    const arguments_ = transformer.transformChildren<babel.Expression>(
+      node.args,
+    );
+    const callee = transformer.transformChild<babel.Expression>(node.receiver);
+    const isOptionalReceiver = isOptionalObjectOrCallee(callee);
+    const nodeType =
+      optional || isOptionalReceiver
+        ? 'OptionalCallExpression'
+        : 'CallExpression';
+    return transformer.createNode<
+      babel.CallExpression | babel.OptionalCallExpression
+    >({
+      type: nodeType,
+      callee,
+      arguments: arguments_,
+      ...(nodeType === 'OptionalCallExpression' ? { optional } : undefined),
+    });
+  };
+
+export const visitCall = transformCall<VisitorCall>(callOptions);
+export const visitSafeCall = transformCall<VisitorSafeCall>(safeCallOptions);