testomatio-editor-blocks 0.4.72 → 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,38 +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/);
-                dataLines.forEach((dataLine) => {
+                const escaped = escapeBody(stepData);
+                escaped.split(/\r?\n/).forEach((dataLine) => {
                     const trimmedLine = dataLine.trim();
-                    if (trimmedLine.length > 0) {
-                        lines.push(`  ${escapeStepContent(trimmedLine)}`);
-                    }
-                    else {
-                        lines.push("  ");
-                    }
+                    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*";
-                expectedLines.forEach((expectedLine, index) => {
+                let isFirst = true;
+                escaped.split(/\r?\n/).forEach((expectedLine) => {
                     const trimmedLine = expectedLine.trim();
                     if (trimmedLine.length === 0) {
                         return;
                     }
-                    if (index === 0) {
-                        lines.push(`  ${label}: ${escapeStepContent(trimmedLine)}`);
-                    }
-                    else {
-                        lines.push(`  ${escapeStepContent(trimmedLine)}`);
-                    }
+                    lines.push(isFirst ? `  ${label}: ${trimmedLine}` : `  ${trimmedLine}`);
+                    isFirst = false;
                 });
             }
             return lines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testomatio-editor-blocks",
-  "version": "0.4.72",
+  "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

@@ -1249,6 +1249,112 @@ describe("markdownToBlocks", () => {
     );
   });
 
+  it("does not escape dots inside fenced code blocks in step data", () => {
+    const stepData = [
+      "```",
+      "curl 'https://stable.testomat.io/api/runs/54?page=1&entry=' \\",
+      "  -H 'accept-language: en-US,en;q=0.9' \\",
+      "  -b 'gclau=1.1.1681594017.1781077572;'",
+      "```",
+    ].join("\n");
+
+    const markdown = blocksToMarkdown([
+      {
+        id: "step1",
+        type: "testStep",
+        props: {
+          stepTitle: "Run the request.",
+          stepData,
+          expectedResult: "",
+          listStyle: "bullet",
+        },
+        content: undefined,
+        children: [],
+      },
+    ]);
+
+    expect(markdown).toBe(
+      [
+        // Title outside the fence is still escaped.
+        "* Run the request\\.",
+        // Dots inside the fence stay literal.
+        "  ```",
+        "  curl 'https://stable.testomat.io/api/runs/54?page=1&entry=' \\",
+        "  -H 'accept-language: en-US,en;q=0.9' \\",
+        "  -b 'gclau=1.1.1681594017.1781077572;'",
+        "  ```",
+      ].join("\n"),
+    );
+
+    // Round-trip stays stable.
+    const roundTrip = blocksToMarkdown(
+      markdownToBlocks(["### Steps", "", markdown].join("\n")) as CustomEditorBlock[],
+    );
+    expect(roundTrip).toContain(
+      "  curl 'https://stable.testomat.io/api/runs/54?page=1&entry=' \\",
+    );
+    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,39 +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/);
-        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(`  ${escapeStepContent(trimmedLine)}`);
-          } else {
-            lines.push("  ");
-          }
+          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*";
-        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;
           }
-
-          if (index === 0) {
-            lines.push(`  ${label}: ${escapeStepContent(trimmedLine)}`);
-          } else {
-            lines.push(`  ${escapeStepContent(trimmedLine)}`);
-          }
+          lines.push(isFirst ? `  ${label}: ${trimmedLine}` : `  ${trimmedLine}`);
+          isFirst = false;
         });
       }