@opentui/core 0.5.9 → 0.5.10

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-jxfx3h5k.js";
+} from "./chunk-bun-bb3k0yt8.js";
 import {
   ASCIIFontSelectionHelper,
   ATTRIBUTE_BASE_BITS,
@@ -204,7 +204,7 @@ import {
   visualizeRenderableTree,
   white,
   yellow
-} from "./chunk-bun-b0662dgp.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);
@@ -5704,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",
@@ -5718,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;
@@ -5750,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);
@@ -5769,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`);
@@ -5988,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) {
@@ -6119,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;
@@ -12960,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) {
@@ -15527,6 +15600,7 @@ export {
   OptimizedBuffer,
   NativeSpanFeed,
   NativeMeasureTargetKind,
+  NativeImagePool,
   NativeImage,
   NativeClipboardStartStatus,
   NativeClipboardShutdownStatus,
@@ -15608,5 +15682,5 @@ export {
   ACHROMATOPSIA_MATRIX
 };
 
-//# debugId=281D25630B33385064756E2164756E21
+//# debugId=598A7BAC0738AEF164756E2164756E21
 //# sourceMappingURL=index.bun.js.map