@leavepulse/ui 0.43.2 → 0.43.3

package/dist/composables/useAsyncTask.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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

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

@@ -0,0 +1,67 @@
+import { type MaybeRefOrGetter, type 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

@@ -0,0 +1,9 @@
+import { type ComputedRef, type 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

@@ -0,0 +1,101 @@
+import { type 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 {
+    enabled?: MaybeRefOrGetter<boolean>;
+    priority?: MaybeRefOrGetter<number>;
+    /**
+     * 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

@@ -0,0 +1,14 @@
+import { type 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

@@ -0,0 +1,42 @@
+import { type ComputedRef, type 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

@@ -0,0 +1,21 @@
+import { type 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

@@ -0,0 +1,26 @@
+import { type MaybeRefOrGetter, type 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

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

package/dist/composables/useSettled.d.ts

@@ -0,0 +1,26 @@
+import { type MaybeRefOrGetter } from "vue";
+export interface UseSettledOptions {
+    /** Override the wait. Defaults to the kit's overlay animation duration. */
+    delay?: MaybeRefOrGetter<number>;
+}
+/**
+ * Returns a ref that flips true once `open` has been truthy for the length of
+ * the overlay's opening animation. Gate expensive content on it:
+ *
+ * ```ts
+ * const settled = useSettled(() => isOpen.value)
+ * ```
+ * ```vue
+ * <RowList v-if="settled" :rows="rows" />
+ * <RowSkeletons v-else />
+ * ```
+ *
+ * Anything truthy counts as open, so an id can be passed instead of a boolean.
+ * That is the useful form when the same panel is reused for different subjects:
+ * the wait restarts when the id changes, because the panel is mounting a whole
+ * new body without ever having closed.
+ *
+ * With reduced motion there is no animation to protect, so it resolves on the
+ * next tick rather than making the user wait for a delay that buys nothing.
+ */
+export declare function useSettled(open: MaybeRefOrGetter<unknown>, options?: UseSettledOptions): import("vue").Ref<boolean, boolean>;

package/dist/composables/useShift.d.ts

@@ -0,0 +1,35 @@
+import { type MaybeRefOrGetter, type Ref } from "vue";
+export type ShiftAxis = "height" | "width" | "both";
+export interface UseShiftOptions {
+    /** Which dimension is content-derived. Default `"height"`. */
+    axis?: MaybeRefOrGetter<ShiftAxis | undefined>;
+    /** Tween length. Defaults to the kit's `--duration-fast` (160ms). */
+    duration?: MaybeRefOrGetter<number | undefined>;
+    /**
+     * Gate: while falsy the element is left entirely alone — no observers, no
+     * pinning. Use it for a box that only exists while something is open, so a
+     * remounted element starts measuring from scratch rather than easing in from
+     * a size it held in a previous life. Default: always active.
+     */
+    enabled?: MaybeRefOrGetter<unknown>;
+}
+export interface UseShift {
+    /** Attach to the element whose content-derived size should ease. */
+    el: Ref<HTMLElement | null>;
+    /**
+     * True while a tween owns the size. Bind the transition utilities off this,
+     * so the element is only transition-enabled once it has a size to ease FROM
+     * (otherwise the very first pin animates in from zero).
+     */
+    tweening: Ref<boolean>;
+    /**
+     * True while the element is still catching up to its new size. During the
+     * tween the box is briefly smaller than the content it already holds, so any
+     * scroll region inside it would raise a bar for an overflow that resolves
+     * itself as the tween lands — hide the bar (not the scrolling) on this.
+     */
+    resizing: Ref<boolean>;
+    /** Re-measure and ease to the current natural size. Rarely needed by hand. */
+    retune: () => void;
+}
+export declare function useShift(options?: UseShiftOptions): UseShift;

package/dist/composables/useTilt.d.ts

@@ -0,0 +1,23 @@
+import { type ComputedRef, type CSSProperties, type Ref } from "vue";
+export interface UseTiltOptions {
+    /** Max rotation toward the pointer, in degrees (per axis). Default 10. */
+    max?: number;
+    /** Upward lift on hover, in px. Default 8. */
+    lift?: number;
+    /** Scale on hover. Default 1.03. */
+    scale?: number;
+    /** Glare highlight following the pointer. Default false. */
+    glare?: boolean;
+}
+export interface UseTilt {
+    /** Bind to the tilting element's style. */
+    style: ComputedRef<CSSProperties>;
+    /** Radial-gradient background for an optional glare overlay (0 when idle). */
+    glareStyle: ComputedRef<CSSProperties>;
+    onPointerMove: (e: PointerEvent) => void;
+    onPointerEnter: () => void;
+    onPointerLeave: () => void;
+    /** True while the pointer is over the element (drives lift/scale). */
+    active: Ref<boolean>;
+}
+export declare function useTilt(options?: UseTiltOptions): UseTilt;

package/dist/composables/useToast.d.ts

@@ -0,0 +1,41 @@
+export type ToastVariant = "info" | "success" | "warning" | "error";
+export interface ToastAction {
+    label: string;
+    /** Optional leading icon (any name LpIcon accepts, e.g. "lucide:copy"). */
+    icon?: 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 {};

package/dist/composables/useZoomPan.d.ts

@@ -0,0 +1,58 @@
+import { type ComputedRef, type CSSProperties, type Ref } from "vue";
+export interface UseZoomPanOptions {
+    /** Smallest allowed scale. Default 1 (fit — never shrink past the viewport). */
+    min?: number;
+    /** Largest allowed scale. Default 8. */
+    max?: number;
+    /** Multiplier per wheel notch. Default 1.15. */
+    step?: number;
+    /** Scale that a double-click/tap toggles to, from `min`. Default 2. */
+    zoomedScale?: number;
+}
+export interface UseZoomPan {
+    scale: Ref<number>;
+    /**
+     * Pan offset in CONTENT pixels — what `style` puts inside `translate()`,
+     * before the scale magnifies it. Exposed because anything that has to know
+     * *which part* is visible needs the number, not the CSS string: an exporter
+     * writing the cropped region, a minimap drawing the viewport rectangle, a
+     * caller restoring a saved position. Parsing it back out of `transform` is
+     * the alternative, and that breaks the moment this composable changes how it
+     * composes the transform.
+     */
+    offset: ComputedRef<{
+        x: number;
+        y: number;
+    }>;
+    /**
+     * Put the view somewhere — restoring a saved position, or carrying one
+     * through a change that re-frames the content. Clamped like any other pan,
+     * so a caller cannot place the content off the viewport. Omitting `scale`
+     * keeps the current one.
+     */
+    setView: (view: {
+        x: number;
+        y: number;
+        scale?: number;
+    }) => void;
+    /** True once zoomed past the minimum — the point at which panning matters. */
+    zoomed: ComputedRef<boolean>;
+    /** True while a drag is in flight, so the caller can swap the cursor. */
+    panning: Ref<boolean>;
+    style: ComputedRef<CSSProperties>;
+    onWheel: (e: WheelEvent) => void;
+    onPointerDown: (e: PointerEvent) => void;
+    onPointerMove: (e: PointerEvent) => void;
+    onPointerUp: (e: PointerEvent) => void;
+    /** Zoom about the viewport centre (buttons, keyboard). */
+    zoomBy: (factor: number) => void;
+    /** Toggle between fit and `zoomedScale`, optionally about a point. */
+    toggleZoom: (origin?: {
+        x: number;
+        y: number;
+    }) => void;
+    reset: () => void;
+    /** Call with the viewport element so pointer coords can be made relative. */
+    setViewport: (el: HTMLElement | null) => void;
+}
+export declare function useZoomPan(options?: UseZoomPanOptions): UseZoomPan;

package/dist/icons.d.ts

@@ -0,0 +1 @@
+export {};