@fairyhunter13/opentui-core 0.1.112 → 0.1.114

package/src/renderables/__tests__/__snapshots__/Textarea.rendering.test.ts.snap

@@ -0,0 +1,387 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`Textarea - Rendering Tests Wrapping should render with tab indicator correctly 1`] = `
+"Line 1→ Tabbed                                                                  
+Line 2→ → Double tab                                                            
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+"
+`;
+
+exports[`Textarea - Rendering Tests Textarea Content Snapshots should render basic text content correctly 1`] = `
+"                                                                                
+                                                                                
+                                                                                
+     Hello World                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+"
+`;
+
+exports[`Textarea - Rendering Tests Textarea Content Snapshots should render multiline text content correctly 1`] = `
+"                                                                                
+ Line 1: Hello                                                                  
+ Line 2: World                                                                  
+ Line 3: Testing                                                                
+ Line 4: Multiline                                                              
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+"
+`;
+
+exports[`Textarea - Rendering Tests Textarea Content Snapshots should render text with character wrapping correctly 1`] = `
+"This is a very                                                                  
+long text that                                                                  
+should wrap to                                                                  
+multiple lines                                                                  
+when wrap is en                                                                 
+abled                                                                           
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+"
+`;
+
+exports[`Textarea - Rendering Tests Textarea Content Snapshots should render text with word wrapping and punctuation 1`] = `
+"Hello,World.                                                                    
+Test-                                                                           
+Example/                                                                        
+Path with                                                                       
+various                                                                         
+punctuation                                                                     
+marks!                                                                          
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+"
+`;
+
+exports[`Textarea - Rendering Tests Textarea Content Snapshots should render placeholder when creating textarea with placeholder directly 1`] = `
+"                                                                                
+ Enter text here...                                                             
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+"
+`;
+
+exports[`Textarea - Rendering Tests Textarea Content Snapshots should render placeholder when set programmatically after creation 1`] = `
+"                                                                                
+ Type something...                                                              
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+"
+`;
+
+exports[`Textarea - Rendering Tests Textarea Content Snapshots should resize correctly when typing return as first input with placeholder 1`] = `
+"                                        
+ ┌──────────────────────────────────────
+ │                                      
+ │                                      
+ └──────────────────────────────────────
+                                        
+                                        
+                                        
+                                        
+                                        
+"
+`;
+
+exports[`Textarea - Rendering Tests Width/Height Setter Layout Tests should not shrink box when width is set via setter 1`] = `
+"┌────────────────────────────┐          
+│>    Content that takes up  │          
+│     space                  │          
+└────────────────────────────┘          
+                                        
+                                        
+                                        
+                                        
+                                        
+                                        
+"
+`;
+
+exports[`Textarea - Rendering Tests Width/Height Setter Layout Tests should not shrink box when height is set via setter in column layout with textarea 1`] = `
+"┌───────────────────────┐     
+│Header                 │     
+│                       │     
+│                       │     
+│Line1                  │     
+│Line2                  │     
+│Line3                  │     
+│Footer                 │     
+│                       │     
+└───────────────────────┘     
+                              
+                              
+                              
+                              
+                              
+"
+`;
+
+exports[`Textarea - Rendering Tests Width/Height Setter Layout Tests should not shrink box when minWidth is set via setter 1`] = `
+"┌────────────────────────────┐          
+│>    Content that takes up  │          
+│     space                  │          
+└────────────────────────────┘          
+                                        
+                                        
+                                        
+                                        
+                                        
+                                        
+"
+`;
+
+exports[`Textarea - Rendering Tests Width/Height Setter Layout Tests should not shrink box when minHeight is set via setter in column layout with textarea 1`] = `
+"┌───────────────────────┐     
+│Header                 │     
+│                       │     
+│                       │     
+│Line1                  │     
+│Line2                  │     
+│Line3                  │     
+│Footer                 │     
+│                       │     
+└───────────────────────┘     
+                              
+                              
+                              
+                              
+                              
+"
+`;
+
+exports[`Textarea - Rendering Tests Width/Height Setter Layout Tests should not shrink box when width is set from undefined via setter 1`] = `
+"┌────────────────────────────┐          
+│>    Content that takes up  │          
+│     space                  │          
+└────────────────────────────┘          
+                                        
+                                        
+                                        
+                                        
+                                        
+                                        
+"
+`;
+
+exports[`Textarea - Rendering Tests Absolute Positioned Box with Textarea should render textarea in absolute positioned box with padding and borders correctly 1`] = `
+"                                                                                
+                                                                                
+                  │                                                          │  
+                  │                                                          │  
+                  │    Important Notification                                │  
+                  │                                                          │  
+                  │                                                          │  
+                  │    This is a longer message that should wrap properly within
+                  │                                                          │  
+                  │                                                          │  
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+"
+`;
+
+exports[`Textarea - Rendering Tests Absolute Positioned Box with Textarea should render textarea fully visible in absolute positioned box at various positions 1`] = `
+"                                                                                                    
+                                                           ┌──────────────────────────────────────┐ 
+                                                           │ Error: File not found in the         │ 
+                                                           │ specified directory path             │ 
+                                                           └──────────────────────────────────────┘ 
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+                                                                                                    
+ ───────────────────────────────────                                                                
+  Success: Operation completed                                                                      
+  successfully!                                                                                     
+ ───────────────────────────────────                                                                
+                                                                                                    
+"
+`;
+
+exports[`Textarea - Rendering Tests Absolute Positioned Box with Textarea should handle width:100% textarea in absolute positioned box with constrained maxWidth 1`] = `
+"                                                                      
+                                                                      
+                                                                      
+                                                                      
+                                                                      
+                                                                      
+                                                                      
+             This is an extremely long piece of text                  
+             that needs to wrap multiple times within                 
+             the constrained width of the absolutely                  
+             positioned container box with significant                
+             padding on all sides.                                    
+                                                                      
+                                                                      
+                                                                      
+"
+`;
+
+exports[`Textarea - Rendering Tests Absolute Positioned Box with Textarea should render multiple textarea elements in absolute positioned box with proper spacing 1`] = `
+"                                                                                          
+                                                                                          
+                                                                                          
+                                        ┌───────────────────────────────────────────┐     
+                                        │                                           │     
+                                        │  System Update                            │     
+                                        │                                           │     
+                                        │  A new version is available with bug      │     
+                                        │  fixes and performance improvements.      │     
+                                        │                                           │     
+                                        │  Click to install                         │     
+                                        │                                           │     
+                                        └───────────────────────────────────────────┘     
+                                                                                          
+                                                                                          
+                                                                                          
+                                                                                          
+                                                                                          
+                                                                                          
+                                                                                          
+"
+`;

package/src/renderables/__tests__/markdown-parser.test.ts

@@ -0,0 +1,217 @@
+import { test, expect } from "bun:test"
+import { Lexer } from "marked"
+import { parseMarkdownIncremental, type ParseState } from "../markdown-parser.js"
+
+test("first parse returns all tokens", () => {
+  const state = parseMarkdownIncremental("# Hello\n\nParagraph", null)
+
+  expect(state.content).toBe("# Hello\n\nParagraph")
+  expect(state.tokens.length).toBeGreaterThan(0)
+  expect(state.tokens[0].type).toBe("heading")
+})
+
+test("reuses unchanged tokens when appending content", () => {
+  const state1 = parseMarkdownIncremental("# Hello\n\nPara 1\n\n", null)
+  const state2 = parseMarkdownIncremental("# Hello\n\nPara 1\n\nPara 2", state1, 0) // No trailing unstable
+
+  // First tokens should be same object reference (reused)
+  expect(state2.tokens[0]).toBe(state1.tokens[0]) // heading
+  expect(state2.tokens[1]).toBe(state1.tokens[1]) // paragraph
+})
+
+test("trailing unstable tokens are re-parsed", () => {
+  const state1 = parseMarkdownIncremental("# Hello\n\nPara 1\n\n", null)
+  const state2 = parseMarkdownIncremental("# Hello\n\nPara 1\n\nPara 2", state1, 2)
+
+  // With trailingUnstable=2, last 2 tokens from state1 should be re-parsed
+  // state1 has: heading, paragraph, space (3 tokens)
+  // With trailing=2, only first token (heading) is stable
+  // So heading token should NOT be reused (since we only have 3 tokens and skip last 2)
+  // Actually with 3 tokens and trailingUnstable=2, we keep 1 token stable
+  expect(state2.tokens.length).toBeGreaterThan(0)
+  // The new tokens are re-parsed versions
+  expect(state2.tokens[0].type).toBe("heading")
+})
+
+test("handles content that diverges from start", () => {
+  const state1 = parseMarkdownIncremental("# Hello", null)
+  const state2 = parseMarkdownIncremental("## World", state1)
+
+  // Content changed from start, no tokens can be reused
+  expect(state2.tokens[0]).not.toBe(state1.tokens[0])
+  expect(state2.tokens[0].type).toBe("heading")
+})
+
+test("handles empty content", () => {
+  const state = parseMarkdownIncremental("", null)
+
+  expect(state.content).toBe("")
+  expect(state.tokens).toEqual([])
+})
+
+test("handles empty previous state", () => {
+  const prevState: ParseState = { content: "", tokens: [] }
+  const state = parseMarkdownIncremental("# Hello", prevState)
+
+  expect(state.tokens.length).toBeGreaterThan(0)
+  expect(state.tokens[0].type).toBe("heading")
+})
+
+test("handles content truncation", () => {
+  const state1 = parseMarkdownIncremental("# Hello\n\nPara 1\n\nPara 2", null)
+  const state2 = parseMarkdownIncremental("# Hello", state1)
+
+  expect(state2.tokens.length).toBe(1)
+  expect(state2.tokens[0].type).toBe("heading")
+})
+
+test("handles partial token match", () => {
+  const state1 = parseMarkdownIncremental("# Hello World", null)
+  const state2 = parseMarkdownIncremental("# Hello", state1)
+
+  // Token at start doesn't match exactly, so it's re-parsed
+  expect(state2.tokens[0]).not.toBe(state1.tokens[0])
+})
+
+test("handles multiple stable tokens with explicit boundaries", () => {
+  // Use content with clear token boundaries that won't change
+  const content1 = "Para 1\n\nPara 2\n\nPara 3\n\n"
+  const state1 = parseMarkdownIncremental(content1, null)
+
+  const content2 = content1 + "Para 4"
+  const state2 = parseMarkdownIncremental(content2, state1, 0)
+
+  // All original tokens should be reused (same object reference)
+  for (let i = 0; i < state1.tokens.length; i++) {
+    expect(state2.tokens[i]).toBe(state1.tokens[i])
+  }
+  // And there should be a new token at the end
+  expect(state2.tokens.length).toBe(state1.tokens.length + 1)
+})
+
+test("code blocks are parsed correctly", () => {
+  const state = parseMarkdownIncremental("```js\nconst x = 1;\n```", null)
+
+  const codeToken = state.tokens.find((t) => t.type === "code")
+  expect(codeToken).toBeDefined()
+  expect((codeToken as any).lang).toBe("js")
+})
+
+test("streaming scenario with incremental typing", () => {
+  let state: ParseState | null = null
+
+  // Simulate typing character by character
+  state = parseMarkdownIncremental("#", state, 2)
+  expect(state.tokens.length).toBe(1)
+
+  state = parseMarkdownIncremental("# ", state, 2)
+  state = parseMarkdownIncremental("# H", state, 2)
+  state = parseMarkdownIncremental("# He", state, 2)
+  state = parseMarkdownIncremental("# Hel", state, 2)
+  state = parseMarkdownIncremental("# Hell", state, 2)
+  state = parseMarkdownIncremental("# Hello", state, 2)
+
+  expect(state.tokens[0].type).toBe("heading")
+  expect((state.tokens[0] as any).text).toBe("Hello")
+})
+
+test("token identity is preserved for stable tokens", () => {
+  // Create initial state with multiple paragraphs
+  const state1 = parseMarkdownIncremental("A\n\nB\n\nC\n\n", null)
+
+  // Append content - with trailingUnstable=0, all tokens should be reused
+  const state2 = parseMarkdownIncremental("A\n\nB\n\nC\n\nD", state1, 0)
+
+  // Verify token identity (same object reference)
+  expect(state2.tokens[0]).toBe(state1.tokens[0])
+  expect(state2.tokens[1]).toBe(state1.tokens[1])
+  expect(state2.tokens[2]).toBe(state1.tokens[2])
+})
+
+test("trailingUnstable re-parses trailing table when new rows are appended", () => {
+  const content1 = "| A |\n|---|\n| 1 |"
+  const state1 = parseMarkdownIncremental(content1, null, 2)
+  const table1 = state1.tokens.find((token) => token.type === "table") as any
+
+  expect(table1).toBeDefined()
+  expect(table1.rows.length).toBe(1)
+
+  const content2 = "| A |\n|---|\n| 1 |\n| 2 |"
+  const state2 = parseMarkdownIncremental(content2, state1, 2)
+  const table2 = state2.tokens.find((token) => token.type === "table") as any
+
+  expect(table2).toBeDefined()
+  expect(table2.rows.length).toBe(2)
+  expect(table2).not.toBe(table1)
+})
+
+test("trailingUnstable updates trailing table rows in multi-table markdown", () => {
+  const table1Markdown = "| T1 |\n|---|\n| a |\n| b |"
+  const table2Markdown = "| T2 |\n|---|\n| 1 |\n| 2 |"
+
+  const content1 = `${table1Markdown}\n\n${table2Markdown}`
+  const state1 = parseMarkdownIncremental(content1, null, 2)
+  const tables1 = state1.tokens.filter((token) => token.type === "table") as any[]
+
+  expect(tables1.length).toBe(2)
+  expect(tables1[0].rows.length).toBe(2)
+  expect(tables1[1].rows.length).toBe(2)
+
+  const content2 = `${table1Markdown}\n\n${table2Markdown}\n| 3 |`
+  const state2 = parseMarkdownIncremental(content2, state1, 2)
+  const tables2 = state2.tokens.filter((token) => token.type === "table") as any[]
+
+  expect(tables2.length).toBe(2)
+  expect(tables2[0].rows.length).toBe(2)
+  expect(tables2[1]).not.toBe(tables1[1])
+  expect(tables2[1].rows.length).toBe(3)
+})
+
+test("falls back to full re-parse when incremental tail parse fails", () => {
+  const content1 = "| A |\n|---|\n| 1 |"
+  const content2 = "| A |\n|---|\n| 1 |\n| 2 |"
+  const state1 = parseMarkdownIncremental(content1, null, 2)
+
+  const lexerRef = Lexer as unknown as { lex: typeof Lexer.lex }
+  const originalLex = lexerRef.lex
+  let lexCalls = 0
+
+  lexerRef.lex = ((src, options) => {
+    lexCalls += 1
+    if (lexCalls === 1) {
+      throw new Error("incremental tail parse failed")
+    }
+    return originalLex(src, options)
+  }) as typeof Lexer.lex
+
+  try {
+    const state2 = parseMarkdownIncremental(content2, state1, 2)
+    const table = state2.tokens.find((token) => token.type === "table") as any
+
+    expect(lexCalls).toBeGreaterThanOrEqual(2)
+    expect(table).toBeDefined()
+    expect(table.rows.length).toBe(2)
+  } finally {
+    lexerRef.lex = originalLex
+  }
+})
+
+test("returns empty token list when both incremental and full parse fail", () => {
+  const content1 = "| A |\n|---|\n| 1 |"
+  const content2 = "| A |\n|---|\n| 1 |\n| 2 |"
+  const state1 = parseMarkdownIncremental(content1, null, 2)
+
+  const lexerRef = Lexer as unknown as { lex: typeof Lexer.lex }
+  const originalLex = lexerRef.lex
+
+  lexerRef.lex = (() => {
+    throw new Error("parse failed")
+  }) as typeof Lexer.lex
+
+  try {
+    const state2 = parseMarkdownIncremental(content2, state1, 2)
+    expect(state2.tokens).toEqual([])
+  } finally {
+    lexerRef.lex = originalLex
+  }
+})

package/src/renderables/__tests__/renderable-test-utils.ts

@@ -0,0 +1,60 @@
+import { TextareaRenderable } from "../Textarea.js"
+import { type TestRenderer } from "../../testing/test-renderer.js"
+import { type TextareaOptions } from "../Textarea.js"
+import type { DiffRenderable } from "../Diff.js"
+import type { CodeRenderable } from "../Code.js"
+import type { MockTreeSitterClient } from "../../testing/mock-tree-sitter-client.js"
+import type { ManualClock } from "../../testing/manual-clock.js"
+
+export async function createTextareaRenderable(
+  renderer: TestRenderer,
+  renderOnce: () => Promise<void>,
+  options: TextareaOptions,
+): Promise<{ textarea: TextareaRenderable; root: any }> {
+  const textareaRenderable = new TextareaRenderable(renderer, { left: 0, top: 0, ...options })
+  renderer.root.add(textareaRenderable)
+  await renderOnce()
+
+  return { textarea: textareaRenderable, root: renderer.root }
+}
+
+// Settle Diff highlighting deterministically. Each iteration:
+// 1. Render twice — the first render may trigger Diff.requestRebuild via microtask
+//    (runs during renderOnce's internal awaits), which calls requestRender while
+//    rendering=true, setting immediateRerenderRequested. The resulting re-render
+//    is scheduled via clock.setTimeout (ManualClock), so needs a second renderOnce.
+// 2. Resolve all pending highlights (proper signal via mock)
+// 3. Await Code.highlightingDone on both sides (proper signal from Code)
+// Loop exits when mock has no more pending requests (state-based, not count-based).
+export async function settleDiffHighlighting(
+  diff: DiffRenderable,
+  client: MockTreeSitterClient,
+  render: () => Promise<void>,
+) {
+  const MAX = 15
+  for (let i = 0; i < MAX; i++) {
+    await render()
+    await render()
+    if (!client.isHighlighting()) break
+    client.resolveAllHighlightOnce()
+    const left: CodeRenderable | null = (diff as any).leftCodeRenderable
+    const right: CodeRenderable | null = (diff as any).rightCodeRenderable
+    if (left) await left.highlightingDone
+    if (right) await right.highlightingDone
+  }
+}
+
+// Simulate the passage of time by advancing a ManualClock and rendering frames.
+// Useful for testing animations, scroll momentum, and other time-dependent behavior.
+export async function simulateFrames(
+  clock: ManualClock,
+  renderOnce: () => Promise<void>,
+  ms: number,
+  frameInterval: number = 50,
+): Promise<void> {
+  const frames = Math.ceil(ms / frameInterval)
+  for (let i = 0; i < frames; i++) {
+    clock.advance(frameInterval)
+    await renderOnce()
+  }
+}