drawnui-react 0.1.0-preview.1

package/dist/controls/RefreshIndicator.d.ts

@@ -0,0 +1,35 @@
+import type { ScrollOrientation } from "../core/Types";
+import { SkiaLayout } from "./SkiaLayout";
+/** C# IRefreshIndicator: the pull-to-refresh view a SkiaScroll drives while overscrolling. */
+export interface IRefreshIndicator {
+    /** ratio = overscroll / RefreshShowDistance (not clamped by the caller), ptsScrollOffset = current offset in points. */
+    SetDragRatio(ratio: number, ptsScrollOffset: number, ptsLimit: number, ptsTrigger: number): void;
+    IsVisible: boolean;
+    IsRunning: boolean;
+}
+/**
+ * Mirrors DrawnUi RefreshIndicator: a layout parked above (or left of) the viewport that `SetDragRatio` pulls into
+ * view with the C# position curve and fades in; `IsRunning` becomes true once fully shown (the refresh is in
+ * progress) — override `OnIsRunningChanged` to start / stop your animation. Put the visuals inside as children.
+ */
+export declare class RefreshIndicator extends SkiaLayout implements IRefreshIndicator {
+    private orientation;
+    get Orientation(): ScrollOrientation;
+    set Orientation(v: ScrollOrientation);
+    private isRunning;
+    /** Read-only: the indicator is fully shown (refresh in progress). */
+    get IsRunning(): boolean;
+    set IsRunning(v: boolean);
+    VisibleRatio: number;
+    constructor();
+    /** Only swaps alignments still at the previous orientation's defaults (C# UpdateOrientation). */
+    protected UpdateOrientation(previous: ScrollOrientation): void;
+    /**
+     * C# SetDragRatio: 0..1 (clamped here) -> position + opacity; running once fully shown. The view slides in with the
+     * pull: its far edge follows the overscroll until ptsLimit (RefreshShowDistance), where it stays while refreshing.
+     */
+    SetDragRatio(ratio: number, ptsScrollOffset: number, ptsLimit: number, _ptsTrigger: number): void;
+    /** C# SetAnimationState: shown while it has any opacity. */
+    SetAnimationState(running: boolean): void;
+    protected OnIsRunningChanged(_value: boolean): void;
+}

package/dist/controls/RefreshIndicator.js

@@ -0,0 +1,82 @@
+import { SkiaLayout } from "./SkiaLayout";
+/**
+ * Mirrors DrawnUi RefreshIndicator: a layout parked above (or left of) the viewport that `SetDragRatio` pulls into
+ * view with the C# position curve and fades in; `IsRunning` becomes true once fully shown (the refresh is in
+ * progress) — override `OnIsRunningChanged` to start / stop your animation. Put the visuals inside as children.
+ */
+export class RefreshIndicator extends SkiaLayout {
+    orientation = "Vertical";
+    get Orientation() { return this.orientation; }
+    set Orientation(v) {
+        if (this.orientation === v)
+            return;
+        if (v === "Both")
+            throw new Error("DrawnUi: RefreshIndicator supports Vertical or Horizontal");
+        const prev = this.orientation;
+        this.orientation = v;
+        this.UpdateOrientation(prev);
+    }
+    isRunning = false;
+    /** Read-only: the indicator is fully shown (refresh in progress). */
+    get IsRunning() { return this.isRunning; }
+    set IsRunning(v) { if (this.isRunning !== v) {
+        this.isRunning = v;
+        this.OnIsRunningChanged(v);
+    } }
+    VisibleRatio = 0;
+    constructor() {
+        super();
+        this.Type = "Absolute";
+        this.InputTransparent = true;
+        this.HorizontalOptions = "Fill";
+        this.VerticalOptions = "Start";
+        this.IsVisible = false;
+    }
+    /** Only swaps alignments still at the previous orientation's defaults (C# UpdateOrientation). */
+    UpdateOrientation(previous) {
+        const [oldH, oldV] = previous === "Horizontal" ? ["Start", "Fill"] : ["Fill", "Start"];
+        const [newH, newV] = this.orientation === "Horizontal" ? ["Start", "Fill"] : ["Fill", "Start"];
+        if (this.HorizontalOptions === oldH)
+            this.HorizontalOptions = newH;
+        if (this.VerticalOptions === oldV)
+            this.VerticalOptions = newV;
+        this.InvalidateMeasure();
+    }
+    /**
+     * C# SetDragRatio: 0..1 (clamped here) -> position + opacity; running once fully shown. The view slides in with the
+     * pull: its far edge follows the overscroll until ptsLimit (RefreshShowDistance), where it stays while refreshing.
+     */
+    SetDragRatio(ratio, ptsScrollOffset, ptsLimit, _ptsTrigger) {
+        ratio = Math.max(0, Math.min(1, ratio));
+        this.VisibleRatio = ratio;
+        let opacity = ratio;
+        const scale = this.RenderingScale || 1;
+        const size = (this.orientation === "Horizontal" ? this.MeasuredSize.Pixels.Width : this.MeasuredSize.Pixels.Height) / scale;
+        if (ratio <= 0) {
+            // parked just outside the viewport (C#: dividing by 0 poisoned the transform, so it is placed explicitly)
+            if (this.orientation === "Horizontal")
+                this.TranslationX = -size;
+            else
+                this.TranslationY = -size;
+            opacity = 0;
+        }
+        else if (size > 0) {
+            const shown = Math.min(Math.max(0, ptsScrollOffset), ptsLimit);
+            const pos = shown - size + Math.max(0, (ptsLimit - size) / 2); // centered in the gap when the gap is taller than the view
+            if (this.orientation === "Horizontal")
+                this.TranslationX = pos;
+            else
+                this.TranslationY = pos;
+            opacity = ratio;
+        }
+        this.IsRunning = opacity >= 1;
+        if (this.IsRunning)
+            opacity = 1;
+        this.Opacity = opacity;
+        this.SetAnimationState(opacity !== 0);
+        this.RepaintComposition();
+    }
+    /** C# SetAnimationState: shown while it has any opacity. */
+    SetAnimationState(running) { this.IsVisible = running; }
+    OnIsRunningChanged(_value) { }
+}

package/dist/controls/SkiaBackdrop.d.ts

@@ -0,0 +1,25 @@
+import type { Image } from "canvaskit-wasm";
+import type { DrawingContext } from "../core/SkiaControl";
+import { SkiaLayout } from "./SkiaLayout";
+/**
+ * Mirrors DrawnUi SkiaBackdrop: draws what is already painted beneath its box through `Blur` (points, default 5)
+ * and `Brightness` (gamma, 1 = unchanged), tinted by `BackgroundColor`; children draw first and are blurred too.
+ * The snapshot comes from the surface being drawn (`UseContext`) or the on-screen surface. Not cached (re-blurs
+ * on every frame it is drawn in; inside a cached parent it is re-recorded with that parent).
+ */
+export declare class SkiaBackdrop extends SkiaLayout {
+    Blur: number;
+    Brightness: number;
+    /** Snapshot the surface currently drawn into (true) or the on-screen surface (false). */
+    UseContext: boolean;
+    private snapshot?;
+    constructor();
+    get HasEffects(): boolean;
+    /** The last snapshot taken (C# GetImage hands it over: the caller owns it afterwards). */
+    GetImage(): Image | undefined;
+    /** Background is painted inside Paint(), after the children and before the snapshot (C# order). */
+    protected PaintBackground(_ctx: DrawingContext): void;
+    protected PaintsBackgroundWithoutColor(): boolean;
+    protected Paint(ctx: DrawingContext): void;
+    protected OnDisposing(): void;
+}

package/dist/controls/SkiaBackdrop.js

@@ -0,0 +1,80 @@
+import { Super } from "../core/Super";
+import { SkiaImageEffects } from "../core/ImageEffects";
+import { SkiaLayout } from "./SkiaLayout";
+/**
+ * Mirrors DrawnUi SkiaBackdrop: draws what is already painted beneath its box through `Blur` (points, default 5)
+ * and `Brightness` (gamma, 1 = unchanged), tinted by `BackgroundColor`; children draw first and are blurred too.
+ * The snapshot comes from the surface being drawn (`UseContext`) or the on-screen surface. Not cached (re-blurs
+ * on every frame it is drawn in; inside a cached parent it is re-recorded with that parent).
+ */
+export class SkiaBackdrop extends SkiaLayout {
+    Blur = 5;
+    Brightness = 1;
+    /** Snapshot the surface currently drawn into (true) or the on-screen surface (false). */
+    UseContext = true;
+    snapshot;
+    constructor() {
+        super();
+        this.HorizontalOptions = "Fill";
+        this.VerticalOptions = "Fill";
+    }
+    get HasEffects() { return this.Blur !== 0 || this.Brightness !== 1; }
+    /** The last snapshot taken (C# GetImage hands it over: the caller owns it afterwards). */
+    GetImage() { const i = this.snapshot; this.snapshot = undefined; return i; }
+    /** Background is painted inside Paint(), after the children and before the snapshot (C# order). */
+    PaintBackground(_ctx) { }
+    PaintsBackgroundWithoutColor() { return false; }
+    Paint(ctx) {
+        const d = ctx.Destination;
+        if (d.Width <= 0 || d.Height <= 0)
+            return;
+        const CK = Super.CK;
+        const canvas = ctx.Context.Canvas;
+        super.Paint(ctx); // children
+        if (this.BackgroundColor) {
+            const paint = this.CreateBackgroundPaint(d);
+            canvas.drawRect(CK.LTRBRect(d.Left, d.Top, d.Right, d.Bottom), paint);
+            paint.delete();
+        }
+        if (!this.HasEffects)
+            return;
+        // C# UseContext: snapshot the surface the pixels end up on — the on-screen surface or the nearest Image cache
+        // surface (Origin = its top-left in canvas pixels). Content beneath is already there because caches are recorded
+        // inline while the parent paints, so this also works while an Operations picture is being recorded.
+        const surface = this.UseContext ? ctx.Context.Surface : this.Superview?.Surface;
+        if (!surface)
+            return;
+        surface.flush();
+        const origin = this.UseContext ? ctx.Context.Origin : undefined;
+        const ox = origin?.X ?? 0, oy = origin?.Y ?? 0;
+        const l = Math.floor(d.Left - ox), t = Math.floor(d.Top - oy), r = Math.ceil(d.Right - ox), b = Math.ceil(d.Bottom - oy);
+        // whole-surface snapshot, sub-rect on draw: a bounded snapshot of a GPU surface is not origin-safe in CanvasKit
+        const image = surface.makeImageSnapshot();
+        if (!image)
+            return;
+        const paint = new CK.Paint();
+        const blur = this.Blur > 0 ? CK.ImageFilter.MakeBlur(this.Blur * ctx.Scale, this.Blur * ctx.Scale, CK.TileMode.Mirror, null) : null;
+        if (blur)
+            paint.setImageFilter(blur);
+        const gamma = this.Brightness !== 1 ? SkiaImageEffects.Gamma(this.Brightness) : null;
+        if (gamma)
+            paint.setColorFilter(gamma);
+        const saved = canvas.save();
+        canvas.clipRect(CK.LTRBRect(d.Left, d.Top, d.Right, d.Bottom), CK.ClipOp.Intersect, true);
+        canvas.drawImageRectOptions(image, CK.LTRBRect(l, t, r, b), CK.LTRBRect(d.Left, d.Top, d.Right, d.Bottom), CK.FilterMode.Linear, CK.MipmapMode.None, paint);
+        canvas.restoreToCount(saved);
+        blur?.delete();
+        gamma?.delete();
+        paint.delete();
+        const kill = this.snapshot;
+        this.snapshot = image;
+        kill?.delete();
+        // What is beneath may change without invalidating this branch (an image that loads later, a sibling animating):
+        // stale the ancestors' caches for the NEXT frame, after the current record has finished, without asking for one.
+        queueMicrotask(() => { let p = this.Parent; while (p) {
+            p.InvalidateCache();
+            p = p.Parent;
+        } });
+    }
+    OnDisposing() { this.snapshot?.delete(); this.snapshot = undefined; }
+}

package/dist/controls/SkiaButton.d.ts

@@ -0,0 +1,58 @@
+import type { Path } from "canvaskit-wasm";
+import type { SkiaControl } from "../core/SkiaControl";
+import { type Color, type CornerRadius, ScaledSize, type SkiaTouchAnimation } from "../core/Types";
+import { type GestureEventProcessingInfo, type SkiaGesturesParameters } from "../core/Gestures";
+import { SkiaLayout } from "./SkiaLayout";
+import { type PrebuiltControlStyle, type ResolvedControlStyle } from "../core/ControlStyle";
+/**
+ * Mirrors DrawnUi SkiaButton (default style): a SkiaShape frame tagged "BtnShape" + a centered SkiaLabel
+ * tagged "BtnText". Consumes Down/Up/Tapped inside its rect; releases the pressed state when a pan exceeds
+ * PanThreshold. Press feedback = ApplyEffect (ripple), no darkening.
+ */
+export declare class SkiaButton extends SkiaLayout {
+    static PanThreshold: number;
+    Text: string;
+    /** Look of the default content (C# SkiaButton.ControlStyle): background, corners, font, minimum size when left unset. */
+    ControlStyle: PrebuiltControlStyle;
+    TextColor: Color;
+    FontSize: number;
+    FontFamily: string;
+    /** Glyph fallback chain for the label (React extension, same semantics as SkiaLabel.FontFamilyFallback). */
+    FontFamilyFallback: string;
+    /** Frame corner radius, points (DrawnUi default look uses 8). */
+    CornerRadius: CornerRadius | number;
+    StrokeColor: Color;
+    StrokeWidth: number;
+    IsPressed: boolean;
+    IsDisabled: boolean;
+    LockPanning: boolean;
+    /** Touch feedback played on Down (DrawnUi SkiaButton.ApplyEffect). */
+    ApplyEffect: SkiaTouchAnimation;
+    TotalDown: number;
+    TotalTapped: number;
+    Down?: (sender: SkiaButton, args: SkiaGesturesParameters) => void;
+    Up?: (sender: SkiaButton, args: SkiaGesturesParameters) => void;
+    private readonly frame;
+    private readonly label;
+    private lastDownPts;
+    private hadDown;
+    constructor();
+    /** Set to `Aria.RoleButton` to expose every button (React extension). */
+    static DefaultAccessibilityRole?: string;
+    protected DefaultAccessibilityLabel(): string | undefined;
+    protected DefaultAccessibilityCanInteract(): boolean;
+    /** The button's own BackgroundColor/CornerRadius/Stroke are the frame's; the button itself paints nothing. */
+    protected PaintBackground(): void;
+    get UsingControlStyle(): ResolvedControlStyle;
+    /** C# Create*StyleContent defaults: accent, corner radius, font size/weight, minimum content size. */
+    private static Look;
+    protected MeasureAbsolute(w: number, h: number, scale: number): ScaledSize;
+    /** The frame sits under the padding box: arrange children in the full rect, the label centered inside padding. */
+    protected OnLayoutChanged(): void;
+    /** Ripple clipped to the rounded frame. */
+    CreateClip(): Path;
+    /** DrawnUi SkiaButton.OnDown: press feedback; true = consume Down. */
+    protected OnDown(_args: SkiaGesturesParameters, apply: GestureEventProcessingInfo): boolean;
+    private SetUp;
+    ProcessGestures(args: SkiaGesturesParameters, apply: GestureEventProcessingInfo): SkiaControl | null;
+}

package/dist/controls/SkiaButton.js

@@ -0,0 +1,148 @@
+import { Colors, SKRect, ScaledSize, SkiaShadow, Thickness } from "../core/Types";
+import { SKPoint } from "../core/Gestures";
+import { SkiaLayout } from "./SkiaLayout";
+import { SkiaLabel } from "./SkiaLabel";
+import { SkiaShape } from "./SkiaShape";
+import { ResolveControlStyle } from "../core/ControlStyle";
+/**
+ * Mirrors DrawnUi SkiaButton (default style): a SkiaShape frame tagged "BtnShape" + a centered SkiaLabel
+ * tagged "BtnText". Consumes Down/Up/Tapped inside its rect; releases the pressed state when a pan exceeds
+ * PanThreshold. Press feedback = ApplyEffect (ripple), no darkening.
+ */
+export class SkiaButton extends SkiaLayout {
+    static PanThreshold = 5;
+    Text = "";
+    /** Look of the default content (C# SkiaButton.ControlStyle): background, corners, font, minimum size when left unset. */
+    ControlStyle = "Unset";
+    TextColor = Colors.White;
+    FontSize = 15;
+    FontFamily = "";
+    /** Glyph fallback chain for the label (React extension, same semantics as SkiaLabel.FontFamilyFallback). */
+    FontFamilyFallback = "";
+    /** Frame corner radius, points (DrawnUi default look uses 8). */
+    CornerRadius = 8;
+    StrokeColor = Colors.Transparent;
+    StrokeWidth = 0;
+    IsPressed = false;
+    IsDisabled = false;
+    LockPanning = false;
+    /** Touch feedback played on Down (DrawnUi SkiaButton.ApplyEffect). */
+    ApplyEffect = "Ripple"; // C# default
+    TotalDown = 0;
+    TotalTapped = 0;
+    Down;
+    Up;
+    frame = new SkiaShape();
+    label = new SkiaLabel();
+    lastDownPts = SKPoint.Empty;
+    hadDown = false;
+    constructor() {
+        super();
+        this.Type = "Absolute";
+        this.Padding = new Thickness(16, 10);
+        this.frame.Tag = "BtnShape";
+        this.frame.HorizontalOptions = "Fill";
+        this.frame.VerticalOptions = "Fill";
+        this.label.Tag = "BtnText";
+        this.label.AccessibilityRole = "presentation"; // the button is the accessible node, not its inner label (C# MainLabel.AccessibilityRole = null)
+        this.label.HorizontalOptions = "Center";
+        this.label.VerticalOptions = "Center";
+        this.AddSubView(this.frame);
+        this.AddSubView(this.label);
+    }
+    /** Set to `Aria.RoleButton` to expose every button (React extension). */
+    static DefaultAccessibilityRole;
+    DefaultAccessibilityLabel() { return this.Text || undefined; }
+    DefaultAccessibilityCanInteract() { return !this.IsDisabled; }
+    /** The button's own BackgroundColor/CornerRadius/Stroke are the frame's; the button itself paints nothing. */
+    PaintBackground() { }
+    get UsingControlStyle() { return ResolveControlStyle(this.ControlStyle); }
+    /** C# Create*StyleContent defaults: accent, corner radius, font size/weight, minimum content size. */
+    static Look(s) {
+        switch (s) {
+            case "Cupertino": return { bg: "#007AFF", radius: 8, font: 17, weight: 600, minH: 36, shadow: new SkiaShadow({ X: 0, Y: 1, Blur: 2, Opacity: 0.2, Color: Colors.Black }) };
+            case "Material": return { bg: "#2196F3", radius: 4, font: 14, weight: 0, minH: 40, shadow: new SkiaShadow({ X: 0, Y: 2, Blur: 4, Opacity: 0.3, Color: Colors.Black }) };
+            case "Material3": return { bg: "#6750A4", radius: 20, font: 14, weight: 0, minH: 40 };
+            case "Windows": return { bg: "#0078D7", radius: 4, font: 15, weight: 500, minH: 32, shadow: new SkiaShadow({ X: 0, Y: 1, Blur: 1, Opacity: 0.2, Color: Colors.Black }) };
+            default: return { bg: "#DC143C", radius: 8, font: 15, weight: 0, minH: 41 };
+        }
+    }
+    MeasureAbsolute(w, h, scale) {
+        const look = SkiaButton.Look(this.UsingControlStyle);
+        this.frame.BackgroundColor = this.BackgroundColor ?? look.bg;
+        this.frame.CornerRadius = this.CornerRadius === 8 ? look.radius : this.CornerRadius; // C#: 8 = "not customized"
+        this.frame.StrokeColor = this.StrokeColor;
+        this.frame.StrokeWidth = this.StrokeWidth;
+        if (this.frame.Shadows[0] !== look.shadow)
+            this.frame.Shadows = look.shadow ? [look.shadow] : [];
+        if (this.MinimumHeightRequest < 0 && this.UsingControlStyle !== "Unset")
+            this.MinimumHeightRequest = look.minH;
+        this.label.Text = this.Text;
+        this.label.TextColor = this.TextColor;
+        this.label.FontSize = this.FontSize === 15 ? look.font : this.FontSize;
+        this.label.FontWeight = look.weight;
+        this.label.FontFamily = this.FontFamily;
+        this.label.FontFamilyFallback = this.FontFamilyFallback;
+        // Size comes from the label + Padding; the Fill frame follows whatever the button is arranged to.
+        const px = this.Padding.HorizontalThickness * scale, py = this.Padding.VerticalThickness * scale;
+        const l = this.label.Measure(isFinite(w) ? w - px : w, isFinite(h) ? h - py : h, scale);
+        return ScaledSize.FromPixels(l.Pixels.Width + px, l.Pixels.Height + py, scale);
+    }
+    /** The frame sits under the padding box: arrange children in the full rect, the label centered inside padding. */
+    OnLayoutChanged() {
+        const scale = this.RenderingScale;
+        const r = this.DrawingRect;
+        this.frame.Arrange(r, -1, -1, scale);
+        const p = this.Padding;
+        this.label.Arrange(new SKRect(r.Left + p.Left * scale, r.Top + p.Top * scale, r.Right - p.Right * scale, r.Bottom - p.Bottom * scale), -1, -1, scale);
+    }
+    /** Ripple clipped to the rounded frame. */
+    CreateClip() { return this.frame.CreateClip(); }
+    /** DrawnUi SkiaButton.OnDown: press feedback; true = consume Down. */
+    OnDown(_args, apply) {
+        if (this.ApplyEffect === "Ripple") {
+            const pts = this.GetOffsetInsideControlInPoints(apply.MappedLocation, apply.ChildOffset);
+            this.PlayRippleAnimation(this.TouchEffectColor, pts.X, pts.Y);
+        }
+        return true;
+    }
+    SetUp(args) {
+        this.IsPressed = false;
+        this.hadDown = false;
+        this.Up?.(this, args);
+        this.Repaint();
+    }
+    ProcessGestures(args, apply) {
+        if (this.IsDisabled)
+            return null;
+        const point = args.Event.Location;
+        if (args.Type === "Down") {
+            this.IsPressed = true;
+            this.lastDownPts = point;
+            this.hadDown = true;
+            this.TotalDown++;
+            this.Down?.(this, args);
+            this.Repaint();
+            return this.OnDown(args, apply) ? this : null;
+        }
+        if (args.Type === "Panning") {
+            if (this.LockPanning)
+                return this;
+            const t = SkiaButton.PanThreshold * this.RenderingScale;
+            if (Math.abs(point.X - this.lastDownPts.X) > t || Math.abs(point.Y - this.lastDownPts.Y) > t) {
+                if (this.hadDown)
+                    this.SetUp(args);
+                this.hadDown = false;
+                return null;
+            }
+        }
+        else if (args.Type === "Up") {
+            this.SetUp(args);
+        }
+        else if (args.Type === "Tapped") {
+            this.TotalTapped++;
+            return this.SendTapped(args, apply) ? this : null;
+        }
+        return this.hadDown ? this : null;
+    }
+}

package/dist/controls/SkiaCarousel.d.ts

@@ -0,0 +1,133 @@
+import type { DrawingContext, SkiaControl } from "../core/SkiaControl";
+import { type GestureEventProcessingInfo, SKPoint, type SkiaGesturesParameters } from "../core/Gestures";
+import { Spring } from "../core/ScrollAnimators";
+import { ScaledSize } from "../core/Types";
+import { SnappingLayout } from "./SnappingLayout";
+export interface SnapPoint {
+    Id: number;
+    Location: SKPoint;
+}
+/**
+ * Mirrors DrawnUi SkiaCarousel: every child (static `Children` or a recycled `ItemsSource` + `ItemTemplate` cell)
+ * is a full-size slide laid along the axis, `SidesOffset` peeks the neighbours, `Spacing` separates slides; a
+ * swipe / release snaps to the nearest slide by velocity, `SelectedIndex` drives and reports the position,
+ * `IsLooped` wraps around through virtual anchors, `PreloadNeighboors` draws the hidden neighbours,
+ * `DynamicSize` sizes an auto-sized carousel from the selected slide, `SwipeSpeed` / `LinearSpeedMs` tune the snap.
+ */
+export declare class SkiaCarousel extends SnappingLayout {
+    IsVertical: boolean;
+    /** Side padding in points so the previous/next slides peek in. */
+    SidesOffset: number;
+    /** Accepted for parity; C# marks it TODO. */
+    IsRightToLeft: boolean;
+    /** Wrap from the last slide to the first and back. */
+    IsLooped: boolean;
+    /** Draw the hidden neighbour slides too (preloads images etc.), C# default true. */
+    PreloadNeighboors: boolean;
+    /** An auto-sized carousel takes the size of the selected slide instead of the largest one. */
+    DynamicSize: boolean;
+    /** Multiplies the snap velocity / spring stiffness (C# SwipeSpeed). */
+    SwipeSpeed: number;
+    /** Milliseconds a whole slide takes when snapping without Bounces; 0 = derived from the velocity (C# LinearSpeedMs). */
+    LinearSpeedMs: number;
+    SelectedIndexChanged?: (sender: SkiaCarousel, index: number) => void;
+    ItemAppearing?: (sender: SkiaCarousel, index: number) => void;
+    ItemDisappearing?: (sender: SkiaCarousel, index: number) => void;
+    private selectedIndex;
+    private lastIndex;
+    private childrenInitialized;
+    private layoutKey;
+    private lastLooped;
+    private cellSize;
+    /** Slide size in points (C# CellSize). */
+    protected get CellSize(): {
+        W: number;
+        H: number;
+    };
+    private panningOffset;
+    private panningStart;
+    private wrongDirection;
+    private snapIfNoPanOnUp;
+    private hadDown;
+    private itemsVisibility;
+    private snapPointsVirtual?;
+    private scrollAmount;
+    /** Slides drawn on screen by the last frame: the only gesture targets (C# rendering tree). */
+    private visibleViews;
+    constructor();
+    get SelectedIndex(): number;
+    set SelectedIndex(v: number);
+    /** Previously selected index (C# LastIndex). */
+    get LastIndex(): number;
+    get MaxIndex(): number;
+    get ChildrenTotal(): number;
+    get ChildrenCount(): number;
+    get IsAtStart(): boolean;
+    get IsAtEnd(): boolean;
+    /** 0..1 progress of the content along all slides (C# ScrollProgress). */
+    get ScrollProgress(): number;
+    /** Scroll amount of the selected slide, 0..1 of the track (C# ScrollAmount). */
+    get ScrollAmount(): number;
+    /** Fraction of the current transition between two slides (C# TransitionProgress). */
+    get TransitionProgress(): number;
+    private OnSelectedIndexChanged;
+    /** Index reached by scrolling: state only, no snap (C# SelectedIndex set from UpdateReportedPosition). */
+    private ReportIndex;
+    GoNext(): void;
+    GoPrev(): void;
+    /** C# ScrollTo(index, animate). */
+    ScrollTo(index: number, animate?: boolean): void;
+    private get ApplyLoopedLogic();
+    /** Step between slides in points: slide size + Spacing - 2 * SidesOffset (C# InitializeChildren). */
+    private Step;
+    /**
+     * C# InterruptSnapping: stops an in-flight snap before a programmatic index change and continues from the visual
+     * position; for IsLooped the position is shifted by whole strips into the neighbourhood of the current index.
+     */
+    private InterruptSnapping;
+    private ApplyIndex;
+    UpdateReportedPosition(): void;
+    ApplyPosition(position: SKPoint): void;
+    /** The position changed (C# OnScrollProgressChanged); SkiaShaderCarousel drives its transition here. */
+    protected OnScrollProgressChanged(): void;
+    /** Snap points were (re)built (C# OnChildrenInitialized). */
+    protected OnChildrenInitialized(): void;
+    /** Where a drawn slide goes for its scroll offset; SkiaShaderCarousel keeps every slide in place (C# AnimateVisibleChild). */
+    protected SlideOffset(offset: SKPoint): SKPoint;
+    /** An already realized slide (C# ChildrenFactory.GetViewForIndex): no cell is created. */
+    protected GetExistingView(index: number): SkiaControl | undefined;
+    private GetVirtualSnapPoints;
+    protected GetVirtualAnchor(current: SKPoint): SnapPoint;
+    protected FindNearestAnchorInternal(current: SKPoint, velocity: SKPoint): SKPoint;
+    /** C# SkiaCarousel.ScrollToNearestAnchor: velocity below 100 counts as none; looped snaps around virtual anchors. */
+    ScrollToNearestAnchor(location: SKPoint, velocity: SKPoint): void;
+    /** C# SkiaCarousel.SelectNextAnchor: base choice, plus a wrap to the virtual anchor at the strip borders when looped. */
+    SelectNextAnchor(origin: SKPoint, velocity: SKPoint): SKPoint;
+    /** C# FixIndex: a virtual anchor becomes the real one, the position keeps its offset (visually identical, looped drawing wraps). */
+    private FixIndex;
+    private FixPosition;
+    protected OnTransitionChanged(): void;
+    protected ScaleSnapVelocity(velocity: SKPoint): SKPoint;
+    protected CreateSnapSpring(): Spring;
+    protected SpringVelocity(velocity: SKPoint): SKPoint;
+    protected GetSnapDurationSeconds(start: SKPoint, end: SKPoint, velocity: SKPoint, displacement: SKPoint): number;
+    private InnerRect;
+    /** C# AdaptTemplate: slides fill the carousel (Start only when the carousel auto-sizes on that axis), SidesOffset as margin. */
+    private AdaptTemplate;
+    private GetChild;
+    protected MeasureAbsolute(w: number, h: number, scale: number): ScaledSize;
+    protected OnLayoutChanged(): void;
+    /** C# InitializeChildren: snap points from the slide size, bounds, and the current index applied instantly. */
+    private InitializeChildren;
+    /** C# GetContentOffsetBounds: the snap extent, or unbounded along the axis when looped. */
+    private GetContentOffsetBounds;
+    /** C# CalculateChildPosition: slide offset in points, visibility, and "next to screen"; looped draws the edge slides on the other side. */
+    private CalculateChildPosition;
+    private SendVisibility;
+    /** C# RenderViewsList: position every slide, draw the visible ones (+ neighbours when PreloadNeighboors), release the rest. */
+    protected Paint(ctx: DrawingContext): void;
+    private SlideRect;
+    protected GetGestureListeners(): readonly SkiaControl[];
+    ProcessGestures(args: SkiaGesturesParameters, apply: GestureEventProcessingInfo): SkiaControl | null;
+    protected DefaultAccessibilityLabel(): string | undefined;
+}