layerchart 2.0.0-next.6 → 2.0.0-next.61

package/dist/utils/path.js

@@ -24,17 +24,222 @@ export function circlePath(dimensions) {
     a ${r},${r} 0 1,${_sweep} -${r * 2},0
   `;
 }
-/** Create spike (triangle) using path data  */
+/**
+ * @deprecated Use `vectorSpikePath` or the `Vector` component with `shape="spike"` instead.
+ * Create spike (triangle) using path data
+ */
 export function spikePath({ x, y, width, height, }) {
-    const startPoint = { x: x - width / 2, y };
-    const midPoint = { x, y: y - height };
-    const endPoint = { x: x + width / 2, y };
-    const pathData = `
-    M ${startPoint.x},${startPoint.y}
-    L ${midPoint.x},${midPoint.y}
-    L ${endPoint.x},${endPoint.y}
-  `;
-    return pathData;
+    return transformVectorPath(vectorSpikePath({ length: height, anchor: 'start', width }), x, y, 0);
+}
+/** Create rounded polygon path
+ *
+ * @param coords - Array of points (x, y)
+ * @param radius - Radius of the curve
+ * @returns String of path data
+ */
+export function roundedPolygonPath(coords, radius) {
+    if (radius === 0) {
+        // Simple polygon with straight lines
+        return `M${coords[0].x},${coords[0].y}${coords
+            .slice(1)
+            .map((p) => `L${p.x},${p.y}`)
+            .join('')}Z`;
+    }
+    let path = '';
+    const length = coords.length + 1;
+    for (let i = 0; i < length; i++) {
+        const a = coords[i % coords.length];
+        const b = coords[(i + 1) % coords.length];
+        const t = Math.min(radius / Math.hypot(b.x - a.x, b.y - a.y), 0.5);
+        if (i == 0)
+            path += `M${a.x * (1 - t) + b.x * t},${a.y * (1 - t) + b.y * t}`;
+        if (i > 0)
+            path += `Q${a.x},${a.y} ${a.x * (1 - t) + b.x * t},${a.y * (1 - t) + b.y * t}`;
+        if (i < length - 1)
+            path += `L${a.x * t + b.x * (1 - t)},${a.y * t + b.y * (1 - t)}`;
+    }
+    path += 'Z';
+    return path;
+}
+/**
+ * SVG path `d` attribute for a rectangle with per-corner rounding.
+ * Corners are ordered `[top-left, top-right, bottom-right, bottom-left]`
+ * (matching CSS `border-radius` shorthand). Path is drawn clockwise from
+ * the top-left corner.
+ */
+export function roundedRectPath(x, y, width, height, [tl, tr, br, bl]) {
+    const topEdge = width - tl - tr;
+    const rightEdge = height - tr - br;
+    const bottomEdge = width - br - bl;
+    const leftEdge = height - bl - tl;
+    return [
+        `M${x + tl},${y}`,
+        `h${topEdge}`,
+        tr > 0 ? `a${tr},${tr} 0 0 1 ${tr},${tr}` : '',
+        `v${rightEdge}`,
+        br > 0 ? `a${br},${br} 0 0 1 ${-br},${br}` : '',
+        `h${-bottomEdge}`,
+        bl > 0 ? `a${bl},${bl} 0 0 1 ${-bl},${-bl}` : '',
+        `v${-leftEdge}`,
+        tl > 0 ? `a${tl},${tl} 0 0 1 ${tl},${-tl}` : '',
+        'z',
+    ]
+        .filter(Boolean)
+        .join(' ');
+}
+/**
+ * Normalize a dash-array value (CSS `stroke-dasharray`) to a numeric array.
+ * Accepts `"4 2"`, `"4,2"`, `[4, 2]`, or a single number (e.g. `4` → `[4, 4]`).
+ * Returns `null` when the input is empty or all zeros (i.e. solid stroke).
+ */
+export function parseDashArray(value) {
+    if (value == null || value === '' || value === 'none')
+        return null;
+    let arr;
+    if (typeof value === 'number') {
+        arr = [value, value];
+    }
+    else if (Array.isArray(value)) {
+        arr = value.filter((n) => Number.isFinite(n));
+    }
+    else {
+        arr = value
+            .split(/[\s,]+/)
+            .filter((s) => s.length > 0)
+            .map((s) => Number(s.replace('px', '')))
+            .filter((n) => Number.isFinite(n));
+    }
+    if (arr.length === 0 || arr.every((n) => n === 0))
+        return null;
+    // SVG/Canvas semantics: an odd-length array is repeated (e.g. `[5]` → `[5, 5]`)
+    if (arr.length % 2 === 1)
+        arr = [...arr, ...arr];
+    return arr;
+}
+/**
+ * Build a CSS `repeating-linear-gradient` string approximating a `stroke-dasharray`
+ * pattern along a horizontal line (use with `background` on a rotated `<div>`).
+ * Alternates stops between `color` (dash) and `transparent` (gap) to match SVG.
+ */
+export function dashArrayToGradient(dashArray, color, direction = 'to right') {
+    const stops = [];
+    let offset = 0;
+    for (let i = 0; i < dashArray.length; i++) {
+        const length = dashArray[i];
+        const isDash = i % 2 === 0;
+        const c = isDash ? color : 'transparent';
+        stops.push(`${c} ${offset}px ${offset + length}px`);
+        offset += length;
+    }
+    return `repeating-linear-gradient(${direction}, ${stops.join(', ')})`;
+}
+/**
+ * Create arrow vector path data (pointing up by default).
+ * The path is centered on the anchor point at origin — use SVG `transform` to position and rotate.
+ *
+ * The arrow consists of a stem line with a V-shaped arrowhead at the tip.
+ */
+export function vectorArrowPath({ length, anchor = 'middle', width = 5, }) {
+    const halfWidth = width / 2;
+    // Compute y-offsets for base and tip relative to anchor point at origin
+    let baseY, tipY;
+    switch (anchor) {
+        case 'start':
+            baseY = 0;
+            tipY = -length;
+            break;
+        case 'end':
+            baseY = length;
+            tipY = 0;
+            break;
+        case 'middle':
+        default:
+            baseY = length / 2;
+            tipY = -length / 2;
+            break;
+    }
+    // Stem from base to tip, then arrowhead wings at the tip
+    return `M0,${baseY}L0,${tipY}M${-halfWidth},${tipY + width}L0,${tipY}L${halfWidth},${tipY + width}`;
+}
+/**
+ * Create spike (filled triangle) vector path data (pointing up by default).
+ * The path is centered on the anchor point at origin — use SVG `transform` to position and rotate.
+ */
+export function vectorSpikePath({ length, anchor = 'start', width = 3, }) {
+    const halfWidth = width / 2;
+    let baseY, tipY;
+    switch (anchor) {
+        case 'start':
+            baseY = 0;
+            tipY = -length;
+            break;
+        case 'end':
+            baseY = length;
+            tipY = 0;
+            break;
+        case 'middle':
+        default:
+            baseY = length / 2;
+            tipY = -length / 2;
+            break;
+    }
+    return `M${-halfWidth},${baseY}L0,${tipY}L${halfWidth},${baseY}`;
+}
+/**
+ * Create filled arrow vector path data (pointing up by default).
+ * The path is centered on the anchor point at origin — use SVG `transform` to position and rotate.
+ *
+ * The shape has a tapered tail that widens into a triangular arrowhead at the tip.
+ */
+export function vectorArrowFilledPath({ length, anchor = 'middle', width = length * 0.3, }) {
+    let baseY, tipY;
+    switch (anchor) {
+        case 'start':
+            baseY = 0;
+            tipY = -length;
+            break;
+        case 'end':
+            baseY = length;
+            tipY = 0;
+            break;
+        case 'middle':
+        default:
+            baseY = length / 2;
+            tipY = -length / 2;
+            break;
+    }
+    const headLength = Math.max(3, length * 0.3);
+    const headSpike = headLength * 0.2;
+    const headWidth = Math.max(2, width);
+    const tailWidth = headWidth * 0.3;
+    // Path points (relative to base→tip axis)
+    const headStart = tipY + headLength;
+    const spikeY = headStart - headSpike;
+    return [
+        `M0,${baseY}`,
+        `L${tailWidth / 2},${spikeY}`,
+        `L${headWidth / 2},${headStart}`,
+        `L0,${tipY}`,
+        `L${-headWidth / 2},${headStart}`,
+        `L${-tailWidth / 2},${spikeY}`,
+        'Z',
+    ].join('');
+}
+/**
+ * Apply rotation (degrees) and translation to a path string containing only M and L commands
+ * with absolute coordinates. Converts local vector path data to absolute positioned coordinates.
+ */
+export function transformVectorPath(pathData, cx, cy, rotateDeg) {
+    const rad = (rotateDeg * Math.PI) / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    return pathData.replace(/([ML])(-?\d*\.?\d+),(-?\d*\.?\d+)/g, (_match, cmd, xStr, yStr) => {
+        const lx = Number(xStr);
+        const ly = Number(yStr);
+        const ax = cx + lx * cos - ly * sin;
+        const ay = cy + lx * sin + ly * cos;
+        return `${cmd}${ax},${ay}`;
+    });
 }
 /** Flatten all `y` coordinates to `0` */
 export function flattenPathData(pathData, yOverride = 0) {
@@ -47,12 +252,9 @@ export function flattenPathData(pathData, yOverride = 0) {
     result = result.replace(/([v])(-?\d*\.?\d+)/g, (match, command, l) => {
         return `${command}${0}`;
     });
-    // TODO: Flatten all elliptical arc commands (ex. `a4,4 0 0 1 4,4`) with `0` height
-    // result = result.replace(
-    //   /a(\d+),(\d+) (\d+) (\d+) (\d+) (\d+),(\d+)/g,
-    //   (match, rx, ry, rot, large, sweep, x, y) => {
-    //     return `a${rx},0 ${rot} ${large} ${sweep} ${x},0`;
-    //   }
-    // );
+    // Flatten relative elliptical arc commands (ex. `a4,4 0 0 1 4,4`) — zero out ry and dy
+    result = result.replace(/a(-?\d*\.?\d+),(-?\d*\.?\d+) (\d+) (\d+) (\d+) (-?\d*\.?\d+),(-?\d*\.?\d+)/g, (match, rx, ry, rot, large, sweep, dx, dy) => {
+        return `a${rx},0 ${rot} ${large} ${sweep} ${dx},0`;
+    });
     return result;
 }

package/dist/utils/rasterBounds.d.ts

@@ -0,0 +1,18 @@
+import type { InterpolateMethod } from './rasterInterpolate.js';
+export type RasterBounds = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export declare function resolveRasterBounds(width: number, height: number, x1?: number, y1?: number, x2?: number, y2?: number): RasterBounds;
+export declare function gridPointToBounds(x: number, y: number, width: number, height: number, bounds: RasterBounds): {
+    x: number;
+    y: number;
+};
+export declare function gridCellCenterToBounds(column: number, row: number, width: number, height: number, bounds: RasterBounds): {
+    x: number;
+    y: number;
+};
+export declare function sampleGridAtBounds(values: ArrayLike<number>, width: number, height: number, bounds: RasterBounds, x: number, y: number, method?: InterpolateMethod): number;
+export declare function blurGridIgnoringNaN(values: ArrayLike<number>, width: number, height: number, radius: number): Float64Array<ArrayBufferLike>;

package/dist/utils/rasterBounds.js

@@ -0,0 +1,98 @@
+import { blur2 } from 'd3-array';
+export function resolveRasterBounds(width, height, x1, y1, x2, y2) {
+    return {
+        x1: x1 ?? 0,
+        y1: y1 ?? 0,
+        x2: x2 ?? width,
+        y2: y2 ?? height,
+    };
+}
+export function gridPointToBounds(x, y, width, height, bounds) {
+    return {
+        x: bounds.x1 + (x / width) * (bounds.x2 - bounds.x1),
+        y: bounds.y1 + (y / height) * (bounds.y2 - bounds.y1),
+    };
+}
+export function gridCellCenterToBounds(column, row, width, height, bounds) {
+    return {
+        x: bounds.x1 + ((column + 0.5) / width) * (bounds.x2 - bounds.x1),
+        y: bounds.y1 + ((row + 0.5) / height) * (bounds.y2 - bounds.y1),
+    };
+}
+export function sampleGridAtBounds(values, width, height, bounds, x, y, method = 'barycentric') {
+    const dx = bounds.x2 - bounds.x1;
+    const dy = bounds.y2 - bounds.y1;
+    if (!width || !height || dx === 0 || dy === 0)
+        return NaN;
+    const fx = ((x - bounds.x1) / dx) * width - 0.5;
+    const fy = ((y - bounds.y1) / dy) * height - 0.5;
+    if (fx < -0.5 || fx > width - 0.5 || fy < -0.5 || fy > height - 0.5) {
+        return NaN;
+    }
+    switch (method) {
+        case 'barycentric':
+            return sampleBilinear(values, width, height, fx, fy);
+        case 'nearest':
+        case 'none':
+        default:
+            return sampleNearest(values, width, height, fx, fy);
+    }
+}
+export function blurGridIgnoringNaN(values, width, height, radius) {
+    if (!radius || !values.length) {
+        return values instanceof Float64Array ? values : Float64Array.from(values);
+    }
+    const numerators = new Float64Array(values.length);
+    const weights = new Float64Array(values.length);
+    for (let index = 0; index < values.length; index++) {
+        const value = values[index] ?? NaN;
+        if (!Number.isFinite(value))
+            continue;
+        numerators[index] = value;
+        weights[index] = 1;
+    }
+    blur2({ data: numerators, width, height }, radius);
+    blur2({ data: weights, width, height }, radius);
+    const result = new Float64Array(values.length);
+    for (let index = 0; index < values.length; index++) {
+        const weight = weights[index];
+        result[index] = weight > 1e-12 ? numerators[index] / weight : NaN;
+    }
+    return result;
+}
+function sampleNearest(values, width, height, x, y) {
+    const column = clamp(Math.round(x), 0, width - 1);
+    const row = clamp(Math.round(y), 0, height - 1);
+    return values[row * width + column] ?? NaN;
+}
+function sampleBilinear(values, width, height, x, y) {
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const x1 = x0 + 1;
+    const y1 = y0 + 1;
+    const tx = x - x0;
+    const ty = y - y0;
+    const weightedValues = [
+        [getSample(values, width, height, x0, y0), (1 - tx) * (1 - ty)],
+        [getSample(values, width, height, x1, y0), tx * (1 - ty)],
+        [getSample(values, width, height, x0, y1), (1 - tx) * ty],
+        [getSample(values, width, height, x1, y1), tx * ty],
+    ];
+    let totalWeight = 0;
+    let totalValue = 0;
+    for (const [value, weight] of weightedValues) {
+        if (!Number.isFinite(value))
+            continue;
+        totalWeight += weight;
+        totalValue += value * weight;
+    }
+    return totalWeight > 0 ? totalValue / totalWeight : NaN;
+}
+function getSample(values, width, height, x, y) {
+    const column = clamp(x, 0, width - 1);
+    const row = clamp(y, 0, height - 1);
+    return values[row * width + column] ?? NaN;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}

package/dist/utils/rasterBounds.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/rasterBounds.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest';
+import { blurGridIgnoringNaN, gridCellCenterToBounds, gridPointToBounds, resolveRasterBounds, sampleGridAtBounds, } from './rasterBounds.js';
+describe('resolveRasterBounds', () => {
+    it('defaults to grid dimensions', () => {
+        expect(resolveRasterBounds(360, 180)).toEqual({
+            x1: 0,
+            y1: 0,
+            x2: 360,
+            y2: 180,
+        });
+    });
+    it('uses explicit geographic bounds', () => {
+        expect(resolveRasterBounds(360, 180, -180, 90, 180, -90)).toEqual({
+            x1: -180,
+            y1: 90,
+            x2: 180,
+            y2: -90,
+        });
+    });
+});
+describe('gridPointToBounds', () => {
+    it('maps contour-space coordinates back into bound coordinates', () => {
+        expect(gridPointToBounds(180, 90, 360, 180, resolveRasterBounds(360, 180, -180, 90, 180, -90))).toEqual({
+            x: 0,
+            y: 0,
+        });
+    });
+});
+describe('gridCellCenterToBounds', () => {
+    it('maps grid cell centers into bound coordinates', () => {
+        expect(gridCellCenterToBounds(0, 0, 360, 180, resolveRasterBounds(360, 180, -180, 90, 180, -90))).toEqual({
+            x: -179.5,
+            y: 89.5,
+        });
+    });
+});
+describe('sampleGridAtBounds', () => {
+    const grid = [0, 1, 2, 3];
+    const bounds = resolveRasterBounds(2, 2, -1, 1, 1, -1);
+    it('samples the nearest grid cell center', () => {
+        expect(sampleGridAtBounds(grid, 2, 2, bounds, -0.5, 0.5, 'nearest')).toBe(0);
+        expect(sampleGridAtBounds(grid, 2, 2, bounds, 0.5, -0.5, 'nearest')).toBe(3);
+    });
+    it('interpolates between adjacent cells', () => {
+        expect(sampleGridAtBounds(grid, 2, 2, bounds, 0, 0, 'barycentric')).toBe(1.5);
+    });
+    it('returns NaN outside the raster bounds', () => {
+        expect(sampleGridAtBounds(grid, 2, 2, bounds, 4, 4, 'barycentric')).toBeNaN();
+    });
+});
+describe('blurGridIgnoringNaN', () => {
+    it('preserves nearby finite values when blurring through NaN gaps', () => {
+        const blurred = blurGridIgnoringNaN([1, NaN, 3], 3, 1, 1);
+        expect(blurred[0]).toBeGreaterThan(0);
+        expect(blurred[1]).toBeGreaterThan(1);
+        expect(blurred[1]).toBeLessThan(3);
+        expect(blurred[2]).toBeGreaterThan(0);
+    });
+    it('keeps fully empty regions as NaN', () => {
+        const blurred = blurGridIgnoringNaN([NaN, NaN, NaN], 3, 1, 1);
+        expect(Array.from(blurred).every((value) => Number.isNaN(value))).toBe(true);
+    });
+});

package/dist/utils/rasterInterpolate.d.ts

@@ -0,0 +1,11 @@
+export type InterpolateMethod = 'none' | 'nearest' | 'barycentric';
+/**
+ * Interpolate scattered 2D points onto a regular grid.
+ *
+ * @param points - Array of [x, y, value] triples in grid coordinates
+ * @param width - Grid width (columns)
+ * @param height - Grid height (rows)
+ * @param method - Interpolation method
+ * @returns Flat Float64Array of grid values (row-major, length = width * height)
+ */
+export declare function interpolateGrid(points: [number, number, number][], width: number, height: number, method?: InterpolateMethod): Float64Array;

package/dist/utils/rasterInterpolate.js

@@ -0,0 +1,103 @@
+import { Delaunay } from 'd3-delaunay';
+/**
+ * Interpolate scattered 2D points onto a regular grid.
+ *
+ * @param points - Array of [x, y, value] triples in grid coordinates
+ * @param width - Grid width (columns)
+ * @param height - Grid height (rows)
+ * @param method - Interpolation method
+ * @returns Flat Float64Array of grid values (row-major, length = width * height)
+ */
+export function interpolateGrid(points, width, height, method = 'barycentric') {
+    const n = width * height;
+    const grid = new Float64Array(n);
+    if (points.length === 0) {
+        grid.fill(NaN);
+        return grid;
+    }
+    // Need at least 3 points for triangulation
+    if (points.length < 3) {
+        return interpolateNearest(points, width, height, grid);
+    }
+    switch (method) {
+        case 'none':
+            return interpolateNone(points, width, height, grid);
+        case 'nearest':
+            return interpolateNearest(points, width, height, grid);
+        case 'barycentric':
+            return interpolateBarycentric(points, width, height, grid);
+        default:
+            return interpolateBarycentric(points, width, height, grid);
+    }
+}
+/** Only fill grid cells that directly contain a data point */
+function interpolateNone(points, width, _height, grid) {
+    grid.fill(NaN);
+    for (const [x, y, value] of points) {
+        const ix = Math.round(x);
+        const iy = Math.round(y);
+        if (ix >= 0 && ix < width && iy >= 0 && iy < grid.length / width) {
+            grid[iy * width + ix] = value;
+        }
+    }
+    return grid;
+}
+/** Assign each grid cell the value of its nearest data point (Voronoi) */
+function interpolateNearest(points, width, height, grid) {
+    const delaunay = Delaunay.from(points, (d) => d[0], (d) => d[1]);
+    for (let j = 0; j < height; j++) {
+        for (let i = 0; i < width; i++) {
+            const idx = delaunay.find(i + 0.5, j + 0.5);
+            grid[j * width + i] = points[idx][2];
+        }
+    }
+    return grid;
+}
+/** Delaunay triangulation with barycentric interpolation within triangles */
+function interpolateBarycentric(points, width, height, grid) {
+    const delaunay = Delaunay.from(points, (d) => d[0], (d) => d[1]);
+    const { triangles } = delaunay;
+    const numTriangles = triangles.length / 3;
+    // Build per-point triangle adjacency for fast lookup
+    const pointTriangles = Array.from({ length: points.length }, () => []);
+    for (let t = 0; t < numTriangles; t++) {
+        pointTriangles[triangles[t * 3]].push(t);
+        pointTriangles[triangles[t * 3 + 1]].push(t);
+        pointTriangles[triangles[t * 3 + 2]].push(t);
+    }
+    for (let j = 0; j < height; j++) {
+        for (let i = 0; i < width; i++) {
+            const px = i + 0.5;
+            const py = j + 0.5;
+            const nearest = delaunay.find(px, py);
+            let value = NaN;
+            // Check triangles incident to the nearest point
+            for (const t of pointTriangles[nearest]) {
+                const i0 = triangles[t * 3];
+                const i1 = triangles[t * 3 + 1];
+                const i2 = triangles[t * 3 + 2];
+                const x0 = points[i0][0], y0 = points[i0][1];
+                const x1 = points[i1][0], y1 = points[i1][1];
+                const x2 = points[i2][0], y2 = points[i2][1];
+                // Barycentric coordinates
+                const denom = (y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2);
+                if (Math.abs(denom) < 1e-10)
+                    continue;
+                const w0 = ((y1 - y2) * (px - x2) + (x2 - x1) * (py - y2)) / denom;
+                const w1 = ((y2 - y0) * (px - x2) + (x0 - x2) * (py - y2)) / denom;
+                const w2 = 1 - w0 - w1;
+                // Point is inside triangle (with small epsilon for edge cases)
+                if (w0 >= -1e-6 && w1 >= -1e-6 && w2 >= -1e-6) {
+                    value = w0 * points[i0][2] + w1 * points[i1][2] + w2 * points[i2][2];
+                    break;
+                }
+            }
+            // Fallback for points outside convex hull
+            if (isNaN(value)) {
+                value = points[nearest][2];
+            }
+            grid[j * width + i] = value;
+        }
+    }
+    return grid;
+}

package/dist/utils/rect.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { ChartContextValue } from '../components/Chart.svelte';
+import type { ChartState } from '../states/chart.svelte.js';
 import { type Accessor } from './common.js';
 /**
  * A set of inset distances, applied to a rectangle to shrink or expand
@@ -31,15 +31,40 @@ type DimensionGetterOptions = {
     y1?: Accessor;
     insets?: Insets;
 };
-export declare function createDimensionGetter<TData>(ctx: ChartContextValue<TData>, getOptions?: () => DimensionGetterOptions): (item: TData) => {
+export type ResolvedInsets = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export declare function resolveInsets(insets?: Insets): ResolvedInsets;
+export declare function createDimensionGetter<TData>(ctx: ChartState<TData>, getOptions?: () => DimensionGetterOptions): (item: TData) => {
     x: any;
     y: any;
     width: number;
     height: number;
-};
+} | undefined;
 /**
  * If value is an array, returns first item, else returns original value
  * Useful when x/y getters for band scale are an array (such as for histograms)
  */
-export declare function firstValue(value: number | number[]): number;
+export declare function firstValue(value: number | number[] | undefined): number | undefined;
+/**
+ * Per-corner radii, ordered [top-left, top-right, bottom-right, bottom-left] —
+ * matching CSS `border-radius` shorthand and Canvas `roundRect`.
+ */
+export type CornerRadii = [number, number, number, number];
+export type Corners = number | CornerRadii | {
+    topLeft?: number;
+    topRight?: number;
+    bottomRight?: number;
+    bottomLeft?: number;
+};
+/**
+ * Normalize a `Corners` value to `[tl, tr, br, bl]`, clamping each corner to
+ * half the shorter side so opposite corners cannot overlap.
+ */
+export declare function resolveCorners(corners: Corners | undefined, width: number, height: number): CornerRadii;
+/** True when all four corner radii are equal (lets callers use simpler `rx`/`ry` rendering). */
+export declare function cornersUniform([tl, tr, br, bl]: CornerRadii): boolean;
 export {};