esrap 1.4.9 → 2.0.1

package/src/languages/ts/public.d.ts

@@ -0,0 +1,2 @@
+export * from './index';
+export { Comment } from '../types';

package/src/languages/tsx/index.js

@@ -0,0 +1,139 @@
+/** @import { TSESTree } from '@typescript-eslint/types' */
+/** @import { Visitors } from '../../types.js' */
+/** @import { TSOptions } from '../types.js' */
+import ts from '../ts/index.js';
+
+/** @typedef {TSESTree.Node} Node */
+
+/**
+ * @param {TSOptions} [options]
+ * @returns {Visitors<TSESTree.Node>}
+ */
+export default (options) => ({
+	...ts(options),
+
+	JSXElement(node, context) {
+		context.visit(node.openingElement);
+
+		if (node.children.length > 0) {
+			context.indent();
+		}
+
+		for (const child of node.children) {
+			context.visit(child);
+		}
+
+		if (node.children.length > 0) {
+			context.dedent();
+		}
+
+		if (node.closingElement) {
+			context.visit(node.closingElement);
+		}
+	},
+
+	JSXOpeningElement(node, context) {
+		context.write('<');
+
+		context.visit(node.name);
+
+		for (const attribute of node.attributes) {
+			context.write(' ');
+			context.visit(attribute);
+		}
+
+		if (node.selfClosing) {
+			context.write(' /');
+		}
+
+		context.write('>');
+	},
+
+	JSXClosingElement(node, context) {
+		context.write('</');
+
+		context.visit(node.name);
+
+		context.write('>');
+	},
+
+	JSXNamespacedName(node, context) {
+		context.visit(node.namespace);
+		context.write(':');
+		context.visit(node.name);
+	},
+
+	JSXIdentifier(node, context) {
+		context.write(node.name, node);
+	},
+
+	JSXMemberExpression(node, context) {
+		context.visit(node.object);
+		context.write('.');
+		context.visit(node.property);
+	},
+
+	JSXText(node, context) {
+		context.write(node.value, node);
+	},
+
+	JSXAttribute(node, context) {
+		context.visit(node.name);
+		if (node.value) {
+			context.write('=');
+			context.visit(node.value);
+		}
+	},
+
+	JSXEmptyExpression(node, context) {},
+
+	JSXFragment(node, context) {
+		context.visit(node.openingFragment);
+
+		if (node.children.length > 0) {
+			context.indent();
+		}
+
+		for (const child of node.children) {
+			context.visit(child);
+		}
+
+		if (node.children.length > 0) {
+			context.dedent();
+		}
+
+		context.visit(node.closingFragment);
+	},
+
+	JSXOpeningFragment(node, context) {
+		context.write('<>');
+	},
+
+	JSXClosingFragment(node, context) {
+		context.write('</>');
+	},
+
+	JSXExpressionContainer(node, context) {
+		context.write('{');
+
+		context.visit(node.expression);
+
+		context.write('}');
+	},
+
+	JSXSpreadChild(node, context) {
+		context.write('{...');
+
+		context.visit(node.expression);
+
+		context.write('}');
+	},
+
+	JSXSpreadAttribute(node, context) {
+		context.write('{...');
+
+		context.visit(node.argument);
+
+		context.write('}');
+	}
+});

package/src/languages/tsx/public.d.ts

@@ -0,0 +1,2 @@
+export * from './index';
+export { Comment } from '../types';

package/src/languages/types.d.ts

@@ -0,0 +1,22 @@
+export type TSOptions = {
+	quotes?: 'double' | 'single';
+	comments?: Comment[];
+};
+
+interface Position {
+	line: number;
+	column: number;
+}
+
+// this exists in TSESTree but because of the inanity around enums
+// it's easier to do this ourselves
+export interface Comment {
+	type: 'Line' | 'Block';
+	value: string;
+	start?: number;
+	end?: number;
+	loc: {
+		start: Position;
+		end: Position;
+	};
+}

package/src/public.d.ts

@@ -1,2 +1,2 @@
-export { PrintOptions } from './types';
+export { PrintOptions, Visitors } from './types';
 export * from './index';

package/src/types.d.ts

@@ -1,11 +1,28 @@
 import { TSESTree } from '@typescript-eslint/types';
+import { Context } from 'esrap';
+
+export type BaseNode = {
+	type: string;
+	loc?: null | {
+		start: { line: number; column: number };
+		end: { line: number; column: number };
+	};
+};
 
-type Handler<T> = (node: T, state: State) => undefined;
+type NodeOf<T extends string, X> = X extends { type: T } ? X : never;
 
-export type Handlers = {
-	[T in TSESTree.Node['type']]: Handler<Extract<TSESTree.Node, { type: T }>>;
+type SpecialisedVisitors<T extends BaseNode> = {
+	[K in T['type']]?: Visitor<NodeOf<K, T>>;
 };
 
+export type Visitor<T> = (node: T, context: Context) => void;
+
+export type Visitors<T extends BaseNode = BaseNode> = T['type'] extends '_'
+	? never
+	: SpecialisedVisitors<T> & { _?: (node: T, context: Context, visit: (node: T) => void) => void };
+
+export { Context };
+
 export type TypeAnnotationNodes =
 	| TSESTree.TypeNode
 	| TSESTree.TypeElement
@@ -24,54 +41,22 @@ type TSExpressionWithTypeArguments = {
 	expression: any;
 };
 
-// `@typescript-eslint/types` differs from the official `estree` spec by handling
-// comments differently. This is a node which we can use to ensure type saftey.
-export type NodeWithComments = {
-	leadingComments?: TSESTree.Comment[] | undefined;
-	trailingComments?: TSESTree.Comment[] | undefined;
-} & TSESTree.Node;
-
-export interface State {
-	commands: Command[];
-	comments: TSESTree.Comment[];
-	multiline: boolean;
-	quote: "'" | '"';
-}
-
 export interface Location {
 	type: 'Location';
 	line: number;
 	column: number;
 }
 
-export interface Newline {
-	type: 'Newline';
-}
-
-export interface Indent {
-	type: 'Indent';
-}
-
-export interface Dedent {
-	type: 'Dedent';
-}
-
 export interface IndentChange {
 	type: 'IndentChange';
 	offset: number;
 }
 
-export interface CommentChunk {
-	type: 'Comment';
-	comment: TSESTree.Comment;
-}
-
-export type Command = string | Location | Newline | Indent | Dedent | CommentChunk | Command[];
+export type Command = string | number | Location | Command[];
 
 export interface PrintOptions {
 	sourceMapSource?: string;
 	sourceMapContent?: string;
 	sourceMapEncodeMappings?: boolean; // default true
 	indent?: string; // default tab
-	quotes?: 'single' | 'double'; // default single
 }

package/types/index.d.ts

@@ -1,21 +1,169 @@
 declare module 'esrap' {
+	type BaseNode = {
+		type: string;
+		loc?: null | {
+			start: { line: number; column: number };
+			end: { line: number; column: number };
+		};
+	};
+
+	type NodeOf<T extends string, X> = X extends { type: T } ? X : never;
+
+	type SpecialisedVisitors<T extends BaseNode> = {
+		[K in T['type']]?: Visitor<NodeOf<K, T>>;
+	};
+
+	type Visitor<T> = (node: T, context: Context) => void;
+
+	export type Visitors<T extends BaseNode = BaseNode> = T['type'] extends '_'
+		? never
+		: SpecialisedVisitors<T> & { _?: (node: T, context: Context, visit: (node: T) => void) => void };
+
+	interface Location {
+		type: 'Location';
+		line: number;
+		column: number;
+	}
+
+	type Command = string | number | Location | Command[];
+
 	export interface PrintOptions {
 		sourceMapSource?: string;
 		sourceMapContent?: string;
 		sourceMapEncodeMappings?: boolean; // default true
 		indent?: string; // default tab
-		quotes?: 'single' | 'double'; // default single
 	}
 	/**
 	 * @returns // TODO
 	 */
-	export function print(node: {
-		type: string;
-		[key: string]: any;
-	}, opts?: PrintOptions): {
+	export function print<T extends BaseNode = BaseNode>(node: T, visitors: Visitors<T>, opts?: PrintOptions): {
 		code: string;
 		map: any;
 	};
+	export class Context {
+		
+		constructor(visitors: Visitors, commands?: Command[]);
+		multiline: boolean;
+		indent(): void;
+		dedent(): void;
+		margin(): void;
+		newline(): void;
+		
+		append(context: Context): void;
+		
+		write(content: string, node?: BaseNode): void;
+		
+		location(line: number, column: number): void;
+		
+		visit(node: {
+			type: string;
+		}): void;
+		empty(): boolean;
+		measure(): number;
+		"new"(): Context;
+		#private;
+	}
+
+	export {};
+}
+
+declare module 'esrap/languages/ts' {
+	import type { TSESTree } from '@typescript-eslint/types';
+	import type { Context } from 'esrap';
+	export const EXPRESSIONS_PRECEDENCE: Record<TSESTree.Expression["type"] | "Super" | "RestElement", number>;
+	export default function _default(options?: TSOptions): Visitors<TSESTree.Node>;
+	export type Node = TSESTree.Node;
+	type TSOptions = {
+		quotes?: 'double' | 'single';
+		comments?: Comment[];
+	};
+
+	interface Position {
+		line: number;
+		column: number;
+	}
+
+	// this exists in TSESTree but because of the inanity around enums
+	// it's easier to do this ourselves
+	export interface Comment {
+		type: 'Line' | 'Block';
+		value: string;
+		start?: number;
+		end?: number;
+		loc: {
+			start: Position;
+			end: Position;
+		};
+	}
+	type BaseNode = {
+		type: string;
+		loc?: null | {
+			start: { line: number; column: number };
+			end: { line: number; column: number };
+		};
+	};
+
+	type NodeOf<T extends string, X> = X extends { type: T } ? X : never;
+
+	type SpecialisedVisitors<T extends BaseNode> = {
+		[K in T['type']]?: Visitor<NodeOf<K, T>>;
+	};
+
+	type Visitor<T> = (node: T, context: Context) => void;
+
+	type Visitors<T extends BaseNode = BaseNode> = T['type'] extends '_'
+		? never
+		: SpecialisedVisitors<T> & { _?: (node: T, context: Context, visit: (node: T) => void) => void };
+
+	export {};
+}
+
+declare module 'esrap/languages/tsx' {
+	import type { TSESTree } from '@typescript-eslint/types';
+	import type { Context } from 'esrap';
+	export default function _default(options?: TSOptions): Visitors<TSESTree.Node>;
+	export type Node = TSESTree.Node;
+	type TSOptions = {
+		quotes?: 'double' | 'single';
+		comments?: Comment[];
+	};
+
+	interface Position {
+		line: number;
+		column: number;
+	}
+
+	// this exists in TSESTree but because of the inanity around enums
+	// it's easier to do this ourselves
+	export interface Comment {
+		type: 'Line' | 'Block';
+		value: string;
+		start?: number;
+		end?: number;
+		loc: {
+			start: Position;
+			end: Position;
+		};
+	}
+	type BaseNode = {
+		type: string;
+		loc?: null | {
+			start: { line: number; column: number };
+			end: { line: number; column: number };
+		};
+	};
+
+	type NodeOf<T extends string, X> = X extends { type: T } ? X : never;
+
+	type SpecialisedVisitors<T extends BaseNode> = {
+		[K in T['type']]?: Visitor<NodeOf<K, T>>;
+	};
+
+	type Visitor<T> = (node: T, context: Context) => void;
+
+	type Visitors<T extends BaseNode = BaseNode> = T['type'] extends '_'
+		? never
+		: SpecialisedVisitors<T> & { _?: (node: T, context: Context, visit: (node: T) => void) => void };
 
 	export {};
 }

package/types/index.d.ts.map

@@ -2,17 +2,38 @@
 	"version": 3,
 	"file": "index.d.ts",
 	"names": [
+		"BaseNode",
+		"NodeOf",
+		"SpecialisedVisitors",
+		"Visitor",
+		"Visitors",
+		"Location",
+		"Command",
 		"PrintOptions",
-		"print"
+		"print",
+		"Context",
+		"EXPRESSIONS_PRECEDENCE",
+		"Node",
+		"TSOptions",
+		"Position",
+		"Comment"
 	],
 	"sources": [
 		"../src/types.d.ts",
-		"../src/index.js"
+		"../src/index.js",
+		"../src/context.js",
+		"../src/languages/ts/index.js",
+		"../src/languages/types.d.ts",
+		"../src/languages/tsx/index.js"
 	],
 	"sourcesContent": [
+		null,
+		null,
+		null,
+		null,
 		null,
 		null
 	],
-	"mappings": ";kBAsEiBA,YAAYA;;;;;;;;;;iBC/CbC,KAAKA",
+	"mappings": ";MAGYA,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;aAEPC,QAAQA;;;;WAwBHC,QAAQA;;;;;;MAWbC,OAAOA;;kBAEFC,YAAYA;;;;;;;;;iBCHbC,KAAKA;;;;cC7CRC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCAPC,sBAAsBA;;aAHZC,IAAIA;MCLfC,SAASA;;;;;WAKXC,QAAQA;;;;;;;kBAODC,OAAOA;;;;;;;;;;MJTZd,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;MAEPC,QAAQA;;;;;;;;;;;aKdGO,IAAIA;MDLfC,SAASA;;;;;WAKXC,QAAQA;;;;;;;kBAODC,OAAOA;;;;;;;;;;MJTZd,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;MAEPC,QAAQA",
 	"ignoreList": []
 }