ember-estree 0.6.7 → 0.6.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-estree",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "ESTree generator for gjs and gts file used by ember",
   "keywords": [
     "AST",

package/src/print.js

@@ -26,9 +26,15 @@ export function print(node) {
     case "Literal":
     case "StringLiteral":
       if (typeof node.value === "string") {
+        // Prefer the original source: it preserves escape sequences
+        // (`\n`, `\t`, `\uXXXX`, escaped quotes) and the original quote
+        // style exactly. Emitting the cooked `value` turns escapes into raw
+        // characters and corrupts the string (e.g. `'\n'` -> a real newline,
+        // which breaks a single-quoted literal).
         const raw = node.extra?.raw ?? node.raw;
-        const quote = raw && (raw[0] === "'" || raw[0] === '"' || raw[0] === "`") ? raw[0] : '"';
-        return `${quote}${node.value}${quote}`;
+        if (raw != null) return raw;
+        // Synthesized node with no source — quote and escape the value.
+        return JSON.stringify(node.value);
       }
       if (node.raw != null) return node.raw;
       return String(node.value);
@@ -83,6 +89,12 @@ export function print(node) {
     case "ChainExpression":
       return print(node.expression);
 
+    case "V8IntrinsicExpression": {
+      const name = typeof node.name === "string" ? node.name : print(node.name);
+      const args = (node.arguments ?? []).map(print).join(", ");
+      return `%${name}(${args})`;
+    }
+
     case "ParenthesizedExpression":
       return `(${print(node.expression)})`;
 
@@ -203,7 +215,7 @@ export function print(node) {
     case "BlockStatement":
     case "StaticBlock": {
       const body = (node.body ?? []).map(print).join("\n");
-      return `{\n${body}\n}`;
+      return braceBlock(body);
     }
 
     case "EmptyStatement":
@@ -244,13 +256,13 @@ export function print(node) {
     case "SwitchStatement": {
       const disc = print(node.discriminant);
       const cases = (node.cases ?? []).map(print).join("\n");
-      return `switch (${disc}) {\n${cases}\n}`;
+      return `switch (${disc}) ${braceBlock(cases)}`;
     }
 
     case "SwitchCase": {
       const test = node.test ? `case ${print(node.test)}:` : "default:";
       const body = (node.consequent ?? []).map(print).join("\n");
-      return `${test}\n${body}`;
+      return body ? `${test}\n${indent(body)}` : test;
     }
 
     case "ThrowStatement":
@@ -324,7 +336,7 @@ export function print(node) {
 
     case "ClassBody": {
       const body = (node.body ?? []).map(print).join("\n");
-      return `{\n${body}\n}`;
+      return braceBlock(body);
     }
 
     case "MethodDefinition":
@@ -541,6 +553,19 @@ export function print(node) {
     case "TSArrayType":
       return `${print(node.elementType)}[]`;
 
+    case "TSParenthesizedType":
+      return `(${print(node.typeAnnotation)})`;
+
+    // JSDoc type syntax (`?Foo`, `!Foo`, `?`) — `postfix` flips prefix/suffix.
+    case "TSJSDocNullableType":
+      return node.postfix ? `${print(node.typeAnnotation)}?` : `?${print(node.typeAnnotation)}`;
+
+    case "TSJSDocNonNullableType":
+      return node.postfix ? `${print(node.typeAnnotation)}!` : `!${print(node.typeAnnotation)}`;
+
+    case "TSJSDocUnknownType":
+      return "?";
+
     case "TSTupleType": {
       const elems = (node.elementTypes ?? []).map(print).join(", ");
       return `[${elems}]`;
@@ -659,7 +684,7 @@ export function print(node) {
 
     case "TSInterfaceBody": {
       const body = (node.body ?? []).map(print).join("\n");
-      return `{\n${body}\n}`;
+      return braceBlock(body);
     }
 
     case "TSInterfaceHeritage":
@@ -680,8 +705,15 @@ export function print(node) {
       const declare = node.declare ? "declare " : "";
       const constKw = node.const ? "const " : "";
       const id = print(node.id);
+      // Newer oxc nests members in a TSEnumBody child; older versions put
+      // `members` directly on the declaration.
+      const members = (node.body?.members ?? node.members ?? []).map(print).join(",\n");
+      return `${declare}${constKw}enum ${id} ${braceBlock(members)}`;
+    }
+
+    case "TSEnumBody": {
       const members = (node.members ?? []).map(print).join(",\n");
-      return `${declare}${constKw}enum ${id} {\n${members}\n}`;
+      return braceBlock(members);
     }
 
     case "TSEnumMember": {
@@ -698,7 +730,7 @@ export function print(node) {
 
     case "TSModuleBlock": {
       const body = (node.body ?? []).map(print).join("\n");
-      return `{\n${body}\n}`;
+      return braceBlock(body);
     }
 
     case "TSNamespaceExportDeclaration":
@@ -919,6 +951,30 @@ export function print(node) {
  * @param {object} node
  * @return {string}
  */
+/**
+ * Indents every non-empty line of a block's inner content by one level.
+ * Nesting compounds naturally: each enclosing block re-indents the
+ * already-formatted child string.
+ * @param {string} text
+ * @return {string}
+ */
+function indent(text) {
+  return text
+    .split("\n")
+    .map((line) => (line ? `  ${line}` : line))
+    .join("\n");
+}
+
+/**
+ * Wraps already-joined statement text in a brace block, indented one level.
+ * Empty content collapses to `{}`.
+ * @param {string} inner
+ * @return {string}
+ */
+function braceBlock(inner) {
+  return inner ? `{\n${indent(inner)}\n}` : "{}";
+}
+
 function printTypeAnnotated(name, node) {
   const optional = node.optional ? "?" : "";
   const typeAnnotation = node.typeAnnotation ? print(node.typeAnnotation) : "";