@promptctl/rich-js 0.28.0 → 0.29.0

package/dist/widgets/index.d.ts

@@ -1,10 +1,10 @@
 export type { KeyHandlerPriority, KeyHandlerOptions, WidgetMouseEvent, WidgetFocusEvent, InteractiveWidget, OverlayRenderable, FocusManager, } from "./types.js";
-export { hasOverlay, KeyEvent } from "./types.js";
+export { hasOverlay, WidgetKeyEvent } from "./types.js";
 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, WidgetPresence } from "./widget-app.js";
+export type { WidgetAppOptions, WidgetVisibility } from "./widget-app.js";
 export { Button } from "./button.js";
 export type { ButtonVariant, ButtonOptions } from "./button.js";
 export { Checkbox } from "./checkbox.js";

package/dist/widgets/index.js

@@ -1,4 +1,4 @@
-export { hasOverlay, KeyEvent } from "./types.js";
+export { hasOverlay, WidgetKeyEvent } from "./types.js";
 export { StaticItem } from "./static-item.js";
 export { WidgetBase } from "./widget-base.js";
 export { WidgetApp } from "./widget-app.js";

package/dist/widgets/ink.d.ts

@@ -1,8 +1,8 @@
 /**
- * ink — the colour pair a widget cell is drawn in: a foreground and the ground
+ * ink — the color pair a widget cell is drawn in: a foreground and the ground
  * it stands on, both from one theme's palette.
  *
- * A palette's colours are chosen against that palette's own background. A
+ * A palette's colors are chosen against that palette's own background. A
  * foreground drawn over whatever the terminal shows is readable only when the
  * terminal happens to match the theme — the default theme's white text
  * vanished into a light terminal. With both halves taken from the palette, a
@@ -12,7 +12,7 @@
  * [LAW:types-are-the-program] There is no call that takes a foreground alone,
  * so a widget cannot draw half a pair.
  * [LAW:single-enforcer] Every widget resolves palette roles here, and this is
- * where one that draws no colour (a theme's fully transparent "no background")
+ * where one that draws no color (a theme's fully transparent "no background")
  * is reported.
  */
 import { ColorSpec, type TerminalTheme } from "../core/color.js";

package/dist/widgets/ink.js

@@ -1,8 +1,8 @@
 /**
- * ink — the colour pair a widget cell is drawn in: a foreground and the ground
+ * ink — the color pair a widget cell is drawn in: a foreground and the ground
  * it stands on, both from one theme's palette.
  *
- * A palette's colours are chosen against that palette's own background. A
+ * A palette's colors are chosen against that palette's own background. A
  * foreground drawn over whatever the terminal shows is readable only when the
  * terminal happens to match the theme — the default theme's white text
  * vanished into a light terminal. With both halves taken from the palette, a
@@ -12,7 +12,7 @@
  * [LAW:types-are-the-program] There is no call that takes a foreground alone,
  * so a widget cannot draw half a pair.
  * [LAW:single-enforcer] Every widget resolves palette roles here, and this is
- * where one that draws no colour (a theme's fully transparent "no background")
+ * where one that draws no color (a theme's fully transparent "no background")
  * is reported.
  */
 import { ColorSpec } from "../core/color.js";
@@ -22,7 +22,7 @@ export function ink(theme, fg, bg) {
 function paletteColor(theme, role) {
     const rgba = theme.palette.get(role);
     if (rgba.alpha === 0) {
-        throw new RangeError(`palette ${JSON.stringify(theme.palette.name)}: ${JSON.stringify(role)} is fully transparent, so it cannot be half of a widget's colour pair`);
+        throw new RangeError(`palette ${JSON.stringify(theme.palette.name)}: ${JSON.stringify(role)} is fully transparent, so it cannot be half of a widget's color pair`);
     }
     return ColorSpec.fromRgba(rgba);
 }

package/dist/widgets/slider.d.ts

@@ -21,7 +21,7 @@ import { Segment } from "../core/segment.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 { WidgetKeyEvent, WidgetMouseEvent } from "./types.js";
 export interface SliderOptions {
     value?: number;
     min?: number;
@@ -42,7 +42,7 @@ export declare class Slider extends ThemedWidget {
     accessor width: number;
     private accessor _dragging;
     constructor(options?: SliderOptions);
-    handleKey(event: KeyEvent): void;
+    handleKey(event: WidgetKeyEvent): void;
     handleMouse(event: WidgetMouseEvent): void;
     private setValue;
     private setValueFromMouseX;

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

@@ -13,7 +13,7 @@
 import { Segment } from "../core/segment.js";
 import type { Measurable, Renderable, RenderOptions } from "../core/protocol.js";
 import { WidgetBase } from "./widget-base.js";
-import type { KeyEvent } from "./types.js";
+import type { WidgetKeyEvent } from "./types.js";
 export interface StaticItemOptions {
     id: string;
     render: Renderable | ((options: RenderOptions) => Iterable<Segment>);
@@ -25,7 +25,7 @@ export declare class StaticItem extends WidgetBase {
     private readonly body;
     private readonly measureFn;
     constructor(options: StaticItemOptions);
-    handleKey(_event: KeyEvent): void;
+    handleKey(_event: WidgetKeyEvent): void;
     protected draw(options: RenderOptions): Iterable<Segment>;
     measure(options: RenderOptions): {
         minimum: number;

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, WidgetFocusEvent, WidgetMouseEvent } from "./types.js";
+import type { WidgetKeyEvent, 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
@@ -222,7 +222,7 @@ export declare class TextInput extends ThemedWidget {
     private readonly _viewport;
     readonly multiline: boolean;
     constructor(options?: TextInputOptions);
-    handleKey(event: KeyEvent): void;
+    handleKey(event: WidgetKeyEvent): void;
     handleFocus(event: WidgetFocusEvent): void;
     private _edit;
     handleMouse(event: WidgetMouseEvent): void;

package/dist/widgets/text-input.js

@@ -105,7 +105,7 @@ import { afterPass, drawable, render } from "../core/protocol.js";
 import { State } from "../core/state.js";
 import { Viewport } from "../renderables/viewport.js";
 import { Animation } from "../core/animation.js";
-import { beat } from "../core/easing.js";
+import { stepSequence } from "../core/easing.js";
 import { Timeline } from "../core/timeline.js";
 import { placed } from "../core/animation.js";
 import { levelOf } from "../core/anchor.js";
@@ -243,7 +243,7 @@ function wordSpan(clusters, skipped, taken) {
  * second, so the caret is solid the moment the field is touched, then dark
  * for the next, on a `beat`. A loop, so with its motion taken out it holds lit.
  */
-const CARET_BLINK = Animation.map(beat([0.5, 0.5]), (hold) => hold === 0);
+const CARET_BLINK = Animation.map(stepSequence([0.5, 0.5]), (validity) => validity === 0);
 /**
  * The caret's blink restarted at `from`, as one animation of the frame's
  * time: `CARET_BLINK` run forward from `from` at and after it, and backward
@@ -257,8 +257,8 @@ function caretBlink(from) {
     const backward = Timeline.run(Timeline.play(from, -1), CARET_BLINK);
     return Animation.of({
         at: (t) => (t >= from ? forward : backward).at(t),
-        nextChange: (t) => (t >= from ? forward.nextChange(t) : Math.min(backward.nextChange(t), from)),
-        lastChange: (t) => (t >= from ? Math.max(forward.lastChange(t), from) : backward.lastChange(t)),
+        validUntil: (t) => (t >= from ? forward.validUntil(t) : Math.min(backward.validUntil(t), from)),
+        validFrom: (t) => (t >= from ? Math.max(forward.validFrom(t), from) : backward.validFrom(t)),
         reduced: () => CARET_BLINK.reduced(),
     });
 }
@@ -1111,7 +1111,7 @@ let TextInput = (() => {
         // next flips, which is when a host draws again. A print, drawn for no
         // moment, draws it at 0 like any placed animation. Lit, the cell is the
         // cursor's; dark, it is drawn as the text around it, since the cursor is a
-        // colour pair and no attribute hides it.
+        // color pair and no attribute hides it.
         _caret(at, cursorStyle, contentStyle, options) {
             return placed(this._blink, options, (lit) => [new Segment(at, lit ? cursorStyle : contentStyle)]);
         }

package/dist/widgets/themed-widget.js

@@ -65,7 +65,7 @@ let ThemedWidget = (() => {
         }
         #theme_accessor_storage = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _theme_initializers, void 0));
         // [LAW:types-are-the-program] @observableRef so setTheme() triggers a
-        // re-render: every draw reads its colours through this reference.
+        // re-render: every draw reads its colors through this reference.
         get theme() { return this.#theme_accessor_storage; }
         set theme(value) { this.#theme_accessor_storage = value; }
         constructor(theme) {

package/dist/widgets/toggle.d.ts

@@ -1,5 +1,5 @@
 /**
- * Toggle widget — on/off switch with label and variant colour.
+ * Toggle widget — on/off switch with label and variant color.
  * [LAW:dataflow-not-control-flow] one Segment of fixed width every render;
  * indicator and palette keys come from observable state via lookup tables.
  * [LAW:one-type-per-behavior] shared infrastructure inherited from WidgetBase.
@@ -14,7 +14,7 @@ import { Segment } from "../core/segment.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 { WidgetKeyEvent, WidgetMouseEvent } from "./types.js";
 export type ToggleVariant = "default" | "primary" | "success" | "warning" | "danger";
 export interface ToggleOptions {
     label: string;
@@ -31,7 +31,7 @@ export declare class Toggle extends ThemedWidget {
     accessor on: boolean;
     accessor variant: ToggleVariant;
     constructor(options: ToggleOptions);
-    handleKey(event: KeyEvent): void;
+    handleKey(event: WidgetKeyEvent): void;
     handleMouse(event: WidgetMouseEvent): void;
     protected draw(options: RenderOptions): Iterable<Segment>;
     measure(_options: RenderOptions): {

package/dist/widgets/toggle.js

@@ -1,5 +1,5 @@
 /**
- * Toggle widget — on/off switch with label and variant colour.
+ * Toggle widget — on/off switch with label and variant color.
  * [LAW:dataflow-not-control-flow] one Segment of fixed width every render;
  * indicator and palette keys come from observable state via lookup tables.
  * [LAW:one-type-per-behavior] shared infrastructure inherited from WidgetBase.
@@ -44,7 +44,7 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
-import { labelled } from "../core/orient.js";
+import { labeled } from "../core/orient.js";
 import { action } from "mobx";
 import { observableRef } from "./observable.js";
 import { Style } from "../core/style.js";
@@ -140,7 +140,7 @@ let Toggle = (() => {
         draw(options) {
             // Both indicators are exactly 5 cells: "[ON] " and "[OFF]".
             const indicator = this.on ? "[ON] " : "[OFF]";
-            const drawn = (style) => labelled(`${indicator} `, this.label, "", style, options.textOrder);
+            const drawn = (style) => labeled(`${indicator} `, this.label, "", style, options.textOrder);
             if (this.disabled) {
                 return drawn(new Style(this.disabledInk));
             }

package/dist/widgets/types.d.ts

@@ -9,8 +9,8 @@ import type { HostFrame, Renderable, Measurable, RenderOptions } from "../core/p
 import type { Segment } from "../core/segment.js";
 import type { Anchor } from "../core/anchor.js";
 import type { Unsubscribe } from "../core/subscription.js";
-import type { KeyPress, ScreenMouseEvent } from "../host/input.js";
-export declare class KeyEvent implements KeyPress {
+import type { KeyEvent, TerminalMouseEvent } from "../host/input.js";
+export declare class WidgetKeyEvent implements KeyEvent {
     readonly key: string;
     readonly character: string;
     readonly shift: boolean;
@@ -18,7 +18,7 @@ export declare class KeyEvent implements KeyPress {
     readonly meta: boolean;
     readonly time: number;
     private _stopped;
-    constructor(init: KeyPress, time: number);
+    constructor(init: KeyEvent, time: number);
     get stopped(): boolean;
     stop(): void;
 }
@@ -26,7 +26,7 @@ export type KeyHandlerPriority = "high" | "normal";
 export interface KeyHandlerOptions {
     priority?: KeyHandlerPriority;
 }
-export type WidgetMouseEvent = Extract<ScreenMouseEvent, {
+export type WidgetMouseEvent = Extract<TerminalMouseEvent, {
     type: "mouse_down" | "mouse_up" | "mouse_move";
 }> & {
     readonly over: boolean;
@@ -44,7 +44,7 @@ export interface InteractiveWidget extends Renderable, Measurable {
     hovered: boolean;
     active: boolean;
     disabled: boolean;
-    handleKey(event: KeyEvent): void;
+    handleKey(event: WidgetKeyEvent): void;
     handleMouse(event: WidgetMouseEvent): void;
     handleFocus(event: WidgetFocusEvent): void;
     focus(time: number): void;
@@ -65,7 +65,7 @@ export interface FocusManager {
     next(): void;
     prev(): void;
     focus(widget: InteractiveWidget): void;
-    handleKey(event: KeyEvent): void;
+    handleKey(event: WidgetKeyEvent): void;
     onChange(handler: (current: InteractiveWidget | null) => void): Unsubscribe;
 }
 export interface FrameSource {

package/dist/widgets/types.js

@@ -10,14 +10,14 @@
 // the frame's cells are read on (`RenderOptions.frame`), so a widget
 // keeping the moment of its last interaction — a caret's blink restarting —
 // compares it with the frame it draws and never reads a clock.
-// [LAW:types-are-the-program] KeyEvent is a `KeyPress` the app heard, plus
+// [LAW:types-are-the-program] WidgetKeyEvent is a `KeyEvent` the app heard, plus
 // when it was heard and the say over who else hears it. It carries a single mutable signal
 // (`stopped`) that participants in the dispatch chain set by calling
 // `stop()`. Treating it as an interface would force every handler to
 // shuttle a return value upward and the router to interpret it — the
 // class collapses that into one self-describing value flowing through
 // the chain.
-export class KeyEvent {
+export class WidgetKeyEvent {
     key;
     character;
     shift;

package/dist/widgets/widget-app.d.ts

@@ -8,7 +8,7 @@
  * reads the frame the view drew:
  *
  * - Focus moves in document order: the order the view reports its widgets in
- *   (`RenderOptions.onPresent`), among those with a cell on the frame on screen.
+ *   (`RenderOptions.onVisibility`), among those with a cell on the frame on screen.
  *   A widget its container hands no column is reported held, not drawn: it is
  *   in the view, so it keeps focus, and it has no cell, so Tab passes it.
  *   Not reading order — in a `Layout` split into columns, reading order
@@ -26,12 +26,12 @@
  * hear the input.
  */
 import { Segment } from "../core/segment.js";
-import type { HostFrame, FrameHost, Presence } from "../core/protocol.js";
+import type { HostFrame, FrameHost, Visibility } from "../core/protocol.js";
 import type { Unsubscribe } from "../core/subscription.js";
 import type { Clock, FrameRate } from "../core/clock.js";
 import type { Timeline } from "../core/timeline.js";
-import { type AppOptions, type AppPhase, type Wheel } from "../host/app.js";
-import type { FocusManager, FrameSource, KeyEvent, KeyHandlerOptions } from "./types.js";
+import { type AppOptions, type AppPhase, type WheelEvent } from "../host/app.js";
+import type { FocusManager, FrameSource, WidgetKeyEvent, KeyHandlerOptions } from "./types.js";
 import type { AppMouseEvent } from "../host/app.js";
 import { WidgetBase } from "./widget-base.js";
 export interface WidgetAppOptions extends AppOptions {
@@ -42,9 +42,9 @@ export interface WidgetAppOptions extends AppOptions {
     readonly focusOnClick?: boolean;
 }
 /** A widget the view reported for a frame, and whether it was drawn or held. */
-export interface WidgetPresence {
+export interface WidgetVisibility {
     readonly widget: WidgetBase;
-    readonly presence: Presence;
+    readonly visibility: Visibility;
 }
 export declare class WidgetApp implements FrameSource, FrameHost {
     readonly focusManager: FocusManager;
@@ -65,10 +65,10 @@ export declare class WidgetApp implements FrameSource, FrameHost {
     set rate(rate: FrameRate);
     /**
      * The widgets the view reported for the frame on screen, in document order,
-     * each drawn or held (`RenderOptions.onPresent`). A held widget is one its
+     * each drawn or held (`RenderOptions.onVisibility`). A held widget is one its
      * container handed no column: in the view, with no cell on the frame.
      */
-    get present(): readonly WidgetPresence[];
+    get mounted(): readonly WidgetVisibility[];
     private get widgets();
     /** The rows on screen now, as painted: what a pointer event lands on. */
     get frame(): readonly (readonly Segment[])[];
@@ -93,7 +93,7 @@ export declare class WidgetApp implements FrameSource, FrameHost {
      * `normal` one after it — and after Tab has moved focus — and a handler
      * that calls `event.stop()` ends the key there.
      */
-    onKey(handler: (event: KeyEvent) => void, options?: KeyHandlerOptions): Unsubscribe;
+    onKey(handler: (event: WidgetKeyEvent) => void, options?: KeyHandlerOptions): Unsubscribe;
     /** Hear every pointer event but the vertical wheel, in terminal cells, before any widget does. */
     onMouse(handler: (event: AppMouseEvent) => void): Unsubscribe;
     /**
@@ -101,6 +101,6 @@ export declare class WidgetApp implements FrameSource, FrameHost {
      * `handler`, as `App.onWheel` does: it returns whether it moved something,
      * and a turn nothing moved with is passed outward.
      */
-    onWheel(handler: (wheel: Wheel) => boolean): Unsubscribe;
+    onWheel(handler: (wheel: WheelEvent) => boolean): Unsubscribe;
     private compose;
 }

package/dist/widgets/widget-app.js

@@ -8,7 +8,7 @@
  * reads the frame the view drew:
  *
  * - Focus moves in document order: the order the view reports its widgets in
- *   (`RenderOptions.onPresent`), among those with a cell on the frame on screen.
+ *   (`RenderOptions.onVisibility`), among those with a cell on the frame on screen.
  *   A widget its container hands no column is reported held, not drawn: it is
  *   in the view, so it keeps focus, and it has no cell, so Tab passes it.
  *   Not reading order — in a `Layout` split into columns, reading order
@@ -60,7 +60,7 @@ export class WidgetApp {
             },
         });
         this.focus = new DefaultFocusManager({
-            present: () => this.widgets,
+            mounted: () => this.widgets,
             onScreen: () => {
                 const owners = ownersOn(this.app.frame);
                 return this.widgets.filter((widget) => owners.has(widget));
@@ -105,10 +105,10 @@ export class WidgetApp {
     }
     /**
      * The widgets the view reported for the frame on screen, in document order,
-     * each drawn or held (`RenderOptions.onPresent`). A held widget is one its
+     * each drawn or held (`RenderOptions.onVisibility`). A held widget is one its
      * container handed no column: in the view, with no cell on the frame.
      */
-    get present() {
+    get mounted() {
         return this._present;
     }
     get widgets() {
@@ -180,9 +180,9 @@ export class WidgetApp {
         const present = new Map();
         // [LAW:parse-dont-validate] What the view reports is any renderable; only
         // a `WidgetBase` is a widget, so this is where a renderable becomes one.
-        const onPresent = (renderable, presence) => {
+        const onVisibility = (renderable, visibility) => {
             if (renderable instanceof WidgetBase)
-                present.set(renderable, present.get(renderable) === "drawn" ? "drawn" : presence);
+                present.set(renderable, present.get(renderable) === "visible" ? "visible" : visibility);
         };
         // The view, its render and the overlays are all tracked, so an observable
         // any of them reads — a label, `focused`, the state that picks what the
@@ -190,14 +190,14 @@ export class WidgetApp {
         // An overlay reports what it draws too: a widget in it is in the view,
         // and visiting `present` in report order paints its overlay in turn. A
         // held widget has no footprint on the frame, and so paints none.
-        const drawing = { ...options, onPresent };
+        const drawing = { ...options, onVisibility };
         const lines = tracked(this.reaction, () => {
             const base = Segment.splitLines(render(view, drawing));
             for (const widget of present.keys())
                 paintOverlay(base, widget, drawing);
             return base;
         });
-        this._present = [...present].map(([widget, presence]) => ({ widget, presence }));
+        this._present = [...present].map(([widget, visibility]) => ({ widget, visibility }));
         return lines.flatMap((line) => [...line, Segment.line()]);
     }
 }

package/dist/widgets/widget-base.d.ts

@@ -10,7 +10,7 @@
 import { Segment } from "../core/segment.js";
 import { type Style } from "../core/style.js";
 import type { RenderOptions } from "../core/protocol.js";
-import type { InteractiveWidget, KeyEvent, WidgetMouseEvent, WidgetFocusEvent } from "./types.js";
+import type { InteractiveWidget, WidgetKeyEvent, WidgetMouseEvent, WidgetFocusEvent } from "./types.js";
 import type { Unsubscribe } from "../core/subscription.js";
 export declare abstract class WidgetBase implements InteractiveWidget {
     abstract readonly id: string;
@@ -21,7 +21,7 @@ export declare abstract class WidgetBase implements InteractiveWidget {
     accessor disabled: boolean;
     private readonly changeHandlers;
     private readonly submitHandlers;
-    abstract handleKey(event: KeyEvent): void;
+    abstract handleKey(event: WidgetKeyEvent): void;
     handleMouse(_event: WidgetMouseEvent): void;
     handleFocus(event: WidgetFocusEvent): void;
     focus(time: number): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptctl/rich-js",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Rich text and beautiful formatting in the terminal — a TypeScript port of Python's Rich",
   "repository": {
     "type": "git",