@leavepulse/ui 0.41.0 → 0.43.0

package/dist/components/dropdown.d.ts

@@ -1,29 +0,0 @@
-/** 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/fileTree.d.ts

@@ -1,79 +0,0 @@
-import { ContextMenuItemDef } from './LpContextMenu.vue';
-export interface FileNode {
-    /** Stable identity — use the full path when you have one. */
-    id: string;
-    name: string;
-    /** Directories can hold `children`; files are leaves. */
-    kind: "file" | "dir";
-    /** Size in bytes. Shown right-aligned when `showSize` is on. */
-    size?: number;
-    /** Last-modified time — Date, epoch ms, or a pre-formatted string. */
-    modified?: Date | number | string;
-    /** Extra right-aligned text (badge-ish), e.g. "read-only". */
-    meta?: string;
-    /**
-     * Omit on a directory to mark its children as not-yet-loaded: the row shows a
-     * chevron and emits `expand` on first open so the caller can fetch them.
-     * An empty array means "loaded, and genuinely empty".
-     */
-    children?: FileNode[];
-    /** Override the type-derived icon. */
-    icon?: string;
-    /** Dimmed row (e.g. a git-ignored or unreadable entry). Still expandable. */
-    disabled?: boolean;
-    /** Right-click menu for this entry. */
-    menu?: ContextMenuItemDef[];
-}
-/** Icon for a node: explicit override → dir state → name → extension → generic. */
-export declare function fileIcon(node: FileNode, expanded?: boolean): string;
-/** Directories first, then case-insensitive by name — the file-manager order. */
-export declare function sortNodes(nodes: FileNode[]): FileNode[];
-/** Human-readable byte size — binary units, matching what file managers show. */
-export declare function formatSize(bytes: number): string;
-/** Short local date-time for the modified column; passes strings through. */
-export declare function formatModified(value: Date | number | string): string;
-/**
- * Total size of a subtree: a directory's own `size` when the caller computed one
- * (the common case for a server-side listing), otherwise the sum of its loaded
- * descendants. Returns undefined when nothing along the way carries a size.
- */
-export declare function subtreeSize(node: FileNode): number | undefined;
-/** Every id in a subtree including the root — the unit a checkbox toggles. */
-export declare function subtreeIds(node: FileNode): string[];
-export type CheckState = "checked" | "unchecked" | "indeterminate";
-/**
- * A node's checkbox state derived from the checked-id set.
- *
- * A directory reflects its loaded children: all checked → checked, some →
- * indeterminate. A directory whose children aren't loaded yet (or which has
- * none) falls back to its own membership, so an unexpanded folder can still be
- * ticked as a whole — which is exactly what a backup picker needs.
- */
-export declare function checkStateOf(node: FileNode, checked: ReadonlySet<string>): CheckState;
-/**
- * How much of a directory's subtree is ticked, counting FILES only (folders are
- * containers, not payload). Lets a row say "3 / 12" so a half-filled checkbox
- * isn't the only clue that a folder is partially selected.
- */
-export declare function checkedCount(node: FileNode, checked: ReadonlySet<string>): {
-    checked: number;
-    total: number;
-};
-/** Everything a row needs to render, precomputed once per node. */
-export interface NodeStats {
-    state: CheckState;
-    /** Ticked files in the subtree, and how many there are in total. */
-    checked: number;
-    total: number;
-    /** Rolled-up subtree size, or undefined when nothing carries one. */
-    size?: number;
-}
-/**
- * Derive every row's state in ONE post-order pass over the tree, keyed by node
- * id. Calling `checkStateOf`/`subtreeSize`/`checkedCount` per row instead makes
- * each row walk its own subtree, which is quadratic on a deep tree and shows up
- * as a stutter the moment a directory holds a few thousand files.
- */
-export declare function computeStats(nodes: FileNode[], checked: ReadonlySet<string>): Map<string, NodeStats>;
-/** Ids of every ancestor directory of `id`, so callers can reveal a deep node. */
-export declare function ancestorIds(nodes: FileNode[], id: string): string[];

package/dist/components/lightbox.d.ts

@@ -1,24 +0,0 @@
-export interface LightboxItem {
-    /** Full-size source. */
-    src: string;
-    /** Smaller source for the filmstrip; falls back to `src`. */
-    thumb?: string;
-    /** Caption under the image, and the img alt text. */
-    title?: string;
-    /** Secondary line under the title (size, date, resolution…). */
-    description?: string;
-    /** Filename used when downloading; derived from `src` when absent. */
-    filename?: string;
-    /**
-     * Hide this image behind a cover until someone asks for it — a spoiler, a
-     * screenshot of something not everyone in the channel has reached yet, a
-     * picture that should not appear in a scroll past.
-     *
-     * A property of the ITEM rather than of the grid showing it: which images are
-     * spoilers is a fact about the images, and the usual set is a mixed one, with
-     * a marked picture sitting beside plain ones.
-     */
-    spoiler?: boolean;
-}
-/** Last path segment of a URL, or a fallback — used to name a download. */
-export declare function fileNameOf(item: LightboxItem, fallback?: string): string;

package/dist/components/modalDepth.d.ts

@@ -1,15 +0,0 @@
-import { ComputedRef } from 'vue';
-/**
- * Register a dialog as open and get back the z-indexes it should paint with.
- * The result is reactive: opening another dialog moves this one down a step.
- */
-export declare function useModalLayer(): {
-    claim: () => void;
-    release: () => void;
-    layer: ComputedRef<{
-        scrim: string;
-        panel: string;
-    }>;
-};
-/** True while any dialog or drawer holds a level — e.g. to keep a gesture from opening another one over it. */
-export declare function anyModalOpen(): boolean;

package/dist/components/sidebar.d.ts

@@ -1,42 +0,0 @@
-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[];
-    /**
-     * Extra terms the sidebar's filter should match, beyond the label. For the
-     * item people look for under a name it does not carry — "Billing" found by
-     * "invoice", a page found by the feature it used to be called.
-     */
-    keywords?: string[];
-}
-export interface SidebarSection {
-    /** Optional heading above the group. */
-    title?: string;
-    items: SidebarItem[];
-    /**
-     * The heading folds the group away when clicked. Needs a `title` — there is
-     * nothing to click otherwise.
-     *
-     * A long nav is read by scanning headings, not items: past a certain length
-     * every item is equally far from the eye, and folding the groups that are
-     * not today's work restores that. Which groups start folded is the app's
-     * call (see `collapsedIds`), not this component's.
-     */
-    collapsible?: boolean;
-    /**
-     * Stable key for remembering this group's folded state. Defaults to `title`;
-     * set it when the title is translated, so the memory survives a language
-     * change.
-     */
-    key?: string;
-    /** Icon for the heading — shown when the group is collapsible. */
-    icon?: string;
-}

package/dist/composables/easing.d.ts

@@ -1,46 +0,0 @@
-/**
- * Does the OS ask for less motion?
- *
- * Written out in eight places before this, in two different shapes — some
- * guarded against SSR, some not, which is a crash in a Nuxt app rather than a
- * style difference. Anything that animates asks here.
- *
- * A plain function, not a reactive composable: it is read at the moment an
- * animation starts, and a component that also needs to RE-RENDER when the
- * setting changes mid-session should use motion-v's `useReducedMotion`.
- */
-export declare const prefersReducedMotion: () => boolean;
-/**
- * A motion token's value, for an API that cannot take a `var()`.
- *
- * The Web Animations API and SVG's SMIL both want a literal easing string, so
- * three call sites had `cubic-bezier(0.2, 0, 0, 1)` typed out — the value of
- * `--ease-emphasized`, copied. A theme that retuned the token moved everything
- * except those, and nothing said they were meant to match.
- *
- * Reading the custom property keeps them themeable. The fallback covers SSR and
- * the frame before tokens are applied.
- */
-export declare const easingToken: (name: "ease-emphasized" | "ease-travel" | "ease-settle", fallback?: string) => string;
-/**
- * Comes to rest — `--ease-settle`'s shape without the overshoot.
- *
- * Gently decelerating: the value keeps moving visibly for most of the travel
- * instead of arriving early and then creeping. Use it wherever a figure counts
- * up to something, so the digits keep turning across the whole duration.
- */
-export declare const easeOut: (t: number) => number;
-/**
- * Travels a distance the eye follows — the JS form of `--ease-travel`.
- *
- * Nearly linear, and deliberately so: an ease-out spends about half its
- * duration covering the last tenth of the path, so a stroke or sweep animated
- * with one flashes past and then visibly creeps. Use this wherever the journey
- * is the content — a line drawing itself, a wipe crossing a plot, a circle
- * sweeping open.
- *
- * The ease is applied only near the ends, and the finish is NOT flattened onto
- * the target: the motion is still moving when it lands, which is what keeps
- * the tail short.
- */
-export declare const easeTravel: (t: number) => number;

package/dist/composables/useAsyncTask.d.ts

@@ -1,18 +0,0 @@
-/**
- * One debounced, abortable request at a time — the shape every "fetch on input"
- * control in the kit needs: the command palette's `search`, the table's `load`.
- *
- * Two races are lost silently without it: a stale response overwriting a
- * fresher one, and a response landing after the control moved on. The token
- * guards both — the abort signal only asks the consumer to stop, it cannot
- * promise they did.
- */
-export declare function useAsyncTask<T>(): {
-    pending: import('vue').Ref<boolean, boolean>;
-    run: (task: (signal: AbortSignal) => T | Promise<T>, options: {
-        delay?: number;
-        apply: (value: T) => void;
-        fail?: (error: unknown) => void;
-    }) => void;
-    cancel: () => void;
-};

package/dist/composables/useClipboard.d.ts

@@ -1,46 +0,0 @@
-export interface CopyOptions {
-    /**
-     * Toast to raise on success. `false` (the default) stays silent, for callers
-     * whose button already shows the tick and would otherwise say it twice.
-     */
-    toast?: string | false;
-    /**
-     * Toast to raise when the copy fails. Defaults to silence for the same
-     * reason the kit's other best-effort paths are silent: a copy that didn't
-     * happen is usually obvious, and a scary red box over a blocked clipboard
-     * helps nobody. Pass a string where losing the copy actually costs something.
-     */
-    errorToast?: string | false;
-}
-export interface UseClipboard {
-    /**
-     * True for a moment after a successful copy. Bind it to swap a copy icon for
-     * a tick:
-     *
-     * ```vue
-     * <LpIcon :name="copied ? 'lucide:check' : 'lucide:copy'" />
-     * ```
-     */
-    copied: import('vue').Ref<boolean>;
-    /**
-     * Writes `text` to the clipboard. Resolves true on success, false when the
-     * clipboard was unavailable or refused — it never rejects, so `await copy(x)`
-     * is safe to call bare from an event handler.
-     */
-    copy: (text: string, options?: CopyOptions) => Promise<boolean>;
-}
-/**
- * Clipboard writes with optional toast feedback.
- *
- * ```ts
- * const { copy, copied } = useClipboard()
- * copy(hex)                                  // silent; bind `copied` to a tick
- * copy(hex, { toast: "Copied #3b82f6" })     // says so
- * ```
- *
- * Defaults are per-call rather than per-instance: one component often copies
- * several things for different reasons — a menu item that should announce
- * itself, a button that shows its own tick — and hoisting the choice to the
- * composable would force those to agree.
- */
-export declare function useClipboard(): UseClipboard;

package/dist/composables/useFormDraft.d.ts

@@ -1,67 +0,0 @@
-import { MaybeRefOrGetter, Ref } from 'vue';
-export interface UseFormDraftOptions<T> {
-    /**
-     * Where this draft lives. Include whatever identifies the subject — a draft
-     * for device A must not surface while editing device B.
-     */
-    key: MaybeRefOrGetter<string>;
-    /** The form's current value. Watched deeply; every change rewrites the draft. */
-    value: MaybeRefOrGetter<T>;
-    /**
-     * Whether there is anything worth keeping. Return false while the form still
-     * matches what was loaded, so an untouched form leaves nothing behind and no
-     * later visit is offered its own starting state back as a "draft".
-     */
-    dirty?: MaybeRefOrGetter<boolean>;
-    /**
-     * How long a draft stays offerable, in milliseconds. Older ones are dropped
-     * on read: a fortnight-old draft of a record that has been edited twice since
-     * is not a rescue, it is a way to overwrite current facts with stale ones.
-     * Defaults to a week. `0` keeps them indefinitely.
-     */
-    maxAgeMs?: number;
-    /** Skip the write without tearing the composable out of the component. */
-    disabled?: MaybeRefOrGetter<boolean>;
-}
-export interface UseFormDraft<T> {
-    /** A draft was found for this key, and has not been restored or discarded. */
-    hasDraft: Ref<boolean>;
-    /** When that draft was written, ISO-8601, or `null` when there is none. */
-    savedAt: Ref<string | null>;
-    /**
-     * The stored value, or `null`. Reading does not apply it — the caller decides
-     * what to do with each field, because only it knows the form's shape.
-     */
-    read: () => T | null;
-    /** Forget the draft. Call after applying it, and after a successful save. */
-    discard: () => void;
-    /** Write now, ignoring `dirty`. For "save and come back to this later". */
-    save: () => void;
-}
-/**
- * Keeps an unsaved form in browser storage, so losing the page does not lose
- * what was typed into it.
- *
- * ```ts
- * const draft = useFormDraft({
- *   key: () => `lp.draft.device-power:${deviceId.value}`,
- *   value: () => interfaces.value,
- *   dirty: () => hasUnsavedChanges.value,
- * })
- * ```
- * ```vue
- * <LpAlert v-if="draft.hasDraft.value" variant="info">
- *   {{ t("draft.found", { when: draft.savedAt.value }) }}
- *   <LpButton @click="applyDraft">Restore</LpButton>
- *   <LpButton variant="ghost" @click="draft.discard()">Discard</LpButton>
- * </LpAlert>
- * ```
- *
- * `hasDraft` answers for the key as it is now, so a form that switches subject
- * re-reads rather than carrying the previous subject's answer.
- *
- * Call `discard()` once the record is saved. A draft that outlives the save it
- * describes is offered back on the next visit as though it were newer than the
- * record, which is how a form helpfully undoes somebody's work.
- */
-export declare function useFormDraft<T>(options: UseFormDraftOptions<T>): UseFormDraft<T>;

package/dist/composables/useGlass.d.ts

@@ -1,9 +0,0 @@
-import { ComputedRef, MaybeRefOrGetter } from 'vue';
-/** Make `glass` the default for every overlay below the calling component. */
-export declare function provideGlass(enabled?: MaybeRefOrGetter<boolean>): void;
-/**
- * The glass flag an overlay renders with: its own prop when set, otherwise the
- * nearest `provideGlass`, otherwise off. The prop must default to `undefined`,
- * not `false`, or an unset prop could not be told apart from an explicit off.
- */
-export declare function useGlass(own: () => boolean | undefined): ComputedRef<boolean>;

package/dist/composables/useHotkeys.d.ts

@@ -1,99 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-export interface HotkeyBinding {
-    /** Layout-produced key, compared case-insensitively ("l", "f2", "escape"). */
-    key: string;
-    /**
-     * Physical key position ("KeyL", "F2", "Digit1"). Matches on its own, which
-     * is what makes non-Latin layouts work.
-     */
-    code?: string;
-    /** Ctrl on Windows/Linux, ⌘ on macOS — the two are treated as one. */
-    ctrl?: boolean;
-    shift?: boolean;
-    alt?: boolean;
-    /**
-     * Runs even while a text field has focus. Only for shortcuts that mean
-     * something there — Escape, and the palette the user reaches from anywhere.
-     */
-    allowInInput?: boolean;
-    /**
-     * How the key reference lists this binding while it is mounted. Bindings
-     * without it still work, they just stay out of `activeShortcuts`.
-     */
-    help?: HotkeyHelp;
-    /**
-     * Returning `false` declines the key: the event keeps its default and the
-     * search moves on. This is what lets a binding defer to a layer that owns the
-     * key better than it does — Escape belongs to whichever overlay is on top,
-     * and swallowing it here would close all of them. The event is passed for
-     * the checks only it can answer: where the focus is, whether an inner
-     * control already took the key.
-     */
-    handler: (event: KeyboardEvent) => void | boolean;
-}
-export interface HotkeyHelp {
-    /** Section of the reference the entry goes under. */
-    group: string;
-    label: string;
-    /**
-     * Written the way it reads, "+"-separated. Defaults to one built from the
-     * binding; set it where the binding is not the whole story, such as the
-     * second key of a chord ("G+D") or a key that needs Shift to type ("?").
-     */
-    combo?: string;
-}
-export interface ShortcutEntry {
-    /** Rendered one <kbd> per "+"-separated key, so write it the way it reads. */
-    combo: string;
-    label: string;
-}
-export interface ShortcutGroup {
-    title: string;
-    entries: ShortcutEntry[];
-}
-/**
- * Whether this machine prints ⌘ where the rest print Ctrl. Read once: the
- * keyboard does not change under a running window, and the check is only ever
- * used to pick a label.
- */
-export declare const isAppleKeyboard: boolean;
-/**
- * The symbol to print for a modifier on this platform. Bindings treat Ctrl and
- * Meta as one modifier, so only the label may differ — never the binding.
- */
-export declare function appleModifierLabel(key: string): string;
-/**
- * Bind a list of hotkeys for as long as the calling component is mounted.
- *
- * The list is read on every keystroke rather than captured once, so bindings
- * may come and go with the state that owns them — a getter is the point, not a
- * formality.
- */
-export interface UseHotkeysOptions {
-    /**
-     * Only act while the focus is inside this element.
-     *
-     * The default is the whole window, which is right for a command palette and
-     * wrong for a control: two of the same component on one page would both
-     * answer the same key, and a control beside a form would answer keys aimed
-     * at the form. Scoping it here rather than in each component because every
-     * one of them was about to write the same `document.activeElement` check and
-     * decline by hand.
-     *
-     * Undefined or null means the window, so the palette case stays the default.
-     */
-    scope?: MaybeRefOrGetter<HTMLElement | null | undefined>;
-}
-export declare function useHotkeys(bindings: MaybeRefOrGetter<HotkeyBinding[]>, options?: UseHotkeysOptions): void;
-/**
- * The shortcuts that work right now, grouped for `LpShortcutsDialog`: every
- * binding with `help` from every mounted `useHotkeys`. A screen that binds its
- * own keys adds its section while it is open, so the reference never lists a
- * key that does nothing here or misses one that does.
- */
-export declare const activeShortcuts: import('vue').ComputedRef<ShortcutGroup[]>;
-/**
- * Groups merged by title, entries kept once per combo: what a reference shows
- * when it lists both its own entries and the live ones.
- */
-export declare function mergeShortcutGroups(...lists: ShortcutGroup[][]): ShortcutGroup[];

package/dist/composables/useInputFilter.d.ts

@@ -1,14 +0,0 @@
-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/useMergedClass.d.ts

@@ -1,42 +0,0 @@
-import { ComputedRef, MaybeRefOrGetter } from 'vue';
-/**
- * Merges the component's own classes with the `class` attribute the consumer
- * passed, resolving Tailwind conflicts in the consumer's favour.
- *
- * ```ts
- * const rootClass = useMergedClass(() => shell({ size: props.size }))
- * ```
- * ```vue
- * <div :class="rootClass">
- * ```
- *
- * Pair it with `inheritAttrs: false` (and bind the rest of `$attrs` yourself)
- * so the raw `class` does not land on the element a second time, unmerged.
- */
-export declare function useMergedClass(own: MaybeRefOrGetter<string | undefined>): ComputedRef<string>;
-/**
- * `useMergedClass` plus the rest of `$attrs`, for the common `inheritAttrs:
- * false` shape: bind `class` and `attrs` and the consumer's `class` lands once,
- * merged, while ids, handlers and aria-* still reach the element.
- *
- * ```ts
- * const { class: rootClass, attrs: rest } = useMergedAttrs(() => card({ padded }))
- * ```
- * ```vue
- * <div :class="rootClass" v-bind="rest">
- * ```
- *
- * Binding the raw `$attrs` alongside a merged class is the bug this avoids:
- * Vue appends that second `class` to the merged one, and stylesheet order —
- * not the caller — decides which wins.
- */
-export declare function useMergedAttrs(own: MaybeRefOrGetter<string | undefined>): {
-    class: ComputedRef<string>;
-    attrs: ComputedRef<Record<string, unknown>>;
-};
-/**
- * The same merge as a plain function, for the places that already have both
- * strings in hand and do not need the attrs lookup — a render helper, or a
- * component merging a class onto a child rather than its own root.
- */
-export declare function mergeClass(...classes: (string | undefined | null | false)[]): string;

package/dist/composables/usePillTransition.d.ts

@@ -1,21 +0,0 @@
-import { ComputedRef } from 'vue';
-export type PillTransition = {
-    duration: number;
-} | {
-    type: "spring";
-    stiffness: number;
-    damping: number;
-};
-export type PillFeel = "pill" | "float";
-export declare function usePillTransition(feel?: PillFeel): ComputedRef<PillTransition>;
-export interface SpringState {
-    /** Current position; seed it with the start value. */
-    value: number;
-    /** Current velocity; seed with 0. */
-    velocity: number;
-}
-export declare function springStep(state: SpringState, target: number, feel?: PillFeel, 
-/** Frame time in seconds; clamped so a backgrounded tab can't explode it. */
-dt?: number): SpringState;
-/** True once a spring is close enough to its target to stop animating. */
-export declare const springSettled: (state: SpringState, target: number) => boolean;

package/dist/composables/useReveal.d.ts

@@ -1,26 +0,0 @@
-import { MaybeRefOrGetter, Ref } from 'vue';
-export interface UseRevealOptions {
-    /**
-     * Skip the wait and reveal at once. For a caller that has switched its
-     * entrance off — there is nothing to gate, and holding content back for an
-     * observer that no longer guards anything only delays the first paint.
-     */
-    immediate?: MaybeRefOrGetter<boolean | undefined>;
-    /**
-     * Fraction of the element that must be on screen. A sliver of a tall chart
-     * scrolling into view is not yet an arrival; a quarter of it is.
-     */
-    threshold?: number;
-    /**
-     * Grow the viewport for the test, so an element just past the fold starts
-     * drawing as it is scrolled toward rather than after it lands.
-     */
-    rootMargin?: string;
-}
-export interface UseReveal {
-    /** Attach to the element whose appearance starts the animation. */
-    el: Ref<Element | null>;
-    /** False until that element has been seen; true forever after. */
-    revealed: Ref<boolean>;
-}
-export declare function useReveal(options?: UseRevealOptions): UseReveal;

package/dist/composables/useRovingFocus.d.ts

@@ -1,49 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-export interface RovingItem {
-    /** Stable identity of the row. */
-    id: string;
-    /**
-     * What typeahead matches against. Omit to opt this row out of typeahead —
-     * a separator, say.
-     */
-    label?: string;
-    disabled?: boolean;
-}
-export interface UseRovingFocusOptions {
-    /**
-     * Which axis the arrows follow. `vertical` (default) uses ↑↓, `horizontal`
-     * uses ←→, `both` accepts either — for a grid whose wrapping the caller
-     * cannot describe here.
-     */
-    orientation?: "vertical" | "horizontal" | "both";
-    /** Wrap around at the ends instead of stopping. Default true. */
-    loop?: boolean;
-    /** Jump to an item by typing its first letters. Default true. */
-    typeahead?: boolean;
-    /** Called when the user activates the current item (Enter or Space). */
-    onActivate?: (id: string) => void;
-    /**
-     * Called when focus should leave the list without activating anything —
-     * Escape. Lets a dialog close, or a filter field take focus back.
-     */
-    onEscape?: () => void;
-}
-export declare function useRovingFocus(items: MaybeRefOrGetter<RovingItem[]>, options?: UseRovingFocusOptions): {
-    activeId: import('vue').Ref<string | undefined, string | undefined>;
-    focus: (id: string | undefined) => void;
-    move: (delta: number) => void;
-    first: () => void;
-    last: () => void;
-    onKeydown: (event: KeyboardEvent) => void;
-    setContainer: (el: HTMLElement | null) => void;
-    containerProps: import('vue').ComputedRef<{
-        ref: (el: unknown) => void;
-        onKeydown: (event: KeyboardEvent) => void;
-    }>;
-    itemProps: (id: string) => {
-        tabindex: number;
-        "data-active": string | undefined;
-        "data-roving-id": string;
-        onFocus: () => void;
-    };
-};