@promptctl/rich-js 0.24.1 → 0.25.0

package/dist/widgets/focus-manager.js

@@ -38,7 +38,8 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
-import { action, observableRef } from "mobx";
+import { action } from "mobx";
+import { observableRef } from "./observable.js";
 let DefaultFocusManager = (() => {
     let _instanceExtraInitializers = [];
     let _currentWidget_decorators;
@@ -162,7 +163,7 @@ let DefaultFocusManager = (() => {
             // [LAW:single-enforcer] WidgetBase.focus()/blur() route through
             // handleFocus; calling it here as well would dispatch twice and run any
             // subclass side effect (e.g. Dropdown clearing its filter) twice.
-            this.currentWidget.blur();
+            this.currentWidget.blur(this.view.frameTime());
             this.currentWidget = null;
             this.emitChange();
         }
@@ -171,10 +172,11 @@ let DefaultFocusManager = (() => {
                 return;
             // [LAW:single-enforcer] focus()/blur() already dispatch handleFocus —
             // see clear() for the rationale.
+            const time = this.view.frameTime();
             if (this.currentWidget)
-                this.currentWidget.blur();
+                this.currentWidget.blur(time);
             this.currentWidget = widget;
-            widget.focus();
+            widget.focus(time);
             this.emitChange();
         }
         emitChange() {

package/dist/widgets/hit.d.ts

@@ -11,6 +11,7 @@
  * answer "what is under the pointer", so the answer cannot disagree with what
  * the user sees. Z-order is paint order — whoever painted a cell last owns it.
  */
+import type { Anchor } from "../core/anchor.js";
 import { Segment } from "../core/segment.js";
 import type { Scrollable } from "../core/protocol.js";
 import type { InteractiveWidget } from "./types.js";
@@ -50,6 +51,11 @@ export declare function originOf(frame: readonly (readonly Segment[])[], widget:
  * or through a widget nested in its output.
  */
 export declare function drew(frame: readonly (readonly Segment[])[], widget: InteractiveWidget, x: number, y: number): boolean;
+/**
+ * What `widget`'s own draw stamped on the cell at column `x` of row `y` of
+ * `frame`, inside its stamp, or `undefined` when it drew none of it.
+ */
+export declare function cellOf(frame: readonly (readonly Segment[])[], widget: InteractiveWidget, x: number, y: number): Anchor | undefined;
 /**
  * Where `widget`'s footprint sits in `frame`: the cell its row 0, column 0
  * falls on, and how many of its rows the frame shows down to its lowest — or

package/dist/widgets/hit.js

@@ -11,7 +11,7 @@
  * answer "what is under the pointer", so the answer cannot disagree with what
  * the user sees. Z-order is paint order — whoever painted a cell last owns it.
  */
-import { drawnBy } from "../core/anchor.js";
+import { drawnBy, levelOf } from "../core/anchor.js";
 import { Segment } from "../core/segment.js";
 import { isScrollable } from "../core/protocol.js";
 import { WidgetBase } from "./widget-base.js";
@@ -75,6 +75,13 @@ export function originOf(frame, widget) {
 export function drew(frame, widget, x, y) {
     return drawnBy(Segment.anchorAt(frame, x, y), widget);
 }
+/**
+ * What `widget`'s own draw stamped on the cell at column `x` of row `y` of
+ * `frame`, inside its stamp, or `undefined` when it drew none of it.
+ */
+export function cellOf(frame, widget, x, y) {
+    return levelOf(Segment.anchorAt(frame, x, y), widget)?.inner;
+}
 /**
  * Where `widget`'s footprint sits in `frame`: the cell its row 0, column 0
  * falls on, and how many of its rows the frame shows down to its lowest — or

package/dist/widgets/observable.d.ts

@@ -0,0 +1,23 @@
+/**
+ * observable — the widgets' state carrier: mobx's `observableRef` accessor
+ * decorator, refusing a write during a render or measure the widget was not
+ * made in.
+ *
+ * A render changes nothing (`src/core/state.ts`). `State` refuses a write in
+ * its setter; a widget's state is a mobx observable, whose setter is mobx's, so
+ * the refusal is an interceptor every instance registers on each of its
+ * observables as it is made, holding the pass it was made in. `core/` cannot do
+ * this itself: mobx is an optional peer, reachable only through `./widgets`.
+ *
+ * There is no deep `observable`. It turns an array or object into a mobx one
+ * whose contents are written without the interceptor, so a refusal on the
+ * accessor alone would be a refusal of half the writes. A held value is
+ * replaced whole, and the render-purity gate reports one whose type can be
+ * written in place.
+ *
+ * Every observable accessor in `src/widgets/` is declared with this, never
+ * with mobx's own: `test/seam/render-purity.ts` sanctions an accessor
+ * decorated from this module and reports any other as a writable property.
+ */
+/** mobx's `observableRef` (the reference, not its contents), refusing a write during a render or measure. */
+export declare function observableRef<This extends object, Value>(target: ClassAccessorDecoratorTarget<This, Value>, context: ClassAccessorDecoratorContext<This, Value>): ClassAccessorDecoratorResult<This, Value>;

package/dist/widgets/observable.js

@@ -0,0 +1,43 @@
+/**
+ * observable — the widgets' state carrier: mobx's `observableRef` accessor
+ * decorator, refusing a write during a render or measure the widget was not
+ * made in.
+ *
+ * A render changes nothing (`src/core/state.ts`). `State` refuses a write in
+ * its setter; a widget's state is a mobx observable, whose setter is mobx's, so
+ * the refusal is an interceptor every instance registers on each of its
+ * observables as it is made, holding the pass it was made in. `core/` cannot do
+ * this itself: mobx is an optional peer, reachable only through `./widgets`.
+ *
+ * There is no deep `observable`. It turns an array or object into a mobx one
+ * whose contents are written without the interceptor, so a refusal on the
+ * accessor alone would be a refusal of half the writes. A held value is
+ * replaced whole, and the render-purity gate reports one whose type can be
+ * written in place.
+ *
+ * Every observable accessor in `src/widgets/` is declared with this, never
+ * with mobx's own: `test/seam/render-purity.ts` sanctions an accessor
+ * decorated from this module and reports any other as a writable property.
+ */
+import { observableRef as mobxObservableRef, intercept } from "mobx";
+import { activePass } from "../core/protocol.js";
+import { refuseRenderWrite } from "../core/state.js";
+/** mobx's accessor decorator, typed as what it returns for an accessor: a `get`, a `set` and an `init`, always all three. */
+const mobxRef = mobxObservableRef;
+/** mobx's `observableRef` (the reference, not its contents), refusing a write during a render or measure. */
+export function observableRef(target, context) {
+    const inner = mobxRef(target, context);
+    return {
+        ...inner,
+        init(value) {
+            const initial = inner.init.call(this, value);
+            const owner = activePass();
+            // [LAW:single-enforcer] The rule is `State`'s, applied by its one enforcer.
+            intercept(this, context.name, (change) => {
+                refuseRenderWrite(owner);
+                return change;
+            });
+            return initial;
+        },
+    };
+}

package/dist/widgets/slider.d.ts

@@ -40,7 +40,7 @@ export declare class Slider extends ThemedWidget {
     accessor max: number;
     accessor step: number;
     accessor width: number;
-    private _dragging;
+    private accessor _dragging;
     constructor(options?: SliderOptions);
     handleKey(event: KeyEvent): void;
     handleMouse(event: WidgetMouseEvent): void;

package/dist/widgets/slider.js

@@ -51,7 +51,8 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
-import { observable, action, observableRef } from "mobx";
+import { action } from "mobx";
+import { observableRef } from "./observable.js";
 import { Segment } from "../core/segment.js";
 import { Style } from "../core/style.js";
 import { drawable } from "../core/protocol.js";
@@ -76,17 +77,21 @@ let Slider = (() => {
     let _width_decorators;
     let _width_initializers = [];
     let _width_extraInitializers = [];
+    let __dragging_decorators;
+    let __dragging_initializers = [];
+    let __dragging_extraInitializers = [];
     let _handleKey_decorators;
     let _handleMouse_decorators;
     let _setValue_decorators;
     return class Slider extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _value_decorators = [observable];
+            _value_decorators = [observableRef];
             _min_decorators = [observableRef];
             _max_decorators = [observableRef];
             _step_decorators = [observableRef];
             _width_decorators = [observableRef];
+            __dragging_decorators = [observableRef];
             _handleKey_decorators = [action];
             _handleMouse_decorators = [action];
             _setValue_decorators = [action];
@@ -95,6 +100,7 @@ let Slider = (() => {
             __esDecorate(this, null, _max_decorators, { kind: "accessor", name: "max", static: false, private: false, access: { has: obj => "max" in obj, get: obj => obj.max, set: (obj, value) => { obj.max = value; } }, metadata: _metadata }, _max_initializers, _max_extraInitializers);
             __esDecorate(this, null, _step_decorators, { kind: "accessor", name: "step", static: false, private: false, access: { has: obj => "step" in obj, get: obj => obj.step, set: (obj, value) => { obj.step = value; } }, metadata: _metadata }, _step_initializers, _step_extraInitializers);
             __esDecorate(this, null, _width_decorators, { kind: "accessor", name: "width", static: false, private: false, access: { has: obj => "width" in obj, get: obj => obj.width, set: (obj, value) => { obj.width = value; } }, metadata: _metadata }, _width_initializers, _width_extraInitializers);
+            __esDecorate(this, null, __dragging_decorators, { kind: "accessor", name: "_dragging", static: false, private: false, access: { has: obj => "_dragging" in obj, get: obj => obj._dragging, set: (obj, value) => { obj._dragging = value; } }, metadata: _metadata }, __dragging_initializers, __dragging_extraInitializers);
             __esDecorate(this, null, _handleKey_decorators, { kind: "method", name: "handleKey", static: false, private: false, access: { has: obj => "handleKey" in obj, get: obj => obj.handleKey }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _handleMouse_decorators, { kind: "method", name: "handleMouse", static: false, private: false, access: { has: obj => "handleMouse" in obj, get: obj => obj.handleMouse }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _setValue_decorators, { kind: "method", name: "setValue", static: false, private: false, access: { has: obj => "setValue" in obj, get: obj => obj.setValue }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -117,9 +123,12 @@ let Slider = (() => {
         #width_accessor_storage = (__runInitializers(this, _step_extraInitializers), __runInitializers(this, _width_initializers, void 0));
         get width() { return this.#width_accessor_storage; }
         set width(value) { this.#width_accessor_storage = value; }
-        _dragging = (__runInitializers(this, _width_extraInitializers), false);
+        #_dragging_accessor_storage = (__runInitializers(this, _width_extraInitializers), __runInitializers(this, __dragging_initializers, false));
+        get _dragging() { return this.#_dragging_accessor_storage; }
+        set _dragging(value) { this.#_dragging_accessor_storage = value; }
         constructor(options = {}) {
             super(options.theme);
+            __runInitializers(this, __dragging_extraInitializers);
             this.id = options.id ?? `slider-${Math.random().toString(36).slice(2, 8)}`;
             this.min = options.min ?? 0;
             this.max = options.max ?? 100;

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

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

@@ -26,9 +26,6 @@ export class StaticItem extends WidgetBase {
         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) { }

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

@@ -68,7 +68,7 @@ import { type CellCol, type CodePoint, type CodeUnit } from "../core/cells.js";
 import { type RenderOptions } from "../core/protocol.js";
 import type { TerminalTheme } from "../core/color.js";
 import { ThemedWidget } from "./themed-widget.js";
-import type { KeyEvent, WidgetMouseEvent } from "./types.js";
+import type { KeyEvent, WidgetFocusEvent, 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 line arrives as the
@@ -111,7 +111,7 @@ export interface WrapRow {
  *
  * Wide characters (CJK, emoji) are treated as atomic: a char that would
  * straddle the budget is moved to the next row rather than split, and one too
- * wide for the whole budget is force-taken — see `cellStepFrom`.
+ * wide for the whole budget is force-taken — see `cellRows`.
  */
 export declare const charGreedyWrap: WrapStrategy;
 export interface TextInputOptions {
@@ -168,10 +168,11 @@ export interface TextInputOptions {
      *     area on the first/last visible row when scroll is possible in that
      *     direction. Fully self-contained — host needs no wiring.
      *   - `"indices"`: the widget suppresses in-content arrows and instead
-     *     publishes `scrollIndicatorText` (e.g. `"[14/102]"`) for the host
-     *     (typically a `Panel`'s `bottomRightAccessory`) to display in the
-     *     border. Useful when the surrounding chrome should carry the
-     *     indicator so widget content area stays untouched.
+     *     answers `scrollIndicatorText(frame)` (e.g. `"[14/102]"`) for a frame
+     *     it is drawn in, which a `Panel`'s `bottomRightAccessory` function
+     *     hands it, to display in the border. Useful when the surrounding
+     *     chrome should carry the indicator so widget content area stays
+     *     untouched.
      *   - `"none"`: no indicator at all.
      */
     scrollIndicator?: "arrows" | "indices" | "none";
@@ -197,6 +198,7 @@ export declare class TextInput extends ThemedWidget {
     readonly focusable = true;
     private accessor _value;
     private accessor _cursor;
+    private accessor _blinkFrom;
     get value(): string;
     set value(v: string);
     get cursorPosition(): CodePoint;
@@ -214,35 +216,23 @@ export declare class TextInput extends ThemedWidget {
     accessor indicatorStyleOverride: Style | undefined;
     accessor cursorStyleOverride: Style | undefined;
     accessor contentStyleOverride: Style | undefined;
-    /**
-     * Last computed visual-row decomposition. Cached at the end of `render()`
-     * so vertical motion (Up/Down) can step row-by-row without re-running the
-     * wrap strategy. Null before the first render — vertical motion falls
-     * back to logical-line motion in that case.
-     *
-     * [LAW:dataflow-not-control-flow] One source of truth for "what does Up
-     * mean right now": the row table the renderer just produced. No parallel
-     * "where would the cursor go" math; both the renderer and the keymap
-     * read from the same array.
-     */
-    private _visualRows;
-    private _preferredColumn;
-    private _killBuffer;
-    private _scrollStart;
-    private _singleLineViewportStart;
-    private _drawn;
+    private readonly _preferredColumn;
+    private readonly _killBuffer;
+    private readonly _drawn;
+    private readonly _viewport;
     readonly multiline: boolean;
     constructor(options?: TextInputOptions);
     handleKey(event: KeyEvent): void;
+    handleFocus(event: WidgetFocusEvent): void;
+    private _edit;
     handleMouse(event: WidgetMouseEvent): void;
     setHovered(value: boolean): void;
     moveCharLeft(): void;
     moveCharRight(): void;
     moveLineUp(): void;
     moveLineDown(): void;
+    private _moveLine;
     private _clampColForRow;
-    private _cursorVisualRow;
-    private _cursorVisualCol;
     moveLineStart(): void;
     moveLineEnd(): void;
     moveDocStart(): void;
@@ -266,11 +256,14 @@ export declare class TextInput extends ThemedWidget {
     private _shown;
     private _shownCells;
     private _offsetAtShownCell;
+    private _singleLine;
+    private _showsPlaceholder;
     private _renderSingleLine;
     private _renderMultiline;
+    private _caret;
     private _drawsArrows;
     private _emitRowContent;
-    private _computeVisualRows;
+    private _rows;
     measure(options: RenderOptions): {
         minimum: number;
         maximum: number;
@@ -278,16 +271,19 @@ export declare class TextInput extends ThemedWidget {
     /**
      * `[X/Y]` scroll-position string when there's actually something to
      * 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;
-     * `BorderAccessory` names the widths where it has not.
+     * the total visual row count. Hand it a frame this field is drawn in — a
+     * `Panel`'s `bottomRightAccessory` function is handed its body's:
+     *
+     *   bottomRightAccessory: (body) => input.scrollIndicatorText(body)
+     *
+     * It counts the rows that frame laid out, read off the field's own cells, so
+     * it is right on the frame it labels however deep the field sits in it.
      *
      * Returns `undefined` when:
      *   - `scrollIndicator` is not `"indices"`, or
      *   - `maxRows` is unset, or total visual rows ≤ maxRows (nothing to
      *     scroll), or
-     *   - no render has happened yet (cache is empty).
+     *   - `frame` shows none of the field's rows (a width too narrow to draw it).
      */
-    get scrollIndicatorText(): string | undefined;
+    scrollIndicatorText(frame: readonly (readonly Segment[])[]): string | undefined;
 }