@opentui/core 0.5.8 → 0.5.10

package/index.node.js

@@ -43,7 +43,7 @@ import {
   mergeKeyAliases,
   mergeKeyBindings,
   wrapWithDelegates
-} from "./chunk-node-kr27pp2p.js";
+} from "./chunk-node-6bg8r2m7.js";
 import {
   ASCIIFontSelectionHelper,
   ATTRIBUTE_BASE_BITS,
@@ -203,7 +203,7 @@ import {
   visualizeRenderableTree,
   white,
   yellow
-} from "./chunk-node-mfda59vq.js";
+} from "./chunk-node-f647ts9q.js";
 // src/post/effects.ts
 function toU8(value) {
   return Math.round(Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0)) * 255);
@@ -218,6 +218,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;
@@ -402,6 +405,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]);
@@ -413,12 +417,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;
@@ -436,17 +442,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);
   }
 }
@@ -5672,7 +5703,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",
@@ -5686,9 +5718,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;
@@ -5718,6 +5752,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);
@@ -5737,6 +5772,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`);
@@ -5956,6 +6000,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) {
@@ -6087,6 +6144,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;
@@ -8320,12 +8424,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) {
@@ -8352,6 +8457,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 };
@@ -8542,8 +8649,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",
@@ -12921,7 +13032,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) {
@@ -15488,6 +15599,7 @@ export {
   OptimizedBuffer,
   NativeSpanFeed,
   NativeMeasureTargetKind,
+  NativeImagePool,
   NativeImage,
   NativeClipboardStartStatus,
   NativeClipboardShutdownStatus,
@@ -15569,5 +15681,5 @@ export {
   ACHROMATOPSIA_MATRIX
 };
 
-//# debugId=9542D2256201683264756E2164756E21
+//# debugId=A215C65C5C28D5BB64756E2164756E21
 //# sourceMappingURL=index.node.js.map