@leavepulse/ui 0.24.1 → 0.25.0

package/dist/chunks/LpUptimeBar-DcQ8HikG.js

@@ -0,0 +1,152 @@
+import { defineComponent, computed, ref, openBlock, createElementBlock, createElementVNode, toDisplayString, createCommentVNode, createVNode, withCtx, Fragment, renderList, normalizeStyle, createBlock, createTextVNode } from "vue";
+import { _ as _sfc_main$3 } from "./LpNumberFlow-amWYaeuA.js";
+import { _ as _sfc_main$2 } from "./LpRollingText-CM5gkSeF.js";
+import { _ as _sfc_main$1 } from "./LpTooltip-hCLPAqMG.js";
+import '../assets/LpUptimeBar-B98o9krI.css';const _hoisted_1 = { class: "flex flex-col gap-1.5" };
+const _hoisted_2 = {
+  key: 0,
+  class: "text-xs"
+};
+const _hoisted_3 = { class: "font-medium text-ink" };
+const _hoisted_4 = {
+  key: 0,
+  class: "flex items-center gap-1.5"
+};
+const _hoisted_5 = ["aria-label", "onPointerenter"];
+const _hoisted_6 = {
+  key: 1,
+  class: "flex items-center gap-2 text-xs text-muted"
+};
+const _hoisted_7 = { class: "shrink-0" };
+const _hoisted_8 = {
+  key: 0,
+  class: "shrink-0 text-muted-strong"
+};
+const _hoisted_9 = { class: "shrink-0" };
+const MARK_WIDTH = 0.64;
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "LpUptimeBar",
+  props: {
+    segments: {},
+    startLabel: {},
+    endLabel: {},
+    showUptime: { type: Boolean, default: true },
+    title: {},
+    colors: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const defaultColor = {
+      operational: "var(--color-action)",
+      degraded: "var(--color-accent)",
+      down: "var(--color-danger)",
+      maintenance: "var(--color-brand)",
+      empty: "var(--color-surface-soft)"
+    };
+    const opacityFor = (status) => status === "empty" ? 0.4 : 1;
+    const colorFor = (status) => props.colors?.[status] ?? defaultColor[status];
+    const statusLabel = {
+      operational: "Operational",
+      degraded: "Degraded",
+      down: "Down",
+      maintenance: "Maintenance",
+      empty: "No data"
+    };
+    const uptimePct = computed(() => {
+      const tracked = props.segments.filter((s) => s.status !== "empty");
+      if (!tracked.length) return null;
+      const up = tracked.filter((s) => s.status === "operational" || s.status === "maintenance").length;
+      return up / tracked.length * 100;
+    });
+    const hovered = ref(null);
+    const tip = computed(() => {
+      const i = hovered.value;
+      if (i == null) return null;
+      const seg = props.segments[i];
+      if (!seg) return null;
+      return { status: seg.status, text: seg.label ?? statusLabel[seg.status] };
+    });
+    const uptimeDecimals = computed(() => {
+      const v = uptimePct.value;
+      if (v == null) return 0;
+      const trimmed = Number(v.toFixed(2));
+      return Number.isInteger(trimmed) ? 0 : String(trimmed).split(".")[1].length;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        __props.title ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          createElementVNode("span", _hoisted_3, toDisplayString(__props.title), 1)
+        ])) : createCommentVNode("", true),
+        createVNode(_sfc_main$1, {
+          delay: 80,
+          "follow-cursor": "",
+          side: "top",
+          disabled: hovered.value === null
+        }, {
+          content: withCtx(() => [
+            tip.value ? (openBlock(), createElementBlock("span", _hoisted_4, [
+              createElementVNode("span", {
+                class: "size-1.5 shrink-0 rounded-full",
+                style: normalizeStyle({ backgroundColor: colorFor(tip.value.status) })
+              }, null, 4),
+              createVNode(_sfc_main$2, {
+                value: tip.value.text,
+                duration: 180,
+                align: "start"
+              }, null, 8, ["value"])
+            ])) : createCommentVNode("", true)
+          ]),
+          default: withCtx(() => [
+            createElementVNode("div", {
+              class: "lp-uptime flex h-[34px] items-stretch",
+              onPointerleave: _cache[0] || (_cache[0] = ($event) => hovered.value = null)
+            }, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.segments, (seg, i) => {
+                return openBlock(), createElementBlock("button", {
+                  key: i,
+                  type: "button",
+                  class: "lp-uptime__slot min-w-0 flex-1 outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                  "aria-label": seg.label ?? statusLabel[seg.status],
+                  onPointerenter: ($event) => hovered.value = i
+                }, [
+                  createElementVNode("span", {
+                    class: "lp-uptime__mark block h-full rounded-[1px] transition-[opacity,scale] duration-[var(--duration-fast)] motion-reduce:transition-none",
+                    style: normalizeStyle({
+                      backgroundColor: colorFor(seg.status),
+                      opacity: hovered.value === i ? 1 : opacityFor(seg.status),
+                      // Both axes every time: the x factor is what holds the gap open
+                      // (see the stylesheet), so a hover that set only y would widen
+                      // the slice into its neighbours' spacing.
+                      scale: hovered.value === i ? `${MARK_WIDTH} 1.12` : void 0
+                    })
+                  }, null, 4)
+                ], 40, _hoisted_5);
+              }), 128))
+            ], 32)
+          ]),
+          _: 1
+        }, 8, ["disabled"]),
+        __props.startLabel || __props.endLabel || __props.showUptime ? (openBlock(), createElementBlock("div", _hoisted_6, [
+          createElementVNode("span", _hoisted_7, toDisplayString(__props.startLabel), 1),
+          _cache[2] || (_cache[2] = createElementVNode("span", { class: "h-px flex-1 bg-line" }, null, -1)),
+          __props.showUptime ? (openBlock(), createElementBlock("span", _hoisted_8, [
+            uptimePct.value != null ? (openBlock(), createBlock(_sfc_main$3, {
+              key: 0,
+              value: uptimePct.value,
+              decimals: uptimeDecimals.value,
+              suffix: "%"
+            }, null, 8, ["value", "decimals"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+              createTextVNode("—")
+            ], 64)),
+            _cache[1] || (_cache[1] = createElementVNode("span", { class: "text-muted" }, " uptime", -1))
+          ])) : createCommentVNode("", true),
+          _cache[3] || (_cache[3] = createElementVNode("span", { class: "h-px flex-1 bg-line" }, null, -1)),
+          createElementVNode("span", _hoisted_9, toDisplayString(__props.endLabel), 1)
+        ])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/component-names.d.ts

@@ -1 +1 @@
-export declare const COMPONENT_NAMES: readonly ["LayoutCanvas", "LayoutNode", "LpAddressInput", "LpAlert", "LpAppShell", "LpAutocomplete", "LpAvatar", "LpBadge", "LpBreadcrumbs", "LpButton", "LpCalendar", "LpCard", "LpCheckbox", "LpCodeBlock", "LpCommandPalette", "LpConfirmDialog", "LpContextMenu", "LpDatePicker", "LpDisclosure", "LpDivider", "LpDrawer", "LpDropdownMenu", "LpEmptyState", "LpFileTree", "LpFileTreeNode", "LpFormField", "LpIcon", "LpInfraNode", "LpInput", "LpLaneNode", "LpLightbox", "LpLink", "LpLogViewer", "LpMapPicker", "LpModal", "LpNotificationBell", "LpNumberField", "LpOtpInput", "LpPagination", "LpPasswordInput", "LpPhoneInput", "LpPopover", "LpProgress", "LpRadio", "LpRadioGroup", "LpScrollArea", "LpSegmented", "LpSelect", "LpServiceNode", "LpShift", "LpShortcutsDialog", "LpSidebar", "LpSidebarNav", "LpSkeleton", "LpSlider", "LpStat", "LpStepper", "LpSwitch", "LpTable", "LpTableOfContents", "LpTabs", "LpTextarea", "LpThemeSwitcher", "LpTilt", "LpToaster", "LpTooltip", "LpTopologyCanvas", "LpUptimeBar", "LpWaypointEdge"];
+export declare const COMPONENT_NAMES: readonly ["LayoutCanvas", "LayoutNode", "LpAddressInput", "LpAlert", "LpAppShell", "LpAutocomplete", "LpAvatar", "LpBadge", "LpBreadcrumbs", "LpButton", "LpCalendar", "LpCard", "LpChart", "LpCheckbox", "LpCodeBlock", "LpCommandPalette", "LpConfirmDialog", "LpContextMenu", "LpDatePicker", "LpDisclosure", "LpDivider", "LpDrawer", "LpDropdownMenu", "LpEmptyState", "LpFileTree", "LpFileTreeNode", "LpFormField", "LpIcon", "LpInfraNode", "LpInput", "LpLaneNode", "LpLightbox", "LpLink", "LpLogViewer", "LpMapPicker", "LpModal", "LpNotificationBell", "LpNumberField", "LpNumberFlow", "LpOtpInput", "LpPagination", "LpPasswordInput", "LpPhoneInput", "LpPie", "LpPopover", "LpProgress", "LpRadio", "LpRadioGroup", "LpRollingText", "LpScrollArea", "LpSegmented", "LpSelect", "LpServiceNode", "LpShift", "LpShortcutsDialog", "LpSidebar", "LpSidebarNav", "LpSkeleton", "LpSlider", "LpSparkline", "LpStat", "LpStepper", "LpSwitch", "LpTable", "LpTableOfContents", "LpTabs", "LpTextarea", "LpThemeSwitcher", "LpTilt", "LpToaster", "LpTooltip", "LpTopologyCanvas", "LpUptimeBar", "LpWaypointEdge"];

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

@@ -0,0 +1,88 @@
+import { ChartSeries } from './chart';
+import { ContextMenuItemDef } from './LpContextMenu.vue';
+/** What was under the pointer when a point was clicked or right-clicked. */
+export interface ChartPointEvent {
+    index: number;
+    label: string;
+    /** Every series' value at this index, in `series` order (hidden included). */
+    values: (number | null)[];
+    /** The original event, for callers that need modifiers or coordinates. */
+    originalEvent: MouseEvent;
+}
+type __VLS_Props = {
+    series: ChartSeries[];
+    /** Shared x-axis labels; a point's own `x` overrides its slot. */
+    labels?: string[];
+    type?: "line" | "area" | "bar";
+    /** Plot height in px. The width always fills the container. */
+    height?: number;
+    /** Headline above the plot. */
+    title?: string;
+    /** Sub-headline under the title. */
+    subtitle?: string;
+    /** Curve tension for line/area. 0 = straight polyline, 1 = fully smooth. */
+    smooth?: number;
+    /** Draw a dot at every point rather than only the hovered one. */
+    showPoints?: boolean;
+    showGrid?: boolean;
+    showXAxis?: boolean;
+    showYAxis?: boolean;
+    /** Legend also toggles series visibility on click. */
+    showLegend?: boolean;
+    /** Roughly how many y ticks to aim for; bounds are rounded to fit. */
+    yTicks?: number;
+    /** Force the y-axis to include 0 (bars always do). */
+    includeZero?: boolean;
+    /** Appended to values in ticks and the tooltip, e.g. "%" or " ms". */
+    unit?: string;
+    /** Unit for series on the right axis. Falls back to `unit`. */
+    rightUnit?: string;
+    /** Custom value formatter; overrides the compact 1.2k default. */
+    formatValue?: (v: number) => string;
+    /** Formatter for the right axis. Falls back to `formatValue`. */
+    formatRightValue?: (v: number) => string;
+    /** Stack bars instead of grouping them side by side. */
+    stacked?: boolean;
+    /** Grow the marks in on mount and on data change. */
+    animate?: boolean;
+    /** Shown when every series is empty. */
+    emptyLabel?: string;
+    /**
+     * Right-click menu for a point, built from whatever was hit. Return [] to
+     * leave the browser's own menu alone for that point. Which actions a point
+     * offers is an application question — "compare with last week", "open the
+     * incident", "copy value" — so the chart supplies the context and the
+     * caller supplies the items.
+     */
+    menuItems?: (point: ChartPointEvent) => ContextMenuItemDef[];
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    actions?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    pointClick: (payload: ChartPointEvent) => any;
+    pointContextMenu: (payload: ChartPointEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onPointClick?: ((payload: ChartPointEvent) => any) | undefined;
+    onPointContextMenu?: ((payload: ChartPointEvent) => any) | undefined;
+}>, {
+    type: "line" | "area" | "bar";
+    height: number;
+    animate: boolean;
+    smooth: number;
+    showGrid: boolean;
+    showXAxis: boolean;
+    showYAxis: boolean;
+    showLegend: boolean;
+    yTicks: number;
+    emptyLabel: string;
+}, {}, {}, {}, 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/LpChart.vue.js

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

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

@@ -4,7 +4,23 @@ type __VLS_Props = {
     description?: string;
     confirmLabel?: string;
     cancelLabel?: string;
+    /**
+     * The action destroys something. Colours the confirm button, and marks the
+     * title with a warning glyph — a destructive prompt should be recognisable
+     * before the words are read, since it is the one dialog people dismiss on
+     * reflex.
+     */
     danger?: boolean;
+    /**
+     * Override the marker: any iconify name, or `""` to leave the title plain —
+     * for a `danger` action whose dialog body already carries the warning and
+     * would otherwise state it twice.
+     *
+     * A string rather than `string | false`, deliberately: a union including
+     * Boolean makes Vue boolean-cast the prop, so an absent `icon` would arrive
+     * as `false` and be indistinguishable from a caller suppressing the marker.
+     */
+    icon?: string;
     /**
      * The confirm action is in flight: the button disables and swaps to
      * `loadingLabel`, and confirming no longer closes the dialog — the owner
@@ -13,9 +29,9 @@ type __VLS_Props = {
     loading?: boolean;
     loadingLabel?: string;
 };
-declare var __VLS_10: {};
+declare var __VLS_16: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_10) => any;
+    default?: (props: typeof __VLS_16) => any;
 };
 declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     cancel: () => any;

package/dist/components/LpConfirmDialog.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpConfirmDialog-CObRah9c.js";
+import { _ as _sfc_main } from "../chunks/LpConfirmDialog-CjOGcj1e.js";
 export {
   _sfc_main as default
 };

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

@@ -89,11 +89,11 @@ declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
     sort: boolean;
     loading: boolean;
     skeletonRows: number;
+    emptyLabel: string;
     iconSize: number;
     checkable: boolean;
     showSize: boolean;
     showModified: boolean;
-    emptyLabel: string;
     emptyDescription: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/LpFileTree.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpFileTree-H7Ho8uoq.js";
+import { _ as _sfc_main } from "../chunks/LpFileTree-BaV7f0O7.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpFileTreeNode.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpFileTreeNode-BEZIvxHi.js";
+import { _ as _sfc_main } from "../chunks/LpFileTreeNode-BzpBa7R7.js";
 export {
   _sfc_main as default
 };

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

@@ -47,8 +47,8 @@ declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {},
     loop: boolean;
     open: boolean;
     maxZoom: number;
-    copyable: boolean;
     index: number;
+    copyable: boolean;
     rotatable: boolean;
     downloadable: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

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

@@ -80,8 +80,8 @@ declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {
 }>, {
     height: string;
     wrap: boolean;
-    lineNumbers: boolean;
     emptyLabel: string;
+    lineNumbers: boolean;
     showTime: boolean;
     showLevel: boolean;
     tail: boolean;

package/dist/components/LpLogViewer.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpLogViewer-B1aLUVdz.js";
+import { _ as _sfc_main } from "../chunks/LpLogViewer-CcQ3s3Fp.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpMapPicker.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpMapPicker-DFKrd1Ne.js";
+import { _ as _sfc_main } from "../chunks/LpMapPicker-CXvoTrAe.js";
 export {
   _sfc_main as default
 };

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

@@ -5,6 +5,15 @@ export interface NotificationItem {
     body?: string;
     /** Optional icon name (e.g. "lucide:check-circle"). */
     icon?: string;
+    /**
+     * Colours the row's icon by what KIND of notification it is — a billing
+     * notice and a security one should not look alike at a glance.
+     *
+     * A named tone rather than a class, so the categories stay themeable:
+     * consumers were mapping their own types onto raw palette classes, which is
+     * the one place a theme cannot follow them.
+     */
+    tone?: "brand" | "action" | "danger" | "accent" | "muted";
     /** Optional deep link; the row becomes clickable when set. */
     link?: string;
     /** ISO-8601 creation time; rendered as a relative label. */
@@ -20,6 +29,7 @@ export interface NotificationItem {
 export interface NotificationLabels {
     title?: string;
     markAllRead?: string;
+    clear?: string;
     markAsRead?: string;
     markAsUnread?: string;
     open?: string;
@@ -53,12 +63,14 @@ type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare const __VLS_export: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
 } & {
+    clear: () => any;
     select: (item: NotificationItem) => any;
     markRead: (id: string) => any;
     markUnread: (id: string) => any;
     markAllRead: () => any;
     dismiss: (id: string) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClear?: (() => any) | undefined;
     onSelect?: ((item: NotificationItem) => any) | undefined;
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
     onMarkRead?: ((id: string) => any) | undefined;

package/dist/components/LpNotificationBell.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpNotificationBell-X1M30e0X.js";
+import { _ as _sfc_main } from "../chunks/LpNotificationBell-Dvu-b6Vn.js";
 export {
   _sfc_main as default
 };

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

@@ -0,0 +1,35 @@
+type __VLS_Props = {
+    value: number;
+    /** Travel time in ms. Distance changes the feel, not the duration. */
+    duration?: number;
+    /** Fixed decimal places. Ignored under `compact`. */
+    decimals?: number;
+    /**
+     * Abbreviate large numbers — 1.2k, 3.4M. Off by default: an exact figure
+     * should stay exact unless asked otherwise.
+     */
+    compact?: boolean;
+    /** Thousands separators. Ignored under `compact`. */
+    grouped?: boolean;
+    prefix?: string;
+    suffix?: string;
+    /** Custom formatter; overrides compact/decimals/grouped entirely. */
+    format?: (v: number) => string;
+    /** Start from 0 on first render rather than showing the value outright. */
+    animateOnMount?: boolean;
+    locale?: string;
+    /**
+     * Force the roll direction: "up" and "down" make every column travel the
+     * same way regardless of the digit, which reads as one mechanism turning.
+     * "auto" lets each column take the shorter route.
+     */
+    trend?: "auto" | "up" | "down";
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    duration: number;
+    decimals: number;
+    animateOnMount: boolean;
+    trend: "auto" | "up" | "down";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/LpNumberFlow.vue.js

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

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;