testomatio-editor-blocks 0.4.46 → 0.4.48

package/src/editor/blocks/step.tsx

@@ -105,7 +105,7 @@ export function canInsertStepOrSnippet(
  */
 export function addStepsBlock(editor: {
   document: any[];
-  insertBlocks: (blocks: any[], referenceId: string, placement: string) => any[];
+  insertBlocks: (blocks: any[], referenceId: string, placement: "before" | "after") => any[];
 }): string | null {
   const allBlocks = editor.document;
   const emptyStep = {
@@ -157,6 +157,66 @@ export function addStepsBlock(editor: {
   return inserted?.[1]?.id ?? null;
 }
 
+/**
+ * Programmatically add an empty snippet block to the editor.
+ * - If a "Steps" heading exists, inserts after the last step/snippet under it.
+ * - Otherwise, appends a "Steps" heading + empty snippet at the end.
+ * Returns the inserted snippet's block ID (for focusing), or null.
+ */
+export function addSnippetBlock(editor: {
+  document: any[];
+  insertBlocks: (blocks: any[], referenceId: string, placement: "before" | "after") => any[];
+}): string | null {
+  const allBlocks = editor.document;
+  const emptySnippet = {
+    type: "snippet" as const,
+    props: { snippetId: "", snippetTitle: "", snippetData: "", snippetExpectedResult: "" },
+    children: [],
+  };
+
+  let stepsHeadingIndex = -1;
+  for (let i = 0; i < allBlocks.length; i++) {
+    const b = allBlocks[i];
+    if (b.type !== "heading") continue;
+    const text = (Array.isArray(b.content) ? b.content : [])
+      .filter((n: any) => n.type === "text")
+      .map((n: any) => n.text ?? "")
+      .join("")
+      .trim()
+      .toLowerCase()
+      .replace(/[:\-–—]$/, "");
+    if (isStepsHeading(text)) {
+      stepsHeadingIndex = i;
+      break;
+    }
+  }
+
+  if (stepsHeadingIndex >= 0) {
+    let lastIndex = stepsHeadingIndex;
+    for (let i = stepsHeadingIndex + 1; i < allBlocks.length; i++) {
+      const b = allBlocks[i];
+      if (b.type === "testStep" || b.type === "snippet") {
+        lastIndex = i;
+        continue;
+      }
+      if (isEmptyParagraph(b)) continue;
+      break;
+    }
+    const inserted = editor.insertBlocks([emptySnippet], allBlocks[lastIndex].id, "after");
+    return inserted?.[0]?.id ?? null;
+  }
+
+  const lastBlock = allBlocks[allBlocks.length - 1];
+  const stepsHeading = {
+    type: "heading" as const,
+    props: { level: 3 },
+    content: [{ type: "text" as const, text: "Steps" }],
+    children: [],
+  };
+  const inserted = editor.insertBlocks([stepsHeading, emptySnippet], lastBlock.id, "after");
+  return inserted?.[1]?.id ?? null;
+}
+
 export const stepBlock = createReactBlockSpec(
   {
     type: "testStep",

package/src/editor/blocks/stepField.tsx

@@ -81,6 +81,22 @@ type ExtractedImage = {
 
 type LinkMeta = { start: number; end: number; url: string };
 type FormattingMeta = { start: number; end: number; type: "bold" | "italic" | "code" };
+type FormatType = "bold" | "italic" | "code";
+
+function getActiveFormats(
+  formatting: FormattingMeta[],
+  selStart: number,
+  selEnd: number,
+): Set<FormatType> {
+  const active = new Set<FormatType>();
+  if (selStart === selEnd) return active;
+  for (const f of formatting) {
+    if (selStart < f.end && selEnd > f.start) {
+      active.add(f.type);
+    }
+  }
+  return active;
+}
 
 
 function stripInlineMarkdown(markdown: string): {
@@ -345,8 +361,6 @@ function getCaretRectInPreview(preview: HTMLElement, offset: number, textareaVal
 }
 
 function applyFormattingHighlights(preview: HTMLElement, formatting: FormattingMeta[], textareaValue?: string) {
-  if (formatting.length === 0) return;
-
   // Remove previous formatting highlights
   const existingBold = preview.querySelectorAll("strong.step-preview-bold");
   for (let i = 0; i < existingBold.length; i++) {
@@ -386,6 +400,8 @@ function applyFormattingHighlights(preview: HTMLElement, formatting: FormattingM
   // so the tree walker sees clean text nodes matching the original structure.
   preview.normalize();
 
+  if (formatting.length === 0) return;
+
   // OverType splits textarea lines into <div> elements, discarding the \n
   // characters. Convert textarea-space positions (with \n) to preview-space
   // positions (without \n) so we can find the correct text nodes.
@@ -632,10 +648,14 @@ export function StepField({
   const linkSelectionRef = useRef<{ start: number; end: number; text: string } | null>(null);
   const linksRef = useRef<LinkMeta[]>([]);
   const formattingRef = useRef<FormattingMeta[]>([]);
+  const formattingUndoRef = useRef<Array<{ formatting: FormattingMeta[]; links: LinkMeta[] }>>([]);
+  const formattingRedoRef = useRef<Array<{ formatting: FormattingMeta[]; links: LinkMeta[] }>>([]);
   const caretRef = useRef<HTMLDivElement | null>(null);
   const prevTextRef = useRef("");
   const isSyncingRef = useRef(false);
   const [cursorLink, setCursorLink] = useState<LinkMeta | null>(null);
+  const [activeFormats, setActiveFormats] = useState<Set<FormatType>>(new Set());
+  const [linkActive, setLinkActive] = useState(false);
   const Components = useComponentsContext();
   const resolvedPlaceholder = placeholder ?? "";
 
@@ -658,6 +678,8 @@ export function StepField({
 
     linksRef.current = adjustLinksForEdit(linksRef.current, editPos, delta);
     formattingRef.current = adjustFormattingForEdit(formattingRef.current, editPos, delta);
+    formattingUndoRef.current = [];
+    formattingRedoRef.current = [];
     prevTextRef.current = nextValue;
 
     const markdown = buildFullMarkdown(nextValue, linksRef.current, formattingRef.current);
@@ -1024,22 +1046,45 @@ export function StepField({
       textareaNode.focus();
 
       const fmtType: "bold" | "italic" | "code" = action === "toggleBold" ? "bold" : action === "toggleCode" ? "code" : "italic";
-      const start = textareaNode.selectionStart ?? 0;
-      const end = textareaNode.selectionEnd ?? 0;
+      const rawStart = textareaNode.selectionStart ?? 0;
+      const rawEnd = textareaNode.selectionEnd ?? 0;
+
+      // Trim leading/trailing whitespace from the selection so that
+      // formatting markers wrap only the meaningful content.
+      const selectedText = textareaNode.value.slice(rawStart, rawEnd);
+      const leadingWs = selectedText.match(/^(\s*)/)?.[1].length ?? 0;
+      const trailingWs = selectedText.match(/(\s*)$/)?.[1].length ?? 0;
+      const start = rawStart + leadingWs;
+      const end = rawEnd - trailingWs;
+
+      // If selection is all whitespace, nothing to format
+      if (start >= end) return;
 
       // Check if selection is already formatted
       const existingIdx = formattingRef.current.findIndex(
         (f) => f.type === fmtType && f.start <= start && f.end >= end,
       );
 
+      // Save current state for undo before modifying
+      formattingUndoRef.current = [
+        ...formattingUndoRef.current,
+        { formatting: [...formattingRef.current], links: [...linksRef.current] },
+      ];
+      formattingRedoRef.current = [];
+
       if (existingIdx !== -1) {
         // Remove formatting
         formattingRef.current = formattingRef.current.filter((_, i) => i !== existingIdx);
       } else if (start !== end) {
+        // Remove overlapping formatting of other types before applying new format
+        formattingRef.current = formattingRef.current.filter(
+          (f) => f.type === fmtType || f.start >= end || f.end <= start,
+        );
         // Add formatting for selection
         formattingRef.current = [...formattingRef.current, { start, end, type: fmtType }];
       } else {
         // No selection — nothing to format
+        formattingUndoRef.current = formattingUndoRef.current.slice(0, -1);
         return;
       }
 
@@ -1057,6 +1102,46 @@ export function StepField({
     [textareaNode],
   );
 
+  const updateActiveFormats = useCallback(() => {
+    if (!textareaNode) return;
+    const selStart = textareaNode.selectionStart ?? 0;
+    const selEnd = textareaNode.selectionEnd ?? 0;
+    const next = getActiveFormats(formattingRef.current, selStart, selEnd);
+    setActiveFormats((prev) => {
+      if (prev.size === next.size && [...prev].every((t) => next.has(t))) return prev;
+      return next;
+    });
+    const hasLink = selStart !== selEnd && linksRef.current.some((l) => selStart < l.end && selEnd > l.start);
+    setLinkActive(hasLink);
+  }, [textareaNode]);
+
+  useEffect(() => {
+    if (!textareaNode) return;
+
+    const onSelectionChange = () => {
+      if (document.activeElement === textareaNode) {
+        updateActiveFormats();
+      }
+    };
+
+    const onBlur = () => {
+      setActiveFormats(new Set());
+      setLinkActive(false);
+    };
+
+    document.addEventListener("selectionchange", onSelectionChange);
+    textareaNode.addEventListener("keyup", updateActiveFormats);
+    textareaNode.addEventListener("mouseup", updateActiveFormats);
+    textareaNode.addEventListener("blur", onBlur);
+
+    return () => {
+      document.removeEventListener("selectionchange", onSelectionChange);
+      textareaNode.removeEventListener("keyup", updateActiveFormats);
+      textareaNode.removeEventListener("mouseup", updateActiveFormats);
+      textareaNode.removeEventListener("blur", onBlur);
+    };
+  }, [textareaNode, updateActiveFormats]);
+
   const linkPopoverRef = useRef<HTMLDivElement>(null);
 
   // Close link popover on outside click
@@ -1310,6 +1395,54 @@ export function StepField({
           handleToolbarAction("toggleCode");
           return;
         }
+        if (event.key === "z" || event.key === "Z") {
+          const undoStack = formattingUndoRef.current;
+          if (undoStack.length > 0) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            formattingRedoRef.current = [
+              ...formattingRedoRef.current,
+              { formatting: [...formattingRef.current], links: [...linksRef.current] },
+            ];
+            const prev = undoStack[undoStack.length - 1];
+            formattingUndoRef.current = undoStack.slice(0, -1);
+            formattingRef.current = prev.formatting;
+            linksRef.current = prev.links;
+            const instance = editorInstanceRef.current;
+            if (instance) {
+              const markdown = buildFullMarkdown(instance.getValue(), linksRef.current, formattingRef.current);
+              onChangeRef.current?.(markdown);
+              setPlainTextValue(markdownToPlainText(markdown));
+              applyFormattingHighlights(instance.preview, formattingRef.current, instance.textarea?.value);
+              applyLinkHighlights(instance.preview, linksRef.current);
+            }
+            return;
+          }
+        }
+      }
+      if (modKey && event.shiftKey && (event.key === "z" || event.key === "Z")) {
+        const redoStack = formattingRedoRef.current;
+        if (redoStack.length > 0) {
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          formattingUndoRef.current = [
+            ...formattingUndoRef.current,
+            { formatting: [...formattingRef.current], links: [...linksRef.current] },
+          ];
+          const next = redoStack[redoStack.length - 1];
+          formattingRedoRef.current = redoStack.slice(0, -1);
+          formattingRef.current = next.formatting;
+          linksRef.current = next.links;
+          const instance = editorInstanceRef.current;
+          if (instance) {
+            const markdown = buildFullMarkdown(instance.getValue(), linksRef.current, formattingRef.current);
+            onChangeRef.current?.(markdown);
+            setPlainTextValue(markdownToPlainText(markdown));
+            applyFormattingHighlights(instance.preview, formattingRef.current, instance.textarea?.value);
+            applyLinkHighlights(instance.preview, linksRef.current);
+          }
+          return;
+        }
       }
 
       if (enableAutocomplete && shouldShowAutocomplete) {
@@ -1489,7 +1622,7 @@ export function StepField({
               <>
                 <button
                   type="button"
-                  className="bn-step-toolbar__button"
+                  className={`bn-step-toolbar__button${activeFormats.has("bold") ? " bn-step-toolbar__button--active" : ""}`}
                   data-tooltip="Bold"
                   onMouseDown={(event) => {
                     event.preventDefault();
@@ -1504,7 +1637,7 @@ export function StepField({
                 </button>
                 <button
                   type="button"
-                  className="bn-step-toolbar__button"
+                  className={`bn-step-toolbar__button${activeFormats.has("italic") ? " bn-step-toolbar__button--active" : ""}`}
                   data-tooltip="Italic"
                   onMouseDown={(event) => {
                     event.preventDefault();
@@ -1519,7 +1652,7 @@ export function StepField({
                 </button>
                 <button
                   type="button"
-                  className="bn-step-toolbar__button"
+                  className={`bn-step-toolbar__button${activeFormats.has("code") ? " bn-step-toolbar__button--active" : ""}`}
                   data-tooltip="Code"
                   onMouseDown={(event) => {
                     event.preventDefault();
@@ -1558,7 +1691,7 @@ export function StepField({
                 <Components.Generic.Popover.Trigger>
                   <button
                     type="button"
-                    className="bn-step-toolbar__button"
+                    className={`bn-step-toolbar__button${linkActive ? " bn-step-toolbar__button--active" : ""}`}
                     data-tooltip="Insert link"
                     onMouseDown={(event) => {
                       event.preventDefault();

package/src/editor/customMarkdownConverter.test.ts

@@ -704,11 +704,15 @@ describe("markdownToBlocks", () => {
 
   it("parses test steps and test cases", () => {
     const markdown = [
+      "### Steps",
+      "",
       "* Open the Login page.",
       "  *Expected*: The Login page loads successfully.",
     ].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
       {
         type: "testStep",
         props: {
@@ -723,9 +727,11 @@ describe("markdownToBlocks", () => {
   });
 
   it("parses a step with empty title but with step data", () => {
-    const markdown = ["* ", "  Navigate to the page"].join("\n");
+    const markdown = ["### Steps", "", "* ", "  Navigate to the page"].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
       {
         type: "testStep",
         props: {
@@ -741,6 +747,13 @@ describe("markdownToBlocks", () => {
 
   it("round-trips a title-less step with data", () => {
     const blocks: CustomEditorBlock[] = [
+      {
+        id: "h1",
+        type: "heading",
+        props: { level: 3, textColor: "default", backgroundColor: "default", textAlignment: "left" as const },
+        content: [{ type: "text" as const, text: "Steps", styles: {} }],
+        children: [],
+      },
       {
         id: "s1",
         type: "testStep",
@@ -757,7 +770,8 @@ describe("markdownToBlocks", () => {
 
     const md = blocksToMarkdown(blocks);
     const parsed = markdownToBlocks(md);
-    expect(parsed).toEqual([
+    const stepBlocks = parsed.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
       {
         type: "testStep",
         props: {
@@ -773,12 +787,16 @@ describe("markdownToBlocks", () => {
 
   it("parses snippet markdown into snippet blocks", () => {
     const markdown = [
+      "### Steps",
+      "",
       "<!-- begin snippet #501 -->",
       "Run the seeder",
       "<!-- end snippet #501 -->",
     ].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const snippetBlocks = blocks.filter((b) => b.type === "snippet");
+    expect(snippetBlocks).toEqual([
       {
         type: "snippet",
         props: {
@@ -794,13 +812,17 @@ describe("markdownToBlocks", () => {
 
   it("parses snippet markdown with space between # and ID", () => {
     const markdown = [
+      "### Steps",
+      "",
       "<!-- begin snippet # 22289 -->",
       "* Fill `<Email>` with correct registered email",
       "* Verify that the update to the target is successful",
       "<!-- end snippet # 22289 -->",
     ].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const snippetBlocks = blocks.filter((b) => b.type === "snippet");
+    expect(snippetBlocks).toEqual([
       {
         type: "snippet",
         props: {
@@ -816,6 +838,8 @@ describe("markdownToBlocks", () => {
 
   it("parses snippet bodies and ignores nested snippet markers", () => {
     const markdown = [
+      "### Steps",
+      "",
       "<!-- begin snippet #888 -->",
       "Prep DB",
       "<!-- begin snippet #ignored -->",
@@ -824,7 +848,9 @@ describe("markdownToBlocks", () => {
       "<!-- end snippet #888 -->",
     ].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const snippetBlocks = blocks.filter((b) => b.type === "snippet");
+    expect(snippetBlocks).toEqual([
       {
         type: "snippet",
         props: {
@@ -940,6 +966,8 @@ describe("markdownToBlocks", () => {
 
   it("parses step data containing code fences, blank lines, and images", () => {
     const markdown = [
+      "### Steps",
+      "",
       "* Step 2: Update an order status.",
       "  ```",
       "  SQL CREATE bnbmnbm mnbmb mm",
@@ -969,7 +997,9 @@ describe("markdownToBlocks", () => {
       "![](/attachments/HMhkVtlDrO.png)",
     ].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
       {
         type: "testStep",
         props: {
@@ -1104,12 +1134,16 @@ describe("markdownToBlocks", () => {
 
    it("parses expected result prefixes with emphasis", () => {
      const markdown = [
+       "### Steps",
+       "",
        "* Open the form.",
        "  **Expected:** The form opens.",
        "  Expected: Fields are empty.",
      ].join("\n");
 
-     expect(markdownToBlocks(markdown)).toEqual([
+     const blocks = markdownToBlocks(markdown);
+     const stepBlocks = blocks.filter((b) => b.type === "testStep");
+     expect(stepBlocks).toEqual([
        {
          type: "testStep",
          props: {
@@ -1125,13 +1159,17 @@ describe("markdownToBlocks", () => {
 
    it("parses test step with data", () => {
      const markdown = [
+       "### Steps",
+       "",
        "* Navigate to login",
        "  Open browser",
        "  Go to login page",
        "  *Expected*: Login form visible",
      ].join("\n");
 
-     expect(markdownToBlocks(markdown)).toEqual([
+     const blocks = markdownToBlocks(markdown);
+     const stepBlocks = blocks.filter((b) => b.type === "testStep");
+     expect(stepBlocks).toEqual([
        {
          type: "testStep",
          props: {
@@ -1147,13 +1185,17 @@ describe("markdownToBlocks", () => {
 
   it("parses unindented step data between the title and expected result", () => {
     const markdown = [
+      "### Steps",
+      "",
       "* Prepare test fixtures",
       "Collect user accounts from staging.",
       "Reset passwords for all test accounts.",
       "*Expected*: Test accounts are ready for execution.",
     ].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
       {
         type: "testStep",
         props: {
@@ -1169,11 +1211,15 @@ describe("markdownToBlocks", () => {
 
   it("parses expected result containing a markdown image", () => {
     const markdown = [
+      "### Steps",
+      "",
       "* Display the generated report.",
       "  *Expected*: ![](/attachments/report.png)",
     ].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
       {
         type: "testStep",
         props: {
@@ -1201,17 +1247,26 @@ describe("markdownToBlocks", () => {
       },
     ]);
 
-    expect(markdownRoundTrip).toBe(markdown);
+    expect(markdownRoundTrip).toBe(
+      [
+        "* Display the generated report.",
+        "  *Expected*: ![](/attachments/report.png)",
+      ].join("\n"),
+    );
   });
 
   it("parses expected result with short expected label and image", () => {
     const markdown = [
+      "### Steps",
+      "",
       "* Should open login screen",
       "  *Expected*: Login should look like this",
       "  ![](/login.png)",
     ].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
       {
         type: "testStep",
         props: {
@@ -1755,11 +1810,15 @@ describe("markdownToBlocks", () => {
 
   it("parses expected result lines written with bold 'Expected Result' prefix for compatibility", () => {
     const markdown = [
+      "### Steps",
+      "",
       "* Step 1: Send a chat message to the user.",
       "**Expected Result**: The user receives a real-time notification for the chat message.",
     ].join("\n");
 
-    expect(markdownToBlocks(markdown)).toEqual([
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toEqual([
       {
         type: "testStep",
         props: {
@@ -2407,3 +2466,42 @@ describe("video/audio block serialization", () => {
     expect(md).toBe("[![sound.mp3](/images/file-type-icons/file.svg)](https://example.com/sound.mp3)");
   });
 });
+
+describe("steps require Steps heading", () => {
+  it("does not parse bullet items with Expected markers as steps without a Steps heading", () => {
+    const markdown = [
+      "### Preconditions",
+      "",
+      "* Open the Login page.",
+      "  *Expected*: The Login page loads successfully.",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    expect(blocks.filter((b) => b.type === "testStep")).toHaveLength(0);
+    expect(blocks.filter((b) => b.type === "bulletListItem")).toHaveLength(1);
+  });
+
+  it("does not parse snippet comments as snippet blocks without a Steps heading", () => {
+    const markdown = [
+      "<!-- begin snippet #501 -->",
+      "Run the seeder",
+      "<!-- end snippet #501 -->",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    expect(blocks.filter((b) => b.type === "snippet")).toHaveLength(0);
+  });
+
+  it("parses bullet items as steps when preceded by a Steps heading", () => {
+    const markdown = [
+      "### Steps",
+      "",
+      "* next 22",
+    ].join("\n");
+
+    const blocks = markdownToBlocks(markdown);
+    const stepBlocks = blocks.filter((b) => b.type === "testStep");
+    expect(stepBlocks).toHaveLength(1);
+    expect((stepBlocks[0].props as any).stepTitle).toBe("next 22");
+  });
+});

package/src/editor/customMarkdownConverter.ts

@@ -834,14 +834,9 @@ function parseList(
       break;
     }
 
-    // Only try to parse as testStep for top-level items (indentLevel === 0)
-    // Under a Steps heading (allowEmptySteps=true): always try for both bullet and numbered
-    // Outside Steps heading: only if the item looks like a test step (has Expected markers or indented data)
-    if (indentLevel === 0 && (allowEmptySteps || isLikelyStep(lines, index))) {
-      const looksLikeTestStep = listType === "bullet" ||
-        (listType === "numbered" && (
-          allowEmptySteps || isLikelyStep(lines, index)
-        ));
+    // Only try to parse as testStep for top-level items under a Steps heading
+    if (indentLevel === 0 && allowEmptySteps) {
+      const looksLikeTestStep = listType === "bullet" || listType === "numbered";
 
       if (looksLikeTestStep) {
         const nextStep = parseTestStep(lines, index, allowEmptySteps);
@@ -890,31 +885,6 @@ function parseList(
   return { items, nextIndex: index };
 }
 
-function isLikelyStep(lines: string[], index: number): boolean {
-  // Look ahead to see if there's indented content or expected result
-  // Look ahead through subsequent lines for expected result markers or indented content
-  for (let i = index + 1; i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.trim();
-
-    // Stop at blank lines
-    if (!trimmed) break;
-
-    // Check for indented content (step data) first — indented lines indicate a test step
-    const hasIndent = /^\s{2,}/.test(line);
-    if (hasIndent) return true;
-
-    // Stop at new list items, headings, or other block-level elements (only if not indented)
-    if (/^[-*+](\s|$)/.test(trimmed) || /^\d+[.)]\s/.test(trimmed)) break;
-    if (trimmed.startsWith("#") || trimmed.startsWith(">") || trimmed.startsWith("|") || trimmed.startsWith("```") || trimmed.startsWith(":::")) break;
-
-    // Check for expected result markers
-    if (EXPECTED_LABEL_REGEX.test(trimmed)) return true;
-    if (trimmed.match(/^\*[^*]*expected/i)) return true;
-  }
-
-  return false;
-}
 
 function parseTestStep(
   lines: string[],
@@ -1453,15 +1423,17 @@ export function markdownToBlocks(markdown: string, options?: MarkdownToBlocksOpt
       continue;
     }
 
-    const snippetWrapper = parseSnippetWrapper(lines, index);
+    const snippetWrapper = stepsHeadingLevel !== null
+      ? parseSnippetWrapper(lines, index)
+      : null;
     if (snippetWrapper) {
       blocks.push(snippetWrapper.block);
       index = snippetWrapper.nextIndex;
       continue;
     }
 
-    const stepLikeBlock = (stepsHeadingLevel !== null || isLikelyStep(lines, index))
-      ? parseTestStep(lines, index, stepsHeadingLevel !== null)
+    const stepLikeBlock = stepsHeadingLevel !== null
+      ? parseTestStep(lines, index, true)
       : null;
     if (stepLikeBlock) {
       blocks.push(stepLikeBlock.block);