@opentuah/core 0.1.88 → 0.1.90

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

@@ -30,6 +30,7 @@ import {
   RendererControlState,
   RootRenderable,
   Selection,
+  SpanInfoStruct,
   StdinBuffer,
   StyledText,
   TerminalConsole,
@@ -150,7 +151,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-1n3xjscm.js";
+} from "./index-bsnn7gyg.js";
 // src/text-buffer-view.ts
 class TextBufferView {
   lib;
@@ -2062,6 +2063,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;
@@ -6363,6 +6624,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();
@@ -9377,6 +9673,7 @@ export {
   RGBA,
   PasteEvent,
   OptimizedBuffer,
+  NativeSpanFeed,
   MouseParser,
   MouseEvent,
   MouseButton,
@@ -9424,5 +9721,5 @@ export {
   ASCIIFont
 };
 
-//# debugId=F3E0750B0CE8050E64756E2164756E21
+//# debugId=3AFAA02CD618183B64756E2164756E21
 //# sourceMappingURL=index.js.map