@silvery/term 0.3.0

package/src/adapters/flexily-zero-adapter.ts

@@ -0,0 +1,368 @@
+/**
+ * Flexily Layout Engine Adapter
+ *
+ * Wraps Flexily to implement the LayoutEngine interface.
+ * Uses the default zero-allocation algorithm from flexily.
+ */
+
+import {
+  ALIGN_AUTO,
+  ALIGN_BASELINE,
+  ALIGN_CENTER,
+  ALIGN_FLEX_END,
+  ALIGN_FLEX_START,
+  ALIGN_SPACE_AROUND,
+  ALIGN_SPACE_BETWEEN,
+  ALIGN_SPACE_EVENLY,
+  ALIGN_STRETCH,
+  DIRECTION_LTR,
+  DISPLAY_FLEX,
+  DISPLAY_NONE,
+  EDGE_ALL,
+  EDGE_BOTTOM,
+  EDGE_HORIZONTAL,
+  EDGE_LEFT,
+  EDGE_RIGHT,
+  EDGE_TOP,
+  EDGE_VERTICAL,
+  // Constants
+  FLEX_DIRECTION_COLUMN,
+  FLEX_DIRECTION_COLUMN_REVERSE,
+  FLEX_DIRECTION_ROW,
+  FLEX_DIRECTION_ROW_REVERSE,
+  Node as FlexilyNode,
+  GUTTER_ALL,
+  GUTTER_COLUMN,
+  GUTTER_ROW,
+  JUSTIFY_CENTER,
+  JUSTIFY_FLEX_END,
+  JUSTIFY_FLEX_START,
+  JUSTIFY_SPACE_AROUND,
+  JUSTIFY_SPACE_BETWEEN,
+  JUSTIFY_SPACE_EVENLY,
+  MEASURE_MODE_AT_MOST,
+  MEASURE_MODE_EXACTLY,
+  MEASURE_MODE_UNDEFINED,
+  OVERFLOW_HIDDEN,
+  OVERFLOW_SCROLL,
+  OVERFLOW_VISIBLE,
+  POSITION_TYPE_ABSOLUTE,
+  POSITION_TYPE_RELATIVE,
+  POSITION_TYPE_STATIC,
+  WRAP_NO_WRAP,
+  WRAP_WRAP,
+  WRAP_WRAP_REVERSE,
+} from "flexily"
+
+import type {
+  AlignValue,
+  DirectionValue,
+  DisplayValue,
+  EdgeValue,
+  FlexDirectionValue,
+  GutterValue,
+  JustifyValue,
+  LayoutConstants,
+  LayoutEngine,
+  LayoutNode,
+  MeasureFunc,
+  MeasureMode,
+  MeasureModeValue,
+  OverflowValue,
+  PositionTypeValue,
+  WrapValue,
+} from "../layout-engine"
+
+// ============================================================================
+// Flexily Zero Node Adapter
+// ============================================================================
+
+/**
+ * Wraps a Flexily zero-alloc node to implement LayoutNode interface.
+ * Since Flexily already has a Yoga-compatible API, this is mostly delegation.
+ */
+class FlexilyZeroNodeAdapter implements LayoutNode {
+  private node: FlexilyNode
+
+  constructor(node: FlexilyNode) {
+    this.node = node
+  }
+
+  /** Get the underlying Flexily node (for tree operations) */
+  getFlexilyNode(): FlexilyNode {
+    return this.node
+  }
+
+  // Tree operations
+  insertChild(child: LayoutNode, index: number): void {
+    const flexilyChild = (child as FlexilyZeroNodeAdapter).getFlexilyNode()
+    this.node.insertChild(flexilyChild, index)
+  }
+
+  removeChild(child: LayoutNode): void {
+    const flexilyChild = (child as FlexilyZeroNodeAdapter).getFlexilyNode()
+    this.node.removeChild(flexilyChild)
+  }
+
+  free(): void {
+    this.node.free()
+  }
+
+  // Measure function
+  setMeasureFunc(measureFunc: MeasureFunc): void {
+    this.node.setMeasureFunc((width, widthMode, height, heightMode) => {
+      const widthModeStr = this.measureModeToString(widthMode)
+      const heightModeStr = this.measureModeToString(heightMode)
+      return measureFunc(width, widthModeStr, height, heightModeStr)
+    })
+  }
+
+  // Dirty tracking - forces layout recalculation
+  markDirty(): void {
+    this.node.markDirty()
+  }
+
+  private measureModeToString(mode: number): MeasureMode {
+    if (mode === MEASURE_MODE_EXACTLY) return "exactly"
+    if (mode === MEASURE_MODE_AT_MOST) return "at-most"
+    return "undefined"
+  }
+
+  // Dimension setters
+  setWidth(value: number): void {
+    this.node.setWidth(value)
+  }
+  setWidthPercent(value: number): void {
+    this.node.setWidthPercent(value)
+  }
+  setWidthAuto(): void {
+    this.node.setWidthAuto()
+  }
+  setHeight(value: number): void {
+    this.node.setHeight(value)
+  }
+  setHeightPercent(value: number): void {
+    this.node.setHeightPercent(value)
+  }
+  setHeightAuto(): void {
+    this.node.setHeightAuto()
+  }
+  setMinWidth(value: number): void {
+    this.node.setMinWidth(value)
+  }
+  setMinWidthPercent(value: number): void {
+    this.node.setMinWidthPercent(value)
+  }
+  setMinHeight(value: number): void {
+    this.node.setMinHeight(value)
+  }
+  setMinHeightPercent(value: number): void {
+    this.node.setMinHeightPercent(value)
+  }
+  setMaxWidth(value: number): void {
+    this.node.setMaxWidth(value)
+  }
+  setMaxWidthPercent(value: number): void {
+    this.node.setMaxWidthPercent(value)
+  }
+  setMaxHeight(value: number): void {
+    this.node.setMaxHeight(value)
+  }
+  setMaxHeightPercent(value: number): void {
+    this.node.setMaxHeightPercent(value)
+  }
+
+  // Flex properties
+  setFlexGrow(value: number): void {
+    this.node.setFlexGrow(value)
+  }
+  setFlexShrink(value: number): void {
+    this.node.setFlexShrink(value)
+  }
+  setFlexBasis(value: number): void {
+    this.node.setFlexBasis(value)
+  }
+  setFlexBasisPercent(value: number): void {
+    this.node.setFlexBasisPercent(value)
+  }
+  setFlexBasisAuto(): void {
+    this.node.setFlexBasisAuto()
+  }
+  setFlexDirection(direction: number): void {
+    this.node.setFlexDirection(direction)
+  }
+  setFlexWrap(wrap: number): void {
+    this.node.setFlexWrap(wrap)
+  }
+
+  // Alignment
+  setAlignItems(align: number): void {
+    this.node.setAlignItems(align)
+  }
+  setAlignSelf(align: number): void {
+    this.node.setAlignSelf(align)
+  }
+  setAlignContent(align: number): void {
+    this.node.setAlignContent(align)
+  }
+  setJustifyContent(justify: number): void {
+    this.node.setJustifyContent(justify)
+  }
+
+  // Spacing
+  setPadding(edge: number, value: number): void {
+    this.node.setPadding(edge, value)
+  }
+  setMargin(edge: number, value: number): void {
+    this.node.setMargin(edge, value)
+  }
+  setBorder(edge: number, value: number): void {
+    this.node.setBorder(edge, value)
+  }
+  setGap(gutter: number, value: number): void {
+    this.node.setGap(gutter, value)
+  }
+
+  // Display & Position
+  setDisplay(display: number): void {
+    this.node.setDisplay(display)
+  }
+  setPositionType(positionType: number): void {
+    this.node.setPositionType(positionType)
+  }
+  setPosition(edge: number, value: number): void {
+    this.node.setPosition(edge, value)
+  }
+  setPositionPercent(edge: number, value: number): void {
+    this.node.setPositionPercent(edge, value)
+  }
+  setOverflow(overflow: number): void {
+    this.node.setOverflow(overflow)
+  }
+
+  // Aspect Ratio
+  setAspectRatio(value: number): void {
+    this.node.setAspectRatio(value)
+  }
+
+  // Layout calculation
+  calculateLayout(width: number, height: number, direction?: number): void {
+    this.node.calculateLayout(width, height, direction ?? DIRECTION_LTR)
+  }
+
+  // Layout results
+  getComputedLeft(): number {
+    return this.node.getComputedLeft()
+  }
+  getComputedTop(): number {
+    return this.node.getComputedTop()
+  }
+  getComputedWidth(): number {
+    return this.node.getComputedWidth()
+  }
+  getComputedHeight(): number {
+    return this.node.getComputedHeight()
+  }
+}
+
+// ============================================================================
+// Flexily Zero Layout Engine
+// ============================================================================
+
+/**
+ * Layout engine implementation using Flexily zero-allocation variant.
+ * Optimized for high-frequency layout with reduced GC pressure.
+ */
+export class FlexilyZeroLayoutEngine implements LayoutEngine {
+  private _constants: LayoutConstants = {
+    // Flex Direction (cast from Flexily's plain numbers to branded types)
+    FLEX_DIRECTION_COLUMN: FLEX_DIRECTION_COLUMN as FlexDirectionValue,
+    FLEX_DIRECTION_COLUMN_REVERSE: FLEX_DIRECTION_COLUMN_REVERSE as FlexDirectionValue,
+    FLEX_DIRECTION_ROW: FLEX_DIRECTION_ROW as FlexDirectionValue,
+    FLEX_DIRECTION_ROW_REVERSE: FLEX_DIRECTION_ROW_REVERSE as FlexDirectionValue,
+
+    // Wrap
+    WRAP_NO_WRAP: WRAP_NO_WRAP as WrapValue,
+    WRAP_WRAP: WRAP_WRAP as WrapValue,
+    WRAP_WRAP_REVERSE: WRAP_WRAP_REVERSE as WrapValue,
+
+    // Align
+    ALIGN_AUTO: ALIGN_AUTO as AlignValue,
+    ALIGN_FLEX_START: ALIGN_FLEX_START as AlignValue,
+    ALIGN_CENTER: ALIGN_CENTER as AlignValue,
+    ALIGN_FLEX_END: ALIGN_FLEX_END as AlignValue,
+    ALIGN_STRETCH: ALIGN_STRETCH as AlignValue,
+    ALIGN_BASELINE: ALIGN_BASELINE as AlignValue,
+    ALIGN_SPACE_BETWEEN: ALIGN_SPACE_BETWEEN as AlignValue,
+    ALIGN_SPACE_AROUND: ALIGN_SPACE_AROUND as AlignValue,
+    ALIGN_SPACE_EVENLY: ALIGN_SPACE_EVENLY as AlignValue,
+
+    // Justify
+    JUSTIFY_FLEX_START: JUSTIFY_FLEX_START as JustifyValue,
+    JUSTIFY_CENTER: JUSTIFY_CENTER as JustifyValue,
+    JUSTIFY_FLEX_END: JUSTIFY_FLEX_END as JustifyValue,
+    JUSTIFY_SPACE_BETWEEN: JUSTIFY_SPACE_BETWEEN as JustifyValue,
+    JUSTIFY_SPACE_AROUND: JUSTIFY_SPACE_AROUND as JustifyValue,
+    JUSTIFY_SPACE_EVENLY: JUSTIFY_SPACE_EVENLY as JustifyValue,
+
+    // Edge
+    EDGE_LEFT: EDGE_LEFT as EdgeValue,
+    EDGE_TOP: EDGE_TOP as EdgeValue,
+    EDGE_RIGHT: EDGE_RIGHT as EdgeValue,
+    EDGE_BOTTOM: EDGE_BOTTOM as EdgeValue,
+    EDGE_HORIZONTAL: EDGE_HORIZONTAL as EdgeValue,
+    EDGE_VERTICAL: EDGE_VERTICAL as EdgeValue,
+    EDGE_ALL: EDGE_ALL as EdgeValue,
+
+    // Gutter
+    GUTTER_COLUMN: GUTTER_COLUMN as GutterValue,
+    GUTTER_ROW: GUTTER_ROW as GutterValue,
+    GUTTER_ALL: GUTTER_ALL as GutterValue,
+
+    // Display
+    DISPLAY_FLEX: DISPLAY_FLEX as DisplayValue,
+    DISPLAY_NONE: DISPLAY_NONE as DisplayValue,
+
+    // Position Type
+    POSITION_TYPE_STATIC: POSITION_TYPE_STATIC as PositionTypeValue,
+    POSITION_TYPE_RELATIVE: POSITION_TYPE_RELATIVE as PositionTypeValue,
+    POSITION_TYPE_ABSOLUTE: POSITION_TYPE_ABSOLUTE as PositionTypeValue,
+
+    // Overflow
+    OVERFLOW_VISIBLE: OVERFLOW_VISIBLE as OverflowValue,
+    OVERFLOW_HIDDEN: OVERFLOW_HIDDEN as OverflowValue,
+    OVERFLOW_SCROLL: OVERFLOW_SCROLL as OverflowValue,
+
+    // Direction
+    DIRECTION_LTR: DIRECTION_LTR as DirectionValue,
+
+    // Measure Mode
+    MEASURE_MODE_UNDEFINED: MEASURE_MODE_UNDEFINED as MeasureModeValue,
+    MEASURE_MODE_EXACTLY: MEASURE_MODE_EXACTLY as MeasureModeValue,
+    MEASURE_MODE_AT_MOST: MEASURE_MODE_AT_MOST as MeasureModeValue,
+  }
+
+  createNode(): LayoutNode {
+    return new FlexilyZeroNodeAdapter(FlexilyNode.create())
+  }
+
+  get constants(): LayoutConstants {
+    return this._constants
+  }
+
+  get name(): string {
+    return "flexily-zero"
+  }
+}
+
+// ============================================================================
+// Initialization Helper
+// ============================================================================
+
+/**
+ * Create a Flexily zero-allocation layout engine.
+ * Unlike Yoga, Flexily doesn't require async initialization.
+ */
+export function createFlexilyZeroEngine(): FlexilyZeroLayoutEngine {
+  return new FlexilyZeroLayoutEngine()
+}

package/src/adapters/terminal-adapter.ts

@@ -0,0 +1,305 @@
+/**
+ * Terminal Render Adapter
+ *
+ * Implements the RenderAdapter interface for terminal output.
+ * Uses character cells as units, ANSI codes for styling.
+ */
+
+import { type Color, TerminalBuffer } from "../buffer"
+import { outputPhase } from "../pipeline/output-phase"
+import type {
+  BorderChars,
+  RenderAdapter,
+  RenderBuffer,
+  RenderStyle,
+  TextMeasureResult,
+  TextMeasureStyle,
+  TextMeasurer,
+} from "../render-adapter"
+import { type Measurer, displayWidth } from "../unicode"
+
+// ============================================================================
+// Border Characters
+// ============================================================================
+
+const BORDER_CHARS: Record<string, BorderChars> = {
+  single: {
+    topLeft: "┌",
+    topRight: "┐",
+    bottomLeft: "└",
+    bottomRight: "┘",
+    horizontal: "─",
+    vertical: "│",
+  },
+  double: {
+    topLeft: "╔",
+    topRight: "╗",
+    bottomLeft: "╚",
+    bottomRight: "╝",
+    horizontal: "═",
+    vertical: "║",
+  },
+  round: {
+    topLeft: "╭",
+    topRight: "╮",
+    bottomLeft: "╰",
+    bottomRight: "╯",
+    horizontal: "─",
+    vertical: "│",
+  },
+  bold: {
+    topLeft: "┏",
+    topRight: "┓",
+    bottomLeft: "┗",
+    bottomRight: "┛",
+    horizontal: "━",
+    vertical: "┃",
+  },
+  singleDouble: {
+    topLeft: "╓",
+    topRight: "╖",
+    bottomLeft: "╙",
+    bottomRight: "╜",
+    horizontal: "─",
+    vertical: "║",
+  },
+  doubleSingle: {
+    topLeft: "╒",
+    topRight: "╕",
+    bottomLeft: "╘",
+    bottomRight: "╛",
+    horizontal: "═",
+    vertical: "│",
+  },
+  classic: {
+    topLeft: "+",
+    topRight: "+",
+    bottomLeft: "+",
+    bottomRight: "+",
+    horizontal: "-",
+    vertical: "|",
+  },
+}
+
+// ============================================================================
+// Terminal Measurer
+// ============================================================================
+
+/** Create a terminal text measurer, optionally using an explicit width measurer. */
+export function createTerminalMeasurer(measurer?: Measurer): TextMeasurer {
+  const dw = measurer ? measurer.displayWidth.bind(measurer) : displayWidth
+  return {
+    measureText(text: string, _style?: TextMeasureStyle): TextMeasureResult {
+      return { width: dw(text), height: 1 }
+    },
+    getLineHeight(_style?: TextMeasureStyle): number {
+      return 1
+    },
+  }
+}
+
+/** Default terminal measurer (uses module-level displayWidth / scoped measurer). */
+export const terminalMeasurer: TextMeasurer = createTerminalMeasurer()
+
+// ============================================================================
+// Terminal Render Buffer
+// ============================================================================
+
+/**
+ * Wraps TerminalBuffer to implement the RenderBuffer interface.
+ */
+export class TerminalRenderBuffer implements RenderBuffer {
+  private buffer: TerminalBuffer
+  private dw: (text: string) => number
+
+  constructor(width: number, height: number, measurer?: Measurer) {
+    this.buffer = new TerminalBuffer(width, height)
+    this.dw = measurer ? measurer.displayWidth.bind(measurer) : displayWidth
+  }
+
+  get width(): number {
+    return this.buffer.width
+  }
+
+  get height(): number {
+    return this.buffer.height
+  }
+
+  /**
+   * Get the underlying TerminalBuffer for output phase.
+   */
+  getTerminalBuffer(): TerminalBuffer {
+    return this.buffer
+  }
+
+  fillRect(x: number, y: number, width: number, height: number, style: RenderStyle): void {
+    const cellStyle = this.convertStyle(style)
+    for (let row = y; row < y + height; row++) {
+      for (let col = x; col < x + width; col++) {
+        if (this.buffer.inBounds(col, row)) {
+          this.buffer.setCell(col, row, {
+            char: " ",
+            ...cellStyle,
+          })
+        }
+      }
+    }
+  }
+
+  drawText(x: number, y: number, text: string, style: RenderStyle): void {
+    const cellStyle = this.convertStyle(style)
+    let col = x
+    for (const char of text) {
+      if (!this.buffer.inBounds(col, y)) break
+      const charWidth = this.dw(char)
+      this.buffer.setCell(col, y, {
+        char,
+        ...cellStyle,
+        wide: charWidth > 1,
+      })
+      // Mark continuation cells for wide characters
+      for (let i = 1; i < charWidth; i++) {
+        if (this.buffer.inBounds(col + i, y)) {
+          this.buffer.setCell(col + i, y, {
+            char: "",
+            ...cellStyle,
+            continuation: true,
+          })
+        }
+      }
+      col += charWidth
+    }
+  }
+
+  drawChar(x: number, y: number, char: string, style: RenderStyle): void {
+    if (this.buffer.inBounds(x, y)) {
+      this.buffer.setCell(x, y, {
+        char,
+        ...this.convertStyle(style),
+      })
+    }
+  }
+
+  inBounds(x: number, y: number): boolean {
+    return this.buffer.inBounds(x, y)
+  }
+
+  private convertStyle(style: RenderStyle): {
+    fg: Color
+    bg: Color
+    underlineColor: Color
+    attrs: {
+      bold?: boolean
+      dim?: boolean
+      italic?: boolean
+      underline?: boolean
+      underlineStyle?: "single" | "double" | "curly" | "dotted" | "dashed" | false
+      strikethrough?: boolean
+      inverse?: boolean
+    }
+  } {
+    return {
+      fg: this.parseColor(style.fg),
+      bg: this.parseColor(style.bg),
+      underlineColor: this.parseColor(style.attrs?.underlineColor),
+      attrs: {
+        bold: style.attrs?.bold,
+        dim: style.attrs?.dim,
+        italic: style.attrs?.italic,
+        underline: style.attrs?.underline,
+        underlineStyle: style.attrs?.underlineStyle,
+        strikethrough: style.attrs?.strikethrough,
+        inverse: style.attrs?.inverse,
+      },
+    }
+  }
+
+  /**
+   * Parse a color string to the Color type used by TerminalBuffer.
+   */
+  private parseColor(color: string | undefined): Color {
+    if (!color) return null
+
+    // Hex color
+    if (color.startsWith("#")) {
+      const hex = color.slice(1)
+      if (hex.length === 6) {
+        return {
+          r: Number.parseInt(hex.slice(0, 2), 16),
+          g: Number.parseInt(hex.slice(2, 4), 16),
+          b: Number.parseInt(hex.slice(4, 6), 16),
+        }
+      }
+      if (hex.length === 3) {
+        return {
+          r: Number.parseInt(hex[0]! + hex[0]!, 16),
+          g: Number.parseInt(hex[1]! + hex[1]!, 16),
+          b: Number.parseInt(hex[2]! + hex[2]!, 16),
+        }
+      }
+    }
+
+    // RGB color
+    const rgbMatch = color.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/)
+    if (rgbMatch) {
+      return {
+        r: Number.parseInt(rgbMatch[1]!, 10),
+        g: Number.parseInt(rgbMatch[2]!, 10),
+        b: Number.parseInt(rgbMatch[3]!, 10),
+      }
+    }
+
+    // Named ANSI colors - map to 256-color indices
+    const namedColors: Record<string, number> = {
+      black: 0,
+      red: 1,
+      green: 2,
+      yellow: 3,
+      blue: 4,
+      magenta: 5,
+      cyan: 6,
+      white: 7,
+      gray: 8,
+      grey: 8,
+      brightblack: 8,
+      brightred: 9,
+      brightgreen: 10,
+      brightyellow: 11,
+      brightblue: 12,
+      brightmagenta: 13,
+      brightcyan: 14,
+      brightwhite: 15,
+    }
+
+    const normalized = color.toLowerCase().replace(/[^a-z]/g, "")
+    const index = namedColors[normalized]
+    if (index !== undefined) {
+      return index
+    }
+
+    return null
+  }
+}
+
+// ============================================================================
+// Terminal Adapter
+// ============================================================================
+
+export const terminalAdapter: RenderAdapter = {
+  name: "terminal",
+  measurer: terminalMeasurer,
+
+  createBuffer(width: number, height: number): RenderBuffer {
+    return new TerminalRenderBuffer(width, height)
+  },
+
+  flush(buffer: RenderBuffer, prevBuffer: RenderBuffer | null): string {
+    const termBuffer = (buffer as TerminalRenderBuffer).getTerminalBuffer()
+    const prevTermBuffer = prevBuffer ? (prevBuffer as TerminalRenderBuffer).getTerminalBuffer() : null
+    return outputPhase(prevTermBuffer, termBuffer)
+  },
+
+  getBorderChars(style: string): BorderChars {
+    return BORDER_CHARS[style] ?? BORDER_CHARS.single!
+  },
+}