feat: add option for quote and indentation styles

Author: manuel3108

README.md

@@ -35,15 +35,19 @@ 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 optionally pass information that will be used while generating the output (note that the AST is assumed to come from a single file):
 
 ```js
 const { code, map } = print(ast, {
   sourceMapSource: 'input.js',
   sourceMapContent: fs.readFileSync('input.js', 'utf-8')
+  indent: ' ' // default '\t'
+  quotes: 'single' // or 'double', default 'single'
 });
 ```
 
+The `quotes` option is only used for string literals where no raw value was provided. In most cases this means that the ast node was added by manipulating the ast. This avoid's unnecessarily transforming the provided source code.
+
 ## TypeScript
 
 `esrap` can also print TypeScript nodes, assuming they match the ESTree-like [`@typescript-eslint/types`](https://www.npmjs.com/package/@typescript-eslint/types).

src/handlers.js

@@ -69,12 +69,14 @@ export function handle(node, state) {
 /**
  * @param {string} content
  * @param {TSESTree.Node} node
+ * @param {boolean} quote
  * @returns {Chunk}
  */
-function c(content, node) {
+function c(content, node, quote = false) {
 	return {
 		type: 'Chunk',
 		content,
+		quote,
 		loc: node?.loc ?? null
 	};
 }
@@ -1115,10 +1117,16 @@ const handlers = {
 		// 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);
+		if (value) {
+			state.commands.push(c(value, node));
+			return;
+		}
+
+		const isString = typeof node.value === 'string';
+		const addQuotes = isString;
+		value = isString ? node.value : String(node.value);
 
-		state.commands.push(c(value, node));
+		state.commands.push(c(value, node, addQuotes));
 	},
 
 	LogicalExpression: shared['BinaryExpression|LogicalExpression'],

src/index.js

@@ -69,6 +69,9 @@ export function print(node, opts = {}) {
 	}
 
 	let newline = '\n';
+	const indent = opts.indent ?? '\t';
+	const quote_type = opts.quote ?? 'single';
+	const quote = quote_type === 'single' ? "'" : '"';
 
 	/** @param {Command} command */
 	function run(command) {
@@ -90,7 +93,15 @@ export function print(node, opts = {}) {
 					]);
 				}
 
-				append(command.content);
+				let content = command.content;
+
+				if (command.quote) {
+					if (content.includes(quote)) content = content.replaceAll(quote, `\\${quote}`);
+
+					content = `${quote}${content}${quote}`;
+				}
+
+				append(content);
 
 				if (loc) {
 					current_line.push([
@@ -108,11 +119,11 @@ export function print(node, opts = {}) {
 				break;
 
 			case 'Indent':
-				newline += '\t';
+				newline += indent;
 				break;
 
 			case 'Dedent':
-				newline = newline.slice(0, -1);
+				newline = newline.slice(0, -indent.length);
 				break;
 
 			case 'Sequence':

src/types.d.ts

@@ -40,6 +40,7 @@ export interface State {
 export interface Chunk {
 	type: 'Chunk';
 	content: string;
+	quote: boolean;
 	loc: null | {
 		start: { line: number; column: number };
 		end: { line: number; column: number };
@@ -79,4 +80,6 @@ export interface PrintOptions {
 	sourceMapSource?: string;
 	sourceMapContent?: string;
 	sourceMapEncodeMappings?: boolean; // default true
+	indent?: string; // default tab
+	quote?: 'single' | 'double'; // default single
 }

test/common.js

@@ -0,0 +1,55 @@
+import * as acorn from 'acorn';
+import { tsPlugin } from 'acorn-typescript';
+import { walk } from 'zimmerframe';
+
+// @ts-expect-error
+export const acornTs = acorn.Parser.extend(tsPlugin({ allowSatisfies: true }));
+
+/** @param {string} input */
+export function load(input) {
+	const comments = [];
+
+	const ast = acornTs.parse(input, {
+		ecmaVersion: 'latest',
+		sourceType: 'module',
+		locations: true,
+		onComment: (block, value, start, end) => {
+			if (block && /\n/.test(value)) {
+				let a = start;
+				while (a > 0 && input[a - 1] !== '\n') a -= 1;
+
+				let b = a;
+				while (/[ \t]/.test(input[b])) b += 1;
+
+				const indentation = input.slice(a, b);
+				value = value.replace(new RegExp(`^${indentation}`, 'gm'), '');
+			}
+
+			comments.push({ type: block ? 'Block' : 'Line', value, start, end });
+		}
+	});
+
+	walk(ast, null, {
+		_(node, { next }) {
+			let comment;
+			const commentNode = /** @type {NodeWithComments} */ (/** @type {any} */ (node));
+
+			while (comments[0] && comments[0].start < node.start) {
+				comment = comments.shift();
+				(commentNode.leadingComments ??= []).push(comment);
+			}
+
+			next();
+
+			if (comments[0]) {
+				const slice = input.slice(node.end, comments[0].start);
+
+				if (/^[,) \t]*$/.test(slice)) {
+					commentNode.trailingComments = [comments.shift()];
+				}
+			}
+		}
+	});
+
+	return /** @type {TSESTree.Program} */ (/** @type {any} */ (ast));
+}

test/esrap.test.js

@@ -3,62 +3,9 @@
 /** @import { NodeWithComments, PrintOptions } from '../src/types' */
 import fs from 'node:fs';
 import { expect, test } from 'vitest';
-import * as acorn from 'acorn';
-import { tsPlugin } from 'acorn-typescript';
 import { walk } from 'zimmerframe';
 import { print } from '../src/index.js';
-
-// @ts-expect-error
-const acornTs = acorn.Parser.extend(tsPlugin({ allowSatisfies: true }));
-
-/** @param {string} input */
-function load(input) {
-	const comments = [];
-
-	const ast = acornTs.parse(input, {
-		ecmaVersion: 'latest',
-		sourceType: 'module',
-		locations: true,
-		onComment: (block, value, start, end) => {
-			if (block && /\n/.test(value)) {
-				let a = start;
-				while (a > 0 && input[a - 1] !== '\n') a -= 1;
-
-				let b = a;
-				while (/[ \t]/.test(input[b])) b += 1;
-
-				const indentation = input.slice(a, b);
-				value = value.replace(new RegExp(`^${indentation}`, 'gm'), '');
-			}
-
-			comments.push({ type: block ? 'Block' : 'Line', value, start, end });
-		}
-	});
-
-	walk(ast, null, {
-		_(node, { next }) {
-			let comment;
-			const commentNode = /** @type {NodeWithComments} */ (/** @type {any} */ (node));
-
-			while (comments[0] && comments[0].start < node.start) {
-				comment = comments.shift();
-				(commentNode.leadingComments ??= []).push(comment);
-			}
-
-			next();
-
-			if (comments[0]) {
-				const slice = input.slice(node.end, comments[0].start);
-
-				if (/^[,) \t]*$/.test(slice)) {
-					commentNode.trailingComments = [comments.shift()];
-				}
-			}
-		}
-	});
-
-	return /** @type {TSESTree.Program} */ (/** @type {any} */ (ast));
-}
+import { acornTs, load } from './common.js';
 
 /** @param {TSESTree.Node} ast */
 function clean(ast) {

test/indent.test.js

@@ -0,0 +1,39 @@
+import { test } from 'vitest';
+import { load } from './common';
+import { print } from '../src';
+import { expect } from 'vitest';
+
+const test_code = "const foo = () => { const bar = 'baz' }";
+
+test('default indent type is tab', () => {
+	const ast = load(test_code);
+	const code = print(ast).code;
+
+	expect(code).toMatchInlineSnapshot(`
+		"const foo = () => {
+			const bar = 'baz';
+		};"
+	`);
+});
+
+test('two space indent', () => {
+	const ast = load(test_code);
+	const code = print(ast, { indent: '  ' }).code;
+
+	expect(code).toMatchInlineSnapshot(`
+		"const foo = () => {
+		  const bar = 'baz';
+		};"
+	`);
+});
+
+test('four space indent', () => {
+	const ast = load(test_code);
+	const code = print(ast, { indent: '    ' }).code;
+
+	expect(code).toMatchInlineSnapshot(`
+		"const foo = () => {
+		    const bar = 'baz';
+		};"
+	`);
+});

test/quotes.test.js

@@ -0,0 +1,63 @@
+import { test } from 'vitest';
+import { print } from '../src/index.js';
+import { expect } from 'vitest';
+import { load } from './common.js';
+import { walk } from 'zimmerframe';
+import { TSESTree } from '@typescript-eslint/types';
+
+/**
+ * Removes the `raw` property from all `Literal` nodes, as the printer is prefering it's
+ * value. Only if the `raw` value is not present it will try to add the prefered quoting
+ * @param {TSESTree.Program} ast
+ */
+function clean(ast) {
+	walk(ast, null, {
+		_(node, { next }) {
+			if (node.type === 'Literal') delete node.raw;
+
+			next();
+		}
+	});
+}
+
+const test_code = "const foo = 'bar'";
+
+test('default quote type is single', () => {
+	const ast = load(test_code);
+	clean(ast);
+	const code = print(ast).code;
+
+	expect(code).toMatchInlineSnapshot(`"const foo = 'bar';"`);
+});
+
+test('single quotes used when single quote type provided', () => {
+	const ast = load(test_code);
+	clean(ast);
+	const code = print(ast, { quote: 'single' }).code;
+
+	expect(code).toMatchInlineSnapshot(`"const foo = 'bar';"`);
+});
+
+test('double quotes used when double quote type provided', () => {
+	const ast = load(test_code);
+	clean(ast);
+	const code = print(ast, { quote: 'double' }).code;
+
+	expect(code).toMatchInlineSnapshot(`"const foo = "bar";"`);
+});
+
+test('escape single quotes if present in string literal', () => {
+	const ast = load('const foo = "b\'ar"');
+	clean(ast);
+	const code = print(ast, { quote: 'single' }).code;
+
+	expect(code).toMatchInlineSnapshot(`"const foo = 'b\\'ar';"`);
+});
+
+test('escape double quotes if present in string literal', () => {
+	const ast = load("const foo = 'b\"ar'");
+	clean(ast);
+	const code = print(ast, { quote: 'double' }).code;
+
+	expect(code).toMatchInlineSnapshot(`"const foo = "b\\"ar";"`);
+});