@leavepulse/ui 0.24.0 → 0.25.0

package/dist/components/LpPie.vue.d.ts

@@ -0,0 +1,134 @@
+import { PieSlice } from './chart';
+import { ContextMenuItemDef } from './LpContextMenu.vue';
+/** A slice, as reported by every interaction event. */
+export interface SliceEvent {
+    index: number;
+    label: string;
+    value: number;
+    isOther: boolean;
+}
+type __VLS_Props = {
+    slices: PieSlice[];
+    type?: "pie" | "donut";
+    /** Outer diameter in px. */
+    size?: number;
+    /** Donut only: hole diameter as a fraction of the outer radius (0–1). */
+    innerRatio?: number;
+    title?: string;
+    subtitle?: string;
+    /**
+     * Keep the largest N-1 slices and sum the rest into "Other". `0` disables
+     * the fold and draws every slice — for a caller that knows its data is
+     * already few, or that would rather show a crowded circle than a bucket.
+     */
+    maxSlices?: number;
+    /** Label for the folded remainder. */
+    otherLabel?: string;
+    /**
+     * Draw the slices largest-first instead of in the order given. Ranking
+     * always decides which slices survive `maxSlices`; this decides whether it
+     * also reorders them.
+     */
+    sortBySize?: boolean;
+    /** Appended to values in the legend and tooltip, e.g. " GB". */
+    unit?: string;
+    /** Custom value formatter; overrides the compact 1.2k default. */
+    formatValue?: (v: number) => string;
+    /**
+     * Name the slices with leader lines around the circle instead of a legend
+     * beside it. Better when the labels are long and self-explanatory (versions,
+     * hostnames) and the reader wants share-per-name without cross-referencing a
+     * colour; the legend stays better for short, repeated categories.
+     */
+    labels?: boolean;
+    /** Callout width reserved for text on each side, in px. */
+    labelWidth?: number;
+    /**
+     * Defaults to true, except in `labels` mode — callouts already name every
+     * slice, and a legend beside them says the same thing twice. Set it
+     * explicitly to have both.
+     */
+    showLegend?: boolean;
+    /** Print each slice's percentage next to its legend entry. */
+    showPercent?: boolean;
+    /** Donut only: print the total in the hole. Ignored when #center is used. */
+    showTotal?: boolean;
+    /** Gap between slices in degrees — reads as separate parts, not one disc. */
+    padAngle?: number;
+    /** Corner radius of each slice in px. 0 for hard edges. */
+    cornerRadius?: number;
+    /** How far the hovered slice lifts out of the circle, in px. */
+    hoverOffset?: number;
+    /**
+     * Sweep the circle open, clockwise from twelve, when it first comes into
+     * view. Turn it off where several are drawn at once and the sweeps would
+     * compete rather than read as one arrival.
+     */
+    animate?: boolean;
+    /** Sweep time in ms. */
+    duration?: number;
+    /**
+     * Right-click menu, built from the slice that was hit and the whole current
+     * selection — so an action can apply to one slice or to all the picked ones.
+     */
+    menuItems?: (slice: SliceEvent, selection: SliceEvent[]) => ContextMenuItemDef[];
+    emptyLabel?: string;
+};
+declare var __VLS_40: {
+    total: number;
+    active: {
+        d: string;
+        lift: string;
+        label: string;
+        value: number;
+        color: string;
+        fraction: number;
+        isOther: boolean;
+        count: number;
+    } | null;
+    selection: {
+        d: string;
+        lift: string;
+        label: string;
+        value: number;
+        color: string;
+        fraction: number;
+        isOther: boolean;
+        count: number;
+    }[];
+};
+type __VLS_Slots = {} & {
+    center?: (props: typeof __VLS_40) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    sliceClick: (payload: SliceEvent) => any;
+    selectionChange: (payload: SliceEvent[]) => any;
+    sliceContextMenu: (payload: SliceEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSliceClick?: ((payload: SliceEvent) => any) | undefined;
+    onSelectionChange?: ((payload: SliceEvent[]) => any) | undefined;
+    onSliceContextMenu?: ((payload: SliceEvent) => any) | undefined;
+}>, {
+    size: number;
+    type: "pie" | "donut";
+    animate: boolean;
+    duration: number;
+    emptyLabel: string;
+    innerRatio: number;
+    maxSlices: number;
+    otherLabel: string;
+    labelWidth: number;
+    showPercent: boolean;
+    showTotal: boolean;
+    padAngle: number;
+    cornerRadius: number;
+    hoverOffset: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LpPie.vue.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "../chunks/LpPie-BkjWlfSw.js";
+export {
+  _sfc_main as default
+};

package/dist/components/LpProgress.vue.d.ts

@@ -1,12 +1,66 @@
 type __VLS_Props = {
     value?: number;
     max?: number;
-    tone?: "brand" | "action" | "danger";
+    /**
+     * `"auto"` colours by how full the bar is — calm up to `warnAt`, accent
+     * past it, danger past `dangerAt`.
+     *
+     * A gauge of a finite resource (disk, memory, quota) means something
+     * different at 92% than at 12%, and consumers were each re-deriving that
+     * with their own palette — which also put raw colours back into components
+     * the theme can no longer reach.
+     */
+    tone?: "brand" | "action" | "danger" | "accent" | "auto";
+    /** `auto` tone: the fill fraction, 0–1, where the bar turns accent. */
+    warnAt?: number;
+    /** `auto` tone: the fill fraction, 0–1, where it turns danger. */
+    dangerAt?: number;
+    /**
+     * Bar only: a name for what is being measured, printed above the bar. With
+     * `caption` it forms the "CPU … 42%" header a usage row wants.
+     */
+    title?: string;
+    /**
+     * Bar only: the reading, printed opposite `title`. `true` prints the
+     * rounded percentage; a string says it in the units that matter
+     * ("23 GB / 64 GB"), which a percentage alone cannot.
+     */
+    caption?: boolean | string;
+    /** `bar` (default) fills horizontally; `ring` draws a dial. */
+    variant?: "bar" | "ring";
+    /** Ring only: outer diameter in px. */
+    size?: number;
+    /** Ring only: stroke width in px. */
+    thickness?: number;
+    /**
+     * Ring only: print the rounded percentage in the middle. Pass a string to
+     * label it with something else ("12.4k", "3/8") — the ring shows progress,
+     * the caption says what it is progress of.
+     */
+    label?: boolean | string;
+    /**
+     * Grow from empty on first render instead of appearing already filled.
+     *
+     * A dial that arrives complete states a fact; one that fills shows a
+     * quantity being measured, and the eye follows the sweep to where it stops —
+     * which is the number the tile is actually about. Both variants already ease
+     * every later change, so this only concerns the first paint.
+     */
+    animateOnMount?: boolean;
+    /** How long the fill takes, in ms. The counter in a ring matches it. */
+    duration?: number;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: number;
     max: number;
     value: number;
-    tone: "brand" | "action" | "danger";
+    duration: number;
+    variant: "bar" | "ring";
+    tone: "brand" | "action" | "danger" | "accent" | "auto";
+    animateOnMount: boolean;
+    warnAt: number;
+    dangerAt: number;
+    thickness: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/LpProgress.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpProgress-BhI0IbjC.js";
+import { _ as _sfc_main } from "../chunks/LpProgress-DoIP4jQR.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpRollingText.vue.d.ts

@@ -0,0 +1,33 @@
+type __VLS_Props = {
+    /** The text. A change to this is what triggers the transition. */
+    value: string | number;
+    mode?: "slide" | "flip";
+    /** Which way "slide" travels. `up` moves the old text up and out. */
+    direction?: "up" | "down";
+    duration?: number;
+    /**
+     * Alignment inside the clipped box, for when the two values differ in
+     * width — a value that grows shouldn't shove its neighbours.
+     */
+    align?: "start" | "center" | "end";
+};
+declare var __VLS_7: {
+    value: string | number;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    mode: "slide" | "flip";
+    direction: "up" | "down";
+    align: "start" | "center" | "end";
+    duration: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LpRollingText.vue.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "../chunks/LpRollingText-CM5gkSeF.js";
+export {
+  _sfc_main as default
+};

package/dist/components/LpSidebar.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpSidebar-D3GGLSE7.js";
+import { _ as _sfc_main } from "../chunks/LpSidebar-7Vpy2IJc.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpSidebarNav.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpSidebarNav-X14xMdPa.js";
+import { _ as _sfc_main } from "../chunks/LpSidebarNav-CFX5NxGs.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpSparkline.vue.d.ts

@@ -0,0 +1,48 @@
+type __VLS_Props = {
+    /** Oldest → newest. `null` breaks the line, as in LpChart. */
+    data: (number | null)[];
+    /** Rendered size in px. The path scales to it; stroke width does not. */
+    width?: number;
+    height?: number;
+    /** Any CSS colour. Defaults to the brand token. */
+    color?: string;
+    /** Named theme tones, for callers that don't want to spell a var(). */
+    tone?: "brand" | "action" | "danger" | "accent" | "muted";
+    /** Fill under the line. */
+    area?: boolean;
+    /** Curve tension, as in LpChart. 0 draws a polyline. */
+    smooth?: number;
+    /** Dot on the final point — "you are here" on a trend. */
+    showLast?: boolean;
+    /**
+     * Pin the vertical range instead of fitting the data. Without it a flat
+     * series fills the box with noise, and two sparklines in one column can't
+     * be compared: each would be scaled to its own extremes.
+     */
+    min?: number;
+    max?: number;
+    /** Accessible description; falls back to a direction + latest value. */
+    ariaLabel?: string;
+    /**
+     * Draw the line on from oldest to newest when it first appears. Turn it off
+     * for a table that renders many at once — dozens of simultaneous sweeps
+     * read as flicker.
+     */
+    animate?: boolean;
+    /**
+     * Draw time in ms. The stroke travels at a near-even rate (see
+     * `--ease-travel`), so this is roughly how long the line is actually
+     * watched being drawn — not a figure mostly spent easing out.
+     */
+    duration?: number;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    width: number;
+    height: number;
+    animate: boolean;
+    duration: number;
+    smooth: number;
+    tone: "brand" | "action" | "danger" | "accent" | "muted";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/LpSparkline.vue.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "../chunks/LpSparkline-C6xQ2dwv.js";
+export {
+  _sfc_main as default
+};

package/dist/components/LpStat.vue.d.ts

@@ -1,6 +1,18 @@
 type __VLS_Props = {
     label: string;
-    value: string;
+    /**
+     * A string is printed as given; a NUMBER counts to its new value on
+     * LpNumberFlow's digit wheels. A tile on a live dashboard is the one place
+     * a figure changes while somebody is looking at it, and a value that cuts
+     * from 41 to 43 says nothing about which way it moved.
+     */
+    value: string | number;
+    /** Formatting for a numeric `value` — see LpNumberFlow. */
+    compact?: boolean;
+    grouped?: boolean;
+    decimals?: number;
+    prefix?: string;
+    valueSuffix?: string;
     hint?: string;
     icon?: string;
     online?: boolean;
@@ -15,8 +27,19 @@ type __VLS_Props = {
      *  downward trend reads as positive (action) and upward as danger. */
     invertTrend?: boolean;
 };
-declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+declare var __VLS_21: {};
+type __VLS_Slots = {} & {
+    trend?: (props: typeof __VLS_21) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    decimals: number;
     trend: "auto" | "up" | "down" | "flat";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LpStat.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpStat-CdbEFOvn.js";
+import { _ as _sfc_main } from "../chunks/LpStat-CDanpzU0.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpThemeSwitcher.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpThemeSwitcher-BgpJgrnP.js";
+import { _ as _sfc_main } from "../chunks/LpThemeSwitcher-7mAK6bI7.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpTooltip.vue.d.ts

@@ -16,12 +16,33 @@ type __VLS_Props = {
      * pops up after every mouse click on the trigger is noise.
      */
     showOnPointerFocus?: boolean;
+    /**
+     * Track the pointer instead of anchoring to the trigger's edge.
+     *
+     * For a trigger that is large or oddly shaped — a chart slice, a canvas, a
+     * map region — where the element's bounding box says little about what the
+     * pointer is actually over: anchored to the box, the tip can appear far from
+     * the thing it describes. Following the cursor keeps it next to the reading.
+     */
+    followCursor?: boolean;
+    /**
+     * Suppress the tip. For a trigger whose tip only applies to part of it — a
+     * chart wrapper where the pointer may be over a mark or over empty canvas —
+     * so an empty panel never opens over the gaps.
+     *
+     * This also FORCES CLOSED a tip that is already showing. reka's own
+     * `disabled` does not: it stops managing the tooltip where it stands, so one
+     * that was open when the flag flipped stayed on screen for good — outliving
+     * the pointer, letting a second chart open its own beside it, and surviving
+     * a scroll that should have dismissed it.
+     */
+    disabled?: boolean;
 };
-declare var __VLS_20: {}, __VLS_34: {};
+declare var __VLS_24: {}, __VLS_38: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_20) => any;
+    default?: (props: typeof __VLS_24) => any;
 } & {
-    content?: (props: typeof __VLS_34) => any;
+    content?: (props: typeof __VLS_38) => any;
 };
 declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     delay: number;

package/dist/components/LpTooltip.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpTooltip-D1hbjQWG.js";
+import { _ as _sfc_main } from "../chunks/LpTooltip-hCLPAqMG.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpUptimeBar.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpUptimeBar-CB366k0O.js";
+import { _ as _sfc_main } from "../chunks/LpUptimeBar-DcQ8HikG.js";
 export {
   _sfc_main as default
 };

package/dist/components/chart.d.ts

@@ -0,0 +1,180 @@
+export interface ChartPoint {
+    /** Numeric value. `null` breaks the line — a real gap, not a zero. */
+    y: number | null;
+    /** Optional label for this point; falls back to the shared `labels` prop. */
+    x?: string;
+}
+export interface ChartSeries {
+    name: string;
+    /** Bare numbers are accepted and normalised to points. */
+    data: (number | null | ChartPoint)[];
+    /** Any CSS colour. Unset series cycle through the palette. */
+    color?: string;
+    /** Draw this series as a dashed line (targets, budgets, forecasts). */
+    dashed?: boolean;
+    /**
+     * Which y-axis this series is measured against. A series in different units
+     * or of a wildly different magnitude (errors beside requests, a rate beside a
+     * count) flattens against a shared axis; putting it on `"right"` gives it its
+     * own scale and its own ticks.
+     */
+    axis?: "left" | "right";
+}
+export type ChartAxis = "left" | "right";
+export interface NormalSeries {
+    name: string;
+    color: string;
+    dashed: boolean;
+    axis: ChartAxis;
+    values: (number | null)[];
+}
+export interface Box {
+    width: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+/** Plot area inside the padding — where marks may actually be drawn. */
+export declare const plotWidth: (b: Box) => number;
+export declare const plotHeight: (b: Box) => number;
+/** Series colours cycle through the theme's semantic palette. */
+export declare const CHART_PALETTE: string[];
+export declare const normalise: (series: ChartSeries[]) => NormalSeries[];
+/** Point labels win over the shared axis labels; index is the last resort. */
+export declare const resolveLabels: (series: ChartSeries[], labels: string[] | undefined, count: number) => string[];
+/** Longest series wins; shorter ones simply stop early. */
+export declare const pointCount: (series: NormalSeries[]) => number;
+/**
+ * "Nice" axis bounds: round the extent out to a human step (1/2/5 × 10ⁿ) so
+ * ticks land on readable numbers instead of 0.37, 1.24, 2.11.
+ */
+export declare const niceScale: (min: number, max: number, ticks: number) => {
+    min: number;
+    max: number;
+    step: number;
+};
+export declare const axisTicks: (min: number, max: number, step: number) => number[];
+/** Extent across every visible series, with zero pulled in when asked. */
+export declare const extent: (series: NormalSeries[], includeZero: boolean) => {
+    min: number;
+    max: number;
+};
+/** x pixel for point i. Bars sit at band centres, lines span edge to edge. */
+export declare const xAt: (i: number, count: number, box: Box, banded: boolean) => number;
+export declare const yAt: (v: number, min: number, max: number, box: Box) => number;
+interface Scale {
+    min: number;
+    max: number;
+    box: Box;
+    count: number;
+    banded: boolean;
+}
+export declare const linePath: (values: (number | null)[], s: Scale, smooth: number) => string;
+/** The line closed down to the baseline — one filled shape per unbroken run. */
+export declare const areaPath: (values: (number | null)[], s: Scale, smooth: number) => string;
+/** Nearest point index for a pixel x — what the hover crosshair snaps to. */
+export declare const nearestIndex: (px: number, s: Scale) => number;
+/**
+ * A bar as a path, rounded only on the corners named. A stack is one shape cut
+ * into segments: rounding every segment would bevel the internal joins and read
+ * as separate tiles rather than as one bar, so only the outermost segment of a
+ * stack rounds, and only on the end it actually terminates.
+ *
+ * `r` is clamped to half the box so a short segment degrades to a slab instead
+ * of inverting its own corners.
+ */
+export declare const barPath: (x: number, y: number, w: number, h: number, r: number, round: {
+    top: boolean;
+    bottom: boolean;
+}) => string;
+export interface PieSlice {
+    label: string;
+    value: number;
+    /** Any CSS colour. Unset slices cycle through the palette. */
+    color?: string;
+}
+export interface ResolvedSlice {
+    label: string;
+    value: number;
+    color: string;
+    /** 0–1 of the total. */
+    fraction: number;
+    /** True for the synthesised remainder slice. */
+    isOther: boolean;
+    /** How many input slices this one stands for (1, or N when collapsed). */
+    count: number;
+}
+/**
+ * Fold an arbitrary number of slices down to something a circle can actually
+ * show, WITHOUT dropping data.
+ *
+ * A pie is only legible while its slices are distinguishable by angle; past a
+ * handful they become slivers no one can compare or click. But a shared kit
+ * can't know how many categories a caller has, so refusing to draw twenty is
+ * not an option either. So: keep the largest `max - 1` and sum the rest into a
+ * single "Other" slice that keeps its own total, its own share, and a count of
+ * what it stands for — the tail stays visible and addressable instead of being
+ * silently truncated.
+ *
+ * Negative values are dropped: a share of a whole has no meaning below zero,
+ * and letting one in makes every other slice's fraction wrong.
+ */
+export declare const resolveSlices: (slices: PieSlice[], max: number | undefined, otherLabel: string, 
+/**
+ * Keep the caller's ordering for the slices that survive. Ranking decides
+ * WHICH slices are kept; it needn't decide the order they're shown in, and a
+ * caller that ordered its data deliberately ("Free" last, states worst-first)
+ * would see that shuffled for no reason. "Other" always sorts last.
+ */
+preserveOrder?: boolean) => {
+    slices: ResolvedSlice[];
+    total: number;
+};
+/**
+ * One slice as a path. `inner > 0` makes it a donut segment (an annulus) rather
+ * than a wedge from the centre.
+ *
+ * A slice covering the whole circle is drawn as two half-arcs: a single arc
+ * whose start and end coincide is a zero-length path, so "100% of one category"
+ * would render as nothing at all.
+ */
+export declare const arcPath: (cx: number, cy: number, outer: number, inner: number, startAngle: number, endAngle: number, 
+/** Corner radius in px, clamped to what the slice can actually carry. */
+corner?: number) => string;
+export interface CalloutLabel {
+    index: number;
+    /** Which side of the circle the label sits on. */
+    side: "left" | "right";
+    /** Elbow polyline: leader out of the slice, a bend, then a run to the text. */
+    points: string;
+    /** Where the text is anchored. */
+    x: number;
+    y: number;
+}
+/**
+ * Lay out callout labels around a circle: a leader line leaves each slice along
+ * its own bisector, bends, and runs horizontally to text stacked down the side.
+ *
+ * The whole difficulty is collision. Slices cluster — twenty versions of a
+ * server jar are mostly slivers packed into one arc — so labels placed at their
+ * natural angles would land on top of each other. Each side is therefore
+ * relaxed independently: labels keep their order around the circle, then get
+ * pushed apart to a minimum spacing and shifted back inside the box. That's why
+ * a leader can end well away from its slice's angle and still be unambiguous —
+ * the line, not the position, is what identifies it.
+ */
+export declare const calloutLabels: (angles: {
+    index: number;
+    mid: number;
+}[], cx: number, cy: number, radius: number, 
+/** How far past the radius the elbow sits. */
+elbow: number, 
+/** Horizontal run from the elbow to the text. */
+run: number, 
+/** Minimum vertical gap between two labels on the same side. */
+spacing: number, height: number) => CalloutLabel[];
+/** Compact default tick formatting: 1.2k, 3.4M — never 1200.0000001. */
+export declare const formatTick: (v: number) => string;
+export {};