@leavepulse/ui 0.43.1 → 0.43.3

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

@@ -0,0 +1,206 @@
+export interface Command {
+    id: string;
+    label: string;
+    /** Second line under the label. */
+    description?: string;
+    /**
+     * A passage of the matched text, wrapped over several lines (clamped by
+     * `excerptLines`) instead of truncated to one. For results a server found
+     * inside long text — a docs section, a ticket, a message — where the reason
+     * the row matched is the part worth reading before opening it.
+     */
+    excerpt?: string;
+    /**
+     * Extra words to highlight besides the typed query. A server that matches
+     * word forms or typos knows which words actually matched; the query alone
+     * would leave those unmarked.
+     */
+    highlight?: string[];
+    icon?: string;
+    /** Right-aligned hint, e.g. "⌘P". */
+    shortcut?: string;
+    /** Extra search terms not shown but matched against the query. */
+    keywords?: string[];
+    /** Section heading this command sits under. */
+    group?: string;
+    disabled?: boolean;
+    /**
+     * Hidden from the default (empty-query) list — only surfaces once the user
+     * types something it matches. For rarely-used or destructive actions (prune,
+     * decommission, …) that shouldn't clutter the palette but stay reachable.
+     */
+    hidden?: boolean;
+    /**
+     * Picking this opens a mode instead of closing: a nested list, either given
+     * outright or fetched from the query typed inside it. This is what keeps a
+     * palette from flattening "restart <service>" into one row per service —
+     * and what lets the second step search a list too big to enumerate.
+     *
+     * `onSelect` still runs when the mode opens, so a command can both act and
+     * drill in.
+     */
+    children?: Command[] | ((query: string) => Command[] | Promise<Command[]>);
+    /** Placeholder while inside this command's mode. */
+    childPlaceholder?: string;
+    /**
+     * Keep the palette open after this runs. For a command that toggles
+     * something the user may want to toggle again (a theme, a filter) without
+     * reopening and retyping.
+     */
+    keepOpen?: boolean;
+    /**
+     * Where the command leads. The row renders as a real link, so Ctrl/⌘-click,
+     * Shift-click and middle-click open it the way the browser opens any link,
+     * and Ctrl/⌘+Enter opens it in a new tab from the keyboard. A plain pick
+     * still runs `onSelect` (a router push, say); without one it follows the
+     * link.
+     */
+    href?: string;
+    /**
+     * Further things to do with this result besides opening it — copy its id,
+     * open it elsewhere, share it. Tab on the highlighted row lists them as a
+     * mode named after the row. A command with `href` gets "open in new tab"
+     * and "copy link" after its own.
+     */
+    actions?: Command[];
+    /**
+     * The whole text behind this result, for the preview pane (`previewPane`):
+     * the section a docs hit points into, the ticket body, the message. Line
+     * breaks are kept. Without it the pane shows the `excerpt`.
+     */
+    preview?: string;
+    onSelect?: () => void;
+}
+/** Footer hints and the mode chip, spelled out so an app can translate them. */
+export interface PaletteLabels {
+    navigate: string;
+    select: string;
+    close: string;
+    /** Hint for leaving a mode, shown only while inside one. */
+    back: string;
+    searching: string;
+    /** Shown when `search` (or a fetching mode) threw. */
+    searchFailed: string;
+    retry: string;
+    /** The row that unfolds a group cut by `groupLimit`; `{count}` is how many are hidden. */
+    showMore: string;
+    /** Footer hint for Tab while the highlighted row has actions. */
+    actions: string;
+    openInNewTab: string;
+    copyLink: string;
+    /** Toast after "copy link"; empty for none. */
+    linkCopied: string;
+    /**
+     * @deprecated The pane now closes for a row with nothing to show, so this
+     * text is never displayed. Kept so existing `labels` objects still type-check.
+     */
+    noPreview?: string;
+}
+type __VLS_Props = {
+    open?: boolean;
+    commands: Command[];
+    placeholder?: string;
+    emptyText?: string;
+    /** Bind a global ⌘K / Ctrl-K toggle. */
+    hotkey?: boolean;
+    /**
+     * Commands fetched from the typed query — what reaches the things too many
+     * (or too remote) to hand over as a list: people, files, tickets. Called
+     * debounced, never for a query shorter than `minChars`, and only its
+     * newest call counts: an earlier one that lands late is dropped, so a slow
+     * response can't overwrite a fresher list.
+     *
+     * Results join the static commands, so a palette can do both.
+     */
+    search?: (query: string, signal: AbortSignal) => Command[] | Promise<Command[]>;
+    /** Wait after the last keystroke before `search` runs. */
+    debounce?: number;
+    /** Shortest query `search` runs for. */
+    minChars?: number;
+    /**
+     * Ids of recently picked commands, newest first — bind it to storage and
+     * the palette opens on what this person actually uses. It only reorders
+     * commands already in the list; an id that no longer resolves is skipped,
+     * so a stored history never resurrects a command that has gone away.
+     */
+    recent?: string[];
+    /** How many recent commands to surface. */
+    recentLimit?: number;
+    /** Headings the palette adds itself. */
+    recentLabel?: string;
+    resultsLabel?: string;
+    /** Footer hints and the mode chip, spelled out for translation. */
+    labels?: Partial<PaletteLabels>;
+    /** Lines an `excerpt` may wrap to before it is clamped. */
+    excerptLines?: number;
+    /**
+     * Rows a group shows before folding the rest behind a "Show N more" row.
+     * One provider answering with thirty people would otherwise push every
+     * other group off the screen. 0 shows everything.
+     */
+    groupLimit?: number;
+    /**
+     * When the query matches nothing, retry it as if typed in the other
+     * keyboard layout (QWERTY ↔ Cyrillic). Off for an app whose commands are
+     * meant to be typed in one layout only.
+     */
+    layoutFallback?: boolean;
+    /**
+     * A pane beside the list showing the highlighted result in full — its
+     * `preview` text, or the `preview` slot. For palettes that search
+     * content rather than commands: the excerpt says why a row matched, the
+     * pane lets it be read without leaving the page. It opens only for a row
+     * with `preview` or `excerpt` (any row, with the slot): the dialog eases
+     * wider, the pane slides in, and the text arrives paragraph by paragraph.
+     * Hidden below the md breakpoint, where there is no room beside the list.
+     *
+     * The width is an inline style rather than a pair of classes: a base
+     * width plus an `md:` override could be emitted by a consumer's Tailwind
+     * build in an order where the base won, and the pane opened squeezed.
+     */
+    previewPane?: boolean;
+    /**
+     * Frosted glass instead of a solid panel: the page shows through,
+     * blurred, under a lighter scrim (.lp-glass-overlay, .lp-scrim--light).
+     * A look, not a behaviour, so it is the app's call: unset follows
+     * `provideGlass`, and without one it is off.
+     */
+    glass?: boolean;
+};
+type __VLS_Slots = {
+    /** Body of the preview pane for the highlighted command. */
+    preview?: (props: {
+        command: Command;
+    }) => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    select: (command: Command) => any;
+    "update:open": (value: boolean) => any;
+    run: (id: string, command: Command) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((command: Command) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onRun?: ((id: string, command: Command) => any) | undefined;
+}>, {
+    placeholder: string;
+    emptyText: string;
+    minChars: number;
+    glass: boolean;
+    debounce: number;
+    recentLimit: number;
+    hotkey: boolean;
+    recentLabel: string;
+    resultsLabel: string;
+    excerptLines: number;
+    groupLimit: number;
+    layoutFallback: boolean;
+    previewPane: 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/LpCommandPalette.vue.js

@@ -9,7 +9,7 @@ import { useHotkeys } from "../composables/useHotkeys.js";
 import { useModalLayer } from "./modalDepth.js";
 import { parseCommandQuery, rankCommandItems, swapCommandTerms } from "./commandSearch.js";
 import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper-1tPrXgE0.js";
-import '../assets/LpCommandPalette-s_kKuCRf.css';const _hoisted_1 = { class: "flex shrink-0 items-center gap-2.5 border-b border-line px-4" };
+import '../assets/LpCommandPalette-DH7sPcKP.css';const _hoisted_1 = { class: "flex shrink-0 items-center gap-2.5 border-b border-line px-4" };
 const _hoisted_2 = ["title", "onClick"];
 const _hoisted_3 = ["aria-activedescendant", "placeholder", "onKeydown"];
 const _hoisted_4 = {
@@ -783,7 +783,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LpCommandPalette = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-10500f32"]]);
+const LpCommandPalette = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-0175ffca"]]);
 export {
   LpCommandPalette as default
 };

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

@@ -0,0 +1,59 @@
+type __VLS_Props = {
+    open?: boolean;
+    title?: string;
+    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
+     * closes it once the work settles, so a failure can stay on screen.
+     */
+    loading?: boolean;
+    loadingLabel?: string;
+    /** Frosted glass panel, passed to LpModal. Follows `provideGlass` when unset. */
+    glass?: boolean;
+};
+declare var __VLS_16: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    cancel: () => any;
+    "update:open": (value: boolean) => any;
+    confirm: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {
+    glass: boolean;
+    confirmLabel: string;
+    cancelLabel: string;
+    loadingLabel: 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/LpContextMenu.vue.d.ts

@@ -0,0 +1,44 @@
+export interface ContextMenuItemDef {
+    label: string;
+    icon?: string;
+    /** Right-aligned hint, e.g. "⌘C". */
+    shortcut?: string;
+    danger?: boolean;
+    disabled?: boolean;
+    separatorBefore?: boolean;
+    onSelect?: () => void;
+    /** Nested submenu. When present, onSelect is ignored. */
+    children?: ContextMenuItemDef[];
+    /**
+     * Renders as a tick-box rather than a plain item, and the menu stays open on
+     * select. For the lists where the point is to set several at once — which
+     * columns to show, which values to filter by — and closing after each one
+     * would mean reopening the menu for every tick.
+     */
+    checked?: boolean;
+}
+type __VLS_Props = {
+    items: ContextMenuItemDef[];
+    /**
+     * Keep the reka menu mounted even while `items` is momentarily empty. Use when
+     * the items are resolved on the right-click itself (e.g. a list that figures
+     * out which row was clicked): without this the trigger would still be in
+     * native-menu mode on that first click and swallow it.
+     */
+    always?: boolean;
+};
+declare var __VLS_1: {}, __VLS_18: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_18) => 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/LpDatePicker.vue.d.ts

@@ -0,0 +1,33 @@
+type __VLS_Props = {
+    /** Selected date "YYYY-MM-DD" (v-model). */
+    modelValue?: string;
+    placeholder?: string;
+    min?: string;
+    max?: string;
+    isDisabled?: (iso: string) => boolean;
+    clearable?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: "sm" | "md" | "lg";
+    /** Intl format for the displayed date. */
+    format?: Intl.DateTimeFormatOptions;
+    /** Also pick a minute; the model becomes "YYYY-MM-DDTHH:mm". */
+    time?: boolean;
+    /** Time a freshly picked day starts at, "HH:mm". */
+    defaultTime?: string;
+    /** Label of the button that closes the popover in `time` mode. */
+    doneLabel?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    format: Intl.DateTimeFormatOptions;
+    placeholder: string;
+    defaultTime: string;
+    doneLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,47 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    /** Controlled open state. Omit to let the component own it (with `defaultOpen`). */
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Trigger label (or use the #trigger slot for richer content). */
+    label?: string;
+    /** Optional iconify name shown left of the label. */
+    icon?: string;
+    /**
+     * On open, smooth-scroll the block to the top of the nearest scroll
+     * container so its content isn't left below the fold. Fires immediately,
+     * in parallel with the expand.
+     */
+    scrollIntoView?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    /** Controlled open state. Omit to let the component own it (with `defaultOpen`). */
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Trigger label (or use the #trigger slot for richer content). */
+    label?: string;
+    /** Optional iconify name shown left of the label. */
+    icon?: string;
+    /**
+     * On open, smooth-scroll the block to the top of the nearest scroll
+     * container so its content isn't left below the fold. Fires immediately,
+     * in parallel with the expand.
+     */
+    scrollIntoView?: boolean;
+}> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    defaultOpen: boolean;
+    scrollIntoView: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    trigger?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    vertical?: boolean;
+    label?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => 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/LpDrawer.vue.d.ts

@@ -0,0 +1,170 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    open?: boolean;
+    /** Edge the drawer attaches to. `side` is a back-compat alias (left/right). */
+    direction?: "left" | "right" | "top" | "bottom";
+    side?: "left" | "right";
+    title?: string;
+    description?: string;
+    /** Size preset along the drawer's main axis (width for left/right, height for top/bottom). */
+    size?: "sm" | "md" | "lg" | "xl";
+    /** Explicit size override (any CSS length), wins over `size`. */
+    width?: string;
+    /** Drag-to-dismiss + click-outside. Set false to force a controlled close. */
+    dismissible?: boolean;
+    /** Fractions (0–1) or px strings the drawer snaps between, nearest edge first. */
+    snapPoints?: (number | string)[];
+    /** Show the drag handle (auto-on for bottom/top sheets). */
+    handle?: boolean;
+    /** Only the handle initiates a drag — frees inner content to scroll. */
+    handleOnly?: boolean;
+    /** Scale the [vaul-drawer-wrapper] background while open. */
+    scaleBackground?: boolean;
+    /** Drag fraction (0–1) past which a release dismisses. */
+    closeThreshold?: number;
+    /**
+     * Auto-tag interactive descendants (input, textarea, select, button, links,
+     * [contenteditable]) with data-vaul-no-drag so a drag can't start on them —
+     * you can select text / use controls without dragging the drawer. On by
+     * default; the drawer still drags from empty space, the handle and header.
+     */
+    noDragControls?: boolean;
+    /**
+     * Mark the entire body as non-draggable: the drawer then only drags from the
+     * handle/header. Stronger than noDragControls — use for form-heavy drawers.
+     */
+    noDragContent?: boolean;
+    /**
+     * Open by dragging in from the screen edge (Discord-style). A touch that
+     * starts within `edgeSize` of the edge and travels inward drags a preview of
+     * the panel (with its content) under the finger; a release past
+     * `edgeOpenThreshold`, or a quick flick, opens the drawer. Nothing is laid
+     * over the edge, so taps there still reach the page. Left/right drawers only.
+     */
+    edgeOpen?: boolean;
+    /**
+     * Tailwind breakpoint at and above which the edge pull is ignored. Pass the
+     * same breakpoint at which the host switches to the drawer (LpSidebar
+     * does), so a wide touch screen with the rail visible doesn't pull it too.
+     */
+    edgeBreakpoint?: "sm" | "md" | "lg" | "xl";
+    /** Distance (px) from the edge within which a touch can start a pull. */
+    edgeSize?: number;
+    /** Fraction (0–1) of the panel width the pull must reach to open on release. */
+    edgeOpenThreshold?: number;
+    /**
+     * Let the user drag the inner edge to resize the panel (horizontal drawers
+     * only — e.g. a logs panel whose long lines overflow). The new size is kept
+     * for the session. Min/max bound the drag.
+     */
+    resizable?: boolean;
+    /** Min main-axis size while resizing (any CSS length). Default 22rem. */
+    minSize?: string;
+    /** Max main-axis size while resizing (any CSS length). Default 96vw. */
+    maxSize?: string;
+    /**
+     * Frosted glass instead of a solid panel: the page shows through,
+     * blurred, under a lighter scrim (.lp-glass-overlay, .lp-scrim--light).
+     * A look, not a behaviour, so it is the app's call: unset follows
+     * `provideGlass`, and without one it is off.
+     */
+    glass?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    open?: boolean;
+    /** Edge the drawer attaches to. `side` is a back-compat alias (left/right). */
+    direction?: "left" | "right" | "top" | "bottom";
+    side?: "left" | "right";
+    title?: string;
+    description?: string;
+    /** Size preset along the drawer's main axis (width for left/right, height for top/bottom). */
+    size?: "sm" | "md" | "lg" | "xl";
+    /** Explicit size override (any CSS length), wins over `size`. */
+    width?: string;
+    /** Drag-to-dismiss + click-outside. Set false to force a controlled close. */
+    dismissible?: boolean;
+    /** Fractions (0–1) or px strings the drawer snaps between, nearest edge first. */
+    snapPoints?: (number | string)[];
+    /** Show the drag handle (auto-on for bottom/top sheets). */
+    handle?: boolean;
+    /** Only the handle initiates a drag — frees inner content to scroll. */
+    handleOnly?: boolean;
+    /** Scale the [vaul-drawer-wrapper] background while open. */
+    scaleBackground?: boolean;
+    /** Drag fraction (0–1) past which a release dismisses. */
+    closeThreshold?: number;
+    /**
+     * Auto-tag interactive descendants (input, textarea, select, button, links,
+     * [contenteditable]) with data-vaul-no-drag so a drag can't start on them —
+     * you can select text / use controls without dragging the drawer. On by
+     * default; the drawer still drags from empty space, the handle and header.
+     */
+    noDragControls?: boolean;
+    /**
+     * Mark the entire body as non-draggable: the drawer then only drags from the
+     * handle/header. Stronger than noDragControls — use for form-heavy drawers.
+     */
+    noDragContent?: boolean;
+    /**
+     * Open by dragging in from the screen edge (Discord-style). A touch that
+     * starts within `edgeSize` of the edge and travels inward drags a preview of
+     * the panel (with its content) under the finger; a release past
+     * `edgeOpenThreshold`, or a quick flick, opens the drawer. Nothing is laid
+     * over the edge, so taps there still reach the page. Left/right drawers only.
+     */
+    edgeOpen?: boolean;
+    /**
+     * Tailwind breakpoint at and above which the edge pull is ignored. Pass the
+     * same breakpoint at which the host switches to the drawer (LpSidebar
+     * does), so a wide touch screen with the rail visible doesn't pull it too.
+     */
+    edgeBreakpoint?: "sm" | "md" | "lg" | "xl";
+    /** Distance (px) from the edge within which a touch can start a pull. */
+    edgeSize?: number;
+    /** Fraction (0–1) of the panel width the pull must reach to open on release. */
+    edgeOpenThreshold?: number;
+    /**
+     * Let the user drag the inner edge to resize the panel (horizontal drawers
+     * only — e.g. a logs panel whose long lines overflow). The new size is kept
+     * for the session. Min/max bound the drag.
+     */
+    resizable?: boolean;
+    /** Min main-axis size while resizing (any CSS length). Default 22rem. */
+    minSize?: string;
+    /** Max main-axis size while resizing (any CSS length). Default 96vw. */
+    maxSize?: string;
+    /**
+     * Frosted glass instead of a solid panel: the page shows through,
+     * blurred, under a lighter scrim (.lp-glass-overlay, .lp-scrim--light).
+     * A look, not a behaviour, so it is the app's call: unset follows
+     * `provideGlass`, and without one it is off.
+     */
+    glass?: boolean;
+}> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg" | "xl";
+    side: "left" | "right";
+    glass: boolean;
+    dismissible: boolean;
+    noDragControls: boolean;
+    edgeSize: number;
+    edgeOpenThreshold: number;
+    minSize: string;
+    maxSize: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+} & {
+    title?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+} & {
+    footer?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,23 @@
+export interface MenuItem {
+    label: string;
+    icon?: string;
+    danger?: boolean;
+    separatorBefore?: boolean;
+    onSelect?: () => void;
+}
+type __VLS_Props = {
+    items: MenuItem[];
+};
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    trigger?: (props: typeof __VLS_14) => 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;
+    };
+};