@synopackageland/ui 0.20.3 → 0.20.5

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/components/rich-text-editor/RichTextEditor.vue.d.ts

@@ -68,10 +68,10 @@ declare const __VLS_export: import('vue').DefineComponent<{
     variant: "compact" | "full";
     loading: boolean;
     disabled: boolean;
+    invalid: boolean;
     id: string;
     modelValue: string;
     placeholder: string;
-    invalid: boolean;
     ariaLabel: string;
     headings: boolean;
     files: (id: string) => FileItem | undefined;

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/formControl.d.ts

@@ -1,3 +1,11 @@
+/** The native `type` for an Input `type`: `integer` and `decimal` are text fields with a number keyboard (never `type="number"`). */
+export declare function nativeInputType(type: string): string;
+/**
+ * The on-screen keyboard a field of this type opens: its layout
+ * (`inputmode`), whether it capitalises and spell-checks, and the label of
+ * its Enter key. The caller's own attributes override every one of them.
+ */
+export declare function keyboardHints(type: string): Record<string, string>;
 /** One primary control per FormItem. Layout attrs stay on wrappers; all other
  * attrs belong to the focusable control. Composite controls consume the field
  * so their popup's internal inputs cannot steal its label or reuse its id. */
@@ -8,6 +16,16 @@ export declare function useFormControl(options: {
     ariaLabel?: () => string | undefined;
     ariaLabelledby?: () => string | undefined;
     invalid?: () => boolean | undefined;
+    /**
+     * A text entry field: its type sets the keyboard hints. With `element`, the
+     * field also joins its Form's field order, so its Enter key reads Next, or
+     * Done on the last field, and on a touch device Next moves to the next field.
+     */
+    keyboard?: {
+        type: () => string;
+        element?: () => HTMLElement | null | undefined;
+        active?: () => boolean;
+    };
 }): {
     controlAttrs: () => Record<string, unknown> & {
         id?: string;

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/phoneSurface.d.ts

@@ -0,0 +1,35 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+/** A menu with more actions than this becomes an action sheet on a phone. */
+export declare const PHONE_MENU_MAX_ACTIONS = 5;
+/** What a popup holds; any of these, on a phone, makes it a sheet. */
+export interface PhoneSurfaceContent {
+    list?: boolean;
+    search?: boolean;
+    form?: boolean;
+    /** The number of actions on the first level of a menu. */
+    actions?: number;
+    submenu?: boolean;
+}
+export type PhoneSurface = 'popover' | 'sheet';
+/** Whether this content needs a sheet once the app is phone-width. */
+export declare function needsSheet(content: PhoneSurfaceContent): boolean;
+type MenuEntryShape = {
+    key?: unknown;
+    type?: string;
+    children?: readonly unknown[];
+};
+/** The content of a menu: its first-level actions (separators don't count) and whether any of them opens a submenu. */
+export declare function menuContent(items: readonly MenuEntryShape[]): PhoneSurfaceContent;
+/**
+ * `sheet` while the enclosing app is phone-width (640px or narrower, the same
+ * signal that turns a Dialog into a BottomSheet) and the content needs one,
+ * else `popover`. A touch tablet keeps popovers. Call it in setup.
+ */
+export declare function usePhoneSurface(content: MaybeRefOrGetter<PhoneSurfaceContent>): ComputedRef<PhoneSurface>;
+/**
+ * The name a control is known by, to title the sheet it opens: its
+ * `aria-label`, else the text of the elements its `aria-labelledby` names
+ * (a form label).
+ */
+export declare function accessibleName(element: Element | null | undefined): string;
+export {};

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;
+}>, {
+    message: string;
+    height: string;
+    width: 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;

package/dist/grid/cells/draw.d.ts

@@ -0,0 +1,57 @@
+import { drawCheckbox, drawRect } from '../../grid-core/renderer/base';
+import { GridRect } from '../contracts';
+import { GridChipColors } from '../theme';
+import { GridCellPaintArgs } from './types';
+export declare const CHIP_GAP = 4;
+export declare const CHIP_PADDING = 6;
+export declare const CHIP_RADIUS = 4;
+export declare const ICON_GAP = 4;
+export declare const setFont: (ctx: CanvasRenderingContext2D, size: number, family: string, weight?: string) => void;
+/** Width of `text` in the current font, with grid-core's cache. */
+export declare const measure: (ctx: CanvasRenderingContext2D, text: string, fontSize: number) => number;
+/** First grapheme of a name, for avatar initials. */
+export declare const firstGrapheme: (text: string) => string;
+export interface TextOptions {
+    color?: string;
+    align?: 'left' | 'right';
+    /** Left edge, defaults to the cell's padding. */
+    x?: number;
+    maxWidth?: number;
+    fontSize?: number;
+}
+/** One line of cell text, vertically centred, cut with an ellipsis. Returns the drawn width. */
+export declare const drawCellText: (ctx: CanvasRenderingContext2D, args: GridCellPaintArgs, text: string, options?: TextOptions) => number;
+/** A rounded chip with its label, already planned to `width`. */
+export declare const drawChip: (ctx: CanvasRenderingContext2D, args: GridCellPaintArgs, rect: GridRect, label: string, colors: GridChipColors) => void;
+export interface InlinePlan {
+    /** Widths of the items that are drawn, in order (the last may be cut). */
+    widths: number[];
+    /** Items not drawn, shown as a "+N" badge. */
+    more: number;
+    badgeWidth: number;
+}
+/**
+ * Lays out inline items (chips, avatars, thumbnails) on one line within
+ * `available`. Items that do not fit collapse into a "+N" badge; when even the
+ * first item does not fit, it is cut to the room left beside the badge.
+ */
+export declare const planInline: (natural: readonly number[], available: number, badgeWidthFor: (count: number) => number, minItem: number) => InlinePlan;
+/** Width of a "+N" badge at the chip font. */
+export declare const badgeWidth: (ctx: CanvasRenderingContext2D, args: GridCellPaintArgs, count: number) => number;
+export declare const drawBadge: (ctx: CanvasRenderingContext2D, args: GridCellPaintArgs, x: number, count: number, width: number) => void;
+/** Five-point star inside a `size` box at (x, y). */
+export declare const drawStar: (ctx: CanvasRenderingContext2D, x: number, y: number, size: number, fill: string) => void;
+/** "Open link" glyph: a box with an arrow leaving its top-right corner. */
+export declare const drawLinkIcon: (ctx: CanvasRenderingContext2D, x: number, y: number, size: number, stroke: string) => void;
+export { drawCheckbox, drawRect };
+/** Keeps the inline rects a draw produced so a later click can hit-test them without a canvas. */
+export declare class RegionCache {
+    private readonly cache;
+    set(key: string, regions: GridRect[]): void;
+    get(key: string): GridRect[] | undefined;
+    clear(): void;
+}
+export declare const inside: (point: {
+    x: number;
+    y: number;
+}, rect: GridRect) => boolean;

package/dist/grid/cells/images.d.ts

@@ -0,0 +1,5 @@
+import { GridImageSource } from './types';
+export interface GridImageCache extends GridImageSource {
+    clear: () => void;
+}
+export declare const createGridImageCache: (onLoad: () => void, max?: number) => GridImageCache;

package/dist/grid/cells/index.d.ts

@@ -0,0 +1,7 @@
+export { createGridCells, type GridCells, type GridCellsOptions } from './registry';
+export { useGridCells, type UseGridCellsOptions } from './use';
+export { defaultGridCellRenderers, clearGridCellRegions } from './renderers';
+export { formatGridNumber, parseGridNumber } from './number';
+export { drawGridCellStatus } from './status';
+export { createGridImageCache, type GridImageCache } from './images';
+export type * from './types';

package/dist/grid/cells/number.d.ts

@@ -0,0 +1,5 @@
+import { GridNumberFormat } from './types';
+/** 12.5 → "12.50"; currency "$1,234.50"; percent 0.125 → "12.50%". Empty for null. */
+export declare const formatGridNumber: (value: number | null | undefined, format?: GridNumberFormat, locale?: string) => string;
+/** Teable's lenient parse: keeps digits, `.`, `+`, `-`; "12.5abc" → 12.5, "50%" → 0.5. Null when nothing parses. */
+export declare const parseGridNumber: (value: string | null | undefined, format?: GridNumberFormat) => number | null;