Rewrite

Author: fisker

src/transforms/transform-array-expression.ts

@@ -0,0 +1,12 @@
+import { type LiteralArray } from '@angular/compiler';
+import type * as babel from '@babel/types';
+
+import { type Transformer } from '../transform-ast.ts';
+
+export const visitLiteralArray = (
+  node: LiteralArray,
+  transformer: Transformer,
+): babel.ArrayExpression => ({
+  type: 'ArrayExpression',
+  elements: transformer.transformChildren<babel.Expression>(node.expressions),
+});

src/transforms/transform-chained-expression.ts

@@ -0,0 +1,15 @@
+import { type Chain } from '@angular/compiler';
+import type * as babel from '@babel/types';
+
+import { type Transformer } from '../transform-ast.ts';
+import type { NGChainedExpression } from '../types.ts';
+
+export const visitChain = (
+  node: Chain,
+  transformer: Transformer,
+): Omit<NGChainedExpression, 'start' | 'end' | 'range'> => ({
+  type: 'NGChainedExpression',
+  expressions: transformer.transformChildren<babel.Expression>(
+    node.expressions,
+  ),
+});

src/transforms/transform-interpolation.ts

@@ -0,0 +1,17 @@
+import { type Interpolation } from '@angular/compiler';
+
+import { type Transformer } from '../transform-ast.ts';
+
+export const visitInterpolation = (
+  node: Interpolation,
+  transformer: Transformer,
+) => {
+  const { expressions } = node;
+
+  /* c8 ignore next 3 @preserve */
+  if (expressions.length !== 1) {
+    throw new Error("Unexpected 'Interpolation'");
+  }
+
+  return transformer.transformChild(expressions[0]);
+};

src/transforms/transform-non-null-expression.ts

@@ -0,0 +1,12 @@
+import { type NonNullAssert } from '@angular/compiler';
+import type * as babel from '@babel/types';
+
+import { type Transformer } from '../transform-ast.ts';
+
+export const visitNonNullAssert = (
+  node: NonNullAssert,
+  transformer: Transformer,
+): babel.TSNonNullExpression => ({
+  type: 'TSNonNullExpression',
+  expression: transformer.transformChild<babel.Expression>(node.expression),
+});

src/transforms/transform-parenthesized-expression.ts

@@ -0,0 +1,8 @@
+import { type ParenthesizedExpression } from '@angular/compiler';
+
+import { type Transformer } from '../transform-ast.ts';
+
+export const visitParenthesizedExpression = (
+  node: ParenthesizedExpression,
+  transformer: Transformer,
+) => transformer.transformChild(node.expression);

src/transforms/transform-pipe-expression.ts

@@ -0,0 +1,18 @@
+import { type BindingPipe } from '@angular/compiler';
+import type * as babel from '@babel/types';
+
+import { type Transformer } from '../transform-ast.ts';
+import type { NGPipeExpression } from '../types.ts';
+
+export const visitPipe = (
+  node: BindingPipe,
+  transformer: Transformer,
+): Omit<NGPipeExpression, 'start' | 'end' | 'range'> => ({
+  type: 'NGPipeExpression',
+  left: transformer.transformChild<babel.Expression>(node.exp),
+  right: transformer.createNode<babel.Identifier>(
+    { type: 'Identifier', name: node.name },
+    node.nameSpan,
+  ),
+  arguments: transformer.transformChildren<babel.Expression>(node.args),
+});

src/transforms/transform-this-expression.ts

@@ -0,0 +1,5 @@
+import type * as babel from '@babel/types';
+
+export const visitThisReceiver = (): babel.ThisExpression => ({
+  type: 'ThisExpression',
+});

src/transforms/transforms.ts

@@ -0,0 +1,16 @@
+export * from './transform-array-expression.ts';
+export * from './transform-binary-expression.ts';
+export * from './transform-call-expression.ts';
+export * from './transform-chained-expression.ts';
+export * from './transform-conditional-expression.ts';
+export * from './transform-interpolation.ts';
+export * from './transform-literal.ts';
+export * from './transform-member-expression.ts';
+export * from './transform-non-null-expression.ts';
+export * from './transform-object-expression.ts';
+export * from './transform-parenthesized-expression.ts';
+export * from './transform-pipe-expression.ts';
+export * from './transform-template-literal.ts';
+export * from './transform-this-expression.ts';
+export * from './transform-unary-expression.ts';
+export * from './transform-unexpected-node.ts';

src/transforms/visitor.ts

@@ -1,130 +1,7 @@
-import type * as angular from '@angular/compiler';
-import type * as babel from '@babel/types';
+import { type AstVisitor as AngularAstVisitor } from '@angular/compiler';
 
-import { type Transformer } from '../transform-ast.ts';
-import type { NGChainedExpression, NGPipeExpression } from '../types.ts';
-import { visitBinary } from './transform-binary-expression.ts';
-import { visitCall, visitSafeCall } from './transform-call-expression.ts';
-import { visitConditional } from './transform-conditional-expression.ts';
-import {
-  visitLiteralPrimitive,
-  visitRegularExpressionLiteral,
-} from './transform-literal.ts';
-import {
-  visitKeyedRead,
-  visitPropertyRead,
-  visitSafeKeyedRead,
-  visitSafePropertyRead,
-} from './transform-member-expression.ts';
-import { visitLiteralMap } from './transform-object-expression.ts';
-import {
-  visitTaggedTemplateLiteral,
-  visitTemplateLiteral,
-  visitTemplateLiteralElement,
-} from './transform-template-literal.ts';
-import {
-  visitPrefixNot,
-  visitTypeofExpression,
-  visitUnary,
-  visitVoidExpression,
-} from './transform-unary-expression.ts';
-import {
-  visitASTWithSource,
-  visitImplicitReceiver,
-} from './transform-unexpected-node.ts';
+import * as transforms from './transforms.ts';
 
-type AstVisitor = Required<Omit<angular.AstVisitor, 'visit'>>;
+type AstVisitor = Required<Omit<AngularAstVisitor, 'visit'>>;
 
-export const transformVisitor: AstVisitor = {
-  visitCall,
-  visitSafeCall,
-
-  visitKeyedRead,
-  visitPropertyRead,
-  visitSafeKeyedRead,
-  visitSafePropertyRead,
-
-  visitPrefixNot,
-  visitTypeofExpression,
-  visitVoidExpression,
-  visitUnary,
-
-  visitBinary,
-
-  visitLiteralMap,
-
-  visitLiteralPrimitive,
-  visitRegularExpressionLiteral,
-
-  visitTaggedTemplateLiteral,
-  visitTemplateLiteral,
-  visitTemplateLiteralElement,
-
-  visitConditional,
-
-  visitPipe(
-    node: angular.BindingPipe,
-    transformer: Transformer,
-  ): Omit<NGPipeExpression, 'start' | 'end' | 'range'> {
-    return {
-      type: 'NGPipeExpression',
-      left: transformer.transformChild<babel.Expression>(node.exp),
-      right: transformer.createNode<babel.Identifier>(
-        { type: 'Identifier', name: node.name },
-        node.nameSpan,
-      ),
-      arguments: transformer.transformChildren<babel.Expression>(node.args),
-    };
-  },
-
-  visitChain(
-    node: angular.Chain,
-    transformer: Transformer,
-  ): Omit<NGChainedExpression, 'start' | 'end' | 'range'> {
-    return {
-      type: 'NGChainedExpression',
-      expressions: transformer.transformChildren<babel.Expression>(
-        node.expressions,
-      ),
-    };
-  },
-
-  visitThisReceiver: (): babel.ThisExpression => ({ type: 'ThisExpression' }),
-
-  visitLiteralArray: (
-    node: angular.LiteralArray,
-    transformer: Transformer,
-  ): babel.ArrayExpression => ({
-    type: 'ArrayExpression',
-    elements: transformer.transformChildren<babel.Expression>(node.expressions),
-  }),
-
-  visitNonNullAssert: (
-    node: angular.NonNullAssert,
-    transformer: Transformer,
-  ): babel.TSNonNullExpression => ({
-    type: 'TSNonNullExpression',
-    expression: transformer.transformChild<babel.Expression>(node.expression),
-  }),
-
-  visitParenthesizedExpression(
-    node: angular.ParenthesizedExpression,
-    transformer: Transformer,
-  ) {
-    return transformer.transformChild(node.expression);
-  },
-
-  visitInterpolation(node: angular.Interpolation, transformer: Transformer) {
-    const { expressions } = node;
-
-    /* c8 ignore next 3 @preserve */
-    if (expressions.length !== 1) {
-      throw new Error("Unexpected 'Interpolation'");
-    }
-
-    return transformer.transformChild(expressions[0]);
-  },
-
-  visitASTWithSource,
-  visitImplicitReceiver,
-};
+export const transformVisitor: AstVisitor = transforms;