@fairyhunter13/opentui-core 0.1.112 → 0.1.114

package/src/text-buffer-view.ts

@@ -0,0 +1,189 @@
+import { RGBA } from "./lib/RGBA.js"
+import { resolveRenderLib, type LineInfo, type RenderLib } from "./zig.js"
+import { type Pointer } from "bun:ffi"
+import type { TextBuffer } from "./text-buffer.js"
+
+export class TextBufferView {
+  private lib: RenderLib
+  private viewPtr: Pointer
+  private textBuffer: TextBuffer
+  private _destroyed: boolean = false
+
+  constructor(lib: RenderLib, ptr: Pointer, 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(): Pointer {
+    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 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,347 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test"
+import { TextBuffer } from "./text-buffer.js"
+import { StyledText, stringToStyledText } from "./lib/styled-text.js"
+import { RGBA } from "./lib/RGBA.js"
+
+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", () => {
+      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")
+    })
+  })
+
+  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("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")
+    })
+  })
+
+  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 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")
+    })
+  })
+})