1681-engine 0.0.0-stage → 0.5.8

package/dist/types/ui/UiPointerGate.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Keeps a press on a canvas widget from also counting as a press in the world.
+ *
+ * Pixi's event system listens on the canvas in the capture phase, so it hit-tests the widgets and runs their
+ * `pointerdown` handlers before `Pointer`'s own listener on the same canvas sees the event. A widget marks the native
+ * event (`consume`), and the gate, chained into `Pointer.ignorePress`, tells `Pointer` to leave that press out. A
+ * game's own `ignorePress` keeps working: the gate asks it too.
+ */
+export declare const UiPointerGate: {
+    /** Marks a native event (a federated event's `nativeEvent`) as taken by the UI. */
+    consume(e: object | null | undefined): void;
+    /** Whether the UI took this native event (a game's own canvas listener may ask too). */
+    wasConsumed(e: object | null | undefined): boolean;
+    /** Chains the gate into `Pointer.ignorePress`; counted, so two UI roots install it once. Returns the uninstall. */
+    install(): () => void;
+};
+//# sourceMappingURL=UiPointerGate.d.ts.map

package/dist/types/ui/UiPointerGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UiPointerGate.d.ts","sourceRoot":"","sources":["../../../src/ui/UiPointerGate.ts"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;IACxB,mFAAmF;eACxE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAI3C,wFAAwF;mBACzE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO;IAIlD,mHAAmH;eACxG,MAAM,IAAI;CAiBtB,CAAC"}

package/dist/types/ui/UiRoot.d.ts

@@ -0,0 +1,73 @@
+import { Container } from 'pixi.js';
+import { Stage } from '../core/Stage.js';
+import { FocusManager, type NavBindings, type NavInput } from './FocusManager.js';
+import { type ScreenAnchor } from './layout/anchor.js';
+import type { Insets, Size } from './layout/geometry.js';
+import type { UiHost, UiTicking } from './UiHost.js';
+/** A window that takes the screen while it is open (a `Dialog`): laid out on resize, asked on Cancel. */
+export interface UiModal extends Container {
+    /** Lays itself out for the screen's size. */
+    layoutFor(viewport: Size): void;
+    /** Cancel pressed inside it; true when it used it (it closed). */
+    cancel(): boolean;
+}
+export interface UiRootOptions {
+    /** Lay out on whole pixels (default: the camera's `roundPixels`, which `pixelPerfect: true` turns on). */
+    pixelPerfect?: boolean;
+    /** The action names navigation reads (default `ui_up`, `ui_down`, … `ui_accept`, `ui_cancel`). */
+    bindings?: Partial<NavBindings>;
+    /**
+     * The container the root is added to (default the stage's screen layer). Give a scene's `hud` and the UI lives and
+     * dies with the scene: the scene destroys it on exit, its ticker listener and resize hook with it. On the screen
+     * layer it outlives the scene that made it until `destroy` is called.
+     */
+    parent?: Container;
+}
+/**
+ * The canvas UI's root, on the stage's screen layer above the world: it pins HUD pieces to screen corners and keeps
+ * them there on resize, owns keyboard/gamepad focus, ticks only the widgets that are moving, opens modals with a
+ * focus trap, and keeps presses on widgets from reaching the world (`UiPointerGate`).
+ *
+ * ```ts
+ * const ui = new UiRoot(engine.stage, { parent: scene.hud }); // goes when the scene does
+ * ui.pin(healthBar, 'top-left', 8);
+ * // in a fixed step, between actions.poll() and endStep():
+ * if (!ui.handleInput(actions) && !ui.capturesInput) movePlayer();
+ * ```
+ */
+export declare class UiRoot extends Container implements UiHost {
+    private readonly stage;
+    readonly isUiHost = true;
+    readonly pixelPerfect: boolean;
+    readonly focus: FocusManager;
+    private readonly pins;
+    private readonly moving;
+    private readonly modals;
+    private readonly cleanup;
+    private readonly ticker;
+    private readonly onTick;
+    constructor(stage: Stage, options?: UiRootOptions);
+    /** The screen's size in screen pixels. */
+    get viewport(): Size;
+    /** A modal is open or a widget has focus: the game should leave its own actions alone this step. */
+    get capturesInput(): boolean;
+    /** Adds `child` and keeps it pinned to a screen anchor, `margin` in from the edges, through every resize. */
+    pin(child: Container, anchor: ScreenAnchor, margin?: number | Partial<Insets>): this;
+    unpin(child: Container): this;
+    /** Places every pinned piece and open modal again (after one changed size; resizes do it by themselves). */
+    layout(): void;
+    /** Opens a modal over everything: focus is trapped inside it until it closes. */
+    openModal(modal: UiModal): void;
+    closeModal(modal: UiModal): void;
+    /** Reads one step of navigation input (call between `actions.poll()` and `endStep()`); true when the UI used it. */
+    handleInput(input: NavInput): boolean;
+    invalidateFocus(): void;
+    animate(t: UiTicking): void;
+    /** Ticks what is moving; called by the ticker, or by a game driving the UI itself. */
+    update(dtMs: number): void;
+    destroy(): void;
+    private place;
+    /** A ticker listener that throws never asks for the next frame: the UI's faults are caught and reported once. */
+    private guardedUpdate;
+}
+//# sourceMappingURL=UiRoot.d.ts.map

package/dist/types/ui/UiRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UiRoot.d.ts","sourceRoot":"","sources":["../../../src/ui/UiRoot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAe,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAe,YAAY,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC5F,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAIlD,yGAAyG;AACzG,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,6CAA6C;IAC7C,SAAS,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;IAChC,kEAAkE;IAClE,MAAM,IAAI,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,0GAA0G;IAC1G,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,kGAAkG;IAClG,QAAQ,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAChC;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAQD;;;;;;;;;;;GAWG;AACH,qBAAa,MAAO,SAAQ,SAAU,YAAW,MAAM;IAYnD,OAAO,CAAC,QAAQ,CAAC,KAAK;IAXxB,QAAQ,CAAC,QAAQ,QAAQ;IACzB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgD;gBAGpD,KAAK,EAAE,KAAK,EAC7B,OAAO,GAAE,aAAkB;IAY7B,0CAA0C;IAC1C,IAAI,QAAQ,IAAI,IAAI,CAEnB;IAED,oGAAoG;IACpG,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED,6GAA6G;IAC7G,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAK,GAAG,IAAI;IAUvF,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAM7B,4GAA4G;IAC5G,MAAM,IAAI,IAAI;IAUd,iFAAiF;IACjF,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAQ/B,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAQhC,oHAAoH;IACpH,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAIrC,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI;IAI3B,sFAAsF;IACtF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKjB,OAAO,IAAI,IAAI;IAWxB,OAAO,CAAC,KAAK;IAKb,iHAAiH;IACjH,OAAO,CAAC,aAAa;CAStB"}

package/dist/types/ui/Widget.d.ts

@@ -0,0 +1,56 @@
+import { Container } from 'pixi.js';
+import type { NavDirection } from './layout/focusNav.js';
+import { type Size } from './layout/geometry.js';
+import { type UiHost } from './UiHost.js';
+/**
+ * The base of every canvas widget: a Pixi container with a layout box (`boxWidth` × `boxHeight`, its own units, not
+ * its drawn bounds), an enabled and a focused state, and the hooks keyboard and gamepad navigation call.
+ *
+ * A widget is a Pixi `Container`, so Container's own members are taken names: in particular `label` (Pixi's debug
+ * name, a string) — a subclass field `label` holding a `Label` clashes with it; call it `caption`, `title`, … .
+ */
+export declare abstract class Widget extends Container {
+    /** Whether the focus manager may land on it (buttons, sliders, toggles). */
+    focusable: boolean;
+    protected boxW: number;
+    protected boxH: number;
+    private isEnabled;
+    private isFocused;
+    get boxWidth(): number;
+    get boxHeight(): number;
+    get enabled(): boolean;
+    set enabled(v: boolean);
+    get focused(): boolean;
+    /** Called by the focus manager. */
+    setFocused(v: boolean): void;
+    /** Resizes the layout box (whole pixels under a pixel-perfect root) and redraws. */
+    resize(width: number, height: number): this;
+    /** Moves it, on whole pixels under a pixel-perfect root. */
+    place(x: number, y: number): this;
+    /** Focusable now: enabled, shown, and every parent shown. */
+    canFocus(): boolean;
+    /** Accept pressed while focused (Enter, the pad's A). */
+    activate(): void;
+    /** A direction pressed while focused; true when the widget used it (a slider stepping) so focus stays. */
+    navigate(_dir: NavDirection): boolean;
+    /** The root it sits under, looked up when needed: a widget may be built before it is added. */
+    protected get host(): UiHost | null;
+    /**
+     * Hit-tested by Pixi, and every press on it is kept from the world. A widget whose drawing has gaps (a scroll
+     * view, an empty panel) also sets a `hitArea` over its box, so a press between its pieces is not the world's.
+     */
+    protected makeInteractive(): void;
+    /**
+     * A child widget's box changed size by itself (a `Label` given a longer text). A widget that places a child by its
+     * size (a `Button` centring its content) lays it out again here; the default does nothing, so a `Stack` still waits
+     * for its `layout()` and a change does not ripple up through every container.
+     */
+    protected childResized(_child: Widget): void;
+    /** Tells the parent widget this one's box changed size by itself. */
+    protected notifyResized(): void;
+    /** Draws the current size and state. */
+    protected abstract redraw(): void;
+}
+/** A child's layout size: a widget's box, anything else its drawn bounds. */
+export declare function sizeOf(c: Container): Size;
+//# sourceMappingURL=Widget.d.ts.map

package/dist/types/ui/Widget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Widget.d.ts","sourceRoot":"","sources":["../../../src/ui/Widget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAA8B,MAAM,SAAS,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAU,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAY,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAQjD;;;;;;GAMG;AACH,8BAAsB,MAAO,SAAQ,SAAS;IAC5C,4EAA4E;IAC5E,SAAS,UAAS;IAClB,SAAS,CAAC,IAAI,SAAK;IACnB,SAAS,CAAC,IAAI,SAAK;IACnB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,SAAS,CAAS;IAE1B,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,OAAO,CAAC,CAAC,EAAE,OAAO,EAMrB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,mCAAmC;IACnC,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI;IAM5B,oFAAoF;IACpF,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ3C,4DAA4D;IAC5D,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAMjC,6DAA6D;IAC7D,QAAQ,IAAI,OAAO;IAMnB,yDAAyD;IACzD,QAAQ,IAAI,IAAI;IAEhB,0GAA0G;IAC1G,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO;IAIrC,+FAA+F;IAC/F,SAAS,KAAK,IAAI,IAAI,MAAM,GAAG,IAAI,CAElC;IAED;;;OAGG;IACH,SAAS,CAAC,eAAe,IAAI,IAAI;IAKjC;;;;OAIG;IACH,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAE5C,qEAAqE;IACrE,SAAS,CAAC,aAAa,IAAI,IAAI;IAK/B,wCAAwC;IACxC,SAAS,CAAC,QAAQ,CAAC,MAAM,IAAI,IAAI;CAClC;AAED,6EAA6E;AAC7E,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAIzC"}

package/dist/types/ui/dom/DomOverlay.d.ts

@@ -0,0 +1,52 @@
+export interface DomOverlayOptions {
+    /** Added to the root element (for the game's CSS). */
+    className?: string;
+    /** Stacking order over the canvas (default 1). */
+    zIndex?: number;
+    /**
+     * The canvas's size in screen pixels (`() => app.screen`): when CSS stretches the canvas past it (a small fixed
+     * canvas scaled up), `cssScale` is how much, and world placement follows it. Default: no stretch.
+     */
+    logicalSize?: () => {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * The element a DOM (or React) UI is mounted in, laid exactly over the canvas and resized with it. It sits beside the
+ * canvas in the same parent, so it shares the canvas's positioned ancestor and needs no change to the page's CSS.
+ *
+ * The root lets presses through (`pointer-events: none`) so the world stays playable between panels; give what the
+ * player presses `pointer-events: auto` (`DomOverlay.interactive`). `content` is drawn at `scale` (a whole multiple
+ * for pixel-art UI): laid out on a box `1 / scale` the overlay and scaled back up, so a window sized for 320 × 180
+ * fills the screen at ×4 with sharp edges.
+ */
+export declare class DomOverlay {
+    readonly canvas: HTMLCanvasElement;
+    private readonly options;
+    readonly root: HTMLDivElement;
+    /** Where the UI goes: scaled by `scale`. */
+    readonly content: HTMLDivElement;
+    private scaleNow;
+    private cssW;
+    private cssH;
+    private stretch;
+    private readonly observer;
+    private readonly onWindow;
+    constructor(canvas: HTMLCanvasElement, options?: DomOverlayOptions);
+    /** Lets presses on `el` reach it (the overlay's root and content let them through to the canvas). */
+    static interactive(el: HTMLElement): HTMLElement;
+    /** The overlay's size in CSS pixels (the canvas's box). */
+    get width(): number;
+    get height(): number;
+    /** CSS pixels per screen pixel of the canvas: 1 unless CSS stretches it. */
+    get cssScale(): number;
+    get scale(): number;
+    /** Draws `content` at `scale` (also published as the CSS variable `--ui-scale`). */
+    setScale(scale: number): void;
+    /** Lines the overlay up with the canvas again; resizes do it by themselves. */
+    sync(): void;
+    destroy(): void;
+    private applySize;
+}
+//# sourceMappingURL=DomOverlay.d.ts.map

package/dist/types/ui/dom/DomOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomOverlay.d.ts","sourceRoot":"","sources":["../../../../src/ui/dom/DomOverlay.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACvD;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAU;IAYnB,QAAQ,CAAC,MAAM,EAAE,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZ1B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwB;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;gBAGnC,MAAM,EAAE,iBAAiB,EACjB,OAAO,GAAE,iBAAsB;IAiBlD,qGAAqG;IACrG,MAAM,CAAC,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,WAAW;IAKhD,2DAA2D;IAC3D,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,4EAA4E;IAC5E,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,oFAAoF;IACpF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM7B,+EAA+E;IAC/E,IAAI,IAAI,IAAI;IAiBZ,OAAO,IAAI,IAAI;IAMf,OAAO,CAAC,SAAS;CAQlB"}

package/dist/types/ui/dom/DomWorldAnchors.d.ts

@@ -0,0 +1,50 @@
+import { type Ticker } from 'pixi.js';
+import type { DomOverlay } from './DomOverlay.js';
+import { type LayerTransform } from './worldToScreen.js';
+export interface WorldAnchorOptions {
+    /** Moved this far after projecting (CSS px): a name 20 px over the feet. */
+    offsetX?: number;
+    offsetY?: number;
+    /**
+     * Which point of the element sits on the spot, as fractions of its size (default 0.5, 1: centred above it).
+     * Written as a CSS translate in percent, so the element is never measured.
+     */
+    alignX?: number;
+    alignY?: number;
+    /** Kept shown this far past the screen's edge (default 64 px), so a wide label does not pop out early. */
+    margin?: number;
+}
+/** Anything with a world position read every frame: an entity's position object, a sprite. */
+export interface WorldPoint {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * DOM elements that follow points in the world (names over heads, speech bubbles, markers): placed every frame
+ * through the world layer's own transform, on whole CSS pixels, and hidden off screen. A style is written only when
+ * the rounded position or visibility changed, so a still crowd costs no DOM writes.
+ */
+export declare class DomWorldAnchors {
+    private readonly overlay;
+    /** The layer the points are in: `engine.stage.world`. */
+    private readonly layer;
+    private readonly anchors;
+    private ticker;
+    private readonly onTick;
+    constructor(overlay: DomOverlay, 
+    /** The layer the points are in: `engine.stage.world`. */
+    layer: LayerTransform);
+    /** Places `el` (put inside the overlay's content if it is not already there) on `target`. Returns the remover. */
+    add(el: HTMLElement, target: WorldPoint, options?: WorldAnchorOptions): () => void;
+    remove(el: HTMLElement): void;
+    /**
+     * Runs `update` on `ticker` after Pixi renders (`UTILITY` priority), so it reads the camera as this frame drew it,
+     * shake included. The returned function stops it.
+     */
+    attach(ticker: Ticker): () => void;
+    detach(): void;
+    /** Places every element for this frame. */
+    update(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=DomWorldAnchors.d.ts.map

package/dist/types/ui/dom/DomWorldAnchors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomWorldAnchors.d.ts","sourceRoot":"","sources":["../../../../src/ui/dom/DomWorldAnchors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAA2B,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/E,MAAM,WAAW,kBAAkB;IACjC,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0GAA0G;IAC1G,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,8FAA8F;AAC9F,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAgBD;;;;GAIG;AACH,qBAAa,eAAe;IAMxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,yDAAyD;IACzD,OAAO,CAAC,QAAQ,CAAC,KAAK;IAPxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;gBAG3B,OAAO,EAAE,UAAU;IACpC,yDAAyD;IACxC,KAAK,EAAE,cAAc;IAGxC,kHAAkH;IAClH,GAAG,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,kBAAuB,GAAG,MAAM,IAAI;IAsBtF,MAAM,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAK7B;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI;IAOlC,MAAM,IAAI,IAAI;IAKd,2CAA2C;IAC3C,MAAM,IAAI,IAAI;IAqBd,OAAO,IAAI,IAAI;CAIhB"}

package/dist/types/ui/dom/InputShield.d.ts

@@ -0,0 +1,20 @@
+import { type ShieldOptions } from './shieldDecision.js';
+/**
+ * Keeps input meant for the DOM UI from reaching the engine. It listens on the overlay's root as events bubble out
+ * of it and stops the ones `shouldShield` names, so the element under them still gets them (a text field still
+ * types) but listeners on the window and document (`Keyboard`, a game's own) never hear them.
+ *
+ * Presses on the overlay never reach `Pointer` anyway, which counts presses only on the canvas; the shield covers
+ * keys, wheel and window-level listeners. Releases always pass, or a key held when a field took focus would stick.
+ */
+export declare class InputShield {
+    private readonly root;
+    private readonly options;
+    private readonly handler;
+    constructor(root: HTMLElement, options?: ShieldOptions);
+    /** Whether the player is typing in a field of the UI now (a game may also skip its hotkeys). */
+    get typing(): boolean;
+    destroy(): void;
+    private check;
+}
+//# sourceMappingURL=InputShield.d.ts.map

package/dist/types/ui/dom/InputShield.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputShield.d.ts","sourceRoot":"","sources":["../../../../src/ui/dom/InputShield.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAK1F;;;;;;;GAOG;AACH,qBAAa,WAAW;IAIpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;gBAGpC,IAAI,EAAE,WAAW,EACjB,OAAO,GAAE,aAAkB;IAK9C,gGAAgG;IAChG,IAAI,MAAM,IAAI,OAAO,CAGpB;IAED,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,KAAK;CAMd"}

package/dist/types/ui/dom/createStore.d.ts

@@ -0,0 +1,22 @@
+export type StoreListener<T> = (state: T, previous: T) => void;
+/**
+ * A tiny shared state store between the game and its UI, framework-free. Same shape as the engine's settings store
+ * and as zustand's vanilla stores (`getState`, `setState`, `subscribe`), so React reads it with
+ * `useSyncExternalStore(store.subscribe, store.getState)`.
+ */
+export interface Store<T extends object> {
+    getState(): T;
+    /**
+     * Merges a patch (or what a function of the state returns) into a new state object. A patch that changes nothing
+     * notifies nobody: a game may set the player's health every frame and the UI renders only when it moved.
+     */
+    setState(patch: Partial<T> | ((state: T) => Partial<T>)): void;
+    /** Calls `listener` after every change; the returned function unsubscribes. */
+    subscribe(listener: StoreListener<T>): () => void;
+    /** Calls `listener` only when `select(state)` changes (by `equals`, default `Object.is`). */
+    select<S>(select: (state: T) => S, listener: (value: S, previous: S) => void, equals?: (a: S, b: S) => boolean): () => void;
+    /** Back to the state it was made with. */
+    reset(): void;
+}
+export declare function createStore<T extends object>(initial: T): Store<T>;
+//# sourceMappingURL=createStore.d.ts.map

package/dist/types/ui/dom/createStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStore.d.ts","sourceRoot":"","sources":["../../../../src/ui/dom/createStore.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,IAAI,CAAC;AAE/D;;;;GAIG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,SAAS,MAAM;IACrC,QAAQ,IAAI,CAAC,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC/D,+EAA+E;IAC/E,SAAS,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC;IAClD,6FAA6F;IAC7F,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,IAAI,CAAC;IAC5H,0CAA0C;IAC1C,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CA6ClE"}

package/dist/types/ui/dom/shieldDecision.d.ts

@@ -0,0 +1,34 @@
+/** The few fields of a DOM element the decision reads; real elements fit, and tests pass plain objects. */
+export interface ElementLike {
+    readonly tagName?: string;
+    readonly type?: string;
+    readonly isContentEditable?: boolean;
+    readonly parentElement?: ElementLike | null;
+}
+/** Whether keys pressed on this element are typing (a text field, a text area, a select, editable content). */
+export declare function isEditable(el: ElementLike | null | undefined): boolean;
+/** Whether `el` is `root` or inside it. */
+export declare function isInside(el: ElementLike | null | undefined, root: ElementLike): boolean;
+export interface ShieldFacts {
+    /** The event's target is in the DOM UI overlay. */
+    insideUi: boolean;
+    /** The target takes typing (`isEditable`). */
+    editable: boolean;
+    /** `KeyboardEvent.code`, for key events. */
+    code?: string;
+}
+export interface ShieldOptions {
+    /**
+     * Keys a focused, non-typing UI element (a button) keeps from the game: the ones that press it (default Enter,
+     * Space). Others still reach the game, so a button left focused after a click does not stop the hero walking.
+     */
+    uiKeys?: readonly string[];
+}
+/**
+ * Whether an event on the DOM UI must be kept from the engine's input. Releases (`keyup`, `pointerup`,
+ * `pointercancel`) always go through, or a key or button held when the UI took over would stay down for good; moves
+ * go through so aiming follows the pointer over a panel. Presses, wheel and context menus on the UI stay in the UI,
+ * and so does every key typed into a field.
+ */
+export declare function shouldShield(type: string, facts: ShieldFacts, options?: ShieldOptions): boolean;
+//# sourceMappingURL=shieldDecision.d.ts.map

package/dist/types/ui/dom/shieldDecision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shieldDecision.d.ts","sourceRoot":"","sources":["../../../../src/ui/dom/shieldDecision.ts"],"names":[],"mappings":"AAAA,2GAA2G;AAC3G,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,aAAa,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CAC7C;AAKD,+GAA+G;AAC/G,wBAAgB,UAAU,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAMtE;AAED,2CAA2C;AAC3C,wBAAgB,QAAQ,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAGvF;AAED,MAAM,WAAW,WAAW;IAC1B,mDAAmD;IACnD,QAAQ,EAAE,OAAO,CAAC;IAClB,8CAA8C;IAC9C,QAAQ,EAAE,OAAO,CAAC;IAClB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAID;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAkBnG"}

package/dist/types/ui/dom/worldToScreen.d.ts

@@ -0,0 +1,24 @@
+/** A layer's transform as drawn: `stage.world` (a Pixi container) fits it, with the camera and its shake applied. */
+export interface LayerTransform {
+    readonly x: number;
+    readonly y: number;
+    readonly scale: {
+        readonly x: number;
+        readonly y: number;
+    };
+}
+/**
+ * Where a world point is on the overlay, in CSS pixels: through the world layer's own transform (so the camera's
+ * zoom, scroll and shake are all in it), times how much CSS stretches the canvas (`cssScale`, 1 normally). Writes
+ * into `out`: called for every placed element every frame.
+ */
+export declare function worldToScreen(layer: LayerTransform, wx: number, wy: number, out: {
+    x: number;
+    y: number;
+}, cssScale?: number): {
+    x: number;
+    y: number;
+};
+/** Whether a point is on a `width` × `height` screen, or within `margin` of it (an element's own size past the point). */
+export declare function onScreen(x: number, y: number, width: number, height: number, margin?: number): boolean;
+//# sourceMappingURL=worldToScreen.d.ts.map

package/dist/types/ui/dom/worldToScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldToScreen.d.ts","sourceRoot":"","sources":["../../../../src/ui/dom/worldToScreen.ts"],"names":[],"mappings":"AAAA,qHAAqH;AACrH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,QAAQ,SAAI,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAIlJ;AAED,0HAA0H;AAC1H,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,OAAO,CAEjG"}

package/dist/types/ui/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 1681 Engine's UI module (`1681-engine/ui`): canvas widgets drawn with Pixi on the stage's screen layer, a
+ * bridge for a UI written in the DOM or React over the canvas, and the pure layout maths both use. A game that
+ * draws no UI through the engine never ships it.
+ */
+export { insets, snapPx, snapRect, clamp, type Size, type Point, type Rect, type Insets } from './layout/geometry.js';
+export { stackLayout, type StackOptions, type StackResult, type StackDirection, type StackAlign } from './layout/stack.js';
+export { anchorPosition, type ScreenAnchor } from './layout/anchor.js';
+export { fitToViewport, type FitOptions, type FitResult } from './layout/fitToViewport.js';
+export { placeTooltip, type TooltipOptions, type TooltipPlacement, type TipSide } from './layout/placeTooltip.js';
+export { wrapRow } from './layout/wrapRow.js';
+export { listWidth, type ListWidthOptions } from './layout/listWidth.js';
+export { maxScroll, clampScroll, scrollIntoView, stepFling, FLING_STOP } from './layout/scroll.js';
+export { quantize, sliderFraction, sliderValueAt } from './layout/slider.js';
+export { drainState, setDrainValue, stepDrain, type DrainState, type DrainOptions } from './layout/barDrain.js';
+export { nextFocus, firstFocus, linearFocus, type NavDirection } from './layout/focusNav.js';
+export { UiRoot, type UiRootOptions, type UiModal } from './UiRoot.js';
+export { uiHostOf, type UiHost, type UiTicking } from './UiHost.js';
+export { UiPointerGate } from './UiPointerGate.js';
+export { FocusManager, DEFAULT_NAV, type NavBindings, type NavInput } from './FocusManager.js';
+export { Widget, sizeOf } from './Widget.js';
+export { Panel, type PanelSkin, type TextureSkin, type ColourSkin, type PanelOptions } from './Panel.js';
+export { Label, type LabelText } from './Label.js';
+export { Button, type ButtonOptions, type ButtonSkin, type ButtonState } from './Button.js';
+export { Bar, type BarOptions } from './Bar.js';
+export { Slider, type SliderOptions } from './Slider.js';
+export { Toggle, type ToggleOptions } from './Toggle.js';
+export { Stack } from './Stack.js';
+export { ScrollView, type ScrollViewOptions } from './ScrollView.js';
+export { List, type ListOptions } from './List.js';
+export { Dialog, type DialogOptions } from './Dialog.js';
+export { DomOverlay, type DomOverlayOptions } from './dom/DomOverlay.js';
+export { DomWorldAnchors, type WorldAnchorOptions, type WorldPoint } from './dom/DomWorldAnchors.js';
+export { worldToScreen, onScreen, type LayerTransform } from './dom/worldToScreen.js';
+export { createStore, type Store, type StoreListener } from './dom/createStore.js';
+export { InputShield } from './dom/InputShield.js';
+export { shouldShield, isEditable, isInside, type ShieldFacts, type ShieldOptions, type ElementLike } from './dom/shieldDecision.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ui/index.ts"],"names":[],"mappings":"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"}

package/dist/types/ui/layout/anchor.d.ts

@@ -0,0 +1,9 @@
+import { type Insets, type Point, type Size } from './geometry.js';
+/** A spot on the screen a HUD piece is pinned to; it stays there whatever the screen's size. */
+export type ScreenAnchor = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right';
+/**
+ * Top-left of a box of `size` pinned to `anchor` of the viewport, `margin` in from the edges (a number, or per side
+ * for a phone's notch). Centred anchors ignore the margins of the sides they do not touch.
+ */
+export declare function anchorPosition(anchor: ScreenAnchor, size: Size, viewport: Size, margin?: number | Partial<Insets>, snap?: boolean): Point;
+//# sourceMappingURL=anchor.d.ts.map

package/dist/types/ui/layout/anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.d.ts","sourceRoot":"","sources":["../../../../src/ui/layout/anchor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,MAAM,EAAE,KAAK,KAAK,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAEhF,gGAAgG;AAChG,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,KAAK,GAAG,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,aAAa,GAAG,QAAQ,GAAG,cAAc,CAAC;AAetI;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAK,EAAE,IAAI,UAAQ,GAAG,KAAK,CAM1I"}

package/dist/types/ui/layout/barDrain.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A bar's two lengths: what it holds now (`value`) and the trail behind it (`trail`) that drains down to it after a
+ * short hold, so a hit shows how much it took. Fractions 0–1. Mutated in place: a health bar is set every frame.
+ */
+export interface DrainState {
+    value: number;
+    trail: number;
+    /** What is left of the hold before the trail starts to drain (ms). */
+    holdMs: number;
+}
+export interface DrainOptions {
+    /** How long the trail holds after a loss before draining (default 400 ms). */
+    delayMs?: number;
+    /** How fast it drains, in whole bars a second (default 0.6). */
+    rate?: number;
+}
+export declare function drainState(value?: number): DrainState;
+/**
+ * Sets the bar. A loss restarts the hold, so blows in quick succession show one trail for all of them; a gain fills
+ * at once and pulls the trail up with it (a heal has nothing to show behind it).
+ */
+export declare function setDrainValue(state: DrainState, value: number, options?: DrainOptions): void;
+/** Advances the trail by a frame `dtMs` long. */
+export declare function stepDrain(state: DrainState, dtMs: number, options?: DrainOptions): void;
+//# sourceMappingURL=barDrain.d.ts.map

package/dist/types/ui/layout/barDrain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"barDrain.d.ts","sourceRoot":"","sources":["../../../../src/ui/layout/barDrain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,UAAU,CAAC,KAAK,SAAI,GAAG,UAAU,CAEhD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,IAAI,CAKhG;AAED,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,IAAI,CAa3F"}

package/dist/types/ui/layout/fitToViewport.d.ts

@@ -0,0 +1,32 @@
+import { type Rect, type Size } from './geometry.js';
+export interface FitOptions {
+    /** Kept clear between the window and the screen's edges (default 8). */
+    margin?: number;
+    /**
+     * The scale the window is meant to be drawn at (default 1): a player's "window size" setting, or a whole multiple
+     * for pixel art. The window is laid out on a box `1 / scale` the screen and drawn back at `scale`.
+     */
+    scale?: number;
+    /**
+     * The smallest scale it may shrink to before it starts scrolling instead (default: `scale`, never shrinks). A
+     * pixel-art game keeps it at its whole scale: a fractional one smears every texel.
+     */
+    minScale?: number;
+    /** Centre it on the screen instead of keeping `rect.x/y` (default false). */
+    centre?: boolean;
+    snap?: boolean;
+}
+export interface FitResult extends Rect {
+    /** The scale to draw the window at; `x`, `y` are screen pixels, `width`, `height` the window's own units. */
+    scale: number;
+    /** The window was cut shorter (narrower) than it wanted: its body must scroll. */
+    scrollY: boolean;
+    scrollX: boolean;
+}
+/**
+ * Fits a window into the screen so it never overflows it: shrunk down to `minScale` if that is allowed, then cut to
+ * what is left (the caller scrolls its body), and moved back inside the edges. `rect` is where and how big the
+ * window wants to be, in its own units; `x`, `y` are screen pixels.
+ */
+export declare function fitToViewport(rect: Rect | Size, viewport: Size, options?: FitOptions): FitResult;
+//# sourceMappingURL=fitToViewport.d.ts.map

package/dist/types/ui/layout/fitToViewport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitToViewport.d.ts","sourceRoot":"","sources":["../../../../src/ui/layout/fitToViewport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,IAAI,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,WAAW,UAAU;IACzB,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,SAAU,SAAQ,IAAI;IACrC,6GAA6G;IAC7G,KAAK,EAAE,MAAM,CAAC;IACd,kFAAkF;IAClF,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,CA2BpG"}

package/dist/types/ui/layout/focusNav.d.ts

@@ -0,0 +1,13 @@
+import type { Rect } from './geometry.js';
+export type NavDirection = 'up' | 'down' | 'left' | 'right';
+/** The item a fresh focus lands on: the top-most, then left-most. */
+export declare function firstFocus(rects: readonly Rect[]): number;
+/**
+ * Spatial navigation (a gamepad's d-pad, the arrow keys): from `current`, the nearest item whose centre lies in
+ * `dir`, an item straight ahead preferred over a nearer one off to the side. With `wrap`, going past the last item
+ * comes back in from the far side on the same line. Returns `current` when nothing lies that way.
+ */
+export declare function nextFocus(rects: readonly Rect[], current: number, dir: NavDirection, wrap?: boolean): number;
+/** Tab order: the next (`step` 1) or previous (−1) of `count` items, wrapping round. */
+export declare function linearFocus(count: number, current: number, step: 1 | -1): number;
+//# sourceMappingURL=focusNav.d.ts.map

package/dist/types/ui/layout/focusNav.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focusNav.d.ts","sourceRoot":"","sources":["../../../../src/ui/layout/focusNav.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAa5D,qEAAqE;AACrE,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,MAAM,CAQzD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,UAAQ,GAAG,MAAM,CAkC1G;AAED,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAIhF"}

package/dist/types/ui/layout/geometry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The shapes every UI layout function speaks: plain objects, no Pixi and no DOM, so the same maths places a canvas
+ * widget, a DOM panel or a React component.
+ */
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Rect extends Point, Size {
+}
+/** Space kept clear on each side (padding, margins, a phone's safe area). */
+export interface Insets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/** `8` or `{ top: 8, left: 4 }` → all four sides; a missing side is 0. */
+export declare function insets(v: number | Partial<Insets> | undefined): Insets;
+/**
+ * Rounds to a whole pixel when `on`. Pixel art laid out at x.5 lands each texel across two screen pixels and reads
+ * blurred or a pixel wider on one side, so a pixel-perfect game snaps every UI position and size.
+ */
+export declare function snapPx(v: number, on?: boolean): number;
+/**
+ * A rect with its edges (not its size) rounded: two neighbours that touch before snapping still touch after, where
+ * rounding x and width apart could open or overlap a pixel between them.
+ */
+export declare function snapRect(r: Rect, on?: boolean): Rect;
+export declare function clamp(v: number, min: number, max: number): number;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/types/ui/layout/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../../../src/ui/layout/geometry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,IAAK,SAAQ,KAAK,EAAE,IAAI;CAAG;AAE5C,6EAA6E;AAC7E,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,0EAA0E;AAC1E,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,GAAG,MAAM,CAItE;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,UAAO,GAAG,MAAM,CAEnD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,UAAO,GAAG,IAAI,CAKjD;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjE"}

package/dist/types/ui/layout/listWidth.d.ts

@@ -0,0 +1,13 @@
+export interface ListWidthOptions {
+    /** Added to the longest label: the row's padding, a check mark, a scroll bar (default 0). */
+    padding?: number;
+    min?: number;
+    max?: number;
+}
+/**
+ * How wide a drop-down list (or a menu) must be so its longest label fits: measured, not guessed, so no label is
+ * clipped. `measure` is the caller's (a canvas `measureText`, a bitmap font's advance sum). Rounded up to a whole
+ * pixel so the measurement never loses the last half pixel of a letter.
+ */
+export declare function listWidth(labels: readonly string[], measure: (label: string) => number, options?: ListWidthOptions): number;
+//# sourceMappingURL=listWidth.d.ts.map

package/dist/types/ui/layout/listWidth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listWidth.d.ts","sourceRoot":"","sources":["../../../../src/ui/layout/listWidth.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,6FAA6F;IAC7F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,MAAM,CAK/H"}