@xincli/opentui-core 0.4.6

package/src/text-buffer-view.ts

@@ -0,0 +1,193 @@
+import { RGBA } from "./lib/RGBA.js"
+import { resolveRenderLib, type LineInfo, type RenderLib, type TextBufferViewHandle } from "./zig.js"
+import type { TextBuffer } from "./text-buffer.js"
+
+export class TextBufferView {
+  private lib: RenderLib
+  private viewPtr: TextBufferViewHandle
+  private textBuffer: TextBuffer
+  private _destroyed: boolean = false
+
+  constructor(lib: RenderLib, ptr: TextBufferViewHandle, textBuffer: TextBuffer) {
+    this.lib = lib
+    this.viewPtr = ptr
+    this.textBuffer = textBuffer
+  }
+
+  static create(textBuffer: TextBuffer): TextBufferView {
+    const lib = resolveRenderLib()
+    const viewPtr = lib.createTextBufferView(textBuffer.ptr)
+    return new TextBufferView(lib, viewPtr, textBuffer)
+  }
+
+  // Fail loud and clear
+  private guard(): void {
+    if (this._destroyed) throw new Error("TextBufferView is destroyed")
+  }
+
+  public get ptr(): TextBufferViewHandle {
+    this.guard()
+    return this.viewPtr
+  }
+
+  public setSelection(start: number, end: number, bgColor?: RGBA, fgColor?: RGBA): void {
+    this.guard()
+    this.lib.textBufferViewSetSelection(this.viewPtr, start, end, bgColor || null, fgColor || null)
+  }
+
+  public updateSelection(end: number, bgColor?: RGBA, fgColor?: RGBA): void {
+    this.guard()
+    this.lib.textBufferViewUpdateSelection(this.viewPtr, end, bgColor || null, fgColor || null)
+  }
+
+  public resetSelection(): void {
+    this.guard()
+    this.lib.textBufferViewResetSelection(this.viewPtr)
+  }
+
+  public getSelection(): { start: number; end: number } | null {
+    this.guard()
+    return this.lib.textBufferViewGetSelection(this.viewPtr)
+  }
+
+  public hasSelection(): boolean {
+    this.guard()
+    return this.getSelection() !== null
+  }
+
+  public setLocalSelection(
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor?: RGBA,
+    fgColor?: RGBA,
+  ): boolean {
+    this.guard()
+    return this.lib.textBufferViewSetLocalSelection(
+      this.viewPtr,
+      anchorX,
+      anchorY,
+      focusX,
+      focusY,
+      bgColor || null,
+      fgColor || null,
+    )
+  }
+
+  public updateLocalSelection(
+    anchorX: number,
+    anchorY: number,
+    focusX: number,
+    focusY: number,
+    bgColor?: RGBA,
+    fgColor?: RGBA,
+  ): boolean {
+    this.guard()
+    return this.lib.textBufferViewUpdateLocalSelection(
+      this.viewPtr,
+      anchorX,
+      anchorY,
+      focusX,
+      focusY,
+      bgColor || null,
+      fgColor || null,
+    )
+  }
+
+  public resetLocalSelection(): void {
+    this.guard()
+    this.lib.textBufferViewResetLocalSelection(this.viewPtr)
+  }
+
+  public setWrapWidth(width: number | null): void {
+    this.guard()
+    this.lib.textBufferViewSetWrapWidth(this.viewPtr, width ?? 0)
+  }
+
+  public setWrapMode(mode: "none" | "char" | "word"): void {
+    this.guard()
+    this.lib.textBufferViewSetWrapMode(this.viewPtr, mode)
+  }
+
+  public setFirstLineOffset(offset: number): void {
+    this.guard()
+    this.lib.textBufferViewSetFirstLineOffset(this.viewPtr, offset)
+  }
+
+  public setViewportSize(width: number, height: number): void {
+    this.guard()
+    this.lib.textBufferViewSetViewportSize(this.viewPtr, width, height)
+  }
+
+  public setViewport(x: number, y: number, width: number, height: number): void {
+    this.guard()
+    this.lib.textBufferViewSetViewport(this.viewPtr, x, y, width, height)
+  }
+
+  public get lineInfo(): LineInfo {
+    this.guard()
+    return this.lib.textBufferViewGetLineInfo(this.viewPtr)
+  }
+
+  public get logicalLineInfo(): LineInfo {
+    this.guard()
+    return this.lib.textBufferViewGetLogicalLineInfo(this.viewPtr)
+  }
+
+  public getSelectedText(): string {
+    this.guard()
+    const byteSize = this.textBuffer.byteSize
+    if (byteSize === 0) return ""
+
+    const selectedBytes = this.lib.textBufferViewGetSelectedTextBytes(this.viewPtr, byteSize)
+
+    if (!selectedBytes) return ""
+
+    return this.lib.decoder.decode(selectedBytes)
+  }
+
+  public getPlainText(): string {
+    this.guard()
+    const byteSize = this.textBuffer.byteSize
+    if (byteSize === 0) return ""
+
+    const plainBytes = this.lib.textBufferViewGetPlainTextBytes(this.viewPtr, byteSize)
+
+    if (!plainBytes) return ""
+
+    return this.lib.decoder.decode(plainBytes)
+  }
+
+  public setTabIndicator(indicator: string | number): void {
+    this.guard()
+    const codePoint = typeof indicator === "string" ? (indicator.codePointAt(0) ?? 0) : indicator
+    this.lib.textBufferViewSetTabIndicator(this.viewPtr, codePoint)
+  }
+
+  public setTabIndicatorColor(color: RGBA): void {
+    this.guard()
+    this.lib.textBufferViewSetTabIndicatorColor(this.viewPtr, color)
+  }
+
+  public setTruncate(truncate: boolean): void {
+    this.guard()
+    this.lib.textBufferViewSetTruncate(this.viewPtr, truncate)
+  }
+
+  public measureForDimensions(width: number, height: number): { lineCount: number; widthColsMax: number } | null {
+    this.guard()
+    return this.lib.textBufferViewMeasureForDimensions(this.viewPtr, width, height)
+  }
+
+  public getVirtualLineCount(): number {
+    this.guard()
+    return this.lib.textBufferViewGetVirtualLineCount(this.viewPtr)
+  }
+
+  public destroy(): void {
+    if (this._destroyed) return
+    this._destroyed = true
+    this.lib.destroyTextBufferView(this.viewPtr)
+  }
+}

package/src/text-buffer.test.ts

@@ -0,0 +1,512 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test"
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { TextBuffer } from "./text-buffer.js"
+import { resolveRenderLib } from "./zig.js"
+import { StyledText, stringToStyledText } from "./lib/styled-text.js"
+import { RGBA } from "./lib/RGBA.js"
+import { SyntaxStyle } from "./syntax-style.js"
+
+const MALFORMED_UTF8_ABOVE_UNICODE_RANGE = new Uint8Array([0x41, 0xf4, 0x90, 0x80, 0x80, 0x42])
+const MALFORMED_UTF8_TEXT = "A" + "\uFFFD".repeat(4) + "B"
+
+describe("TextBuffer", () => {
+  let buffer: TextBuffer
+
+  beforeEach(() => {
+    buffer = TextBuffer.create("wcwidth")
+  })
+
+  afterEach(() => {
+    buffer.destroy()
+  })
+
+  describe("setText and setStyledText", () => {
+    it("should set text content", () => {
+      const text = "Hello World"
+      buffer.setText(text)
+
+      expect(buffer.length).toBe(11)
+      expect(buffer.byteSize).toBeGreaterThan(0)
+    })
+
+    it("should set styled text", () => {
+      const styledText = stringToStyledText("Hello World")
+      buffer.setStyledText(styledText)
+
+      expect(buffer.length).toBe(11)
+    })
+
+    it("should handle empty text", () => {
+      buffer.setText("")
+
+      expect(buffer.length).toBe(0)
+      expect(buffer.getPlainText()).toBe("")
+    })
+
+    it("should replace existing text with empty text", () => {
+      buffer.setText("Hello World")
+      buffer.setText("")
+
+      expect(buffer.length).toBe(0)
+      expect(buffer.getPlainText()).toBe("")
+    })
+
+    it("should handle empty styled text", () => {
+      const emptyText = stringToStyledText("")
+      buffer.setStyledText(emptyText)
+
+      expect(buffer.length).toBe(0)
+    })
+
+    it("should handle text with newlines", () => {
+      const text = "Line 1\nLine 2\nLine 3"
+      buffer.setText(text)
+
+      expect(buffer.length).toBe(18) // 6 + 6 + 6 chars (newlines not counted)
+    })
+  })
+
+  describe("getPlainText", () => {
+    it("should return empty string for empty buffer", () => {
+      const emptyText = stringToStyledText("")
+      buffer.setStyledText(emptyText)
+
+      const plainText = buffer.getPlainText()
+      expect(plainText).toBe("")
+    })
+
+    it("should return plain text without styling", () => {
+      const styledText = stringToStyledText("Hello World")
+      buffer.setStyledText(styledText)
+
+      const plainText = buffer.getPlainText()
+      expect(plainText).toBe("Hello World")
+    })
+
+    it("should handle text with newlines", () => {
+      const styledText = stringToStyledText("Line 1\nLine 2\nLine 3")
+      buffer.setStyledText(styledText)
+
+      const plainText = buffer.getPlainText()
+      expect(plainText).toBe("Line 1\nLine 2\nLine 3")
+    })
+
+    it("should handle Unicode characters correctly", () => {
+      const styledText = stringToStyledText("Hello 世界 🌟")
+      buffer.setStyledText(styledText)
+
+      const plainText = buffer.getPlainText()
+      expect(plainText).toBe("Hello 世界 🌟")
+    })
+
+    it("should handle styled text with colors and attributes", () => {
+      const redChunk = {
+        __isChunk: true as const,
+        text: "Red",
+        fg: RGBA.fromValues(1, 0, 0, 1),
+      }
+      const newlineChunk = {
+        __isChunk: true as const,
+        text: "\n",
+      }
+      const blueChunk = {
+        __isChunk: true as const,
+        text: "Blue",
+        fg: RGBA.fromValues(0, 0, 1, 1),
+      }
+
+      const styledText = new StyledText([redChunk, newlineChunk, blueChunk])
+      buffer.setStyledText(styledText)
+
+      const plainText = buffer.getPlainText()
+      expect(plainText).toBe("Red\nBlue")
+    })
+
+    it("should return null bytes for zero-length plain-text output buffer", () => {
+      buffer.setText("Hello World")
+
+      const plainBytes = (buffer as any).lib.getPlainTextBytes(buffer.ptr, 0)
+
+      expect(plainBytes).toBeNull()
+    })
+  })
+
+  describe("getTextRange", () => {
+    it("should return null bytes for zero-length range output buffers", () => {
+      buffer.setText("Hello World")
+
+      const lib = (buffer as any).lib
+
+      expect(lib.textBufferGetTextRange(buffer.ptr, 0, 5, 0)).toBeNull()
+      expect(lib.textBufferGetTextRangeByCoords(buffer.ptr, 0, 0, 0, 5, 0)).toBeNull()
+    })
+  })
+
+  describe("line highlights", () => {
+    it("should return an empty list when a line has no highlights", () => {
+      buffer.setText("Hello\nWorld")
+
+      expect(buffer.getLineHighlights(0)).toEqual([])
+      expect(buffer.getLineHighlights(1)).toEqual([])
+    })
+
+    it("should round-trip line highlights through the native highlight buffer", () => {
+      const style = SyntaxStyle.create()
+
+      try {
+        const styleId = style.registerStyle("highlight", {
+          fg: RGBA.fromValues(1, 0, 0, 1),
+        })
+
+        buffer.setSyntaxStyle(style)
+        buffer.setText("Hello World")
+        buffer.addHighlight(0, { start: 0, end: 5, styleId, priority: 7, hlRef: 42 })
+
+        expect(buffer.getLineHighlights(0)).toEqual([{ start: 0, end: 5, styleId, priority: 7, hlRef: 42 }])
+      } finally {
+        style.destroy()
+      }
+    })
+  })
+
+  describe("length property", () => {
+    it("should return correct length for simple text", () => {
+      const styledText = stringToStyledText("Hello World")
+      buffer.setStyledText(styledText)
+
+      expect(buffer.length).toBe(11)
+    })
+
+    it("should return 0 for empty buffer", () => {
+      const emptyText = stringToStyledText("")
+      buffer.setStyledText(emptyText)
+
+      expect(buffer.length).toBe(0)
+    })
+
+    it("should handle text with newlines correctly", () => {
+      const styledText = stringToStyledText("Line 1\nLine 2\nLine 3")
+      buffer.setStyledText(styledText)
+
+      expect(buffer.length).toBe(18) // 6 + 6 + 6 chars (newlines not counted)
+    })
+
+    it("should handle Unicode characters correctly", () => {
+      const styledText = stringToStyledText("Hello 世界 🌟")
+      buffer.setStyledText(styledText)
+
+      expect(buffer.length).toBe(13)
+    })
+  })
+
+  describe("default styles", () => {
+    it("should set and reset default foreground color", () => {
+      const fg = RGBA.fromValues(1, 0, 0, 1)
+      buffer.setDefaultFg(fg)
+      buffer.resetDefaults()
+
+      // No error should be thrown
+      expect(true).toBe(true)
+    })
+
+    it("should set and reset default background color", () => {
+      const bg = RGBA.fromValues(0, 0, 1, 1)
+      buffer.setDefaultBg(bg)
+      buffer.resetDefaults()
+
+      // No error should be thrown
+      expect(true).toBe(true)
+    })
+
+    it("should set and reset default attributes", () => {
+      buffer.setDefaultAttributes(1)
+      buffer.resetDefaults()
+
+      // No error should be thrown
+      expect(true).toBe(true)
+    })
+  })
+
+  describe("clear() vs reset()", () => {
+    it("clear() should empty buffer but preserve text across setText calls", () => {
+      // Set initial text
+      buffer.setText("First text")
+      expect(buffer.length).toBe(10)
+
+      // Set new text (which calls clear() internally)
+      buffer.setText("Second text")
+      expect(buffer.length).toBe(11)
+      expect(buffer.getPlainText()).toBe("Second text")
+
+      // Explicit clear
+      buffer.clear()
+      expect(buffer.length).toBe(0)
+      expect(buffer.getPlainText()).toBe("")
+    })
+
+    it("reset() should fully reset the buffer", () => {
+      buffer.setText("Some text")
+      expect(buffer.length).toBe(9)
+
+      buffer.reset()
+      expect(buffer.length).toBe(0)
+      expect(buffer.getPlainText()).toBe("")
+
+      // Should be able to use buffer after reset
+      buffer.setText("New text")
+      expect(buffer.length).toBe(8)
+    })
+
+    it("setText should preserve highlights (use clear() not reset())", () => {
+      // This test verifies that setText now uses clear() internally
+      // and doesn't clear highlights
+      buffer.setText("Hello World")
+
+      // Note: We can't easily test highlight preservation from TypeScript
+      // without a SyntaxStyle, but we verify the buffer still works
+      expect(buffer.length).toBe(11)
+
+      buffer.setText("New Text")
+      expect(buffer.length).toBe(8)
+      expect(buffer.getPlainText()).toBe("New Text")
+    })
+
+    it("setText should clear styled text chunk highlights", () => {
+      const syntaxStyle = SyntaxStyle.create()
+      buffer.setSyntaxStyle(syntaxStyle)
+      buffer.setStyledText(
+        new StyledText([
+          {
+            __isChunk: true,
+            text: "Styled",
+            fg: RGBA.fromValues(1, 0, 0, 1),
+          },
+        ]),
+      )
+
+      expect(buffer.getHighlightCount()).toBe(1)
+
+      buffer.setText("Plain")
+
+      expect(buffer.getPlainText()).toBe("Plain")
+      expect(buffer.getHighlightCount()).toBe(0)
+
+      syntaxStyle.destroy()
+    })
+
+    it("setText should preserve user highlights including max hlRef", () => {
+      const syntaxStyle = SyntaxStyle.create()
+      const styleId = syntaxStyle.registerStyle("user-highlight", { fg: RGBA.fromValues(0, 1, 0, 1) })
+      buffer.setSyntaxStyle(syntaxStyle)
+      buffer.setText("Hello World")
+      buffer.addHighlight(0, { start: 0, end: 5, styleId, priority: 0, hlRef: 65535 })
+
+      expect(buffer.getHighlightCount()).toBe(1)
+
+      buffer.setText("New Text")
+
+      expect(buffer.getPlainText()).toBe("New Text")
+      expect(buffer.getHighlightCount()).toBe(1)
+      expect(buffer.getLineHighlights(0)[0]?.hlRef).toBe(65535)
+
+      syntaxStyle.destroy()
+    })
+
+    it("setStyledText should preserve content across calls", () => {
+      const firstText = stringToStyledText("First")
+      buffer.setStyledText(firstText)
+      expect(buffer.length).toBe(5)
+
+      const secondText = stringToStyledText("Second")
+      buffer.setStyledText(secondText)
+      expect(buffer.length).toBe(6)
+      expect(buffer.getPlainText()).toBe("Second")
+    })
+
+    it("multiple setText calls should work correctly with clear()", () => {
+      buffer.setText("Text 1")
+      expect(buffer.length).toBe(6)
+
+      buffer.setText("Text 2")
+      expect(buffer.length).toBe(6)
+
+      buffer.setText("Text 3")
+      expect(buffer.length).toBe(6)
+
+      expect(buffer.getPlainText()).toBe("Text 3")
+    })
+
+    it("clear() followed by setText should work", () => {
+      buffer.setText("Initial")
+      expect(buffer.length).toBe(7)
+
+      buffer.clear()
+      expect(buffer.length).toBe(0)
+
+      buffer.setText("After clear")
+      expect(buffer.length).toBe(11)
+      expect(buffer.getPlainText()).toBe("After clear")
+    })
+
+    it("reset() followed by setText should work", () => {
+      buffer.setText("Initial")
+      expect(buffer.length).toBe(7)
+
+      buffer.reset()
+      expect(buffer.length).toBe(0)
+
+      buffer.setText("After reset")
+      expect(buffer.length).toBe(11)
+      expect(buffer.getPlainText()).toBe("After reset")
+    })
+
+    it("recovers if the native memory registry entry was cleared", () => {
+      buffer.setText("Hello World")
+
+      resolveRenderLib().textBufferClearMemRegistry(buffer.ptr)
+
+      buffer.setText("Recovered")
+
+      expect(buffer.length).toBe(9)
+      expect(buffer.byteSize).toBe(9)
+      expect(buffer.getPlainText()).toBe("Recovered")
+    })
+  })
+
+  describe("malformed UTF-8 bytes", () => {
+    it("loadFile should preserve malformed UTF-8 bytes without panicking", () => {
+      const dir = mkdtempSync(join(process.env.OTUI_TEXT_BUFFER_TEST_TMPDIR ?? tmpdir(), "opentui-text-buffer-"))
+      const path = join(dir, "malformed.txt")
+      const unicodeBuffer = TextBuffer.create("unicode")
+
+      try {
+        writeFileSync(path, MALFORMED_UTF8_ABOVE_UNICODE_RANGE)
+
+        unicodeBuffer.loadFile(path)
+
+        expect(unicodeBuffer.byteSize).toBe(6)
+        expect(unicodeBuffer.length).toBe(2)
+        expect(unicodeBuffer.getLineCount()).toBe(1)
+        expect(unicodeBuffer.getPlainText()).toBe(MALFORMED_UTF8_TEXT)
+      } finally {
+        unicodeBuffer.destroy()
+        rmSync(dir, { recursive: true, force: true })
+      }
+    })
+
+    it("textBufferAppend should preserve malformed UTF-8 bytes without panicking", () => {
+      const lib = resolveRenderLib()
+      const unicodeBuffer = TextBuffer.create("unicode")
+
+      try {
+        lib.textBufferAppend(unicodeBuffer.ptr, MALFORMED_UTF8_ABOVE_UNICODE_RANGE)
+
+        expect(lib.textBufferGetByteSize(unicodeBuffer.ptr)).toBe(6)
+        expect(lib.textBufferGetLength(unicodeBuffer.ptr)).toBe(2)
+      } finally {
+        unicodeBuffer.destroy()
+      }
+    })
+  })
+
+  describe("append()", () => {
+    it("should append text to empty buffer", () => {
+      buffer.append("Hello")
+      expect(buffer.length).toBe(5)
+      expect(buffer.getPlainText()).toBe("Hello")
+    })
+
+    it("should append text to existing content", () => {
+      buffer.setText("Hello")
+      buffer.append(" World")
+      expect(buffer.length).toBe(11)
+      expect(buffer.getPlainText()).toBe("Hello World")
+    })
+
+    it("should append text with newlines", () => {
+      buffer.setText("Line 1")
+      buffer.append("\nLine 2")
+      expect(buffer.getPlainText()).toBe("Line 1\nLine 2")
+    })
+
+    it("should append multiple times", () => {
+      buffer.setText("Start")
+      buffer.append(" middle")
+      buffer.append(" end")
+      expect(buffer.getPlainText()).toBe("Start middle end")
+    })
+
+    it("should handle appending empty string", () => {
+      buffer.setText("Hello")
+      const lengthBefore = buffer.length
+      buffer.append("")
+      expect(buffer.length).toBe(lengthBefore)
+      expect(buffer.getPlainText()).toBe("Hello")
+    })
+
+    it("should append empty string to an empty buffer", () => {
+      buffer.append("")
+
+      expect(buffer.length).toBe(0)
+      expect(buffer.getPlainText()).toBe("")
+    })
+
+    it("should append unicode content", () => {
+      buffer.setText("Hello ")
+      buffer.append("世界 🌟")
+      expect(buffer.getPlainText()).toBe("Hello 世界 🌟")
+    })
+
+    it("should handle streaming chunks", () => {
+      buffer.append("First")
+      buffer.append("\nLine2")
+      buffer.append("\n")
+      buffer.append("Line3")
+      buffer.append(" end")
+      expect(buffer.getPlainText()).toBe("First\nLine2\nLine3 end")
+    })
+
+    it("should handle CRLF line endings in append", () => {
+      buffer.append("Line1\r\n")
+      buffer.append("Line2\r\n")
+      buffer.append("Line3")
+      // CRLF should be normalized to LF
+      expect(buffer.getPlainText()).toBe("Line1\nLine2\nLine3")
+    })
+
+    it("should work with clear and append", () => {
+      buffer.setText("Initial")
+      buffer.clear()
+      buffer.append("After clear")
+      expect(buffer.getPlainText()).toBe("After clear")
+    })
+
+    it("should work with reset and append", () => {
+      buffer.setText("Initial")
+      buffer.reset()
+      buffer.append("After reset")
+      expect(buffer.getPlainText()).toBe("After reset")
+    })
+
+    it("should handle large streaming append", () => {
+      for (let i = 0; i < 100; i++) {
+        buffer.append(`Line ${i}\n`)
+      }
+      const result = buffer.getPlainText()
+      expect(result).toContain("Line 0")
+      expect(result).toContain("Line 99")
+    })
+
+    it("should mix setText and append", () => {
+      buffer.setText("First")
+      buffer.append(" appended")
+      expect(buffer.getPlainText()).toBe("First appended")
+
+      buffer.setText("Reset")
+      buffer.append(" again")
+      expect(buffer.getPlainText()).toBe("Reset again")
+    })
+  })
+})