@vincemakes/kiso-tui 0.25.0 → 0.26.1

package/dist/pick-input.js

@@ -0,0 +1,100 @@
+/**
+ * The SESSION PICKER's input controller — S5 (finding C10). TUI2-R2 ②:
+ * the band's third occupant. Its filter is the @ picker's rank aimed at
+ * the session id; this controller owns the keys, the compositor draws
+ * the rows.
+ *
+ * The picker is MODAL in a way the @ picker is not: it opens before a
+ * session exists, owns the whole composer (the buffer IS the filter
+ * query, derived on every read rather than stored, so every buffer op —
+ * backspace, the kills, paste — filters correctly with no handler of
+ * its own), and the only ways out are a pick and an esc. That is why
+ * the commit callback lives here rather than on the line channel: the
+ * caller is waiting for an id, not for a turn.
+ *
+ * DECLARED MOVE (S5, 2026-09-06): `beginPick`, `#pickView`, `pickState`,
+ * `#pickUp`, `#pickRows`, `#pickClose`, `#pickAccept` and the ↑↓ branch
+ * stood in editor.ts; the bodies are the same, the buffer access goes
+ * through the host.
+ */
+import { AT_VISIBLE } from "./at-picker.js";
+import { sessionFilter } from "./session-picker.js";
+export class PickInput {
+    host;
+    #cards = null;
+    #commit = null;
+    #sel = 0;
+    constructor(host) {
+        this.host = host;
+    }
+    up() {
+        return this.#cards !== null;
+    }
+    /** Open the picker on a bound card source. The composer is cleared
+     *  (the buffer becomes the filter query) and `onPick` receives the
+     *  chosen id — or null when the human leaves without picking, which
+     *  is a first-class outcome and not an error. */
+    begin(cards, onPick) {
+        this.#cards = cards;
+        this.#commit = onPick;
+        this.#sel = 0;
+        this.host.syncMouse();
+        this.host.clear();
+        this.host.reflow();
+        this.host.render();
+    }
+    /** The picker's state, derived: the full card list (the id column
+     *  measures over ALL of them, so the columns never jump), the
+     *  filtered matches, and the selection CLAMPED at read time — the
+     *  same correction discipline the @ picker uses, for the same
+     *  reason: narrowing can only ever shrink the list. */
+    state() {
+        if (this.#cards === null)
+            return null;
+        const cards = this.#cards();
+        const matches = sessionFilter(cards, this.host.line());
+        return { cards, matches, selected: Math.max(0, Math.min(this.#sel, matches.length - 1)) };
+    }
+    /** The band's height estimate: the header + the windowed rows (or
+     *  the one "no match" row) + the counter. */
+    rows() {
+        const view = this.state();
+        return view === null ? 0 : Math.min(Math.max(view.matches.length, 1), AT_VISIBLE) + 2;
+    }
+    /** ↑↓: the selection walks the matches and stops at both ends. True
+     *  when the picker owned the key (the caller renders). */
+    arrow(dir) {
+        const view = this.state();
+        if (view === null)
+            return false;
+        this.#sel = dir === "up" ? Math.max(0, view.selected - 1) : Math.min(Math.max(0, view.matches.length - 1), view.selected + 1);
+        return true;
+    }
+    /** Close and hand the verdict back. The callback fires AFTER the
+     *  state is cleared, so a caller that re-enters (a second picker, a
+     *  session that starts) never sees the closing picker's rows. */
+    close(id) {
+        const cb = this.#commit;
+        this.#cards = null;
+        this.#commit = null;
+        this.#sel = 0;
+        this.host.syncMouse();
+        this.host.clear();
+        this.host.reflow();
+        cb?.(id);
+        this.host.render();
+    }
+    /** Enter takes the SELECTED session. An empty match set takes
+     *  nothing and leaves the picker up: a picker that invented a pick
+     *  when the query matched nothing would resume the wrong session,
+     *  which is the one failure this surface must never have. */
+    accept() {
+        const view = this.state();
+        if (view === null)
+            return;
+        const card = view.matches[view.selected];
+        if (card === undefined)
+            return;
+        this.close(card.id);
+    }
+}

package/dist/session-picker.js

@@ -23,7 +23,7 @@
  * state — which is what lets the picker band and the `kiso sessions`
  * listing render from ONE definition instead of two that drift.
  */
-import { escapeTerminal, palette } from "./render.js";
+import { escapeTerminal, palette } from "./lines.js";
 import { selectionBar, visibleWidth, widthCut } from "./components.js";
 import { atEmbed, bandHeader, longestRun, AT_VISIBLE, atWindow } from "./at-picker.js";
 /** The glyph per state — one cell each, so the badge column never

package/dist/status.js

@@ -21,7 +21,7 @@
  * deliberate exception: the running row's interrupt hint, which KC2 §2
  * widens to name the new gesture.
  */
-import { kUnit } from "./render.js";
+import { kUnit } from "./lines.js";
 import { TWINKLE } from "@vincemakes/kiso-tui-cells/render";
 /**
  * R3 (design §5.2) — the working glyph family is the TWINKLE, and the

package/dist/transcript.js

@@ -33,8 +33,8 @@
  * so a viewer that expanded a committed cell in place would corrupt the
  * window arithmetic for the rest of the session.
  */
-import { palette } from "./render.js";
-import { visibleWidth } from "./components.js";
+import { palette } from "./lines.js";
+import { cutLine, visibleWidth } from "./components.js";
 /** The gutter every viewer row carries: the cursor mark and its space. */
 export const VIEWER_GUTTER = 3;
 export function viewerInit(entries) {
@@ -135,7 +135,7 @@ export function viewerRows(entries, state, W, rows) {
         const mark = line.head ? (open ? "▾" : onCursor ? "▸" : " ") : "│";
         const gutter = onCursor ? `${p.bold}${mark}${p.reset} ` : `${p.dim}${mark}${p.reset} `;
         const row = ` ${gutter}${line.text}`;
-        out.push(open ? shade(row, W) : cut(row, W));
+        out.push(open ? shade(row, W) : cutLine(row, W));
     }
     return out;
 }
@@ -152,34 +152,11 @@ export function viewerRows(entries, state, W, rows) {
  */
 function shade(row, W) {
     const p = palette();
-    const body = cut(row, W);
+    const body = cutLine(row, W);
     if (p.wash === "")
         return body;
     return `${p.wash}${body}${" ".repeat(Math.max(0, W - visibleWidth(body)))}${p.washEnd}`;
 }
-/** The last resort — the row is cut at W rather than overflowing it. */
-function cut(row, W) {
-    if (visibleWidth(row) <= W)
-        return row;
-    let out = "";
-    let n = 0;
-    for (let i = 0; i < row.length;) {
-        if (row[i] === "\x1b") {
-            const j = row.indexOf("m", i);
-            if (j < 0)
-                break;
-            out += row.slice(i, j + 1);
-            i = j + 1;
-            continue;
-        }
-        if (n >= W - 1)
-            break;
-        out += row[i];
-        n += 1;
-        i += 1;
-    }
-    return `${out}…${palette().reset}`;
-}
 /** The viewer's affordance row — what the keys do, where they are
  *  useful (the PICKER_HINT convention). */
 export function viewerHint(state, entries) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.25.0",
+	"version": "0.26.1",
 	"description": "kiso tui — the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",
@@ -35,6 +35,6 @@
 	},
 	"homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
 	"dependencies": {
-		"@vincemakes/kiso-tui-cells": "0.25.0"
+		"@vincemakes/kiso-tui-cells": "0.26.1"
 	}
 }