drawnui-react 0.1.0-preview.1

package/dist/controls/SkiaRichLabel.d.ts

@@ -0,0 +1,77 @@
+import type { SkiaControl } from "../core/SkiaControl";
+import type { GestureEventProcessingInfo, SkiaGesturesParameters } from "../core/Gestures";
+import { type Color } from "../core/Types";
+import { SkiaLabel } from "./SkiaLabel";
+import { TextSpan } from "./TextSpan";
+/**
+ * Mirrors DrawnUi SkiaRichLabel: a SkiaLabel whose Text is markdown, rendered as TextSpans.
+ * Lightweight parser like the C# one (display-oriented, not full CommonMark): headings, paragraphs, bullet and
+ * numbered lists, fenced code blocks, inline code, bold, italic, strikethrough, links (tap -> LinkTapped).
+ */
+export declare class SkiaRichLabel extends SkiaLabel {
+    static ColorLink: Color;
+    static ColorCodeBackground: Color;
+    static ColorCodeBlock: Color;
+    static ColorCode: Color;
+    static ColorStrikeout: Color;
+    static MaskPrefixBullet: string;
+    static MaskPrefixNumbered: string;
+    private markdownEnabled;
+    private linkColor;
+    private codeTextColor;
+    private headingTextColor;
+    private codeBlockBackgroundColor;
+    private codeBackgroundColor;
+    private strikeoutColor;
+    private prefixBullet;
+    private prefixNumbered;
+    private underlineLink;
+    private underlineWidth;
+    /** Raised when a `[text](url)` span is tapped (C# LinkTapped event). */
+    LinkTapped?: (sender: SkiaRichLabel, url: string) => void;
+    private Style;
+    /** false = one literal span, no parsing (unicode/emoji without formatting). */
+    get MarkdownEnabled(): boolean;
+    set MarkdownEnabled(v: boolean);
+    get LinkColor(): Color;
+    set LinkColor(v: Color);
+    get CodeTextColor(): Color;
+    set CodeTextColor(v: Color);
+    get HeadingTextColor(): Color;
+    set HeadingTextColor(v: Color);
+    get CodeBlockBackgroundColor(): Color;
+    set CodeBlockBackgroundColor(v: Color);
+    get CodeBackgroundColor(): Color;
+    set CodeBackgroundColor(v: Color);
+    get StrikeoutColor(): Color;
+    set StrikeoutColor(v: Color);
+    get PrefixBullet(): string;
+    set PrefixBullet(v: string);
+    /** `{0}` is replaced by the item number. */
+    get PrefixNumbered(): string;
+    set PrefixNumbered(v: string);
+    get UnderlineLink(): boolean;
+    set UnderlineLink(v: boolean);
+    get UnderlineWidth(): number;
+    set UnderlineWidth(v: number);
+    /** The markdown source; spans are rebuilt on every change (C# SetTextInternal). */
+    get Text(): string;
+    set Text(v: string);
+    get FontSize(): number;
+    set FontSize(v: number);
+    /** C# OnLinkTapped: raises LinkTapped; override to open the url yourself. */
+    OnLinkTapped(url: string, _text: string): void;
+    protected OnSpanTapped(span: TextSpan, args: SkiaGesturesParameters, apply: GestureEventProcessingInfo): SkiaControl | null;
+    private hadParagraph;
+    private RebuildSpans;
+    private static Plain;
+    /** C# AddTextSpan + SpanWithAttributes: one span per fragment carrying the current inline state. */
+    private AddTextSpan;
+    /** C# RenderInline(LineBreak): a "\n" appended to the last span (or a span of its own). */
+    private LineBreak;
+    private RenderDocument;
+    /** Blocks are separated by one line break once something was emitted (C# hadParagraph). */
+    private BeginBlock;
+    /** Inline markdown: `code`, **bold**, __bold__, *italic*, _italic_, ~~strike~~, [text](url), backslash escapes. */
+    private RenderInlines;
+}

package/dist/controls/SkiaRichLabel.js

@@ -0,0 +1,274 @@
+import { Colors } from "../core/Types";
+import { SkiaLabel } from "./SkiaLabel";
+import { TextSpan } from "./TextSpan";
+/**
+ * Mirrors DrawnUi SkiaRichLabel: a SkiaLabel whose Text is markdown, rendered as TextSpans.
+ * Lightweight parser like the C# one (display-oriented, not full CommonMark): headings, paragraphs, bullet and
+ * numbered lists, fenced code blocks, inline code, bold, italic, strikethrough, links (tap -> LinkTapped).
+ */
+export class SkiaRichLabel extends SkiaLabel {
+    // DrawnUi static defaults
+    static ColorLink = "#6495ED";
+    static ColorCodeBackground = "#696969";
+    static ColorCodeBlock = "#222222";
+    static ColorCode = Colors.White;
+    static ColorStrikeout = Colors.Red;
+    static MaskPrefixBullet = "• ";
+    static MaskPrefixNumbered = "{0}. ";
+    markdownEnabled = true;
+    linkColor = SkiaRichLabel.ColorLink;
+    codeTextColor = SkiaRichLabel.ColorCode;
+    headingTextColor = SkiaRichLabel.ColorCode;
+    codeBlockBackgroundColor = SkiaRichLabel.ColorCodeBlock;
+    codeBackgroundColor = SkiaRichLabel.ColorCodeBackground;
+    strikeoutColor = SkiaRichLabel.ColorStrikeout;
+    prefixBullet = SkiaRichLabel.MaskPrefixBullet;
+    prefixNumbered = SkiaRichLabel.MaskPrefixNumbered;
+    underlineLink = true;
+    underlineWidth = -1;
+    /** Raised when a `[text](url)` span is tapped (C# LinkTapped event). */
+    LinkTapped;
+    Style(key, v) { if (this[key] !== v) {
+        this[key] = v;
+        this.RebuildSpans();
+    } }
+    /** false = one literal span, no parsing (unicode/emoji without formatting). */
+    get MarkdownEnabled() { return this.markdownEnabled; }
+    set MarkdownEnabled(v) { this.Style("markdownEnabled", v); }
+    get LinkColor() { return this.linkColor; }
+    set LinkColor(v) { this.Style("linkColor", v); }
+    get CodeTextColor() { return this.codeTextColor; }
+    set CodeTextColor(v) { this.Style("codeTextColor", v); }
+    get HeadingTextColor() { return this.headingTextColor; }
+    set HeadingTextColor(v) { this.Style("headingTextColor", v); }
+    get CodeBlockBackgroundColor() { return this.codeBlockBackgroundColor; }
+    set CodeBlockBackgroundColor(v) { this.Style("codeBlockBackgroundColor", v); }
+    get CodeBackgroundColor() { return this.codeBackgroundColor; }
+    set CodeBackgroundColor(v) { this.Style("codeBackgroundColor", v); }
+    get StrikeoutColor() { return this.strikeoutColor; }
+    set StrikeoutColor(v) { this.Style("strikeoutColor", v); }
+    get PrefixBullet() { return this.prefixBullet; }
+    set PrefixBullet(v) { this.Style("prefixBullet", v); }
+    /** `{0}` is replaced by the item number. */
+    get PrefixNumbered() { return this.prefixNumbered; }
+    set PrefixNumbered(v) { this.Style("prefixNumbered", v); }
+    get UnderlineLink() { return this.underlineLink; }
+    set UnderlineLink(v) { this.Style("underlineLink", v); }
+    get UnderlineWidth() { return this.underlineWidth; }
+    set UnderlineWidth(v) { this.Style("underlineWidth", v); }
+    /** The markdown source; spans are rebuilt on every change (C# SetTextInternal). */
+    get Text() { return super.Text; }
+    set Text(v) { super.Text = v; this.RebuildSpans(); }
+    // headings scale from the label's FontSize, so rebuild when it changes
+    get FontSize() { return super.FontSize; }
+    set FontSize(v) { super.FontSize = v; this.RebuildSpans(); }
+    /** C# OnLinkTapped: raises LinkTapped; override to open the url yourself. */
+    OnLinkTapped(url, _text) { this.LinkTapped?.(this, url); }
+    OnSpanTapped(span, args, apply) {
+        if (span.Tag) {
+            this.OnLinkTapped(span.Tag, span.Text);
+            return this;
+        }
+        return super.OnSpanTapped(span, args, apply);
+    }
+    // ---- markdown -> spans ----
+    hadParagraph = false;
+    RebuildSpans() {
+        for (const s of this.Spans)
+            s.Parent = undefined;
+        this.Spans.length = 0;
+        this.hadParagraph = false;
+        const text = super.Text;
+        if (text) {
+            if (!this.markdownEnabled)
+                this.AddTextSpan(text, SkiaRichLabel.Plain());
+            else
+                this.RenderDocument(text);
+        }
+        this.Update();
+    }
+    static Plain() { return { bold: false, italic: false, strike: false, heading: 0, code: false }; }
+    /** C# AddTextSpan + SpanWithAttributes: one span per fragment carrying the current inline state. */
+    AddTextSpan(text, state, modify) {
+        if (!text)
+            return undefined;
+        const span = new TextSpan();
+        span.Parent = this;
+        span.Text = text;
+        span.IsBold = state.bold;
+        span.IsItalic = state.italic;
+        span.Strikeout = state.strike;
+        if (state.strike)
+            span.StrikeoutColor = this.strikeoutColor;
+        if (state.heading === 1) {
+            span.IsBold = true;
+            span.FontSize = this.FontSize + 9;
+            span.TextColor = this.headingTextColor;
+        }
+        else if (state.heading === 2) {
+            span.IsBold = true;
+            span.FontSize = this.FontSize + 4;
+            span.TextColor = this.headingTextColor;
+        }
+        else if (state.heading === 3) {
+            span.IsBold = true;
+            span.FontSize = this.FontSize + 2;
+            span.TextColor = this.headingTextColor;
+        }
+        modify?.(span);
+        this.Spans.push(span);
+        return span;
+    }
+    /** C# RenderInline(LineBreak): a "\n" appended to the last span (or a span of its own). */
+    LineBreak() {
+        const last = this.Spans[this.Spans.length - 1];
+        if (last)
+            last.Text += "\n";
+        else
+            this.AddTextSpan("\n", SkiaRichLabel.Plain());
+    }
+    RenderDocument(text) {
+        const lines = text.replace(/\r\n?/g, "\n").split("\n");
+        let i = 0;
+        const paragraph = [];
+        const flushParagraph = (prefix) => {
+            if (paragraph.length === 0)
+                return;
+            this.BeginBlock();
+            if (prefix)
+                this.AddTextSpan(prefix, SkiaRichLabel.Plain());
+            this.RenderInlines(paragraph.join("\n"), SkiaRichLabel.Plain());
+            paragraph.length = 0;
+        };
+        while (i < lines.length) {
+            const line = lines[i];
+            const fence = /^\s*```/.exec(line);
+            const heading = /^(#{1,6})\s+(.*?)\s*#*\s*$/.exec(line);
+            const bullet = /^\s*[-*+]\s+(.*)$/.exec(line);
+            const numbered = /^\s*(\d+)[.)]\s+(.*)$/.exec(line);
+            if (fence) {
+                flushParagraph();
+                const code = [];
+                i++;
+                while (i < lines.length && !/^\s*```/.test(lines[i]))
+                    code.push(lines[i++]);
+                i++; // closing fence
+                this.BeginBlock();
+                code.forEach((l, n) => {
+                    if (n > 0)
+                        this.LineBreak();
+                    this.AddTextSpan(l, { ...SkiaRichLabel.Plain(), code: true }, (s) => { s.TextColor = this.codeTextColor; s.BackgroundColor = this.codeBlockBackgroundColor; });
+                });
+                continue;
+            }
+            if (heading) {
+                flushParagraph();
+                this.BeginBlock();
+                const level = Math.min(3, heading[1].length);
+                this.RenderInlines(heading[2], { ...SkiaRichLabel.Plain(), heading: level });
+                i++;
+                continue;
+            }
+            if (bullet || numbered) {
+                flushParagraph();
+                let itemNumber = 1;
+                while (i < lines.length) {
+                    const b = /^\s*[-*+]\s+(.*)$/.exec(lines[i]);
+                    const n = /^\s*(\d+)[.)]\s+(.*)$/.exec(lines[i]);
+                    if (!b && !n)
+                        break;
+                    this.BeginBlock();
+                    this.AddTextSpan(b ? this.prefixBullet : this.prefixNumbered.replace("{0}", String(n ? itemNumber++ : 0)), SkiaRichLabel.Plain());
+                    this.RenderInlines(b ? b[1] : n[2], SkiaRichLabel.Plain());
+                    i++;
+                    // continuation lines of the same item (indented, not blank, not a new item)
+                    while (i < lines.length && /^\s+\S/.test(lines[i]) && !/^\s*([-*+]|\d+[.)])\s+/.test(lines[i])) {
+                        this.LineBreak();
+                        this.RenderInlines(lines[i].trim(), SkiaRichLabel.Plain());
+                        i++;
+                    }
+                }
+                continue;
+            }
+            if (line.trim() === "") {
+                flushParagraph();
+                i++;
+                continue;
+            }
+            paragraph.push(line);
+            i++;
+        }
+        flushParagraph();
+    }
+    /** Blocks are separated by one line break once something was emitted (C# hadParagraph). */
+    BeginBlock() {
+        if (this.hadParagraph)
+            this.LineBreak();
+        this.hadParagraph = true;
+    }
+    /** Inline markdown: `code`, **bold**, __bold__, *italic*, _italic_, ~~strike~~, [text](url), backslash escapes. */
+    RenderInlines(text, state) {
+        let literal = "";
+        const flush = () => { if (literal) {
+            this.AddTextSpan(literal, state);
+            literal = "";
+        } };
+        let i = 0;
+        const n = text.length;
+        const closes = (marker, from) => {
+            let k = text.indexOf(marker, from);
+            while (k > 0 && text[k - 1] === "\\")
+                k = text.indexOf(marker, k + 1);
+            return k;
+        };
+        while (i < n) {
+            const ch = text[i];
+            if (ch === "\\" && i + 1 < n) {
+                literal += text[i + 1];
+                i += 2;
+                continue;
+            }
+            if (ch === "`") {
+                const end = text.indexOf("`", i + 1);
+                if (end > i) {
+                    flush();
+                    this.AddTextSpan(text.slice(i + 1, end), { ...state, code: true }, (s) => { s.TextColor = this.codeTextColor; s.BackgroundColor = this.codeBackgroundColor; });
+                    i = end + 1;
+                    continue;
+                }
+            }
+            if (ch === "[") {
+                const m = /^\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/.exec(text.slice(i));
+                if (m) {
+                    flush();
+                    this.AddTextSpan(m[1] || m[2], state, (s) => { s.Tag = m[2]; s.TextColor = this.linkColor; s.Underline = this.underlineLink; s.UnderlineWidth = this.underlineWidth; s.ForceCaptureInput = true; });
+                    i += m[0].length;
+                    continue;
+                }
+            }
+            const two = text.slice(i, i + 2);
+            if (two === "**" || two === "__" || two === "~~") {
+                const end = closes(two, i + 2);
+                if (end > i + 2) {
+                    flush();
+                    const inner = text.slice(i + 2, end);
+                    this.RenderInlines(inner, two === "~~" ? { ...state, strike: true } : { ...state, bold: true });
+                    i = end + 2;
+                    continue;
+                }
+            }
+            if ((ch === "*" || ch === "_") && i + 1 < n && !/\s/.test(text[i + 1])) {
+                const end = closes(ch, i + 1);
+                if (end > i + 1 && !/\s/.test(text[end - 1])) {
+                    flush();
+                    this.RenderInlines(text.slice(i + 1, end), { ...state, italic: true });
+                    i = end + 1;
+                    continue;
+                }
+            }
+            literal += ch;
+            i++;
+        }
+        flush();
+    }
+}

package/dist/controls/SkiaScroll.d.ts

@@ -0,0 +1,231 @@
+import { type DrawingContext, SkiaControl } from "../core/SkiaControl";
+import { type Color, type RelativePositionType, SKRect, ScaledSize, type ScrollOrientation, type SnapToChildrenType } from "../core/Types";
+import { type IScrollBar, type ScrollBarVisibility } from "./SkiaScrollBar";
+import type { IRefreshIndicator } from "./RefreshIndicator";
+import { type GestureEventProcessingInfo, SKPoint, type SkiaGesturesParameters } from "../core/Gestures";
+/** DrawnUi ScaledPoint: same point in points and pixels. */
+export interface ScaledPoint {
+    Units: SKPoint;
+    Pixels: SKPoint;
+}
+/**
+ * Mirrors DrawnUi SkiaScroll (plain content, no header/footer/refresh/virtualization yet).
+ * Offsets are in POINTS and <= 0 while inside bounds (content moves up/left as you scroll).
+ * Physics ported 1:1: deceleration fling (rate = 1 - FrictionScrolled/100) cut at the content edge,
+ * rubber-band overscroll while dragging, spring bounce back on release, wheel = WheelLineSize per notch.
+ */
+export declare class SkiaScroll extends SkiaControl {
+    static WheelLineSize: number;
+    static ThesholdSwipeOnUp: number;
+    static ScrollVelocityThreshold: number;
+    Orientation: ScrollOrientation;
+    Bounces: boolean;
+    RubberDamping: number;
+    RubberEffect: number;
+    /** 0.1..1, lower = longer fling. */
+    FrictionScrolled: number;
+    ChangeVelocityScrolled: number;
+    ChangeDistancePanned: number;
+    MaxVelocity: number;
+    MaxBounceVelocity: number;
+    AutoScrollingSpeedMs: number;
+    ScrollingSpeedMs: number;
+    IgnoreWrongDirection: boolean;
+    RespondsToGestures: boolean;
+    private header?;
+    private footer?;
+    /** A view before the content along the scroll axis; `Tag="Header"` on a JSX child sets it. */
+    get Header(): SkiaControl | undefined;
+    set Header(v: SkiaControl | undefined);
+    /** A view after the content along the scroll axis; `Tag="Footer"` on a JSX child sets it. */
+    get Footer(): SkiaControl | undefined;
+    set Footer(v: SkiaControl | undefined);
+    /** The header stays at the viewport start while the content scrolls under it (drawn over the content unless HeaderBehind). */
+    HeaderSticky: boolean;
+    /** The header is drawn behind the content (the content covers it as it scrolls, parallax covers). */
+    HeaderBehind: boolean;
+    /** 1 = the header scrolls with the content, 0.5 = at half speed (parallax), 0 = stays. */
+    HeaderParallaxRatio: number;
+    /** Apply the parallax while overscrolling at the start too (false: the header follows the content there). */
+    ParallaxOverscrollEnabled: boolean;
+    /** Extra points between a HeaderBehind / HeaderSticky header and the content (C# ContentOffset). */
+    ContentOffset: number;
+    private headerSize;
+    private footerSize;
+    private scrollBar?;
+    private scrollBarHorizontal?;
+    private scrollBarsVisibility;
+    /** Creates default SkiaScrollBar overlays for the given axes (matched against Orientation). */
+    get ScrollBarsVisibility(): ScrollBarVisibility;
+    set ScrollBarsVisibility(v: ScrollBarVisibility);
+    /** Custom vertical bar (IScrollBar control); `Tag="ScrollBar"` on a JSX child sets it. */
+    get ScrollBar(): (IScrollBar & SkiaControl) | undefined;
+    set ScrollBar(v: (IScrollBar & SkiaControl) | undefined);
+    get ScrollBarHorizontal(): (IScrollBar & SkiaControl) | undefined;
+    set ScrollBarHorizontal(v: (IScrollBar & SkiaControl) | undefined);
+    private scrollBarThumbColor?;
+    private scrollBarTrackColor?;
+    /** Colors applied to the default SkiaScrollBar (C# ScrollBarThumbColor / ScrollBarTrackColor). */
+    get ScrollBarThumbColor(): Color | undefined;
+    set ScrollBarThumbColor(v: Color | undefined);
+    get ScrollBarTrackColor(): Color | undefined;
+    set ScrollBarTrackColor(v: Color | undefined);
+    private scrollBarLast?;
+    private scrollBarHLast?;
+    private ApplyScrollBarColors;
+    /** C# ApplyScrollBarsVisibility: a default bar per wanted axis, none otherwise. */
+    protected ApplyScrollBarsVisibility(): void;
+    /** C# UpdateScrollBarIndicator: pushes progress / thumb ratio / overscroll / scrolling state when any changed. */
+    protected UpdateScrollBarIndicator(): void;
+    RefreshEnabled: boolean;
+    /** Called when the pull passed RefreshDistanceLimit (C# RefreshCommand); set IsRefreshing = false when done. */
+    RefreshCommand?: (sender: SkiaScroll) => void;
+    /** Pull distance (points) that triggers the refresh. */
+    RefreshDistanceLimit: number;
+    /** Distance (points) where the indicator stops moving and stays while refreshing. */
+    RefreshShowDistance: number;
+    private refreshIndicator?;
+    /** The pull-to-refresh view (IRefreshIndicator control); `Tag="RefreshIndicator"` on a JSX child sets it. */
+    get RefreshIndicator(): (IRefreshIndicator & SkiaControl) | undefined;
+    set RefreshIndicator(v: (IRefreshIndicator & SkiaControl) | undefined);
+    private isRefreshing;
+    private wasRefreshing;
+    private scrollLocked;
+    get IsRefreshing(): boolean;
+    set IsRefreshing(v: boolean);
+    private get UsingRefreshDistanceLimit();
+    /** C# SetIsRefreshing: true locks the scroll at RefreshShowDistance and runs RefreshCommand; false hides the indicator. */
+    SetIsRefreshing(state: boolean, initial: boolean): void;
+    protected HideRefreshIndicator(): void;
+    /** C# ShowRefreshIndicatorForced: parks the offset at RefreshShowDistance and shows the indicator fully. */
+    protected ShowRefreshIndicatorForced(): void;
+    /** C# CheckNeedRefresh + ApplyScrollPositionToRefreshViewUnsafe: called from every scroll change. */
+    protected CheckNeedRefresh(): void;
+    /** Snap to the child at the tracked position after scrolling stops: Center = centered in the viewport, Side = aligned to the viewport start (or end when TrackIndexPosition is End). */
+    SnapToChildren: SnapToChildrenType;
+    /** The viewport position whose child index is reported as CurrentIndex (None = off). */
+    TrackIndexPosition: RelativePositionType;
+    /** Points added to the tracked position (C# TrackIndexPositionOffset). */
+    TrackIndexPositionOffset: number;
+    /** Index of the content child at the tracked position, -1 when none. */
+    CurrentIndex: number;
+    CurrentIndexChanged?: (sender: SkiaScroll, index: number) => void;
+    private isSnapping;
+    private snapped;
+    /** The content child covering the tracked viewport point (C# CurrentIndexHit): index, its rect and the point, canvas px. */
+    protected GetIndexHit(position: RelativePositionType): {
+        Index: number;
+        Area: SKRect;
+        Point: SKPoint;
+    } | undefined;
+    private TrackIndex;
+    /** C# CheckNeedToSnap: after the fling stopped, not panning, no bounce, no ordered scroll. */
+    protected CheckNeedToSnap(): boolean;
+    /** C# Snap: scroll so the tracked child is centered / aligned to the side. */
+    Snap(maxTimeSecs: number): void;
+    private get HeaderExtentPts();
+    private get FooterExtentPts();
+    /** Offset changed (drag, fling, bounce, ScrollTo). */
+    Scrolled?: (sender: SkiaScroll, e: ScaledPoint) => void;
+    /** Called when scrolling within LoadMoreOffset points of the end (bottom / right), or when the content underfills the viewport. */
+    LoadMoreCommand?: (sender: SkiaScroll) => void;
+    /** Called when scrolling within LoadMoreTopOffset points of the start (top / left). */
+    LoadMoreTopCommand?: (sender: SkiaScroll) => void;
+    LoadMoreOffset: number;
+    LoadMoreTopOffset: number;
+    private loadMoreBottomAt;
+    private loadMoreBottomTime;
+    /** Top fires only after the user has actually left the top edge and comes back (a fresh list at offset 0 is not a "reached the top"). */
+    private loadMoreTopArmed;
+    /** C# CheckNeedToLoadMore: fires once per content extent near an edge; re-arms when the content grows or the user moves away (>offset+100pt, >2 s). */
+    private CheckLoadMore;
+    IsUserPanning: boolean;
+    IsUserFocused: boolean;
+    IsScrolling: boolean;
+    ContentSize: ScaledSize;
+    /** Points: Left/Top = most negative allowed offset, Right/Bottom = 0. */
+    ContentOffsetBounds: SKRect;
+    OverscrollDistance: SKPoint;
+    get OverScrolled(): boolean;
+    private content?;
+    get Content(): SkiaControl | undefined;
+    set Content(value: SkiaControl | undefined);
+    private offsetX;
+    private offsetY;
+    get ViewportOffsetX(): number;
+    set ViewportOffsetX(value: number);
+    get ViewportOffsetY(): number;
+    set ViewportOffsetY(value: number);
+    private readonly animatorFlingX;
+    private readonly animatorFlingY;
+    private readonly bounceX;
+    private readonly bounceY;
+    protected OnDisposing(): void;
+    protected DisposeChildren(): void;
+    private readonly velocity;
+    private panningCurrentOffsetPts;
+    private panningLastDelta;
+    private hadDown;
+    private childWasPanning;
+    private velocityX;
+    private velocityY;
+    private static readonly MinVelocity;
+    /** Set when a fling was cut to stop at the edge: the edge offset it lands on (DrawnUi _axis / _changeSpeed). */
+    private flingEdgeX;
+    private flingEdgeY;
+    constructor();
+    /** DrawnUi BounceIfNeeded: after an edge-cut fling finishes, bounce with the velocity it still had. */
+    private BounceIfNeeded;
+    AddSubView(control: SkiaControl): void;
+    InsertSubView(_index: number, control: SkiaControl): void;
+    RemoveSubView(control: SkiaControl): void;
+    /** Draw order: behind header, content, flow / sticky header, footer (the base walks it top-most first for gestures). */
+    protected GetGestureListeners(): readonly SkiaControl[];
+    /** Content gets an infinite constraint along the scroll axis; the scroll itself takes the box it is given. */
+    protected MeasureAbsolute(widthConstraint: number, heightConstraint: number, scale: number): ScaledSize;
+    protected OnLayoutChanged(): void;
+    /** Places Content at the current offset; called on layout and every frame while the offset moves. */
+    private ArrangeContent;
+    /** Header: sticky = pinned at the viewport start, else scrolled at HeaderParallaxRatio of the offset; footer after the content. */
+    private ArrangeHeaderFooter;
+    protected Paint(ctx: DrawingContext): void;
+    private OnScrolled;
+    ClampOffset(x: number, y: number, bounds: SKRect, strict?: boolean): {
+        X: number;
+        Y: number;
+    };
+    private CalculateOverscrollDistance;
+    /** Scroll to an offset in points; maxSpeedSecs > 0 animates along the deceleration curve. */
+    /**
+     * Scrolls every SkiaScroll ancestor of `control` so its DrawingRect lies inside the viewport (React extension,
+     * used by the accessibility overlay when keyboard focus lands on an off-screen node). Offsets are points.
+     */
+    static EnsureVisible(control: SkiaControl, maxTimeSecs?: number, paddingPts?: number): void;
+    /** Destination of the running ScrollTo per axis: the deceleration curve stops within its threshold, the exact value is applied when it finishes. */
+    private scrollToTargetX;
+    private scrollToTargetY;
+    private LandScrollTo;
+    ScrollTo(x: number, y: number, maxSpeedSecs: number, clamp?: boolean): void;
+    ScrollToTop(maxTimeSecs: number): void;
+    ScrollToBottom(maxTimeSecs: number): void;
+    StopScrolling(): void;
+    /**
+     * Scrolls so that item `index` is at the viewport start (or end). Like DrawnUi, Content must BE the
+     * templated layout (the recycled list is the scroll's only child; a header goes above the scroll or in Header).
+     */
+    ScrollToIndex(index: number, animate: boolean, option?: RelativePositionType): void;
+    private StopAnimators;
+    /** DrawnUi DecelerationRatio: FrictionScrolled / 100, floored at 0.1 friction. */
+    private get DecelerationRatio();
+    private ResetPan;
+    ProcessGestures(args: SkiaGesturesParameters, apply: GestureEventProcessingInfo): SkiaControl | null;
+    private Bounce;
+    /** DrawnUi StartToFlingFrom + PrepareToFlingAfterInitialized: cut the curve so it stops exactly at the edge. */
+    private StartToFlingFrom;
+    /**
+     * One wheel notch = WheelLineSize points, hard-clamped, animated over AutoScrollingSpeedMs.
+     * Notches arriving while the previous one is still animating add onto its target, so a fast wheel
+     * spin travels N steps instead of restarting from the barely-moved current offset.
+     */
+    private ApplyWheelScroll;
+}