@fairyhunter13/opentui-core 0.1.91 → 0.1.94

package/src/renderables/Code.ts

@@ -1,357 +0,0 @@
-import { type RenderContext } from "../types.js"
-import { StyledText } from "../lib/styled-text.js"
-import { SyntaxStyle } from "../syntax-style.js"
-import { getTreeSitterClient, treeSitterToStyledText, TreeSitterClient } from "../lib/tree-sitter/index.js"
-import { TextBufferRenderable, type TextBufferOptions } from "./TextBufferRenderable.js"
-import type { OptimizedBuffer } from "../buffer.js"
-import type { SimpleHighlight } from "../lib/tree-sitter/types.js"
-import type { TextChunk } from "../text-buffer.js"
-import { treeSitterToTextChunks } from "../lib/tree-sitter-styled-text.js"
-
-export interface HighlightContext {
-  content: string
-  filetype: string
-  syntaxStyle: SyntaxStyle
-}
-
-export type OnHighlightCallback = (
-  highlights: SimpleHighlight[],
-  context: HighlightContext,
-) => SimpleHighlight[] | undefined | Promise<SimpleHighlight[] | undefined>
-
-export interface ChunkRenderContext extends HighlightContext {
-  highlights: SimpleHighlight[]
-}
-
-export type OnChunksCallback = (
-  chunks: TextChunk[],
-  context: ChunkRenderContext,
-) => TextChunk[] | undefined | Promise<TextChunk[] | undefined>
-
-export interface CodeOptions extends TextBufferOptions {
-  content?: string
-  filetype?: string
-  syntaxStyle: SyntaxStyle
-  treeSitterClient?: TreeSitterClient
-  conceal?: boolean
-  drawUnstyledText?: boolean
-  streaming?: boolean
-  onHighlight?: OnHighlightCallback
-  onChunks?: OnChunksCallback
-}
-
-export class CodeRenderable extends TextBufferRenderable {
-  private _content: string
-  private _filetype?: string
-  private _syntaxStyle: SyntaxStyle
-  private _isHighlighting: boolean = false
-  private _treeSitterClient: TreeSitterClient
-  private _highlightsDirty: boolean = false
-  private _highlightSnapshotId: number = 0
-  private _conceal: boolean
-  private _drawUnstyledText: boolean
-  private _shouldRenderTextBuffer: boolean = true
-  private _streaming: boolean
-  private _hadInitialContent: boolean = false
-  private _lastHighlights: SimpleHighlight[] = []
-  private _onHighlight?: OnHighlightCallback
-  private _onChunks?: OnChunksCallback
-  private _highlightingPromise: Promise<void> = Promise.resolve()
-
-  protected _contentDefaultOptions = {
-    content: "",
-    conceal: true,
-    drawUnstyledText: true,
-    streaming: false,
-  } satisfies Partial<CodeOptions>
-
-  constructor(ctx: RenderContext, options: CodeOptions) {
-    super(ctx, options)
-
-    this._content = options.content ?? this._contentDefaultOptions.content
-    this._filetype = options.filetype
-    this._syntaxStyle = options.syntaxStyle
-    this._treeSitterClient = options.treeSitterClient ?? getTreeSitterClient()
-    this._conceal = options.conceal ?? this._contentDefaultOptions.conceal
-    this._drawUnstyledText = options.drawUnstyledText ?? this._contentDefaultOptions.drawUnstyledText
-    this._streaming = options.streaming ?? this._contentDefaultOptions.streaming
-    this._onHighlight = options.onHighlight
-    this._onChunks = options.onChunks
-
-    if (this._content.length > 0) {
-      this.textBuffer.setText(this._content)
-      this.updateTextInfo()
-      this._shouldRenderTextBuffer = this._drawUnstyledText || !this._filetype
-    }
-
-    this._highlightsDirty = this._content.length > 0
-  }
-
-  get content(): string {
-    return this._content
-  }
-
-  set content(value: string) {
-    if (this._content !== value) {
-      this._content = value
-      this._highlightsDirty = true
-      this._highlightSnapshotId++
-
-      if (this._streaming && !this._drawUnstyledText && this._filetype) {
-        return
-      }
-
-      this.textBuffer.setText(value)
-      this.updateTextInfo()
-    }
-  }
-
-  get filetype(): string | undefined {
-    return this._filetype
-  }
-
-  set filetype(value: string | undefined) {
-    if (this._filetype !== value) {
-      this._filetype = value
-      this._highlightsDirty = true
-    }
-  }
-
-  get syntaxStyle(): SyntaxStyle {
-    return this._syntaxStyle
-  }
-
-  set syntaxStyle(value: SyntaxStyle) {
-    if (this._syntaxStyle !== value) {
-      this._syntaxStyle = value
-      this._highlightsDirty = true
-    }
-  }
-
-  get conceal(): boolean {
-    return this._conceal
-  }
-
-  set conceal(value: boolean) {
-    if (this._conceal !== value) {
-      this._conceal = value
-      this._highlightsDirty = true
-    }
-  }
-
-  get drawUnstyledText(): boolean {
-    return this._drawUnstyledText
-  }
-
-  set drawUnstyledText(value: boolean) {
-    if (this._drawUnstyledText !== value) {
-      this._drawUnstyledText = value
-      this._highlightsDirty = true
-    }
-  }
-
-  get streaming(): boolean {
-    return this._streaming
-  }
-
-  set streaming(value: boolean) {
-    if (this._streaming !== value) {
-      this._streaming = value
-      this._hadInitialContent = false
-      this._lastHighlights = []
-      this._highlightsDirty = true
-    }
-  }
-
-  get treeSitterClient(): TreeSitterClient {
-    return this._treeSitterClient
-  }
-
-  set treeSitterClient(value: TreeSitterClient) {
-    if (this._treeSitterClient !== value) {
-      this._treeSitterClient = value
-      this._highlightsDirty = true
-    }
-  }
-
-  get onHighlight(): OnHighlightCallback | undefined {
-    return this._onHighlight
-  }
-
-  set onHighlight(value: OnHighlightCallback | undefined) {
-    if (this._onHighlight !== value) {
-      this._onHighlight = value
-      this._highlightsDirty = true
-    }
-  }
-
-  get onChunks(): OnChunksCallback | undefined {
-    return this._onChunks
-  }
-
-  set onChunks(value: OnChunksCallback | undefined) {
-    if (this._onChunks !== value) {
-      this._onChunks = value
-      this._highlightsDirty = true
-    }
-  }
-
-  get isHighlighting(): boolean {
-    return this._isHighlighting
-  }
-
-  get highlightingDone(): Promise<void> {
-    return this._highlightingPromise
-  }
-
-  protected async transformChunks(chunks: TextChunk[], context: ChunkRenderContext): Promise<TextChunk[]> {
-    if (!this._onChunks) return chunks
-
-    const modified = await this._onChunks(chunks, context)
-    return modified ?? chunks
-  }
-
-  private ensureVisibleTextBeforeHighlight(): void {
-    if (this.isDestroyed) return
-
-    const content = this._content
-
-    if (!this._filetype) {
-      this._shouldRenderTextBuffer = true
-      return
-    }
-
-    const isInitialContent = this._streaming && !this._hadInitialContent
-    const shouldDrawUnstyledNow = this._streaming ? isInitialContent && this._drawUnstyledText : this._drawUnstyledText
-
-    if (this._streaming && !isInitialContent) {
-      this._shouldRenderTextBuffer = true
-    } else if (shouldDrawUnstyledNow) {
-      this.textBuffer.setText(content)
-      this._shouldRenderTextBuffer = true
-    } else {
-      this._shouldRenderTextBuffer = false
-    }
-  }
-
-  private async startHighlight(): Promise<void> {
-    const content = this._content
-    const filetype = this._filetype
-    const snapshotId = ++this._highlightSnapshotId
-
-    if (!filetype) return
-
-    const isInitialContent = this._streaming && !this._hadInitialContent
-    if (isInitialContent) {
-      this._hadInitialContent = true
-    }
-
-    this._isHighlighting = true
-
-    try {
-      const result = await this._treeSitterClient.highlightOnce(content, filetype)
-
-      if (snapshotId !== this._highlightSnapshotId) {
-        return
-      }
-
-      if (this.isDestroyed) return
-
-      let highlights = result.highlights ?? []
-
-      if (this._onHighlight && highlights.length >= 0) {
-        const context: HighlightContext = {
-          content,
-          filetype,
-          syntaxStyle: this._syntaxStyle,
-        }
-        const modified = await this._onHighlight(highlights, context)
-        if (modified !== undefined) {
-          highlights = modified
-        }
-      }
-
-      if (snapshotId !== this._highlightSnapshotId) {
-        return
-      }
-
-      if (this.isDestroyed) return
-
-      if (highlights.length > 0) {
-        if (this._streaming) {
-          this._lastHighlights = highlights
-        }
-      }
-
-      if (highlights.length > 0 || this._onChunks) {
-        const context: ChunkRenderContext = {
-          content,
-          filetype,
-          syntaxStyle: this._syntaxStyle,
-          highlights,
-        }
-
-        let chunks = treeSitterToTextChunks(content, highlights, this._syntaxStyle, {
-          enabled: this._conceal,
-        })
-
-        chunks = await this.transformChunks(chunks, context)
-
-        if (snapshotId !== this._highlightSnapshotId) {
-          return
-        }
-
-        if (this.isDestroyed) return
-
-        const styledText = new StyledText(chunks)
-        this.textBuffer.setStyledText(styledText)
-      } else {
-        this.textBuffer.setText(content)
-      }
-
-      this._shouldRenderTextBuffer = true
-      this._isHighlighting = false
-      this._highlightsDirty = false
-      this.updateTextInfo()
-      this.requestRender()
-    } catch (error) {
-      if (snapshotId !== this._highlightSnapshotId) {
-        return
-      }
-
-      console.warn("Code highlighting failed, falling back to plain text:", error)
-      if (this.isDestroyed) return
-      this.textBuffer.setText(content)
-      this._shouldRenderTextBuffer = true
-      this._isHighlighting = false
-      this._highlightsDirty = false
-      this.updateTextInfo()
-      this.requestRender()
-    }
-  }
-
-  public getLineHighlights(lineIdx: number) {
-    return this.textBuffer.getLineHighlights(lineIdx)
-  }
-
-  protected override renderSelf(buffer: OptimizedBuffer): void {
-    if (this._highlightsDirty) {
-      if (this.isDestroyed) return
-
-      if (this._content.length === 0) {
-        this._shouldRenderTextBuffer = false
-        this._highlightsDirty = false
-      } else if (!this._filetype) {
-        this._shouldRenderTextBuffer = true
-        this._highlightsDirty = false
-      } else {
-        this.ensureVisibleTextBeforeHighlight()
-        this._highlightsDirty = false
-        this._highlightingPromise = this.startHighlight()
-      }
-    }
-
-    if (!this._shouldRenderTextBuffer) return
-    super.renderSelf(buffer)
-  }
-}

package/src/renderables/Diff.regression.test.ts

@@ -1,226 +0,0 @@
-import { test, expect, beforeEach, afterEach } from "bun:test"
-import { DiffRenderable } from "./Diff.js"
-import { SyntaxStyle } from "../syntax-style.js"
-import { RGBA } from "../lib/RGBA.js"
-import { createTestRenderer, type TestRenderer } from "../testing.js"
-import { ManualClock } from "../testing/manual-clock.js"
-import { MockTreeSitterClient } from "../testing/mock-tree-sitter-client.js"
-import type { SimpleHighlight } from "../lib/tree-sitter/types.js"
-import { BoxRenderable } from "./Box.js"
-import { settleDiffHighlighting } from "./__tests__/renderable-test-utils.js"
-
-let currentRenderer: TestRenderer
-let renderOnce: () => Promise<void>
-let captureFrame: () => string
-let mockClient: MockTreeSitterClient
-let clock: ManualClock
-
-beforeEach(async () => {
-  mockClient = new MockTreeSitterClient()
-  clock = new ManualClock()
-
-  const testRenderer = await createTestRenderer({
-    width: 32,
-    height: 10,
-    gatherStats: true,
-    clock,
-  })
-  currentRenderer = testRenderer.renderer
-  renderOnce = testRenderer.renderOnce
-  captureFrame = testRenderer.captureCharFrame
-})
-
-afterEach(async () => {
-  if (currentRenderer) {
-    currentRenderer.destroy()
-  }
-})
-
-// When highlights conceal formatting characters (like **), line lengths change,
-// potentially triggering wrapping changes, height changes, and onResize.
-// This test ensures onResize doesn't cause content resets that create endless loops.
-test("DiffRenderable - no endless loop when concealing markdown formatting", async () => {
-  const syntaxStyle = SyntaxStyle.fromStyles({
-    default: { fg: RGBA.fromValues(1, 1, 1, 1) },
-  })
-
-  const markdownDiff = `--- a/test.md
-+++ b/test.md
-@@ -1,2 +1,2 @@
--Some text **boldtext**
--Short
-+Some text **boldtext**
-+More text **formats**`
-
-  const mockHighlights: SimpleHighlight[] = [
-    [10, 11, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [11, 12, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [20, 21, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [21, 22, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [33, 34, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [34, 35, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [42, 43, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [43, 44, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-  ]
-
-  mockClient.setMockResult({ highlights: mockHighlights })
-
-  const box = new BoxRenderable(currentRenderer, {
-    id: "background-box",
-    border: true,
-  })
-
-  const diffRenderable = new DiffRenderable(currentRenderer, {
-    id: "test-diff",
-    diff: markdownDiff,
-    syntaxStyle,
-    filetype: "markdown",
-    conceal: true,
-    treeSitterClient: mockClient,
-  })
-
-  box.add(diffRenderable)
-  currentRenderer.root.add(box)
-
-  await renderOnce()
-  diffRenderable.view = "split"
-
-  await renderOnce()
-  diffRenderable.wrapMode = "word"
-
-  await settleDiffHighlighting(diffRenderable, mockClient, renderOnce)
-
-  const stats = currentRenderer.getStats()
-  expect(stats.frameCount).toBeLessThan(25)
-})
-
-// Tests that line numbers align correctly and gutter heights are properly sized
-// when switching between view modes and wrap modes in split view
-test("DiffRenderable - line number alignment and gutter heights in split view with wrapping", async () => {
-  const syntaxStyle = SyntaxStyle.fromStyles({
-    default: { fg: RGBA.fromValues(1, 1, 1, 1) },
-  })
-
-  const markdownDiff = `--- a/test.md
-+++ b/test.md
-@@ -1,2 +1,2 @@
--Some text **boldtext**
--Short
-+Some text **boldtext**
-+More text **formats**`
-
-  const mockHighlights: SimpleHighlight[] = [
-    [10, 11, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [11, 12, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [20, 21, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [21, 22, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [33, 34, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [34, 35, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [42, 43, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-    [43, 44, "conceal", { isInjection: true, injectionLang: "markdown_inline", conceal: "" }],
-  ]
-
-  mockClient.setMockResult({ highlights: mockHighlights })
-
-  const box = new BoxRenderable(currentRenderer, {
-    id: "background-box",
-    border: true,
-  })
-
-  const diffRenderable = new DiffRenderable(currentRenderer, {
-    id: "test-diff",
-    diff: markdownDiff,
-    syntaxStyle,
-    filetype: "markdown",
-    conceal: true,
-    treeSitterClient: mockClient,
-  })
-
-  box.add(diffRenderable)
-  currentRenderer.root.add(box)
-
-  await renderOnce()
-  const unifiedFrame = captureFrame()
-
-  expect(unifiedFrame).toContain("1 - Some text")
-  expect(unifiedFrame).toContain("2 - Short")
-  expect(unifiedFrame).toContain("1 + Some text")
-  expect(unifiedFrame).toContain("2 + More text")
-
-  diffRenderable.view = "split"
-  await renderOnce()
-  const splitFrame = captureFrame()
-
-  expect(splitFrame).toContain("1 - Some text")
-  expect(splitFrame).toContain("1 + Some text")
-  expect(splitFrame).toContain("2 - Short")
-  expect(splitFrame).toContain("2 + More text")
-
-  // First wrapMode toggle: none → word
-  diffRenderable.wrapMode = "word"
-  await settleDiffHighlighting(diffRenderable, mockClient, renderOnce)
-  const splitWrapFrame = captureFrame()
-
-  const diffChildren = diffRenderable.getChildren()
-  const lines = splitWrapFrame.split("\n")
-
-  let leftLine2Row = -1
-  let rightLine2Row = -1
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    if (line.includes("2 - Short")) {
-      leftLine2Row = i
-    }
-    if (line.includes("2 + More")) {
-      rightLine2Row = i
-    }
-  }
-
-  expect(leftLine2Row).toBeGreaterThan(-1)
-  expect(rightLine2Row).toBeGreaterThan(-1)
-  expect(leftLine2Row).toBe(rightLine2Row)
-  const leftSide = diffChildren[0]
-  const rightSide = diffChildren[1]
-  const leftGutter = leftSide.getChildren()[0]
-  const rightGutter = rightSide.getChildren()[0]
-  const leftCode = leftSide.getChildren()[1]
-  const rightCode = rightSide.getChildren()[1]
-
-  const leftVisualLines = (leftCode as any).lineInfo?.lineSources?.length || 0
-  const rightVisualLines = (rightCode as any).lineInfo?.lineSources?.length || 0
-
-  expect(leftVisualLines).toBe(rightVisualLines)
-  expect(leftGutter.height).toBe(leftVisualLines)
-  expect(rightGutter.height).toBe(rightVisualLines)
-
-  // Second wrapMode toggle: word → none → word
-  diffRenderable.wrapMode = "none"
-  await renderOnce()
-  diffRenderable.wrapMode = "word"
-  await settleDiffHighlighting(diffRenderable, mockClient, renderOnce)
-  const splitWrapFrame2 = captureFrame()
-  const lines2 = splitWrapFrame2.split("\n")
-  let leftLine2Row2 = -1
-  let rightLine2Row2 = -1
-
-  for (let i = 0; i < lines2.length; i++) {
-    const line = lines2[i]
-    if (line.includes("2 - Short")) {
-      leftLine2Row2 = i
-    }
-    if (line.includes("2 + More")) {
-      rightLine2Row2 = i
-    }
-  }
-
-  expect(leftLine2Row2).toBeGreaterThan(-1)
-  expect(rightLine2Row2).toBeGreaterThan(-1)
-  expect(leftLine2Row2).toBe(rightLine2Row2)
-
-  expect(splitWrapFrame2).toContain("1 - Some text")
-  expect(splitWrapFrame2).toContain("boldtext")
-  expect(splitWrapFrame2).toContain("2 - Short")
-  expect(splitWrapFrame2).toContain("2 + More text")
-  expect(splitWrapFrame2).toContain("formats")
-})