esrap 1.3.7 → 1.4.1

package/README.md

@@ -35,12 +35,29 @@ If the nodes of the input AST have `loc` properties (e.g. the AST was generated
 
 ## Options
 
-You can pass information that will be added to the resulting sourcemap (note that the AST is assumed to come from a single file):
+You can pass the following options:
 
 ```js
 const { code, map } = print(ast, {
+  // Populate the `sources` field of the resulting sourcemap
+  // (note that the AST is assumed to come from a single file)
   sourceMapSource: 'input.js',
-  sourceMapContent: fs.readFileSync('input.js', 'utf-8')
+
+  // Populate the `sourcesContent` field of the resulting sourcemap
+  sourceMapContent: fs.readFileSync('input.js', 'utf-8'),
+
+  // Whether to encode the `mappings` field of the resulting sourcemap
+  // as a VLQ string, rather than an unencoded array. Defaults to `true`
+  sourceMapEncodeMappings: false,
+
+  // String to use for indentation — defaults to '\t'
+  indent: '  ',
+
+  // Whether to wrap strings in single or double quotes — defaults to 'single'.
+  // This only applies to string literals with no `raw` value, which generally
+  // means the AST node was generated programmatically, rather than parsed
+  // from an original source
+  quotes: 'single'
 });
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esrap",
-  "version": "1.3.7",
+  "version": "1.4.1",
   "description": "Parse in reverse",
   "repository": {
     "type": "git",

package/src/handlers.js

@@ -1,5 +1,5 @@
 /** @import { TSESTree } from '@typescript-eslint/types' */
-/** @import { Chunk, Command, Dedent, Handlers, Indent, Newline, NodeWithComments, Sequence, State, TypeAnnotationNodes } from './types' */
+/** @import { Command, Dedent, Handlers, Location, Indent, Newline, NodeWithComments, State, TypeAnnotationNodes } from './types' */
 
 /** @type {Newline} */
 const newline = { type: 'Newline' };
@@ -11,11 +11,10 @@ const indent = { type: 'Indent' };
 const dedent = { type: 'Dedent' };
 
 /**
- * @param {Command[]} children
- * @returns {Sequence}
+ * @returns {Command[]}
  */
-function create_sequence(...children) {
-	return { type: 'Sequence', children };
+function create_sequence() {
+	return [];
 }
 
 /**
@@ -30,11 +29,11 @@ function measure(commands, from, to = commands.length) {
 		const command = commands[i];
 		if (typeof command === 'string') {
 			total += command.length;
-		} else if (command.type === 'Chunk') {
-			total += command.content.length;
-		} else if (command.type === 'Sequence') {
-			// assume this is ', '
-			total += 2;
+		} else if (Array.isArray(command)) {
+			total +=
+				command.length === 0
+					? 2 // assume this is ', '
+					: measure(command, 0);
 		}
 	}
 
@@ -66,17 +65,32 @@ export function handle(node, state) {
 	}
 }
 
+/**
+ * @param {number} line
+ * @param {number} column
+ * @returns {Location}
+ */
+function l(line, column) {
+	return {
+		type: 'Location',
+		line,
+		column
+	};
+}
+
 /**
  * @param {string} content
  * @param {TSESTree.Node} node
- * @returns {Chunk}
+ * @returns {string | Command[]}
  */
 function c(content, node) {
-	return {
-		type: 'Chunk',
-		content,
-		loc: node?.loc ?? null
-	};
+	return node.loc
+		? [
+				l(node.loc.start.line, node.loc.start.column),
+				content,
+				l(node.loc.end.line, node.loc.end.column)
+			]
+		: content;
 }
 
 /**
@@ -96,6 +110,33 @@ function prepend_comments(comments, state, newlines) {
 	}
 }
 
+/**
+ * @param {string} string
+ * @param {'\'' | '"'} char
+ */
+function quote(string, char) {
+	let out = char;
+	let escaped = false;
+
+	for (const c of string) {
+		if (escaped) {
+			out += c;
+			escaped = false;
+		} else if (c === '\\') {
+			out += '\\\\';
+			escaped = true;
+		} else if (c === char) {
+			out += '\\' + c;
+		} else if (c === '\n') {
+			out += '\\n';
+		} else {
+			out += c;
+		}
+	}
+
+	return out + char;
+}
+
 const OPERATOR_PRECEDENCE = {
 	'||': 2,
 	'&&': 3,
@@ -280,7 +321,7 @@ const handle_body = (nodes, state) => {
 				grouped_expression_types.includes(last_statement.type)) &&
 				last_statement.type !== statement.type)
 		) {
-			margin.children.push('\n');
+			margin.push('\n');
 		}
 
 		let add_newline = false;
@@ -324,11 +365,11 @@ const handle_var_declaration = (node, state) => {
 
 	if (multiline) {
 		state.multiline = true;
-		if (node.declarations.length > 1) open.children.push(indent);
-		join.children.push(',', newline);
+		if (node.declarations.length > 1) open.push(indent);
+		join.push(',', newline);
 		if (node.declarations.length > 1) state.commands.push(dedent);
 	} else {
-		join.children.push(', ');
+		join.push(', ');
 	}
 };
 
@@ -400,13 +441,13 @@ function sequence(nodes, state, spaces, fn, separator = ',') {
 	if (multiline) {
 		state.multiline = true;
 
-		open.children.push(indent, newline);
-		join.children.push(newline);
-		close.children.push(dedent, newline);
+		open.push(indent, newline);
+		join.push(newline);
+		close.push(dedent, newline);
 	} else {
-		if (spaces) open.children.push(' ');
-		join.children.push(' ');
-		if (spaces) close.children.push(' ');
+		if (spaces) open.push(' ');
+		join.push(' ');
+		if (spaces) close.push(' ');
 	}
 }
 
@@ -702,11 +743,11 @@ const shared = {
 		}
 
 		if (multiline) {
-			open.children.push(indent, newline);
-			join.children.push(',', newline);
-			close.children.push(dedent, newline);
+			open.push(indent, newline);
+			join.push(',', newline);
+			close.push(dedent, newline);
 		} else {
-			join.children.push(', ');
+			join.push(', ');
 		}
 	},
 
@@ -898,12 +939,12 @@ const handlers = {
 		const multiline = child_state.multiline;
 
 		if (multiline) {
-			if_true.children.push(indent, newline, '? ');
-			if_false.children.push(newline, ': ');
+			if_true.push(indent, newline, '? ');
+			if_false.push(newline, ': ');
 			state.commands.push(dedent);
 		} else {
-			if_true.children.push(' ? ');
-			if_false.children.push(' : ');
+			if_true.push(' ? ');
+			if_false.push(' : ');
 		}
 	},
 
@@ -1125,9 +1166,9 @@ const handlers = {
 		// TODO do we need to handle weird unicode characters somehow?
 		// str.replace(/\\u(\d{4})/g, (m, n) => String.fromCharCode(+n))
 
-		let value = node.raw;
-		if (!value)
-			value = typeof node.value === 'string' ? JSON.stringify(node.value) : String(node.value);
+		const value =
+			node.raw ||
+			(typeof node.value === 'string' ? quote(node.value, state.quote) : String(node.value));
 
 		state.commands.push(c(value, node));
 	},

package/src/index.js

@@ -37,7 +37,8 @@ export function print(node, opts = {}) {
 	const state = {
 		commands: [],
 		comments: [],
-		multiline: false
+		multiline: false,
+		quote: opts.quotes === 'double' ? '"' : "'"
 	};
 
 	handle(/** @type {TSESTree.Node} */ (node), state);
@@ -69,6 +70,7 @@ export function print(node, opts = {}) {
 	}
 
 	let newline = '\n';
+	const indent = opts.indent ?? '\t';
 
 	/** @param {Command} command */
 	function run(command) {
@@ -77,30 +79,21 @@ export function print(node, opts = {}) {
 			return;
 		}
 
-		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
-					]);
-				}
+		if (Array.isArray(command)) {
+			for (let i = 0; i < command.length; i += 1) {
+				run(command[i]);
+			}
+			return;
+		}
 
+		switch (command.type) {
+			case 'Location':
+				current_line.push([
+					current_column,
+					0, // source index is always zero
+					command.line - 1,
+					command.column
+				]);
 				break;
 
 			case 'Newline':
@@ -108,18 +101,11 @@ export function print(node, opts = {}) {
 				break;
 
 			case 'Indent':
-				newline += '\t';
+				newline += indent;
 				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]);
-				}
-
+				newline = newline.slice(0, -indent.length);
 				break;
 
 			case 'Comment':

package/src/types.d.ts

@@ -35,15 +35,13 @@ export interface State {
 	commands: Command[];
 	comments: TSESTree.Comment[];
 	multiline: boolean;
+	quote: "'" | '"';
 }
 
-export interface Chunk {
-	type: 'Chunk';
-	content: string;
-	loc: null | {
-		start: { line: number; column: number };
-		end: { line: number; column: number };
-	};
+export interface Location {
+	type: 'Location';
+	line: number;
+	column: number;
 }
 
 export interface Newline {
@@ -63,20 +61,17 @@ export interface IndentChange {
 	offset: number;
 }
 
-export interface Sequence {
-	type: 'Sequence';
-	children: Command[];
-}
-
 export interface CommentChunk {
 	type: 'Comment';
 	comment: TSESTree.Comment;
 }
 
-export type Command = string | Chunk | Newline | Indent | Dedent | Sequence | CommentChunk;
+export type Command = string | Location | Newline | Indent | Dedent | CommentChunk | 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

@@ -3,6 +3,8 @@ declare module 'esrap' {
 		sourceMapSource?: string;
 		sourceMapContent?: string;
 		sourceMapEncodeMappings?: boolean; // default true
+		indent?: string; // default tab
+		quotes?: 'single' | 'double'; // default single
 	}
 	/**
 	 * @returns // TODO

package/types/index.d.ts.map

@@ -13,6 +13,6 @@
 		null,
 		null
 	],
-	"mappings": ";kBA6EiBA,YAAYA;;;;;;;;iBCtDbC,KAAKA",
+	"mappings": ";kBAsEiBA,YAAYA;;;;;;;;;;iBC/CbC,KAAKA",
 	"ignoreList": []
 }