@opentui/core 0.1.78 → 0.1.80

package/index.d.ts

@@ -11,6 +11,7 @@ export * from "./post/filters";
 export * from "./animation/Timeline";
 export * from "./lib";
 export * from "./renderer";
+export * from "./NativeSpanFeed";
 export * from "./renderables";
 export * from "./zig";
 export * from "./console";

package/index.js

@@ -33,6 +33,7 @@ import {
   RendererControlState,
   RootRenderable,
   Selection,
+  SpanInfoStruct,
   StdinBuffer,
   StyledText,
   TerminalConsole,
@@ -152,7 +153,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-rje6z21e.js";
+} from "./index-vnvba6q9.js";
 // src/text-buffer-view.ts
 class TextBufferView {
   lib;
@@ -2064,6 +2065,266 @@ function createTimeline(options = {}) {
   engine.register(timeline);
   return timeline;
 }
+// src/NativeSpanFeed.ts
+import { toArrayBuffer } from "bun:ffi";
+function toPointer(value) {
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("Pointer exceeds safe integer range");
+    }
+    return Number(value);
+  }
+  return value;
+}
+function toNumber(value) {
+  return typeof value === "bigint" ? Number(value) : value;
+}
+
+class NativeSpanFeed {
+  static create(options) {
+    const lib = resolveRenderLib();
+    const streamPtr = lib.createNativeSpanFeed(options);
+    const stream = new NativeSpanFeed(streamPtr);
+    lib.registerNativeSpanFeedStream(streamPtr, stream.eventHandler);
+    const status = lib.attachNativeSpanFeed(streamPtr);
+    if (status !== 0) {
+      lib.unregisterNativeSpanFeedStream(streamPtr);
+      lib.destroyNativeSpanFeed(streamPtr);
+      throw new Error(`Failed to attach stream: ${status}`);
+    }
+    return stream;
+  }
+  static attach(streamPtr, _options) {
+    const lib = resolveRenderLib();
+    const ptr = toPointer(streamPtr);
+    const stream = new NativeSpanFeed(ptr);
+    lib.registerNativeSpanFeedStream(ptr, stream.eventHandler);
+    const status = lib.attachNativeSpanFeed(ptr);
+    if (status !== 0) {
+      lib.unregisterNativeSpanFeedStream(ptr);
+      throw new Error(`Failed to attach stream: ${status}`);
+    }
+    return stream;
+  }
+  streamPtr;
+  lib = resolveRenderLib();
+  eventHandler;
+  chunkMap = new Map;
+  chunkSizes = new Map;
+  dataHandlers = new Set;
+  errorHandlers = new Set;
+  drainBuffer = null;
+  stateBuffer = null;
+  closed = false;
+  destroyed = false;
+  draining = false;
+  pendingDataAvailable = false;
+  pendingClose = false;
+  closing = false;
+  pendingAsyncHandlers = 0;
+  inCallback = false;
+  closeQueued = false;
+  constructor(streamPtr) {
+    this.streamPtr = streamPtr;
+    this.eventHandler = (eventId, arg0, arg1) => {
+      this.handleEvent(eventId, arg0, arg1);
+    };
+    this.ensureDrainBuffer();
+  }
+  ensureDrainBuffer() {
+    if (this.drainBuffer)
+      return;
+    const capacity = 256;
+    this.drainBuffer = new Uint8Array(capacity * SpanInfoStruct.size);
+  }
+  onData(handler) {
+    this.dataHandlers.add(handler);
+    if (this.pendingDataAvailable) {
+      this.pendingDataAvailable = false;
+      this.drainAll();
+    }
+    return () => this.dataHandlers.delete(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  close() {
+    if (this.destroyed)
+      return;
+    if (this.inCallback || this.draining || this.pendingAsyncHandlers > 0) {
+      this.pendingClose = true;
+      if (!this.closeQueued) {
+        this.closeQueued = true;
+        queueMicrotask(() => {
+          this.closeQueued = false;
+          this.processPendingClose();
+        });
+      }
+      return;
+    }
+    this.performClose();
+  }
+  processPendingClose() {
+    if (!this.pendingClose || this.destroyed)
+      return;
+    if (this.inCallback || this.draining || this.pendingAsyncHandlers > 0)
+      return;
+    this.pendingClose = false;
+    this.performClose();
+  }
+  performClose() {
+    if (this.closing)
+      return;
+    this.closing = true;
+    if (!this.closed) {
+      const status = this.lib.streamClose(this.streamPtr);
+      if (status !== 0) {
+        this.closing = false;
+        return;
+      }
+      this.closed = true;
+    }
+    this.finalizeDestroy();
+  }
+  finalizeDestroy() {
+    if (this.destroyed)
+      return;
+    this.lib.unregisterNativeSpanFeedStream(this.streamPtr);
+    this.lib.destroyNativeSpanFeed(this.streamPtr);
+    this.destroyed = true;
+    this.chunkMap.clear();
+    this.chunkSizes.clear();
+    this.stateBuffer = null;
+    this.drainBuffer = null;
+    this.dataHandlers.clear();
+    this.errorHandlers.clear();
+    this.pendingDataAvailable = false;
+  }
+  handleEvent(eventId, arg0, arg1) {
+    this.inCallback = true;
+    try {
+      switch (eventId) {
+        case 8 /* StateBuffer */: {
+          const len = toNumber(arg1);
+          if (len > 0 && arg0) {
+            const buffer = toArrayBuffer(arg0, 0, len);
+            this.stateBuffer = new Uint8Array(buffer);
+          }
+          break;
+        }
+        case 7 /* DataAvailable */: {
+          if (this.closing)
+            break;
+          if (this.dataHandlers.size === 0) {
+            this.pendingDataAvailable = true;
+            break;
+          }
+          this.drainAll();
+          break;
+        }
+        case 2 /* ChunkAdded */: {
+          const chunkLen = toNumber(arg1);
+          if (chunkLen > 0 && arg0) {
+            if (!this.chunkMap.has(arg0)) {
+              const buffer = toArrayBuffer(arg0, 0, chunkLen);
+              this.chunkMap.set(arg0, buffer);
+            }
+            this.chunkSizes.set(arg0, chunkLen);
+          }
+          break;
+        }
+        case 6 /* Error */: {
+          const code = arg0;
+          for (const handler of this.errorHandlers)
+            handler(code);
+          break;
+        }
+        case 5 /* Closed */: {
+          this.closed = true;
+          break;
+        }
+        default:
+          break;
+      }
+    } finally {
+      this.inCallback = false;
+    }
+  }
+  decrementRefcount(chunkIndex) {
+    if (this.stateBuffer && chunkIndex < this.stateBuffer.length) {
+      const prev = this.stateBuffer[chunkIndex];
+      this.stateBuffer[chunkIndex] = prev > 0 ? prev - 1 : 0;
+    }
+  }
+  drainOnce() {
+    if (!this.drainBuffer || this.draining || this.pendingClose)
+      return 0;
+    const capacity = Math.floor(this.drainBuffer.byteLength / SpanInfoStruct.size);
+    if (capacity === 0)
+      return 0;
+    const count = this.lib.streamDrainSpans(this.streamPtr, this.drainBuffer, capacity);
+    if (count === 0)
+      return 0;
+    this.draining = true;
+    const spans = SpanInfoStruct.unpackList(this.drainBuffer.buffer, count);
+    let firstError = null;
+    try {
+      for (const span of spans) {
+        if (span.len === 0)
+          continue;
+        let buffer = this.chunkMap.get(span.chunkPtr);
+        if (!buffer) {
+          const size = this.chunkSizes.get(span.chunkPtr);
+          if (!size)
+            continue;
+          buffer = toArrayBuffer(span.chunkPtr, 0, size);
+          this.chunkMap.set(span.chunkPtr, buffer);
+        }
+        if (span.offset + span.len > buffer.byteLength)
+          continue;
+        const slice = new Uint8Array(buffer, span.offset, span.len);
+        let asyncResults = null;
+        for (const handler of this.dataHandlers) {
+          try {
+            const result = handler(slice);
+            if (result && typeof result.then === "function") {
+              asyncResults ??= [];
+              asyncResults.push(result);
+            }
+          } catch (e) {
+            firstError ??= e;
+          }
+        }
+        const shouldStopAfterThisSpan = this.pendingClose;
+        if (asyncResults) {
+          const chunkIndex = span.chunkIndex;
+          this.pendingAsyncHandlers += 1;
+          Promise.allSettled(asyncResults).then(() => {
+            this.decrementRefcount(chunkIndex);
+            this.pendingAsyncHandlers -= 1;
+            this.processPendingClose();
+          });
+        } else {
+          this.decrementRefcount(span.chunkIndex);
+        }
+        if (shouldStopAfterThisSpan)
+          break;
+      }
+    } finally {
+      this.draining = false;
+    }
+    if (firstError)
+      throw firstError;
+    return count;
+  }
+  drainAll() {
+    let count = this.drainOnce();
+    while (count > 0) {
+      count = this.drainOnce();
+    }
+  }
+}
 // src/renderables/FrameBuffer.ts
 class FrameBufferRenderable extends Renderable {
   frameBuffer;
@@ -3856,6 +4117,23 @@ class LineNumberRenderable extends Renderable {
   getLineNumbers() {
     return this._lineNumbers;
   }
+  highlightLines(startLine, endLine, color) {
+    for (let i = startLine;i <= endLine; i++) {
+      this.parseLineColor(i, color);
+    }
+    if (this.gutter) {
+      this.gutter.setLineColors(this._lineColorsGutter, this._lineColorsContent);
+    }
+  }
+  clearHighlightLines(startLine, endLine) {
+    for (let i = startLine;i <= endLine; i++) {
+      this._lineColorsGutter.delete(i);
+      this._lineColorsContent.delete(i);
+    }
+    if (this.gutter) {
+      this.gutter.setLineColors(this._lineColorsGutter, this._lineColorsContent);
+    }
+  }
 }
 
 // ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/base.js
@@ -5580,6 +5858,30 @@ class DiffRenderable extends Renderable {
       }
     }
   }
+  setLineColor(line, color) {
+    this.leftSide?.setLineColor(line, color);
+    this.rightSide?.setLineColor(line, color);
+  }
+  clearLineColor(line) {
+    this.leftSide?.clearLineColor(line);
+    this.rightSide?.clearLineColor(line);
+  }
+  setLineColors(lineColors) {
+    this.leftSide?.setLineColors(lineColors);
+    this.rightSide?.setLineColors(lineColors);
+  }
+  clearAllLineColors() {
+    this.leftSide?.clearAllLineColors();
+    this.rightSide?.clearAllLineColors();
+  }
+  highlightLines(startLine, endLine, color) {
+    this.leftSide?.highlightLines(startLine, endLine, color);
+    this.rightSide?.highlightLines(startLine, endLine, color);
+  }
+  clearHighlightLines(startLine, endLine) {
+    this.leftSide?.clearHighlightLines(startLine, endLine);
+    this.rightSide?.clearHighlightLines(startLine, endLine);
+  }
 }
 // src/renderables/EditBufferRenderable.ts
 class EditBufferRenderable extends Renderable {
@@ -6011,13 +6313,11 @@ class EditBufferRenderable extends Renderable {
     const cursorX = this.x + visualCursor.visualCol + 1;
     const cursorY = this.y + visualCursor.visualRow + 1;
     this._ctx.setCursorPosition(cursorX, cursorY, true);
-    this._ctx.setCursorColor(this._cursorColor);
-    this._ctx.setCursorStyle(this._cursorStyle.style, this._cursorStyle.blinking);
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
   }
   focus() {
     super.focus();
-    this._ctx.setCursorStyle(this._cursorStyle.style, this._cursorStyle.blinking);
-    this._ctx.setCursorColor(this._cursorColor);
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
     this.requestRender();
   }
   blur() {
@@ -6797,6 +7097,41 @@ class InputRenderable extends TextareaRenderable {
     this.emit("input" /* INPUT */, this.plainText);
     return result;
   }
+  deleteLine() {
+    const result = super.deleteLine();
+    this.emit("input" /* INPUT */, this.plainText);
+    return result;
+  }
+  deleteWordBackward() {
+    const result = super.deleteWordBackward();
+    this.emit("input" /* INPUT */, this.plainText);
+    return result;
+  }
+  deleteWordForward() {
+    const result = super.deleteWordForward();
+    this.emit("input" /* INPUT */, this.plainText);
+    return result;
+  }
+  deleteToLineStart() {
+    const result = super.deleteToLineStart();
+    this.emit("input" /* INPUT */, this.plainText);
+    return result;
+  }
+  deleteToLineEnd() {
+    const result = super.deleteToLineEnd();
+    this.emit("input" /* INPUT */, this.plainText);
+    return result;
+  }
+  undo() {
+    const result = super.undo();
+    this.emit("input" /* INPUT */, this.plainText);
+    return result;
+  }
+  redo() {
+    const result = super.redo();
+    this.emit("input" /* INPUT */, this.plainText);
+    return result;
+  }
   deleteCharacter(direction) {
     if (direction === "backward") {
       this.deleteCharBackward();
@@ -8146,7 +8481,8 @@ class MarkdownRenderable extends Renderable {
   constructor(ctx, options) {
     super(ctx, {
       ...options,
-      flexDirection: "column"
+      flexDirection: "column",
+      flexShrink: options.flexShrink ?? 0
     });
     this._syntaxStyle = options.syntaxStyle;
     this._conceal = options.conceal ?? this._contentDefaultOptions.conceal;
@@ -8190,8 +8526,7 @@ class MarkdownRenderable extends Renderable {
   set streaming(value) {
     if (this._streaming !== value) {
       this._streaming = value;
-      this.updateBlocks();
-      this.requestRender();
+      this.clearCache();
     }
   }
   getStyle(group) {
@@ -10816,6 +11151,7 @@ export {
   RGBA,
   PasteEvent,
   OptimizedBuffer,
+  NativeSpanFeed,
   MouseParser,
   MouseEvent,
   MouseButton,
@@ -10862,5 +11198,5 @@ export {
   ASCIIFont
 };
 
-//# debugId=004D8C839D92DEBF64756E2164756E21
+//# debugId=3CB381A14248B1EF64756E2164756E21
 //# sourceMappingURL=index.js.map