@leavepulse/ui 0.24.1 → 0.25.0

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/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 {};