@dogsbay/markdown-it-mdx-jsx 0.2.0-beta.12 → 0.2.0-beta.121

package/dist/index.d.ts

@@ -16,6 +16,13 @@ export interface MdxJsxOptions {
     components?: string[];
     /** Tags that are always self-closing even without `/>`. */
     selfClosing?: string[];
+    /**
+     * A self-closing tag followed by TEXT on its line opens a paragraph (the
+     * tag inline), as MDX reads it, instead of a block that dropped the rest of
+     * the line. Opt-in: a host must then handle (or report) inline components,
+     * or the component is lost instead of the text.
+     */
+    inlineWhenFollowedByText?: boolean;
 }
 /**
  * Parse JSX-style attributes from a string.

package/dist/index.js

@@ -271,7 +271,10 @@ function parseBlockTag(state, startLine, endLine, offset = 0) {
     let combined = remaining;
     let currentLine = startLine + 1;
     while (currentLine < endLine) {
-        const nextLine = getLine(state, currentLine);
+        // The whole line, indentation included: a multi-line attribute VALUE
+        // (`<Code code={`…`} />`) is content, and trimming each line flattened
+        // every code sample written that way.
+        const nextLine = state.src.slice(state.bMarks[currentLine], state.eMarks[currentLine]);
         combined += "\n" + nextLine;
         const parsed = parseTag(combined, 0);
         if (parsed) {
@@ -300,10 +303,21 @@ function createJsxBlockRule(options) {
             return false;
         if (componentSet && !componentSet.has(parsed.tag))
             return false;
-        if (silent)
-            return true;
         const lineEnd = state.eMarks[startLine];
         const lineText = state.src.slice(pos, lineEnd);
+        // A self-closing tag followed by TEXT on its line opens a paragraph, as in
+        // MDX (`<Badge text="Beta" /> Connected meetings let you…`): taken as a
+        // block, the rest of the line was dropped. Another tag after it is still
+        // flow (`<Tabs> <TabItem>`), handled below.
+        if (options.inlineWhenFollowedByText && parsed.endLine === startLine && parsed.selfClosing) {
+            const rest = lineText.slice(parsed.length).trim();
+            // Another tag or a trailing `{…}` expression (`{/* c */}`, `{" "}`) is
+            // still flow; only prose makes it a paragraph.
+            if (rest && !rest.startsWith("<") && !rest.startsWith("{"))
+                return false;
+        }
+        if (silent)
+            return true;
         // Process this tag and any subsequent tags on the same line
         return processFlowTags(state, startLine, endLine, pos, lineText, componentSet, selfClosingSet);
     };
@@ -406,6 +420,7 @@ function processFlowTags(state, startLine, endLine, linePos, lineText, component
     return true;
 }
 // ── Inline rule ────────────────────────────────────────────
+const openInline = new WeakMap();
 function createJsxInlineRule(options) {
     const componentSet = options.components ? new Set(options.components) : null;
     const selfClosingSet = new Set(options.selfClosing || []);
@@ -418,11 +433,23 @@ function createJsxInlineRule(options) {
             return false;
         if (componentSet && !componentSet.has(parsed.tag))
             return false;
-        if (silent)
+        // In silent mode (link-label scanning) the rule must still CONSUME the
+        // tag: returning true without moving pos threw "inline rule didn't
+        // increment state.pos" for any JSX inside `[label](url)`.
+        if (silent) {
+            state.pos += parsed.length;
             return true;
+        }
         const isSelfClosing = parsed.selfClosing || selfClosingSet.has(parsed.tag);
+        // Open inline tags in THIS inline run. A closer with no opener here (its
+        // opener sat in another paragraph) must not be nesting -1: markdown-it
+        // pops its delimiter stack on every -1, and an unmatched pop left it
+        // undefined, crashing the parse in balance_pairs.
+        const open = openInline.get(state) ?? 0;
         if (parsed.isClose) {
-            const token = state.push("jsx_inline_close", parsed.tag, -1);
+            const token = state.push("jsx_inline_close", parsed.tag, open > 0 ? -1 : 0);
+            if (open > 0)
+                openInline.set(state, open - 1);
             token.markup = `</${parsed.tag}>`;
         }
         else if (isSelfClosing) {
@@ -431,6 +458,7 @@ function createJsxInlineRule(options) {
         }
         else {
             const token = state.push("jsx_inline_open", parsed.tag, 1);
+            openInline.set(state, open + 1);
             token.meta = { attrs: parsed.attrs };
             token.markup = `<${parsed.tag}>`;
         }
@@ -480,6 +508,13 @@ function createImportStripRule() {
             state.line = startLine + 1;
             return true;
         }
+        // Side-effect import (no binding): `import "./styles.module.css";`
+        if (text.match(/^import\s+["'][^"']*["']\s*;?\s*$/)) {
+            if (silent)
+                return true;
+            state.line = startLine + 1;
+            return true;
+        }
         if (text.match(/^import\s*\{/)) {
             if (silent)
                 return true;
@@ -514,11 +549,34 @@ function createImportStripRule() {
  * Exported so consumers can call it before md.parse() if needed.
  */
 export function normalizeJsxLines(source) {
-    // Split close tag + open/close tag: </X> <Y or </X> </Y
-    let result = source.replace(/(<\/[A-Z]\w*\s*>)([ \t]+)(<\/?[A-Z])/g, "$1\n$3");
-    // Split open tag end + next tag: ...> <Y (for <Tabs> <TabItem> pattern)
-    result = result.replace(/(>)([ \t]+)(<\/?[A-Z]\w*[\s>])/g, "$1\n$3");
-    return result;
+    // Line by line, and never inside a fence or a table row: a row is ONE
+    // line by definition, and splitting `</p> <Example>` out of a cell broke
+    // the table in two; a fence shows its JSX as code.
+    let fence = null;
+    return source
+        .split("\n")
+        .map((line) => {
+        const m = /^[ \t]*(`{3,}|~{3,})/.exec(line);
+        if (fence) {
+            if (m && m[1][0] === fence[0] && m[1].length >= fence.length && line.trim() === m[1])
+                fence = null;
+            return line;
+        }
+        // A backtick fence's info string cannot hold a backtick: "```x@y```"
+        // is an inline code span, and taking it for a fence switched this off
+        // for the rest of the document.
+        if (m && !(m[1][0] === "`" && line.slice(line.indexOf(m[1]) + m[1].length).includes("`"))) {
+            fence = m[1];
+            return line;
+        }
+        if (/^[ \t]*\|/.test(line))
+            return line;
+        // Split close tag + open/close tag: </X> <Y or </X> </Y
+        const once = line.replace(/(<\/[A-Z]\w*\s*>)([ \t]+)(<\/?[A-Z])/g, "$1\n$3");
+        // Split open tag end + next tag: ...> <Y (for <Tabs> <TabItem> pattern)
+        return once.replace(/(>)([ \t]+)(<\/?[A-Z]\w*[\s>])/g, "$1\n$3");
+    })
+        .join("\n");
 }
 // ── Plugin entry point ─────────────────────────────────────
 export default function mdxJsxPlugin(md, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dogsbay/markdown-it-mdx-jsx",
-  "version": "0.2.0-beta.12",
+  "version": "0.2.0-beta.121",
   "description": "markdown-it plugin that tokenizes JSX-style component tags inside Markdown — used by @dogsbay/format-starlight",
   "type": "module",
   "exports": {
@@ -11,13 +11,13 @@
     "README.md"
   ],
   "dependencies": {
-    "markdown-it": "^14.1.0"
+    "markdown-it": "^14.3.0"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
     "@types/markdown-it": "^14.1.2",
-    "typescript": "^5.8.0",
-    "vitest": "^3.2.0"
+    "@types/node": "^22.20.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
   },
   "license": "MIT",
   "repository": {