@opentui/core 0.5.8 → 0.5.10

package/edit-buffer.d.ts

@@ -46,6 +46,8 @@ export declare class EditBuffer extends EventEmitter {
      */
     replaceTextOwned(text: string): void;
     getLineCount(): number;
+    setTabWidth(width: number): void;
+    getTabWidth(): number;
     getText(): string;
     insertChar(char: string): void;
     insertText(text: string): void;

package/image.d.ts

@@ -62,10 +62,16 @@ export interface RawImage {
     colorSpace: "srgb";
     alpha: "straight";
 }
+export interface PixelImportOptions {
+    stride?: number;
+    format?: PixelFormat;
+    alpha?: "straight" | "opaque";
+    colorSpace?: "srgb";
+}
 export interface OwnedRawImage extends RawImage {
     dispose(): void;
 }
-export type ImageErrorCode = "invalid-handle" | "unsupported-format" | "unsupported-color-space" | "malformed-data" | "dimension-limit" | "memory-limit" | "invalid-argument" | "out-of-memory" | "output-too-small" | "internal-error" | "unsupported-feature";
+export type ImageErrorCode = "invalid-handle" | "unsupported-format" | "unsupported-color-space" | "malformed-data" | "dimension-limit" | "memory-limit" | "invalid-argument" | "out-of-memory" | "output-too-small" | "internal-error" | "unsupported-feature" | "busy";
 export declare class ImageError extends Error {
     readonly code: ImageErrorCode;
     readonly status: number;
@@ -80,6 +86,7 @@ export declare class NativeImage {
     static decode(data: Uint8Array | ArrayBuffer): NativeImage;
     static load(source: ImageSource, options?: ImageLoadOptions): Promise<NativeImage>;
     static fromRgba(pixels: Uint8Array, width: number, height: number, stride?: number): NativeImage;
+    static fromPixels(pixels: Uint8Array, width: number, height: number, options?: PixelImportOptions): NativeImage;
     private static fromHandle;
     private guard;
     get ptr(): ImageHandle;
@@ -105,3 +112,20 @@ export declare class NativeImage {
     }): void;
     dispose(): void;
 }
+export interface NativeImagePoolOptions {
+    width: number;
+    height: number;
+    capacity?: number;
+}
+export declare class NativeImagePool {
+    private readonly lib;
+    private readonly images;
+    private disposed;
+    readonly width: number;
+    readonly height: number;
+    readonly capacity: number;
+    constructor(options: NativeImagePoolOptions);
+    publishRgba(pixels: Uint8Array, stride?: number): NativeImage | null;
+    publishPixels(pixels: Uint8Array, options?: PixelImportOptions): NativeImage | null;
+    dispose(): void;
+}

package/index.bun.js

@@ -44,7 +44,7 @@ import {
   mergeKeyAliases,
   mergeKeyBindings,
   wrapWithDelegates
-} from "./chunk-bun-b3exa82d.js";
+} from "./chunk-bun-bb3k0yt8.js";
 import {
   ASCIIFontSelectionHelper,
   ATTRIBUTE_BASE_BITS,
@@ -204,7 +204,7 @@ import {
   visualizeRenderableTree,
   white,
   yellow
-} from "./chunk-bun-2956gvaq.js";
+} from "./chunk-bun-9gqvxy8c.js";
 // src/post/effects.ts
 function toU8(value) {
   return Math.round(Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0)) * 255);
@@ -219,6 +219,9 @@ function setRgb(buffer, base, r, g, b) {
   buffer[base + 2] = toU8(b);
   buffer[base + 3] = a;
 }
+function isGraphemeCell(char) {
+  return char >>> 30 >= 2;
+}
 
 class DistortionEffect {
   glitchChancePerSecond = 0.5;
@@ -403,6 +406,7 @@ class DistortionEffect {
 class VignetteEffect {
   _strength;
   precomputedAttenuationCellMask = null;
+  precomputedAttenuation = null;
   cachedWidth = -1;
   cachedHeight = -1;
   static zeroMatrix = new Float32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
@@ -414,12 +418,14 @@ class VignetteEffect {
     this.cachedWidth = -1;
     this.cachedHeight = -1;
     this.precomputedAttenuationCellMask = null;
+    this.precomputedAttenuation = null;
   }
   get strength() {
     return this._strength;
   }
   _computeFactors(width, height) {
     this.precomputedAttenuationCellMask = new Float32Array(width * height * 3);
+    this.precomputedAttenuation = new Float32Array(width * height);
     const centerX = width / 2;
     const centerY = height / 2;
     const maxDistSq = centerX * centerX + centerY * centerY;
@@ -437,17 +443,42 @@ class VignetteEffect {
         this.precomputedAttenuationCellMask[i++] = x;
         this.precomputedAttenuationCellMask[i++] = y;
         this.precomputedAttenuationCellMask[i++] = attenuation;
+        this.precomputedAttenuation[y * width + x] = attenuation;
       }
     }
     this.cachedWidth = width;
     this.cachedHeight = height;
   }
+  _preserveGraphemeRuns(buffer) {
+    const baseAttenuation = this.precomputedAttenuation;
+    const cellMask = this.precomputedAttenuationCellMask;
+    const chars = buffer.buffers.char;
+    const width = buffer.width;
+    for (let y = 0;y < buffer.height; y++) {
+      let x = 0;
+      while (x < width) {
+        const cell = y * width + x;
+        if (!isGraphemeCell(chars[cell])) {
+          cellMask[cell * 3 + 2] = baseAttenuation[cell];
+          x++;
+          continue;
+        }
+        const start = x;
+        while (x < width && isGraphemeCell(chars[y * width + x]))
+          x++;
+        const attenuation = baseAttenuation[y * width + start + Math.floor((x - start) / 2)];
+        for (let runX = start;runX < x; runX++)
+          cellMask[(y * width + runX) * 3 + 2] = attenuation;
+      }
+    }
+  }
   apply(buffer) {
     const width = buffer.width;
     const height = buffer.height;
     if (width !== this.cachedWidth || height !== this.cachedHeight || !this.precomputedAttenuationCellMask) {
       this._computeFactors(width, height);
     }
+    this._preserveGraphemeRuns(buffer);
     buffer.colorMatrix(VignetteEffect.zeroMatrix, this.precomputedAttenuationCellMask, 1, 3);
   }
 }
@@ -5673,7 +5704,8 @@ var STATUS_MESSAGES = [
   "out of memory",
   "image output buffer is too small",
   "internal image error",
-  "unsupported image feature"
+  "unsupported image feature",
+  "image is retained"
 ];
 var STATUS_CODES = [
   "internal-error",
@@ -5687,9 +5719,11 @@ var STATUS_CODES = [
   "out-of-memory",
   "output-too-small",
   "internal-error",
-  "unsupported-feature"
+  "unsupported-feature",
+  "busy"
 ];
 var INVALID_ARGUMENT_STATUS = 7;
+var BUSY_STATUS = 12;
 
 class ImageError extends Error {
   code;
@@ -5719,6 +5753,7 @@ var PIXEL_FORMAT_BGRA = {
   rgba8: false,
   bgra8: true
 };
+var PIXEL_ALPHA_IDS = { straight: 0, opaque: 1 };
 var MAX_ENCODED_BYTES = 64 * 1024 * 1024;
 function imageError(status) {
   return new ImageError(status);
@@ -5738,6 +5773,15 @@ function requireU32(value, name, allowZero = false) {
   }
   return value;
 }
+function pixelImportOptions(width, options) {
+  const stride = requireU32(options.stride ?? width * 4, "stride");
+  const bgra = requireMappedOption(PIXEL_FORMAT_BGRA, options.format ?? "rgba8", "pixel format");
+  const alpha = requireMappedOption(PIXEL_ALPHA_IDS, options.alpha ?? "straight", "pixel alpha");
+  if (options.colorSpace !== undefined && options.colorSpace !== "srgb") {
+    throw new TypeError(`Unsupported pixel color space: ${String(options.colorSpace)}`);
+  }
+  return { stride, format: Number(bgra), alpha };
+}
 function requireI32(value, name) {
   if (!Number.isSafeInteger(value) || value < -2147483648 || value > 2147483647) {
     throw new RangeError(`${name} must be an i32 integer`);
@@ -5957,6 +6001,19 @@ class NativeImage {
       throw imageError(10);
     return NativeImage.fromHandle(lib, result.handle);
   }
+  static fromPixels(pixels, width, height, options = {}) {
+    if (!(pixels instanceof Uint8Array))
+      throw new TypeError("pixels must be a Uint8Array");
+    requireU32(width, "width");
+    requireU32(height, "height");
+    const { stride, format, alpha } = pixelImportOptions(width, options);
+    const lib = resolveRenderLib();
+    const result = lib.imageCreateFromPixels(pixels, width, height, stride, format, alpha);
+    checkStatus(result.status);
+    if (!result.handle)
+      throw imageError(10);
+    return NativeImage.fromHandle(lib, result.handle);
+  }
   static fromHandle(lib, handle) {
     const result = lib.imageGetInfo(handle);
     if (result.status !== 0) {
@@ -6088,6 +6145,53 @@ class NativeImage {
     this.handle = null;
   }
 }
+
+class NativeImagePool {
+  lib;
+  images = [];
+  disposed = false;
+  width;
+  height;
+  capacity;
+  constructor(options) {
+    this.width = requireU32(options.width, "width");
+    this.height = requireU32(options.height, "height");
+    this.capacity = requireU32(options.capacity ?? 3, "capacity");
+    if (this.capacity > 8)
+      throw new RangeError("capacity must be between 1 and 8");
+    this.lib = resolveRenderLib();
+  }
+  publishRgba(pixels, stride = this.width * 4) {
+    return this.publishPixels(pixels, { stride: requireU32(stride, "stride") });
+  }
+  publishPixels(pixels, options = {}) {
+    if (this.disposed)
+      throw new Error("NativeImagePool is disposed");
+    if (!(pixels instanceof Uint8Array))
+      throw new TypeError("pixels must be a Uint8Array");
+    const { stride, format, alpha } = pixelImportOptions(this.width, options);
+    for (const image2 of this.images) {
+      const status = this.lib.imageUpdatePixels(image2.ptr, pixels, stride, format, alpha);
+      if (status === BUSY_STATUS)
+        continue;
+      checkStatus(status);
+      return image2.retain();
+    }
+    if (this.images.length === this.capacity)
+      return null;
+    const image = NativeImage.fromPixels(pixels, this.width, this.height, options);
+    this.images.push(image);
+    return image.retain();
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    for (const image of this.images)
+      image.dispose();
+    this.images.length = 0;
+  }
+}
 // src/renderables/FrameBuffer.ts
 class FrameBufferRenderable extends Renderable {
   frameBuffer;
@@ -8321,12 +8425,13 @@ class EmbeddedTerminalRenderable extends Renderable {
     if (!this.handle)
       return new Uint8Array;
     const text = textualKey(key);
+    const physical = physicalKey(key);
     return this.lib.embeddedTerminalEncodeKey(this.handle, {
       action: key.eventType === "release" ? "release" : key.repeated ? "repeat" : "press",
-      key: physicalKey(key),
+      key: physical,
       mods: modifiers(key),
       text,
-      unshiftedCodepoint: key.baseCode ?? physicalUnshiftedCodepoint(key.code)
+      unshiftedCodepoint: key.baseCode ?? physicalUnshiftedCodepoint(physical)
     });
   }
   encodePaste(bytes) {
@@ -8353,6 +8458,8 @@ class EmbeddedTerminalRenderable extends Renderable {
       this.requestRender();
       return false;
     }
+    if (!this.selection && local.behavior === "cell" && local.anchorX === local.focusX && local.anchorY === local.focusY)
+      return false;
     const point = (x, y) => {
       if (y < 0)
         return { x: 0, y: 0 };
@@ -8543,8 +8650,12 @@ function modifiers(input) {
   return value;
 }
 function physicalKey(key) {
-  if (key.code)
+  if (key.code && !key.code.startsWith("["))
     return key.code;
+  if (/^[a-z]$/i.test(key.name))
+    return `Key${key.name.toUpperCase()}`;
+  if (/^[0-9]$/.test(key.name))
+    return `Digit${key.name}`;
   return {
     backspace: "Backspace",
     enter: "Enter",
@@ -12922,7 +13033,7 @@ class MarkdownRenderable extends Renderable {
         blockIndex++;
         continue;
       }
-      if (existing && !forceTableRefresh && existing.canUpdateInPlace && existing.token.type === block.token.type && this.canUpdateBlockRenderable(existing.renderable, block.token)) {
+      if (existing && existing.canUpdateInPlace && existing.token.type === block.token.type && this.canUpdateBlockRenderable(existing.renderable, block.token)) {
         if (this._renderNode) {
           const custom = this.createTopLevelCustomRenderable(block, blockIndex);
           if (custom.renderable && !custom.canUpdateInPlace) {
@@ -15489,6 +15600,7 @@ export {
   OptimizedBuffer,
   NativeSpanFeed,
   NativeMeasureTargetKind,
+  NativeImagePool,
   NativeImage,
   NativeClipboardStartStatus,
   NativeClipboardShutdownStatus,
@@ -15570,5 +15682,5 @@ export {
   ACHROMATOPSIA_MATRIX
 };
 
-//# debugId=C0029738F074C79064756E2164756E21
+//# debugId=598A7BAC0738AEF164756E2164756E21
 //# sourceMappingURL=index.bun.js.map