@typecad/ui 0.1.0-alpha.1

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

@@ -0,0 +1,241 @@
+import { HostAdafruitGFX } from "./host-gfx.js";
+import type { PreviewPinControlSpec, PreviewSnapshot } from "./types.js";
+type ScreenElementProxy = {
+    value: number;
+    text?: string;
+    onClick(): void;
+    onHold(): void;
+    onRelease(): void;
+};
+type ScreenProxy = Record<string, ScreenElementProxy>;
+interface RuntimeOptions {
+    onFrame?: (rgba: Uint8ClampedArray) => void;
+    onDiagnostics?: (message: string) => void;
+}
+export declare class PreviewUIRuntime {
+    private readonly snapshot;
+    readonly gfx: HostAdafruitGFX;
+    readonly screen: ScreenProxy;
+    private readonly nodes;
+    private readonly transitions;
+    private readonly keyframeSets;
+    private readonly animations;
+    private readonly fontAssets;
+    private readonly imageAssets;
+    private readonly bindings;
+    private readonly listStates;
+    private readonly callbacks;
+    private readonly pinControls;
+    private readonly canvasBindings;
+    private readonly intervals;
+    private readonly initialAssignments;
+    /** Module-scoped `let`/`const`/`var` bindings, seeded once and shared (mutably)
+     * across every callback body — mirrors the device hoisting them to globals. */
+    private readonly moduleScope;
+    /** Names declared via `const X = ui.signal(...)` — lowered to plain device
+     *  variables on hardware, so the preview stores the bare value (not the `ui`
+     *  facade's getter) and rewrites `X()`/`X.set(v)` reads/writes accordingly
+     *  (see normalizeScript). Mirrors ir/transformers/variables.ts + ui-callback-
+     *  lowering.ts so template interpolations and callbacks see the same slot. */
+    private readonly signalNames;
+    private readonly onFrame?;
+    private readonly onDiagnostics?;
+    private readonly screenCount;
+    private readonly timers;
+    private activeScreen;
+    private touchState;
+    private touchNode;
+    tapSeq: number;
+    tapNode: number;
+    private readonly pinLevels;
+    private touchDownTime;
+    private lastTouchTime;
+    private lastReleaseTime;
+    private lastTickTime;
+    private dragStartX;
+    private dragStartY;
+    private lastTouchX;
+    private lastTouchY;
+    private isDragging;
+    private scrollNode;
+    private settleStartMs;
+    private settleFromOverscroll;
+    private settleFromScrollY;
+    private rangeNode;
+    private keyboardVisible;
+    private keyboardDirty;
+    private keyboardTarget;
+    private keyboardKeys;
+    private keyboardRows;
+    private keyboardCols;
+    private keyboardBg;
+    private keyboardBox;
+    private keyboardBuffer;
+    private keyboardMaxLen;
+    private keyboardShift;
+    private keyboardBackspaceHeld;
+    private keyboardBackspaceRepeat;
+    private keyboardPressedKey;
+    private keyboardRepaintKey;
+    private directFrameChanged;
+    private readonly scrollDragScale;
+    constructor(snapshot: PreviewSnapshot, options?: RuntimeOptions);
+    start(): void;
+    /** Drive a GPIO level for a watched pin and synchronously fire the watch
+     *  callback on a HIGH→LOW edge. Test hook so edge behavior is deterministic
+     *  without wall-clock waits; the real ~20ms poller in start() shares this
+     *  path. Mirrors the device's falling-edge contract. */
+    setPinLevel(pin: string, level: 0 | 1): void;
+    private pollWatchPin;
+    stop(): void;
+    tick(deltaMs?: number): void;
+    pointerDown(x: number, y: number): void;
+    pointerMove(x: number, y: number): void;
+    pointerUp(): void;
+    triggerPin(control: PreviewPinControlSpec): void;
+    private createScreenProxy;
+    private applyInitialAssignments;
+    /** Seed module-scoped variables from their initializers, evaluated once. These
+     * live for the lifetime of the runtime and are shared mutably with callback
+     * bodies via runBody/evaluateExpression (see moduleVarNames()). */
+    private seedModuleScope;
+    private moduleVarNames;
+    private uiInit;
+    private isActiveNode;
+    private isEffectivelyVisible;
+    private drawsBefore;
+    private compareDrawOrder;
+    private navigate;
+    private evaluateBindings;
+    private refreshListState;
+    private advanceTransitions;
+    private scrollMotionActive;
+    private keyframeSetHasScrollSensitiveGeometry;
+    private advanceAnimations;
+    private drawYForNode;
+    private baseDrawXForNode;
+    private baseDrawYForNode;
+    private scrollAncestorForNode;
+    private pressedOffsetXForNode;
+    private pressedOffsetYForNode;
+    private drawXForNode;
+    private parentClearColor;
+    private clearPressOffsetArea;
+    private shadowExtents;
+    private rotationQuadrant;
+    private canUseQuarterTurnBounds;
+    private rotatedFaceSize;
+    private activeDrawClip;
+    private intersectRect;
+    private drawImageWithFit;
+    private drawImageNode;
+    private nodePaintRect;
+    private currentPaintRect;
+    private currentSubtreePaintRect;
+    private rectsIntersect;
+    private markOverlappingHigherLayersDirty;
+    private markOverlappingHigherLayersDirtyForRect;
+    private repairCurrentNodePaintWithParent;
+    private clearNodePaintRect;
+    private clearCurrentNodePaint;
+    private tryRepairGeometryFill;
+    private clearCurrentSubtreePaint;
+    private setVisible;
+    private scrollClipForNode;
+    private rectIntersectsClip;
+    private intersectClipRect;
+    private clearDirtyScrollViewports;
+    private drawScrollbars;
+    private nodeTextSize;
+    private fontAsset;
+    private fontGlyph;
+    private fontAlpha;
+    private textWidth;
+    private textHeight;
+    private textLineHeight;
+    private textWhiteSpace;
+    private textLayout;
+    private clipTextToWidth;
+    private truncateEllipsis;
+    private drawAssetText;
+    private drawText;
+    private drawGradientFill;
+    private drawNodeShadow;
+    private drawRectOutline;
+    private drawClosedRoundRect;
+    private drawNodeBorder;
+    private drawNodeOutline;
+    private markScrollDescendantsDirtyLocal;
+    private markScrollDescendantsDirty;
+    private markScrollViewDirty;
+    private invalidateScrollCanvasForNode;
+    private drawDirty;
+    private lineX;
+    private textInsets;
+    private drawTextLines;
+    private drawRichNode;
+    private richLinkHit;
+    private drawTextNode;
+    private listStateForNode;
+    private shiftListViewport;
+    private drawListRows;
+    private drawListNode;
+    private drawCanvasNode;
+    /** Lower a canvas drawBody (`ctx.X(...)` source) against the host gfx.
+     *  Mirrors the device ctx→ui_display_* rewrite so preview and device match.
+     *  Coordinates are translated to the node origin (ox, oy). Only the flat call
+     *  sequence is supported — same constraint as bindList item expressions. */
+    private runCanvasBody;
+    private drawButtonNode;
+    private drawCheckNode;
+    private drawRadioNode;
+    private drawProgressNode;
+    private drawRangeNode;
+    private drawInputNode;
+    private hitTest;
+    private findScrollNode;
+    private hasAnyHandler;
+    private updateRangeValue;
+    private smoothDragDelta;
+    private scrollMax;
+    private overscrollFor;
+    private applyScrollDelta;
+    private releaseScroll;
+    private advanceScrollSettle;
+    private dispatchListTap;
+    private handleTouch;
+    private handleNoTouch;
+    private dispatchBuiltInClick;
+    private keyboardTemplateForNode;
+    private keyboardOpen;
+    private keyboardClose;
+    private keyboardComputeBox;
+    private keyboardKeyRect;
+    private keyboardHandleTouch;
+    private keyboardHandleTap;
+    private keyboardInsert;
+    private keyboardDelete;
+    private keyboardTick;
+    private keyboardSwapPage;
+    private keyboardLabel;
+    private drawKeyboardTextRow;
+    private drawKeyboardKey;
+    private drawKeyboard;
+    private dispatch;
+    private setPressed;
+    private uiOnPress;
+    private uiOnRelease;
+    private markDirty;
+    private scriptTreeNames;
+    private normalizeScript;
+    /** 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. */
+    private rewriteSignalAccesses;
+    private scriptValues;
+    private listLocal;
+    private evaluateExpression;
+    private runBody;
+    private createUiFacade;
+}
+export {};