@leavepulse/ui 0.41.0 → 0.43.0

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

@@ -1,205 +0,0 @@
-import { Connection } from '@vue-flow/core';
-import { InfraNodeData } from './LpInfraNode.vue';
-import { ServiceNodeData } from './LpServiceNode.vue';
-export type EdgeObserved = "applied" | "pending" | "drift";
-export interface TopologyNode {
-    id: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    /** Host/group nodes use InfraNodeData; service nodes use ServiceNodeData. */
-    data: InfraNodeData | ServiceNodeData;
-    /**
-     * Node kind: "infra" (a host card, default), "service" (a small service node
-     * placed inside a host frame), or "group" (a host frame that contains
-     * services). Services set `parent` to their group's id.
-     */
-    type?: "infra" | "service" | "group";
-    /** For service nodes: the id of the host-frame group node they live in. */
-    parent?: string;
-    /** For group nodes: pixel size of the frame, and an optional label. */
-    width?: number;
-    height?: number;
-    label?: string;
-}
-/**
- * Edge semantics, encoded with both colour AND line style so the two kinds read
- * apart at a glance (and for colour-blind users): "network" = a transport wire
- * between hosts (solid, brand-cyan); "structural" = a depends_on relation
- * between services (dotted, violet, thinner). Inferred from `kind` when omitted
- * (`depends_on` → structural, everything else → network).
- */
-export type EdgeCategory = "network" | "structural";
-export interface TopologyEdge {
-    id: string;
-    source: string;
-    target: string;
-    /** transport label shown on the edge (e.g. "wg", "cloudflared"). */
-    kind?: string;
-    /** Semantic class driving colour + dash. Inferred from `kind` if omitted. */
-    category?: EdgeCategory;
-    observed?: EdgeObserved;
-    /**
-     * Push the edge into the background, matching the node data's `dimmed`. A
-     * focus highlight has to fade the edges too — dimming only the nodes leaves
-     * every unrelated line at full strength.
-     */
-    dimmed?: boolean;
-    /**
-     * Points the edge should curve through, when the host's layout knows where
-     * the gaps are. Requires `edgeType: "waypoints"`; ignored otherwise.
-     */
-    waypoints?: {
-        x: number;
-        y: number;
-    }[];
-}
-/**
- * A background swimlane: a sized zone (one per project / overlay network) drawn
- * beneath the nodes. The consumer computes the geometry; the canvas renders it
- * as a non-interactive Vue Flow node so it pans/zooms in lockstep with the
- * graph. Lanes are layered below real nodes and never intercept pointer events.
- */
-export interface TopologyLane {
-    id: string;
-    label: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Optional accent colour token for the lane border + label. */
-    accent?: string;
-}
-/** Canvas viewport transform — for restoring a saved pan/zoom. */
-export interface CanvasViewport {
-    x: number;
-    y: number;
-    zoom: number;
-}
-type __VLS_Props = {
-    nodes: TopologyNode[];
-    edges: TopologyEdge[];
-    /** Allow drag-to-connect (emits `connect`). Default false (read-only). */
-    connectable?: boolean;
-    /**
-     * Desktop-style marquee selection: drag on empty canvas to rubber-band a
-     * box and select every node inside; the selected set then drags together.
-     * Hold Shift to add to the selection. Panning moves to a right-drag / the
-     * space bar so left-drag is free for selecting. Default false (left-drag
-     * pans, the classic read-only behaviour). Emits `selection-change`.
-     */
-    selectable?: boolean;
-    /** Show the edge-type legend (Network / Depends-on / Pending / Drift). */
-    legend?: boolean;
-    /**
-     * Where the legend sits. Defaults to bottom-left: hosts commonly float a
-     * toolbar across the top, which would cover a top-anchored legend, and the
-     * minimap owns the bottom-right.
-     */
-    legendPosition?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
-    /**
-     * Edge shape. The default bezier bulges away from the straight line between
-     * its ends, which suits a free-form graph and cuts through everything in a
-     * LAYERED one — a long edge crosses the cards standing between its columns.
-     * `smoothstep` routes orthogonally through the gaps instead.
-     */
-    edgeType?: "default" | "smoothstep" | "step" | "straight" | "waypoints";
-    /** Rename legend rows to match what this graph's edges actually mean. */
-    legendLabels?: Partial<Record<"network" | "structural" | "pending" | "drift", string>>;
-    /**
-     * Background swimlanes drawn beneath the nodes (one per project / overlay).
-     * Non-interactive; pan/zoom with the graph. Empty = no lanes.
-     */
-    lanes?: TopologyLane[];
-    /**
-     * Minimap and zoom controls. On by default — a full-page map needs both —
-     * but a graph embedded at a few hundred pixels has nothing to navigate, and
-     * the overlays then cover a real share of the picture.
-     */
-    minimap?: boolean;
-    controls?: boolean;
-};
-declare function applyViewport(v: CanvasViewport): Promise<void>;
-declare var __VLS_29: {};
-type __VLS_Slots = {} & {
-    'legend-extra'?: (props: typeof __VLS_29) => any;
-};
-declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
-    fitView: import('@vue-flow/core').FitView;
-    setViewport: typeof applyViewport;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    connect: (value: Connection) => any;
-    "node-select": (id: string) => any;
-    "node-activate": (id: string) => any;
-    "node-contextmenu": (value: {
-        id: string;
-        x: number;
-        y: number;
-    }) => any;
-    "edge-contextmenu": (value: {
-        id: string;
-        x: number;
-        y: number;
-    }) => any;
-    "pane-click": () => any;
-    "selection-change": (ids: string[]) => any;
-    "update:nodes": (value: TopologyNode[]) => any;
-    "node-drag-stop": (value: {
-        id: string;
-        position: {
-            x: number;
-            y: number;
-        };
-    }) => any;
-    "viewport-change": (value: {
-        zoom: number;
-        x: number;
-        y: number;
-    }) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onConnect?: ((value: Connection) => any) | undefined;
-    "onNode-select"?: ((id: string) => any) | undefined;
-    "onNode-activate"?: ((id: string) => any) | undefined;
-    "onNode-contextmenu"?: ((value: {
-        id: string;
-        x: number;
-        y: number;
-    }) => any) | undefined;
-    "onEdge-contextmenu"?: ((value: {
-        id: string;
-        x: number;
-        y: number;
-    }) => any) | undefined;
-    "onPane-click"?: (() => any) | undefined;
-    "onSelection-change"?: ((ids: string[]) => any) | undefined;
-    "onUpdate:nodes"?: ((value: TopologyNode[]) => any) | undefined;
-    "onNode-drag-stop"?: ((value: {
-        id: string;
-        position: {
-            x: number;
-            y: number;
-        };
-    }) => any) | undefined;
-    "onViewport-change"?: ((value: {
-        zoom: number;
-        x: number;
-        y: number;
-    }) => any) | undefined;
-}>, {
-    legend: boolean;
-    controls: boolean;
-    connectable: boolean;
-    selectable: boolean;
-    legendPosition: "top-left" | "top-right" | "bottom-left" | "bottom-right";
-    lanes: TopologyLane[];
-    minimap: boolean;
-}, {}, {}, {}, 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/LpUptimeBar.vue.d.ts

@@ -1,46 +0,0 @@
-export type UptimeStatus = "operational" | "degraded" | "down" | "maintenance" | "empty";
-export interface UptimeSegment {
-    /** Health of this slice. `empty` renders a faded placeholder (no data). */
-    status: UptimeStatus;
-    /** Optional rich tooltip body; falls back to a humanised status. */
-    label?: string;
-}
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: import('vue').DefineComponent<{
-    /** Oldest → newest. Each entry is one slice of the timeline. */
-    segments: UptimeSegment[];
-    /** Caption shown under the left edge (oldest point). */
-    startLabel?: string;
-    /** Caption shown under the right edge (newest point). */
-    endLabel?: string;
-    /** Show the computed uptime % above the bar. */
-    showUptime?: boolean;
-    /** Override the headline shown next to the uptime %. */
-    title?: string;
-    /**
-     * Per-status colours. Any CSS colour (hex, rgb, `var(--token)`). Unset
-     * statuses fall back to the theme tokens below. Pass e.g.
-     * `{ degraded: '#ffb84d' }` to recolour just one state.
-     */
-    colors?: Partial<Record<UptimeStatus, string>>;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    /** Oldest → newest. Each entry is one slice of the timeline. */
-    segments: UptimeSegment[];
-    /** Caption shown under the left edge (oldest point). */
-    startLabel?: string;
-    /** Caption shown under the right edge (newest point). */
-    endLabel?: string;
-    /** Show the computed uptime % above the bar. */
-    showUptime?: boolean;
-    /** Override the headline shown next to the uptime %. */
-    title?: string;
-    /**
-     * Per-status colours. Any CSS colour (hex, rgb, `var(--token)`). Unset
-     * statuses fall back to the theme tokens below. Pass e.g.
-     * `{ degraded: '#ffb84d' }` to recolour just one state.
-     */
-    colors?: Partial<Record<UptimeStatus, string>>;
-}> & Readonly<{}>, {
-    showUptime: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

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

@@ -1,21 +0,0 @@
-import { Position } from '@vue-flow/core';
-type __VLS_Props = {
-    id: string;
-    sourceX: number;
-    sourceY: number;
-    targetX: number;
-    targetY: number;
-    sourcePosition?: Position;
-    targetPosition?: Position;
-    data?: {
-        waypoints?: {
-            x: number;
-            y: number;
-        }[];
-    };
-    markerEnd?: string;
-    style?: Record<string, unknown>;
-};
-declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/components/actionBar.d.ts

@@ -1,19 +0,0 @@
-export interface BarEntry {
-    id: number;
-    /** Measured height in px, reported by the bar once it is on screen. */
-    height: number;
-}
-/** Gap between stacked bars, matching the padding the bar sits in. */
-export declare const STACK_GAP = 8;
-/**
- * Registers a bar for as long as the calling scope lives. `setHeight` reports
- * the measured height; `offset()` returns how far up this bar should sit —
- * the total height of every bar that opened before it.
- */
-export declare function useBarStack(): {
-    register: () => void;
-    unregister: () => void;
-    setHeight: (height: number) => void;
-    offset: () => number;
-    bars: import('vue').Ref<BarEntry[] | undefined, BarEntry[] | undefined>;
-};

package/dist/components/address.d.ts

@@ -1,107 +0,0 @@
-export interface LatLon {
-    lat: number;
-    lon: number;
-}
-export interface AddressValue {
-    /** Street and house number, e.g. "Baker Street 221B". */
-    line: string;
-    /** Apartment, suite, floor — only shown when LpAddressInput asks for it. */
-    line2?: string;
-    city: string;
-    postalCode: string;
-    /** ISO 3166-1 alpha-2, uppercase — same shape LpPhoneInput uses. */
-    country: string;
-    /** Set once a point is picked on the map or a suggestion carries one. */
-    lat?: number;
-    lon?: number;
-}
-export declare function emptyAddress(): AddressValue;
-export interface AddressSuggestion {
-    /** Text to put in the field that asked for it. */
-    value: string;
-    label: string;
-    /** Fuller context — the whole formatted address, shown under the label. */
-    description?: string;
-    /** Parsed parts, as much as the provider resolved. */
-    address: Partial<AddressValue>;
-    lat?: number;
-    lon?: number;
-}
-/** Which field is being completed — providers can bias results accordingly. */
-export type AddressField = "line" | "city" | "postalCode";
-export interface GeocodeQuery {
-    /** Restrict to a country (ISO2) when the form already has one. */
-    country?: string;
-    /** Preferred result language, as an Accept-Language value. */
-    language?: string;
-    limit?: number;
-    signal?: AbortSignal;
-}
-export interface GeocodeProvider {
-    search(term: string, field: AddressField, query?: GeocodeQuery): Promise<AddressSuggestion[]>;
-    /** Point → address. Undefined when the point resolves to nothing. */
-    reverse(lat: number, lon: number, query?: GeocodeQuery): Promise<AddressSuggestion | undefined>;
-}
-export interface NominatimOptions {
-    /** Base URL of a Nominatim instance, no trailing slash. */
-    endpoint?: string;
-    language?: string;
-    /**
-     * Public Nominatim asks for an identifying UA and rate-limits hard; browsers
-     * won't let us set User-Agent, so this rides along as `email` instead, which
-     * their usage policy accepts. Point `endpoint` at your own instance for
-     * anything busier than a settings form.
-     */
-    email?: string;
-}
-export declare function createNominatimProvider(options?: NominatimOptions): GeocodeProvider;
-/**
- * Every user-facing string in LpAddressInput, so an app can translate it
- * without the kit taking an i18n dependency. Pass a partial — anything absent
- * keeps the English default.
- */
-export interface AddressLabels {
-    line: string;
-    linePlaceholder: string;
-    secondLine: string;
-    secondLinePlaceholder: string;
-    city: string;
-    cityPlaceholder: string;
-    postalCode: string;
-    postalCodePlaceholder: string;
-    country: string;
-    countryPlaceholder: string;
-    countrySearch: string;
-    pickOnMap: string;
-    mapTitle: string;
-    mapHint: string;
-    use: string;
-    cancel: string;
-    searching: string;
-    noSuggestions: string;
-    nothingHere: string;
-}
-/** Formats an address the way a shipping label would read. */
-export declare function formatAddress(value: AddressValue, countryName?: string): string;
-export interface TileSource {
-    /** Template with {z}/{x}/{y}, plus optional {s} for a subdomain. */
-    url: string;
-    /** Rendered under the map — most tile terms require crediting the source. */
-    attribution?: string;
-    subdomains?: string[];
-    minZoom?: number;
-    maxZoom?: number;
-    /** Edge length of one tile in CSS pixels. Default 256. */
-    tileSize?: number;
-}
-export declare const OSM_TILES: TileSource;
-export declare function tileUrl(source: TileSource, z: number, x: number, y: number): string;
-export declare const MAX_LATITUDE = 85.05112878;
-export declare function project(lat: number, lon: number, zoom: number, tileSize?: number): {
-    x: number;
-    y: number;
-};
-export declare function unproject(x: number, y: number, zoom: number, tileSize?: number): {
-    lat: number;
-    lon: number;
-};

package/dist/components/chart.d.ts

@@ -1,180 +0,0 @@
-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 {};

package/dist/components/codeHighlight.d.ts

@@ -1,8 +0,0 @@
-export type CodeLang = "ts" | "js" | "json" | "bash" | "html" | "python" | "rust" | "yaml" | "toml" | "kotlin" | "java" | "groovy" | "plain";
-export interface Token {
-    text: string;
-    /** CSS class for this token, or "" for plain text. */
-    cls: string;
-}
-/** Tokenize one line into coloured spans. JSON keys get the property colour. */
-export declare function tokenizeLine(line: string, lang: CodeLang): Token[];

package/dist/components/color.d.ts

@@ -1,65 +0,0 @@
-/** Hue 0..360, saturation/value 0..1, alpha 0..1. */
-export interface Hsv {
-    h: number;
-    s: number;
-    v: number;
-    a: number;
-}
-/** Channels 0..255, alpha 0..1. */
-export interface Rgb {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-}
-/** The string shapes a caller can hand the picker, and ask back out of it. */
-export type ColorFormat = "hex" | "rgb" | "hsl";
-/** Wraps rather than clamps: hue is a circle, and 370° is 10°, not 360°. */
-export declare function normalizeHue(h: number): number;
-export declare function clampHsv(c: Hsv): Hsv;
-export declare function hsvToRgb({ h, s, v, a }: Hsv): Rgb;
-export declare function rgbToHsv({ r, g, b, a }: Rgb): Hsv;
-/** "#rrggbb", or "#rrggbbaa" when the colour is not fully opaque. */
-export declare function rgbToHex({ r, g, b, a }: Rgb): string;
-/**
- * Parses #rgb / #rgba / #rrggbb / #rrggbbaa, with or without the leading `#`.
- * Returns null for anything it doesn't recognise, so a half-typed value in the
- * hex field can be left alone instead of snapping the picker to black.
- */
-export declare function parseHex(input: string): Rgb | null;
-/**
- * Parses a colour a person might paste: hex (3/4/6/8 digits, `#` optional),
- * rgb()/rgba() and hsl()/hsla() in both the comma and the space/slash forms,
- * percentages, hue in deg/turn/rad/grad, brackets optional, and a bare triple
- * of numbers read as rgb. A round-trip through a caller's storage therefore
- * comes back the colour it went in as, whatever shape it was stored in.
- *
- * Named colours ("rebeccapurple") and the newer spaces (lab, oklch, color())
- * are out of scope: resolving those needs the browser's own parser, and a
- * component that silently handled some and not others would be worse than one
- * that is clear about what it takes.
- */
-export declare function parseColor(input: string): Rgb | null;
-/** HSV→HSL, for the hsl() output format. Saturation/lightness come back 0..1. */
-export declare function hsvToHsl({ h, s, v }: Hsv): {
-    h: number;
-    s: number;
-    l: number;
-};
-/** The colour as a CSS string in the requested format. */
-export declare function formatColor(c: Hsv, format: ColorFormat): string;
-/** Always opaque — for the swatch behind an alpha checkerboard, and for rails. */
-export declare function opaqueCss(c: Hsv): string;
-/**
- * Whether dark ink reads better than light on this colour, by WCAG relative
- * luminance. The picker uses it for the check mark on a selected swatch, which
- * otherwise disappears into a pale preset.
- */
-export declare function isLight(c: Hsv): boolean;
-/**
- * A neutral starting palette. Kit tokens are deliberately NOT used here: these
- * are values a user picks *for their own data* (a tag, a calendar category),
- * which must stay put when the app's theme changes — a preset that shifted with
- * the theme would silently restyle everything already saved with it.
- */
-export declare const DEFAULT_SWATCHES: readonly ["#ef4444", "#f97316", "#f59e0b", "#22c55e", "#10b981", "#06b6d4", "#3b82f6", "#6366f1", "#8b5cf6", "#ec4899", "#64748b", "#111827"];

package/dist/components/countries-data.d.ts

@@ -1,2 +0,0 @@
-import { Country } from './countries';
-export declare const COUNTRIES: Country[];

package/dist/components/countries.d.ts

@@ -1,20 +0,0 @@
-export interface Country {
-    /** ISO 3166-1 alpha-2, uppercase (e.g. "US"). Drives the flag. */
-    iso2: string;
-    name: string;
-    /** Calling code without "+", e.g. "1", "44", "380". */
-    dial: string;
-}
-/** Turn an ISO2 code into its flag emoji (two regional-indicator symbols). */
-export declare function flagEmoji(iso2: string): string;
-/**
- * Load the country table (code-split chunk). Cached after first call, so repeat
- * calls are synchronous-ish (resolved promise) with no re-import cost.
- */
-export declare function loadCountries(): Promise<Country[]>;
-/**
- * Best-effort: pick the country whose dial code prefixes the given E.164-ish
- * value (longest match wins, so "1868" beats "1"). For shared codes the primary
- * country is preferred. Pass the list (from loadCountries). Undefined if none.
- */
-export declare function matchCountryByValue(value: string, list: Country[]): Country | undefined;