esrap 2.0.0 → 2.1.0

package/README.md

@@ -107,6 +107,7 @@ The `context` API has several methods:
 - `context.write(data: string, node?: BaseNode)` — add a string. If `node` is provided and has a standard `loc` property (with `start` and `end` properties each with a `line` and `column`), a sourcemap mapping will be created
 - `context.indent()` — increase the indentation level, typically before adding a newline
 - `context.newline()` — self-explanatory
+- `context.space()` — adds a space character, if it doesn't immediately follow a newline
 - `context.margin()` — causes the next newline to be repeated (consecutive newlines are otherwise merged into one)
 - `context.dedent()` — decrease the indentation level (again, typically before adding a newline)
 - `context.visit(node: BaseNode)` — calls the visitor corresponding to `node.type`

package/package.json

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

package/src/context.js

@@ -5,10 +5,12 @@ export const margin = 0;
 export const newline = 1;
 export const indent = 2;
 export const dedent = 3;
+export const space = 4;
 
 export class Context {
 	#visitors;
 	#commands;
+	#has_newline = false;
 
 	multiline = false;
 
@@ -35,15 +37,23 @@ export class Context {
 	}
 
 	newline() {
-		this.multiline = true;
+		this.#has_newline = true;
 		this.#commands.push(newline);
 	}
 
+	space() {
+		this.#commands.push(space);
+	}
+
 	/**
 	 * @param {Context} context
 	 */
 	append(context) {
 		this.#commands.push(context.#commands);
+
+		if (this.#has_newline) {
+			this.multiline = true;
+		}
 	}
 
 	/**
@@ -59,6 +69,10 @@ export class Context {
 		} else {
 			this.#commands.push(content);
 		}
+
+		if (this.#has_newline) {
+			this.multiline = true;
+		}
 	}
 
 	/**

package/src/index.js

@@ -1,6 +1,6 @@
 /** @import { BaseNode, Command, Visitors, PrintOptions } from './types' */
 import { encode } from '@jridgewell/sourcemap-codec';
-import { Context, dedent, indent, margin, newline } from './context.js';
+import { Context, dedent, indent, margin, newline, space } from './context.js';
 
 /** @type {(str: string) => string} str */
 let btoa = () => {
@@ -91,6 +91,7 @@ export function print(node, visitors, opts = {}) {
 
 	let needs_newline = false;
 	let needs_margin = false;
+	let needs_space = false;
 
 	/** @param {Command} command */
 	function run(command) {
@@ -106,6 +107,8 @@ export function print(node, visitors, opts = {}) {
 				needs_newline = true;
 			} else if (command === margin) {
 				needs_margin = true;
+			} else if (command === space) {
+				needs_space = true;
 			} else if (command === indent) {
 				current_newline += indent_str;
 			} else if (command === dedent) {
@@ -117,9 +120,11 @@ export function print(node, visitors, opts = {}) {
 
 		if (needs_newline) {
 			append(needs_margin ? '\n' + current_newline : current_newline);
+		} else if (needs_space) {
+			append(' ');
 		}
 
-		needs_margin = needs_newline = false;
+		needs_margin = needs_newline = needs_space = false;
 
 		if (typeof command === 'string') {
 			append(command);

package/src/languages/ts/index.js

@@ -139,7 +139,6 @@ export default (options = {}) => {
 	 * @param {Context} context
 	 * @param {{ line: number, column: number } | null} prev
 	 * @param {{ line: number, column: number } | null} next
-	 * @returns {boolean} true if final comment is a line comment
 	 */
 	function flush_trailing_comments(context, prev, next) {
 		while (comment_index < comments.length) {
@@ -157,14 +156,14 @@ export default (options = {}) => {
 				comment_index += 1;
 
 				if (comment.type === 'Line') {
-					return true;
+					context.newline();
+				} else {
+					continue;
 				}
-			} else {
-				break;
 			}
-		}
 
-		return false;
+			break;
+		}
 	}
 
 	/**
@@ -226,9 +225,7 @@ export default (options = {}) => {
 			}
 
 			const next = i === nodes.length - 1 ? until : nodes[i + 1]?.loc?.start || null;
-			if (child && flush_trailing_comments(child_context, child.loc?.end || null, next)) {
-				multiline = true;
-			}
+			flush_trailing_comments(child_context, child?.loc?.end || null, next);
 
 			length += child_context.measure() + 1;
 			multiline ||= child_context.multiline;
@@ -293,7 +290,8 @@ export default (options = {}) => {
 		let prev_type = null;
 		let prev_multiline = false;
 
-		for (const child of node.body) {
+		for (let i = 0; i < node.body.length; i += 1) {
+			const child = node.body[i];
 			if (child.type === 'EmptyStatement') continue;
 
 			const child_context = context.new();
@@ -309,6 +307,12 @@ export default (options = {}) => {
 
 			context.append(child_context);
 
+			flush_trailing_comments(
+				context,
+				child.loc?.end || null,
+				node.body[i + 1]?.loc?.end ?? node.loc?.end ?? null
+			);
+
 			prev_type = child.type;
 			prev_multiline = child_context.multiline;
 		}
@@ -472,9 +476,7 @@ export default (options = {}) => {
 					? (node.loc?.end ?? null)
 					: (node.arguments[i + 1]?.loc?.start ?? null);
 
-				if (flush_trailing_comments(context, arg.loc?.end ?? null, next)) {
-					child_context.multiline = true;
-				}
+				flush_trailing_comments(context, arg.loc?.end ?? null, next);
 
 				if (!is_last) context.append(join);
 			}
@@ -516,9 +518,9 @@ export default (options = {}) => {
 				context.write(' ');
 			}
 
-			if (node.implements) {
-				context.write('implements ');
-				sequence(context, node.implements, node.body.loc?.start ?? null, false);
+			if (node.implements && node.implements.length > 0) {
+				context.write('implements');
+				sequence(context, node.implements, node.body.loc?.start ?? null, true);
 			}
 
 			context.visit(node.body);
@@ -584,17 +586,11 @@ export default (options = {}) => {
 
 	return {
 		_(node, context, visit) {
-			const is_statement = /(Statement|Declaration)$/.test(node.type);
-
 			if (node.loc) {
 				flush_comments_until(context, null, node.loc.start, true);
 			}
 
 			visit(node);
-
-			if (is_statement && node.loc) {
-				flush_trailing_comments(context, node.loc.end, null);
-			}
 		},
 
 		ArrayExpression: shared['ArrayExpression|ArrayPattern'],
@@ -868,7 +864,8 @@ export default (options = {}) => {
 			context.visit(node.consequent);
 
 			if (node.alternate) {
-				context.write(' else ');
+				context.space();
+				context.write('else ');
 				context.visit(node.alternate);
 			}
 		},

package/types/index.d.ts

@@ -48,6 +48,7 @@ declare module 'esrap' {
 		dedent(): void;
 		margin(): void;
 		newline(): void;
+		space(): void;
 		
 		append(context: Context): void;
 		

package/types/index.d.ts.map

@@ -34,6 +34,6 @@
 		null,
 		null
 	],
-	"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",
+	"mappings": ";MAGYA,QAAQA;;;;;;;;MAQfC,MAAMA;;MAENC,mBAAmBA;;;;MAIZC,OAAOA;;aAEPC,QAAQA;;;;WAwBHC,QAAQA;;;;;;MAWbC,OAAOA;;kBAEFC,YAAYA;;;;;;;;;iBCHbC,KAAKA;;;;cC5CRC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCDPC,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": []
 }