drawnui-react 0.1.0-preview.1

package/dist/controls/AnimatedFramesRenderer.d.ts

@@ -0,0 +1,58 @@
+import { type DrawingContext, SkiaControl } from "../core/SkiaControl";
+import { SkiaValueAnimator } from "../core/Animators";
+/**
+ * Mirrors DrawnUi AnimatedFramesRenderer: base for controls that play frames (Lottie, GIF, sprites) with a
+ * range animator driven by the canvas frame loop: `AutoPlay`, `Repeat` (-1 = forever), `SpeedRatio`,
+ * `DefaultFrame` (-1 = last), `Start`/`Stop`/`Seek`, `Started`/`Finished`.
+ */
+export declare class AnimatedFramesRenderer extends SkiaControl {
+    Finished?: (sender: AnimatedFramesRenderer) => void;
+    Started?: (sender: AnimatedFramesRenderer) => void;
+    /** Range animator over the frames, created on the first layout (C# RangeAnimator). */
+    Animator?: SkiaValueAnimator;
+    /** Start() was asked before the control could play; plays as soon as it can. */
+    PlayWhenAvailable: boolean;
+    protected WasStarted: boolean;
+    private delayedPlay;
+    private wasLayout;
+    private defaultFrame;
+    private speedRatio;
+    private repeat;
+    private autoPlay;
+    /** Frame shown when not playing; -1 = the last frame. */
+    get DefaultFrame(): number;
+    set DefaultFrame(v: number);
+    /** Playback speed multiplier. */
+    get SpeedRatio(): number;
+    set SpeedRatio(v: number);
+    /** > 0 how many more times to repeat, < 0 loops forever. */
+    get Repeat(): number;
+    set Repeat(v: number);
+    get AutoPlay(): boolean;
+    set AutoPlay(v: boolean);
+    get IsPlaying(): boolean;
+    protected get CanPlay(): boolean;
+    protected Paint(ctx: DrawingContext): void;
+    /** Draws the current frame into ctx.Destination. */
+    protected RenderFrame(_ctx: DrawingContext): void;
+    protected OnLayoutChanged(): void;
+    PlayIfNeeded(): void;
+    InitializeAnimator(): void;
+    /** Configure the animator range/speed once the frames source is known. */
+    protected OnAnimatorInitializing(): void;
+    /** The animator produced a new frame value. */
+    protected OnAnimatorUpdated(_value: number): void;
+    protected CheckCanStartAnimator(): boolean;
+    protected OnAnimatorStarting(): void;
+    protected OnAnimatorSeeking(_frame: number): void;
+    Seek(frame: number): void;
+    Start(delayMs?: number): void;
+    Stop(): void;
+    /** Frame at a 0..1 ratio of the animator range. */
+    GetFrameAt(ratio: number): number;
+    protected OnFinished(): void;
+    protected OnStarted(): void;
+    protected ApplySpeed(): void;
+    protected ApplyDefaultFrame(): void;
+    protected OnDisposing(): void;
+}

package/dist/controls/AnimatedFramesRenderer.js

@@ -0,0 +1,133 @@
+import { SkiaControl } from "../core/SkiaControl";
+import { SkiaValueAnimator } from "../core/Animators";
+/**
+ * Mirrors DrawnUi AnimatedFramesRenderer: base for controls that play frames (Lottie, GIF, sprites) with a
+ * range animator driven by the canvas frame loop: `AutoPlay`, `Repeat` (-1 = forever), `SpeedRatio`,
+ * `DefaultFrame` (-1 = last), `Start`/`Stop`/`Seek`, `Started`/`Finished`.
+ */
+export class AnimatedFramesRenderer extends SkiaControl {
+    Finished;
+    Started;
+    /** Range animator over the frames, created on the first layout (C# RangeAnimator). */
+    Animator;
+    /** Start() was asked before the control could play; plays as soon as it can. */
+    PlayWhenAvailable = false;
+    WasStarted = false;
+    delayedPlay = false;
+    wasLayout = false;
+    defaultFrame = 0;
+    speedRatio = 1;
+    repeat = 0;
+    autoPlay = true;
+    /** Frame shown when not playing; -1 = the last frame. */
+    get DefaultFrame() { return this.defaultFrame; }
+    set DefaultFrame(v) { if (this.defaultFrame !== v) {
+        this.defaultFrame = v;
+        this.ApplyDefaultFrame();
+    } }
+    /** Playback speed multiplier. */
+    get SpeedRatio() { return this.speedRatio; }
+    set SpeedRatio(v) { if (this.speedRatio !== v) {
+        this.speedRatio = v;
+        this.ApplySpeed();
+    } }
+    /** > 0 how many more times to repeat, < 0 loops forever. */
+    get Repeat() { return this.repeat; }
+    set Repeat(v) { if (this.repeat !== v) {
+        this.repeat = v;
+        if (this.Animator)
+            this.Animator.Repeat = v;
+    } }
+    get AutoPlay() { return this.autoPlay; }
+    set AutoPlay(v) { if (this.autoPlay !== v) {
+        this.autoPlay = v;
+        if (!v)
+            this.Stop();
+    } }
+    get IsPlaying() { return !!this.Animator?.IsRunning; }
+    get CanPlay() { return this.wasLayout && this.CheckCanStartAnimator(); }
+    Paint(ctx) { this.RenderFrame(ctx); }
+    /** Draws the current frame into ctx.Destination. */
+    RenderFrame(_ctx) { }
+    OnLayoutChanged() {
+        super.OnLayoutChanged();
+        // Arrange runs every frame here (C# only on a real layout change): initialize once, or a playing
+        // animator would be restarted at its first frame on every draw
+        if (!this.wasLayout) {
+            this.wasLayout = true;
+            this.InitializeAnimator();
+        }
+        this.PlayIfNeeded();
+    }
+    PlayIfNeeded() {
+        if (this.PlayWhenAvailable && this.Animator) {
+            this.PlayWhenAvailable = false;
+            if (!this.Animator.IsRunning)
+                this.Start();
+        }
+    }
+    InitializeAnimator() {
+        if (!this.Animator) {
+            const a = new SkiaValueAnimator(this);
+            a.OnUpdated = (v) => this.OnAnimatorUpdated(v);
+            a.OnStart = () => { this.WasStarted = true; this.OnStarted(); };
+            a.OnStop = () => { if (this.WasStarted)
+                this.OnFinished(); this.WasStarted = false; };
+            this.Animator = a;
+        }
+        this.Animator.Repeat = this.repeat;
+        this.OnAnimatorInitializing();
+        if (this.delayedPlay || (this.autoPlay && this.CheckCanStartAnimator())) {
+            this.delayedPlay = false;
+            this.Start();
+        }
+    }
+    /** Configure the animator range/speed once the frames source is known. */
+    OnAnimatorInitializing() { }
+    /** The animator produced a new frame value. */
+    OnAnimatorUpdated(_value) { }
+    CheckCanStartAnimator() { return true; }
+    OnAnimatorStarting() { }
+    OnAnimatorSeeking(_frame) { }
+    Seek(frame) { this.OnAnimatorSeeking(frame); }
+    Start(delayMs = 0) {
+        if (!this.Animator) {
+            this.delayedPlay = true;
+            return;
+        }
+        if (this.Animator.IsRunning)
+            this.Animator.Stop();
+        if (this.CanPlay) {
+            this.Animator.Repeat = this.repeat; // the animator consumes its counter while looping
+            this.OnAnimatorStarting();
+            this.Animator.Start(delayMs);
+        }
+        if (!this.Animator.IsRunning)
+            this.PlayWhenAvailable = true;
+        this.InvalidateCache();
+        this.RepaintComposition();
+    }
+    Stop() {
+        this.PlayWhenAvailable = false;
+        this.delayedPlay = false;
+        if (!this.Animator)
+            return;
+        this.Animator.Stop();
+        this.InvalidateCache();
+        this.RepaintComposition();
+    }
+    /** Frame at a 0..1 ratio of the animator range. */
+    GetFrameAt(ratio) { return this.Animator ? (this.Animator.mMaxValue - this.Animator.mMinValue) * ratio : 0; }
+    OnFinished() { this.Finished?.(this); }
+    OnStarted() { this.Started?.(this); }
+    ApplySpeed() { }
+    ApplyDefaultFrame() { if (!this.IsPlaying && this.Animator)
+        this.Seek(this.defaultFrame); }
+    OnDisposing() {
+        if (this.Animator) {
+            this.Stop();
+            this.Animator.Dispose();
+            this.Animator = undefined;
+        }
+    }
+}

package/dist/controls/GridStructure.d.ts

@@ -0,0 +1,79 @@
+import type { SkiaControl } from "../core/SkiaControl";
+import type { GridLength } from "../core/Types";
+import type { SkiaLayout } from "./SkiaLayout";
+type GridUnit = "Absolute" | "Auto" | "Star";
+/** One row/column track (MAUI DefinitionInfo): its GridLength and the resolved size in points. */
+export declare class DefinitionInfo {
+    Unit: GridUnit;
+    Value: number;
+    Size: number;
+    constructor(length: GridLength);
+    get IsAuto(): boolean;
+    get IsStar(): boolean;
+    get IsAbsolute(): boolean;
+    /** Auto tracks grow to the largest measured child. */
+    Update(size: number): void;
+}
+/** Parses "*, 2*, Auto, 100" (or an array of the same values) into tracks. */
+export declare function ParseDefinitions(defs: string | GridLength[] | undefined): DefinitionInfo[];
+/**
+ * Port of DrawnUi SkiaGridStructure (itself adapted from the MAUI Grid manager). Works in POINTS: constraints come in
+ * already reduced by the grid's padding, cells are returned relative to the padded box. Children are measured in
+ * pixels through SkiaControl.Measure and their Units sizes drive the tracks.
+ */
+export declare class SkiaGridStructure {
+    private readonly grid;
+    private readonly widthConstraint;
+    private readonly heightConstraint;
+    private readonly scale;
+    readonly Rows: DefinitionInfo[];
+    readonly Columns: DefinitionInfo[];
+    readonly ColumnSpacing: number;
+    readonly RowSpacing: number;
+    private readonly children;
+    private readonly cells;
+    private readonly spans;
+    private readonly explicitWidth;
+    private readonly explicitHeight;
+    constructor(grid: SkiaLayout, widthConstraint: number, heightConstraint: number, scale: number);
+    private InitializeTracks;
+    private static CreateDefinitionIfMissing;
+    private static ToLengthType;
+    private InitializeCells;
+    private static Sum;
+    GridWidth(): number;
+    GridHeight(): number;
+    LeftEdgeOfColumn(column: number): number;
+    TopEdgeOfRow(row: number): number;
+    /** Cell rectangle in points relative to the padded box (+ offsets). */
+    GetCellBoundsFor(view: SkiaControl, xOffset?: number, yOffset?: number): {
+        Left: number;
+        Top: number;
+        Width: number;
+        Height: number;
+    };
+    private MeasureCells;
+    /** Points -> pixels for Measure; negative/NaN = unconstrained. */
+    private MeasurePx;
+    private MeasureChild;
+    private TrackSpan;
+    private ResolveSpans;
+    private static ResolveSpan;
+    private ApplyMinimumDimensionsFromFillChildren;
+    private ResolveStars;
+    private ResolveStarColumns;
+    private ResolveStarRows;
+    private MeasureKnownCells;
+    private AvailableWidth;
+    private AvailableHeight;
+    /** Re-resolves stars against the final size when the grid has an explicit size request (C# DecompressStars). */
+    DecompressStars(targetWidth: number, targetHeight: number): void;
+    private CompressStarMeasurements;
+    /** Stars shrink to what their cells actually need (so an auto-sized grid does not take the whole constraint). */
+    private CompressStars;
+    private static ExpandStarsInSpan;
+    private static ZeroOutStars;
+    /** Tracks are final only now: measure every child at its final cell so its internal layout matches the arranged box. */
+    RemeasureChildrenAtFinalCells(): void;
+}
+export {};

package/dist/controls/GridStructure.js

@@ -0,0 +1,403 @@
+/** One row/column track (MAUI DefinitionInfo): its GridLength and the resolved size in points. */
+export class DefinitionInfo {
+    Unit;
+    Value;
+    Size;
+    constructor(length) {
+        if (typeof length === "number") {
+            this.Unit = "Absolute";
+            this.Value = length;
+            this.Size = length;
+        }
+        else if (length === "Auto") {
+            this.Unit = "Auto";
+            this.Value = 1;
+            this.Size = 0;
+        }
+        else {
+            this.Unit = "Star";
+            this.Value = length === "*" ? 1 : parseFloat(length) || 1;
+            this.Size = 0;
+        }
+    }
+    get IsAuto() { return this.Unit === "Auto"; }
+    get IsStar() { return this.Unit === "Star"; }
+    get IsAbsolute() { return this.Unit === "Absolute"; }
+    /** Auto tracks grow to the largest measured child. */
+    Update(size) { if (size > this.Size)
+        this.Size = size; }
+}
+/** Parses "*, 2*, Auto, 100" (or an array of the same values) into tracks. */
+export function ParseDefinitions(defs) {
+    if (!defs)
+        return [];
+    const list = typeof defs === "string"
+        ? defs.split(",").map((s) => s.trim()).filter(Boolean).map((s) => (/^\d+(\.\d+)?$/.test(s) ? parseFloat(s) : s))
+        : defs;
+    return list.map((l) => new DefinitionInfo(l));
+}
+var LengthType;
+(function (LengthType) {
+    LengthType[LengthType["None"] = 0] = "None";
+    LengthType[LengthType["Absolute"] = 1] = "Absolute";
+    LengthType[LengthType["Star"] = 2] = "Star";
+    LengthType[LengthType["Auto"] = 4] = "Auto";
+})(LengthType || (LengthType = {}));
+/** A child placed in the grid with the combined track types it spans (MAUI Cell). */
+class Cell {
+    ViewIndex;
+    Row;
+    Column;
+    RowSpan;
+    ColumnSpan;
+    ColumnGridLengthType;
+    RowGridLengthType;
+    constructor(ViewIndex, Row, Column, RowSpan, ColumnSpan, ColumnGridLengthType, RowGridLengthType) {
+        this.ViewIndex = ViewIndex;
+        this.Row = Row;
+        this.Column = Column;
+        this.RowSpan = RowSpan;
+        this.ColumnSpan = ColumnSpan;
+        this.ColumnGridLengthType = ColumnGridLengthType;
+        this.RowGridLengthType = RowGridLengthType;
+    }
+    get IsColumnSpanAuto() { return (this.ColumnGridLengthType & LengthType.Auto) === LengthType.Auto; }
+    get IsRowSpanAuto() { return (this.RowGridLengthType & LengthType.Auto) === LengthType.Auto; }
+    get IsColumnSpanStar() { return (this.ColumnGridLengthType & LengthType.Star) === LengthType.Star; }
+    get IsRowSpanStar() { return (this.RowGridLengthType & LengthType.Star) === LengthType.Star; }
+    get IsAbsolute() { return this.ColumnGridLengthType === LengthType.Absolute && this.RowGridLengthType === LengthType.Absolute; }
+    /** Any Absolute/Star part means a second measure once Auto tracks are known. */
+    get NeedsKnownMeasurePass() { return ((this.ColumnGridLengthType | this.RowGridLengthType) ^ LengthType.Auto) > 0; }
+}
+/**
+ * Port of DrawnUi SkiaGridStructure (itself adapted from the MAUI Grid manager). Works in POINTS: constraints come in
+ * already reduced by the grid's padding, cells are returned relative to the padded box. Children are measured in
+ * pixels through SkiaControl.Measure and their Units sizes drive the tracks.
+ */
+export class SkiaGridStructure {
+    grid;
+    widthConstraint;
+    heightConstraint;
+    scale;
+    Rows;
+    Columns;
+    ColumnSpacing;
+    RowSpacing;
+    children;
+    cells = [];
+    spans = new Map();
+    explicitWidth;
+    explicitHeight;
+    constructor(grid, widthConstraint, heightConstraint, scale) {
+        this.grid = grid;
+        this.widthConstraint = widthConstraint;
+        this.heightConstraint = heightConstraint;
+        this.scale = scale;
+        this.ColumnSpacing = grid.ColumnSpacing;
+        this.RowSpacing = grid.RowSpacing;
+        this.explicitWidth = grid.WidthRequest;
+        this.explicitHeight = grid.HeightRequest;
+        this.Rows = this.InitializeTracks(grid.RowDefinitions, grid.DefaultRowDefinition);
+        this.Columns = this.InitializeTracks(grid.ColumnDefinitions, grid.DefaultColumnDefinition);
+        this.children = grid.Views.filter((v) => v.IsVisible);
+        this.InitializeCells();
+        this.MeasureCells();
+    }
+    InitializeTracks(defs, fallback) {
+        const tracks = ParseDefinitions(defs);
+        return tracks.length > 0 ? tracks : [new DefinitionInfo(fallback)];
+    }
+    static CreateDefinitionIfMissing(array, requiredIndex, fallback) {
+        while (array.length <= requiredIndex)
+            array.push(new DefinitionInfo(fallback));
+    }
+    static ToLengthType(d) {
+        return d.IsAbsolute ? LengthType.Absolute : d.IsStar ? LengthType.Star : LengthType.Auto;
+    }
+    InitializeCells() {
+        let maxRow = 0, maxColumn = 0;
+        for (const child of this.children) {
+            maxRow = Math.max(maxRow, child.Row + child.RowSpan - 1);
+            maxColumn = Math.max(maxColumn, child.Column + child.ColumnSpan - 1);
+        }
+        SkiaGridStructure.CreateDefinitionIfMissing(this.Rows, maxRow, this.grid.DefaultRowDefinition);
+        SkiaGridStructure.CreateDefinitionIfMissing(this.Columns, maxColumn, this.grid.DefaultColumnDefinition);
+        for (let n = 0; n < this.children.length; n++) {
+            const v = this.children[n];
+            let ct = LengthType.None, rt = LengthType.None;
+            for (let c = v.Column; c < v.Column + v.ColumnSpan; c++)
+                ct |= SkiaGridStructure.ToLengthType(this.Columns[c]);
+            for (let r = v.Row; r < v.Row + v.RowSpan; r++)
+                rt |= SkiaGridStructure.ToLengthType(this.Rows[r]);
+            this.cells.push(new Cell(n, v.Row, v.Column, v.RowSpan, v.ColumnSpan, ct, rt));
+        }
+    }
+    static Sum(defs, spacing) {
+        let sum = 0;
+        for (let n = 0; n < defs.length; n++) {
+            sum += defs[n].Size;
+            if (n > 0)
+                sum += spacing;
+        }
+        return sum;
+    }
+    GridWidth() { return SkiaGridStructure.Sum(this.Columns, this.ColumnSpacing); }
+    GridHeight() { return SkiaGridStructure.Sum(this.Rows, this.RowSpacing); }
+    LeftEdgeOfColumn(column) { let x = 0; for (let n = 0; n < column; n++)
+        x += this.Columns[n].Size + this.ColumnSpacing; return x; }
+    TopEdgeOfRow(row) { let y = 0; for (let n = 0; n < row; n++)
+        y += this.Rows[n].Size + this.RowSpacing; return y; }
+    /** Cell rectangle in points relative to the padded box (+ offsets). */
+    GetCellBoundsFor(view, xOffset = 0, yOffset = 0) {
+        const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+        const firstColumn = clamp(view.Column, 0, this.Columns.length - 1);
+        const columnSpan = clamp(view.ColumnSpan, 1, this.Columns.length - firstColumn);
+        const firstRow = clamp(view.Row, 0, this.Rows.length - 1);
+        const rowSpan = clamp(view.RowSpan, 1, this.Rows.length - firstRow);
+        let width = 0, height = 0;
+        for (let n = firstColumn; n < firstColumn + columnSpan; n++)
+            width += this.Columns[n].Size;
+        for (let n = firstRow; n < firstRow + rowSpan; n++)
+            height += this.Rows[n].Size;
+        width += (columnSpan - 1) * this.ColumnSpacing;
+        height += (rowSpan - 1) * this.RowSpacing;
+        return { Left: this.LeftEdgeOfColumn(firstColumn) + xOffset, Top: this.TopEdgeOfRow(firstRow) + yOffset, Width: width, Height: height };
+    }
+    // ---- measure passes (same order as C#) ----
+    MeasureCells() {
+        for (const cell of this.cells)
+            this.MeasureChild(cell);
+        this.ResolveStarColumns(this.widthConstraint);
+        this.ResolveStarRows(this.heightConstraint);
+        this.MeasureKnownCells();
+        this.ResolveSpans();
+        this.ApplyMinimumDimensionsFromFillChildren();
+        this.CompressStarMeasurements();
+    }
+    /** Points -> pixels for Measure; negative/NaN = unconstrained. */
+    MeasurePx(child, wPts, hPts) {
+        const w = wPts < 0 ? Infinity : wPts * this.scale;
+        const h = hPts < 0 ? Infinity : Math.round(hPts * this.scale);
+        return child.Measure(w, h, this.scale).Units;
+    }
+    MeasureChild(cell) {
+        if (cell.IsAbsolute)
+            return;
+        const child = this.children[cell.ViewIndex];
+        let availableWidth = this.AvailableWidth(cell);
+        let availableHeight = this.AvailableHeight(cell);
+        const finiteW = availableWidth, finiteH = availableHeight;
+        // a Fill child in an Auto track is measured unconstrained (content-sized track, MAUI desired-size semantics)
+        if (cell.IsColumnSpanAuto && child.HorizontalOptions === "Fill")
+            availableWidth = Infinity;
+        if (cell.IsRowSpanAuto && child.VerticalOptions === "Fill")
+            availableHeight = Infinity;
+        const m = this.MeasurePx(child, availableWidth, availableHeight);
+        let mw = m.Width, mh = m.Height;
+        // ...but clamped to the finite grid so a wrapping label / scroll cannot inflate the track
+        if (availableWidth === Infinity && isFinite(finiteW) && finiteW >= 0 && mw > finiteW)
+            mw = finiteW;
+        if (availableHeight === Infinity && isFinite(finiteH) && finiteH >= 0 && mh > finiteH)
+            mh = finiteH;
+        if (cell.IsColumnSpanAuto) {
+            if (cell.ColumnSpan === 1)
+                this.Columns[cell.Column].Update(mw);
+            else
+                this.TrackSpan({ Key: `c${cell.Column}:${cell.ColumnSpan}`, Start: cell.Column, Length: cell.ColumnSpan, IsColumn: true, Requested: mw });
+        }
+        if (cell.IsRowSpanAuto) {
+            if (cell.RowSpan === 1)
+                this.Rows[cell.Row].Update(mh);
+            else
+                this.TrackSpan({ Key: `r${cell.Row}:${cell.RowSpan}`, Start: cell.Row, Length: cell.RowSpan, IsColumn: false, Requested: mh });
+        }
+    }
+    TrackSpan(span) {
+        const other = this.spans.get(span.Key);
+        if (!other || span.Requested > other.Requested)
+            this.spans.set(span.Key, span);
+    }
+    ResolveSpans() {
+        for (const span of this.spans.values()) {
+            if (span.IsColumn)
+                SkiaGridStructure.ResolveSpan(this.Columns, span.Start, span.Length, this.ColumnSpacing, span.Requested);
+            else
+                SkiaGridStructure.ResolveSpan(this.Rows, span.Start, span.Length, this.RowSpacing, span.Requested);
+        }
+    }
+    static ResolveSpan(defs, start, length, spacing, requested) {
+        let current = 0;
+        const end = start + length;
+        for (let n = start; n < end; n++) {
+            current += defs[n].Size;
+            if (n > start)
+                current += spacing;
+        }
+        if (requested <= current)
+            return;
+        const required = requested - current;
+        let autoCount = 0;
+        for (let n = start; n < end; n++) {
+            if (defs[n].IsAuto)
+                autoCount++;
+            else if (defs[n].IsStar)
+                return;
+        }
+        if (autoCount === 0)
+            return;
+        const distribution = required / autoCount;
+        for (let n = start; n < end; n++)
+            if (defs[n].IsAuto)
+                defs[n].Size += distribution;
+    }
+    ApplyMinimumDimensionsFromFillChildren() {
+        for (const cell of this.cells) {
+            const child = this.children[cell.ViewIndex];
+            if (child.HorizontalOptions === "Fill" && child.MinimumWidthRequest >= 0) {
+                const min = (child.MinimumWidthRequest + child.Margin.HorizontalThickness) / cell.ColumnSpan;
+                for (let c = cell.Column; c < cell.Column + cell.ColumnSpan; c++)
+                    if (this.Columns[c].Size < min)
+                        this.Columns[c].Size = min;
+            }
+            if (child.VerticalOptions === "Fill" && child.MinimumHeightRequest >= 0) {
+                const min = (child.MinimumHeightRequest + child.Margin.VerticalThickness) / cell.RowSpan;
+                for (let r = cell.Row; r < cell.Row + cell.RowSpan; r++)
+                    if (this.Rows[r].Size < min)
+                        this.Rows[r].Size = min;
+            }
+        }
+    }
+    ResolveStars(defs, availableSpace, cellCheck, dimension) {
+        let starCount = 0;
+        for (const d of defs)
+            if (d.IsStar)
+                starCount += d.Value;
+        if (starCount === 0)
+            return;
+        let starSize = 0;
+        if (!isFinite(availableSpace)) {
+            // unbounded axis: stars take the largest star cell's desired size
+            for (const cell of this.cells)
+                if (cellCheck(cell))
+                    starSize = Math.max(starSize, dimension(this.children[cell.ViewIndex]));
+        }
+        else {
+            starSize = availableSpace / starCount;
+        }
+        for (const d of defs)
+            if (d.IsStar)
+                d.Size = starSize * d.Value;
+    }
+    ResolveStarColumns(widthConstraint) {
+        this.ResolveStars(this.Columns, widthConstraint - this.GridWidth(), (c) => c.IsColumnSpanStar, (v) => v.MeasuredSize.Units.Width);
+    }
+    ResolveStarRows(heightConstraint) {
+        this.ResolveStars(this.Rows, heightConstraint - this.GridHeight(), (c) => c.IsRowSpanStar, (v) => v.MeasuredSize.Units.Height);
+    }
+    MeasureKnownCells() {
+        for (const cell of this.cells) {
+            if (!cell.NeedsKnownMeasurePass)
+                continue;
+            let width = 0, height = 0;
+            for (let n = cell.Row; n < cell.Row + cell.RowSpan; n++)
+                height += this.Rows[n].Size;
+            for (let n = cell.Column; n < cell.Column + cell.ColumnSpan; n++)
+                width += this.Columns[n].Size;
+            if (width === 0 || height === 0)
+                continue;
+            const child = this.children[cell.ViewIndex];
+            const rect = this.GetCellBoundsFor(child);
+            this.MeasurePx(child, rect.Width, rect.Height);
+            if (cell.IsColumnSpanStar && cell.ColumnSpan > 1)
+                this.TrackSpan({ Key: `c${cell.Column}:${cell.ColumnSpan}`, Start: cell.Column, Length: cell.ColumnSpan, IsColumn: true, Requested: rect.Width });
+            if (cell.IsRowSpanStar && cell.RowSpan > 1)
+                this.TrackSpan({ Key: `r${cell.Row}:${cell.RowSpan}`, Start: cell.Row, Length: cell.RowSpan, IsColumn: false, Requested: rect.Height });
+        }
+    }
+    AvailableWidth(cell) {
+        let w = 0, absolute = true;
+        for (let c = cell.Column; c < cell.Column + cell.ColumnSpan; c++) {
+            w += this.Columns[c].Size;
+            if (!this.Columns[c].IsAbsolute)
+                absolute = false;
+        }
+        w += (cell.ColumnSpan - 1) * this.ColumnSpacing;
+        if (absolute)
+            return w;
+        return this.widthConstraint - this.GridWidth() + w;
+    }
+    AvailableHeight(cell) {
+        let h = 0, absolute = true;
+        for (let r = cell.Row; r < cell.Row + cell.RowSpan; r++) {
+            h += this.Rows[r].Size;
+            if (!this.Rows[r].IsAbsolute)
+                absolute = false;
+        }
+        h += (cell.RowSpan - 1) * this.RowSpacing;
+        if (absolute)
+            return h;
+        return this.heightConstraint - this.GridHeight() + h;
+    }
+    /** Re-resolves stars against the final size when the grid has an explicit size request (C# DecompressStars). */
+    DecompressStars(targetWidth, targetHeight) {
+        if (this.explicitHeight >= 0) {
+            SkiaGridStructure.ZeroOutStars(this.Rows);
+            this.ResolveStarRows(targetHeight);
+        }
+        if (this.explicitWidth >= 0) {
+            SkiaGridStructure.ZeroOutStars(this.Columns);
+            this.ResolveStarColumns(targetWidth);
+        }
+    }
+    CompressStarMeasurements() {
+        this.CompressStars(this.Rows, (c) => c.IsRowSpanStar, (c) => c.Row, (c) => c.RowSpan, this.heightConstraint, (v) => v.MeasuredSize.Units.Height);
+        this.CompressStars(this.Columns, (c) => c.IsColumnSpanStar, (c) => c.Column, (c) => c.ColumnSpan, this.widthConstraint, (v) => v.MeasuredSize.Units.Width);
+    }
+    /** Stars shrink to what their cells actually need (so an auto-sized grid does not take the whole constraint). */
+    CompressStars(defs, isStar, start, span, constraint, dimension) {
+        const copy = defs.map((d) => { const c = new DefinitionInfo(d.Unit === "Absolute" ? d.Value : d.Unit === "Auto" ? "Auto" : `${d.Value}*`); c.Size = d.IsStar ? 0 : d.Size; return c; });
+        for (const cell of this.cells) {
+            if (!isStar(cell))
+                continue;
+            const needed = Math.min(constraint, dimension(this.children[cell.ViewIndex]));
+            SkiaGridStructure.ExpandStarsInSpan(needed, defs, copy, start(cell), start(cell) + span(cell));
+        }
+        for (let n = 0; n < copy.length; n++)
+            if (copy[n].IsStar)
+                defs[n].Size = copy[n].Size;
+    }
+    static ExpandStarsInSpan(spaceNeeded, original, updated, start, end) {
+        for (let n = start; n < end; n++)
+            if (original[n].IsAbsolute || original[n].IsAuto)
+                spaceNeeded -= original[n].Size;
+        let spaceAvailable = 0, starCount = 0;
+        for (let n = start; n < end; n++)
+            if (updated[n].IsStar) {
+                starCount++;
+                spaceAvailable += updated[n].Size;
+            }
+        if (starCount > 0 && spaceAvailable < spaceNeeded) {
+            const toAdd = (spaceNeeded - spaceAvailable) / starCount;
+            for (let n = start; n < end; n++)
+                if (updated[n].IsStar)
+                    updated[n].Size += toAdd;
+        }
+    }
+    static ZeroOutStars(defs) { for (const d of defs)
+        if (d.IsStar)
+            d.Size = 0; }
+    /** Tracks are final only now: measure every child at its final cell so its internal layout matches the arranged box. */
+    RemeasureChildrenAtFinalCells() {
+        for (const cell of this.cells) {
+            const child = this.children[cell.ViewIndex];
+            const rect = this.GetCellBoundsFor(child);
+            if (rect.Width <= 0 || rect.Height <= 0)
+                continue;
+            const m = this.MeasurePx(child, rect.Width, rect.Height);
+            if (cell.ColumnSpan === 1 && this.Columns[cell.Column].IsAuto && m.Width > this.Columns[cell.Column].Size)
+                this.Columns[cell.Column].Update(m.Width);
+            if (cell.RowSpan === 1 && this.Rows[cell.Row].IsAuto && m.Height > this.Rows[cell.Row].Size)
+                this.Rows[cell.Row].Update(m.Height);
+        }
+    }
+}