testomatio-editor-blocks 0.4.73 → 0.4.74

package/package/editor/customMarkdownConverter.js

@@ -43,8 +43,46 @@ function escapeMarkdown(text) {
     result += text.slice(lastIndex).replace(SPECIAL_CHAR_REGEX, "\\$1");
     return result;
 }
-function escapeStepContent(text) {
-    return text.replace(/\./g, "\\.");
+// Creates a stateful escaper that escapes dots outside Markdown code while
+// leaving code spans (inline `…`, fenced ``` … ```) verbatim — backslash
+// escapes are ignored inside code, so `\.` would render literally.
+//
+// The state (an open, not-yet-closed backtick run) carries across calls so a
+// fence can be opened in one segment and closed in another. This matters
+// because the step editor splits a multi-line code block across props: the
+// opening ``` lands in `stepTitle` while the body and closing ``` land in
+// `stepData`.
+function makeStepEscaper() {
+    let fence = null;
+    return (text) => {
+        let result = "";
+        let i = 0;
+        while (i < text.length) {
+            if (text[i] === "`") {
+                let ticks = 0;
+                while (text[i + ticks] === "`")
+                    ticks++;
+                const run = "`".repeat(ticks);
+                result += run;
+                i += ticks;
+                if (fence === null) {
+                    fence = run; // open a code span/fence
+                }
+                else if (fence === run) {
+                    fence = null; // matching run closes it
+                }
+                continue;
+            }
+            if (fence !== null) {
+                result += text[i]; // inside code — copy verbatim
+                i++;
+                continue;
+            }
+            result += text[i] === "." ? "\\." : text[i];
+            i++;
+        }
+        return result;
+    };
 }
 function stripHtmlWrappers(text) {
     return text
@@ -380,53 +418,35 @@ function serializeBlock(block, ctx, orderedIndex, stepIndex) {
                 .join(" ");
             const normalizedExpectedForCheck = stripExpectedPrefix(expectedResult).trim();
             const hasContent = stepData.length > 0 || normalizedExpectedForCheck.length > 0;
+            // One escaper threads code-fence state from the title into the data: the
+            // editor splits a multi-line code block so the opening ``` sits in the
+            // title and the body + closing ``` sit in the data. Both must be treated
+            // as a single code region so their dots stay literal.
+            const escapeBody = makeStepEscaper();
             if (normalizedTitle.length > 0 || hasContent) {
                 const listStyle = (_o = block.props.listStyle) !== null && _o !== void 0 ? _o : "bullet";
                 const prefix = listStyle === "ordered" ? `${(stepIndex !== null && stepIndex !== void 0 ? stepIndex : 0) + 1}.` : "*";
-                lines.push(normalizedTitle.length > 0 ? `${prefix} ${escapeStepContent(normalizedTitle)}` : `${prefix} `);
+                lines.push(normalizedTitle.length > 0 ? `${prefix} ${escapeBody(normalizedTitle)}` : `${prefix} `);
             }
             if (stepData.length > 0) {
-                const dataLines = stepData.split(/\r?\n/);
-                let insideCodeFence = false;
-                dataLines.forEach((dataLine) => {
+                const escaped = escapeBody(stepData);
+                escaped.split(/\r?\n/).forEach((dataLine) => {
                     const trimmedLine = dataLine.trim();
-                    if (trimmedLine.length === 0) {
-                        lines.push("  ");
-                        return;
-                    }
-                    // Don't escape dots inside fenced code blocks (or on the fence lines
-                    // themselves) — Markdown ignores backslash escapes there, so `\.`
-                    // would render literally.
-                    const isFence = trimmedLine.startsWith("```");
-                    const content = insideCodeFence || isFence ? trimmedLine : escapeStepContent(trimmedLine);
-                    lines.push(`  ${content}`);
-                    if (isFence) {
-                        insideCodeFence = !insideCodeFence;
-                    }
+                    lines.push(trimmedLine.length === 0 ? "  " : `  ${trimmedLine}`);
                 });
             }
             const normalizedExpected = stripExpectedPrefix(expectedResult).trim();
             if (normalizedExpected.length > 0) {
-                const expectedLines = normalizedExpected.split(/\r?\n/);
+                const escaped = makeStepEscaper()(normalizedExpected);
                 const label = "*Expected result*";
-                let insideCodeFence = false;
-                expectedLines.forEach((expectedLine, index) => {
+                let isFirst = true;
+                escaped.split(/\r?\n/).forEach((expectedLine) => {
                     const trimmedLine = expectedLine.trim();
                     if (trimmedLine.length === 0) {
                         return;
                     }
-                    // As with step data, leave dots untouched inside fenced code blocks.
-                    const isFence = trimmedLine.startsWith("```");
-                    const content = insideCodeFence || isFence ? trimmedLine : escapeStepContent(trimmedLine);
-                    if (index === 0) {
-                        lines.push(`  ${label}: ${content}`);
-                    }
-                    else {
-                        lines.push(`  ${content}`);
-                    }
-                    if (isFence) {
-                        insideCodeFence = !insideCodeFence;
-                    }
+                    lines.push(isFirst ? `  ${label}: ${trimmedLine}` : `  ${trimmedLine}`);
+                    isFirst = false;
                 });
             }
             return lines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testomatio-editor-blocks",
-  "version": "0.4.73",
+  "version": "0.4.74",
   "description": "Custom BlockNote schema, markdown conversion helpers, and UI for Testomatio-style test cases and steps.",
   "type": "module",
   "main": "./package/index.js",

package/src/editor/customMarkdownConverter.test.ts

@@ -1296,6 +1296,65 @@ describe("markdownToBlocks", () => {
     expect(roundTrip).toContain("  -b 'gclau=1.1.1681594017.1781077572;'");
   });
 
+  it("does not escape dots inside inline code in step data", () => {
+    const markdown = blocksToMarkdown([
+      {
+        id: "step1",
+        type: "testStep",
+        props: {
+          stepTitle: "Run the request.",
+          stepData: "`curl https://example.com/api`",
+          expectedResult: "",
+          listStyle: "bullet",
+        },
+        content: undefined,
+        children: [],
+      },
+    ]);
+
+    expect(markdown).toBe(
+      [
+        // Title outside code is still escaped.
+        "* Run the request\\.",
+        // Dots inside the inline code span stay literal.
+        "  `curl https://example.com/api`",
+      ].join("\n"),
+    );
+  });
+
+  it("does not escape dots when a fenced block opens in the title and the body lands in step data", () => {
+    // The step editor splits a multi-line code block: the opening ``` becomes
+    // the title and the body + closing ``` become the step data.
+    const markdown = blocksToMarkdown([
+      {
+        id: "step1",
+        type: "testStep",
+        props: {
+          stepTitle: "```",
+          stepData: [
+            "curl --location 'https://example.com.ua' \\",
+            "--data-raw '{ \"method\": \"url.method\" }'",
+            "```",
+          ].join("\n"),
+          expectedResult: "",
+          listStyle: "bullet",
+        },
+        content: undefined,
+        children: [],
+      },
+    ]);
+
+    expect(markdown).toBe(
+      [
+        "* ```",
+        // Dots inside the fence stay literal even though it opened in the title.
+        "  curl --location 'https://example.com.ua' \\",
+        "  --data-raw '{ \"method\": \"url.method\" }'",
+        "  ```",
+      ].join("\n"),
+    );
+  });
+
   it("does not include content after a blank line in step data", () => {
     const markdown = [
       "### Steps",

package/src/editor/customMarkdownConverter.ts

@@ -84,8 +84,44 @@ function escapeMarkdown(text: string): string {
   return result;
 }
 
-function escapeStepContent(text: string): string {
-  return text.replace(/\./g, "\\.");
+// Creates a stateful escaper that escapes dots outside Markdown code while
+// leaving code spans (inline `…`, fenced ``` … ```) verbatim — backslash
+// escapes are ignored inside code, so `\.` would render literally.
+//
+// The state (an open, not-yet-closed backtick run) carries across calls so a
+// fence can be opened in one segment and closed in another. This matters
+// because the step editor splits a multi-line code block across props: the
+// opening ``` lands in `stepTitle` while the body and closing ``` land in
+// `stepData`.
+function makeStepEscaper(): (text: string) => string {
+  let fence: string | null = null;
+  return (text: string): string => {
+    let result = "";
+    let i = 0;
+    while (i < text.length) {
+      if (text[i] === "`") {
+        let ticks = 0;
+        while (text[i + ticks] === "`") ticks++;
+        const run = "`".repeat(ticks);
+        result += run;
+        i += ticks;
+        if (fence === null) {
+          fence = run; // open a code span/fence
+        } else if (fence === run) {
+          fence = null; // matching run closes it
+        }
+        continue;
+      }
+      if (fence !== null) {
+        result += text[i]; // inside code — copy verbatim
+        i++;
+        continue;
+      }
+      result += text[i] === "." ? "\\." : text[i];
+      i++;
+    }
+    return result;
+  };
 }
 
 function stripHtmlWrappers(text: string): string {
@@ -461,57 +497,38 @@ function serializeBlock(
       const normalizedExpectedForCheck = stripExpectedPrefix(expectedResult).trim();
       const hasContent = stepData.length > 0 || normalizedExpectedForCheck.length > 0;
 
+      // One escaper threads code-fence state from the title into the data: the
+      // editor splits a multi-line code block so the opening ``` sits in the
+      // title and the body + closing ``` sit in the data. Both must be treated
+      // as a single code region so their dots stay literal.
+      const escapeBody = makeStepEscaper();
+
       if (normalizedTitle.length > 0 || hasContent) {
         const listStyle = (block.props as any).listStyle ?? "bullet";
         const prefix = listStyle === "ordered" ? `${(stepIndex ?? 0) + 1}.` : "*";
-        lines.push(normalizedTitle.length > 0 ? `${prefix} ${escapeStepContent(normalizedTitle)}` : `${prefix} `);
+        lines.push(normalizedTitle.length > 0 ? `${prefix} ${escapeBody(normalizedTitle)}` : `${prefix} `);
       }
 
       if (stepData.length > 0) {
-        const dataLines = stepData.split(/\r?\n/);
-        let insideCodeFence = false;
-        dataLines.forEach((dataLine: string) => {
+        const escaped = escapeBody(stepData);
+        escaped.split(/\r?\n/).forEach((dataLine: string) => {
           const trimmedLine = dataLine.trim();
-          if (trimmedLine.length === 0) {
-            lines.push("  ");
-            return;
-          }
-          // Don't escape dots inside fenced code blocks (or on the fence lines
-          // themselves) — Markdown ignores backslash escapes there, so `\.`
-          // would render literally.
-          const isFence = trimmedLine.startsWith("```");
-          const content =
-            insideCodeFence || isFence ? trimmedLine : escapeStepContent(trimmedLine);
-          lines.push(`  ${content}`);
-          if (isFence) {
-            insideCodeFence = !insideCodeFence;
-          }
+          lines.push(trimmedLine.length === 0 ? "  " : `  ${trimmedLine}`);
         });
       }
 
       const normalizedExpected = stripExpectedPrefix(expectedResult).trim();
       if (normalizedExpected.length > 0) {
-        const expectedLines = normalizedExpected.split(/\r?\n/);
+        const escaped = makeStepEscaper()(normalizedExpected);
         const label = "*Expected result*";
-        let insideCodeFence = false;
-        expectedLines.forEach((expectedLine: string, index: number) => {
+        let isFirst = true;
+        escaped.split(/\r?\n/).forEach((expectedLine: string) => {
           const trimmedLine = expectedLine.trim();
           if (trimmedLine.length === 0) {
             return;
           }
-
-          // As with step data, leave dots untouched inside fenced code blocks.
-          const isFence = trimmedLine.startsWith("```");
-          const content =
-            insideCodeFence || isFence ? trimmedLine : escapeStepContent(trimmedLine);
-          if (index === 0) {
-            lines.push(`  ${label}: ${content}`);
-          } else {
-            lines.push(`  ${content}`);
-          }
-          if (isFence) {
-            insideCodeFence = !insideCodeFence;
-          }
+          lines.push(isFirst ? `  ${label}: ${trimmedLine}` : `  ${trimmedLine}`);
+          isFirst = false;
         });
       }