@zakmandhro/bunti 0.1.0

package/src/render.ts

@@ -0,0 +1,302 @@
+/**
+ * Bunti Functional Rendering & Diffing
+ */
+
+import { ANSI, type ScreenState } from './state';
+
+/**
+ * Diffs back and front buffers surgically.
+ */
+export function flush(state: ScreenState) {
+  const writer = Bun.stdout.writer();
+  let renderString = '';
+  let lastFg: any = state.lastFg;
+  let lastBg: any = state.lastBg;
+  let lastBold: boolean = state.lastBold ?? false;
+
+  const width = state.width;
+  const height = state.height;
+
+  for (let y = 0; y < height; y++) {
+    let firstDirty = -1;
+    let lastDirty = -1;
+    const rowOffset = y * width;
+
+    for (let x = 0; x < width; x++) {
+      const idx = rowOffset + x;
+      const b = state.backBuffer[idx];
+      const f = state.frontBuffer[idx];
+      if (
+        b.char !== f.char ||
+        b.fg !== f.fg ||
+        b.bg !== f.bg ||
+        !!b.bold !== !!f.bold
+      ) {
+        if (firstDirty === -1) firstDirty = x;
+        lastDirty = x;
+      }
+    }
+
+    if (firstDirty !== -1) {
+      renderString += `\x1b[${y + 1};${firstDirty + 1}H`;
+
+      for (let x = firstDirty; x <= lastDirty; x++) {
+        const idx = rowOffset + x;
+        const cell = state.backBuffer[idx];
+        const front = state.frontBuffer[idx];
+
+        if (cell.char === '') {
+          front.char = '';
+          front.fg = cell.fg;
+          front.bg = cell.bg;
+          front.fgCode = cell.fgCode;
+          front.bgCode = cell.bgCode;
+          front.bold = cell.bold;
+          continue;
+        }
+
+        const fg = cell.fgCode;
+        const bg = cell.bgCode;
+        const bold = !!cell.bold;
+
+        if (bold !== lastBold) {
+          renderString += bold ? '\x1b[1m' : '\x1b[22m';
+          lastBold = bold;
+        }
+
+        if (fg !== lastFg || bg !== lastBg) {
+          if (fg === undefined && bg === undefined) {
+            renderString += '\x1b[0m';
+            if (lastBold) {
+              renderString += '\x1b[1m';
+            }
+          } else {
+            // Foreground
+            if (fg !== lastFg) {
+              if (fg === undefined) {
+                renderString += '\x1b[39m';
+              } else {
+                const fgStr = String(fg);
+                if (fgStr.startsWith('2;')) {
+                  renderString += `\x1b[38;${fgStr}m`;
+                } else {
+                  renderString += `\x1b[38;5;${fgStr}m`;
+                }
+              }
+            }
+            // Background
+            if (bg !== lastBg) {
+              if (bg === undefined) {
+                renderString += '\x1b[49m';
+              } else {
+                const bgStr = String(bg);
+                if (bgStr.startsWith('2;')) {
+                  renderString += `\x1b[48;${bgStr}m`;
+                } else {
+                  renderString += `\x1b[48;5;${bgStr}m`;
+                }
+              }
+            }
+          }
+          lastFg = fg;
+          lastBg = bg;
+        }
+
+        renderString += cell.char;
+        front.char = cell.char;
+        front.fg = cell.fg;
+        front.bg = cell.bg;
+        front.fgCode = cell.fgCode;
+        front.bgCode = cell.bgCode;
+        front.bold = cell.bold;
+      }
+    }
+  }
+
+  if (renderString) {
+    writer.write(
+      ANSI.syncStart + ANSI.hideCursor + renderString + ANSI.syncEnd,
+    );
+    writer.flush();
+  }
+
+  state.lastFg = lastFg;
+  state.lastBg = lastBg;
+  state.lastBold = lastBold;
+}
+
+/**
+ * Starts the render loop for a given screen state.
+ */
+export function loop(
+  state: ScreenState,
+  renderCallback: (s: ScreenState) => void,
+): Promise<void> {
+  const options = state.options;
+
+  if (options.alternateBuffer) process.stdout.write(ANSI.alternateBuffer);
+  if (options.hideCursor) process.stdout.write(ANSI.hideCursor);
+
+  return new Promise((resolve) => {
+    let stopped = false;
+    let interval: ReturnType<typeof setInterval> | null = null;
+
+    const setupInput = () => {
+      let cmd = '';
+      if (options.mouse) cmd += ANSI.mouseEnable;
+      if (options.focus) cmd += ANSI.focusEnable;
+      if (cmd) process.stdout.write(cmd);
+
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('data', inputHandler);
+      }
+    };
+
+    const inputHandler = (data: unknown) => handleInput(state, data, stop);
+
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+
+      if (interval) clearInterval(interval);
+
+      // 1. Restore Terminal Modes
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+      }
+
+      // 2. Remove Listeners
+      process.stdin.removeListener('data', inputHandler);
+      process.removeListener('SIGWINCH', resizeHandler);
+      process.removeListener('SIGINT', stop);
+      process.removeListener('SIGTERM', stop);
+
+      // 3. Emit Restorative ANSI Sequence
+      let cmd = '';
+      if (options.mouse) cmd += ANSI.mouseDisable;
+      if (options.focus) cmd += ANSI.focusDisable;
+      if (options.alternateBuffer) cmd += ANSI.mainBuffer;
+      if (options.hideCursor) cmd += ANSI.showCursor;
+      cmd += ANSI.reset;
+
+      process.stdout.write(cmd);
+      resolve();
+    };
+
+    const resizeHandler = () => {
+      resizeScreen(state);
+      tick();
+    };
+
+    let ticking = false;
+    let tickAgain = false;
+
+    const tick = () => {
+      if (ticking) {
+        tickAgain = true;
+        return;
+      }
+
+      ticking = true;
+      try {
+        do {
+          tickAgain = false;
+          renderCallback(state);
+          flush(state);
+          state.lastKey = undefined;
+        } while (tickAgain);
+      } catch (err) {
+        console.error(err);
+      } finally {
+        ticking = false;
+      }
+    };
+
+    const requestTick = () => {
+      if (ticking) {
+        tickAgain = true;
+      } else {
+        tick();
+      }
+    };
+
+    const restartLoop = () => {
+      if (interval) clearInterval(interval);
+      const fps = state.hasFocus ? options.fps || 60 : 5;
+      interval = setInterval(tick, 1000 / fps);
+      requestTick();
+    };
+
+    if (options.mouse || options.focus || options.keyboard) setupInput();
+
+    process.on('SIGWINCH', resizeHandler);
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+
+    (state as { restartLoop?: () => void }).restartLoop = restartLoop;
+    (state as { requestTick?: () => void }).requestTick = requestTick;
+    (state as { requestStop?: () => void }).requestStop = stop;
+    restartLoop();
+  });
+}
+
+function handleInput(state: ScreenState, data: any, stop: () => void) {
+  const input = data.toString();
+
+  // 1. Focus Tracking
+  if (input === '\x1b[I') {
+    state.hasFocus = true;
+    if ((state as any).restartLoop) (state as any).restartLoop();
+    return;
+  }
+  if (input === '\x1b[O') {
+    state.hasFocus = false;
+    if ((state as any).restartLoop) (state as any).restartLoop();
+    return;
+  }
+
+  // 2. Mouse Tracking (SGR protocol)
+  const match = input.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+  if (match) {
+    state.mouseButton = parseInt(match[1], 10);
+    state.mouseX = parseInt(match[2], 10) - 1;
+    state.mouseY = parseInt(match[3], 10) - 1;
+    state.isMouseDown = match[4] === 'M';
+    if (match[4] === 'M') {
+      if (state.mouseButton === 64) state.lastKey = 'wheel_up';
+      else if (state.mouseButton === 65) state.lastKey = 'wheel_down';
+      else if (state.mouseButton === 0) state.lastKey = 'click';
+      if ((state as { requestTick?: () => void }).requestTick) {
+        (state as { requestTick?: () => void }).requestTick!();
+      }
+    }
+    return;
+  }
+
+  // 3. Signal Interception
+  if (input === '\u0003') {
+    stop(); // Ctrl+C
+    return;
+  }
+
+  // 4. Key Normalization
+  let key = input;
+  if (input === '\x7f' || input === '\x08') key = 'backspace';
+  else if (input === '\r' || input === '\n') key = 'enter';
+  else if (input === '\t') key = 'tab';
+  else if (input === '\x1b[A') key = 'up';
+  else if (input === '\x1b[B') key = 'down';
+  else if (input === '\x1b[C') key = 'right';
+  else if (input === '\x1b[D') key = 'left';
+  else if (input === '\x1b') key = 'escape';
+
+  state.lastKey = key;
+  if ((state as { requestTick?: () => void }).requestTick) {
+    (state as { requestTick?: () => void }).requestTick!();
+  }
+}
+
+import { resizeScreen } from './state';

package/src/state.ts

@@ -0,0 +1,148 @@
+/**
+ * Bunti Functional Screen State & Initialization
+ */
+
+export interface RGB {
+  r: number;
+  g: number;
+  b: number;
+}
+
+export interface Cell {
+  char: string;
+  fg?: string | number | RGB;
+  bg?: string | number | RGB;
+  bold?: boolean;
+  fgCode?: string | number;
+  bgCode?: string | number;
+  raw?: boolean; // Bypasses automatic emoji-to-NF replacement
+}
+
+export interface ScreenState {
+  width: number;
+  height: number;
+  frontBuffer: Cell[];
+  backBuffer: Cell[];
+  mouseX: number;
+  mouseY: number;
+  mouseButton: number;
+  isMouseDown: boolean;
+  hasFocus: boolean;
+  lastKey?: string;
+  focusedId?: string;
+  focusableIds: string[];
+  componentState: Map<string, any>;
+  startTime: number;
+  lastFg?: any;
+  lastBg?: any;
+  lastBold?: boolean;
+  id?: string;
+  options: ScreenOptions;
+  requestStop?: () => void;
+}
+
+export interface ScreenOptions {
+  fps?: number;
+  mouse?: boolean;
+  focus?: boolean;
+  keyboard?: boolean;
+  alternateBuffer?: boolean;
+  hideCursor?: boolean;
+  nerdFont?: boolean;
+}
+
+/**
+ * Creates a fresh ScreenState based on the terminal dimensions and options.
+ */
+export function createScreenState(options: ScreenOptions = {}): ScreenState {
+  const width = process.stdout.columns || 80;
+  const height = process.stdout.rows || 24;
+  const size = width * height;
+
+  const state: ScreenState = {
+    width,
+    height,
+    frontBuffer: Array.from({ length: size }, () => ({
+      char: '',
+      fg: undefined,
+      bg: undefined,
+      fgCode: undefined,
+      bgCode: undefined,
+    })),
+    backBuffer: Array.from({ length: size }, () => ({
+      char: ' ',
+      fg: undefined,
+      bg: undefined,
+      fgCode: undefined,
+      bgCode: undefined,
+    })),
+    mouseX: 0,
+    mouseY: 0,
+    mouseButton: 0,
+    isMouseDown: false,
+    hasFocus: true,
+    focusableIds: [],
+    componentState: new Map(),
+    startTime: Date.now(),
+    options,
+  };
+
+  return state;
+}
+
+/**
+ * Resizes the front/back buffers to match the new terminal size.
+ */
+export function resizeScreen(state: ScreenState) {
+  const width = process.stdout.columns || 80;
+  const height = process.stdout.rows || 24;
+  const size = width * height;
+
+  state.width = width;
+  state.height = height;
+  state.frontBuffer = Array.from({ length: size }, () => ({
+    char: '',
+    fg: undefined,
+    bg: undefined,
+    fgCode: undefined,
+    bgCode: undefined,
+  }));
+  state.backBuffer = Array.from({ length: size }, () => ({
+    char: ' ',
+    fg: undefined,
+    bg: undefined,
+    fgCode: undefined,
+    bgCode: undefined,
+  }));
+}
+
+/**
+ * Clears the back buffer to the base wallpaper or a given cell style.
+ */
+export function clearBackBuffer(state: ScreenState) {
+  for (let i = 0; i < state.backBuffer.length; i++) {
+    const cell = state.backBuffer[i];
+    cell.char = ' ';
+    cell.fg = undefined;
+    cell.bg = undefined;
+    cell.fgCode = undefined;
+    cell.bgCode = undefined;
+    cell.bold = false;
+  }
+}
+
+export const ANSI = {
+  reset: '\x1b[0m',
+  clear: '\x1b[2J',
+  home: '\x1b[H',
+  alternateBuffer: '\x1b[?1049h',
+  mainBuffer: '\x1b[?1049l',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+  mouseEnable: '\x1b[?1003h\x1b[?1006h',
+  mouseDisable: '\x1b[?1003l\x1b[?1006l',
+  focusEnable: '\x1b[?1004h',
+  focusDisable: '\x1b[?1004l',
+  syncStart: '\x1b[?2026h',
+  syncEnd: '\x1b[?2026l',
+};

package/src/utils.ts

@@ -0,0 +1,165 @@
+/**
+ * Bunti Utility Suite - Bun-Native High Performance Edition
+ */
+
+/**
+ * Strips ANSI escape sequences from a string to allow accurate width measurement.
+ */
+export function stripAnsi(str: string): string {
+  if (!str) return '';
+  return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+}
+
+/**
+ * Calculates the visible width of a string using Bun's SIMD-optimized API.
+ */
+export function visibleWidth(str: string): number {
+  if (!str) return 0;
+  const lines = str.split('\n');
+  if (lines.length > 1) {
+    return Math.max(...lines.map(visibleWidth));
+  }
+
+  return Bun.stringWidth(stripAnsi(str));
+}
+
+/**
+ * Returns the width of a single character or grapheme.
+ */
+export function charWidth(char: string): number {
+  const clean = stripAnsi(char);
+  if (clean.length === 0) return 0;
+  return Bun.stringWidth(clean);
+}
+
+/**
+ * Truncates a string to a visible width while preserving ANSI codes.
+ * GUARANTEE: Never slices an ANSI escape sequence in half.
+ */
+export function truncate(str: string, width: number, tail = '…'): string {
+  const visible = visibleWidth(str);
+  if (visible <= width) return str;
+
+  const targetWidth = width - visibleWidth(tail);
+  if (targetWidth <= 0) return '';
+
+  let currentWidth = 0;
+  let out = '';
+
+  // Custom parsing loop to isolate ANSI sequences from text
+  const regex = /\x1B\[[0-9;]*[a-zA-Z]/g;
+  let lastIndex = 0;
+  let match: RegExpExecArray | null = null;
+
+  while ((match = regex.exec(str)) !== null) {
+    // 1. Process text before the ANSI code
+    const textSegment = str.substring(lastIndex, match.index);
+    if (textSegment.length > 0) {
+      const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+      for (const { segment } of segmenter.segment(textSegment)) {
+        const w = charWidth(segment);
+        if (currentWidth + w > targetWidth) {
+          return `${out}\x1b[0m${tail}`; // Return immediately upon hitting limit
+        }
+        out += segment;
+        currentWidth += w;
+      }
+    }
+
+    // 2. Append the ANSI code itself (zero width)
+    out += match[0];
+    lastIndex = regex.lastIndex;
+  }
+
+  // 3. Process remaining text after the last ANSI code
+  const remainingText = str.substring(lastIndex);
+  if (remainingText.length > 0) {
+    const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+    for (const { segment } of segmenter.segment(remainingText)) {
+      const w = charWidth(segment);
+      if (currentWidth + w > targetWidth) {
+        return `${out}\x1b[0m${tail}`;
+      }
+      out += segment;
+      currentWidth += w;
+    }
+  }
+
+  return `${out}\x1b[0m`;
+}
+
+/**
+ * Wraps text to a specific visible width, preserving ANSI codes.
+ * Implements word-based wrapping with fallback to char-breaking for long tokens.
+ */
+export function wrapText(str: string, width: number): string[] {
+  if (width <= 0) return [str];
+  const result: string[] = [];
+  const rawLines = str.split('\n');
+
+  for (const rawLine of rawLines) {
+    if (visibleWidth(rawLine) <= width) {
+      result.push(rawLine);
+      continue;
+    }
+
+    // Split into tokens: words and whitespaces
+    const tokens = rawLine.split(/(\s+)/).filter((t) => t.length > 0);
+    let currentLine = '';
+    let currentWidth = 0;
+
+    for (const token of tokens) {
+      const tokenWidth = visibleWidth(token);
+      const isWhitespace = /^\s+$/.test(stripAnsi(token));
+
+      // If token itself is too wide, we MUST break it by character
+      if (tokenWidth > width) {
+        // Flush current line if it exists
+        if (currentLine) {
+          result.push(`${currentLine}\x1b[0m`);
+          currentLine = '';
+          currentWidth = 0;
+        }
+
+        // Segmented break of the long token
+        const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+        for (const { segment } of segmenter.segment(token)) {
+          const sw = charWidth(segment);
+          if (currentWidth + sw > width) {
+            result.push(`${currentLine}\x1b[0m`);
+            currentLine = segment;
+            currentWidth = sw;
+          } else {
+            currentLine += segment;
+            currentWidth += sw;
+          }
+        }
+        continue;
+      }
+
+      // Normal word wrap
+      if (currentWidth + tokenWidth > width) {
+        if (isWhitespace) {
+          // Swallow leading whitespace on new lines
+          continue;
+        }
+        result.push(`${currentLine.trimEnd()}\x1b[0m`);
+        currentLine = token;
+        currentWidth = tokenWidth;
+      } else {
+        currentLine += token;
+        currentWidth += tokenWidth;
+      }
+    }
+    if (currentLine) result.push(currentLine.trimEnd());
+  }
+
+  return result;
+}
+
+/**
+ * Identity function.
+ */
+export function replaceEmojis(str: string): string {
+  return str;
+}