@promptctl/rich-js 0.19.0 → 0.21.0

package/dist/widgets/dropdown.js

@@ -61,6 +61,7 @@ import { Segment } from "../core/segment.js";
 import { Style } from "../core/style.js";
 import { cellLen, setCellSize, splitText, asCellCol } from "../core/cells.js";
 import { drawable } from "../core/protocol.js";
+import { moveSelection } from "../core/selection.js";
 import { ThemedWidget } from "./themed-widget.js";
 import { ink } from "./ink.js";
 let Dropdown = (() => {
@@ -189,12 +190,11 @@ let Dropdown = (() => {
             // expanded
             switch (event.key) {
                 case "up":
-                    this.highlightedIndex = Math.max(0, this.highlightedIndex - 1);
+                    this.highlightedIndex = moveSelection(this.highlightedIndex, -1, this.filteredOptions.length);
                     event.stop();
                     return;
                 case "down": {
-                    const max = Math.max(0, this.filteredOptions.length - 1);
-                    this.highlightedIndex = Math.min(max, this.highlightedIndex + 1);
+                    this.highlightedIndex = moveSelection(this.highlightedIndex, 1, this.filteredOptions.length);
                     event.stop();
                     return;
                 }

package/dist/widgets/event-router.d.ts

@@ -1,49 +1,38 @@
 /**
- * EventRouter — parses raw stdin into KeyEvent / ScreenMouseEvent values
- * and dispatches them to widgets via a FocusManager and the frame on screen.
+ * EventRouter — dispatches the keys and pointer events an `App` hears to
+ * widgets, via a FocusManager and the frame on screen.
  *
- * It reads the terminal and never sets it up: raw mode and mouse tracking are
- * the runtime's (`App`), which undoes them on every path out.
- *
- * [LAW:single-enforcer] ANSI escape parsing lives only here — widgets never
- * see raw bytes. One parser, one dispatch surface.
- *
- * [LAW:dataflow-not-control-flow] The same parse pipeline runs for every
- * input chunk: append → consume one event at a time until the buffer can't
- * yield more. The byte's value, not a side-mode, decides which event is
- * emitted. There is no "are we mid-sequence" mode flag — the buffer head
- * carries all the state we need.
- *
- * Lone-ESC handling: a bare `\x1b` is ambiguous (escape key vs. start of a
- * CSI sequence). When the buffer is drained but ends with a lone ESC, the
- * router defers emission via setTimeout(0). The next chunk cancels the timer
- * if it extends the sequence. Tests can call `flush()` to drain synchronously.
+ * It parses nothing and reads no terminal: `App` owns the one parser over its
+ * host's input (`host/input`), and `WidgetApp` hands this what the app hears.
  */
 import { KeyEvent } from "./types.js";
-import type { FrameSource, ScreenMouseEvent, KeyHandlerOptions } from "./types.js";
+import type { FrameSource, KeyHandlerOptions } from "./types.js";
 import type { Unsubscribe } from "../core/subscription.js";
-import type { TerminalHost } from "../host/terminal-host.js";
+import type { KeyPress } from "../host/input.js";
+import type { AppMouseEvent } from "../host/app.js";
+import type { Wheel } from "../host/app.js";
 type KeyHandler = (event: KeyEvent) => void;
 export interface EventRouterOptions {
     source: FrameSource;
-    /** The I/O capability the router reads input from. */
-    host: TerminalHost;
+    /** Whether a left-button press focuses the widget under it before it hears the press. */
+    focusOnClick: boolean;
 }
 export declare class EventRouter {
     private readonly source;
-    private readonly host;
-    private buffer;
-    private running;
-    private dataUnsubscribe;
-    private escTimer;
+    private readonly focusOnClick;
     private captured;
     private pointer;
     private hoveredWidget;
     private readonly keyChain;
     private readonly mouseHandlers;
     constructor(options: EventRouterOptions);
-    start(): void;
-    stop(): void;
+    /**
+     * Drop what a run left behind — a captured drag, the pointer, hover — so the
+     * router is in the shape a fresh construction would be.
+     *
+     * [LAW:one-source-of-truth] Per-session state belongs to one session.
+     */
+    reset(): void;
     /**
      * Read hover again off the frame just painted: under a pointer that has not
      * moved, a widget may have gone, moved, or arrived.
@@ -53,17 +42,19 @@ export declare class EventRouter {
      */
     framePainted(): void;
     onKey(handler: KeyHandler, options?: KeyHandlerOptions): Unsubscribe;
-    onMouse(handler: (event: ScreenMouseEvent) => void): Unsubscribe;
-    /** Feed a chunk of bytes (or a string of bytes) into the parser. */
-    feed(chunk: Uint8Array | string): void;
-    /** Force any pending lone ESC out of the buffer. */
-    flush(): void;
-    private drain;
-    private consumeOne;
-    private consumePrintable;
-    private consumeEscape;
-    private consumeSS3;
-    private consumeCSI;
+    onMouse(handler: (event: AppMouseEvent) => void): Unsubscribe;
+    /** Route a key the app heard. */
+    key(press: KeyPress): void;
+    /** Route a pointer event the app heard. */
+    mouse(event: AppMouseEvent): void;
+    /**
+     * Scroll the innermost viewport under the pointer that can move, a line a
+     * notch, past any widget it shows there and whatever a drag captured.
+     * Whether one moved is the answer: with none, the app passes the wheel
+     * outward.
+     */
+    wheel({ x, y, lines }: Wheel): boolean;
+    private point;
     private dispatchKey;
     private dispatchMouse;
     private hover;