testomatio-editor-blocks 0.4.0 → 0.4.1

package/package/editor/blocks/stepHorizontalView.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+type StepHorizontalViewProps = {
+    blockId: string;
+    stepNumber: number;
+    stepValue: string;
+    expectedResult: string;
+    onStepChange: (next: string) => void;
+    onExpectedChange: (next: string) => void;
+    onInsertNextStep: () => void;
+    onFieldFocus: () => void;
+    viewToggle?: ReactNode;
+};
+export declare function StepHorizontalView({ blockId, stepNumber, stepValue, expectedResult, onStepChange, onExpectedChange, onInsertNextStep, onFieldFocus, viewToggle, }: StepHorizontalViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/package/editor/blocks/stepHorizontalView.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { StepField } from "./stepField";
+const STEP_PLACEHOLDER = "Enter step name";
+const EXPECTED_RESULT_PLACEHOLDER = "Enter expected result";
+export function StepHorizontalView({ blockId, stepNumber, stepValue, expectedResult, onStepChange, onExpectedChange, onInsertNextStep, onFieldFocus, viewToggle, }) {
+    return (_jsxs("div", { className: "bn-teststep bn-teststep--horizontal", "data-block-id": blockId, children: [_jsxs("div", { className: "bn-teststep__timeline", children: [_jsx("span", { className: "bn-teststep__number", children: stepNumber }), _jsx("div", { className: "bn-teststep__line" })] }), _jsxs("div", { className: "bn-teststep__content", children: [_jsxs("div", { className: "bn-teststep__horizontal-fields", children: [_jsxs("div", { className: "bn-teststep__horizontal-col", children: [_jsx("div", { className: "bn-teststep__header", children: _jsx("span", { className: "bn-teststep__title", children: "Step" }) }), _jsx(StepField, { label: "Step", showLabel: false, value: stepValue, onChange: onStepChange, placeholder: STEP_PLACEHOLDER, enableAutocomplete: true, fieldName: "title", suggestionFilter: (suggestion) => suggestion.isSnippet !== true, onFieldFocus: onFieldFocus, multiline: true, enableImageUpload: true, showFormattingButtons: true, showImageButton: true })] }), _jsxs("div", { className: "bn-teststep__horizontal-col", children: [_jsxs("div", { className: "bn-teststep__header", children: [_jsx("span", { className: "bn-teststep__title", children: "Expected result" }), viewToggle] }), _jsx(StepField, { label: "Expected result", showLabel: false, value: expectedResult, onChange: onExpectedChange, placeholder: EXPECTED_RESULT_PLACEHOLDER, multiline: true, enableAutocomplete: true, enableImageUpload: true, showFormattingButtons: true, showImageButton: true, onFieldFocus: onFieldFocus })] })] }), _jsx("div", { className: "bn-step-actions", children: _jsxs("button", { type: "button", className: "bn-step-action-btn", onClick: onInsertNextStep, children: [_jsx("svg", { className: "bn-step-action-btn__icon", width: "16", height: "16", viewBox: "0 0 13.334 13.334", fill: "none", "aria-hidden": "true", children: _jsx("path", { d: "M6.667 0a6.667 6.667 0 1 1 0 13.334A6.667 6.667 0 0 1 6.667 0Zm0 1.334a5.333 5.333 0 1 0 0 10.666 5.333 5.333 0 0 0 0-10.666ZM7.334 3.334V6H10v1.334H7.334V10H6V7.334H3.334V6H6V3.334h1.334Z", fill: "currentColor" }) }), "Add new step"] }) })] })] }));
+}

package/package/editor/customMarkdownConverter.d.ts

@@ -4,5 +4,6 @@ type Schema = typeof customSchema;
 export type CustomEditorBlock = Block<Schema["blockSchema"], Schema["inlineContentSchema"], Schema["styleSchema"]>;
 export type CustomPartialBlock = PartialBlock<Schema["blockSchema"], Schema["inlineContentSchema"], Schema["styleSchema"]>;
 export declare function blocksToMarkdown(blocks: CustomEditorBlock[]): string;
+export declare function fixMalformedImageBlocks(blocks: CustomPartialBlock[]): CustomPartialBlock[];
 export declare function markdownToBlocks(markdown: string): CustomPartialBlock[];
 export {};

package/package/editor/customMarkdownConverter.js

@@ -23,7 +23,7 @@ const headingPrefixes = {
 const SPECIAL_CHAR_REGEX = /([*_`~\[\]()<>\\])/g;
 const HTML_SPAN_REGEX = /<\/?span[^>]*>/g;
 const HTML_UNDERLINE_REGEX = /<\/?u>/g;
-const EXPECTED_LABEL_REGEX = /^(?:[*_`]*\s*)?(expected(?:\s+result)?)\s*(?:[*_`]*\s*)?(?:\s*[:\-–—]?\s*)/i;
+const EXPECTED_LABEL_REGEX = /^(?:[*_`]*\s*)?(expected(?:\s+result)?)\s*(?:[*_`]*\s*)?\s*[:\-–—]\s*/i;
 // Matches any non-empty line that falls between the step title and the expected result line.
 const STEP_DATA_LINE_REGEX = /^(?!\s*(?:[*_`]*\s*)?(?:expected(?:\s+result)?)\b).+/i;
 const NUMBERED_STEP_REGEX = /^\d+[.)]\s+/;
@@ -124,22 +124,39 @@ function inlineToMarkdown(content) {
     if (!content || !Array.isArray(content)) {
         return "";
     }
-    return content
-        .map((item) => {
+    const result = [];
+    let i = 0;
+    while (i < content.length) {
+        const item = content[i];
         if (isStyledTextInlineContent(item)) {
-            return applyTextStyles(escapeMarkdown(item.text), item.styles);
+            // Check if this is a "!" followed by a link (image syntax)
+            if (item.text === "!" && i + 1 < content.length && isLinkInlineContent(content[i + 1])) {
+                const link = content[i + 1];
+                const inner = inlineToMarkdown(link.content);
+                const safeHref = escapeMarkdown(link.href);
+                result.push(`![${inner}](${safeHref})`);
+                i += 2;
+                continue;
+            }
+            result.push(applyTextStyles(escapeMarkdown(item.text), item.styles));
+            i += 1;
+            continue;
         }
         if (isLinkInlineContent(item)) {
             const inner = inlineToMarkdown(item.content);
             const safeHref = escapeMarkdown(item.href);
-            return `[${inner}](${safeHref})`;
+            result.push(`[${inner}](${safeHref})`);
+            i += 1;
+            continue;
         }
         if (Array.isArray(item.content)) {
-            return inlineToMarkdown(item.content);
+            result.push(inlineToMarkdown(item.content));
+            i += 1;
+            continue;
         }
-        return "";
-    })
-        .join("");
+        i += 1;
+    }
+    return result.join("");
 }
 function inlineContentToPlainText(content) {
     if (!Array.isArray(content)) {
@@ -497,10 +514,13 @@ function parseInlineMarkdown(text) {
                 pushPlain();
                 const label = cleaned.slice(i + 1, endLabel);
                 const href = cleaned.slice(startLink + 1, endLink);
+                const parsedLabel = parseInlineMarkdown(label);
+                // Ensure link content is never undefined - if empty, add empty text
+                const linkContent = parsedLabel.length > 0 ? parsedLabel : [{ type: "text", text: "", styles: {} }];
                 result.push({
                     type: "link",
                     href: unescapeMarkdown(href),
-                    content: parseInlineMarkdown(label),
+                    content: linkContent,
                 });
                 i = endLink + 1;
                 continue;
@@ -593,14 +613,21 @@ function parseList(lines, startIndex, listType, indentLevel, allowEmptySteps = f
         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;
+        // Only try to parse as testStep for top-level items (indentLevel === 0)
+        // when we're under a Steps heading AND the list type is bullet
+        // Numbered lists under Steps heading are only parsed as test steps if they look like test steps
+        if (indentLevel === 0 && allowEmptySteps) {
+            // For bullet lists, always try to parse as test steps
+            // For numbered lists, only try if they have step-like characteristics
+            const looksLikeTestStep = listType === "bullet" ||
+                (listType === "numbered" && (isLikelyStep(lines, index)));
+            if (looksLikeTestStep) {
+                const nextStep = parseTestStep(lines, index, allowEmptySteps);
+                if (nextStep) {
+                    items.push(nextStep.block);
+                    index = nextStep.nextIndex;
+                    continue;
+                }
             }
         }
         if (listType === "check") {
@@ -639,13 +666,46 @@ function parseList(lines, startIndex, listType, indentLevel, allowEmptySteps = f
     }
     return { items, nextIndex: index };
 }
+function isLikelyStep(lines, index) {
+    // Look ahead to see if there's indented content or expected result
+    if (index + 1 >= lines.length)
+        return false;
+    const nextLine = lines[index + 1];
+    const hasIndent = /^\s{2,}/.test(nextLine);
+    // Check if the next line contains expected result markers
+    const nextTrimmed = nextLine.trim();
+    const hasExpectedResult = EXPECTED_LABEL_REGEX.test(nextTrimmed);
+    // Only consider it a test step if:
+    // 1. It has an expected result, OR
+    // 2. The next line is indented but doesn't start with a numbered or bullet list
+    if (hasExpectedResult)
+        return true;
+    if (hasIndent && !/^\d+[.)]/.test(nextTrimmed) && !/^[-*+]/.test(nextTrimmed))
+        return true;
+    return false;
+}
 function parseTestStep(lines, index, allowEmpty = false, snippetId) {
     const current = lines[index];
     const trimmed = current.trim();
-    if (!trimmed.startsWith("* ") && !trimmed.startsWith("- ")) {
+    const isBullet = trimmed.startsWith("* ") || trimmed.startsWith("- ");
+    const isNumbered = /^\d+[.)]\s+/.test(trimmed);
+    if (!isBullet && !isNumbered) {
+        return null;
+    }
+    // For numbered lists, only parse as test steps if called from parseList with allowEmpty=true
+    // The first call to parseTestStep from markdownToBlocks uses allowEmpty=stepsHeadingLevel !== null
+    // which should be false unless we're under a Steps heading
+    if (isNumbered && !allowEmpty) {
         return null;
     }
-    let rawTitle = unescapeMarkdown(trimmed.slice(2)).trim();
+    let rawTitle;
+    if (isBullet) {
+        rawTitle = unescapeMarkdown(trimmed.slice(2)).trim();
+    }
+    else {
+        // For numbered lists, remove the number and delimiter
+        rawTitle = unescapeMarkdown(trimmed.replace(/^\d+[.)]\s+/, "")).trim();
+    }
     let blockType = "testStep";
     const snippetMatch = rawTitle.match(/^snippet\s*[:\-–—]?\s*(.*)$/i);
     if (snippetMatch) {
@@ -667,7 +727,6 @@ function parseTestStep(lines, index, allowEmpty = false, 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);
@@ -701,7 +760,6 @@ function parseTestStep(lines, index, allowEmpty = false, snippetId) {
         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();
@@ -720,7 +778,6 @@ function parseTestStep(lines, index, allowEmpty = false, snippetId) {
         }
         // 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;
             // Remove the leading * and trim
             let content = rawTrimmed.slice(1).trim();
@@ -776,17 +833,6 @@ function parseTestStep(lines, index, allowEmpty = false, snippetId) {
                     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;
         }
@@ -1014,6 +1060,60 @@ function parseSnippetWrapper(lines, index) {
         nextIndex: next,
     };
 }
+// Post-process blocks to fix malformed image blocks
+export function fixMalformedImageBlocks(blocks) {
+    var _a, _b, _c, _d;
+    const result = [];
+    let i = 0;
+    while (i < blocks.length) {
+        const current = blocks[i];
+        const next = blocks[i + 1];
+        // Skip empty paragraphs
+        if (current.type === "paragraph" &&
+            (!current.content || !Array.isArray(current.content) || current.content.length === 0)) {
+            i += 1;
+            continue;
+        }
+        // Check if current is a paragraph with just "!" - this is definitely a malformed image
+        if (current.type === "paragraph" &&
+            current.content &&
+            Array.isArray(current.content) &&
+            current.content.length === 1 &&
+            ((_a = current.content[0]) === null || _a === void 0 ? void 0 : _a.type) === "text" &&
+            ((_b = current.content[0]) === null || _b === void 0 ? void 0 : _b.text) === "!") {
+            // This is a malformed image block, skip it entirely
+            // The full image was likely parsed as ![](...) but got corrupted
+            i += 1;
+            continue;
+        }
+        // Check if current is a paragraph with just "!" and next is an empty paragraph
+        if (current.type === "paragraph" &&
+            (next === null || next === void 0 ? void 0 : next.type) === "paragraph" &&
+            current.content &&
+            Array.isArray(current.content) &&
+            current.content.length === 1 &&
+            ((_c = current.content[0]) === null || _c === void 0 ? void 0 : _c.type) === "text" &&
+            ((_d = current.content[0]) === null || _d === void 0 ? void 0 : _d.text) === "!" &&
+            (!next.content || !Array.isArray(next.content) || next.content.length === 0)) {
+            // This looks like a malformed image, skip both blocks
+            i += 2;
+            continue;
+        }
+        // Check if current has "!" but no link
+        if (current.type === "paragraph" &&
+            current.content &&
+            Array.isArray(current.content) &&
+            current.content.some((item) => item.type === "text" && item.text === "!") &&
+            !current.content.some((item) => item.type === "link")) {
+            // Skip malformed image block
+            i += 1;
+            continue;
+        }
+        result.push(current);
+        i += 1;
+    }
+    return result;
+}
 export function markdownToBlocks(markdown) {
     var _a, _b;
     const normalized = markdown.replace(/\r\n/g, "\n");
@@ -1051,7 +1151,7 @@ export function markdownToBlocks(markdown) {
             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") {
+            if (normalizedHeading.replace(/[:\-–—]$/, "") === "steps") {
                 stepsHeadingLevel = headingLevel;
             }
             else if (stepsHeadingLevel !== null &&
@@ -1086,7 +1186,7 @@ export function markdownToBlocks(markdown) {
         blocks.push(paragraph.block);
         index = paragraph.nextIndex;
     }
-    return blocks;
+    return fixMalformedImageBlocks(blocks);
 }
 function splitTableRow(line) {
     let value = line.trim();