@ahrowe/ui 0.35.0 → 0.36.0

package/dist/cjs-types/common/hooks/useSwipeDismiss.d.ts

@@ -0,0 +1,33 @@
+export interface UseSwipeDismissOptions {
+    /** Called once the swipe commits (past the threshold) — after the exit transition finishes,
+     * not the instant the pointer is released. */
+    onDismiss: () => void;
+    /** Which axis the drag tracks (default `'x'`, the natural direction for a toast/notification). */
+    axis?: 'x' | 'y';
+    /** Distance in px past which releasing counts as a commit, regardless of speed (default `80`). */
+    distanceThreshold?: number;
+    /** Speed in px/ms past which releasing counts as a commit, regardless of distance (default `0.5`) —
+     * lets a fast flick dismiss even if the pointer didn't travel very far. */
+    velocityThreshold?: number;
+    /** Disables the gesture entirely — no listeners are attached. */
+    disabled?: boolean;
+    /** Restricts the gesture to coarse (touch) pointers, auto-detected via `matchMedia`. On a
+     * mouse/trackpad device a drag is more likely to be a text selection than an intentional
+     * dismiss, and other affordances (a close button, auto-dismiss) typically already cover that
+     * case. Default `true`; set `false` to allow the gesture on any pointer type. */
+    mobileOnly?: boolean;
+}
+export interface UseSwipeDismissResult<T extends HTMLElement> {
+    /** Attach to the element that should become draggable. The hook wires up its own pointer
+     * listeners on this node directly (no handlers to spread), so this is the only thing to attach. */
+    ref: React.RefObject<T | null>;
+    /** True for the duration of an active drag — e.g. use it to pause an auto-dismiss timer. */
+    isDragging: boolean;
+}
+/**
+ * Drag-to-dismiss on any pointer type (touch, mouse, pen) via the Pointer Events API. Applies the
+ * drag offset and a fading opacity directly to the DOM node (bypassing React state) so the visual
+ * tracks the pointer at native speed, then either springs back or animates fully off-screen and
+ * calls `onDismiss` once that exit transition completes.
+ */
+export declare function useSwipeDismiss<T extends HTMLElement>({ onDismiss, axis, distanceThreshold, velocityThreshold, disabled, mobileOnly, }: UseSwipeDismissOptions): UseSwipeDismissResult<T>;

package/dist/cjs-types/common/hooks/useVisualViewportSize.d.ts

@@ -0,0 +1,13 @@
+export interface VisualViewportSize {
+    /** Height of the actually-visible viewport in px — shrinks when a mobile on-screen keyboard
+     * opens, unlike `window.innerHeight` / CSS `vh`, which stay pinned to the full layout viewport. */
+    height: number;
+    /** Vertical offset of the visible viewport's top edge within the layout viewport — non-zero once
+     * the page has scrolled to keep a focused field above the keyboard. */
+    offsetTop: number;
+}
+/**
+ * Tracks `window.visualViewport` so layout can react to the on-screen keyboard opening/closing.
+ * Falls back to `window.innerHeight`/0 in browsers without the API.
+ */
+export declare function useVisualViewportSize(): VisualViewportSize;

package/dist/cjs-types/common/iconPicker/iconPicker.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { IconPickerProps } from './iconPicker.types.js';
+export default function IconPicker({ data, selectedId, label, onChange, formValidator, isRequired: _isRequired, className, style, classNames, styles: slotStyles, ...rest }: IconPickerProps): React.JSX.Element;

package/dist/cjs-types/common/iconPicker/iconPicker.types.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { IconDefinition } from '@fortawesome/free-solid-svg-icons';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+import { FormValidator } from '../../services/formValidation/index.js';
+export type IconPickerSlots = 'root' | 'label' | 'itemContainer' | 'item';
+export interface IconPickerItem {
+    id: string;
+    label: string;
+    icon?: IconDefinition;
+    customIcon?: React.ReactNode;
+}
+export interface IconPickerProps extends Omit<HtmlProps, 'onChange'> {
+    data?: IconPickerItem[];
+    selectedId?: string | null;
+    label?: string;
+    onChange?: (id: string) => void;
+    formValidator?: FormValidator | null;
+    isRequired?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    classNames?: SlotClassNames<IconPickerSlots>;
+    styles?: SlotStyles<IconPickerSlots>;
+}

package/dist/cjs-types/common/iconPicker/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './iconPicker.js';
+export * from './iconPicker.types.js';

package/dist/cjs-types/common/idleManager/idleManager.d.ts

@@ -0,0 +1,3 @@
+import { IdleManagerProps } from './idleManager.types.js';
+declare function IdleManager({ children, idleAfterSeconds, renderCondition }: IdleManagerProps): import("react").JSX.Element;
+export default IdleManager;

package/dist/cjs-types/common/idleManager/idleManager.types.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface IdleManagerProps {
+    children?: React.ReactNode;
+    /** Seconds of inactivity before children are rendered. Defaults to 600 (10 min). */
+    idleAfterSeconds?: number;
+    /** Children are only rendered when this is true AND the user is idle. Defaults to true. */
+    renderCondition?: boolean;
+}

package/dist/cjs-types/common/idleManager/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './idleManager.js';
+export * from './idleManager.types.js';

package/dist/cjs-types/common/infiniteBlock/useInfiniteScroll.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export declare function useInfiniteScroll(containerRef: React.RefObject<HTMLDivElement | null>, onScroll: () => Promise<void>, disabled: boolean): {
+    isLoading: boolean;
+    sentinelRef: React.RefObject<HTMLDivElement | null>;
+};

package/dist/cjs-types/common/input/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './input.js';
+export * from './input.types.js';

package/dist/cjs-types/common/input/input.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { InputProps } from './input.types.js';
+declare function Input(props: InputProps): React.JSX.Element;
+export default Input;

package/dist/cjs-types/common/input/input.types.d.ts

@@ -0,0 +1,84 @@
+import { default as React } from 'react';
+import { FormValidator } from '../../services/formValidation/index.js';
+import { SlotClassNames, SlotStyles, DataProps } from '../types/slots.types.js';
+export declare enum InputType {
+    Edit = "edit",
+    Phone = "phone",
+    Email = "email",
+    Iban = "iban",
+    Date = "date",
+    HasNoIcon = "hasNoIcon",
+    Search = "searchInput",
+    Password = "password"
+}
+export declare enum InputIconPosition {
+    Left = "left",
+    Right = "right"
+}
+export type InputSlots = 'label' | 'container' | 'input' | 'suffix' | 'upperRightLabel' | 'fieldset';
+type OverriddenInputAttributes = 'onChange' | 'onFocus' | 'onBlur' | 'onMouseEnter' | 'onMouseLeave' | 'onClick' | 'type' | 'value' | 'min' | 'max' | 'autoComplete';
+/** Text Input renders of its own, for translating it. */
+export interface InputLabels {
+    /** Clear button on a search input, read out by screen readers. */
+    clear?: string;
+    /** Reveals a password, read out by screen readers. */
+    showPassword?: string;
+    /** Hides a password again. */
+    hidePassword?: string;
+    /** Clears a search input, read out by screen readers. */
+    clearSearch?: string;
+}
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, OverriddenInputAttributes>, DataProps {
+    onMouseEnter?: ((event: React.MouseEvent) => void) | null;
+    onMouseLeave?: ((event: React.MouseEvent) => void) | null;
+    onFocus?: ((event: React.FocusEvent) => void) | null;
+    onBlur?: ((event: React.FocusEvent) => void) | null;
+    onChange?: ((value: string, event?: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement, Element>) => void) | null;
+    errorMessage?: string;
+    isValid?: boolean;
+    isRequired?: boolean;
+    label?: string;
+    name?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    value?: string | number;
+    icon?: React.ReactElement | null;
+    iconPosition?: InputIconPosition;
+    isUppercase?: boolean;
+    isRow?: boolean;
+    tabIndex?: number;
+    type?: InputType;
+    onIconClick?: (() => void) | null;
+    parse?: ((value: string) => string) | null;
+    suffix?: string | React.ReactNode;
+    disabled?: boolean;
+    upperRightLabel?: string | React.ReactNode;
+    labelInBorder?: boolean;
+    showCancel?: boolean;
+    onClearClicked?: (() => void) | null;
+    min?: string | number | null;
+    max?: string | number | null;
+    placeholder?: string;
+    useMatLabelStyle?: boolean;
+    alwaysFloatLabel?: boolean;
+    autoComplete?: string | null;
+    onClick?: (() => void) | null;
+    readOnly?: boolean;
+    customInput?: React.ReactElement | null;
+    autoFocus?: boolean;
+    alwaysShowCancel?: boolean;
+    formValidator?: FormValidator | null;
+    multiline?: boolean;
+    rows?: number;
+    autoResize?: boolean;
+    /**
+     * Ref to the rendered `<input>` (or `<textarea>` when `multiline`). Not forwarded to a
+     * `customInput`, which owns its own ref.
+     */
+    ref?: React.Ref<HTMLInputElement | HTMLTextAreaElement>;
+    classNames?: SlotClassNames<InputSlots>;
+    styles?: SlotStyles<InputSlots>;
+    /** Overrides the text Input renders of its own. Merged per key. */
+    labels?: InputLabels;
+}
+export {};

package/dist/cjs-types/common/inputDropdown/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './inputDropdown.js';
+export * from './inputDropdown.types.js';

package/dist/cjs-types/common/inputDropdown/inputDropdown.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { InputDropdownProps } from './inputDropdown.types.js';
+export default function InputDropdown(props: InputDropdownProps): React.JSX.Element;

package/dist/cjs-types/common/inputDropdown/inputDropdown.types.d.ts

@@ -0,0 +1,36 @@
+import { default as React } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+import { FormValidator } from '../../services/formValidation/index.js';
+export type InputDropdownSlots = 'root' | 'dropdown' | 'item';
+export interface InputDropdownItem {
+    label?: string;
+    value: string;
+}
+export interface InputDropdownProps extends Omit<HtmlProps, 'onSelect'> {
+    label?: string;
+    value?: string;
+    formValidator?: FormValidator | null;
+    error?: string;
+    isRequired?: boolean;
+    items?: InputDropdownItem[];
+    /**
+     * Allow values that are not part of `items`. When true, the typed text is
+     * emitted via `onChange`/`onSelect`/the form validator on every keystroke,
+     * instead of only when an item is picked from the list.
+     */
+    allowCustomValue?: boolean;
+    /**
+     * Maximum number of filtered items rendered in the list. Matches beyond this
+     * are dropped (the user narrows by typing, not by scrolling). `0` renders all
+     * matches. Default `100`.
+     */
+    maxItems?: number;
+    onSelect?: (value: string) => void;
+    onChange?: (value: unknown) => void;
+    placeholder?: string;
+    readOnly?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    classNames?: SlotClassNames<InputDropdownSlots>;
+    styles?: SlotStyles<InputDropdownSlots>;
+}

package/dist/cjs-types/common/interactableDiv/index.d.ts

@@ -0,0 +1,2 @@
+import { default as InteractableDiv } from './interactableDiv.js';
+export default InteractableDiv;

package/dist/cjs-types/common/interactableDiv/interactableDiv.d.ts

@@ -0,0 +1,8 @@
+import { default as React, ReactElement } from 'react';
+import { DataProps } from '../types/baseProps.types.js';
+interface Properties extends DataProps, Omit<React.HTMLAttributes<HTMLDivElement>, 'tabIndex'> {
+    tabIndex?: number | null;
+    ref?: React.Ref<HTMLDivElement>;
+}
+declare function InteractableDiv({ className, children, onClick, onKeyDown, tabIndex, ref, ...props }: Properties): ReactElement;
+export default InteractableDiv;

package/dist/cjs-types/common/kanbanBoard/KanbanBoard.d.ts

@@ -0,0 +1,3 @@
+import { KanbanBoardProps } from './kanbanBoard.types.js';
+declare function KanbanBoard<T = unknown>({ columns, items, renderItem, onChange, dragHandle, getItemLabel, getItemDisabled, renderEmptyColumn, renderColumnActions, reorderableColumns, collapseEmptyColumns, columnMaxHeight, onLoadMore, loadMoreThreshold, className, style, classNames, styles: slotStyles, ...rest }: KanbanBoardProps<T>): import("react").JSX.Element;
+export default KanbanBoard;

package/dist/cjs-types/common/kanbanBoard/KanbanColumn.d.ts

@@ -0,0 +1,45 @@
+import { ReactNode } from 'react';
+import { KanbanColumnProps } from './kanbanBoard.types.js';
+interface KanbanColumnInternalProps<T> extends KanbanColumnProps {
+    itemIds: string[];
+    items: Record<string, T>;
+    renderItem: (item: T, id: string) => ReactNode;
+    dragHandle?: boolean;
+    /**
+     * Keep the column at its normal flex width even when `itemIds` is empty. Used while a drag
+     * is in progress: the empty-column collapse is driven by transient shadow state during a
+     * drag, and letting the column shrink mid-drag shifts every column's layout underneath the
+     * pointer, which can flip the collision target back and forth forever.
+     */
+    preserveSizeWhileEmpty?: boolean;
+    /** Shrink to a narrow strip when empty — see `KanbanBoardProps.collapseEmptyColumns`. Defaults to `true`. */
+    collapseEmptyColumns?: boolean;
+    /** Work-in-progress limit — see `KanbanColumnDef.maxItems`. Display-only. */
+    maxItems?: number;
+    /** Freezes the column — see `KanbanColumnDef.disabled`. */
+    disabled?: boolean;
+    /** Returns whether a specific card can't be picked up — see `KanbanBoardProps.getItemDisabled`. */
+    getItemDisabled?: (item: T, id: string) => boolean;
+    /** Custom content shown when the column has no cards — see `KanbanBoardProps.renderEmptyColumn`. */
+    emptyPlaceholder?: ReactNode;
+    /** Custom header actions — see `KanbanBoardProps.renderColumnActions`. */
+    actions?: ReactNode;
+    /** Allow the whole column to be dragged (by its header) to reorder it — see `KanbanBoardProps.reorderableColumns`. */
+    reorderable?: boolean;
+    /**
+     * Whether the card currently being dragged (if any) is actually a column. Suppresses the
+     * cards drop-target highlight, which otherwise lights up on every column a dragged column
+     * passes over — that highlight means "drop a card here", which doesn't apply mid-column-drag.
+     */
+    activeIsColumn?: boolean;
+    /** Bounds the column's height and makes its card list scroll — see `KanbanBoardProps.columnMaxHeight`. */
+    columnMaxHeight?: string;
+    /** Whether more items exist for this column — see `KanbanColumnDef.hasMore`. */
+    hasMore?: boolean;
+    /** Requests the next page for this column — see `KanbanBoardProps.onLoadMore`. */
+    onLoadMore?: () => void | Promise<void>;
+    /** Scroll distance from the bottom that triggers `onLoadMore` — see `KanbanBoardProps.loadMoreThreshold`. */
+    loadMoreThreshold?: number;
+}
+declare function KanbanColumn<T>({ id, title, itemIds, items, renderItem, dragHandle, preserveSizeWhileEmpty, collapseEmptyColumns, maxItems, disabled, getItemDisabled, emptyPlaceholder, actions, reorderable, activeIsColumn, columnMaxHeight, hasMore, onLoadMore, loadMoreThreshold, className, style, classNames, styles: slotStyles, ...rest }: KanbanColumnInternalProps<T>): import("react").JSX.Element;
+export default KanbanColumn;

package/dist/cjs-types/common/kanbanBoard/KanbanItem.d.ts

@@ -0,0 +1,3 @@
+import { KanbanItemProps } from './kanbanBoard.types.js';
+declare function KanbanItem({ id, dragHandle, disabled, preventAsDropTarget, children }: KanbanItemProps): import("react").JSX.Element;
+export default KanbanItem;

package/dist/cjs-types/common/kanbanBoard/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './KanbanBoard.js';
+export { default as KanbanColumn } from './KanbanColumn.js';
+export * from './kanbanBoard.types.js';

package/dist/cjs-types/common/kanbanBoard/kanbanBoard.types.d.ts

@@ -0,0 +1,129 @@
+import { CSSProperties, ReactNode } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export interface KanbanColumnDef {
+    id: string;
+    title: string;
+    itemIds: string[];
+    /**
+     * Optional work-in-progress limit. When set, the column header shows a `count/maxItems`
+     * badge, and the column gets a warning style once `itemIds.length` exceeds it. This is
+     * display-only — `KanbanBoard` doesn't block drops on its own. To enforce a hard limit,
+     * check it in `onChange` and skip updating your state when a drop would push a column over.
+     */
+    maxItems?: number;
+    /**
+     * Freezes the column: cards inside it can't be picked up, and nothing can be dropped into it.
+     * Use for a workflow rule like "cards in Done can't be moved back out."
+     */
+    disabled?: boolean;
+    /**
+     * Whether more items exist for this column beyond what's currently in `itemIds` — enables the
+     * scroll-triggered `onLoadMore` request. Only meaningful alongside `KanbanBoardProps.onLoadMore`;
+     * a column without it never asks for more regardless of this flag. Set `false` (or omit) once
+     * the column's source is exhausted to stop asking.
+     */
+    hasMore?: boolean;
+}
+export type KanbanBoardSlots = 'dragOverlay';
+export interface KanbanBoardProps<T = unknown> extends Omit<HtmlProps, 'onChange'> {
+    /** Ordered list of column definitions. Each column owns its itemIds. */
+    columns: KanbanColumnDef[];
+    /** Flat map of all items keyed by their id. */
+    items: Record<string, T>;
+    /** Render function for each item. Receives the item data and its id. */
+    renderItem: (item: T, id: string) => ReactNode;
+    /**
+     * Called after every drop that changes column or order.
+     * Receives the full updated columns array — replace your state with this value.
+     */
+    onChange: (columns: KanbanColumnDef[]) => void;
+    /**
+     * Restrict drag initiation to elements marked `data-drag-handle` within a card,
+     * instead of the whole card. Use when `renderItem` includes interactive content
+     * (buttons, inputs) that would otherwise have its clicks swallowed by the drag listener.
+     */
+    dragHandle?: boolean;
+    /**
+     * Produce an accessible label for a card, announced to screen-reader users while dragging
+     * (e.g. "Picked up <label>."). Defaults to the card's id when omitted.
+     */
+    getItemLabel?: (item: T, id: string) => string;
+    /**
+     * Returns whether a specific card can't be picked up. Defaults to every card being draggable.
+     * Independent of a column's own `disabled` — a card can be pinned even in an otherwise
+     * unrestricted column.
+     */
+    getItemDisabled?: (item: T, id: string) => boolean;
+    /**
+     * Custom content shown inside a column when it has no cards, instead of leaving it blank.
+     * Receives the column definition.
+     */
+    renderEmptyColumn?: (column: KanbanColumnDef) => ReactNode;
+    /**
+     * Custom actions rendered in a column's header, next to its title (e.g. an "add card"
+     * button, a column menu). Receives the column definition.
+     */
+    renderColumnActions?: (column: KanbanColumnDef) => ReactNode;
+    /**
+     * Allow whole columns to be reordered by dragging their header, alongside the existing
+     * card dragging. Defaults to `false`.
+     */
+    reorderableColumns?: boolean;
+    /**
+     * Shrink a column to a narrow strip once it has no cards, instead of keeping it at the same
+     * width as every other column. Defaults to `true`. Set `false` to keep every column the same
+     * width regardless of card count. The collapsed width itself is set via the
+     * `--kanban-empty-column-width` CSS variable (falls back to `140px`) — override it theme-wide
+     * via `ThemeProvider`'s `variables`, or per board via `style`.
+     */
+    collapseEmptyColumns?: boolean;
+    /**
+     * Bounds each column's height (any CSS length, e.g. `'70vh'`, `'600px'`) and makes its card
+     * list scroll independently once content overflows, instead of growing the whole page. Leave
+     * unset for the default unbounded height. Required for `onLoadMore` to ever trigger, since an
+     * unbounded column never scrolls.
+     */
+    columnMaxHeight?: string;
+    /**
+     * Called with a column's `id` when that column has `hasMore` set and its card list is scrolled
+     * within `loadMoreThreshold` of the bottom — fetch and append the next page of items for it.
+     * `KanbanColumn` tracks its own in-flight state per column (shown as a spinner at the bottom of
+     * the list), so overlapping calls for the same column are never made concurrently. Also
+     * retried automatically if a loaded batch doesn't fill the column's visible height, since a
+     * column shorter than its own viewport never generates a scroll event to trigger a next page.
+     */
+    onLoadMore?: (columnId: string) => void | Promise<void>;
+    /**
+     * Distance in px from the bottom of a column's scroll area that triggers `onLoadMore` (default
+     * `100`, matching `VirtualList`'s `loadMoreThreshold`).
+     */
+    loadMoreThreshold?: number;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<KanbanBoardSlots>;
+    styles?: SlotStyles<KanbanBoardSlots>;
+}
+export type KanbanColumnSlots = 'header' | 'items' | 'count' | 'placeholder' | 'actions' | 'loadingIndicator';
+export interface KanbanColumnProps extends HtmlProps {
+    id: string;
+    title: string;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<KanbanColumnSlots>;
+    styles?: SlotStyles<KanbanColumnSlots>;
+}
+export interface KanbanItemProps {
+    id: string;
+    dragHandle?: boolean;
+    /** Whether this card can't be picked up (column frozen, or the card itself is pinned). */
+    disabled?: boolean;
+    /**
+     * Whether this card also can't be a drop target for other cards — i.e. other cards can't be
+     * reordered relative to it either. Only true when the *column* is frozen (nothing should be
+     * dropped into it at all); a card pinned individually via `getItemDisabled` stays droppable, so
+     * other cards can still land before/after it normally.
+     */
+    preventAsDropTarget?: boolean;
+    children?: ReactNode;
+}

package/dist/cjs-types/common/kanbanBoard/kanbanBoard.utils.d.ts

@@ -0,0 +1,60 @@
+import { Announcements, ClientRect, CollisionDetection, KeyboardCoordinateGetter } from '@dnd-kit/core';
+import { KanbanColumnDef } from './kanbanBoard.types.js';
+export declare function columnsEqual(a: KanbanColumnDef[], b: KanbanColumnDef[]): boolean;
+export declare function findColumnForItem(columns: KanbanColumnDef[], itemId: string): number;
+/** Whether a drag's `active`/`over` participant is a whole column (vs. a card) — see `reorderableColumns`. */
+export declare function isColumnDragData(data: unknown): boolean;
+/**
+ * Reorders whole columns: moves `activeColumnId` to `overColumnId`'s position. Returns the same
+ * `columns` reference, unchanged, when either id doesn't resolve to a column or they're the same
+ * — callers can use that to skip a state update.
+ */
+export declare function moveColumn(columns: KanbanColumnDef[], activeColumnId: string, overColumnId: string): KanbanColumnDef[];
+/**
+ * Collision detection for the board's shared `DndContext`, which has to pick between two very
+ * differently-scaled sets of droppables at once: individual cards / a column's own card list
+ * (small, numerous) and whole columns (large, few). Plain `closestCorners` weighs every
+ * registered droppable together regardless of what's actually being dragged, so while dragging a
+ * column it competes against every card and card-list droppable it happens to fly over too — the
+ * column-level target only wins when the pointer lands somewhere that geometrically favors it,
+ * which reads as needing to "wiggle it around" before the right drop target lights up. This
+ * restricts the candidates to only the same kind as whatever is being dragged: a column drag only
+ * considers other columns, a card drag only considers cards and card lists.
+ */
+export declare const kanbanCollisionDetection: CollisionDetection;
+/** Extracts the column id from a column droppable's `column-<id>` identifier, or `null` for a card id. */
+export declare function resolveColumnDropId(overId: string): string | null;
+export interface DragGeometry {
+    /** The dragged card's current rect (translated by the drag delta), if measured. */
+    activeRect: ClientRect | null;
+    /** The rect of whatever `overId` refers to — a card, or a column's own droppable. */
+    overRect: ClientRect;
+}
+/**
+ * Computes the columns that result from dragging `activeItemId` over `overId` (a card id, or a
+ * `column-<id>` droppable id for empty column space). Returns the same `columns` reference,
+ * unchanged, when the drag doesn't resolve to a valid source/destination — callers can use that
+ * to skip a state update.
+ *
+ * `geometry` resolves cross-column drops that land on a card or gap with more than one possible
+ * position (see the two branches below for what each one decides).
+ */
+export declare function moveItem(columns: KanbanColumnDef[], activeItemId: string, overId: string, geometry: DragGeometry): KanbanColumnDef[];
+/**
+ * Builds screen-reader drag announcements against the columns layout as currently understood
+ * (the live shadow layout while a drag is in progress, or the settled `columns` prop otherwise).
+ */
+export declare function buildAnnouncements<T>(columns: KanbanColumnDef[], items: Record<string, T>, getItemLabel: (item: T, id: string) => string): Announcements;
+/**
+ * Custom keyboard coordinate getter for the board's multi-column, multi-`SortableContext`
+ * layout. dnd-kit's default `sortableKeyboardCoordinates` picks the geometrically closest
+ * droppable across the *entire* board — cards and column containers alike — which is unreliable
+ * once cards live inside independent per-column `SortableContext`s: up/down and left/right end up
+ * interchangeable depending on incidental rect positions. This instead restricts up/down to
+ * reordering within the active card's own column, and left/right to moving into the adjacent
+ * column (landing on the closest card there by vertical position, or the column itself when
+ * empty). Requires each `KanbanColumn`'s `SortableContext` to be given an explicit `id` matching
+ * its column id, so a card's `sortable.containerId` can be correlated with its `column-<id>`
+ * droppable.
+ */
+export declare const kanbanKeyboardCoordinateGetter: KeyboardCoordinateGetter;

package/dist/cjs-types/common/klipyPicker/components/gifPreview/gifPreview.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from 'react';
+import { GifPreviewProps } from './gifPreview.types.js';
+export default function GifPreview({ className, previewItems, onSelect, onLoadAdditional, }: GifPreviewProps): ReactElement;

package/dist/cjs-types/common/klipyPicker/components/gifPreview/gifPreview.types.d.ts

@@ -0,0 +1,7 @@
+import { KlipyResult } from '../../../../services/klipy.js';
+export interface GifPreviewProps {
+    className?: string;
+    previewItems?: KlipyResult[];
+    onSelect?: (preview: KlipyResult) => void;
+    onLoadAdditional?: () => void;
+}

package/dist/cjs-types/common/klipyPicker/components/gifPreview/index.d.ts

@@ -0,0 +1 @@
+export { default } from './gifPreview.js';

package/dist/cjs-types/common/klipyPicker/components/gifView/gifView.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from 'react';
+import { GifViewProps } from './gifView.types.js';
+export default function GifView({ className, src }: GifViewProps): ReactElement;

package/dist/cjs-types/common/klipyPicker/components/gifView/gifView.types.d.ts

@@ -0,0 +1,4 @@
+export interface GifViewProps {
+    className?: string;
+    src?: string;
+}

package/dist/cjs-types/common/klipyPicker/components/gifView/index.d.ts

@@ -0,0 +1 @@
+export { default } from './gifView.js';

package/dist/cjs-types/common/klipyPicker/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './klipyPicker.js';
+export * from './klipyPicker.types.js';

package/dist/cjs-types/common/klipyPicker/klipyPicker.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from 'react';
+import { KlipyPickerProps } from './klipyPicker.types.js';
+export default function KlipyPicker({ className, token, isModal, onSelect, selected, labels, }: KlipyPickerProps): ReactElement;

package/dist/cjs-types/common/klipyPicker/klipyPicker.types.d.ts

@@ -0,0 +1,15 @@
+import { KlipyResult } from '../../services/klipy.js';
+/** Text KlipyPicker renders of its own, for translating it. */
+export interface KlipyPickerLabels {
+    /** Floating label on the search field. */
+    search?: string;
+}
+export interface KlipyPickerProps {
+    className?: string;
+    token?: string;
+    isModal?: boolean;
+    onSelect?: (preview: KlipyResult | null) => void | Promise<void>;
+    selected?: string | null;
+    /** Overrides the text KlipyPicker renders of its own. Merged per key. */
+    labels?: KlipyPickerLabels;
+}

package/dist/cjs-types/common/loading/iconLoading/iconLoading.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+declare function IconLoading({ className }: {
+    className?: string | undefined;
+}): React.JSX.Element;
+export default IconLoading;

package/dist/cjs-types/common/loading/iconLoading/index.d.ts

@@ -0,0 +1,2 @@
+import { default as IconLoading } from './iconLoading.js';
+export default IconLoading;

package/dist/cjs-types/common/loading/index.d.ts

@@ -0,0 +1,2 @@
+export { default as IconLoading } from './iconLoading/index.js';
+export { default as SpinnerLoading } from './spinnerLoading/index.js';

package/dist/cjs-types/common/loading/spinnerLoading/index.d.ts

@@ -0,0 +1,2 @@
+import { default as SpinnerLoading } from './spinnerLoading.js';
+export default SpinnerLoading;

package/dist/cjs-types/common/loading/spinnerLoading/spinnerLoading.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement } from 'react';
+interface Properties {
+    className?: string | undefined;
+}
+declare function SpinnerLoading({ className }: Properties): ReactElement;
+export default SpinnerLoading;

package/dist/cjs-types/common/maskedInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './maskedInput.js';
+export * from './maskedInput.types.js';