@termuijs/ui 0.1.3 → 0.1.4

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,37 +17,55 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Box: () => import_widgets12.Box,
+  Box: () => import_widgets17.Box,
   CommandPalette: () => CommandPalette,
   ConfirmDialog: () => ConfirmDialog,
   Divider: () => Divider,
   Form: () => Form,
-  Gauge: () => import_widgets12.Gauge,
-  List: () => import_widgets12.List,
-  LogView: () => import_widgets12.LogView,
+  Gauge: () => import_widgets17.Gauge,
+  KeyboardShortcuts: () => KeyboardShortcuts,
+  List: () => import_widgets17.List,
+  LogView: () => import_widgets17.LogView,
   Modal: () => Modal,
   MultiSelect: () => MultiSelect,
-  ProgressBar: () => import_widgets12.ProgressBar,
+  NonInteractiveError: () => NonInteractiveError,
+  NotificationCenter: () => NotificationCenter,
+  NotificationStore: () => NotificationStore,
+  NumberInput: () => NumberInput,
+  PasswordInput: () => PasswordInput,
+  PathInput: () => PathInput,
+  ProgressBar: () => import_widgets17.ProgressBar,
   Select: () => Select,
   Spacer: () => Spacer,
-  Sparkline: () => import_widgets12.Sparkline,
-  Spinner: () => import_widgets12.Spinner,
-  StatusIndicator: () => import_widgets12.StatusIndicator,
-  Table: () => import_widgets12.Table,
+  Sparkline: () => import_widgets17.Sparkline,
+  Spinner: () => import_widgets17.Spinner,
+  StatusIndicator: () => import_widgets17.StatusIndicator,
+  Table: () => import_widgets17.Table,
   Tabs: () => Tabs,
-  Text: () => import_widgets12.Text,
-  TextInput: () => import_widgets12.TextInput,
+  Text: () => import_widgets17.Text,
+  TextInput: () => import_widgets17.TextInput,
   Toast: () => Toast,
   Tree: () => Tree,
-  Widget: () => import_widgets12.Widget
+  Widget: () => import_widgets17.Widget,
+  notifications: () => notifications,
+  prompt: () => prompt,
+  useNotifications: () => useNotifications
 });
 module.exports = __toCommonJS(index_exports);
-var import_widgets12 = require("@termuijs/widgets");
+var import_widgets17 = require("@termuijs/widgets");
 
 // src/Divider.ts
 var import_widgets = require("@termuijs/widgets");
@@ -132,7 +152,7 @@ var Tabs = class extends import_widgets3.Widget {
     for (let i = 0; i < this._tabs.length; i++) {
       const tab = this._tabs[i];
       const isActive = i === this._activeIndex;
-      const label = isActive ? ` \u25CF ${tab.label} ` : `   ${tab.label} `;
+      const label = isActive ? ` ${import_core3.caps.unicode ? "\u25CF" : "*"} ${tab.label} ` : `   ${tab.label} `;
       screen.writeString(col, y, label, {
         ...attrs,
         fg: isActive ? this._activeColor : this._inactiveColor,
@@ -141,7 +161,7 @@ var Tabs = class extends import_widgets3.Widget {
       });
       col += label.length;
       if (i < this._tabs.length - 1) {
-        screen.writeString(col, y, "\u2502", { ...attrs, dim: true });
+        screen.writeString(col, y, import_core3.caps.unicode ? "\u2502" : "|", { ...attrs, dim: true });
         col++;
       }
     }
@@ -166,7 +186,7 @@ var Modal = class extends import_widgets4.Widget {
     this._modalWidth = options.width ?? 50;
     this._modalHeight = options.height ?? 15;
     this._borderColor = options.borderColor ?? { type: "named", name: "cyan" };
-    this._backdropChar = options.backdropChar ?? "\u2591";
+    this._backdropChar = options.backdropChar ?? (import_core4.caps.unicode ? "\u2591" : " ");
   }
   get visible() {
     return this._visible;
@@ -290,13 +310,13 @@ var Select = class extends import_widgets5.Widget {
     const attrs = (0, import_core5.styleToCellAttrs)(this.style);
     const sel = this._options[this._selectedIndex];
     const label = sel ? sel.label : this._placeholder;
-    const prefix = this._isOpen ? "\u25BC " : "\u25B6 ";
+    const prefix = this._isOpen ? import_core5.caps.unicode ? "\u25BC " : "v " : import_core5.caps.unicode ? "\u25B6 " : "> ";
     screen.writeString(x, y, prefix + label.slice(0, width - 2), { ...attrs, fg: this._activeColor });
     if (this._isOpen) {
       for (let i = 0; i < this._options.length; i++) {
         const o = this._options[i];
         const isSel = i === this._selectedIndex;
-        const m = isSel ? "\u25CF " : "  ";
+        const m = isSel ? import_core5.caps.unicode ? "\u25CF " : "* " : "  ";
         screen.writeString(x, y + 1 + i, m + o.label.slice(0, width - 2), {
           ...attrs,
           fg: o.disabled ? { type: "named", name: "brightBlack" } : isSel ? this._activeColor : attrs.fg,
@@ -324,8 +344,8 @@ var MultiSelect = class extends import_widgets6.Widget {
     super((0, import_core6.mergeStyles)((0, import_core6.defaultStyle)(), { height: Math.max(options.length, 1) }));
     this._options = options;
     this._activeColor = config.activeColor ?? { type: "named", name: "cyan" };
-    this._checkChar = config.checkChar ?? "\u25FC";
-    this._uncheckChar = config.uncheckChar ?? "\u25FB";
+    this._checkChar = config.checkChar ?? (import_core6.caps.unicode ? "\u25FC" : "[x]");
+    this._uncheckChar = config.uncheckChar ?? (import_core6.caps.unicode ? "\u25FB" : "[ ]");
     this._onSubmit = config.onSubmit;
   }
   get selectedOptions() {
@@ -365,7 +385,7 @@ var MultiSelect = class extends import_widgets6.Widget {
       const o = this._options[i];
       const active = i === this._cursorIndex;
       const checked = this._checked.has(i);
-      const label = `${active ? "\u276F " : "  "}${checked ? this._checkChar : this._uncheckChar} ${o.label}`;
+      const label = `${active ? import_core6.caps.unicode ? "\u276F " : "> " : "  "}${checked ? this._checkChar : this._uncheckChar} ${o.label}`;
       screen.writeString(x, y + i, label.slice(0, width), {
         ...attrs,
         fg: o.disabled ? { type: "named", name: "brightBlack" } : active ? this._activeColor : attrs.fg,
@@ -393,12 +413,12 @@ var Tree = class extends import_widgets7.Widget {
   }
   _flatten() {
     const result = [];
-    const walk = (nodes, depth, path) => {
+    const walk = (nodes, depth, path2) => {
       for (let i = 0; i < nodes.length; i++) {
         const node = nodes[i];
         const hasChildren = (node.children?.length ?? 0) > 0;
-        result.push({ node, depth, path: [...path, i], hasChildren });
-        if (hasChildren && node.expanded) walk(node.children, depth + 1, [...path, i]);
+        result.push({ node, depth, path: [...path2, i], hasChildren });
+        if (hasChildren && node.expanded) walk(node.children, depth + 1, [...path2, i]);
       }
     };
     walk(this._roots, 0, []);
@@ -441,7 +461,7 @@ var Tree = class extends import_widgets7.Widget {
       const it = flat[i];
       const active = i === this._cursorIndex;
       const indent = "  ".repeat(it.depth);
-      const icon = it.hasChildren ? it.node.expanded ? "\u25BC " : "\u25B6 " : "  ";
+      const icon = it.hasChildren ? it.node.expanded ? import_core7.caps.unicode ? "\u25BC " : "v " : import_core7.caps.unicode ? "\u25B6 " : "> " : "  ";
       const nodeIcon = it.node.icon ? `${it.node.icon} ` : "";
       const line = `${indent}${icon}${nodeIcon}${it.node.label}`;
       screen.writeString(x, y + i, line.slice(0, width), { ...attrs, fg: active ? this._activeColor : attrs.fg, bold: active });
@@ -452,7 +472,8 @@ var Tree = class extends import_widgets7.Widget {
 // src/Toast.ts
 var import_widgets8 = require("@termuijs/widgets");
 var import_core8 = require("@termuijs/core");
-var ICONS = { info: "\u2139", success: "\u2713", warning: "\u26A0", error: "\u2717" };
+var ICONS_UNICODE = { info: "\u2139", success: "\u2713", warning: "\u26A0", error: "\u2717" };
+var ICONS_ASCII = { info: "i", success: "+", warning: "!", error: "x" };
 var COLORS = { info: "cyan", success: "green", warning: "yellow", error: "red" };
 var Toast = class extends import_widgets8.Widget {
   _messages = [];
@@ -492,10 +513,11 @@ var Toast = class extends import_widgets8.Widget {
     const isBottom = this._position.includes("bottom");
     const sx = isRight ? x + width - tw - 1 : x + 1;
     const sy = isBottom ? y + height - visible.length - 1 : y + 1;
+    const icons = import_core8.caps.unicode ? ICONS_UNICODE : ICONS_ASCII;
     const attrs = (0, import_core8.styleToCellAttrs)(this.style);
     for (let i = 0; i < visible.length; i++) {
       const m = visible[i];
-      const label = ` ${ICONS[m.type]} ${m.text} `.slice(0, tw).padEnd(tw);
+      const label = ` ${icons[m.type]} ${m.text} `.slice(0, tw).padEnd(tw);
       screen.writeString(sx, sy + i, label, { ...attrs, fg: { type: "named", name: COLORS[m.type] }, bold: true });
     }
   }
@@ -779,7 +801,8 @@ var CommandPalette = class extends import_widgets11.Widget {
     if (!this._visible) return;
     const { x, y, width, height } = this._rect;
     const attrs = (0, import_core11.styleToCellAttrs)(this.style);
-    for (let r = 0; r < height; r++) screen.writeString(x, y + r, "\u2591".repeat(width), { ...attrs, dim: true });
+    const backdropCh = import_core11.caps.unicode ? "\u2591" : " ";
+    for (let r = 0; r < height; r++) screen.writeString(x, y + r, backdropCh.repeat(width), { ...attrs, dim: true });
     const vis = this._filtered.slice(0, this._maxVisible);
     const bw = Math.min(60, width - 4);
     const bh = Math.min(vis.length + 3, height - 2);
@@ -791,13 +814,13 @@ var CommandPalette = class extends import_widgets11.Widget {
     screen.writeString(bx, by, border.topLeft + border.top.repeat(bw - 2) + border.topRight, ba);
     screen.writeString(bx, by + 1, border.left, ba);
     const input = this._query || this._placeholder;
-    screen.writeString(bx + 1, by + 1, (" \u{1F50D} " + input).slice(0, bw - 2).padEnd(bw - 2), { ...attrs, dim: !this._query });
+    screen.writeString(bx + 1, by + 1, (` ${import_core11.caps.unicode ? "\u{1F50D}" : "[?]"} ` + input).slice(0, bw - 2).padEnd(bw - 2), { ...attrs, dim: !this._query });
     screen.writeString(bx + bw - 1, by + 1, border.right, ba);
     screen.writeString(bx, by + 2, border.left + "\u2500".repeat(bw - 2) + border.right, ba);
     for (let i = 0; i < vis.length && i + 3 < bh - 1; i++) {
       const c = vis[i];
       const active = i === this._selectedIndex;
-      const label = (active ? "\u276F " : "  ") + c.label;
+      const label = (active ? import_core11.caps.unicode ? "\u276F " : "> " : "  ") + c.label;
       const sc = c.shortcut ?? "";
       screen.writeString(bx, by + 3 + i, border.left, ba);
       screen.writeString(bx + 1, by + 3 + i, (" " + label).slice(0, bw - sc.length - 3).padEnd(bw - sc.length - 3), { ...attrs, fg: active ? this._activeColor : attrs.fg, bold: active });
@@ -808,6 +831,919 @@ var CommandPalette = class extends import_widgets11.Widget {
     screen.writeString(bx, last, border.bottomLeft + border.bottom.repeat(bw - 2) + border.bottomRight, ba);
   }
 };
+
+// src/prompts.ts
+var readline = __toESM(require("readline"), 1);
+var NonInteractiveError = class extends Error {
+  constructor() {
+    super("Prompts require an interactive TTY. stdin is not a TTY.");
+    this.name = "NonInteractiveError";
+  }
+};
+async function promptText(options) {
+  if (!process.stdin.isTTY) throw new NonInteractiveError();
+  const defaultHint = options.default ? ` (${options.default})` : "";
+  const placeholder = options.placeholder ? ` [${options.placeholder}]` : "";
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const ask = () => {
+      rl.question(`${options.message}${defaultHint}${placeholder}: `, (answer) => {
+        const value = answer.trim() || options.default || "";
+        if (options.validate) {
+          const error = options.validate(value);
+          if (error) {
+            process.stdout.write(`  ${error}
+`);
+            ask();
+            return;
+          }
+        }
+        rl.close();
+        resolve(value);
+      });
+    };
+    ask();
+  });
+}
+async function promptConfirm(options) {
+  if (!process.stdin.isTTY) throw new NonInteractiveError();
+  const hint = options.default === true ? "Y/n" : options.default === false ? "y/N" : "y/n";
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(`${options.message} [${hint}]: `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (a === "y" || a === "yes") {
+        resolve(true);
+        return;
+      }
+      if (a === "n" || a === "no") {
+        resolve(false);
+        return;
+      }
+      if (a === "" && options.default !== void 0) {
+        resolve(options.default);
+        return;
+      }
+      resolve(false);
+    });
+  });
+}
+async function promptSelect(options) {
+  if (!process.stdin.isTTY) throw new NonInteractiveError();
+  const { options: choices, default: defaultValue } = options;
+  process.stdout.write(`${options.message}
+`);
+  choices.forEach((opt, i) => {
+    const isDefault = opt.value === defaultValue;
+    process.stdout.write(`  ${i + 1}. ${opt.label}${isDefault ? " (default)" : ""}
+`);
+  });
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const ask = () => {
+      rl.question(`Enter number (1-${choices.length}): `, (answer) => {
+        const trimmed = answer.trim();
+        if (trimmed === "" && defaultValue !== void 0) {
+          rl.close();
+          resolve(defaultValue);
+          return;
+        }
+        const n = parseInt(trimmed, 10);
+        if (!isNaN(n) && n >= 1 && n <= choices.length) {
+          rl.close();
+          resolve(choices[n - 1].value);
+          return;
+        }
+        process.stdout.write(`  Invalid choice. Enter a number 1-${choices.length}.
+`);
+        ask();
+      });
+    };
+    ask();
+  });
+}
+var prompt = {
+  text: promptText,
+  confirm: promptConfirm,
+  select: promptSelect
+};
+
+// src/NotificationCenter.ts
+var import_widgets12 = require("@termuijs/widgets");
+var import_jsx = require("@termuijs/jsx");
+var import_core12 = require("@termuijs/core");
+var NotificationStore = class _NotificationStore {
+  static _instance;
+  _notifications = [];
+  _subs = /* @__PURE__ */ new Set();
+  static getInstance() {
+    if (!_NotificationStore._instance) {
+      _NotificationStore._instance = new _NotificationStore();
+    }
+    return _NotificationStore._instance;
+  }
+  push(message, type = "info", durationMs) {
+    const id = Date.now().toString(36) + Math.random().toString(36).slice(2);
+    const notification = { id, message, type, durationMs, createdAt: Date.now() };
+    this._notifications = [...this._notifications, notification];
+    this._emit();
+    if (durationMs && durationMs > 0) {
+      setTimeout(() => this.dismiss(id), durationMs);
+    }
+    return id;
+  }
+  dismiss(id) {
+    const prev = this._notifications;
+    this._notifications = this._notifications.filter((n) => n.id !== id);
+    if (this._notifications.length !== prev.length) {
+      this._emit();
+    }
+  }
+  dismissAll() {
+    if (this._notifications.length > 0) {
+      this._notifications = [];
+      this._emit();
+    }
+  }
+  subscribe(fn) {
+    this._subs.add(fn);
+    return () => this._subs.delete(fn);
+  }
+  get notifications() {
+    return this._notifications;
+  }
+  _emit() {
+    for (const fn of this._subs) fn(this._notifications);
+  }
+};
+var notifications = NotificationStore.getInstance();
+function useNotifications() {
+  const store = NotificationStore.getInstance();
+  const [current, setCurrent] = (0, import_jsx.useState)(store.notifications);
+  (0, import_jsx.useEffect)(() => {
+    const unsub = store.subscribe((ns) => setCurrent([...ns]));
+    return unsub;
+  }, []);
+  return {
+    notifications: current,
+    push: (msg, type, dur) => store.push(msg, type, dur),
+    dismiss: (id) => store.dismiss(id),
+    dismissAll: () => store.dismissAll()
+  };
+}
+var TYPE_ICONS = {
+  info: { unicode: "\u2139", ascii: "i" },
+  success: { unicode: "\u2713", ascii: "+" },
+  warning: { unicode: "\u26A0", ascii: "!" },
+  error: { unicode: "\u2717", ascii: "x" }
+};
+var TYPE_COLORS = {
+  info: { type: "named", name: "cyan" },
+  success: { type: "named", name: "green" },
+  warning: { type: "named", name: "yellow" },
+  error: { type: "named", name: "red" }
+};
+var NotificationCenter = class extends import_widgets12.Widget {
+  _position;
+  _maxVisible;
+  _notifWidth;
+  _unsub;
+  _current = [];
+  constructor(options = {}) {
+    super();
+    this._position = options.position ?? "top-right";
+    this._maxVisible = options.maxVisible ?? 5;
+    this._notifWidth = options.width ?? 40;
+    const store = NotificationStore.getInstance();
+    this._current = store.notifications;
+    this._unsub = store.subscribe((ns) => {
+      this._current = ns;
+      this.markDirty();
+    });
+  }
+  unmount() {
+    this._unsub?.();
+    this._unsub = void 0;
+    super.unmount();
+  }
+  _renderSelf(screen) {
+    const visible = this._current.slice(-this._maxVisible);
+    if (visible.length === 0) return;
+    const { x, y, width, height } = this._rect;
+    const tw = Math.min(this._notifWidth, width - 2);
+    if (tw <= 0) return;
+    const isRight = this._position.includes("right");
+    const isBottom = this._position.includes("bottom");
+    const sx = isRight ? x + width - tw - 1 : x + 1;
+    const sy = isBottom ? y + height - visible.length - 1 : y + 1;
+    for (let i = 0; i < visible.length; i++) {
+      const notif = visible[i];
+      const icon = import_core12.caps.unicode ? TYPE_ICONS[notif.type].unicode : TYPE_ICONS[notif.type].ascii;
+      const raw = `${icon} ${notif.message}`;
+      const label = ` ${raw} `.slice(0, tw).padEnd(tw);
+      screen.writeString(sx, sy + i, label, {
+        fg: TYPE_COLORS[notif.type],
+        bold: true
+      });
+    }
+  }
+};
+
+// src/PasswordInput.ts
+var import_widgets13 = require("@termuijs/widgets");
+var import_core13 = require("@termuijs/core");
+var PasswordInput = class extends import_widgets13.Widget {
+  _value = "";
+  _cursorPos = 0;
+  _placeholder;
+  _maxLength;
+  _showText = false;
+  _onChange;
+  _onSubmit;
+  focusable = true;
+  // '●' in unicode terminals, '*' in ASCII fallback
+  get _maskChar() {
+    return import_core13.caps.unicode ? "\u25CF" : "*";
+  }
+  constructor(style = {}, options = {}) {
+    super({ border: "single", height: 3, ...style });
+    this._placeholder = options.placeholder ?? "";
+    this._maxLength = options.maxLength ?? Infinity;
+    this._onChange = options.onChange;
+    this._onSubmit = options.onSubmit;
+  }
+  /** The actual (unmasked) value. */
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    this._value = v.slice(0, this._maxLength);
+    this._cursorPos = Math.min(this._cursorPos, this._value.length);
+  }
+  /** Whether the text is currently visible (unmaksed). */
+  get showText() {
+    return this._showText;
+  }
+  /** Toggle visibility of the actual text (Alt+V). */
+  toggleVisibility() {
+    this._showText = !this._showText;
+    this.markDirty();
+  }
+  insertChar(char) {
+    if (this._value.length >= this._maxLength) return;
+    this._value = this._value.slice(0, this._cursorPos) + char + this._value.slice(this._cursorPos);
+    this._cursorPos++;
+    this._onChange?.(this._value);
+    this.markDirty();
+  }
+  deleteBack() {
+    if (this._cursorPos > 0) {
+      this._value = this._value.slice(0, this._cursorPos - 1) + this._value.slice(this._cursorPos);
+      this._cursorPos--;
+      this._onChange?.(this._value);
+      this.markDirty();
+    }
+  }
+  deleteForward() {
+    if (this._cursorPos < this._value.length) {
+      this._value = this._value.slice(0, this._cursorPos) + this._value.slice(this._cursorPos + 1);
+      this._onChange?.(this._value);
+      this.markDirty();
+    }
+  }
+  moveCursorLeft() {
+    this._cursorPos = Math.max(0, this._cursorPos - 1);
+    this.markDirty();
+  }
+  moveCursorRight() {
+    this._cursorPos = Math.min(this._value.length, this._cursorPos + 1);
+    this.markDirty();
+  }
+  moveCursorHome() {
+    this._cursorPos = 0;
+    this.markDirty();
+  }
+  moveCursorEnd() {
+    this._cursorPos = this._value.length;
+    this.markDirty();
+  }
+  submit() {
+    this._onSubmit?.(this._value);
+  }
+  clear() {
+    this._value = "";
+    this._cursorPos = 0;
+    this._onChange?.("");
+    this.markDirty();
+  }
+  /**
+   * Handle key events. Call this from your input loop.
+   *  Alt+V  — toggle visibility
+   *  Other  — standard text editing
+   */
+  handleKey(event) {
+    if (event.alt && event.key === "v") {
+      this.toggleVisibility();
+      return;
+    }
+    switch (event.key) {
+      case "backspace":
+        this.deleteBack();
+        break;
+      case "delete":
+        this.deleteForward();
+        break;
+      case "left":
+        this.moveCursorLeft();
+        break;
+      case "right":
+        this.moveCursorRight();
+        break;
+      case "home":
+        this.moveCursorHome();
+        break;
+      case "end":
+        this.moveCursorEnd();
+        break;
+      case "return":
+      case "enter":
+        this.submit();
+        break;
+      default:
+        if (event.key && event.key.length === 1 && !event.ctrl && !event.alt) {
+          this.insertChar(event.key);
+        }
+    }
+  }
+  _renderSelf(screen) {
+    const rect = this._getContentRect();
+    const { x, y, width, height } = rect;
+    if (width <= 0 || height <= 0) return;
+    const attrs = (0, import_core13.styleToCellAttrs)(this._style);
+    if (this._value.length === 0 && !this.isFocused) {
+      screen.writeString(x, y, (0, import_core13.truncate)(this._placeholder, width), { ...attrs, dim: true });
+      return;
+    }
+    const displayValue = this._showText ? this._value : this._maskChar.repeat(this._value.length);
+    const visibleWidth = width - 1;
+    let scrollX = 0;
+    if (this._cursorPos > visibleWidth) {
+      scrollX = this._cursorPos - visibleWidth;
+    }
+    const visibleText = displayValue.slice(scrollX, scrollX + visibleWidth);
+    screen.writeString(x, y, visibleText, attrs);
+    if (this.isFocused) {
+      const cursorScreenPos = x + this._cursorPos - scrollX;
+      if (cursorScreenPos >= x && cursorScreenPos < x + width) {
+        const cursorChar = this._cursorPos < displayValue.length ? displayValue[this._cursorPos] : " ";
+        screen.setCell(cursorScreenPos, y, {
+          char: cursorChar,
+          ...attrs,
+          inverse: true
+        });
+      }
+    }
+    if (this._showText && width > 4) {
+      const indicator = import_core13.caps.unicode ? " \u{1F441}" : "[v]";
+      screen.writeString(x + width - indicator.length, y, indicator, { ...attrs, dim: true });
+    }
+  }
+};
+
+// src/NumberInput.ts
+var import_widgets14 = require("@termuijs/widgets");
+var import_core14 = require("@termuijs/core");
+var NumberInput = class extends import_widgets14.Widget {
+  _raw = "";
+  // raw string the user typed
+  _cursorPos = 0;
+  _placeholder;
+  _step;
+  _min;
+  _max;
+  _allowDecimal;
+  _onChange;
+  _onSubmit;
+  focusable = true;
+  constructor(style = {}, options = {}) {
+    super({ border: "single", height: 3, ...style });
+    this._placeholder = options.placeholder ?? "";
+    this._step = options.step ?? 1;
+    this._min = options.min ?? -Infinity;
+    this._max = options.max ?? Infinity;
+    this._allowDecimal = options.allowDecimal ?? true;
+    this._onChange = options.onChange;
+    this._onSubmit = options.onSubmit;
+  }
+  /** The numeric value, or null if the field is empty / invalid. */
+  get numericValue() {
+    if (this._raw === "" || this._raw === "-") return null;
+    const n = parseFloat(this._raw);
+    return isNaN(n) ? null : n;
+  }
+  /** Raw text string (what the user typed). */
+  get rawValue() {
+    return this._raw;
+  }
+  set rawValue(v) {
+    this._raw = v;
+    this._cursorPos = Math.min(this._cursorPos, this._raw.length);
+  }
+  _clamp(n) {
+    return Math.min(this._max, Math.max(this._min, n));
+  }
+  _notify() {
+    this._onChange?.(this.numericValue);
+    this.markDirty();
+  }
+  /** Accept only digits, '-' at position 0 (if min < 0), and (optionally) one '.'. */
+  _isAllowed(char) {
+    if (char === "-" && this._cursorPos === 0 && !this._raw.includes("-")) {
+      return this._min < 0;
+    }
+    if (char === "." && this._allowDecimal && !this._raw.includes(".")) return true;
+    return /^\d$/.test(char);
+  }
+  insertChar(char) {
+    if (!this._isAllowed(char)) return;
+    this._raw = this._raw.slice(0, this._cursorPos) + char + this._raw.slice(this._cursorPos);
+    this._cursorPos++;
+    this._notify();
+  }
+  deleteBack() {
+    if (this._cursorPos > 0) {
+      this._raw = this._raw.slice(0, this._cursorPos - 1) + this._raw.slice(this._cursorPos);
+      this._cursorPos--;
+      this._notify();
+    }
+  }
+  deleteForward() {
+    if (this._cursorPos < this._raw.length) {
+      this._raw = this._raw.slice(0, this._cursorPos) + this._raw.slice(this._cursorPos + 1);
+      this._notify();
+    }
+  }
+  moveCursorLeft() {
+    this._cursorPos = Math.max(0, this._cursorPos - 1);
+    this.markDirty();
+  }
+  moveCursorRight() {
+    this._cursorPos = Math.min(this._raw.length, this._cursorPos + 1);
+    this.markDirty();
+  }
+  moveCursorHome() {
+    this._cursorPos = 0;
+    this.markDirty();
+  }
+  moveCursorEnd() {
+    this._cursorPos = this._raw.length;
+    this.markDirty();
+  }
+  /** Increment value by step (↑ arrow). */
+  increment() {
+    const current = this.numericValue ?? 0;
+    const next = this._clamp(current + this._step);
+    this._raw = String(next);
+    this._cursorPos = this._raw.length;
+    this._notify();
+  }
+  /** Decrement value by step (↓ arrow). */
+  decrement() {
+    const current = this.numericValue ?? 0;
+    const next = this._clamp(current - this._step);
+    this._raw = String(next);
+    this._cursorPos = this._raw.length;
+    this._notify();
+  }
+  submit() {
+    this._onSubmit?.(this.numericValue);
+  }
+  clear() {
+    this._raw = "";
+    this._cursorPos = 0;
+    this._notify();
+  }
+  /**
+   * Handle key events. Call this from your input loop.
+   */
+  handleKey(event) {
+    switch (event.key) {
+      case "up":
+        this.increment();
+        break;
+      case "down":
+        this.decrement();
+        break;
+      case "backspace":
+        this.deleteBack();
+        break;
+      case "delete":
+        this.deleteForward();
+        break;
+      case "left":
+        this.moveCursorLeft();
+        break;
+      case "right":
+        this.moveCursorRight();
+        break;
+      case "home":
+        this.moveCursorHome();
+        break;
+      case "end":
+        this.moveCursorEnd();
+        break;
+      case "return":
+      case "enter":
+        this.submit();
+        break;
+      default:
+        if (event.key && event.key.length === 1 && !event.ctrl && !event.alt) {
+          this.insertChar(event.key);
+        }
+    }
+  }
+  _renderSelf(screen) {
+    const rect = this._getContentRect();
+    const { x, y, width, height } = rect;
+    if (width <= 0 || height <= 0) return;
+    const attrs = (0, import_core14.styleToCellAttrs)(this._style);
+    if (this._raw.length === 0 && !this.isFocused) {
+      screen.writeString(x, y, (0, import_core14.truncate)(this._placeholder, width), { ...attrs, dim: true });
+      return;
+    }
+    const display = this._raw;
+    const visibleWidth = width - 1;
+    let scrollX = 0;
+    if (this._cursorPos > visibleWidth) {
+      scrollX = this._cursorPos - visibleWidth;
+    }
+    const visibleText = display.slice(scrollX, scrollX + visibleWidth);
+    screen.writeString(x, y, visibleText, attrs);
+    if (this.isFocused) {
+      const cursorScreenPos = x + this._cursorPos - scrollX;
+      if (cursorScreenPos >= x && cursorScreenPos < x + width) {
+        const cursorChar = this._cursorPos < display.length ? display[this._cursorPos] : " ";
+        screen.setCell(cursorScreenPos, y, {
+          char: cursorChar,
+          ...attrs,
+          inverse: true
+        });
+      }
+    }
+    if (this.isFocused && width > 8) {
+      const hint = `\xB1${this._step}`;
+      screen.writeString(x + width - hint.length, y, hint, { ...attrs, dim: true });
+    }
+  }
+};
+
+// src/PathInput.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_widgets15 = require("@termuijs/widgets");
+var import_core15 = require("@termuijs/core");
+var PathInput = class extends import_widgets15.Widget {
+  _value = "";
+  _cursorPos = 0;
+  _placeholder;
+  _maxLength;
+  _cwd;
+  _maxCompletions;
+  _completions = [];
+  _completionIndex = -1;
+  // -1 = original value, 0..n = cycling
+  _preCompletionValue = "";
+  // value before Tab was pressed
+  _showCompletions = false;
+  _onChange;
+  _onSubmit;
+  focusable = true;
+  constructor(style = {}, options = {}) {
+    super({ border: "single", height: 3, ...style });
+    this._placeholder = options.placeholder ?? "";
+    this._maxLength = options.maxLength ?? 4096;
+    this._cwd = options.cwd ?? process.cwd();
+    this._maxCompletions = options.maxCompletions ?? 5;
+    this._onChange = options.onChange;
+    this._onSubmit = options.onSubmit;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    this._value = v.slice(0, this._maxLength);
+    this._cursorPos = Math.min(this._cursorPos, this._value.length);
+    this._dismissCompletions();
+  }
+  get completions() {
+    return this._completions;
+  }
+  get isShowingCompletions() {
+    return this._showCompletions && this._completions.length > 0;
+  }
+  _dismissCompletions() {
+    this._completions = [];
+    this._completionIndex = -1;
+    this._showCompletions = false;
+  }
+  /** Compute completions for the current value. Does NOT throw. */
+  _computeCompletions() {
+    try {
+      const raw = this._value;
+      const isAbs = path.isAbsolute(raw);
+      const base = isAbs ? raw : path.join(this._cwd, raw);
+      let dir;
+      let prefix;
+      if (raw === "" || raw.endsWith("/") || raw.endsWith(path.sep)) {
+        dir = isAbs ? raw || "/" : path.join(this._cwd, raw || ".");
+        prefix = "";
+      } else {
+        dir = path.dirname(base);
+        prefix = path.basename(base).toLowerCase();
+      }
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      const matches = entries.filter((e) => e.name.toLowerCase().startsWith(prefix)).slice(0, this._maxCompletions).map((e) => {
+        const full = path.join(dir, e.name);
+        const candidate = isAbs ? full + (e.isDirectory() ? path.sep : "") : path.relative(this._cwd, full) + (e.isDirectory() ? path.sep : "");
+        return candidate;
+      });
+      return matches;
+    } catch {
+      return [];
+    }
+  }
+  /** Trigger tab-completion. */
+  triggerCompletion() {
+    if (!this._showCompletions || this._completions.length === 0) {
+      this._preCompletionValue = this._value;
+      this._completions = this._computeCompletions();
+      if (this._completions.length === 0) {
+        this._showCompletions = false;
+        return;
+      }
+      this._showCompletions = true;
+      this._completionIndex = 0;
+    } else {
+      this._completionIndex = (this._completionIndex + 1) % this._completions.length;
+    }
+    this._value = this._completions[this._completionIndex];
+    this._cursorPos = this._value.length;
+    this._onChange?.(this._value);
+    this.markDirty();
+  }
+  insertChar(char) {
+    if (this._value.length >= this._maxLength) return;
+    this._value = this._value.slice(0, this._cursorPos) + char + this._value.slice(this._cursorPos);
+    this._cursorPos++;
+    this._dismissCompletions();
+    this._onChange?.(this._value);
+    this.markDirty();
+  }
+  deleteBack() {
+    if (this._cursorPos > 0) {
+      this._value = this._value.slice(0, this._cursorPos - 1) + this._value.slice(this._cursorPos);
+      this._cursorPos--;
+      this._dismissCompletions();
+      this._onChange?.(this._value);
+      this.markDirty();
+    }
+  }
+  deleteForward() {
+    if (this._cursorPos < this._value.length) {
+      this._value = this._value.slice(0, this._cursorPos) + this._value.slice(this._cursorPos + 1);
+      this._dismissCompletions();
+      this._onChange?.(this._value);
+      this.markDirty();
+    }
+  }
+  moveCursorLeft() {
+    this._cursorPos = Math.max(0, this._cursorPos - 1);
+    this.markDirty();
+  }
+  moveCursorRight() {
+    this._cursorPos = Math.min(this._value.length, this._cursorPos + 1);
+    this.markDirty();
+  }
+  moveCursorHome() {
+    this._cursorPos = 0;
+    this.markDirty();
+  }
+  moveCursorEnd() {
+    this._cursorPos = this._value.length;
+    this.markDirty();
+  }
+  submit() {
+    this._dismissCompletions();
+    this._onSubmit?.(this._value);
+  }
+  clear() {
+    this._value = "";
+    this._cursorPos = 0;
+    this._dismissCompletions();
+    this._onChange?.("");
+    this.markDirty();
+  }
+  /**
+   * Handle key events. Call this from your input loop.
+   *  Tab   — trigger/cycle completions
+   *  Esc   — dismiss completions
+   *  Enter — submit current value
+   */
+  handleKey(event) {
+    switch (event.key) {
+      case "tab":
+        this.triggerCompletion();
+        break;
+      case "escape":
+        this._dismissCompletions();
+        this.markDirty();
+        break;
+      case "backspace":
+        this.deleteBack();
+        break;
+      case "delete":
+        this.deleteForward();
+        break;
+      case "left":
+        this.moveCursorLeft();
+        break;
+      case "right":
+        this.moveCursorRight();
+        break;
+      case "home":
+        this.moveCursorHome();
+        break;
+      case "end":
+        this.moveCursorEnd();
+        break;
+      case "return":
+      case "enter":
+        this.submit();
+        break;
+      default:
+        if (event.key && event.key.length === 1 && !event.ctrl && !event.alt) {
+          this.insertChar(event.key);
+        }
+    }
+  }
+  _renderSelf(screen) {
+    const rect = this._getContentRect();
+    const { x, y, width, height } = rect;
+    if (width <= 0 || height <= 0) return;
+    const attrs = (0, import_core15.styleToCellAttrs)(this._style);
+    if (height <= 1 && this._showCompletions) {
+      this._showCompletions = false;
+    }
+    if (this._value.length === 0 && !this.isFocused) {
+      screen.writeString(x, y, (0, import_core15.truncate)(this._placeholder, width), { ...attrs, dim: true });
+    } else {
+      const visibleWidth = width - 1;
+      let scrollX = 0;
+      if (this._cursorPos > visibleWidth) {
+        scrollX = this._cursorPos - visibleWidth;
+      }
+      const visibleText = this._value.slice(scrollX, scrollX + visibleWidth);
+      screen.writeString(x, y, visibleText, attrs);
+      if (this.isFocused) {
+        const cursorScreenPos = x + this._cursorPos - scrollX;
+        if (cursorScreenPos >= x && cursorScreenPos < x + width) {
+          const cursorChar = this._cursorPos < this._value.length ? this._value[this._cursorPos] : " ";
+          screen.setCell(cursorScreenPos, y, {
+            char: cursorChar,
+            ...attrs,
+            inverse: true
+          });
+        }
+      }
+    }
+    if (this._showCompletions && this._completions.length > 0 && height > 1) {
+      const maxRows = Math.min(this._completions.length, height - 1);
+      for (let i = 0; i < maxRows; i++) {
+        const row = y + 1 + i;
+        const isSelected = i === this._completionIndex;
+        const prefix = isSelected ? import_core15.caps.unicode ? "\u25B6 " : "> " : "  ";
+        const entry = this._completions[i];
+        screen.writeString(x, row, (0, import_core15.truncate)(prefix + entry, width), {
+          ...attrs,
+          bold: isSelected,
+          inverse: isSelected
+        });
+      }
+    }
+  }
+};
+
+// src/KeyboardShortcuts.ts
+var import_widgets16 = require("@termuijs/widgets");
+var import_core16 = require("@termuijs/core");
+var KeyboardShortcuts = class extends import_widgets16.Widget {
+  _bindings;
+  _keyColor;
+  _categoryColor;
+  _columns;
+  _showCategories;
+  constructor(bindings, options = {}) {
+    super({});
+    this._bindings = bindings;
+    this._keyColor = options.keyColor ?? { type: "named", name: "cyan" };
+    this._categoryColor = options.categoryColor ?? { type: "named", name: "yellow" };
+    this._columns = Math.max(1, options.columns ?? 2);
+    this._showCategories = options.showCategories ?? true;
+  }
+  /** Replace all bindings and trigger a re-render. */
+  setBindings(bindings) {
+    this._bindings = bindings;
+    this.markDirty();
+  }
+  /** Group bindings by category, preserving insertion order. */
+  _groupBindings() {
+    const groups = [];
+    const indexMap = /* @__PURE__ */ new Map();
+    for (const b of this._bindings) {
+      const cat = b.category ?? "";
+      const key = cat;
+      if (!indexMap.has(key)) {
+        indexMap.set(key, groups.length);
+        groups.push({ category: b.category, bindings: [] });
+      }
+      groups[indexMap.get(key)].bindings.push(b);
+    }
+    return groups;
+  }
+  /**
+   * Render a key label in a bordered box style:
+   *   ┌─────┐
+   *   │ key │
+   *   └─────┘
+   *
+   * We fit it on one line: [ key ] — box drawing characters or ASCII fallback.
+   */
+  _renderKeyLabel(screen, kx, ky, key, attrs) {
+    if (import_core16.caps.unicode) {
+      const label = `[${key}]`;
+      screen.writeString(kx, ky, label, { ...attrs, fg: this._keyColor, bold: true });
+      return label.length;
+    } else {
+      const label = `[${key}]`;
+      screen.writeString(kx, ky, label, { ...attrs, fg: this._keyColor, bold: true });
+      return label.length;
+    }
+  }
+  _renderSelf(screen) {
+    const { x, y, width, height } = this._rect;
+    if (width <= 0 || height <= 0) return;
+    const attrs = (0, import_core16.styleToCellAttrs)(this._style);
+    const groups = this._groupBindings();
+    let row = y;
+    const colWidth = Math.floor(width / this._columns);
+    for (const group of groups) {
+      if (row >= y + height) break;
+      if (this._showCategories && group.category) {
+        const heading = group.category.toUpperCase();
+        const divider = import_core16.caps.unicode ? "\u2500" : "-";
+        const line = heading + " " + divider.repeat(Math.max(0, width - heading.length - 1));
+        screen.writeString(x, row, line.slice(0, width), {
+          ...attrs,
+          fg: this._categoryColor,
+          bold: true
+        });
+        row++;
+        if (row >= y + height) break;
+      }
+      for (let i = 0; i < group.bindings.length; i += this._columns) {
+        if (row >= y + height) break;
+        for (let col = 0; col < this._columns; col++) {
+          const binding = group.bindings[i + col];
+          if (!binding) continue;
+          const cx = x + col * colWidth;
+          const availWidth = colWidth - 1;
+          if (availWidth <= 0) continue;
+          const labelLen = this._renderKeyLabel(screen, cx, row, binding.key, attrs);
+          const descX = cx + labelLen + 1;
+          const descWidth = availWidth - labelLen - 1;
+          if (descWidth > 0) {
+            const desc = binding.description.slice(0, descWidth);
+            screen.writeString(descX, row, desc, attrs);
+          }
+        }
+        row++;
+      }
+      if (this._showCategories && group.category) {
+        row++;
+      }
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Box,
@@ -816,10 +1752,17 @@ var CommandPalette = class extends import_widgets11.Widget {
   Divider,
   Form,
   Gauge,
+  KeyboardShortcuts,
   List,
   LogView,
   Modal,
   MultiSelect,
+  NonInteractiveError,
+  NotificationCenter,
+  NotificationStore,
+  NumberInput,
+  PasswordInput,
+  PathInput,
   ProgressBar,
   Select,
   Spacer,
@@ -832,6 +1775,9 @@ var CommandPalette = class extends import_widgets11.Widget {
   TextInput,
   Toast,
   Tree,
-  Widget
+  Widget,
+  notifications,
+  prompt,
+  useNotifications
 });
 //# sourceMappingURL=index.cjs.map