esrap 1.1.1 → 1.2.0

package/src/index.js

@@ -39,10 +39,14 @@ export function print(node, opts = {}) {
 		);
 	}
 
-	const chunks = handle(node, {
-		indent: '',
-		comments: []
-	});
+	/** @type {import('./types').State} */
+	const state = {
+		commands: [],
+		comments: [],
+		multiline: false
+	};
+
+	handle(node, state);
 
 	/** @typedef {[number, number, number, number]} Segment */
 
@@ -55,22 +59,12 @@ export function print(node, opts = {}) {
 	/** @type {Segment[]} */
 	let current_line = [];
 
-	for (let i = 0; i < chunks.length; i += 1) {
-		const chunk = chunks[i];
-
-		code += chunk.content;
-
-		if (chunk.loc) {
-			current_line.push([
-				current_column,
-				0, // source index is always zero
-				chunk.loc.start.line - 1,
-				chunk.loc.start.column
-			]);
-		}
+	/** @param {string} str */
+	function append(str) {
+		code += str;
 
-		for (let i = 0; i < chunk.content.length; i += 1) {
-			if (chunk.content[i] === '\n') {
+		for (let i = 0; i < str.length; i += 1) {
+			if (str[i] === '\n') {
 				mappings.push(current_line);
 				current_line = [];
 				current_column = 0;
@@ -78,17 +72,77 @@ export function print(node, opts = {}) {
 				current_column += 1;
 			}
 		}
+	}
+
+	let newline = '\n';
+
+	/** @param {import('./types').Command} command */
+	function run(command) {
+		if (typeof command === 'string') {
+			append(command);
+			return;
+		}
 
-		if (chunk.loc) {
-			current_line.push([
-				current_column,
-				0, // source index is always zero
-				chunk.loc.end.line - 1,
-				chunk.loc.end.column
-			]);
+		switch (command.type) {
+			case 'Chunk':
+				const loc = command.loc;
+
+				if (loc) {
+					current_line.push([
+						current_column,
+						0, // source index is always zero
+						loc.start.line - 1,
+						loc.start.column
+					]);
+				}
+
+				append(command.content);
+
+				if (loc) {
+					current_line.push([
+						current_column,
+						0, // source index is always zero
+						loc.end.line - 1,
+						loc.end.column
+					]);
+				}
+
+				break;
+
+			case 'Newline':
+				append(newline);
+				break;
+
+			case 'Indent':
+				newline += '\t';
+				break;
+
+			case 'Dedent':
+				newline = newline.slice(0, -1);
+				break;
+
+			case 'Sequence':
+				for (let i = 0; i < command.children.length; i += 1) {
+					run(command.children[i]);
+				}
+
+				break;
+
+			case 'Comment':
+				if (command.comment.type === 'Line') {
+					append(`//${command.comment.value}`);
+				} else {
+					append(`/*${command.comment.value.replace(/\n/g, newline)}*/`);
+				}
+
+				break;
 		}
 	}
 
+	for (let i = 0; i < state.commands.length; i += 1) {
+		run(state.commands[i]);
+	}
+
 	mappings.push(current_line);
 
 	const map = {

package/src/types.d.ts

@@ -2,22 +2,52 @@ import { Comment, Node } from 'estree';
 
 type NodeOf<T extends string, X> = X extends { type: T } ? X : never;
 
-type Handler<T> = (node: T, state: State) => Chunk[];
+type Handler<T> = (node: T, state: State) => undefined;
 
 export type Handlers = {
 	[K in Node['type']]: Handler<NodeOf<K, Node>>;
 };
 
 export interface State {
-	indent: string;
+	commands: Command[];
 	comments: Comment[];
+	multiline: boolean;
 }
 
 export interface Chunk {
+	type: 'Chunk';
 	content: string;
 	loc: null | {
 		start: { line: number; column: number };
 		end: { line: number; column: number };
 	};
-	has_newline: boolean;
 }
+
+export interface Newline {
+	type: 'Newline';
+}
+
+export interface Indent {
+	type: 'Indent';
+}
+
+export interface Dedent {
+	type: 'Dedent';
+}
+
+export interface IndentChange {
+	type: 'IndentChange';
+	offset: number;
+}
+
+export interface Sequence {
+	type: 'Sequence';
+	children: Command[];
+}
+
+export interface CommentChunk {
+	type: 'Comment';
+	comment: Comment;
+}
+
+export type Command = string | Chunk | Newline | Indent | Dedent | Sequence | CommentChunk;