@promptctl/rich-js 0.23.0 → 0.24.1

package/dist/widgets/focus-manager.js

@@ -69,42 +69,30 @@ let DefaultFocusManager = (() => {
             __esDecorate(this, null, _setFocus_decorators, { kind: "method", name: "setFocus", static: false, private: false, access: { has: obj => "setFocus" in obj, get: obj => obj.setFocus }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        onScreen = __runInitializers(this, _instanceExtraInitializers);
+        view = __runInitializers(this, _instanceExtraInitializers);
         #currentWidget_accessor_storage = __runInitializers(this, _currentWidget_initializers, null);
         get currentWidget() { return this.#currentWidget_accessor_storage; }
         set currentWidget(value) { this.#currentWidget_accessor_storage = value; }
         changeHandlers = (__runInitializers(this, _currentWidget_extraInitializers), new Set());
         /**
-         * `onScreen` is the widgets on the frame on screen, in document order.
-         *
-         * [LAW:one-source-of-truth] It is asked every time rather than kept: a list
-         * of the widgets held here would be a second picture of the frame, and
-         * wrong from the next paint.
+         * [LAW:one-source-of-truth] The view is asked every time rather than kept:
+         * a list of the widgets held here would be a second picture of the frame,
+         * and wrong from the next paint.
          */
-        constructor(onScreen) {
-            this.onScreen = onScreen;
+        constructor(view) {
+            this.view = view;
         }
         get current() {
             return this.currentWidget;
         }
         get widgets() {
-            return this.onScreen().filter(takesFocus);
+            return this.view.onScreen().filter(takesFocus);
         }
         next() {
-            const focusable = this.widgets;
-            if (focusable.length === 0)
-                return;
-            const currentIdx = this.currentWidget ? focusable.indexOf(this.currentWidget) : -1;
-            const nextIdx = (currentIdx + 1) % focusable.length;
-            this.setFocus(focusable[nextIdx]);
+            this.step(this.view.present());
         }
         prev() {
-            const focusable = this.widgets;
-            if (focusable.length === 0)
-                return;
-            const currentIdx = this.currentWidget ? focusable.indexOf(this.currentWidget) : -1;
-            const prevIdx = currentIdx <= 0 ? focusable.length - 1 : currentIdx - 1;
-            this.setFocus(focusable[prevIdx]);
+            this.step([...this.view.present()].reverse());
         }
         // A widget not on screen yet can take focus: an app that is about to show
         // it focuses it first, and the frame that shows it keeps it (`settle`).
@@ -115,20 +103,21 @@ let DefaultFocusManager = (() => {
         }
         /**
          * Put focus where the frame just painted lets it rest: it stays on a widget
-         * the view drew (`drawn`) that can take it, and otherwise moves to the first
-         * one on screen that can, or to none.
+         * the view holds (`present`) that can take it, and otherwise moves to the
+         * first one on screen that can, or to none.
          *
-         * Drawn, not on screen: a widget cropped for the moment — the terminal
-         * shrank, a viewport scrolled, an overlay covers it — is still in the view,
-         * and keeps focus and whatever focus holds, like a half-typed filter.
+         * In the view, not on screen: a widget cropped for the moment — the
+         * terminal shrank, a viewport scrolled, an overlay covers it, its container
+         * handed it no column — is still in the view, and keeps focus and whatever
+         * focus holds, like a half-typed filter.
          *
          * [LAW:single-enforcer] The one place focus follows the frame — onto the
-         * first widget when the app starts, off a widget that stopped being drawn
+         * first widget when the app starts, off a widget that left the view
          * or was disabled.
          */
-        settle(drawn) {
+        settle() {
             const current = this.currentWidget;
-            if (current && takesFocus(current) && drawn.includes(current))
+            if (current && takesFocus(current) && this.view.present().includes(current))
                 return;
             const first = this.widgets[0];
             if (first)
@@ -154,6 +143,16 @@ let DefaultFocusManager = (() => {
             event.stop();
         }
         // --- Private ---
+        // To the first widget Tab moves between that follows the focused one in
+        // `order`, wrapping. It is found by its place in the view, not among those
+        // on screen, so Tab from a widget on no cell moves to its neighbour.
+        step(order) {
+            const tabbable = new Set(this.widgets);
+            const at = this.currentWidget ? order.indexOf(this.currentWidget) : -1;
+            const target = [...order.slice(at + 1), ...order.slice(0, at + 1)].find((widget) => tabbable.has(widget));
+            if (target)
+                this.setFocus(target);
+        }
         // No focus is where `settle` leaves an app with nothing to focus, and only
         // there: anywhere else the next frame would put focus back on the first
         // widget, so there is no public way in.

package/dist/widgets/index.d.ts

@@ -4,7 +4,7 @@ export { StaticItem } from "./static-item.js";
 export type { StaticItemOptions } from "./static-item.js";
 export { WidgetBase } from "./widget-base.js";
 export { WidgetApp } from "./widget-app.js";
-export type { WidgetAppOptions } from "./widget-app.js";
+export type { WidgetAppOptions, WidgetPresence } from "./widget-app.js";
 export { Button } from "./button.js";
 export type { ButtonVariant, ButtonOptions } from "./button.js";
 export { Checkbox } from "./checkbox.js";

package/dist/widgets/static-item.d.ts

@@ -11,7 +11,7 @@
  * renderable.
  */
 import { Segment } from "../core/segment.js";
-import type { Measurable, Renderable, RenderOptions } from "../core/protocol.js";
+import type { Composite, Measurable, Renderable, RenderOptions } from "../core/protocol.js";
 import { WidgetBase } from "./widget-base.js";
 import type { KeyEvent } from "./types.js";
 export interface StaticItemOptions {
@@ -19,12 +19,13 @@ export interface StaticItemOptions {
     render: Renderable | ((options: RenderOptions) => Iterable<Segment>);
     measure?: Measurable["measure"];
 }
-export declare class StaticItem extends WidgetBase {
+export declare class StaticItem extends WidgetBase implements Composite {
     readonly id: string;
     readonly focusable = false;
-    private readonly renderFn;
+    private readonly body;
     private readonly measureFn;
     constructor(options: StaticItemOptions);
+    contents(): Iterable<Renderable>;
     handleKey(_event: KeyEvent): void;
     protected draw(options: RenderOptions): Iterable<Segment>;
     measure(options: RenderOptions): {

package/dist/widgets/static-item.js

@@ -11,27 +11,29 @@
  * renderable.
  */
 import { Segment } from "../core/segment.js";
+import { render } from "../core/protocol.js";
 import { WidgetBase } from "./widget-base.js";
 export class StaticItem extends WidgetBase {
     id;
     focusable = false;
-    renderFn;
+    // The body as a renderable either way: a function is one that holds nothing.
+    body;
     measureFn;
     constructor(options) {
         super();
         this.id = options.id;
         const r = options.render;
-        this.renderFn =
-            typeof r === "function"
-                ? (opts) => r(opts)
-                : (opts) => r.render(opts);
+        this.body = typeof r === "function" ? { render: r } : r;
         this.measureFn = options.measure;
     }
+    *contents() {
+        yield this.body;
+    }
     // Static items don't respond to keys. WidgetBase.handleMouse / handleFocus
     // are already no-ops, so we only need to satisfy the abstract handleKey.
     handleKey(_event) { }
     draw(options) {
-        return this.renderFn(options);
+        return render(this.body, options);
     }
     measure(options) {
         if (this.measureFn)
@@ -41,7 +43,7 @@ export class StaticItem extends WidgetBase {
         // values too, not just the "\n" sentinel segment. Walking segments and
         // testing `seg.text === "\n"` miscounts widths for any renderable
         // that emits "a\nb" as a single segment.
-        const segments = Array.from(this.renderFn(options));
+        const segments = Array.from(render(this.body, options));
         const lines = Segment.splitLines(segments);
         let max = 0;
         for (const line of lines) {

package/dist/widgets/text-input.d.ts

@@ -3,10 +3,12 @@
  *
  * Two modes:
  *   - single-line (default): Enter submits; newlines in value are rendered
- *                            as a literal `↵` glyph if they ever appear.
+ *                            as a literal `↵` glyph if they ever appear, and
+ *                            any other glyph of zero cells as `◌`.
  *   - multi-line  (`multiline: true`): Enter inserts a `\n`; `value` may
  *                            contain logical line breaks; Up/Down navigate
  *                            between logical lines preserving column intent.
+ *                            A glyph of zero cells is drawn as `◌` here too.
  *
  * [LAW:dataflow-not-control-flow] cursor and value are observable data; the
  * keymap dispatches to small `@action` mutators that all flow through the
@@ -69,20 +71,22 @@ import { ThemedWidget } from "./themed-widget.js";
 import type { KeyEvent, WidgetMouseEvent } from "./types.js";
 /**
  * A soft-wrap strategy. Given one logical line of text and cell-width budgets,
- * return the visual sub-rows that line wraps into. The first sub-row uses
- * `firstWidth` as its capacity; every subsequent (continuation) sub-row uses
- * `continuationWidth` (typically `firstWidth - cellLen(continuationMarker)`).
+ * return the visual sub-rows that line wraps into. The line arrives as the
+ * widget shows it — each glyph of zero cells already its one-cell `◌`, each
+ * glyph of a password its mask — so the budget counts the cells drawn. The
+ * first sub-row uses `firstWidth` as its capacity; every subsequent
+ * (continuation) sub-row uses `continuationWidth` (typically
+ * `firstWidth - cellLen(continuationMarker)`).
  *
- * Each returned row carries:
- *   - `content` — the displayed text for that visual row (the widget prepends
- *     the continuation marker itself; the strategy never includes it).
- *   - `start`   — code-unit offset into the *logical line* where `content`
- *     begins, so the widget can map visual positions back to absolute `value`
- *     offsets for cursor projection.
+ * Each returned row is the stretch `[start, end)` of the line as given that
+ * the row draws; the widget draws the matching stretch of `value` and
+ * prepends the continuation marker itself.
  *
- * [LAW:types-are-the-program] Budget params are `CellCol`; `start` is
- * `CodePoint` (a `CodeUnit` on a code-point boundary) — the type system
- * prevents mixing these integer spaces inside a custom strategy.
+ * [LAW:types-are-the-program] A row names where it falls in the line rather
+ * than carrying text of its own, so it cannot draw anything the line does not
+ * hold. Budget params are `CellCol`; offsets are `CodePoint` (a `CodeUnit` on
+ * a code-point boundary) — the type system prevents mixing these integer
+ * spaces inside a custom strategy.
  *
  * Built-in: `charGreedyWrap` (break at any character at the width limit).
  * Custom: any function matching this signature. Template-aware wrapping
@@ -94,9 +98,10 @@ export type WrapStrategy = (logicalLine: string, budget: {
     continuationWidth: CellCol;
 }) => readonly WrapRow[];
 export interface WrapRow {
-    readonly content: string;
-    /** Code-point offset into the logical line where `content` begins. */
+    /** Offset into the line as given where the row begins. */
     readonly start: CodePoint;
+    /** Offset into the line as given where the row ends, exclusive. */
+    readonly end: CodePoint;
 }
 /**
  * Character-greedy soft wrap. Breaks at any character once `firstWidth`
@@ -225,7 +230,7 @@ export declare class TextInput extends ThemedWidget {
     private _killBuffer;
     private _scrollStart;
     private _singleLineViewportStart;
-    private _singleLineAsciiOnly;
+    private _drawn;
     readonly multiline: boolean;
     constructor(options?: TextInputOptions);
     handleKey(event: KeyEvent): void;
@@ -257,12 +262,16 @@ export declare class TextInput extends ThemedWidget {
     private _insertText;
     protected get ground(): Style;
     protected draw(options: RenderOptions): Iterable<Segment>;
+    private _shownAs;
     private _shown;
+    private _shownCells;
+    private _offsetAtShownCell;
     private _renderSingleLine;
     private _renderMultiline;
+    private _drawsArrows;
     private _emitRowContent;
     private _computeVisualRows;
-    measure(_options: RenderOptions): {
+    measure(options: RenderOptions): {
         minimum: number;
         maximum: number;
     };
@@ -271,7 +280,8 @@ export declare class TextInput extends ThemedWidget {
      * scroll, else `undefined`. X is the cursor's 1-indexed visual row; Y is
      * the total visual row count. Reads cached state populated by the most
      * recent `render()` — call from a `Panel.bottomRightAccessory` thunk so
-     * it evaluates after content has been rendered for the current frame.
+     * it evaluates after content has been rendered for the current frame;
+     * `BorderAccessory` names the widths where it has not.
      *
      * Returns `undefined` when:
      *   - `scrollIndicator` is not `"indices"`, or