@leavepulse/ui 0.12.0

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

@@ -0,0 +1,19 @@
+export interface TocLink {
+    id: string;
+    text: string;
+    depth?: number;
+    children?: TocLink[];
+}
+type __VLS_Props = {
+    links: TocLink[];
+    /** Heading shown above the list. */
+    title?: string;
+    /** px offset from the top used as the scroll-spy trigger line. */
+    offset?: number;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    title: string;
+    offset: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,45 @@
+export interface TabItem {
+    value: string;
+    label: string;
+    /** Optional iconify name (e.g. "lucide:palette"), shown left of the label. */
+    icon?: string;
+}
+type __VLS_Props = {
+    modelValue?: string;
+    items: TabItem[];
+    /**
+     * "contained" (default) wraps the triggers in a bordered, filled bar.
+     * "plain" drops the container chrome — a flat row of tabs with only the
+     * sliding pill marking the active one (for nav bars over a custom surface).
+     */
+    variant?: "contained" | "plain";
+    /** Tint the active pill + label with the brand colour (nav-bar style). */
+    accent?: boolean;
+    /** Stretch the bar to full width with equal-share triggers. */
+    block?: boolean;
+};
+declare var __VLS_48: {
+    value: string;
+}, __VLS_50: {};
+type __VLS_Slots = {} & {
+    panel?: (props: typeof __VLS_48) => any;
+} & {
+    default?: (props: typeof __VLS_50) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    block: boolean;
+    variant: "contained" | "plain";
+    accent: 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/LpTextarea.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    modelValue?: string;
+    placeholder?: string;
+    rows?: number;
+    invalid?: boolean;
+    disabled?: boolean;
+    label?: string;
+    hint?: string;
+    error?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,40 @@
+import { TokenSet } from '../theme/tokens';
+type __VLS_Props = {
+    /** Active theme NAME (v-model). Falls back to the first theme. */
+    modelValue?: string;
+    /** Themes to offer. Defaults to all built-in presets. */
+    themes?: TokenSet[];
+    /**
+     * Trigger style:
+     *  - "swatch" (default): a square showing the active theme's brand colour.
+     *  - "icon": a sun/moon icon following the active theme's mode.
+     *  - "pill": swatch + the theme name in a pill (always shows the label).
+     */
+    variant?: "swatch" | "icon" | "pill";
+    /** Show the active theme's name next to the trigger (forced on for "pill"). */
+    showLabel?: boolean;
+    /**
+     * Default theme applied on mount when nothing is cached yet — the theme NAME
+     * (must be in `themes`) or a TokenSet. Lets a consuming app pick its default
+     * declaratively (<LpThemeSwitcher :default="'Violet'">) with no separate
+     * bootstrap plugin; a previously saved choice still wins over it.
+     */
+    default?: string | TokenSet;
+    /** Animate theme changes with the circular reveal. On by default. */
+    transition?: boolean;
+    size?: "sm" | "md" | "lg";
+    "aria-label"?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (theme: TokenSet) => any;
+    "update:modelValue": (name: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((theme: TokenSet) => any) | undefined;
+    "onUpdate:modelValue"?: ((name: string) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    transition: boolean;
+    variant: "swatch" | "icon" | "pill";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    content?: string;
+    sideOffset?: number;
+};
+declare var __VLS_20: {}, __VLS_34: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_20) => any;
+} & {
+    content?: (props: typeof __VLS_34) => any;
+};
+declare const __VLS_base: 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 __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/LpTopologyCanvas.vue.d.ts

@@ -0,0 +1,154 @@
+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;
+}
+/**
+ * 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;
+    /**
+     * Background swimlanes drawn beneath the nodes (one per project / overlay).
+     * Non-interactive; pan/zoom with the graph. Empty = no lanes.
+     */
+    lanes?: TopologyLane[];
+};
+declare function applyViewport(v: CanvasViewport): Promise<void>;
+declare const __VLS_export: 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-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-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;
+    connectable: boolean;
+    selectable: boolean;
+    lanes: TopologyLane[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,30 @@
+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;
+}
+type __VLS_Props = {
+    /** 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>>;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    showUptime: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/codeHighlight.d.ts

@@ -0,0 +1,8 @@
+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/countries-data.d.ts

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

package/dist/components/countries.d.ts

@@ -0,0 +1,20 @@
+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;

package/dist/components/dropdown.d.ts

@@ -0,0 +1,29 @@
+/** Enter/exit animation for state-open panels (Select, Popover, Dropdown, …). */
+export declare const POPOVER_ANIM: string;
+/** Tooltip variant: faster, and reka uses `delayed-open` instead of `open`. */
+export declare const TOOLTIP_ANIM: string;
+/**
+ * The bare floating surface (border, raised overlay fill, blur, shadow) without
+ * any animation — pair with POPOVER_ANIM or TOOLTIP_ANIM. `group` lets option
+ * rows read the panel's data-side for the cascade direction.
+ */
+export declare const PANEL_SURFACE = "group rounded-control border border-line bg-surface-overlay shadow-panel backdrop-blur";
+/**
+ * Surface + the state-open animation. Add width/padding/overflow and the z-layer
+ * at the call-site (z-layer omitted so tooltips can use z-(--z-tooltip) while the
+ * rest use z-(--z-popover)).
+ */
+export declare const POPOVER_PANEL: string;
+/**
+ * A selectable option row: layout, highlight state, and the staggered cascade.
+ * Cascades downward by default and upward when the panel is flipped above the
+ * trigger (group-data-[side=top]). Pair with an inline animationDelay for the
+ * stagger. `flex` + gap are included; add justify/extra layout if needed.
+ */
+export declare const OPTION_ITEM: string;
+/**
+ * Micro-animation for a close / clear "✕" icon: a quarter-turn on hover and a
+ * dip on press. Put on the <LpIcon>, with `group` on its button. Shared by
+ * Modal, Drawer, Toaster and the Autocomplete clear button.
+ */
+export declare const CLOSE_ICON: string;

package/dist/components/sidebar.d.ts

@@ -0,0 +1,18 @@
+import { ContextMenuItemDef } from './LpContextMenu.vue';
+export interface SidebarItem {
+    id: string;
+    label: string;
+    icon?: string;
+    /** Render as a link instead of a button. */
+    href?: string;
+    /** Count chip on the right (number or short string). */
+    badge?: number | string;
+    disabled?: boolean;
+    /** Right-click menu for this item (e.g. "Open in new tab", "Pin"). */
+    menu?: ContextMenuItemDef[];
+}
+export interface SidebarSection {
+    /** Optional heading above the group. */
+    title?: string;
+    items: SidebarItem[];
+}

package/dist/composables/useInputFilter.d.ts

@@ -0,0 +1,14 @@
+import { MaybeRefOrGetter } from 'vue';
+export interface UseInputFilterOptions {
+    /** One-char RegExp of allowed characters. Disallowed input is blocked. */
+    restrict?: MaybeRefOrGetter<RegExp | undefined>;
+    /** RegExp/string the full value must match to be valid. Validation only. */
+    pattern?: MaybeRefOrGetter<RegExp | string | undefined>;
+}
+export declare function useInputFilter(options?: UseInputFilterOptions): {
+    isInvalid: (value: string | undefined) => boolean;
+    onBeforeInput: (event: InputEvent) => void;
+    onPaste: (event: ClipboardEvent) => void;
+    patternRe: import('vue').ComputedRef<RegExp | undefined>;
+    restrict: import('vue').ComputedRef<RegExp | undefined>;
+};

package/dist/composables/usePillTransition.d.ts

@@ -0,0 +1,9 @@
+import { ComputedRef } from 'vue';
+export type PillTransition = {
+    duration: number;
+} | {
+    type: "spring";
+    stiffness: number;
+    damping: number;
+};
+export declare function usePillTransition(): ComputedRef<PillTransition>;

package/dist/composables/useToast.d.ts

@@ -0,0 +1,39 @@
+export type ToastVariant = "info" | "success" | "warning" | "error";
+export interface ToastAction {
+    label: string;
+    onClick: () => void | Promise<void>;
+}
+export interface ToastItem {
+    id: number;
+    title?: string;
+    message: string;
+    variant: ToastVariant;
+    duration: number;
+    /** Epoch ms when this toast auto-dismisses, or null if it never does. */
+    dismissAt: number | null;
+    actions?: ToastAction[];
+    /** Whole-toast click handler (UAProject-style clickable toast). */
+    onClick?: () => void | Promise<void>;
+}
+export interface ToastOptions {
+    title?: string;
+    duration?: number;
+    actions?: ToastAction[];
+    onClick?: () => void | Promise<void>;
+}
+declare function push(variant: ToastVariant, message: string, options?: ToastOptions): number;
+declare function dismiss(id: number): void;
+declare function clear(): void;
+export declare function useToast(): {
+    queue: ToastItem[];
+    toast: (message: string, o?: ToastOptions) => number;
+    info: (message: string, o?: ToastOptions) => number;
+    success: (message: string, o?: ToastOptions) => number;
+    warning: (message: string, o?: ToastOptions) => number;
+    error: (message: string, o?: ToastOptions) => number;
+    /** Low-level push for bridges (e.g. @leavepulse/ui-sdk apiError). */
+    push: typeof push;
+    dismiss: typeof dismiss;
+    clear: typeof clear;
+};
+export {};