Minor refactoring

Author: fisker

src/ast-transform-visitors/array-expression.ts

@@ -8,5 +8,7 @@ export const visitLiteralArray = (
   transformer: NodeTransformer,
 ): babel.ArrayExpression => ({
   type: 'ArrayExpression',
-  elements: transformer.transformChildren<babel.Expression>(node.expressions),
+  elements: transformer.transformChildren<
+    babel.Expression | babel.SpreadElement
+  >(node.expressions),
 });

src/ast-transform-visitors/ast-with-source.ts

@@ -1,8 +1,9 @@
 import { type ASTWithSource } from '@angular/compiler';
+import type * as babel from '@babel/types';
 
 import { type NodeTransformer } from '../ast-transform/node-transformer.ts';
 
 export const visitASTWithSource = (
   node: ASTWithSource,
   transformer: NodeTransformer,
-) => transformer.transformChild(node.ast);
+) => transformer.transformChild<babel.Expression>(node.ast);

src/ast-transform-visitors/binary-expression.ts

@@ -33,7 +33,7 @@ export const visitBinary = (
   if (isAssignmentOperator(operator)) {
     return {
       type: 'AssignmentExpression',
-      left: left as babel.MemberExpression,
+      left: left as babel.AssignmentExpression['left'],
       right,
       operator: operator,
     };

src/ast-transform-visitors/chained-expression.ts

@@ -1,8 +1,8 @@
 import { type Chain } from '@angular/compiler';
 import type * as babel from '@babel/types';
 
-import type { NGChainedExpression } from '../types.ts';
 import { type NodeTransformer } from '../ast-transform/node-transformer.ts';
+import type { NGChainedExpression } from './node-types.ts';
 
 export const visitChain = (
   node: Chain,

src/ast-transform-visitors/interpolation.ts

@@ -1,4 +1,5 @@
 import { type Interpolation } from '@angular/compiler';
+import type * as babel from '@babel/types';
 
 import { type NodeTransformer } from '../ast-transform/node-transformer.ts';
 
@@ -13,5 +14,5 @@ export const visitInterpolation = (
     throw new Error("Unexpected 'Interpolation'");
   }
 
-  return transformer.transformChild(expressions[0]);
+  return transformer.transformChild<babel.Expression>(expressions[0]);
 };

src/ast-transform-visitors/member-expression.ts

@@ -59,7 +59,7 @@ const transformMemberExpression =
     } else {
       const isImplicitReceiver = receiver instanceof ImplicitReceiver;
       const { name, nameSpan } = node as PropertyRead | SafePropertyRead;
-      property = transformer.createNode<babel.Identifier>(
+      property = transformer.create<babel.Identifier>(
         { type: 'Identifier', name: name },
         nameSpan,
         isImplicitReceiver ? transformer.ancestors : [],

src/ast-transform-visitors/node-types.ts

@@ -0,0 +1,38 @@
+import type * as babel from '@babel/types';
+
+export type Range = [number, number];
+export type StartEnd = { start: number; end: number };
+
+export type LocationInformation = StartEnd & {
+  range: Range;
+  extra?: any;
+};
+
+export type NGBaseNode = LocationInformation & {
+  type: string;
+};
+
+export type CommentLine = babel.CommentLine & LocationInformation;
+
+export type NGOwnNode =
+  | NGEmptyExpression
+  | NGPipeExpression
+  | NGChainedExpression;
+
+export type NGNode = babel.Node | NGOwnNode;
+
+export interface NGEmptyExpression extends NGBaseNode {
+  type: 'NGEmptyExpression';
+}
+
+export interface NGPipeExpression extends NGBaseNode {
+  type: 'NGPipeExpression';
+  left: babel.Expression;
+  right: babel.Identifier;
+  arguments: babel.Expression[];
+}
+
+export interface NGChainedExpression extends NGBaseNode {
+  type: 'NGChainedExpression';
+  expressions: NGNode[];
+}

src/ast-transform-visitors/object-expression.ts

@@ -1,9 +1,9 @@
 import type * as angular from '@angular/compiler';
 import type * as babel from '@babel/types';
 
-import { type RawLocationInformation } from '../source.ts';
-import type { NGNode, Range } from '../types.ts';
 import { type NodeTransformer } from '../ast-transform/node-transformer.ts';
+import { type RawLocationInformation } from '../source.ts';
+import type { NGNode, Range } from './node-types.ts';
 
 export const visitLiteralMap = (
   node: angular.LiteralMap,
@@ -14,7 +14,10 @@ export const visitLiteralMap = (
     properties: Partial<T> & { type: T['type'] },
     location: RawLocationInformation = node,
   ) =>
-    transformer.create(properties, location, [node, ...transformer.ancestors]);
+    transformer.create<T>(properties, location, [
+      node,
+      ...transformer.ancestors,
+    ]);
 
   return {
     type: 'ObjectExpression',

src/ast-transform-visitors/parenthesized-expression.ts

@@ -1,8 +1,9 @@
 import { type ParenthesizedExpression } from '@angular/compiler';
+import type * as babel from '@babel/types';
 
 import { type NodeTransformer } from '../ast-transform/node-transformer.ts';
 
 export const visitParenthesizedExpression = (
   node: ParenthesizedExpression,
   transformer: NodeTransformer,
-) => transformer.transformChild(node.expression);
+) => transformer.transformChild<babel.Expression>(node.expression);

src/ast-transform-visitors/pipe-expression.ts

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