@synopackageland/ui 0.20.2 → 0.20.4

package/dist/components/primitives/select/internal/types.d.ts

@@ -41,4 +41,6 @@ export type SelectFieldProps = {
     openLabel?: string;
     clearLabel?: string;
     removeTagLabel?: (label: string) => string;
+    /** `none` drops the list's open and close motion (a grid editor); inherits `provideOverlayMotion`. */
+    motion?: 'auto' | 'none';
 };

package/dist/components/primitives/skeleton/SectionSkeleton.vue.d.ts

@@ -1,14 +1,35 @@
 type __VLS_Props = {
-    variant?: 'lines' | 'figures' | 'rows';
+    variant?: 'lines' | 'figures' | 'rows' | 'grid' | 'cards' | 'fields';
     /** The number of lines (`lines`). */
     lines?: number;
-    /** The number of figures or rows (`figures`, `rows`). */
+    /** The number of figures, rows, cards or fields. */
     count?: number;
+    /** A row's height (`rows`, `grid`); a grid defaults to `--ui-grid-row-height`. */
+    rowHeight?: string;
+    /** `grid`: the number of equal columns, or each column's CSS width (`auto` takes the rest). */
+    columns?: number | readonly string[];
+    /** `grid`: false leaves out the header row. */
+    header?: boolean;
+    /** `cards`: a card's height, as the real card computes it. */
+    cardHeight?: string;
+    /** `cards`: the CardGrid's `minItemWidth`, `gap` and `fit`. */
+    cardMinWidth?: string;
+    gap?: string;
+    fit?: 'stretch' | 'fill';
+    /** Milliseconds before the shapes show; the reserved box shows at once. */
+    delay?: number;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    variant: "lines" | "figures" | "rows";
-    lines: number;
+    header: boolean;
+    variant: "lines" | "figures" | "rows" | "grid" | "cards" | "fields";
+    delay: number;
     count: number;
+    gap: string;
+    fit: "stretch" | "fill";
+    lines: number;
+    columns: number | readonly string[];
+    cardHeight: string;
+    cardMinWidth: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/primitives/skeleton/Skeleton.vue.d.ts

@@ -2,11 +2,14 @@ type __VLS_Props = {
     width?: string;
     height?: string;
     radius?: string;
+    /** False for a still shape, as a grid placeholder is. */
+    pulse?: boolean;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     height: string;
     width: string;
     radius: string;
+    pulse: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/primitives/tag/Tag.vue.d.ts

@@ -37,11 +37,11 @@ type __VLS_Slots = {} & {
 declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
     measure: typeof measure;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    remove: () => any;
     click: (event: MouseEvent | KeyboardEvent) => any;
+    remove: () => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onRemove?: (() => any) | undefined;
     onClick?: ((event: MouseEvent | KeyboardEvent) => any) | undefined;
+    onRemove?: (() => any) | undefined;
 }>, {
     label: string;
     disabled: boolean;

package/dist/components/primitives/toast/ToastProvider.vue.d.ts

@@ -4,7 +4,6 @@ type __VLS_Props = {
     announcementLabel?: string;
     viewportLabel?: string;
     closeLabel?: string;
-    duration?: number;
     swipeDirection?: 'right' | 'left' | 'up' | 'down';
 };
 declare var __VLS_8: {};
@@ -12,7 +11,6 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, ToastController, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    duration: number;
     swipeDirection: "right" | "left" | "up" | "down";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/primitives/toast/toast.d.ts

@@ -1,10 +1,22 @@
 import { InjectionKey } from 'vue';
-export type ToastTone = 'info' | 'success' | 'warning' | 'danger';
+import { FeedbackTone } from '../../../feedback/timing';
+export type ToastTone = FeedbackTone;
 export type ToastOptions = {
     title: string;
     description?: string;
     tone?: ToastTone;
+    /**
+     * Work in progress ("Deleting"): a spinner, no timer, and nothing shown
+     * unless it is still pending after 300 ms. Turn it into the result with
+     * `update` on the same id.
+     */
+    pending?: boolean;
+    /**
+     * Milliseconds it stays. By default success 3 s, info and warning 5 s, at
+     * least 5 s with an action, and danger until closed.
+     */
     duration?: number;
+    /** One action (Undo, Retry). A click runs `onAction` and closes the toast, unless `onAction` updated it. */
     actionLabel?: string;
     onAction?: () => void;
 };
@@ -14,12 +26,20 @@ export type ToastMessage = ToastOptions & {
 };
 export type ToastController = {
     show: (options: ToastOptions | string) => number;
+    /**
+     * Replaces what toast `id` says, in place: a pending toast becomes its
+     * result, an error becomes pending again on Retry. False when that toast
+     * has already closed.
+     */
+    update: (id: number, options: ToastOptions | string) => boolean;
     dismiss: (id: number) => void;
     clear: () => void;
     info: (title: string, description?: string) => number;
     success: (title: string, description?: string) => number;
     warning: (title: string, description?: string) => number;
     danger: (title: string, description?: string) => number;
+    /** A pending toast; see ToastOptions.pending. */
+    pending: (title: string, description?: string) => number;
 };
 export declare const toastControllerKey: InjectionKey<ToastController>;
 export declare function useToast(): ToastController;

package/dist/components/primitives/tooltip/Tooltip.vue.d.ts

@@ -1,15 +1,20 @@
 type __VLS_Props = {
     content: string;
     side?: 'top' | 'right' | 'bottom' | 'left';
+    /** The first tooltip's delay in ms; a neighbour opened right after another skips it. */
     delay?: number;
     /** Keeps the trigger from opening a tooltip at all. */
     disabled?: boolean;
-    /** A tap on the trigger toggles the tooltip (touch has no hover). Off by default so an icon button's tap only acts. */
+    /**
+     * A touch or pen tap on the trigger toggles the tooltip, and a tap anywhere
+     * else closes it (touch has no hover). On by default on a coarse pointer;
+     * `false` keeps a tap to the trigger's own action.
+     */
     openOnTap?: boolean;
 };
-declare var __VLS_25: {};
+declare var __VLS_27: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_25) => any;
+    default?: (props: typeof __VLS_27) => any;
 };
 declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     disabled: boolean;

package/dist/components/primitives/tooltip/tooltipStyle.d.ts

@@ -1 +1,11 @@
-export declare const TOOLTIP_CONTENT_CLASS = "z-[1450] max-w-72 rounded-[var(--ui-radius-sm)] bg-[var(--ui-tooltip-bg)] px-2.5 py-1.5 text-[12px] leading-4 text-[var(--ui-tooltip-fg)] whitespace-pre-line shadow-[var(--ui-shadow-menu)] [overflow-wrap:anywhere] animate-[ui-fade-in_var(--ui-motion-fast)_var(--ui-motion-ease)]";
+export declare const TOOLTIP_CONTENT_CLASS = "z-[1450] max-w-[min(18rem,var(--reka-popper-available-width,18rem))] rounded-[var(--ui-radius-sm)] bg-[var(--ui-tooltip-bg)] px-3 py-1.5 text-[12px] leading-4 text-[var(--ui-tooltip-fg)] whitespace-pre-line shadow-[var(--ui-shadow-menu)] [overflow-wrap:anywhere] animate-[ui-fade-in_var(--ui-motion-fast)_var(--ui-motion-ease)]";
+/** Gap between a tooltip and its trigger. */
+export declare const TOOLTIP_OFFSET = 6;
+/** The first tooltip waits this long (interaction-spec §1.1). */
+export declare const TOOLTIP_DELAY = 350;
+/** A tooltip that opens within this long of another closing skips the delay. */
+export declare const TOOLTIP_SKIP_DELAY = 300;
+/** True while a tooltip is open or closed less than TOOLTIP_SKIP_DELAY ago. */
+export declare const tooltipWarm: import('vue').Ref<boolean, boolean>;
+export declare function tooltipOpened(): void;
+export declare function tooltipClosed(): void;

package/dist/composables/backDismiss.d.ts

@@ -0,0 +1,19 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * The key this layer adds to `history.state`: how many dismissable surfaces
+ * were open when the entry was pushed. Other keys (a router's) are copied
+ * through unchanged, and the URL never changes.
+ */
+export declare const BACK_DISMISS_STATE_KEY = "__uiBackDismiss";
+export interface BackDismissOptions {
+    /** Off: the surface takes no history entry (a desktop popover, a DSM window). Default on. */
+    enabled?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * Lets the browser's Back (the Android back button, the iOS edge swipe) close
+ * an open sheet, drawer or pushed page instead of leaving the page. While
+ * `open` is true the surface owns one `history.state` entry; Back calls
+ * `close`, and closing by code takes the entry back off. Nested surfaces
+ * stack: each Back closes the top one only. Call it in a component's setup.
+ */
+export declare function useBackDismiss(open: MaybeRefOrGetter<boolean>, close: () => void, options?: BackDismissOptions): void;

package/dist/composables/phone.d.ts

@@ -0,0 +1,8 @@
+import { ComputedRef } from 'vue';
+/**
+ * True on a phone: the enclosing AppRoot is narrow (`presentation` mobile)
+ * and the pointer is coarse. It is the same signal as the phone tokens in
+ * adaptive.css (docs/mobile-native.md, Signals). Outside an AppRoot, or in a
+ * narrow window used with a mouse, it is false.
+ */
+export declare function usePhone(): ComputedRef<boolean>;

package/dist/composables/softKeyboard.d.ts

@@ -1,6 +1,28 @@
-export declare function raisesKeyboard(element: Element | null): boolean;
+import { ComputedRef, Ref } from 'vue';
+import { raisesKeyboard } from './visualViewport';
+export { raisesKeyboard };
 /**
- * True while a text field has focus on a touch device, where the on-screen
- * keyboard is then open. A mouse-and-keyboard device never reports one.
+ * True while the on-screen keyboard is open. A focused text field on a touch
+ * device is the fast first signal; the visual viewport then confirms it (or
+ * not, for a hardware keyboard). A mouse-and-keyboard device never reports one.
+ * Without `visualViewport` the focus signal stands alone.
  */
-export declare function useSoftKeyboard(): import('vue').Ref<boolean, boolean>;
+export declare function useSoftKeyboard(): ComputedRef<boolean>;
+/** Focuses an element without letting the browser scroll the page, then shows it inside its own scroller. */
+export declare function focusWithoutScroll(element: HTMLElement | null | undefined): void;
+/** The element's nearest scroll container below the document; the window itself never scrolls. */
+export declare function scrollerOf(element: HTMLElement): HTMLElement | null;
+/**
+ * Scrolls the element's own scroller (never the window) just enough to show it
+ * above the keyboard and any sticky footer, by the scroller's
+ * `scroll-padding-*` (block "nearest"). Returns the scroller it moved, if any.
+ */
+export declare function revealInScroller(element: HTMLElement): HTMLElement | null;
+/**
+ * While the keyboard is open, keeps the focused field inside `root` visible in
+ * its own scroller: on focus, when the keyboard opens and when it changes
+ * height. The scroller gets `data-ui-kb-room` (scroll padding, and on iOS room
+ * to scroll the last field above the keyboard) until the keyboard closes. A
+ * field inside `[data-ui-keyboard-reveal="off"]` is left to its container.
+ */
+export declare function useFieldReveal(root: Ref<HTMLElement | null>): void;

package/dist/composables/visualViewport.d.ts

@@ -0,0 +1,31 @@
+import { Ref } from 'vue';
+/**
+ * A viewport change smaller than this is browser chrome (the URL bar or a
+ * toolbar), not an on-screen keyboard. vaul and the reka Drawer use the same
+ * threshold.
+ */
+export declare const KEYBOARD_THRESHOLD = 60;
+export interface VisualViewportState {
+    /** The visual viewport's height in CSS px: what is on screen above the keyboard. */
+    height: number;
+    /** How far the visual viewport is panned down the layout viewport (iOS pans it to show a field). */
+    offsetTop: number;
+    /**
+     * How much of the layout viewport the keyboard covers from the bottom:
+     * `innerHeight − height − offsetTop` while a keyboard is open, else 0. It is
+     * the iOS keyboard height; on Android with `interactive-widget=resizes-content`
+     * the layout viewport itself shrinks, so it stays 0 and the layout is already right.
+     */
+    keyboardInset: number;
+    /** An on-screen keyboard is open: a text field has focus and the viewport lost ≥60 px to it. */
+    keyboard: boolean;
+}
+export declare function raisesKeyboard(element: Element | null): element is HTMLElement;
+/**
+ * The visual viewport and the on-screen keyboard, read once per frame and
+ * shared by every caller (one set of listeners per page). Read-only. Without
+ * `window.visualViewport` the keyboard is never reported.
+ */
+export declare function useVisualViewport(): Readonly<Ref<VisualViewportState>>;
+/** True when the page can report the visual viewport (and so confirm a keyboard). */
+export declare function hasVisualViewport(): boolean;

package/dist/dnd/autoScroll.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @license MIT
+ * The edge-zone percentage and the linear speed ramp (full speed at and beyond
+ * the edge) are ported from Baserow's `v-auto-scroll` directive
+ * (web-frontend/modules/core/directives/autoScroll.js:30-99 at 98f727dc2),
+ * rewritten as a requestAnimationFrame loop with a minimum zone and both axes.
+ *
+ * Copyright (c) 2019-present Baserow B.V.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the "Software"), to deal in the Software
+ * without restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies
+ * or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+/** Share of the scroll box, per edge, that scrolls (interaction-spec §5.2). */
+export declare const AUTO_SCROLL_ZONE_PERCENT = 15;
+/** The zone never gets narrower than this. */
+export declare const AUTO_SCROLL_MIN_ZONE_PX = 56;
+/** Pixels per frame at the edge and beyond it. */
+export declare const AUTO_SCROLL_MAX_SPEED = 16;
+export interface AutoScrollOptions {
+    axis: 'x' | 'y' | 'both';
+    /** Zone per edge as a percentage of the box (default 15). */
+    padding?: number;
+    minZone?: number;
+    maxSpeed?: number;
+}
+export interface AutoScroll {
+    /** Feed the latest pointer position; starts the loop when it is in a zone. */
+    update(x: number, y: number): void;
+    stop(): void;
+    readonly running: boolean;
+}
+/**
+ * Speed for a pointer `offset` px from the box start on an axis `size` long:
+ * negative toward the start, positive toward the end, 0 outside both zones.
+ * Linear from 0 at the inner zone border to `max` at the edge; a pointer past
+ * the edge keeps full speed (Baserow clamps the distance to 0).
+ */
+export declare function edgeSpeed(offset: number, size: number, options?: Pick<AutoScrollOptions, 'padding' | 'minZone' | 'maxSpeed'>): number;
+/**
+ * Scrolls `element` while the last pointer position sits in an edge zone. The
+ * box is read once per frame inside the loop, never in the pointer handler.
+ */
+export declare function createAutoScroll(element: () => HTMLElement | null | undefined, options: AutoScrollOptions): AutoScroll;

package/dist/dnd/dragKit.d.ts

@@ -0,0 +1,111 @@
+import { AutoScrollOptions } from './autoScroll';
+import { Axis, LaneLayout, Rect } from './layout';
+export type DragKey = string | number;
+/** Touch must stay down this long before it lifts (interaction-spec §5.2, §14). */
+export declare const TOUCH_HOLD_MS = 250;
+/** Movement before the hold ends that hands the touch back to native scrolling. */
+export declare const TOUCH_HOLD_TOLERANCE_PX = 6;
+/** After a sibling moves, the target holds still this long (Baserow 100 ms). */
+export declare const SWAP_LOCK_MS = 100;
+export declare const DND_LANE_ATTR = "data-dnd-lane";
+export declare const DND_KEY_ATTR = "data-dnd-key";
+export declare const DND_INDEX_ATTR = "data-dnd-index";
+export declare const DND_STATE_ATTR = "data-dnd-state";
+export declare const DND_GHOST_ATTR = "data-dnd-ghost";
+export interface DragPosition {
+    lane: string;
+    index: number;
+}
+export interface DragDrop<K extends DragKey = DragKey> {
+    key: K;
+    from: DragPosition;
+    /** `index` is the item's index in the target lane after the move. */
+    to: DragPosition;
+}
+export type DragPhase = 'idle' | 'pending' | 'dragging' | 'settling' | 'returning';
+export type DragMode = 'pointer' | 'keyboard';
+export interface DragState<K extends DragKey = DragKey> {
+    readonly phase: DragPhase;
+    readonly mode: DragMode | null;
+    readonly key: K | null;
+    readonly from: DragPosition | null;
+    readonly to: DragPosition | null;
+    /** Bumps on every visible change (target, phase), never on pointer moves. */
+    readonly version: number;
+}
+export interface DragLaneOptions<K extends DragKey = DragKey> {
+    id: string;
+    /** The element item positions are measured from (holds the items, or is their scroll content). */
+    element: () => HTMLElement | null | undefined;
+    /** The box that scrolls this lane; defaults to `element`. */
+    scroller?: () => HTMLElement | null | undefined;
+    count: () => number;
+    /** Read at lift; default `{ kind: 'measured' }`. Virtual lanes must give a fixed layout. */
+    layout?: () => LaneLayout;
+    axis?: Axis;
+    /** Whether this lane takes the dragged item (a multi-value stack can refuse). */
+    accepts?: (key: K, from: DragPosition) => boolean;
+    /** Edge auto-scroll along the lane axis; false turns it off. */
+    autoScroll?: boolean | Partial<AutoScrollOptions>;
+}
+export interface DragKitOptions<K extends DragKey = DragKey> {
+    /** Mouse/pen distance before a press becomes a drag (default 5). */
+    threshold?: number;
+    holdMs?: number;
+    holdTolerance?: number;
+    swapLockMs?: number;
+    canDrag?: (key: K, from: DragPosition) => boolean;
+    /** Build the ghost from the pressed item; default clones it. */
+    ghost?: (source: HTMLElement) => HTMLElement;
+    /** Where the ghost is appended; default the app root (`[data-ui-app]`) or `body`. */
+    ghostParent?: (source: HTMLElement) => HTMLElement;
+    /** Outer scroll boxes (the board) that auto-scroll during a drag. */
+    scrollers?: ReadonlyArray<{
+        element: () => HTMLElement | null | undefined;
+    } & AutoScrollOptions>;
+    onStart?: (state: DragState<K>) => void;
+    /** Called in the release frame, before the settle animation. Apply the move to local data here. */
+    onDrop: (drop: DragDrop<K>) => void | PromiseLike<unknown>;
+    /** `onDrop`'s promise rejected: put the item back at `drop.from`. The kit animates it home. */
+    onRestore?: (drop: DragDrop<K>, error: unknown) => void;
+    onCancel?: (state: DragState<K>) => void;
+    onChange?: (state: DragState<K>) => void;
+}
+export interface DragItemBinding {
+    [DND_KEY_ATTR]: string;
+    [DND_INDEX_ATTR]: number;
+    [DND_STATE_ATTR]?: 'source' | 'settling';
+    style: Record<string, string>;
+}
+export interface DragPlaceholder {
+    /** Index in the target lane after the move. */
+    index: number;
+    /** Content coordinates, the same space the lane's items sit in. */
+    rect: Rect;
+    style: Record<string, string>;
+}
+export interface DragKit<K extends DragKey = DragKey> {
+    readonly state: DragState<K>;
+    /** Register a lane; returns its disposer. */
+    lane(options: DragLaneOptions<K>): () => void;
+    /** Bind on the item (or its handle) `pointerdown`. */
+    pointerDown(event: PointerEvent, lane: string, index: number, key: K): void;
+    /** Bind on the focusable item `keydown`. Space lifts, arrows move, Space/Enter drop. Returns true when handled. */
+    keyDown(event: KeyboardEvent, lane: string, index: number, key: K): boolean;
+    /** Attributes and style for item `index` of `lane`. */
+    item(lane: string, index: number, key: K): DragItemBinding;
+    /** Attributes for the lane element. */
+    laneAttrs(lane: string): Record<string, string>;
+    /** Where the placeholder of `lane` goes, or null when the drop is not over it. */
+    placeholder(lane: string): DragPlaceholder | null;
+    isDragging(key: K): boolean;
+    /** Fly the item home and end the drag. */
+    cancel(): void;
+    dispose(): void;
+}
+/**
+ * One drag at a time across any number of lanes. The pointer-following ghost
+ * is written straight to the DOM; only the target index and phase are state,
+ * so siblings re-render once per target change and animate by transform.
+ */
+export declare function createDragKit<K extends DragKey = DragKey>(options: DragKitOptions<K>): DragKit<K>;

package/dist/dnd/index.d.ts

@@ -0,0 +1,4 @@
+export { AUTO_SCROLL_MAX_SPEED, AUTO_SCROLL_MIN_ZONE_PX, AUTO_SCROLL_ZONE_PERCENT, createAutoScroll, edgeSpeed, type AutoScroll, type AutoScrollOptions, } from './autoScroll';
+export { DND_GHOST_ATTR, DND_INDEX_ATTR, DND_KEY_ATTR, DND_LANE_ATTR, DND_STATE_ATTR, SWAP_LOCK_MS, TOUCH_HOLD_MS, TOUCH_HOLD_TOLERANCE_PX, createDragKit, type DragDrop, type DragItemBinding, type DragKey, type DragKit, type DragKitOptions, type DragLaneOptions, type DragMode, type DragPhase, type DragPlaceholder, type DragPosition, type DragState, } from './dragKit';
+export { gridGeometry, listGeometry, measuredGeometry, type Arrangement, type Axis, type LaneGeometry, type LaneLayout, type Rect, } from './layout';
+export { useDragKit, type UseDragKit } from './vue';

package/dist/dnd/layout.d.ts

@@ -0,0 +1,57 @@
+export type Axis = 'x' | 'y';
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type LaneLayout = 
+/** Equal items along the lane axis (virtual lists, grid rows, columns). */
+{
+    kind: 'list';
+    size: number;
+    gap?: number;
+    start?: number;
+}
+/** Equal cards wrapped into `columns` (gallery). Reorder rule uses the x axis. */
+ | {
+    kind: 'grid';
+    width: number;
+    height: number;
+    columns: number;
+    gapX?: number;
+    gapY?: number;
+    startX?: number;
+    startY?: number;
+}
+/** Rendered items measured at lift (`data-dnd-index`); for lanes that render every item. */
+ | {
+    kind: 'measured';
+};
+export interface Arrangement {
+    readonly count: number;
+    rect(slot: number): Rect;
+    /** The visual slot under a content point, clamped to the slots; -1 when there are none. */
+    slotAt(x: number, y: number): number;
+}
+export interface LaneGeometry {
+    /** The axis the half-item rule reads. */
+    readonly axis: Axis;
+    readonly count: number;
+    /** Where original item `index` sits before anything moves. */
+    origin(index: number): Rect;
+    /**
+     * The visual slots after original item `skip` leaves the lane (-1: none
+     * leaves) and a placeholder the size of `drag` takes slot `insert` (-1: none).
+     */
+    arrange(skip: number, insert: number, drag: Rect): Arrangement;
+}
+export declare function listGeometry(axis: Axis, count: number, size: number, gap?: number, start?: number, cross?: number): LaneGeometry;
+export declare function gridGeometry(count: number, layout: Extract<LaneLayout, {
+    kind: 'grid';
+}>): LaneGeometry;
+/**
+ * Items of varying size along one axis. `origins[i]` is item i's measured rect;
+ * `start` places the first slot of an empty lane (its padding).
+ */
+export declare function measuredGeometry(axis: Axis, origins: readonly Rect[], start?: number): LaneGeometry;

package/dist/dnd/vue.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+import { DragItemBinding, DragKey, DragKit, DragKitOptions, DragLaneOptions, DragPlaceholder } from './dragKit';
+export interface UseDragKit<K extends DragKey> {
+    kit: DragKit<K>;
+    /** Bumps on every visible drag change; pointer moves never touch it. */
+    version: Readonly<Ref<number>>;
+    /** `kit.item`, tracked by `version` for templates. */
+    item(lane: string, index: number, key: K): DragItemBinding;
+    /** `kit.placeholder`, tracked by `version` for templates. */
+    placeholder(lane: string): DragPlaceholder | null;
+    isDragging(key: K): boolean;
+    /** Register a lane for as long as the calling scope lives. */
+    useLane(options: DragLaneOptions<K>): () => void;
+}
+/** `createDragKit` bound to the effect scope, with one shallowRef bump per change. */
+export declare function useDragKit<K extends DragKey = DragKey>(options: DragKitOptions<K>): UseDragKit<K>;

package/dist/feedback/StatusSlot.vue.d.ts

@@ -0,0 +1,24 @@
+type __VLS_Props = {
+    state?: 'idle' | 'pending' | 'saved' | 'error';
+    /** What to say in the current state, from the caller's localized copy. */
+    message?: string;
+    width?: string;
+    height?: string;
+    /** Milliseconds before the pending state shows. */
+    delay?: number;
+    /** The error's action; empty hides it. */
+    retryLabel?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    retry: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRetry?: (() => any) | undefined;
+}>, {
+    height: string;
+    width: string;
+    message: string;
+    delay: number;
+    state: "idle" | "pending" | "saved" | "error";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/feedback/showAfter.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+export type ShowAfterOptions = {
+    /** Milliseconds `active` must hold before the indicator shows. */
+    delay?: number;
+    /** Milliseconds a shown indicator stays, from when it appeared, so it does not blink. */
+    minVisible?: number;
+};
+/**
+ * Whether a pending indicator (skeleton shapes, a spinner, a saving mark)
+ * should show: only once `active` has held for `delay` (300 ms by default),
+ * and then for at least `minVisible`. Work that ends sooner shows nothing.
+ * The box the indicator sits in is reserved by the caller from the start;
+ * only its contents wait.
+ */
+export declare function useShowAfter(active: () => boolean, options?: ShowAfterOptions): Readonly<Ref<boolean>>;

package/dist/feedback/stackMotion.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+/**
+ * Moves the items of a stack (the toast viewport) to their new places over
+ * `--ui-motion-stack` when one arrives, leaves or changes its text, instead
+ * of jumping (FLIP).
+ *
+ * The places are read after each change and kept; a change is seen by a
+ * MutationObserver, which runs before the next paint, so each item first
+ * paints at its old place and then slides. Only the `translate` property is
+ * written, so the items' own enter and exit animations (on `transform`) keep
+ * running. With motion off the token reads 0 and nothing animates.
+ */
+export declare function useStackMotion(container: Readonly<Ref<HTMLElement | null | undefined>>, itemSelector: string): void;

package/dist/feedback/timing.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Feedback timing (interaction spec §11-12): how long a loading indicator
+ * waits before it shows, and how long each kind of toast stays.
+ */
+/** No skeleton, spinner or pending mark for work shorter than this. */
+export declare const PENDING_DELAY_MS = 300;
+/** A toast's tone. */
+export type FeedbackTone = 'info' | 'success' | 'warning' | 'danger';
+/** How long a toast of each tone stays; a danger toast stays until closed. */
+export declare const TOAST_DURATION_MS: Readonly<Record<FeedbackTone, number>>;
+/** A toast with an action (Undo, Open) stays at least this long, so there is time to reach it. */
+export declare const TOAST_ACTION_MIN_MS = 5000;
+/**
+ * The time a toast stays open: its own `duration` when given; a pending
+ * toast stays until it is updated; otherwise its tone's time, at least
+ * TOAST_ACTION_MIN_MS when it has an action.
+ */
+export declare function toastDuration(toast: {
+    tone?: FeedbackTone;
+    duration?: number;
+    pending?: boolean;
+    actionLabel?: string;
+}): number;