testomatio-editor-blocks 0.3.0 → 0.4.0

package/package/editor/customMarkdownConverter.js

@@ -141,6 +141,24 @@ function inlineToMarkdown(content) {
     })
         .join("");
 }
+function inlineContentToPlainText(content) {
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content
+        .map((node) => {
+        if (node && typeof node === "object") {
+            if (typeof node.text === "string") {
+                return node.text;
+            }
+            if (Array.isArray(node.content)) {
+                return inlineContentToPlainText(node.content);
+            }
+        }
+        return "";
+    })
+        .join("");
+}
 function serializeChildren(block, ctx) {
     var _a;
     if (!((_a = block.children) === null || _a === void 0 ? void 0 : _a.length)) {
@@ -534,7 +552,7 @@ function countIndent(line) {
     const match = line.match(/^ */);
     return match ? match[0].length : 0;
 }
-function parseList(lines, startIndex, listType, indentLevel) {
+function parseList(lines, startIndex, listType, indentLevel, allowEmptySteps = false) {
     var _a, _b, _c, _d;
     const items = [];
     let index = startIndex;
@@ -546,14 +564,13 @@ function parseList(lines, startIndex, listType, indentLevel) {
             continue;
         }
         let indent = countIndent(rawLine);
-        const baseIndent = indentLevel * 2;
-        if (indent > baseIndent && indent <= baseIndent + 1) {
-            indent = baseIndent;
-        }
         if (indent < indentLevel * 2) {
             break;
         }
-        if (indent > indentLevel * 2) {
+        // Check if this line should be parsed as nested content
+        // Only go deeper if indent is at least 2 more than the next level's expected indent
+        const nextLevelExpectedIndent = (indentLevel + 1) * 2;
+        if (indent >= nextLevelExpectedIndent) {
             const lastItem = items.at(-1);
             if (!lastItem) {
                 break;
@@ -562,7 +579,12 @@ function parseList(lines, startIndex, listType, indentLevel) {
             if (!nestedType) {
                 break;
             }
-            const nested = parseList(lines, index, nestedType, indentLevel + 1);
+            const nested = parseList(lines, index, nestedType, indentLevel + 1, allowEmptySteps);
+            // If nested parsing made no progress, skip this line to avoid infinite loop
+            if (nested.nextIndex === index) {
+                index += 1;
+                continue;
+            }
             lastItem.children = [...((_a = lastItem.children) !== null && _a !== void 0 ? _a : []), ...nested.items];
             index = nested.nextIndex;
             continue;
@@ -571,6 +593,16 @@ function parseList(lines, startIndex, listType, indentLevel) {
         if (detectedType !== listType) {
             break;
         }
+        // Only try to parse as testStep for top-level bullet items (indentLevel === 0)
+        // Nested bullets within numbered lists should remain as regular bulletListItem
+        if (listType === "bullet" && indentLevel === 0) {
+            const nextStep = parseTestStep(lines, index, allowEmptySteps);
+            if (nextStep) {
+                items.push(nextStep.block);
+                index = nextStep.nextIndex;
+                continue;
+            }
+        }
         if (listType === "check") {
             const checkMatch = trimmed.match(/^[-*+]\s+\[([xX\s])\]\s+(.*)$/);
             const checked = ((_b = checkMatch === null || checkMatch === void 0 ? void 0 : checkMatch[1]) !== null && _b !== void 0 ? _b : "").toLowerCase() === "x";
@@ -607,7 +639,7 @@ function parseList(lines, startIndex, listType, indentLevel) {
     }
     return { items, nextIndex: index };
 }
-function parseTestStep(lines, index, snippetId) {
+function parseTestStep(lines, index, allowEmpty = false, snippetId) {
     const current = lines[index];
     const trimmed = current.trim();
     if (!trimmed.startsWith("* ") && !trimmed.startsWith("- ")) {
@@ -635,13 +667,19 @@ function parseTestStep(lines, index, snippetId) {
     let expectedResult = "";
     let next = index + 1;
     let inExpectedResult = false;
+    let foundFirstExpected = false;
     while (next < lines.length) {
         const line = lines[next];
         const hasIndent = /^\s{2,}/.test(line);
         const rawTrimmed = line.trim();
         if (!rawTrimmed) {
-            if (stepDataLines.length > 0) {
-                stepDataLines.push("");
+            if (stepDataLines.length > 0 || inExpectedResult) {
+                if (inExpectedResult) {
+                    expectedResult += "\n";
+                }
+                else {
+                    stepDataLines.push("");
+                }
             }
             next += 1;
             continue;
@@ -658,20 +696,68 @@ function parseTestStep(lines, index, snippetId) {
             rawTrimmed.startsWith("|")) {
             break;
         }
-        if (rawTrimmed.match(EXPECTED_LABEL_REGEX)) {
+        // Check for expected result labels with different formatting
+        const expectedMatch = rawTrimmed.match(EXPECTED_LABEL_REGEX);
+        const expectedStarMatch = rawTrimmed.match(/^\*expected\s*\*:\s*(.*)$/i) ||
+            rawTrimmed.match(/^\*expected\*:\s*(.*)$/i);
+        if (expectedMatch || expectedStarMatch) {
+            foundFirstExpected = true;
+            inExpectedResult = true;
+            const label = expectedMatch ? expectedMatch[0] : (expectedStarMatch ? expectedStarMatch[0] : '');
+            let content = rawTrimmed.slice(label.length).trim();
+            // Add the content (if any) from this line
+            if (content) {
+                const expectedContent = unescapeMarkdown(content);
+                if (expectedResult.length > 0) {
+                    expectedResult += "\n" + expectedContent;
+                }
+                else {
+                    expectedResult = expectedContent;
+                }
+            }
+            next += 1;
+            continue;
+        }
+        // Check for lines that start with * and contain Expected (but don't match the above patterns)
+        if (rawTrimmed.match(/^\*[^*]*expected/i)) {
+            foundFirstExpected = true;
             inExpectedResult = true;
-            const withoutLabel = stripExpectedPrefix(rawTrimmed);
-            expectedResult = unescapeMarkdown(withoutLabel);
+            // Remove the leading * and trim
+            let content = rawTrimmed.slice(1).trim();
+            // Remove any "Expected:" prefix
+            content = content.replace(/^expected\s*:?\s*/i, '').trim();
+            const expectedContent = unescapeMarkdown(content);
+            if (expectedResult.length > 0) {
+                expectedResult += "\n" + expectedContent;
+            }
+            else {
+                expectedResult = expectedContent;
+            }
             next += 1;
             continue;
         }
         if (rawTrimmed.startsWith("```")) {
-            stepDataLines.push(unescapeMarkdown(rawTrimmed));
+            if (inExpectedResult) {
+                if (expectedResult.length > 0) {
+                    expectedResult += "\n" + unescapeMarkdown(rawTrimmed);
+                }
+                else {
+                    expectedResult = unescapeMarkdown(rawTrimmed);
+                }
+            }
+            else {
+                stepDataLines.push(unescapeMarkdown(rawTrimmed));
+            }
             next += 1;
             while (next < lines.length) {
                 const fenceLine = lines[next];
                 const fenceTrimmed = fenceLine.trim();
-                stepDataLines.push(unescapeMarkdown(fenceTrimmed));
+                if (inExpectedResult) {
+                    expectedResult += "\n" + unescapeMarkdown(fenceTrimmed);
+                }
+                else {
+                    stepDataLines.push(unescapeMarkdown(fenceTrimmed));
+                }
                 next += 1;
                 if (fenceTrimmed.startsWith("```")) {
                     break;
@@ -680,8 +766,27 @@ function parseTestStep(lines, index, snippetId) {
             continue;
         }
         if (inExpectedResult) {
-            const withoutLabel = stripExpectedPrefix(rawTrimmed);
-            expectedResult += "\n" + unescapeMarkdown(withoutLabel);
+            // After finding the first expected result, indented lines are part of it
+            if (hasIndent) {
+                const expectedContent = unescapeMarkdown(rawTrimmed);
+                if (expectedResult.length > 0) {
+                    expectedResult += "\n" + expectedContent;
+                }
+                else {
+                    expectedResult = expectedContent;
+                }
+            }
+            else if (foundFirstExpected && rawTrimmed.startsWith("*") && !rawTrimmed.startsWith("* ")) {
+                // Non-indented lines starting with single * (not list item) are likely more expected results
+                // Remove the leading * and treat the rest as content
+                const expectedContent = unescapeMarkdown(rawTrimmed.slice(1).trim());
+                if (expectedResult.length > 0) {
+                    expectedResult += "\n" + expectedContent;
+                }
+                else {
+                    expectedResult = expectedContent;
+                }
+            }
             next += 1;
             continue;
         }
@@ -691,13 +796,23 @@ function parseTestStep(lines, index, snippetId) {
             next += 1;
             continue;
         }
+        // If we have indent and the line doesn't match other patterns, treat it as step data
+        if (hasIndent) {
+            const content = unescapeMarkdown(rawTrimmed);
+            stepDataLines.push(content);
+            next += 1;
+            continue;
+        }
         break;
     }
     const stepData = stepDataLines
         .map((line) => line.trimEnd())
         .join("\n")
         .trim();
-    if (!isLikelyStep && !expectedResult && stepDataLines.length === 0) {
+    if (!isLikelyStep &&
+        !expectedResult &&
+        stepDataLines.length === 0 &&
+        !(allowEmpty && titleWithPlaceholders.length > 0)) {
         return null;
     }
     const stepDataWithImages = [stepData, titleImages.join("\n")]
@@ -900,10 +1015,12 @@ function parseSnippetWrapper(lines, index) {
     };
 }
 export function markdownToBlocks(markdown) {
+    var _a, _b;
     const normalized = markdown.replace(/\r\n/g, "\n");
     const lines = normalized.split("\n");
     const blocks = [];
     let index = 0;
+    let stepsHeadingLevel = null;
     while (index < lines.length) {
         const line = lines[index];
         if (!line.trim()) {
@@ -916,7 +1033,7 @@ export function markdownToBlocks(markdown) {
             index = snippetWrapper.nextIndex;
             continue;
         }
-        const stepLikeBlock = parseTestStep(lines, index);
+        const stepLikeBlock = parseTestStep(lines, index, stepsHeadingLevel !== null);
         if (stepLikeBlock) {
             blocks.push(stepLikeBlock.block);
             index = stepLikeBlock.nextIndex;
@@ -930,7 +1047,19 @@ export function markdownToBlocks(markdown) {
         }
         const heading = parseHeading(lines, index);
         if (heading) {
-            blocks.push(heading.block);
+            const headingBlock = heading.block;
+            const headingLevel = (_b = (_a = headingBlock.props) === null || _a === void 0 ? void 0 : _a.level) !== null && _b !== void 0 ? _b : 3;
+            const headingText = inlineContentToPlainText(headingBlock.content);
+            const normalizedHeading = headingText.trim().toLowerCase();
+            if (normalizedHeading === "steps") {
+                stepsHeadingLevel = headingLevel;
+            }
+            else if (stepsHeadingLevel !== null &&
+                headingLevel <= stepsHeadingLevel &&
+                normalizedHeading.length > 0) {
+                stepsHeadingLevel = null;
+            }
+            blocks.push(headingBlock);
             index = heading.nextIndex;
             continue;
         }
@@ -948,7 +1077,7 @@ export function markdownToBlocks(markdown) {
         }
         const listType = detectListType(line.trim());
         if (listType) {
-            const { items, nextIndex } = parseList(lines, index, listType, 0);
+            const { items, nextIndex } = parseList(lines, index, listType, 0, stepsHeadingLevel !== null);
             blocks.push(...items);
             index = nextIndex;
             continue;