@typecad/ui 1.0.0-alpha.12 → 1.0.0-alpha.13

package/dist/preview/host-ui-runtime.d.ts

@@ -12,6 +12,11 @@ interface RuntimeOptions {
     onFrame?: (rgba: Uint8ClampedArray) => void;
     onDiagnostics?: (message: string) => void;
 }
+/** Linear color lerp at the ACTIVE depth (module runtimeColorFormat): 888
+ *  targets lerp per 8-bit channel; 565 targets lerp per 5/6-bit channel
+ *  (device parity — the C++ ui_lerp macro switches the same way). Exported
+ *  for tests. */
+export declare function lerpColor(a: number, b: number, k100: number): number;
 export declare class PreviewUIRuntime {
     private readonly snapshot;
     readonly gfx: HostAdafruitGFX;
@@ -63,6 +68,10 @@ export declare class PreviewUIRuntime {
     private settleFromScrollY;
     private rangeNode;
     private keyboardVisible;
+    /** Modal <select> option list: node index while open, -1 when closed. */
+    private selectMenuNode;
+    /** True while the select modal overlay needs (re)stamping this frame. */
+    private selectMenuDirty;
     private keyboardDirty;
     private keyboardTarget;
     private keyboardKeys;
@@ -92,6 +101,11 @@ export declare class PreviewUIRuntime {
     pointerDown(x: number, y: number): void;
     pointerMove(x: number, y: number): void;
     pointerUp(): void;
+    /** Mouse-wheel scroll: a discrete delta applied to the scroll owner under
+     *  (x, y) — the same hit-scan a drag uses, without the gesture state
+     *  machine. Wheel-down (positive deltaPx) shows later content; any
+     *  overscroll from the tick bounces back via the standard settle. */
+    wheel(x: number, y: number, deltaPx: number): void;
     triggerPin(control: PreviewPinControlSpec): void;
     private createScreenProxy;
     private applyInitialAssignments;
@@ -103,6 +117,12 @@ export declare class PreviewUIRuntime {
     private uiInit;
     private isActiveNode;
     private isEffectivelyVisible;
+    /** Effective stacking z, CSS-style: a non-zero zIndex raises the node AND
+     *  its subtree — a z-raised panel forms a stacking context, so its
+     *  descendants stack WITH it (above lower-z siblings), never
+     *  independently UNDER it (a flat (z, index) sort painted a dialog card
+     *  over its own children). 0 = "auto" — keep walking ancestors. */
+    private stackingZ;
     private drawsBefore;
     private compareDrawOrder;
     private navigate;
@@ -141,6 +161,12 @@ export declare class PreviewUIRuntime {
     private tryRepairGeometryFill;
     private clearCurrentSubtreePaint;
     private setVisible;
+    private subtreeFlowExtent;
+    private shiftSubtreeMain;
+    private restackFlowContainer;
+    private reflowScrollContent;
+    private reflowAfterVisibility;
+    private classifyDirtyAgainstOpenDrawers;
     private scrollClipForNode;
     private rectIntersectsClip;
     private intersectClipRect;
@@ -170,6 +196,43 @@ export declare class PreviewUIRuntime {
     private markScrollViewDirty;
     private invalidateScrollCanvasForNode;
     private drawDirty;
+    /** Enable/disable per-frame debug geometry capture (the client overlay
+     *  reads it; zero cost while off). */
+    setDebugCapture(on: boolean): void;
+    /** Current-frame debug geometry for the client overlay: every visible node
+     *  on the active screen at its CURRENT draw position (transform/press/
+     *  drawer/scroll offsets applied), the scroll viewport clips, and the
+     *  regions painted this tick (dirty-flash). Coordinates are logical
+     *  display pixels, matching the app canvas 1:1. */
+    debugInfo(): {
+        nodes: Array<{
+            i: number;
+            id?: string;
+            tag: string;
+            kind: string;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            tappable: boolean;
+        }>;
+        clips: Array<{
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        }>;
+        painted: Array<{
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        }>;
+    };
+    /** Inspect-on-tap: topmost node (draw order) whose CURRENT draw box
+     *  contains the point — unlike hitTest, containers count too. Returns the
+     *  index, or -1. */
+    debugHit(tx: number, ty: number): number;
     private lineX;
     private textInsets;
     private drawTextLines;
@@ -208,6 +271,54 @@ export declare class PreviewUIRuntime {
     private handleNoTouch;
     private dispatchBuiltInClick;
     private keyboardTemplateForNode;
+    /** node index -> { open, progress } for every <drawer>; absent = closed. */
+    private readonly drawerStates;
+    /** True while the client wants per-frame debug geometry + paint rects. */
+    private debugCapture;
+    /** Node paint rects drawn during this tick (cleared at tick start). */
+    private debugPaintedRects;
+    /** Drawer animation step per tick (~180ms full slide). */
+    /** <toast> auto-close windows, keyed by drawer slot node index. */
+    private readonly toastElapsed;
+    private applyDrawers;
+    private drawerNodeById;
+    private drawerOpen;
+    private drawerClose;
+    /** Slide extent for a drawer or toast: the panel must clear the display
+     *  edge completely — its own height parks a bottom:0 panel's top row at
+     *  the fold (a visible sliver after close). Centered dialogs don't slide. */
+    private drawerExtent;
+    /** Apply a slide progress to the drawer subtree: offsets shift from the
+     *  edge; the subtree is hidden at 0. Erases the previous frame's region via
+     *  the standard subtree clear + marks descendants dirty (same contract as
+     *  animated transform changes). */
+    private setDrawerProgress;
+    /** True while the node sits inside a fully-closed drawer (skip in draws and
+     *  hit tests). Drawers with no state entry are closed. */
+    private insideClosedDrawer;
+    /** Walk ancestors: any drawer ancestor without an open/animating state. */
+    private drawerAncestorClosed;
+    /** Apply the closed slide offsets to every drawer subtree (initial seed and
+     *  post-navigate reset) so closed drawers never paint at rest position. */
+    private seedDrawersClosed;
+    /** Shared geometry of the select modal: a centered list panel sized to
+     *  the options (capped to ~60% of the screen height). Rows are option
+     *  text, the current one inverted (fill = select bg, text = inverted). */
+    private selectMenuGeometry;
+    private openSelectMenu;
+    /** Close the modal. When `repaint`, mark the whole tree dirty so the
+     *  overlay is erased by a full redraw (navigate() clears the screen
+     *  itself, so it passes false). */
+    private closeSelectMenu;
+    /** Stamp the modal overlay on top of the current framebuffer. Idempotent
+     *  per frame — the close path full-repaints beneath it. */
+    private drawSelectMenu;
+    /** Panel fill: the select's effective background, falling back to a
+     *  near-black card on unstyled selects. */
+    private selectMenuPanelColor;
+    /** Route a tap while the modal is open: a row selects + closes; anything
+     *  else just closes (dismiss on outside tap). */
+    private selectMenuHandleTouch;
     private keyboardOpen;
     private keyboardClose;
     private keyboardComputeBox;
@@ -229,6 +340,10 @@ export declare class PreviewUIRuntime {
     private markDirty;
     private scriptTreeNames;
     private normalizeScript;
+    /** Apply `re` to code segments only: skip '..'/".." literal contents, and
+     *  inside `..` templates recurse into ${...} interpolations (their
+     *  expressions are code; the literal text between them is not). */
+    private rewriteOutsideLiterals;
     /** Rewrite signal getter/setter syntax to plain variable reads/writes. See
      *  normalizeScript for the lowering contract; this is the preview counterpart
      *  of ui-callback-lowering.ts's rules 2 and 3. */