@opentui/core 0.1.79 → 0.1.81

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-zrvzvh6r.js";
+} from "./index-ve2seej0.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() {
@@ -6608,9 +6908,10 @@ class TextareaRenderable extends EditBufferRenderable {
     return this._placeholder;
   }
   set placeholder(value) {
-    if (this._placeholder !== value) {
-      this._placeholder = value;
-      this.applyPlaceholder(value);
+    const normalizedValue = value ?? null;
+    if (this._placeholder !== normalizedValue) {
+      this._placeholder = normalizedValue;
+      this.applyPlaceholder(normalizedValue);
       this.requestRender();
     }
   }
@@ -8181,7 +8482,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;
@@ -8225,8 +8527,7 @@ class MarkdownRenderable extends Renderable {
   set streaming(value) {
     if (this._streaming !== value) {
       this._streaming = value;
-      this.updateBlocks();
-      this.requestRender();
+      this.clearCache();
     }
   }
   getStyle(group) {
@@ -9514,13 +9815,13 @@ class ScrollBoxRenderable extends BoxRenderable {
     if (this.scrollTop <= 0) {
       this._stickyScrollTop = true;
       this._stickyScrollBottom = false;
-      if (this._stickyStart === "top" || this._stickyStart === "bottom" && maxScrollTop === 0) {
+      if (!this._isApplyingStickyScroll && (this._stickyStart === "top" || this._stickyStart === "bottom" && maxScrollTop === 0)) {
         this._hasManualScroll = false;
       }
     } else if (this.scrollTop >= maxScrollTop) {
       this._stickyScrollTop = false;
       this._stickyScrollBottom = true;
-      if (this._stickyStart === "bottom") {
+      if (!this._isApplyingStickyScroll && this._stickyStart === "bottom") {
         this._hasManualScroll = false;
       }
     } else {
@@ -9530,13 +9831,13 @@ class ScrollBoxRenderable extends BoxRenderable {
     if (this.scrollLeft <= 0) {
       this._stickyScrollLeft = true;
       this._stickyScrollRight = false;
-      if (this._stickyStart === "left" || this._stickyStart === "right" && maxScrollLeft === 0) {
+      if (!this._isApplyingStickyScroll && (this._stickyStart === "left" || this._stickyStart === "right" && maxScrollLeft === 0)) {
         this._hasManualScroll = false;
       }
     } else if (this.scrollLeft >= maxScrollLeft) {
       this._stickyScrollLeft = false;
       this._stickyScrollRight = true;
-      if (this._stickyStart === "right") {
+      if (!this._isApplyingStickyScroll && this._stickyStart === "right") {
         this._hasManualScroll = false;
       }
     } else {
@@ -9545,30 +9846,34 @@ class ScrollBoxRenderable extends BoxRenderable {
     }
   }
   applyStickyStart(stickyStart) {
+    const wasApplyingStickyScroll = this._isApplyingStickyScroll;
     this._isApplyingStickyScroll = true;
-    switch (stickyStart) {
-      case "top":
-        this._stickyScrollTop = true;
-        this._stickyScrollBottom = false;
-        this.verticalScrollBar.scrollPosition = 0;
-        break;
-      case "bottom":
-        this._stickyScrollTop = false;
-        this._stickyScrollBottom = true;
-        this.verticalScrollBar.scrollPosition = Math.max(0, this.scrollHeight - this.viewport.height);
-        break;
-      case "left":
-        this._stickyScrollLeft = true;
-        this._stickyScrollRight = false;
-        this.horizontalScrollBar.scrollPosition = 0;
-        break;
-      case "right":
-        this._stickyScrollLeft = false;
-        this._stickyScrollRight = true;
-        this.horizontalScrollBar.scrollPosition = Math.max(0, this.scrollWidth - this.viewport.width);
-        break;
+    try {
+      switch (stickyStart) {
+        case "top":
+          this._stickyScrollTop = true;
+          this._stickyScrollBottom = false;
+          this.verticalScrollBar.scrollPosition = 0;
+          break;
+        case "bottom":
+          this._stickyScrollTop = false;
+          this._stickyScrollBottom = true;
+          this.verticalScrollBar.scrollPosition = Math.max(0, this.scrollHeight - this.viewport.height);
+          break;
+        case "left":
+          this._stickyScrollLeft = true;
+          this._stickyScrollRight = false;
+          this.horizontalScrollBar.scrollPosition = 0;
+          break;
+        case "right":
+          this._stickyScrollLeft = false;
+          this._stickyScrollRight = true;
+          this.horizontalScrollBar.scrollPosition = Math.max(0, this.scrollWidth - this.viewport.width);
+          break;
+      }
+    } finally {
+      this._isApplyingStickyScroll = wasApplyingStickyScroll;
     }
-    this._isApplyingStickyScroll = false;
   }
   constructor(ctx, {
     wrapperOptions,
@@ -9908,29 +10213,32 @@ class ScrollBoxRenderable extends BoxRenderable {
   recalculateBarProps() {
     const wasApplyingStickyScroll = this._isApplyingStickyScroll;
     this._isApplyingStickyScroll = true;
-    this.verticalScrollBar.scrollSize = this.content.height;
-    this.verticalScrollBar.viewportSize = this.viewport.height;
-    this.horizontalScrollBar.scrollSize = this.content.width;
-    this.horizontalScrollBar.viewportSize = this.viewport.width;
-    if (this._stickyScroll) {
-      const newMaxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
-      const newMaxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
-      if (this._stickyStart && !this._hasManualScroll) {
-        this.applyStickyStart(this._stickyStart);
-      } else {
-        if (this._stickyScrollTop) {
-          this.scrollTop = 0;
-        } else if (this._stickyScrollBottom && newMaxScrollTop > 0) {
-          this.scrollTop = newMaxScrollTop;
-        }
-        if (this._stickyScrollLeft) {
-          this.scrollLeft = 0;
-        } else if (this._stickyScrollRight && newMaxScrollLeft > 0) {
-          this.scrollLeft = newMaxScrollLeft;
+    try {
+      this.verticalScrollBar.scrollSize = this.content.height;
+      this.verticalScrollBar.viewportSize = this.viewport.height;
+      this.horizontalScrollBar.scrollSize = this.content.width;
+      this.horizontalScrollBar.viewportSize = this.viewport.width;
+      if (this._stickyScroll) {
+        const newMaxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
+        const newMaxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
+        if (this._stickyStart && !this._hasManualScroll) {
+          this.applyStickyStart(this._stickyStart);
+        } else {
+          if (this._stickyScrollTop) {
+            this.scrollTop = 0;
+          } else if (this._stickyScrollBottom && newMaxScrollTop > 0) {
+            this.scrollTop = newMaxScrollTop;
+          }
+          if (this._stickyScrollLeft) {
+            this.scrollLeft = 0;
+          } else if (this._stickyScrollRight && newMaxScrollLeft > 0) {
+            this.scrollLeft = newMaxScrollLeft;
+          }
         }
       }
+    } finally {
+      this._isApplyingStickyScroll = wasApplyingStickyScroll;
     }
-    this._isApplyingStickyScroll = wasApplyingStickyScroll;
     process.nextTick(() => {
       this.requestRender();
     });
@@ -10851,6 +11159,7 @@ export {
   RGBA,
   PasteEvent,
   OptimizedBuffer,
+  NativeSpanFeed,
   MouseParser,
   MouseEvent,
   MouseButton,
@@ -10897,5 +11206,5 @@ export {
   ASCIIFont
 };
 
-//# debugId=20BF116F533C5D6664756E2164756E21
+//# debugId=B77F27E92D33B1E964756E2164756E21
 //# sourceMappingURL=index.js.map