fix: render text and links together in mixed content lines (#14)

When a line contains both plain text and a quoted link (e.g., "Don't have an account? "Sign up""),
both parts are now correctly parsed and rendered. Previously, only the link was rendered
and the plain text before/after it was lost.

The fix adds link pattern detection to splitInlineSegments(), which now recognizes
quoted text as LinkSegment similar to how it handles button patterns. For mixed content,
elements are wrapped in a Row. For standalone links, they pass through the ParserRegistry
to use LinkParser's existing slugify logic for consistent ID generation.

Tests added:
- parses both text and link from mixed text-link line
- parses link at start followed by text
- parses text with link in middle

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: wickedev

src/index.test.ts

@@ -251,6 +251,148 @@ describe('onSceneChange callback (Issue #2)', () => {
   });
 });
 
+describe('mixed text and link content (Issue #14)', () => {
+  // Regression test for issue #14: Text before link not rendering in mixed text-link line
+  // When a line contains both plain text and a link (e.g., "Don't have an account? "Sign up""),
+  // both parts should be rendered, not just the link.
+
+  const mixedTextLinkWireframe = `
+@scene: test
+
++---------------------------------------+
+|   Don't have an account? "Sign up"    |
++---------------------------------------+
+`;
+
+  test('parses both text and link from mixed text-link line', () => {
+    const result = parse(mixedTextLinkWireframe);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.ast.scenes).toHaveLength(1);
+      const scene = result.ast.scenes[0];
+
+      // Should have elements (likely a Row containing Text and Link)
+      expect(scene.elements.length).toBeGreaterThan(0);
+
+      // Helper to recursively find elements
+      const findElements = (elements: any[], tags: string[]): any[] => {
+        const found: any[] = [];
+        for (const el of elements) {
+          if (tags.includes(el.TAG)) {
+            found.push(el);
+          }
+          if (el.children) {
+            found.push(...findElements(el.children, tags));
+          }
+        }
+        return found;
+      };
+
+      // Find all Text and Link elements
+      const textElements = findElements(scene.elements, ['Text']);
+      const linkElements = findElements(scene.elements, ['Link']);
+
+      // Should have at least one Text element containing "Don't have an account?"
+      const hasAccountText = textElements.some(
+        (t) => t.content && t.content.includes("Don't have an account?")
+      );
+      expect(hasAccountText).toBe(true);
+
+      // Should have the "Sign up" link
+      const hasSignUpLink = linkElements.some((l) => l.text === 'Sign up');
+      expect(hasSignUpLink).toBe(true);
+    }
+  });
+
+  test('parses link at start followed by text', () => {
+    const wireframe = `
+@scene: test
+
++----------------------------+
+|  "Click here" for details  |
++----------------------------+
+`;
+
+    const result = parse(wireframe);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      const scene = result.ast.scenes[0];
+
+      const findElements = (elements: any[], tags: string[]): any[] => {
+        const found: any[] = [];
+        for (const el of elements) {
+          if (tags.includes(el.TAG)) {
+            found.push(el);
+          }
+          if (el.children) {
+            found.push(...findElements(el.children, tags));
+          }
+        }
+        return found;
+      };
+
+      const textElements = findElements(scene.elements, ['Text']);
+      const linkElements = findElements(scene.elements, ['Link']);
+
+      // Should have "Click here" link
+      const hasClickHereLink = linkElements.some((l) => l.text === 'Click here');
+      expect(hasClickHereLink).toBe(true);
+
+      // Should have "for details" text
+      const hasDetailsText = textElements.some(
+        (t) => t.content && t.content.includes('for details')
+      );
+      expect(hasDetailsText).toBe(true);
+    }
+  });
+
+  test('parses text with link in middle', () => {
+    const wireframe = `
+@scene: test
+
++------------------------------------+
+|  Please "click here" to continue  |
++------------------------------------+
+`;
+
+    const result = parse(wireframe);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      const scene = result.ast.scenes[0];
+
+      const findElements = (elements: any[], tags: string[]): any[] => {
+        const found: any[] = [];
+        for (const el of elements) {
+          if (tags.includes(el.TAG)) {
+            found.push(el);
+          }
+          if (el.children) {
+            found.push(...findElements(el.children, tags));
+          }
+        }
+        return found;
+      };
+
+      const textElements = findElements(scene.elements, ['Text']);
+      const linkElements = findElements(scene.elements, ['Link']);
+
+      // Should have "click here" link
+      expect(linkElements.some((l) => l.text === 'click here')).toBe(true);
+
+      // Should have both text parts
+      const hasPlease = textElements.some((t) => t.content && t.content.includes('Please'));
+      const hasContinue = textElements.some(
+        (t) => t.content && t.content.includes('to continue')
+      );
+      expect(hasPlease).toBe(true);
+      expect(hasContinue).toBe(true);
+    }
+  });
+});
+
 describe('device option override (Issue #11)', () => {
   const desktopWireframe = `
 @scene: test

src/parser/Semantic/SemanticParser.res

@@ -727,6 +727,62 @@ let splitInlineSegments = (line: string): array<inlineSegment> => {
           i := i.contents + 1
         }
       }
+    } else if char === "\"" {
+      // Check for link pattern "..."
+      let linkStart = i.contents
+      let start = i.contents + 1
+      let endPos = ref(None)
+      let j = ref(start)
+      // Find matching closing quote, handling escaped quotes
+      while j.contents < len && endPos.contents === None {
+        let currentChar = line->String.charAt(j.contents)
+        if currentChar === "\"" {
+          // Check if this quote is escaped (preceded by backslash)
+          let isEscaped = j.contents > start && line->String.charAt(j.contents - 1) === "\\"
+          if !isEscaped {
+            endPos := Some(j.contents)
+          }
+        }
+        j := j.contents + 1
+      }
+
+      switch endPos.contents {
+      | Some(end) => {
+          let quotedContent = line->String.slice(~start, ~end)
+          let trimmedContent = quotedContent->String.trim
+
+          // Check if the quoted content is not empty
+          if trimmedContent !== "" {
+            // Flush any accumulated text before the link
+            let text = currentText.contents->String.trim
+            if text !== "" {
+              let leadingSpaces = String.length(currentText.contents) - String.length(currentText.contents->String.trimStart)
+              segments->Array.push(TextSegment(text, currentTextStart.contents + leadingSpaces))->ignore
+            }
+            currentText := ""
+
+            // Add the link segment
+            segments->Array.push(LinkSegment(trimmedContent, linkStart))->ignore
+            i := end + 1
+            currentTextStart := i.contents
+          } else {
+            // Empty quoted content, treat as regular text
+            if currentText.contents === "" {
+              currentTextStart := i.contents
+            }
+            currentText := currentText.contents ++ char
+            i := i.contents + 1
+          }
+        }
+      | None => {
+          // No matching closing quote, treat as regular text
+          if currentText.contents === "" {
+            currentTextStart := i.contents
+          }
+          currentText := currentText.contents ++ char
+          i := i.contents + 1
+        }
+      }
     } else {
       // Regular character
       if currentText.contents === "" {
@@ -965,11 +1021,14 @@ let segmentToElement = (
       let actualCol = baseCol + colOffset
       let position = Position.make(basePosition.row, actualCol)
 
+      // Use the same slugify logic as LinkParser for consistent ID generation
       let id = text
         ->String.trim
         ->String.toLowerCase
         ->Js.String2.replaceByRe(%re("/\\s+/g"), "-")
         ->Js.String2.replaceByRe(%re("/[^a-z0-9-]/g"), "")
+        ->Js.String2.replaceByRe(%re("/-+/g"), "-")
+        ->Js.String2.replaceByRe(%re("/^-+|-+$/g"), "")
 
       let align = AlignmentCalc.calculateWithStrategy(
         text,
@@ -1046,10 +1105,12 @@ let parseContentLine = (
           Some(registry->ParserRegistry.parse(buttonContent, position, box.bounds))
         }
       | Some(LinkSegment(text, colOffset)) => {
-          // For LinkSegment, we also need to account for leading spaces
+          // For single LinkSegment, pass through to ParserRegistry to use LinkParser's slugify
           let actualCol = baseCol + leadingSpaces + colOffset
-          let adjustedPosition = Position.make(basePosition.row, actualCol)
-          Some(segmentToElement(LinkSegment(text, colOffset), adjustedPosition, baseCol + leadingSpaces, box.bounds))
+          let position = Position.make(row, actualCol)
+          // Reconstruct the quoted text format for the parser
+          let linkContent = "\"" ++ text ++ "\""
+          Some(registry->ParserRegistry.parse(linkContent, position, box.bounds))
         }
       | Some(TextSegment(_, _)) | None => {
           // For single text segment, use original position calculation