drawnui-react 0.1.0-preview.1

package/dist/controls/SnappingLayout.js

@@ -0,0 +1,217 @@
+import { SKPoint } from "../core/Gestures";
+import { Easing } from "../core/Easing";
+import { SkiaValueAnimator } from "../core/Animators";
+import { Spring, SpringWithVelocityAnimator, RubberBandUtils, VelocityAccumulator } from "../core/ScrollAnimators";
+import { SKRect } from "../core/Types";
+import { SkiaLayout } from "./SkiaLayout";
+/**
+ * Mirrors DrawnUi SnappingLayout: a layout whose content position snaps to `SnapPoints` (points). Base of
+ * SkiaCarousel and SkiaDrawer: nearest/next anchor selection by velocity, spring (Bounces) or linear snap
+ * animation, rubber-band clamping, `Scrolled` / `TransitionChanged` / `Stopped` callbacks.
+ */
+export class SnappingLayout extends SkiaLayout {
+    Animated = true;
+    RespondsToGestures = true;
+    IgnoreWrongDirection = false;
+    Bounces = false;
+    RubberDamping = 0.7;
+    AutoVelocityMultiplyPts = 25;
+    RubberEffect = 0.15;
+    /** Fraction of a snap step a drag must cover before it counts as a direction (C# SnapDistanceRatio). */
+    SnapDistanceRatio = 0.2;
+    SnapPoints = [];
+    /** Current content offset, points (C# CurrentPosition). */
+    CurrentPosition = SKPoint.Empty;
+    /** Anchor the content rests on or travels to (C# CurrentSnap). */
+    CurrentSnap = new SKPoint(-1, -1);
+    ContentOffsetBounds = SKRect.Empty;
+    IsUserPanning = false;
+    IsUserFocused = false;
+    Scrolled;
+    TransitionChanged;
+    Stopped;
+    inTransition = false;
+    get InTransition() { return this.inTransition; }
+    set InTransition(v) { if (this.inTransition !== v) {
+        this.inTransition = v;
+        this.OnTransitionChanged();
+    } }
+    OnTransitionChanged() { this.TransitionChanged?.(this, this.inTransition); }
+    velocityAccumulator = new VelocityAccumulator();
+    springX = new SpringWithVelocityAnimator(this);
+    springY = new SpringWithVelocityAnimator(this);
+    range = new SkiaValueAnimator(this);
+    rangeFrom = SKPoint.Empty;
+    rangeTo = SKPoint.Empty;
+    /** Easing of the linear (non-bouncing) snap. */
+    SnapEasing = Easing.CubicInOut;
+    constructor() {
+        super();
+        this.Type = "Absolute";
+        this.springX.OnUpdated = (v) => this.ApplyPosition(new SKPoint(v, this.CurrentPosition.Y));
+        this.springY.OnUpdated = (v) => this.ApplyPosition(new SKPoint(this.CurrentPosition.X, v));
+        this.springX.OnStop = this.springY.OnStop = () => { if (!this.springX.IsRunning && !this.springY.IsRunning)
+            this.OnAnimationStopped(); };
+        this.range.mMinValue = 0;
+        this.range.mMaxValue = 1;
+        this.range.OnUpdated = (t) => this.ApplyPosition(new SKPoint(this.rangeFrom.X + (this.rangeTo.X - this.rangeFrom.X) * t, this.rangeFrom.Y + (this.rangeTo.Y - this.rangeFrom.Y) * t));
+        this.range.OnStop = () => this.OnAnimationStopped();
+    }
+    stoppingSilently = false;
+    OnAnimationStopped() {
+        if (this.stoppingSilently)
+            return; // interrupted / restarted: not a finished transition
+        this.InTransition = !this.CheckTransitionEnded();
+        this.UpdateReportedPosition(); // subclasses gate reporting on InTransition: report the settled state now
+        this.Stopped?.(this, this.CurrentPosition);
+    }
+    OnDisposing() { this.StopSnapAnimators(); }
+    get IsSnapAnimating() { return this.springX.IsRunning || this.springY.IsRunning || this.range.IsRunning; }
+    StopSnapAnimators() {
+        this.stoppingSilently = true;
+        try {
+            this.springX.Stop();
+            this.springY.Stop();
+            this.range.Stop();
+        }
+        finally {
+            this.stoppingSilently = false;
+        }
+    }
+    /** C# SnappingLayout.Render: the transition state follows the position every frame. */
+    Render(ctx) {
+        super.Render(ctx);
+        this.InTransition = !this.CheckTransitionEnded();
+    }
+    // ---- clamping ----
+    ClampOffset(x, y, rubber) {
+        const b = this.ContentOffsetBounds;
+        if (!rubber)
+            return new SKPoint(Math.max(b.Left, Math.min(b.Right, x)), Math.max(b.Top, Math.min(b.Bottom, y)));
+        const c = RubberBandUtils.ClampOnTrack(x, y, b, this.RubberEffect, this.DrawingRect.Width / this.RenderingScale, this.DrawingRect.Height / this.RenderingScale);
+        return new SKPoint(c.X, c.Y);
+    }
+    /** C# GetContentOffsetBounds: the extent covered by the snap points. */
+    BoundsFromSnapPoints() {
+        if (this.SnapPoints.length === 0)
+            return SKRect.Empty;
+        let l = Infinity, t = Infinity, r = -Infinity, b = -Infinity;
+        for (const p of this.SnapPoints) {
+            l = Math.min(l, p.X);
+            t = Math.min(t, p.Y);
+            r = Math.max(r, p.X);
+            b = Math.max(b, p.Y);
+        }
+        return new SKRect(l, t, r, b);
+    }
+    // ---- anchors ----
+    static Dist(a, b) { return Math.hypot(a.X - b.X, a.Y - b.Y); }
+    FindNearestAnchor(current) {
+        let best = current, d = Infinity;
+        for (const p of this.SnapPoints) {
+            const dd = SnappingLayout.Dist(p, current);
+            if (dd < d) {
+                d = dd;
+                best = p;
+            }
+        }
+        return best;
+    }
+    /** Anchor used as the origin of a snap decision (C# FindNearestAnchorInternal; a looped carousel maps virtual anchors here). */
+    FindNearestAnchorInternal(current, _velocity) { return this.FindNearestAnchor(current); }
+    /** The closest anchor lying in the direction of the velocity (dot product), else the origin. */
+    SelectNextAnchor(origin, velocity) {
+        const len = Math.hypot(velocity.X, velocity.Y);
+        if (len === 0)
+            return origin;
+        const nx = velocity.X / len, ny = velocity.Y / len;
+        const ordered = [...this.SnapPoints].sort((a, b) => SnappingLayout.Dist(a, origin) - SnappingLayout.Dist(b, origin));
+        for (const anchor of ordered) {
+            const dx = anchor.X - origin.X, dy = anchor.Y - origin.Y, l = Math.hypot(dx, dy);
+            if (l === 0)
+                continue;
+            if (nx * (dx / l) + ny * (dy / l) > 0)
+                return anchor;
+        }
+        return origin;
+    }
+    ScrollToNearestAnchor(location, velocity) {
+        if (this.SnapPoints.length === 0)
+            return;
+        const origin = this.FindNearestAnchorInternal(location, velocity);
+        const target = this.SelectNextAnchor(origin, velocity);
+        if (SnappingLayout.Dist(location, target) >= 0.5)
+            this.ScrollToOffset(target, velocity, this.CanAnimate);
+        else
+            this.UpdateReportedPosition();
+    }
+    get CanAnimate() { return this.IsVisible && this.DrawingRect.Height > 0; }
+    GetAutoVelocity(displacement) {
+        const v = this.AutoVelocityMultiplyPts * this.RenderingScale;
+        return new SKPoint(-v * Math.sign(displacement.X), -v * Math.sign(displacement.Y));
+    }
+    // ---- snap animation tuning (SkiaCarousel overrides these for SwipeSpeed / LinearSpeedMs) ----
+    ScaleSnapVelocity(velocity) { return velocity; }
+    CreateSnapSpring() { return new Spring(1 * (1 + this.RubberDamping), 200, 0.5 * (1 + this.RubberDamping)); }
+    SpringVelocity(velocity) { return velocity; }
+    /** Seconds of the linear snap (C# SnappingLayout: 0.3 s scaled by distance, or 0.1–0.8 s from the velocity). */
+    GetSnapDurationSeconds(_start, _end, velocity, displacement) {
+        const magnitude = Math.hypot(velocity.X, velocity.Y);
+        if (magnitude > 10)
+            return 0.7 * Math.max(0.1, Math.min(0.8, 300 / magnitude));
+        const h = this.DrawingRect.Height / this.RenderingScale;
+        return 0.3 * (Math.max(Math.abs(displacement.X), Math.abs(displacement.Y)) / (h || 1));
+    }
+    /** C# ScrollToOffset: spring when Bounces, else a linear animation with the duration from GetSnapDurationSeconds. */
+    ScrollToOffset(target, velocity, animate) {
+        if (target.X === this.CurrentSnap.X && target.Y === this.CurrentSnap.Y)
+            return false;
+        this.StopSnapAnimators();
+        if (animate && this.DrawingRect.Height > 0) {
+            const start = this.CurrentPosition;
+            const displacement = new SKPoint(start.X - target.X, start.Y - target.Y);
+            if (velocity.X === 0 && velocity.Y === 0)
+                velocity = this.GetAutoVelocity(displacement);
+            velocity = this.ScaleSnapVelocity(velocity);
+            if (displacement.X !== 0 || displacement.Y !== 0) {
+                this.InTransition = true;
+                if (this.Bounces) {
+                    const spring = this.CreateSnapSpring(), v = this.SpringVelocity(velocity);
+                    if (displacement.X !== 0) {
+                        this.springX.Initialize(target.X, displacement.X, v.X, spring);
+                        this.springX.Start();
+                    }
+                    if (displacement.Y !== 0) {
+                        this.springY.Initialize(target.Y, displacement.Y, v.Y, spring);
+                        this.springY.Start();
+                    }
+                }
+                else {
+                    const seconds = this.GetSnapDurationSeconds(start, target, velocity, displacement);
+                    this.rangeFrom = start;
+                    this.rangeTo = target;
+                    this.range.Easing = this.SnapEasing;
+                    this.range.Speed = Math.max(60, seconds * 1000);
+                    this.range.Start();
+                }
+            }
+        }
+        else {
+            this.CurrentSnap = target;
+            this.ApplyPosition(target);
+        }
+        this.CurrentSnap = target;
+        this.UpdateReportedPosition();
+        return true;
+    }
+    /** Subclasses move their content here; base records the position and reports (C# ApplyPosition). */
+    ApplyPosition(position) {
+        this.CurrentPosition = position;
+        this.UpdateReportedPosition();
+        this.Scrolled?.(this, position);
+    }
+    /** C# SkiaCarousel.CheckTransitionEnded: never "ended" while a snap animator still runs (the position may touch the target early). */
+    CheckTransitionEnded() { return !this.IsSnapAnimating && Math.abs(this.CurrentPosition.X - this.CurrentSnap.X) <= 1 && Math.abs(this.CurrentPosition.Y - this.CurrentSnap.Y) <= 1; }
+    /** Subclasses translate CurrentSnap into their own state (SelectedIndex, IsOpen). */
+    UpdateReportedPosition() { }
+}

package/dist/controls/TextSpan.d.ts

@@ -0,0 +1,70 @@
+import type { ControlTappedEventArgs } from "../core/Gestures";
+import { type Color, type SKRect } from "../core/Types";
+import type { SkiaLabel } from "./SkiaLabel";
+/**
+ * Mirrors DrawnUi TextSpan: a styled fragment inside a SkiaLabel (`<SkiaLabel><TextSpan .../></SkiaLabel>`).
+ * Unset TextColor / FontSize / FontFamily inherit from the label (C# HasSetColor / HasSetSize / HasSetFont).
+ * Not a SkiaControl: it has no box of its own, the label lays it out and keeps its hit `Rects`.
+ */
+export declare class TextSpan {
+    /** The label hosting this span (C# ParentControl). */
+    Parent?: SkiaLabel;
+    /** Set by the reconciler when React hides the element. */
+    IsVisible: boolean;
+    /** Rectangles of the drawn fragments, pixels relative to the label's top-left, refreshed by every paint. */
+    readonly Rects: SKRect[];
+    Tapped?: (span: TextSpan, e: ControlTappedEventArgs) => void;
+    /** Free payload (SkiaRichLabel stores the link url here). */
+    Tag?: string;
+    /** Listen to taps even without a Tapped handler. */
+    ForceCaptureInput: boolean;
+    private text;
+    private textColor?;
+    private fontSize?;
+    private fontFamily?;
+    private fontWeight;
+    private isBold;
+    private isItalic;
+    private underline;
+    private underlineWidth;
+    private strikeout;
+    private strikeoutWidth;
+    private strikeoutColor;
+    private backgroundColor?;
+    private Set;
+    get Text(): string;
+    set Text(v: string);
+    get TextColor(): Color | undefined;
+    set TextColor(v: Color | undefined);
+    get FontSize(): number | undefined;
+    set FontSize(v: number | undefined);
+    get FontFamily(): string | undefined;
+    set FontFamily(v: string | undefined);
+    get FontWeight(): number;
+    set FontWeight(v: number);
+    get IsBold(): boolean;
+    set IsBold(v: boolean);
+    get IsItalic(): boolean;
+    set IsItalic(v: boolean);
+    get Underline(): boolean;
+    set Underline(v: boolean);
+    /** Points; negative = that many pixels (C# default -1 = 1px). */
+    get UnderlineWidth(): number;
+    set UnderlineWidth(v: number);
+    get Strikeout(): boolean;
+    set Strikeout(v: boolean);
+    /** Points. */
+    get StrikeoutWidth(): number;
+    set StrikeoutWidth(v: number);
+    get StrikeoutColor(): Color;
+    set StrikeoutColor(v: Color);
+    get BackgroundColor(): Color | undefined;
+    set BackgroundColor(v: Color | undefined);
+    get HasTapHandler(): boolean;
+    get HasDecorations(): boolean;
+    /** Invalidates the hosting label (a span has no rendering of its own). */
+    Update(): void;
+    /** x/y in pixels relative to the label's top-left. */
+    HitIsInside(x: number, y: number): boolean;
+    FireTap(e: ControlTappedEventArgs): void;
+}

package/dist/controls/TextSpan.js

@@ -0,0 +1,76 @@
+import { Colors } from "../core/Types";
+/**
+ * Mirrors DrawnUi TextSpan: a styled fragment inside a SkiaLabel (`<SkiaLabel><TextSpan .../></SkiaLabel>`).
+ * Unset TextColor / FontSize / FontFamily inherit from the label (C# HasSetColor / HasSetSize / HasSetFont).
+ * Not a SkiaControl: it has no box of its own, the label lays it out and keeps its hit `Rects`.
+ */
+export class TextSpan {
+    /** The label hosting this span (C# ParentControl). */
+    Parent;
+    /** Set by the reconciler when React hides the element. */
+    IsVisible = true;
+    /** Rectangles of the drawn fragments, pixels relative to the label's top-left, refreshed by every paint. */
+    Rects = [];
+    Tapped;
+    /** Free payload (SkiaRichLabel stores the link url here). */
+    Tag;
+    /** Listen to taps even without a Tapped handler. */
+    ForceCaptureInput = false;
+    text = "";
+    textColor;
+    fontSize;
+    fontFamily;
+    fontWeight = 0;
+    isBold = false;
+    isItalic = false;
+    underline = false;
+    underlineWidth = -1;
+    strikeout = false;
+    strikeoutWidth = 1;
+    strikeoutColor = Colors.Red;
+    backgroundColor;
+    Set(key, v) { if (this[key] !== v) {
+        this[key] = v;
+        this.Update();
+    } }
+    get Text() { return this.text; }
+    set Text(v) { this.Set("text", v); }
+    get TextColor() { return this.textColor; }
+    set TextColor(v) { this.Set("textColor", v); }
+    get FontSize() { return this.fontSize; }
+    set FontSize(v) { this.Set("fontSize", v); }
+    get FontFamily() { return this.fontFamily; }
+    set FontFamily(v) { this.Set("fontFamily", v); }
+    get FontWeight() { return this.fontWeight; }
+    set FontWeight(v) { this.Set("fontWeight", v); }
+    get IsBold() { return this.isBold; }
+    set IsBold(v) { this.Set("isBold", v); }
+    get IsItalic() { return this.isItalic; }
+    set IsItalic(v) { this.Set("isItalic", v); }
+    get Underline() { return this.underline; }
+    set Underline(v) { this.Set("underline", v); }
+    /** Points; negative = that many pixels (C# default -1 = 1px). */
+    get UnderlineWidth() { return this.underlineWidth; }
+    set UnderlineWidth(v) { this.Set("underlineWidth", v); }
+    get Strikeout() { return this.strikeout; }
+    set Strikeout(v) { this.Set("strikeout", v); }
+    /** Points. */
+    get StrikeoutWidth() { return this.strikeoutWidth; }
+    set StrikeoutWidth(v) { this.Set("strikeoutWidth", v); }
+    get StrikeoutColor() { return this.strikeoutColor; }
+    set StrikeoutColor(v) { this.Set("strikeoutColor", v); }
+    get BackgroundColor() { return this.backgroundColor; }
+    set BackgroundColor(v) { this.Set("backgroundColor", v); }
+    get HasTapHandler() { return !!this.Tapped || this.ForceCaptureInput; }
+    get HasDecorations() { return (this.underline && this.underlineWidth !== 0) || this.strikeout; }
+    /** Invalidates the hosting label (a span has no rendering of its own). */
+    Update() { this.Parent?.Update(); }
+    /** x/y in pixels relative to the label's top-left. */
+    HitIsInside(x, y) {
+        for (const r of this.Rects)
+            if (x >= r.Left && x < r.Right && y >= r.Top && y < r.Bottom)
+                return true;
+        return false;
+    }
+    FireTap(e) { this.Tapped?.(this, e); }
+}

package/dist/core/Accessibility.d.ts

@@ -0,0 +1,104 @@
+import type { SkiaControl } from "./SkiaControl";
+import { SKRect } from "./Types";
+/** ARIA role constants (DrawnUi.Models.Aria) for `AccessibilityRole`. */
+export declare const Aria: {
+    readonly RoleButton: "button";
+    readonly RoleLink: "link";
+    readonly RoleCheckbox: "checkbox";
+    readonly RoleRadio: "radio";
+    readonly RoleSwitch: "switch";
+    readonly RoleSlider: "slider";
+    readonly RoleSpinButton: "spinbutton";
+    readonly RoleTextBox: "textbox";
+    readonly RoleSearchBox: "searchbox";
+    readonly RoleComboBox: "combobox";
+    readonly RoleListBox: "listbox";
+    readonly RoleOption: "option";
+    readonly RoleTab: "tab";
+    readonly RoleTabPanel: "tabpanel";
+    readonly RoleTabList: "tablist";
+    readonly RoleMenu: "menu";
+    readonly RoleMenuItem: "menuitem";
+    readonly RoleMenuItemCheckbox: "menuitemcheckbox";
+    readonly RoleMenuItemRadio: "menuitemradio";
+    readonly RoleScrollBar: "scrollbar";
+    readonly RoleText: "text";
+    readonly RoleHeading: "heading";
+    readonly RoleImg: "img";
+    readonly RoleList: "list";
+    readonly RoleListItem: "listitem";
+    readonly RoleSeparator: "separator";
+    readonly RoleProgressBar: "progressbar";
+    readonly RoleTooltip: "tooltip";
+    readonly RoleDialog: "dialog";
+    readonly RoleAlertDialog: "alertdialog";
+    readonly RoleStatus: "status";
+    readonly RoleAlert: "alert";
+    readonly RoleGroup: "group";
+    readonly RoleRegion: "region";
+    readonly RoleNavigation: "navigation";
+    readonly RoleMain: "main";
+    /** Removes the control from the accessibility tree even when a default role would apply (inner label of a button). */
+    readonly RolePresentation: "presentation";
+    readonly LivePolite: "polite";
+    readonly LiveAssertive: "assertive";
+};
+/** One laid-out text line exposed for native selection (AccessibilityTextSelectable): CSS px relative to the node. */
+export interface AccessibilityTextLine {
+    Text: string;
+    Left: number;
+    Top: number;
+    Width: number;
+    Height: number;
+    FontFamily: string;
+    FontWeight: number;
+    FontSize: number;
+}
+/** One entry of the accessibility snapshot (DrawnUi AccessibilityNode). Rect is CSS pixels relative to the canvas. */
+export interface AccessibilityNode {
+    Id: number;
+    Label?: string;
+    Hint?: string;
+    Role: string;
+    Rect: SKRect;
+    CanInteract: boolean;
+    IsPressed?: boolean;
+    Live?: string;
+    Source: SkiaControl;
+    /** Real text lines rendered into the overlay so the browser can select / copy them (opt-in per control). */
+    TextLines?: AccessibilityTextLine[];
+}
+/**
+ * Mirrors DrawnUi SkiaAccessibilityManager: registry of accessible controls + a rate-limited snapshot
+ * (at most one rebuild per MinUpdateIntervalMs, taken at frame end) that the DOM overlay renders.
+ * Detached / hidden / far-off-canvas controls drop out of the snapshot on the next rebuild, so nothing has
+ * to unregister explicitly; positions follow scrolling because rects are read from the arranged DrawingRect.
+ */
+export declare class SkiaAccessibilityManager {
+    private readonly nodes;
+    private dirty;
+    private lastRebuild;
+    private pending;
+    private readonly changed;
+    private readonly liveUpdated;
+    /** Minimum milliseconds between snapshot rebuilds. */
+    MinUpdateIntervalMs: number;
+    Snapshot: AccessibilityNode[];
+    FocusedNode?: SkiaControl;
+    /** Subscribes to snapshot changes; returns the unsubscribe function. */
+    OnChanged(cb: () => void): () => void;
+    /** Fired immediately (bypassing the rate limit) when a live-region node's value changes. */
+    OnLiveRegionUpdated(cb: (node: SkiaControl) => void): () => void;
+    NotifyFocused(node?: SkiaControl): void;
+    Register(node: SkiaControl): void;
+    NotifyUpdated(node: SkiaControl): void;
+    ForceRebuildOnNextFrame(): void;
+    Unregister(node: SkiaControl): void;
+    UnregisterSubtree(root: SkiaControl): void;
+    /**
+     * Called by Canvas at the end of every drawn frame. Rebuilds when something was invalidated, and at most once
+     * per MinUpdateIntervalMs otherwise (keeps rects in sync with scrolling); notifies only when the snapshot differs.
+     */
+    OnFrameEnd(scale: number, canvasWidthPx: number, canvasHeightPx: number, requestFrame: () => void): void;
+    private static Same;
+}

package/dist/core/Accessibility.js

@@ -0,0 +1,150 @@
+import { SKRect } from "./Types";
+/** ARIA role constants (DrawnUi.Models.Aria) for `AccessibilityRole`. */
+export const Aria = {
+    // interactive widgets
+    RoleButton: "button", RoleLink: "link", RoleCheckbox: "checkbox", RoleRadio: "radio", RoleSwitch: "switch",
+    RoleSlider: "slider", RoleSpinButton: "spinbutton", RoleTextBox: "textbox", RoleSearchBox: "searchbox",
+    RoleComboBox: "combobox", RoleListBox: "listbox", RoleOption: "option", RoleTab: "tab", RoleTabPanel: "tabpanel",
+    RoleTabList: "tablist", RoleMenu: "menu", RoleMenuItem: "menuitem", RoleMenuItemCheckbox: "menuitemcheckbox",
+    RoleMenuItemRadio: "menuitemradio", RoleScrollBar: "scrollbar",
+    // structure & landmarks
+    RoleText: "text", RoleHeading: "heading", RoleImg: "img", RoleList: "list", RoleListItem: "listitem",
+    RoleSeparator: "separator", RoleProgressBar: "progressbar", RoleTooltip: "tooltip", RoleDialog: "dialog",
+    RoleAlertDialog: "alertdialog", RoleStatus: "status", RoleAlert: "alert", RoleGroup: "group", RoleRegion: "region",
+    RoleNavigation: "navigation", RoleMain: "main",
+    /** Removes the control from the accessibility tree even when a default role would apply (inner label of a button). */
+    RolePresentation: "presentation",
+    // live regions
+    LivePolite: "polite", LiveAssertive: "assertive",
+};
+/**
+ * Mirrors DrawnUi SkiaAccessibilityManager: registry of accessible controls + a rate-limited snapshot
+ * (at most one rebuild per MinUpdateIntervalMs, taken at frame end) that the DOM overlay renders.
+ * Detached / hidden / far-off-canvas controls drop out of the snapshot on the next rebuild, so nothing has
+ * to unregister explicitly; positions follow scrolling because rects are read from the arranged DrawingRect.
+ */
+export class SkiaAccessibilityManager {
+    nodes = new Set();
+    dirty = false;
+    lastRebuild = -Infinity;
+    pending = 0;
+    changed = new Set();
+    liveUpdated = new Set();
+    /** Minimum milliseconds between snapshot rebuilds. */
+    MinUpdateIntervalMs = 1000;
+    Snapshot = [];
+    FocusedNode;
+    /** Subscribes to snapshot changes; returns the unsubscribe function. */
+    OnChanged(cb) { this.changed.add(cb); return () => this.changed.delete(cb); }
+    /** Fired immediately (bypassing the rate limit) when a live-region node's value changes. */
+    OnLiveRegionUpdated(cb) { this.liveUpdated.add(cb); return () => this.liveUpdated.delete(cb); }
+    NotifyFocused(node) { if (this.FocusedNode !== node)
+        this.FocusedNode = node; }
+    Register(node) { this.nodes.add(node); this.dirty = true; }
+    NotifyUpdated(node) {
+        if (!this.nodes.has(node))
+            return;
+        this.dirty = true;
+        if (node.AccessibilityLive)
+            for (const cb of this.liveUpdated)
+                cb(node);
+    }
+    ForceRebuildOnNextFrame() { this.lastRebuild = 0; this.dirty = true; }
+    Unregister(node) {
+        if (this.nodes.delete(node)) {
+            node.OnAccessibilityUnregistered();
+            this.dirty = true;
+        }
+    }
+    UnregisterSubtree(root) {
+        for (const n of Array.from(this.nodes)) {
+            let c = n;
+            while (c && c !== root)
+                c = c.Parent;
+            if (c)
+                this.Unregister(n);
+        }
+    }
+    /**
+     * Called by Canvas at the end of every drawn frame. Rebuilds when something was invalidated, and at most once
+     * per MinUpdateIntervalMs otherwise (keeps rects in sync with scrolling); notifies only when the snapshot differs.
+     */
+    OnFrameEnd(scale, canvasWidthPx, canvasHeightPx, requestFrame) {
+        if (this.nodes.size === 0 && this.Snapshot.length === 0)
+            return;
+        const now = performance.now();
+        const wait = this.MinUpdateIntervalMs - (now - this.lastRebuild);
+        if (wait > 0) {
+            // rate-limited: rendering is on demand, so make sure a frame comes back once the interval has passed
+            if (!this.pending)
+                this.pending = window.setTimeout(() => { this.pending = 0; requestFrame(); }, wait);
+            return;
+        }
+        this.dirty = false;
+        this.lastRebuild = now;
+        const list = [];
+        for (const n of this.nodes) {
+            if (!n.Superview) {
+                this.nodes.delete(n);
+                n.OnAccessibilityUnregistered();
+                continue;
+            } // detached from the tree
+            if (!n.IsVisible || !n.IsAccessibilityElement || n.AccessibilityRole === Aria.RolePresentation)
+                continue;
+            if (AccessibilityManagerHiddenByAncestor(n))
+                continue; // e.g. the root page kept mounted under a pushed shell page
+            const px = n.GetAccessibilityPixelRect();
+            if (px.Width <= 0 || px.Height <= 0)
+                continue;
+            // nodes beyond the canvas stay in the tree (scroll content reachable with Tab, the overlay scrolls them into view);
+            // only what is entirely outside a clipped canvas by more than a screen is dropped to keep the DOM small
+            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,
+                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,
+                TextLines: n.AccessibilityTextSelectable ? n.GetAccessibilityTextLines(scale) : undefined,
+            });
+        }
+        list.sort((a, b) => a.Rect.Top - b.Rect.Top || a.Rect.Left - b.Rect.Left);
+        if (SkiaAccessibilityManager.Same(list, this.Snapshot))
+            return;
+        this.Snapshot = list;
+        for (const cb of this.changed)
+            cb();
+    }
+    static Same(a, b) {
+        if (a.length !== b.length)
+            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
+                || 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;
+            const tx = x.TextLines, ty = y.TextLines;
+            if (!!tx !== !!ty)
+                return false;
+            if (tx && ty) {
+                if (tx.length !== ty.length)
+                    return false;
+                for (let j = 0; j < tx.length; j++)
+                    if (tx[j].Text !== ty[j].Text || Math.abs(tx[j].Left - ty[j].Left) > 0.5 || Math.abs(tx[j].Top - ty[j].Top) > 0.5 || tx[j].FontSize !== ty[j].FontSize)
+                        return false;
+            }
+        }
+        return true;
+    }
+}
+/** True when any ancestor is hidden (IsVisible false or Opacity 0): the subtree is not drawn, so it gets no nodes. */
+function AccessibilityManagerHiddenByAncestor(control) {
+    let p = control.Parent;
+    while (p) {
+        if (!p.IsVisible || p.Opacity <= 0)
+            return true;
+        p = p.Parent;
+    }
+    return false;
+}