@termuijs/core 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -22,17 +22,26 @@ var index_exports = {};
 __export(index_exports, {
   App: () => App,
   BORDER_CHARS: () => BORDER_CHARS,
+  BRAILLE_DOTS: () => BRAILLE_DOTS,
+  BRAILLE_OFFSET: () => BRAILLE_OFFSET,
+  BarSets: () => BarSets,
+  BorderSets: () => BorderSets,
   CTRL_KEYS: () => CTRL_KEYS,
   ColorDepth: () => ColorDepth,
   ESCAPE_SEQUENCES: () => ESCAPE_SEQUENCES,
   EventEmitter: () => EventEmitter,
   FocusManager: () => FocusManager,
+  HORIZONTAL_BAR_SYMBOLS: () => HORIZONTAL_BAR_SYMBOLS,
   InputParser: () => InputParser,
   LayerManager: () => LayerManager,
+  LineSets: () => LineSets,
   Renderer: () => Renderer,
   SPECIAL_KEYS: () => SPECIAL_KEYS,
   Screen: () => Screen,
+  ScrollbarSets: () => ScrollbarSets,
+  Shade: () => Shade,
   Terminal: () => Terminal,
+  VERTICAL_BAR_SYMBOLS: () => VERTICAL_BAR_SYMBOLS,
   ansi: () => ansi_exports,
   borderSize: () => borderSize,
   cellsEqual: () => cellsEqual,
@@ -43,23 +52,36 @@ __export(index_exports, {
   containsPoint: () => containsPoint,
   createKeyEvent: () => createKeyEvent,
   createLayoutNode: () => createLayoutNode,
+  createTestScreen: () => createTestScreen,
   defaultStyle: () => defaultStyle,
   detectColorDepth: () => detectColorDepth,
   emptyCell: () => emptyCell,
   emptyRect: () => emptyRect,
+  fill: () => fill,
   getBorderChars: () => getBorderChars,
   intersectRect: () => intersectRect,
   isMouseSequence: () => isMouseSequence,
+  length: () => length,
+  max: () => max,
   mergeStyles: () => mergeStyles,
+  min: () => min,
   normalizeEdges: () => normalizeEdges,
   parseColor: () => parseColor,
   parseMouseEvent: () => parseMouseEvent,
+  percentage: () => percentage,
+  ratio: () => ratio,
   renderFallback: () => renderFallback,
   shouldUseFallback: () => shouldUseFallback,
   shrinkRect: () => shrinkRect,
+  splitRect: () => splitRect,
   stringWidth: () => stringWidth,
   stripAnsi: () => stripAnsi,
   styleToCellAttrs: () => styleToCellAttrs,
+  testScreenClear: () => testScreenClear,
+  testScreenGetCell: () => testScreenGetCell,
+  testScreenSetCell: () => testScreenSetCell,
+  testScreenSetString: () => testScreenSetString,
+  testScreenToString: () => testScreenToString,
   truncate: () => truncate,
   unionRect: () => unionRect,
   wordWrap: () => wordWrap
@@ -125,7 +147,7 @@ function parseColor(input) {
     if (hex.length === 6 && /^[0-9a-fA-F]{6}$/.test(hex)) {
       return { type: "hex", hex: "#" + hex.toLowerCase() };
     }
-    throw new Error(`Invalid hex color: ${input}`);
+    return { type: "none" };
   }
   const rgbMatch = input.match(/^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/);
   if (rgbMatch) {
@@ -139,7 +161,7 @@ function parseColor(input) {
     const code = Math.min(255, parseInt(ansi256Match[1], 10));
     return { type: "ansi256", code };
   }
-  throw new Error(`Unknown color format: ${input}`);
+  return { type: "none" };
 }
 function colorToRgb(color) {
   switch (color.type) {
@@ -382,19 +404,26 @@ var Terminal = class {
   _resizeHandlers = [];
   _cleanupHandlers = [];
   _originalRawMode;
+  // Stored handler references for proper cleanup
+  _resizeHandler = null;
+  _exitHandler = null;
+  _sigintHandler = null;
+  _sigtermHandler = null;
+  _restored = false;
   constructor(options = {}) {
     this.stdout = options.stdout ?? process.stdout;
     this.stdin = options.stdin ?? process.stdin;
     this.colorDepth = options.colorDepth ?? detectColorDepth();
     this._cols = this.stdout.columns ?? 80;
     this._rows = this.stdout.rows ?? 24;
-    this.stdout.on("resize", () => {
+    this._resizeHandler = () => {
       this._cols = this.stdout.columns ?? 80;
       this._rows = this.stdout.rows ?? 24;
       for (const handler of this._resizeHandlers) {
         handler(this._cols, this._rows);
       }
-    });
+    };
+    this.stdout.on("resize", this._resizeHandler);
     this._setupCleanup();
   }
   /** Current terminal width in columns */
@@ -471,9 +500,18 @@ var Terminal = class {
   // ── Cleanup ─────────────────────────────────────────
   /**
    * Restore terminal to its original state.
+   * Removes all process signal handlers to prevent leaks.
    * Called automatically on SIGINT, SIGTERM, process exit.
    */
   restore() {
+    if (this._restored) return;
+    this._restored = true;
+    if (this._exitHandler) process.off("exit", this._exitHandler);
+    if (this._sigintHandler) process.off("SIGINT", this._sigintHandler);
+    if (this._sigtermHandler) process.off("SIGTERM", this._sigtermHandler);
+    if (this._resizeHandler) {
+      this.stdout.off("resize", this._resizeHandler);
+    }
     this.disableMouse();
     this.exitAltScreen();
     this.exitRawMode();
@@ -487,7 +525,7 @@ var Terminal = class {
     this._cleanupHandlers.push(handler);
   }
   _setupCleanup() {
-    const cleanup = () => {
+    const runCleanupHandlers = () => {
       for (const handler of this._cleanupHandlers) {
         try {
           handler();
@@ -496,20 +534,18 @@ var Terminal = class {
       }
       this.restore();
     };
-    process.on("exit", cleanup);
-    process.on("SIGINT", () => {
-      cleanup();
+    this._exitHandler = runCleanupHandlers;
+    this._sigintHandler = () => {
+      runCleanupHandlers();
       process.exit(130);
-    });
-    process.on("SIGTERM", () => {
-      cleanup();
+    };
+    this._sigtermHandler = () => {
+      runCleanupHandlers();
       process.exit(143);
-    });
-    process.on("uncaughtException", (err) => {
-      cleanup();
-      console.error(err);
-      process.exit(1);
-    });
+    };
+    process.on("exit", this._exitHandler);
+    process.on("SIGINT", this._sigintHandler);
+    process.on("SIGTERM", this._sigtermHandler);
   }
 };
 
@@ -528,6 +564,18 @@ function emptyCell() {
     width: 1
   };
 }
+function resetCell(cell) {
+  cell.char = " ";
+  cell.fg = { type: "none" };
+  cell.bg = { type: "none" };
+  cell.bold = false;
+  cell.italic = false;
+  cell.underline = false;
+  cell.dim = false;
+  cell.strikethrough = false;
+  cell.inverse = false;
+  cell.width = 1;
+}
 function cellsEqual(a, b) {
   return a.char === b.char && a.bold === b.bold && a.italic === b.italic && a.underline === b.underline && a.dim === b.dim && a.strikethrough === b.strikethrough && a.inverse === b.inverse && a.width === b.width && colorsEqual(a.fg, b.fg) && colorsEqual(a.bg, b.bg);
 }
@@ -659,7 +707,7 @@ var Screen = class {
   clear() {
     for (let r = 0; r < this._rows; r++) {
       for (let c = 0; c < this._cols; c++) {
-        this.back[r][c] = emptyCell();
+        resetCell(this.back[r][c]);
       }
     }
   }
@@ -1194,13 +1242,19 @@ var EventEmitter = class {
     const handlers = this._handlers.get(event);
     if (handlers) {
       for (const handler of handlers) {
-        handler(data);
+        try {
+          handler(data);
+        } catch {
+        }
       }
     }
     const onceHandlers = this._onceHandlers.get(event);
     if (onceHandlers) {
       for (const handler of onceHandlers) {
-        handler(data);
+        try {
+          handler(data);
+        } catch {
+        }
       }
       onceHandlers.clear();
     }
@@ -1641,17 +1695,17 @@ function layoutNode(node, availWidth, availHeight, precomputed = false) {
     }
     if (isRow) {
       info.node.computed = {
-        x: node.computed.x + innerX + mainOffset + info.margin.left,
-        y: node.computed.y + innerY + crossOffset + info.margin.top,
-        width: Math.max(0, info.mainSize - info.margin.left - info.margin.right),
-        height: Math.max(0, finalCrossSize - info.margin.top - info.margin.bottom)
+        x: Math.floor(node.computed.x + innerX + mainOffset + info.margin.left),
+        y: Math.floor(node.computed.y + innerY + crossOffset + info.margin.top),
+        width: Math.round(Math.max(0, info.mainSize - info.margin.left - info.margin.right)),
+        height: Math.round(Math.max(0, finalCrossSize - info.margin.top - info.margin.bottom))
       };
     } else {
       info.node.computed = {
-        x: node.computed.x + innerX + crossOffset + info.margin.left,
-        y: node.computed.y + innerY + mainOffset + info.margin.top,
-        width: Math.max(0, finalCrossSize - info.margin.left - info.margin.right),
-        height: Math.max(0, info.mainSize - info.margin.top - info.margin.bottom)
+        x: Math.floor(node.computed.x + innerX + crossOffset + info.margin.left),
+        y: Math.floor(node.computed.y + innerY + mainOffset + info.margin.top),
+        width: Math.round(Math.max(0, finalCrossSize - info.margin.left - info.margin.right)),
+        height: Math.round(Math.max(0, info.mainSize - info.margin.top - info.margin.bottom))
       };
     }
     mainOffset += info.mainSize + gap + spaceBetween;
@@ -1667,10 +1721,10 @@ function resolveSize(value, available) {
   }
   return void 0;
 }
-function clampSize(value, min, max) {
+function clampSize(value, min2, max2) {
   let result = value;
-  if (min !== void 0) result = Math.max(result, min);
-  if (max !== void 0) result = Math.min(result, max);
+  if (min2 !== void 0) result = Math.max(result, min2);
+  if (max2 !== void 0) result = Math.min(result, max2);
   return result;
 }
 
@@ -1705,6 +1759,94 @@ function unionRect(a, b) {
   return { x, y, width: r - x, height: bot - y };
 }
 
+// src/layout/ConstraintLayout.ts
+var length = (n) => ({ type: "length", value: n });
+var percentage = (n) => ({ type: "percentage", value: n });
+var ratio = (num, den) => ({ type: "ratio", num, den });
+var min = (n) => ({ type: "min", value: n });
+var max = (n) => ({ type: "max", value: n });
+var fill = (weight = 1) => ({ type: "fill", weight });
+function resolveSize2(constraint, available) {
+  switch (constraint.type) {
+    case "length":
+      return Math.min(constraint.value, available);
+    case "percentage":
+      return Math.min(Math.floor(available * constraint.value / 100), available);
+    case "ratio":
+      return constraint.den === 0 ? 0 : Math.min(
+        Math.floor(available * constraint.num / constraint.den),
+        available
+      );
+    case "min":
+      return constraint.value;
+    case "max":
+      return Math.min(constraint.value, available);
+    case "fill":
+      return 0;
+  }
+}
+function splitRect(rect, constraints, direction = "vertical", gap = 0) {
+  if (constraints.length === 0) return [];
+  const totalAvailable = direction === "horizontal" ? rect.width : rect.height;
+  const count = constraints.length;
+  const totalGaps = count > 1 ? gap * (count - 1) : 0;
+  const availableForConstraints = Math.max(0, totalAvailable - totalGaps);
+  const sizes = [];
+  let usedSpace = 0;
+  let fillWeightSum = 0;
+  for (const constraint of constraints) {
+    if (constraint.type === "fill") {
+      sizes.push(0);
+      fillWeightSum += Math.max(1, constraint.weight);
+    } else {
+      const size = resolveSize2(constraint, availableForConstraints);
+      sizes.push(size);
+      usedSpace += size;
+    }
+  }
+  if (fillWeightSum > 0) {
+    const remaining = Math.max(0, availableForConstraints - usedSpace);
+    let distributed = 0;
+    for (let i = 0; i < count; i++) {
+      const constraint = constraints[i];
+      if (!constraint || constraint.type !== "fill") continue;
+      const weight = Math.max(1, constraint.weight);
+      const share = Math.floor(remaining * weight / fillWeightSum);
+      sizes[i] = share;
+      distributed += share;
+    }
+    const leftover = remaining - distributed;
+    if (leftover > 0) {
+      for (let i = count - 1; i >= 0; i--) {
+        const constraint = constraints[i];
+        if (constraint && constraint.type === "fill") {
+          sizes[i] = (sizes[i] ?? 0) + leftover;
+          break;
+        }
+      }
+    }
+  }
+  let totalUsed = 0;
+  for (let i = 0; i < count; i++) {
+    const size = sizes[i] ?? 0;
+    const clamped = Math.max(0, Math.min(size, availableForConstraints - totalUsed));
+    sizes[i] = clamped;
+    totalUsed += clamped;
+  }
+  const results = [];
+  let offset = 0;
+  for (let i = 0; i < count; i++) {
+    const size = sizes[i] ?? 0;
+    if (direction === "horizontal") {
+      results.push({ x: rect.x + offset, y: rect.y, width: size, height: rect.height });
+    } else {
+      results.push({ x: rect.x, y: rect.y + offset, width: rect.width, height: size });
+    }
+    offset += size + gap;
+  }
+  return results;
+}
+
 // src/events/FocusManager.ts
 var FocusManager = class {
   _focusables = [];
@@ -1936,6 +2078,212 @@ var FocusManager = class {
   }
 };
 
+// src/style/symbols.ts
+var BorderSets = {
+  PLAIN: {
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518",
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    cross: "\u253C"
+  },
+  ROUNDED: {
+    topLeft: "\u256D",
+    topRight: "\u256E",
+    bottomLeft: "\u2570",
+    bottomRight: "\u256F",
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    cross: "\u253C"
+  },
+  DOUBLE: {
+    topLeft: "\u2554",
+    topRight: "\u2557",
+    bottomLeft: "\u255A",
+    bottomRight: "\u255D",
+    horizontal: "\u2550",
+    vertical: "\u2551",
+    cross: "\u256C"
+  },
+  THICK: {
+    topLeft: "\u250F",
+    topRight: "\u2513",
+    bottomLeft: "\u2517",
+    bottomRight: "\u251B",
+    horizontal: "\u2501",
+    vertical: "\u2503",
+    cross: "\u254B"
+  },
+  QUADRANT_INSIDE: {
+    topLeft: "\u2597",
+    topRight: "\u2596",
+    bottomLeft: "\u259D",
+    bottomRight: "\u2598",
+    horizontal: "\u2580",
+    vertical: "\u2590",
+    cross: "\u2588"
+  },
+  QUADRANT_OUTSIDE: {
+    topLeft: "\u259B",
+    topRight: "\u259C",
+    bottomLeft: "\u2599",
+    bottomRight: "\u259F",
+    horizontal: "\u2580",
+    vertical: "\u258C",
+    cross: "\u2588"
+  },
+  EMPTY: {
+    topLeft: " ",
+    topRight: " ",
+    bottomLeft: " ",
+    bottomRight: " ",
+    horizontal: " ",
+    vertical: " ",
+    cross: " "
+  }
+};
+var BarSets = {
+  NINE_LEVELS: {
+    full: "\u2588",
+    sevenEighths: "\u2587",
+    threeQuarters: "\u2586",
+    fiveEighths: "\u2585",
+    half: "\u2584",
+    threeEighths: "\u2583",
+    oneQuarter: "\u2582",
+    oneEighth: "\u2581",
+    empty: " "
+  },
+  THREE_LEVELS: {
+    full: "\u2588",
+    sevenEighths: "\u2591",
+    threeQuarters: "\u2591",
+    fiveEighths: "\u2591",
+    half: "\u2584",
+    threeEighths: "\u2591",
+    oneQuarter: "\u2591",
+    oneEighth: "\u2591",
+    empty: " "
+  },
+  ASCII: {
+    full: "#",
+    sevenEighths: "#",
+    threeQuarters: "#",
+    fiveEighths: "#",
+    half: "#",
+    threeEighths: "-",
+    oneQuarter: "-",
+    oneEighth: "-",
+    empty: " "
+  }
+};
+var VERTICAL_BAR_SYMBOLS = [
+  " ",
+  "\u2581",
+  "\u2582",
+  "\u2583",
+  "\u2584",
+  "\u2585",
+  "\u2586",
+  "\u2587",
+  "\u2588"
+];
+var HORIZONTAL_BAR_SYMBOLS = [
+  " ",
+  "\u258F",
+  "\u258E",
+  "\u258D",
+  "\u258C",
+  "\u258B",
+  "\u258A",
+  "\u2589",
+  "\u2588"
+];
+var ScrollbarSets = {
+  VERTICAL: { track: "\u2502", thumb: "\u2588", begin: "\u2191", end: "\u2193" },
+  HORIZONTAL: { track: "\u2500", thumb: "\u2588", begin: "\u2190", end: "\u2192" },
+  DOUBLE_VERTICAL: { track: "\u2551", thumb: "\u2590", begin: "\u25B2", end: "\u25BC" },
+  DOUBLE_HORIZONTAL: { track: "\u2550", thumb: "\u258C", begin: "\u25C4", end: "\u25BA" }
+};
+var LineSets = {
+  NORMAL: { horizontal: "\u2500", vertical: "\u2502", cross: "\u253C" },
+  THICK: { horizontal: "\u2501", vertical: "\u2503", cross: "\u254B" },
+  DOUBLE: { horizontal: "\u2550", vertical: "\u2551", cross: "\u256C" }
+};
+var Shade = {
+  FULL: "\u2588",
+  DARK: "\u2593",
+  MEDIUM: "\u2592",
+  LIGHT: "\u2591",
+  EMPTY: " "
+};
+var BRAILLE_OFFSET = 10240;
+var BRAILLE_DOTS = [
+  [1, 8],
+  [2, 16],
+  [4, 32],
+  [64, 128]
+];
+
+// src/terminal/TestBackend.ts
+function createTestScreen(width, height) {
+  const cells = [];
+  for (let row = 0; row < height; row++) {
+    const rowCells = [];
+    for (let col = 0; col < width; col++) {
+      rowCells.push(emptyCell());
+    }
+    cells.push(rowCells);
+  }
+  return { width, height, cells };
+}
+function testScreenSetCell(screen, x, y, cell) {
+  if (x < 0 || x >= screen.width || y < 0 || y >= screen.height) {
+    return;
+  }
+  const row = screen.cells[y];
+  if (row) {
+    row[x] = cell;
+  }
+}
+function testScreenGetCell(screen, x, y) {
+  if (x < 0 || x >= screen.width || y < 0 || y >= screen.height) {
+    return void 0;
+  }
+  const row = screen.cells[y];
+  return row ? row[x] : void 0;
+}
+function testScreenToString(screen) {
+  return screen.cells.map((row) => row.map((cell) => cell.char).join("")).join("\n");
+}
+function testScreenClear(screen) {
+  for (let y = 0; y < screen.height; y++) {
+    const row = screen.cells[y];
+    if (row) {
+      for (let x = 0; x < screen.width; x++) {
+        row[x] = emptyCell();
+      }
+    }
+  }
+}
+function testScreenSetString(screen, x, y, str) {
+  let cx = x;
+  for (const ch of str) {
+    if (cx >= screen.width) break;
+    if (cx >= 0 && y >= 0 && y < screen.height) {
+      const row = screen.cells[y];
+      if (row) {
+        const cell = emptyCell();
+        cell.char = ch;
+        row[cx] = cell;
+      }
+    }
+    cx++;
+  }
+}
+
 // src/app/Fallback.ts
 function shouldUseFallback() {
   if (!process.stdout.isTTY) return true;
@@ -1996,7 +2344,7 @@ var App = class {
    */
   async mount() {
     if (this._mounted) return 0;
-    if (this._options.forceFallback || shouldUseFallback()) {
+    if (this._options.forceFallback || !this._options.skipFallback && shouldUseFallback()) {
       this._renderFallback();
       return 0;
     }
@@ -2106,8 +2454,6 @@ var App = class {
     if (this._exitResolve) {
       this._exitResolve(code);
       this._exitResolve = null;
-    } else {
-      process.exit(code);
     }
   }
   /**
@@ -2320,17 +2666,26 @@ function wordWrap(str, width) {
 0 && (module.exports = {
   App,
   BORDER_CHARS,
+  BRAILLE_DOTS,
+  BRAILLE_OFFSET,
+  BarSets,
+  BorderSets,
   CTRL_KEYS,
   ColorDepth,
   ESCAPE_SEQUENCES,
   EventEmitter,
   FocusManager,
+  HORIZONTAL_BAR_SYMBOLS,
   InputParser,
   LayerManager,
+  LineSets,
   Renderer,
   SPECIAL_KEYS,
   Screen,
+  ScrollbarSets,
+  Shade,
   Terminal,
+  VERTICAL_BAR_SYMBOLS,
   ansi,
   borderSize,
   cellsEqual,
@@ -2341,23 +2696,36 @@ function wordWrap(str, width) {
   containsPoint,
   createKeyEvent,
   createLayoutNode,
+  createTestScreen,
   defaultStyle,
   detectColorDepth,
   emptyCell,
   emptyRect,
+  fill,
   getBorderChars,
   intersectRect,
   isMouseSequence,
+  length,
+  max,
   mergeStyles,
+  min,
   normalizeEdges,
   parseColor,
   parseMouseEvent,
+  percentage,
+  ratio,
   renderFallback,
   shouldUseFallback,
   shrinkRect,
+  splitRect,
   stringWidth,
   stripAnsi,
   styleToCellAttrs,
+  testScreenClear,
+  testScreenGetCell,
+  testScreenSetCell,
+  testScreenSetString,
+  testScreenToString,
   truncate,
   unionRect,
   wordWrap