drawnui-react 0.1.0-preview.15 → 0.1.0-preview.17

package/dist/controls/SnappingLayout.d.ts

@@ -50,6 +50,8 @@ export declare abstract class SnappingLayout extends SkiaLayout {
     protected StopSnapAnimators(): void;
     /** C# SnappingLayout.Render: the transition state follows the position every frame. */
     Render(ctx: DrawingContext): void;
+    /** Hover waits while the content slides (C# InTransition) or follows a pan. */
+    MovesContent(): boolean;
     ClampOffset(x: number, y: number, rubber: boolean): SKPoint;
     /** C# GetContentOffsetBounds: the extent covered by the snap points. */
     protected BoundsFromSnapPoints(): SKRect;
@@ -59,6 +61,11 @@ export declare abstract class SnappingLayout extends SkiaLayout {
     protected FindNearestAnchorInternal(current: SKPoint, _velocity: SKPoint): SKPoint;
     /** The closest anchor lying in the direction of the velocity (dot product), else the origin. */
     SelectNextAnchor(origin: SKPoint, velocity: SKPoint): SKPoint;
+    /**
+     * Release speed, points per second along an axis, under which the snap ignores the velocity and goes to the nearest
+     * anchor by distance (C# SnapVelocityThreshold, drawnui-cross 6o): a finger held still before lifting is not a flick.
+     */
+    SnapVelocityThreshold: number;
     ScrollToNearestAnchor(location: SKPoint, velocity: SKPoint): void;
     get CanAnimate(): boolean;
     protected GetAutoVelocity(displacement: SKPoint): SKPoint;

package/dist/controls/SnappingLayout.js

@@ -80,9 +80,12 @@ export class SnappingLayout extends SkiaLayout {
     }
     /** C# SnappingLayout.Render: the transition state follows the position every frame. */
     Render(ctx) {
+        this.Superview?.Hover?.RegisterMover(this);
         super.Render(ctx);
         this.InTransition = !this.CheckTransitionEnded();
     }
+    /** Hover waits while the content slides (C# InTransition) or follows a pan. */
+    MovesContent() { return this.InTransition || this.IsUserPanning; }
     // ---- clamping ----
     ClampOffset(x, y, rubber) {
         const b = this.ContentOffsetBounds;
@@ -135,9 +138,17 @@ export class SnappingLayout extends SkiaLayout {
         }
         return origin;
     }
+    /**
+     * Release speed, points per second along an axis, under which the snap ignores the velocity and goes to the nearest
+     * anchor by distance (C# SnapVelocityThreshold, drawnui-cross 6o): a finger held still before lifting is not a flick.
+     */
+    SnapVelocityThreshold = 100;
     ScrollToNearestAnchor(location, velocity) {
         if (this.SnapPoints.length === 0)
             return;
+        if (Math.abs(velocity.X) < this.SnapVelocityThreshold || Math.abs(velocity.Y) < this.SnapVelocityThreshold) {
+            velocity = new SKPoint(Math.abs(velocity.X) < this.SnapVelocityThreshold ? 0 : velocity.X, Math.abs(velocity.Y) < this.SnapVelocityThreshold ? 0 : velocity.Y);
+        }
         const origin = this.FindNearestAnchorInternal(location, velocity);
         const target = this.SelectNextAnchor(origin, velocity);
         if (SnappingLayout.Dist(location, target) >= 0.5)

package/dist/core/Accessibility.d.ts

@@ -52,6 +52,12 @@ export declare const Aria: {
      * its current item, and the arrow keys move between its items.
      */
     readonly IsCompositeRole: (role?: string) => boolean;
+    /**
+     * Roles a user operates (C# Aria.IsInteractiveRole, as DrawnUi.Rust is_control_role): a node with one of them that
+     * cannot take input is read as disabled (aria-disabled). C# also lists listbox and scrollbar; here a listbox is an
+     * arrow-key group and groups are never disabled.
+     */
+    readonly IsInteractiveRole: (role?: string) => boolean;
 };
 /** One laid-out text line exposed for native selection (AccessibilityTextSelectable): CSS px relative to the node. */
 export interface AccessibilityTextLine {
@@ -64,6 +70,17 @@ export interface AccessibilityTextLine {
     FontWeight: number;
     FontSize: number;
 }
+/**
+ * The value of a range control (a slider, a progress bar): what a screen reader reads and adjusts (drawnui-cross 6c,
+ * C# AccessibilityValue): aria-valuenow / min / max, and aria-valuetext when Text is not empty ("65%", "20 – 80").
+ */
+export interface AccessibilityValue {
+    Now: number;
+    Min: number;
+    Max: number;
+    Step: number;
+    Text: string;
+}
 /** One entry of the accessibility snapshot (DrawnUi AccessibilityNode). Rect is CSS pixels relative to the canvas. */
 export interface AccessibilityNode {
     Id: number;
@@ -72,9 +89,13 @@ export interface AccessibilityNode {
     Role: string;
     Rect: SKRect;
     CanInteract: boolean;
+    /** A role a user operates (Aria.IsInteractiveRole) that cannot take input: aria-disabled, no tab stop. */
+    Disabled: boolean;
     IsPressed?: boolean;
     Live?: string;
     Source: SkiaControl;
+    /** A range control's value (aria-valuenow / min / max / valuetext); its name stays the app's label. */
+    Value?: AccessibilityValue;
     /** Real text lines rendered into the overlay so the browser can select / copy them (opt-in per control). */
     TextLines?: AccessibilityTextLine[];
 }

package/dist/core/Accessibility.js

@@ -26,6 +26,16 @@ export const Aria = {
         return role === "list" || role === "listbox" || role === "grid" || role === "toolbar" || role === "radiogroup"
             || role === "tablist" || role === "menu" || role === "menubar";
     },
+    /**
+     * Roles a user operates (C# Aria.IsInteractiveRole, as DrawnUi.Rust is_control_role): a node with one of them that
+     * cannot take input is read as disabled (aria-disabled). C# also lists listbox and scrollbar; here a listbox is an
+     * arrow-key group and groups are never disabled.
+     */
+    IsInteractiveRole(role) {
+        return role === "button" || role === "link" || role === "checkbox" || role === "radio" || role === "switch"
+            || role === "slider" || role === "spinbutton" || role === "textbox" || role === "searchbox" || role === "combobox"
+            || role === "option" || role === "tab" || role === "menuitem" || role === "menuitemcheckbox" || role === "menuitemradio";
+    },
 };
 const asLayout = (c) => ("ChildrenFactory" in c && "Split" in c ? c : undefined);
 const asScroll = (c) => ("ScrollToIndex" in c && "ViewportOffsetY" in c ? c : undefined);
@@ -70,6 +80,7 @@ export class SkiaAccessibilityManager {
         if (!node || !node.AccessibilityCanInteract)
             return false;
         node.OnAccessibilityActivated();
+        node.Superview?.AccessibilityManager.ForceRebuildOnNextFrame(); // a screen reader reads the new state right back
         return true;
     }
     /**
@@ -80,8 +91,10 @@ export class SkiaAccessibilityManager {
     static Key(node, key) {
         if (!node)
             return false;
-        if (node.CanReceiveGesture("Panning") && node.OnAccessibilityKey(key))
+        if (node.CanReceiveGesture("Panning") && node.OnAccessibilityKey(key)) {
+            node.Superview?.AccessibilityManager.ForceRebuildOnNextFrame(); // the new value is read right back, not a second later
             return true;
+        }
         return node.Superview?.AccessibilityManager.MoveInGroup(node, key) ?? false;
     }
     // ---- arrow-key groups (C# SkiaAccessibilityManager, "Arrow-key groups") ----
@@ -150,7 +163,7 @@ export class SkiaAccessibilityManager {
         const current = this.groupRequest?.Group === group ? this.groupRequest.Index : IndexOf(group, item);
         if (current < 0 || count < 1)
             return false;
-        const row = axis === "Both" ? RowLength(group, item) : 1;
+        const row = axis === "Both" ? RowLength(group) : 1;
         const vertical = axis !== "Horizontal";
         const page = () => PageSize(scroll, item, vertical) * row;
         let target, step;
@@ -245,7 +258,7 @@ export class SkiaAccessibilityManager {
             for (const cb of this.liveUpdated)
                 cb(node);
     }
-    ForceRebuildOnNextFrame() { this.lastRebuild = 0; this.dirty = true; }
+    ForceRebuildOnNextFrame() { this.lastRebuild = -Infinity; this.dirty = true; }
     Unregister(node) {
         if (this.nodes.delete(node)) {
             node.OnAccessibilityUnregistered();
@@ -282,7 +295,7 @@ export class SkiaAccessibilityManager {
     Rebuild(scale, canvasWidthPx, canvasHeightPx) {
         this.dirty = false;
         this.lastRebuild = performance.now();
-        const list = [];
+        let list = [];
         for (const n of this.nodes) {
             if (!n.Superview) {
                 this.nodes.delete(n);
@@ -301,12 +314,14 @@ export class SkiaAccessibilityManager {
             if (px.Right < -canvasWidthPx || px.Bottom < -canvasHeightPx || px.Left > 2 * canvasWidthPx || px.Top > 2 * canvasHeightPx)
                 continue;
             list.push({
-                Id: n.AccessibilityId, Label: n.AccessibilityLabel, Hint: n.AccessibilityHint, Role: n.AccessibilityRole,
+                Id: n.AccessibilityId, Label: n.AccessibilityLabel, Hint: n.AccessibilityHint, Role: n.AccessibilityRole, Value: n.AccessibilityValue,
                 Rect: new SKRect(px.Left / scale, px.Top / scale, px.Right / scale, px.Bottom / scale),
                 CanInteract: n.AccessibilityCanInteract, IsPressed: n.AccessibilityIsPressed, Live: n.AccessibilityLive, Source: n,
+                Disabled: !n.AccessibilityCanInteract && Aria.IsInteractiveRole(n.AccessibilityRole),
                 TextLines: n.AccessibilityTextSelectable ? n.GetAccessibilityTextLines(scale) : undefined,
             });
         }
+        list = SayNamesOnce(list);
         list.sort((a, b) => a.Rect.Top - b.Rect.Top || a.Rect.Left - b.Rect.Left);
         // reading order: nodes whose tops are within half the smaller height form one row, read left to right, so a row of
         // vertically centered controls of different heights keeps its visual order (C# RectComparer + LeftComparer)
@@ -334,8 +349,8 @@ export class SkiaAccessibilityManager {
             return false;
         for (let i = 0; i < a.length; i++) {
             const x = a[i], y = b[i];
-            if (x.Source !== y.Source || x.Label !== y.Label || x.Hint !== y.Hint || x.Role !== y.Role || x.CanInteract !== y.CanInteract
-                || x.IsPressed !== y.IsPressed || x.Live !== y.Live
+            if (x.Source !== y.Source || x.Label !== y.Label || x.Hint !== y.Hint || x.Role !== y.Role || x.CanInteract !== y.CanInteract || x.Disabled !== y.Disabled
+                || x.IsPressed !== y.IsPressed || x.Live !== y.Live || !SameValue(x.Value, y.Value)
                 || Math.abs(x.Rect.Left - y.Rect.Left) > 0.5 || Math.abs(x.Rect.Top - y.Rect.Top) > 0.5
                 || Math.abs(x.Rect.Right - y.Rect.Right) > 0.5 || Math.abs(x.Rect.Bottom - y.Rect.Bottom) > 0.5)
                 return false;
@@ -353,6 +368,33 @@ export class SkiaAccessibilityManager {
         return true;
     }
 }
+/**
+ * Each name is said once in the flat overlay (DrawnUi.Rust said_by_child): a text or a heading whose label repeats the
+ * label of the node it is in (its nearest ancestor node) is said by one of them. Under an interactive node (a card
+ * button) the child is left out, the button keeps its name; under any other node (a group card and its title) the
+ * node loses its name and the heading says it. Selectable text (TextLines) always stays.
+ */
+function SayNamesOnce(list) {
+    const bySource = new Map(list.map((x) => [x.Source, x]));
+    const said = new Set();
+    for (const x of list) {
+        if (!x.Label || x.TextLines || (x.Role !== Aria.RoleText && x.Role !== Aria.RoleHeading))
+            continue;
+        let owner;
+        for (let p = x.Source.Parent; p && !owner; p = p.Parent)
+            owner = bySource.get(p);
+        if (!owner || owner.Label !== x.Label)
+            continue;
+        if (owner.CanInteract)
+            said.add(x);
+        else
+            owner.Label = undefined;
+    }
+    return said.size ? list.filter((x) => !said.has(x)) : list;
+}
+function SameValue(a, b) {
+    return a === b || (!!a && !!b && a.Now === b.Now && a.Min === b.Min && a.Max === b.Max && a.Step === b.Step && a.Text === b.Text);
+}
 // ---- group helpers (duck-typed layouts and scrolls) ----
 /** Children of a control (a layout's Views, a scroll's Content). */
 function ViewsOf(c) {
@@ -383,11 +425,18 @@ function AxisOf(group) {
     return "Both";
 }
 /** Items per row of a 2D group: Split when set, else the items sharing the row of `item`. */
-function RowLength(group, item) {
+/**
+ * Items per row of a 2D group: the Split, else the items on the row of the group's first item. C# counts the focused
+ * item's row, which the short last row of a wrap leaves short (Up from it skipped items); DrawnUi.Rust afef66f.
+ */
+function RowLength(group) {
     const l = asLayout(group);
     if (l && l.Split > 1)
         return l.Split;
-    const top = item.GetAccessibilityPixelRect();
+    const first = ItemAt(group, 0) ?? FirstRealized(group);
+    if (!first)
+        return 1;
+    const top = first.GetAccessibilityPixelRect();
     if (top.Height <= 0)
         return 1;
     const mid = (top.Top + top.Bottom) / 2;
@@ -416,6 +465,14 @@ function ItemAt(group, index) {
     }
     return index >= 0 && index < ViewsOf(group).length ? ViewsOf(group)[index] : undefined;
 }
+/** The realized item with the lowest index (item 0 of a scrolled recycled group may not be realized). */
+function FirstRealized(group) {
+    let best;
+    for (const v of ViewsOf(group))
+        if (!best || IndexOf(group, v) < IndexOf(group, best))
+            best = v;
+    return best;
+}
 /** Arranged on the canvas: realized and laid out (a templated layout keeps only the cells it draws in use). */
 function IsDrawn(control) {
     const r = control.GetAccessibilityPixelRect();

package/dist/core/Animators.d.ts

@@ -18,11 +18,28 @@ export declare class AnimatorBase {
     StartFrameTimeNanos: number;
     OnStart?: () => void;
     OnStop?: () => void;
+    /** Paused: the canvas does not tick it and it wakes no frames; Resume goes on from where it was (C# Pause / Resume). */
+    IsPaused: boolean;
+    /** Paused by the canvas because its control is hidden; resumed when it shows again. */
+    PausedWhileHidden: boolean;
+    /**
+     * Frame time (ns) before which nothing it shows changes: the canvas does not tick it and it keeps no frames coming
+     * until then, a timer wakes the frame loop at that time (a GIF or a sprite between two frames; DrawnUi.Rust frame
+     * animators sleep between changes). 0 = tick every frame.
+     */
+    SleepUntilNanos: number;
     private delayHandle;
+    private delayEnd;
+    private delayLeft;
+    private pausedAt;
     constructor(parent: SkiaControl);
     protected Register(): boolean;
     protected Unregister(): void;
     Start(delayMs?: number): void;
+    /** Freezes the run (and what is left of a start delay); Resume goes on from there. */
+    Pause(): void;
+    /** Goes on from where Pause froze it: the paused time is not counted. */
+    Resume(): void;
     Stop(): void;
     /** Returns true when there is nothing more to do (not running / finished). */
     TickFrame(frameTimeNanos: number): boolean;
@@ -55,10 +72,20 @@ export declare class SkiaValueAnimator extends AnimatorBase {
     TickFrame(frameTimeNanos: number): boolean;
     /** Passed over mValue; subclasses derive their own reported value here. */
     protected TransformReportedValue(_deltaT: number): number;
-    /** Updates mValue from elapsed time; true when the target was reached. */
+    /**
+     * Updates mValue from elapsed time; true when the run is over. The eased value is not clamped to the range: a spring
+     * easing goes past its ends, and a run whose mMinValue is above mMaxValue (a ping-pong's way back) goes down.
+     */
     protected UpdateValue(_deltaT: number, deltaFromStart: number): boolean;
     protected FinishedRunning(): boolean;
 }
+/** DrawnUi PingPongAnimator: every repeat runs the other way (Repeat -1 = forever by default). */
+export declare class PingPongAnimator extends SkiaValueAnimator {
+    /** One way done, the next starts (C# CycleFInished). */
+    CycleFinished?: () => void;
+    constructor(parent: SkiaControl);
+    protected FinishedRunning(): boolean;
+}
 /** DrawnUi RenderingAnimator: a value animator that paints itself above its Parent (IOverlayEffect). */
 export declare class RenderingAnimator extends SkiaValueAnimator implements IOverlayEffect {
     constructor(parent: SkiaControl);

package/dist/core/Animators.js

@@ -16,7 +16,20 @@ export class AnimatorBase {
     StartFrameTimeNanos = 0;
     OnStart;
     OnStop;
+    /** Paused: the canvas does not tick it and it wakes no frames; Resume goes on from where it was (C# Pause / Resume). */
+    IsPaused = false;
+    /** Paused by the canvas because its control is hidden; resumed when it shows again. */
+    PausedWhileHidden = false;
+    /**
+     * Frame time (ns) before which nothing it shows changes: the canvas does not tick it and it keeps no frames coming
+     * until then, a timer wakes the frame loop at that time (a GIF or a sprite between two frames; DrawnUi.Rust frame
+     * animators sleep between changes). 0 = tick every frame.
+     */
+    SleepUntilNanos = 0;
     delayHandle = 0;
+    delayEnd = 0;
+    delayLeft = 0;
+    pausedAt = 0;
     constructor(parent) { this.Parent = parent; }
     Register() {
         const parent = this.Parent;
@@ -60,6 +73,8 @@ export class AnimatorBase {
             this.delayHandle = 0;
         }
         if (delayMs > 0) {
+            // the delay waits without frames
+            this.delayEnd = performance.now() + delayMs;
             this.delayHandle = window.setTimeout(() => { this.delayHandle = 0; this.Start(); }, delayMs);
             return;
         }
@@ -72,7 +87,43 @@ export class AnimatorBase {
             }
         }
     }
+    /** Freezes the run (and what is left of a start delay); Resume goes on from there. */
+    Pause() {
+        if (this.IsPaused)
+            return;
+        this.IsPaused = true;
+        this.pausedAt = performance.now();
+        if (this.delayHandle) {
+            clearTimeout(this.delayHandle);
+            this.delayHandle = 0;
+            this.delayLeft = Math.max(0, this.delayEnd - this.pausedAt);
+        }
+    }
+    /** Goes on from where Pause froze it: the paused time is not counted. */
+    Resume() {
+        if (!this.IsPaused)
+            return;
+        this.IsPaused = false;
+        const paused = (performance.now() - this.pausedAt) * 1_000_000;
+        if (this.StartFrameTimeNanos !== 0) {
+            this.StartFrameTimeNanos += paused;
+            this.LastFrameTimeNanos += paused;
+        }
+        if (this.SleepUntilNanos !== 0)
+            this.SleepUntilNanos += paused;
+        if (this.delayLeft > 0) {
+            const left = this.delayLeft;
+            this.delayLeft = 0;
+            this.Start(left);
+            return;
+        }
+        this.Parent?.Repaint(); // frames again
+    }
     Stop() {
+        this.IsPaused = false;
+        this.PausedWhileHidden = false;
+        this.SleepUntilNanos = 0;
+        this.delayLeft = 0;
         if (this.delayHandle) {
             clearTimeout(this.delayHandle);
             this.delayHandle = 0;
@@ -155,23 +206,21 @@ export class SkiaValueAnimator extends AnimatorBase {
     }
     /** Passed over mValue; subclasses derive their own reported value here. */
     TransformReportedValue(_deltaT) { return this.mValue; }
-    /** Updates mValue from elapsed time; true when the target was reached. */
+    /**
+     * Updates mValue from elapsed time; true when the run is over. The eased value is not clamped to the range: a spring
+     * easing goes past its ends, and a run whose mMinValue is above mMaxValue (a ping-pong's way back) goes down.
+     */
     UpdateValue(_deltaT, deltaFromStart) {
         const elapsedMs = deltaFromStart / 1_000_000;
         const progress = this.Speed > 0 ? elapsedMs / this.Speed : 1;
         const deltaValue = this.mMaxValue - this.mMinValue;
         const eased = this.Easing.Ease(Math.min(progress, 1));
         this.Progress = eased;
-        const value = deltaValue * eased + this.mMinValue;
-        if (value < this.mMinValue) {
-            this.mValue = this.mMinValue;
-            return false;
-        }
-        if (value >= this.mMaxValue || progress >= 1) {
+        if (progress >= 1) {
             this.mValue = this.mMaxValue;
             return true;
         }
-        this.mValue = value;
+        this.mValue = deltaValue * eased + this.mMinValue;
         return false;
     }
     FinishedRunning() {
@@ -188,6 +237,25 @@ export class SkiaValueAnimator extends AnimatorBase {
         return true;
     }
 }
+/** DrawnUi PingPongAnimator: every repeat runs the other way (Repeat -1 = forever by default). */
+export class PingPongAnimator extends SkiaValueAnimator {
+    /** One way done, the next starts (C# CycleFInished). */
+    CycleFinished;
+    constructor(parent) { super(parent); this.Repeat = -1; }
+    FinishedRunning() {
+        if (this.Repeat !== 0) {
+            this.CycleFinished?.();
+            if (this.Repeat > 0)
+                this.Repeat--;
+            [this.mMinValue, this.mMaxValue] = [this.mMaxValue, this.mMinValue];
+            this.mValue = this.mMinValue;
+            this.LastFrameTimeNanos = 0;
+            this.StartFrameTimeNanos = 0;
+            return false;
+        }
+        return super.FinishedRunning();
+    }
+}
 /** DrawnUi RenderingAnimator: a value animator that paints itself above its Parent (IOverlayEffect). */
 export class RenderingAnimator extends SkiaValueAnimator {
     constructor(parent) { super(parent); }

package/dist/core/Canvas.d.ts

@@ -2,6 +2,7 @@ import type { Surface } from "canvaskit-wasm";
 import type { DrawingContext, SkiaControl } from "./SkiaControl";
 import type { AnimatorBase } from "./Animators";
 import { SkiaAccessibilityManager } from "./Accessibility";
+import { HoverManager } from "./Hover";
 import { type Color, type RenderingModeType } from "./Types";
 import { ContextMenuEventArgs, type GesturesMode, SkiaGesturesParameters, TouchActionEventArgs } from "./Gestures";
 /**
@@ -14,6 +15,11 @@ export declare class Canvas {
     readonly Element: HTMLCanvasElement;
     /** Points a pointer may travel between Down and Up and still count as a tap (AppoMobi TouchEffect default). */
     static TappedCancelMoveThresholdPoints: number;
+    /**
+     * A press held this long without moving past TappedCancelMoveThresholdPoints is a LongPressing, at the press point
+     * (AppoMobi TouchEffect, DrawnUi.Rust LONG_PRESS_MS); its release sends no Tapped. A timer, no frames while waiting.
+     */
+    static LongPressTimeMs: number;
     BackgroundColor: Color;
     /** Accelerated = WebGL surface, Default = software. Read once at first frame. */
     RenderingMode: RenderingModeType;
@@ -37,6 +43,8 @@ export declare class Canvas {
     WasDrawn?: (sender: Canvas) => void;
     /** Registry + rate-limited snapshot of accessible controls, rendered by the DOM overlay (DrawnUi AccessibilityManager). */
     readonly AccessibilityManager: SkiaAccessibilityManager;
+    /** Mouse hover of the controls (drawnui-cross 6m): ReceivesHover / IsHovered / HoverChanged. */
+    readonly Hover: HoverManager;
     private content?;
     get Content(): SkiaControl | undefined;
     set Content(value: SkiaControl | undefined);
@@ -93,6 +101,10 @@ export declare class Canvas {
     UnregisterAnimator(uid: number): void;
     /** Ticks every registered animator once; returns how many ran. */
     protected ExecuteAnimators(frameTimeNanos: number): number;
+    private wakeTimer;
+    private wakeAtNanos;
+    /** One timer for the earliest sleeping animator: the frame loop wakes then, no frames run in between. */
+    private WakeAt;
     /** Frames drawn so far (SkiaBackdrop uses it to refresh once after a cached record). */
     FrameIndex: number;
     /**
@@ -126,6 +138,8 @@ export declare class Canvas {
     private readonly previousTouchArgs;
     private readonly pendingGestures;
     private readonly onPointer;
+    /** The mouse left the canvas: hover ends at once, also while content moves. */
+    private readonly onPointerLeave;
     private readonly preventTouch;
     /** Gestures="Enabled": touch / pen pointers whose Down a control used (see OnTouchAction). */
     private readonly claimedTouches;
@@ -138,10 +152,11 @@ export declare class Canvas {
     private cursorPointer;
     /**
      * DrawnUi.Blazor shows `cursor: pointer` over interactive controls through its overlay elements; here the overlay
-     * is pointer-events:none, so the mouse position is tested against the accessibility snapshot (the accessible
-     * controls' rects in points, already sorted and rate-limited), each hit control answering WantsPointerCursor
-     * (itself tappable, or a tappable span of a label), and the canvas element's cursor is switched only when the
-     * answer changes. Mouse moves only, no work without a mouse and none in the frame loop.
+     * is pointer-events:none, so the canvas decides from the hover hit path (Hover.Path: the controls under the mouse by
+     * the routing rules of ProcessGestures, so nothing below a popup that blocks gestures below): a control in the
+     * accessibility tree (it has a role) that answers WantsPointerCursor (itself tappable, or a tappable span of a label)
+     * shows the hand. A popup's close-on-background-tap wrapper has no role, so its backdrop shows none. The canvas
+     * element's cursor is switched only when the answer changes. Mouse moves only, none in the frame loop.
      */
     private UpdateCursor;
     /**
@@ -174,9 +189,16 @@ export declare class Canvas {
     private readonly UpdateTouchAction;
     private pageObserver?;
     private AttachInput;
+    /** The page's own overscroll-behavior before Lock set it to none (html, body), put back on detach. */
+    private pageOverscroll?;
     private DetachInput;
     /** Port of DrawnUi.Blazor Canvas.OnTouchAction: per-pointer state machine producing Down / Panning / Tapped / Up. */
     OnTouchAction(args: TouchActionEventArgs): void;
+    private readonly longPressTimers;
+    private readonly longPressed;
+    /** The long press of a new press: due LongPressTimeMs later unless the pointer moves away or lets go. */
+    private ArmLongPress;
+    private DisarmLongPress;
     private OnGestureEvent;
     private ProcessPendingGestures;
     /**