partial-tsx 0.0.2 → 0.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "partial-tsx",
   "description": "Utilities for completing prefix-growing TSX.",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "type": "module",
   "repository": {
     "type": "git",

package/src/partial.ts

@@ -278,6 +278,21 @@ const isLikelyStatementBlock = (code: string, index: number) => {
   return /\bfunction(?:\s+[\w$]+)?\s*\([^)]*\)$/.test(before) || /\b(?:if|for|while|switch|with)\s*\([^)]*\)$/.test(before) || /\bcatch(?:\s*\([^)]*\))?$/.test(before) || /(?:^|[^\w$])(?:else|try|finally|do)$/.test(before) || before.endsWith("=>");
 };
 
+// `null` when `index` isn't a comment start, `-1` when the comment is unterminated, else the index just past it.
+// The three tag/expression scanners below all need this and drifted apart once already — #1600 was one of them missing it.
+const findCommentEnd = (code: string, index: number) => {
+  if (code[index] !== "/") return null;
+  if (code[index + 1] === "/") {
+    const end = code.indexOf("\n", index + 2);
+    return end === -1 ? -1 : end + 1;
+  }
+  if (code[index + 1] === "*") {
+    const end = code.indexOf("*/", index + 2);
+    return end === -1 ? -1 : end + 2;
+  }
+  return null;
+};
+
 const findJsxTagEnd = (code: string, start: number) => {
   const stack: string[] = [];
   let quote: string | null = null;
@@ -288,6 +303,20 @@ const findJsxTagEnd = (code: string, start: number) => {
       else if (char === quote) quote = null;
       continue;
     }
+    // A regex ending in an escaped slash (`/\//`) puts a literal `//` in the source, so it must be consumed before the
+    // comment scan below mistakes it for one — same ordering `findJsxAttributeExpressionEnd` uses.
+    if (stack.length > 0 && isLikelyRegexLiteralStart(code, index)) {
+      index = findRegexLiteralEnd(code, index) - 1;
+      continue;
+    }
+    // Comments are legal anywhere in a tag, including its own attribute list — not just inside an attribute's `{…}`.
+    // Skipping them keeps an apostrophe in `// framework's Link` from opening a string that swallows the rest of the tag (#1600).
+    const commentEnd = findCommentEnd(code, index);
+    if (commentEnd !== null) {
+      if (commentEnd === -1) return -1;
+      index = commentEnd - 1;
+      continue;
+    }
     if (char === '"' || char === "'" || char === "`") {
       quote = char;
       continue;
@@ -307,14 +336,9 @@ const findJsxTagEnd = (code: string, start: number) => {
 const findJsxAttributeExpressionEnd = (code: string, index: number) => {
   let depth = 1;
   while (index < code.length) {
-    if (code[index] === "/" && code[index + 1] === "/") {
-      const end = code.indexOf("\n", index + 2);
-      index = end === -1 ? code.length : end;
-      continue;
-    }
-    if (code[index] === "/" && code[index + 1] === "*") {
-      const close = code.indexOf("*/", index + 2);
-      index = close === -1 ? code.length : close + 2;
+    const commentEnd = findCommentEnd(code, index);
+    if (commentEnd !== null) {
+      index = commentEnd === -1 ? code.length : commentEnd;
       continue;
     }
     if (isLikelyRegexLiteralStart(code, index)) {
@@ -349,6 +373,18 @@ const completeIncompleteJsxTag = (code: string, start: number) => {
   let tag = "";
   while (index < code.length) {
     const char = code[index];
+    const commentEnd = findCommentEnd(code, index);
+    if (commentEnd !== null) {
+      // A still-streaming comment has to be dropped, not carried: emitting it would bury the `>` we synthesize below
+      // inside the comment. A closed one is kept verbatim — comments are legal in a JSX attribute list (#1600).
+      if (commentEnd === -1) {
+        index = code.length;
+        continue;
+      }
+      tag += code.slice(index, commentEnd);
+      index = commentEnd;
+      continue;
+    }
     if (char === "`") {
       // A backtick is illegal as a JSX attribute value (`title=`x`` → "JSX value should be either an expression or a quoted JSX text"); template literals are only valid inside `{...}`. Drop the attribute.
       tag = tag.replace(/\s*[\w$:-]+\s*=\s*$/, "");
@@ -396,7 +432,11 @@ const completeIncompleteJsxTag = (code: string, start: number) => {
   if (/=\s*$/.test(tag)) tag = tag.replace(/\s*[\w$:-]+\s*=\s*$/, "");
   // Otherwise a trailing name with no following space is still streaming (`valu` may become `value`); a trailing space commits it as a boolean attr.
   else if (!/\s$/.test(tag)) tag = tag.replace(/\s+[A-Za-z_$][\w$:-]*$/, "");
-  const completedTag = VOID_TAGS.has(tagName) ? `${tag.replace(/\s*\/\s*$/, "")} />` : `${tag}>`;
+  // That trim can eat the newline terminating a trailing comment. The closer synthesized below must stay clear of it:
+  // after `//` it would be buried inside the comment, after `*/` it would fuse into a spurious self-closing `/>`.
+  if (/\/\/[^\n]*$|\*\/$/.test(tag)) tag += "\n";
+  // The `\/` strip below must not mistake a block comment's terminating slash for a stray self-closing one.
+  const completedTag = VOID_TAGS.has(tagName) ? `${tag.replace(/\s*(?<!\*)\/\s*$/, "")} />` : `${tag}>`;
   return { tag: completedTag, tagName };
 };