gloomberb 0.2.0 → 0.3.2

package/src/components/chart/native/kitty-adapter.ts

@@ -0,0 +1,12 @@
+import type { CliRenderer } from "@opentui/core";
+
+export function writeRendererRaw(renderer: CliRenderer, data: string | Uint8Array): boolean {
+  if (renderer.isDestroyed) {
+    return false;
+  }
+
+  const writer = (renderer as unknown as { writeOut?: (payload: string | Uint8Array) => void }).writeOut;
+  if (typeof writer !== "function") return false;
+  writer.call(renderer, data);
+  return true;
+}

package/src/components/chart/native/kitty-manager.ts

@@ -0,0 +1,142 @@
+import type { CliRenderer } from "@opentui/core";
+import type { NativeChartBitmap, NativePlacement } from "./chart-rasterizer";
+import { writeRendererRaw } from "./kitty-adapter";
+import { encodeKittyDeleteImage, encodeKittyPlacement, encodeKittyTransmitRgba } from "./kitty-protocol";
+
+let nextImageId = 2000;
+let nextPlacementId = 1;
+
+function allocateImageId(): number {
+  const id = nextImageId;
+  nextImageId += 1;
+  return id;
+}
+
+function allocatePlacementId(): number {
+  const id = nextPlacementId;
+  nextPlacementId += 1;
+  return id;
+}
+
+function serializePlacement(placement: NativePlacement): string {
+  return [
+    placement.column,
+    placement.row,
+    placement.cols,
+    placement.rows,
+    placement.cropX,
+    placement.cropY,
+    placement.cropWidth,
+    placement.cropHeight,
+  ].join(":");
+}
+
+function asPlacementArray(placement: NativePlacement | NativePlacement[]): NativePlacement[] {
+  return Array.isArray(placement) ? placement : [placement];
+}
+
+export class KittyImageManager {
+  private readonly imageIds = [allocateImageId(), allocateImageId()] as const;
+  private readonly placementIds: number[] = [];
+  private activeSlot: 0 | 1 | null = null;
+  private lastBitmapKey: string | null = null;
+  private lastPlacementKeys: string[] = [];
+
+  constructor(private readonly renderer: CliRenderer) {}
+
+  render(bitmap: NativeChartBitmap, placement: NativePlacement | NativePlacement[], bitmapKey: string) {
+    const placements = asPlacementArray(placement);
+    if (this.activeSlot !== null && this.lastBitmapKey === bitmapKey) {
+      this.placeActive(placements);
+      return;
+    }
+
+    const nextSlot: 0 | 1 = this.activeSlot === 0 ? 1 : 0;
+    const imageId = this.imageIds[nextSlot];
+    const placementIds = this.ensurePlacementIds(placements.length);
+    const sequences = [
+      ...encodeKittyTransmitRgba({
+        imageId,
+        width: bitmap.width,
+        height: bitmap.height,
+        rgba: bitmap.pixels,
+      }),
+      ...placements.map((entry, index) => encodeKittyPlacement({
+        imageId,
+        placementId: placementIds[index]!,
+        column: entry.column,
+        row: entry.row,
+        cols: entry.cols,
+        rows: entry.rows,
+        cropX: entry.cropX,
+        cropY: entry.cropY,
+        cropWidth: entry.cropWidth,
+        cropHeight: entry.cropHeight,
+      })),
+    ];
+
+    if (this.activeSlot !== null) {
+      sequences.push(encodeKittyDeleteImage(this.imageIds[this.activeSlot]));
+    }
+
+    writeRendererRaw(this.renderer, sequences.join(""));
+    this.activeSlot = nextSlot;
+    this.lastBitmapKey = bitmapKey;
+    this.lastPlacementKeys = placements.map(serializePlacement);
+  }
+
+  placeActive(placement: NativePlacement | NativePlacement[]) {
+    if (this.activeSlot === null) return;
+    const placements = asPlacementArray(placement);
+    const imageId = this.imageIds[this.activeSlot];
+    const placementIds = this.ensurePlacementIds(placements.length);
+    const sequences: string[] = [];
+
+    placements.forEach((entry, index) => {
+      const placementKey = serializePlacement(entry);
+      if (placementKey === this.lastPlacementKeys[index]) return;
+      sequences.push(encodeKittyPlacement({
+        imageId,
+        placementId: placementIds[index]!,
+        column: entry.column,
+        row: entry.row,
+        cols: entry.cols,
+        rows: entry.rows,
+        cropX: entry.cropX,
+        cropY: entry.cropY,
+        cropWidth: entry.cropWidth,
+        cropHeight: entry.cropHeight,
+      }));
+    });
+
+    for (let index = placements.length; index < this.lastPlacementKeys.length; index += 1) {
+      sequences.push(encodeKittyDeleteImage(imageId, placementIds[index]!));
+    }
+
+    if (sequences.length === 0) return;
+
+    writeRendererRaw(this.renderer, sequences.join(""));
+    this.lastPlacementKeys = placements.map(serializePlacement);
+  }
+
+  clear() {
+    writeRendererRaw(
+      this.renderer,
+      `${encodeKittyDeleteImage(this.imageIds[0])}${encodeKittyDeleteImage(this.imageIds[1])}`,
+    );
+    this.activeSlot = null;
+    this.lastBitmapKey = null;
+    this.lastPlacementKeys = [];
+  }
+
+  destroy() {
+    this.clear();
+  }
+
+  private ensurePlacementIds(count: number): number[] {
+    while (this.placementIds.length < count) {
+      this.placementIds.push(allocatePlacementId());
+    }
+    return this.placementIds;
+  }
+}

package/src/components/chart/native/kitty-protocol.ts

@@ -0,0 +1,110 @@
+import { deflateSync } from "node:zlib";
+
+export interface KittyPlacement {
+  imageId: number;
+  placementId: number;
+  column: number;
+  row: number;
+  cols: number;
+  rows: number;
+  cropX?: number;
+  cropY?: number;
+  cropWidth?: number;
+  cropHeight?: number;
+  xOffset?: number;
+  yOffset?: number;
+  zIndex?: number;
+}
+
+export interface KittyTransmitOptions {
+  imageId: number;
+  width: number;
+  height: number;
+  rgba: Uint8Array;
+  chunkSize?: number;
+}
+
+const APC_START = "\x1b_G";
+const APC_END = "\x1b\\";
+const DEFAULT_CHUNK_SIZE = 4096;
+
+function buildControlData(entries: Array<[string, string | number | null | undefined]>): string {
+  return entries
+    .filter(([, value]) => value !== null && value !== undefined)
+    .map(([key, value]) => `${key}=${value}`)
+    .join(",");
+}
+
+function wrapKittySequence(control: string, payload = ""): string {
+  return `${APC_START}${control};${payload}${APC_END}`;
+}
+
+export function chunkBase64Payload(base64: string, chunkSize = DEFAULT_CHUNK_SIZE): string[] {
+  const chunks: string[] = [];
+  for (let index = 0; index < base64.length; index += chunkSize) {
+    chunks.push(base64.slice(index, index + chunkSize));
+  }
+  return chunks.length > 0 ? chunks : [""];
+}
+
+export function buildKittyGraphicsQuery(imageId = 31): string {
+  return wrapKittySequence(`i=${imageId},s=1,v=1,a=q,t=d,f=24`, "AAAA");
+}
+
+export function encodeKittyTransmitRgba(options: KittyTransmitOptions): string[] {
+  const compressed = deflateSync(Buffer.from(options.rgba));
+  const chunks = chunkBase64Payload(compressed.toString("base64"), options.chunkSize);
+
+  return chunks.map((chunk, index) => {
+    const isLast = index === chunks.length - 1;
+    const control = index === 0
+      ? buildControlData([
+        ["a", "t"],
+        ["f", 32],
+        ["t", "d"],
+        ["o", "z"],
+        ["s", options.width],
+        ["v", options.height],
+        ["i", options.imageId],
+        ["q", 2],
+        ["m", isLast ? 0 : 1],
+      ])
+      : buildControlData([
+        ["m", isLast ? 0 : 1],
+      ]);
+
+    return wrapKittySequence(control, chunk);
+  });
+}
+
+export function encodeKittyPlacement(placement: KittyPlacement): string {
+  const control = buildControlData([
+    ["a", "p"],
+    ["i", placement.imageId],
+    ["p", placement.placementId],
+    ["q", 2],
+    ["x", placement.cropX ?? 0],
+    ["y", placement.cropY ?? 0],
+    ["w", placement.cropWidth ?? 0],
+    ["h", placement.cropHeight ?? 0],
+    ["X", placement.xOffset ?? 0],
+    ["Y", placement.yOffset ?? 0],
+    ["c", placement.cols],
+    ["r", placement.rows],
+    ["z", placement.zIndex ?? -1],
+    ["C", 1],
+  ]);
+
+  return `\x1b[s\x1b[${placement.row};${placement.column}H${wrapKittySequence(control)}\x1b[u`;
+}
+
+export function encodeKittyDeleteImage(imageId: number, placementId?: number): string {
+  return wrapKittySequence(buildControlData([
+    ["a", "d"],
+    ["d", "I"],
+    ["i", imageId],
+    ["p", placementId ?? null],
+    ["q", 2],
+  ]));
+}
+

package/src/components/chart/native/kitty-support.ts

@@ -0,0 +1,71 @@
+import type { CliRenderer } from "@opentui/core";
+import { writeRendererRaw } from "./kitty-adapter";
+import { buildKittyGraphicsQuery } from "./kitty-protocol";
+
+interface RendererCapabilities {
+  kitty_graphics?: boolean;
+}
+
+interface SupportCacheEntry {
+  value: boolean | null;
+  promise?: Promise<boolean>;
+}
+
+const supportCache = new WeakMap<CliRenderer, SupportCacheEntry>();
+const QUERY_TIMEOUT_MS = 250;
+
+function readKnownSupport(renderer: CliRenderer): boolean | null {
+  const capabilities = renderer.capabilities as RendererCapabilities | null;
+  return typeof capabilities?.kitty_graphics === "boolean" ? capabilities.kitty_graphics : null;
+}
+
+export function getCachedKittySupport(renderer: CliRenderer): boolean | null {
+  const cached = supportCache.get(renderer)?.value ?? null;
+  if (cached !== null) return cached;
+  return readKnownSupport(renderer);
+}
+
+export function ensureKittySupport(renderer: CliRenderer): Promise<boolean> {
+  const known = readKnownSupport(renderer);
+  if (known !== null) {
+    supportCache.set(renderer, { value: known });
+    return Promise.resolve(known);
+  }
+
+  const cached = supportCache.get(renderer);
+  if (cached?.promise) return cached.promise;
+
+  const nextEntry: SupportCacheEntry = { value: null };
+  const promise = new Promise<boolean>((resolve) => {
+    let settled = false;
+
+    const finish = (value: boolean) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      renderer.off("capabilities", onCapabilities);
+      nextEntry.value = value;
+      nextEntry.promise = undefined;
+      resolve(value);
+    };
+
+    const onCapabilities = () => {
+      const supported = readKnownSupport(renderer);
+      if (supported !== null) finish(supported);
+    };
+
+    const timer = setTimeout(() => finish(false), QUERY_TIMEOUT_MS);
+    renderer.on("capabilities", onCapabilities);
+    if (!writeRendererRaw(renderer, `${buildKittyGraphicsQuery()}\x1b[c`)) {
+      finish(false);
+      return;
+    }
+    const supported = readKnownSupport(renderer);
+    if (supported !== null) finish(supported);
+  });
+
+  nextEntry.promise = promise;
+  supportCache.set(renderer, nextEntry);
+  return promise;
+}
+