@stll/ui 0.26.3 → 0.26.5

package/dist/kanban/matrix.d.ts

@@ -1,32 +1,32 @@
 import { KanbanGroup, KanbanGrouping } from "./grouping.js";
 //#region src/kanban/matrix.d.ts
 /** Which axis of a board a grouping controls. */
-declare const KANBAN_BOARD_AXES: {
+export declare const KANBAN_BOARD_AXES: {
   readonly group: "group";
   readonly subgroup: "subgroup";
 };
-type KanbanBoardAxis = (typeof KANBAN_BOARD_AXES)[keyof typeof KANBAN_BOARD_AXES];
+export type KanbanBoardAxis = (typeof KANBAN_BOARD_AXES)[keyof typeof KANBAN_BOARD_AXES];
 /** The optional horizontal swimlane dimension is intentionally explicit. */
-type KanbanBoardLane = {
+export type KanbanBoardLane = {
   type: "none";
 } | {
   group: KanbanGroup;
   type: "group";
 };
-type KanbanBoardCoordinate = {
+export type KanbanBoardCoordinate = {
   column: KanbanBoardColumn;
   lane: KanbanBoardLane;
 };
-type KanbanBoardCell<TRow> = {
+export type KanbanBoardCell<TRow> = {
   coordinate: KanbanBoardCoordinate;
   rows: TRow[];
 };
 /** A non-grouping destination rendered as a terminal board column. */
-type KanbanBoardDestination = {
+export type KanbanBoardDestination = {
   id: string;
   label: string;
 };
-type KanbanBoardColumn = {
+export type KanbanBoardColumn = {
   group: KanbanGroup;
   type: "group";
 } | {
@@ -38,17 +38,17 @@ type KanbanBoardColumn = {
  * of it, but it must not derive cards independently: every board row is in
  * exactly one cell here before that presentation step.
  */
-type KanbanBoardMatrix<TRow> = {
+export type KanbanBoardMatrix<TRow> = {
   cells: KanbanBoardCell<TRow>[];
   columns: KanbanBoardColumn[];
   lanes: KanbanBoardLane[];
   rows: TRow[];
 };
-type ResolveKanbanGroupValueParams<TRow, TProperty, TGroupId extends string = string> = {
+export type ResolveKanbanGroupValueParams<TRow, TProperty, TGroupId extends string = string> = {
   grouping: KanbanGrouping<TRow, TProperty, TGroupId>;
   row: TRow;
 };
-type BuildKanbanBoardMatrixParams<TRow, TProperty, TGroupId extends string = string> = {
+export type BuildKanbanBoardMatrixParams<TRow, TProperty, TGroupId extends string = string> = {
   /** The vertical board columns. This must be a renderable grouping. */
   group: KanbanGrouping<TRow, TProperty, TGroupId>;
   /** Optional horizontal swimlanes. `none` makes this a one-lane board. */
@@ -59,29 +59,29 @@ type BuildKanbanBoardMatrixParams<TRow, TProperty, TGroupId extends string = str
   uncategorizedLabel: string;
   resolveGroupValue: (params: ResolveKanbanGroupValueParams<TRow, TProperty, TGroupId>) => string | null;
 };
-type OrderKanbanCellsByColumnsParams<TRow> = {
+export type OrderKanbanCellsByColumnsParams<TRow> = {
   cells: readonly KanbanBoardCell<TRow>[];
   columns: readonly KanbanBoardColumn[];
 };
 /** Stable identity for a visible board column; group and destination domains stay distinct. */
-declare const getKanbanBoardColumnIdentity: (column: KanbanBoardColumn) => string;
+export declare const getKanbanBoardColumnIdentity: (column: KanbanBoardColumn) => string;
 /** Stable identity for a swimlane; it can never alias a visible column. */
-declare const getKanbanBoardLaneIdentity: (lane: KanbanBoardLane) => string;
+export declare const getKanbanBoardLaneIdentity: (lane: KanbanBoardLane) => string;
 /** Apply the visible header order to any lane's cells. */
-declare const orderKanbanCellsByColumns: <TRow>({ cells, columns }: OrderKanbanCellsByColumnsParams<TRow>) => KanbanBoardCell<TRow>[];
+export declare const orderKanbanCellsByColumns: <TRow>({ cells, columns }: OrderKanbanCellsByColumnsParams<TRow>) => KanbanBoardCell<TRow>[];
 /**
  * Resolve the board's one source of placement truth.
  *
  * A subgroup never filters the primary board scope. A row outside a subgroup's
  * declared values goes to its explicit No value lane, rather than disappearing.
  */
-declare const buildKanbanBoardMatrix: <TRow, TProperty, TGroupId extends string = string>({ group, subgroup, destinations, rows, uncategorizedLabel, resolveGroupValue }: BuildKanbanBoardMatrixParams<TRow, TProperty, TGroupId>) => KanbanBoardMatrix<TRow>;
-type KanbanDropAxisChange<TGroupId extends string = string> = {
+export declare const buildKanbanBoardMatrix: <TRow, TProperty, TGroupId extends string = string>({ group, subgroup, destinations, rows, uncategorizedLabel, resolveGroupValue }: BuildKanbanBoardMatrixParams<TRow, TProperty, TGroupId>) => KanbanBoardMatrix<TRow>;
+export type KanbanDropAxisChange<TGroupId extends string = string> = {
   groupBy: TGroupId;
   value: string | null;
 };
 /** A complete, atomic move request for a domain mutation adapter. */
-type KanbanDropIntent<TCardId, TGroupId extends string = string> = {
+export type KanbanDropIntent<TCardId, TGroupId extends string = string> = {
   cardId: TCardId;
   changes: readonly [KanbanDropAxisChange<TGroupId>, ...KanbanDropAxisChange<TGroupId>[]];
   type: "move";
@@ -90,7 +90,7 @@ type KanbanDropIntent<TCardId, TGroupId extends string = string> = {
   destination: KanbanBoardDestination;
   type: "destination";
 };
-type CreateKanbanDropIntentParams<TRow, TProperty, TCardId, TGroupId extends string = string> = {
+export type CreateKanbanDropIntentParams<TRow, TProperty, TCardId, TGroupId extends string = string> = {
   cardId: TCardId;
   group: KanbanGrouping<TRow, TProperty, TGroupId>;
   source: KanbanBoardCoordinate;
@@ -102,6 +102,5 @@ type CreateKanbanDropIntentParams<TRow, TProperty, TCardId, TGroupId extends str
  * Diagonal drops carry both changes together; an adapter must commit this
  * intent atomically or reject it as a whole.
  */
-declare const createKanbanDropIntent: <TRow, TProperty, TCardId, TGroupId extends string = string>({ cardId, group, source, subgroup, target }: CreateKanbanDropIntentParams<TRow, TProperty, TCardId, TGroupId>) => KanbanDropIntent<TCardId, TGroupId> | null;
-//#endregion
-export { BuildKanbanBoardMatrixParams, CreateKanbanDropIntentParams, KANBAN_BOARD_AXES, KanbanBoardAxis, KanbanBoardCell, KanbanBoardColumn, KanbanBoardCoordinate, KanbanBoardDestination, KanbanBoardLane, KanbanBoardMatrix, KanbanDropAxisChange, KanbanDropIntent, OrderKanbanCellsByColumnsParams, ResolveKanbanGroupValueParams, buildKanbanBoardMatrix, createKanbanDropIntent, getKanbanBoardColumnIdentity, getKanbanBoardLaneIdentity, orderKanbanCellsByColumns };
+export declare const createKanbanDropIntent: <TRow, TProperty, TCardId, TGroupId extends string = string>({ cardId, group, source, subgroup, target }: CreateKanbanDropIntentParams<TRow, TProperty, TCardId, TGroupId>) => KanbanDropIntent<TCardId, TGroupId> | null;
+//#endregion

package/dist/kanban/sortable-edge.d.ts

@@ -1,15 +1,15 @@
 import { ClientRect } from "@dnd-kit/core";
 //#region src/kanban/sortable-edge.d.ts
-declare const KANBAN_HORIZONTAL_EDGES: {
+export declare const KANBAN_HORIZONTAL_EDGES: {
   readonly before: "before";
   readonly after: "after";
 };
-type KanbanHorizontalEdge = (typeof KANBAN_HORIZONTAL_EDGES)[keyof typeof KANBAN_HORIZONTAL_EDGES];
-declare const KANBAN_DIRECTIONS: {
+export type KanbanHorizontalEdge = (typeof KANBAN_HORIZONTAL_EDGES)[keyof typeof KANBAN_HORIZONTAL_EDGES];
+export declare const KANBAN_DIRECTIONS: {
   readonly ltr: "ltr";
   readonly rtl: "rtl";
 };
-type KanbanDirection = (typeof KANBAN_DIRECTIONS)[keyof typeof KANBAN_DIRECTIONS];
+export type KanbanDirection = (typeof KANBAN_DIRECTIONS)[keyof typeof KANBAN_DIRECTIONS];
 type KanbanPointerHorizontalEdgeOptions = {
   input: "pointer";
   /** The drag's current viewport x coordinate for mouse or touch input. */
@@ -25,7 +25,7 @@ type KanbanKeyboardHorizontalEdgeOptions = {
   /** The target item's position in logical board order. */
   targetIndex: number;
 };
-type KanbanHorizontalEdgeOptions = KanbanPointerHorizontalEdgeOptions | KanbanKeyboardHorizontalEdgeOptions;
+export type KanbanHorizontalEdgeOptions = KanbanPointerHorizontalEdgeOptions | KanbanKeyboardHorizontalEdgeOptions;
 /**
  * Resolves a horizontal insertion edge without consulting application data.
  *
@@ -34,6 +34,5 @@ type KanbanHorizontalEdgeOptions = KanbanPointerHorizontalEdgeOptions | KanbanKe
  * unambiguous. This deliberately avoids drag deltas, which include scroll
  * reconciliation and are not viewport coordinates.
  */
-declare const getKanbanHorizontalEdge: ({ ...options }: KanbanHorizontalEdgeOptions) => KanbanHorizontalEdge;
-//#endregion
-export { KANBAN_DIRECTIONS, KANBAN_HORIZONTAL_EDGES, KanbanDirection, KanbanHorizontalEdge, KanbanHorizontalEdgeOptions, getKanbanHorizontalEdge };
+export declare const getKanbanHorizontalEdge: ({ ...options }: KanbanHorizontalEdgeOptions) => KanbanHorizontalEdge;
+//#endregion

package/dist/kanban/sortable-interactions.d.ts

@@ -4,10 +4,10 @@ import * as React$1 from "react";
 import { AutoScrollActivator, AutoScrollOptions, CollisionDetection, DndContextProps, DragCancelEvent, DragEndEvent, DragOverEvent, DragOverlayProps, DragStartEvent, KeyboardCoordinateGetter, UniqueIdentifier } from "@dnd-kit/core";
 import { SortableContextProps, useSortable } from "@dnd-kit/sortable";
 //#region src/kanban/sortable-interactions.d.ts
-declare const KANBAN_MOUSE_ACTIVATION_DISTANCE = 8;
+export declare const KANBAN_MOUSE_ACTIVATION_DISTANCE = 8;
 /** Above sticky board chrome, below app-level floating surfaces. */
-declare const KANBAN_DRAG_OVERLAY_Z_INDEX = 75;
-declare const KANBAN_BOARD_AUTO_SCROLL_OPTIONS: {
+export declare const KANBAN_DRAG_OVERLAY_Z_INDEX = 75;
+export declare const KANBAN_BOARD_AUTO_SCROLL_OPTIONS: {
   readonly acceleration: 10;
   readonly activator: AutoScrollActivator.Pointer;
   readonly threshold: {
@@ -15,20 +15,20 @@ declare const KANBAN_BOARD_AUTO_SCROLL_OPTIONS: {
     readonly y: 0.15;
   };
 };
-declare const KANBAN_SORTABLE_ACTIVATION_MODES: {
+export declare const KANBAN_SORTABLE_ACTIVATION_MODES: {
   readonly CARD: "card";
   readonly HANDLE: "handle";
   readonly ITEM: "item";
 };
-declare const KANBAN_TOUCH_ACTIVATION_CONSTRAINT: {
+export declare const KANBAN_TOUCH_ACTIVATION_CONSTRAINT: {
   readonly delay: 150;
   readonly tolerance: 8;
 };
-type KanbanDragCancelEvent = DragCancelEvent;
-type KanbanDragEndEvent = DragEndEvent;
-type KanbanDragOverEvent = DragOverEvent;
-type KanbanDragStartEvent = DragStartEvent;
-type KanbanSortableBoardProps = {
+export type KanbanDragCancelEvent = DragCancelEvent;
+export type KanbanDragEndEvent = DragEndEvent;
+export type KanbanDragOverEvent = DragOverEvent;
+export type KanbanDragStartEvent = DragStartEvent;
+export type KanbanSortableBoardProps = {
   children: React$1.ReactNode;
   onDragEnd: (event: KanbanDragEndEvent) => void;
   /** Minimum pointer movement before a mouse drag activates. */
@@ -61,7 +61,7 @@ type KanbanSortableBoardProps = {
   overlay?: ((activeId: UniqueIdentifier | null) => React$1.ReactNode) | undefined;
   overlayProps?: Omit<DragOverlayProps, "children"> | undefined;
 };
-type UseKanbanDropTargetOptions = {
+export type UseKanbanDropTargetOptions = {
   disabled?: boolean | undefined;
   id: string;
   itemIds: readonly UniqueIdentifier[];
@@ -75,7 +75,7 @@ type UseKanbanDropTargetOptions = {
  * underlying drag-and-drop library just to receive an item from a sortable
  * context.
  */
-declare const useKanbanDropTarget: ({ disabled, id, itemIds, navigation, position }: UseKanbanDropTargetOptions) => {
+export declare const useKanbanDropTarget: ({ disabled, id, itemIds, navigation, position }: UseKanbanDropTargetOptions) => {
   isOver: boolean;
   setNodeRef: (element: HTMLElement | null) => void;
 };
@@ -86,23 +86,23 @@ declare const useKanbanDropTarget: ({ disabled, id, itemIds, navigation, positio
  * the sensor activation rules, keyboard navigation, auto-scroll configuration,
  * and overlay lifecycle shared by sortable board UIs.
  */
-declare const KanbanSortableBoard: ({ children, onDragEnd, mouseActivationDistance, collisionDetection, keyboardCoordinates, autoScroll, sensors, accessibility, onDragStart, onDragOver, onDragCancel, onInteractionReady, overlay, overlayProps }: KanbanSortableBoardProps) => React$1.JSX.Element;
-declare const useKanbanSortableSensors: (keyboardCoordinates?: KeyboardCoordinateGetter, mouseActivationDistance?: number) => import("@dnd-kit/core").SensorDescriptor<import("@dnd-kit/core").SensorOptions>[];
-type KanbanSortableListProps = SortableContextProps & React$1.ComponentProps<"div">;
+export declare const KanbanSortableBoard: ({ children, onDragEnd, mouseActivationDistance, collisionDetection, keyboardCoordinates, autoScroll, sensors, accessibility, onDragStart, onDragOver, onDragCancel, onInteractionReady, overlay, overlayProps }: KanbanSortableBoardProps) => React$1.JSX.Element;
+export declare const useKanbanSortableSensors: (keyboardCoordinates?: KeyboardCoordinateGetter, mouseActivationDistance?: number) => import("@dnd-kit/core").SensorDescriptor<import("@dnd-kit/core").SensorOptions>[];
+export type KanbanSortableListProps = SortableContextProps & React$1.ComponentProps<"div">;
 /** A vertical card list that preserves native vertical touch scrolling. */
-declare const KanbanSortableList: ({ className, children, id, items, strategy, disabled, ...props }: KanbanSortableListProps) => React$1.JSX.Element;
-type KanbanSortableColumnsProps = SortableContextProps & React$1.ComponentProps<"div">;
+export declare const KanbanSortableList: ({ className, children, id, items, strategy, disabled, ...props }: KanbanSortableListProps) => React$1.JSX.Element;
+export type KanbanSortableColumnsProps = SortableContextProps & React$1.ComponentProps<"div">;
 /** A horizontal column list that keeps the board pan gesture available. */
-declare const KanbanSortableColumns: ({ className, children, id, items, strategy, disabled, ...props }: KanbanSortableColumnsProps) => React$1.JSX.Element;
-type KanbanSortableBindings = Pick<ReturnType<typeof useSortable>, "attributes" | "listeners" | "setActivatorNodeRef">;
-type KanbanSortableActivationMode = {
+export declare const KanbanSortableColumns: ({ className, children, id, items, strategy, disabled, ...props }: KanbanSortableColumnsProps) => React$1.JSX.Element;
+export type KanbanSortableBindings = Pick<ReturnType<typeof useSortable>, "attributes" | "listeners" | "setActivatorNodeRef">;
+export type KanbanSortableActivationMode = {
   type: "card";
 } | {
   type: "handle";
 } | {
   type: "item";
 };
-type UseKanbanSortableOptions = {
+export type UseKanbanSortableOptions = {
   activation: KanbanSortableActivationMode;
   id: UniqueIdentifier;
   disabled?: boolean | undefined;
@@ -122,7 +122,7 @@ type KanbanSortableActivator = {
  * Connect a sortable item and its separate drag handle without making the
  * item's content a touch-none activation surface.
  */
-declare const useKanbanSortable: ({ activation, id, disabled }: UseKanbanSortableOptions) => {
+export declare const useKanbanSortable: ({ activation, id, disabled }: UseKanbanSortableOptions) => {
   activator: KanbanSortableActivator;
   isDragging: boolean;
   setNodeRef: (element: HTMLElement | null) => void;
@@ -132,7 +132,7 @@ declare const useKanbanSortable: ({ activation, id, disabled }: UseKanbanSortabl
     transition: string | undefined;
   };
 };
-type KanbanDragHandleProps = {
+export type KanbanDragHandleProps = {
   bindings: KanbanSortableBindings;
   label: string;
 } & Omit<React$1.ComponentProps<typeof Button>, "aria-label" | "children" | "ref" | "tooltip" | "type">;
@@ -141,11 +141,11 @@ type KanbanDragHandleProps = {
  * surface that disables touch panning, leaving cards and scroll regions free
  * for ordinary scrolling.
  */
-declare const KanbanDragHandle: ({ bindings, label, className, ...props }: KanbanDragHandleProps) => React$1.JSX.Element;
-type KanbanCardDragSurfaceProps = {
+export declare const KanbanDragHandle: ({ bindings, label, className, ...props }: KanbanDragHandleProps) => React$1.JSX.Element;
+export type KanbanCardDragSurfaceProps = {
   bindings: KanbanSortableBindings;
 } & Omit<React$1.ComponentProps<"div">, "ref">;
 /** A whole-card drag activator that preserves descendant controls and scrolling. */
-declare const KanbanCardDragSurface: ({ bindings, className, ...props }: KanbanCardDragSurfaceProps) => React$1.JSX.Element;
+export declare const KanbanCardDragSurface: ({ bindings, className, ...props }: KanbanCardDragSurfaceProps) => React$1.JSX.Element;
 //#endregion
-export { KANBAN_BOARD_AUTO_SCROLL_OPTIONS, KANBAN_BOARD_COLLISION_DETECTION, KANBAN_DRAG_OVERLAY_Z_INDEX, KANBAN_MOUSE_ACTIVATION_DISTANCE, KANBAN_SORTABLE_ACTIVATION_MODES, KANBAN_TOUCH_ACTIVATION_CONSTRAINT, KanbanCardDragSurface, KanbanCardDragSurfaceProps, type KanbanCellVirtualNavigation, KanbanDragCancelEvent, KanbanDragEndEvent, KanbanDragHandle, KanbanDragHandleProps, KanbanDragOverEvent, KanbanDragStartEvent, KanbanSortableActivationMode, KanbanSortableBindings, KanbanSortableBoard, KanbanSortableBoardProps, type KanbanSortableCellPosition, KanbanSortableColumns, KanbanSortableColumnsProps, KanbanSortableList, KanbanSortableListProps, type KanbanVirtualScrollRequest, UseKanbanDropTargetOptions, UseKanbanSortableOptions, kanbanKeyboardCoordinates, useKanbanDropTarget, useKanbanSortable, useKanbanSortableSensors };
+export { KANBAN_BOARD_COLLISION_DETECTION, type KanbanCellVirtualNavigation, type KanbanSortableCellPosition, type KanbanVirtualScrollRequest, kanbanKeyboardCoordinates };

package/dist/kanban/sortable-interactions.logic.d.ts

@@ -1,24 +1,24 @@
 import { CollisionDetection, KeyboardCoordinateGetter, SensorContext, UniqueIdentifier } from "@dnd-kit/core";
 //#region src/kanban/sortable-interactions.logic.d.ts
-declare const KANBAN_DROP_TARGET_TYPES: {
+export declare const KANBAN_DROP_TARGET_TYPES: {
   readonly CELL: "kanban-cell";
   readonly ITEM: "kanban-item";
 };
-type KanbanSortableCellPosition = {
+export type KanbanSortableCellPosition = {
   column: number;
   lane: number;
 };
-type KanbanVirtualScrollRequest = {
+export type KanbanVirtualScrollRequest = {
   itemId: UniqueIdentifier;
   type: "item";
 };
-type KanbanCellVirtualNavigation = {
+export type KanbanCellVirtualNavigation = {
   type: "static";
 } | {
   requestScroll: (request: KanbanVirtualScrollRequest) => void;
   type: "virtual";
 };
-type KanbanCellDropData = {
+export type KanbanCellDropData = {
   itemIds: readonly UniqueIdentifier[];
   navigation: KanbanCellVirtualNavigation;
   position: KanbanSortableCellPosition;
@@ -33,7 +33,7 @@ type KanbanKeyboardTargetState = {
   targetId: UniqueIdentifier;
   type: "ready";
 };
-type KanbanItemDropData = {
+export type KanbanItemDropData = {
   navigation: {
     current: KanbanKeyboardTargetState;
   };
@@ -42,8 +42,8 @@ type KanbanItemDropData = {
 type NavigationCell = KanbanCellDropData & {
   id: UniqueIdentifier;
 };
-declare const isKanbanCellDropData: (value: unknown) => value is KanbanCellDropData;
-declare const getKanbanKeyboardTargetState: (value: unknown) => KanbanKeyboardTargetState | undefined;
+export declare const isKanbanCellDropData: (value: unknown) => value is KanbanCellDropData;
+export declare const getKanbanKeyboardTargetState: (value: unknown) => KanbanKeyboardTargetState | undefined;
 /**
  * dnd-kit computes collisions while rendering but publishes the resulting drop
  * target to its sensor context a render later, and resolves a drop from that
@@ -57,13 +57,13 @@ declare const getKanbanKeyboardTargetState: (value: unknown) => KanbanKeyboardTa
  * is the published target. Until then both the collisions and the published
  * target still describe where the board was before the user navigated away.
  */
-declare const isKanbanDropSettled: ({ active, collisions, over }: Pick<SensorContext, "active" | "collisions" | "over">) => boolean;
-declare const clearKanbanKeyboardTarget: (value: unknown) => void;
+export declare const isKanbanDropSettled: ({ active, collisions, over }: Pick<SensorContext, "active" | "collisions" | "over">) => boolean;
+export declare const clearKanbanKeyboardTarget: (value: unknown) => void;
 /**
  * Pointer and touch input must be inside a registered board target. Once that
  * boundary is established, closest corners gives stable ranking across cells.
  */
-declare const KANBAN_BOARD_COLLISION_DETECTION: CollisionDetection;
+export declare const KANBAN_BOARD_COLLISION_DETECTION: CollisionDetection;
 type NavigationDirection = "down" | "left" | "right" | "up";
 type GetKeyboardTargetOptions = {
   activeId: UniqueIdentifier;
@@ -72,8 +72,7 @@ type GetKeyboardTargetOptions = {
   currentOverId: UniqueIdentifier;
   direction: NavigationDirection;
 };
-declare const getKanbanKeyboardTarget: ({ activeId, cells, currentCellId, currentOverId, direction }: GetKeyboardTargetOptions) => UniqueIdentifier | undefined;
+export declare const getKanbanKeyboardTarget: ({ activeId, cells, currentCellId, currentOverId, direction }: GetKeyboardTargetOptions) => UniqueIdentifier | undefined;
 /** Ordered two-dimensional navigation over item and empty-cell targets. */
-declare const kanbanKeyboardCoordinates: KeyboardCoordinateGetter;
-//#endregion
-export { KANBAN_BOARD_COLLISION_DETECTION, KANBAN_DROP_TARGET_TYPES, KanbanCellDropData, KanbanCellVirtualNavigation, KanbanItemDropData, KanbanSortableCellPosition, KanbanVirtualScrollRequest, clearKanbanKeyboardTarget, getKanbanKeyboardTarget, getKanbanKeyboardTargetState, isKanbanCellDropData, isKanbanDropSettled, kanbanKeyboardCoordinates };
+export declare const kanbanKeyboardCoordinates: KeyboardCoordinateGetter;
+//#endregion

package/dist/kanban/sticky-lane.d.ts

@@ -9,14 +9,14 @@ import { CSSProperties, ReactNode } from "react";
  * reaches in this custom property; a control sticks at that offset and
  * releases where its lane ends, because the lane's own box is what bounds it.
  */
-declare const KANBAN_STICKY_TOP_VAR: "--kanban-sticky-top";
+export declare const KANBAN_STICKY_TOP_VAR: "--kanban-sticky-top";
 /**
  * Sticks a lane control just under the board's header. The fallback keeps a
  * control usable outside a board that publishes the offset, and inside a cell
  * that keeps its own scroll surface, where the board's header is irrelevant.
  */
-declare const KANBAN_STICKY_TOP_CLASS = "top-(--kanban-sticky-top,0px)";
-type KanbanStickyTopStyle = CSSProperties & {
+export declare const KANBAN_STICKY_TOP_CLASS = "top-(--kanban-sticky-top,0px)";
+export type KanbanStickyTopStyle = CSSProperties & {
   [KANBAN_STICKY_TOP_VAR]?: string;
 };
 /**
@@ -27,14 +27,14 @@ type KanbanStickyTopStyle = CSSProperties & {
  * publishes it on each row it renders, because only the cell knows how tall its
  * own pinned action turned out and how far it translated that row.
  */
-declare const KANBAN_CARD_STICKY_TOP_VAR: "--kanban-card-sticky-top";
+export declare const KANBAN_CARD_STICKY_TOP_VAR: "--kanban-card-sticky-top";
 /**
  * Sticks a card's identity row under everything pinned above it. The fallback
  * keeps the row usable inside a card rendered outside a cell that publishes the
  * offset, where nothing is pinned above it at all.
  */
-declare const KANBAN_CARD_STICKY_TOP_CLASS = "top-(--kanban-card-sticky-top,0px)";
-type KanbanCardStickyTopStyle = CSSProperties & {
+export declare const KANBAN_CARD_STICKY_TOP_CLASS = "top-(--kanban-card-sticky-top,0px)";
+export type KanbanCardStickyTopStyle = CSSProperties & {
   [KANBAN_CARD_STICKY_TOP_VAR]?: string;
 };
 type ResolveKanbanCardStickyTopOptions = {
@@ -53,8 +53,8 @@ type ResolveKanbanCardStickyTopOptions = {
  * offset in the space the browser actually resolves it in, so every card pins
  * where the chrome above it ends no matter how far down the lane it is.
  */
-declare const resolveKanbanCardStickyTop: ({ pinnedAbove, rowOffset }: ResolveKanbanCardStickyTopOptions) => string;
-type KanbanCollapsedBandCaptionProps = {
+export declare const resolveKanbanCardStickyTop: ({ pinnedAbove, rowOffset }: ResolveKanbanCardStickyTopOptions) => string;
+export type KanbanCollapsedBandCaptionProps = {
   label: string;
   /** What the folded band stands in for: its count, already formatted. */
   meta: ReactNode;
@@ -69,6 +69,5 @@ type KanbanCollapsedBandCaptionProps = {
  * height (`h-full`), or a caption as tall as its own text can never move.
  * A host rendering its own collapsed cell composes this inside that cell.
  */
-declare const KanbanCollapsedBandCaption: ({ className, label, meta }: KanbanCollapsedBandCaptionProps) => import("react").JSX.Element;
-//#endregion
-export { KANBAN_CARD_STICKY_TOP_CLASS, KANBAN_CARD_STICKY_TOP_VAR, KANBAN_STICKY_TOP_CLASS, KANBAN_STICKY_TOP_VAR, KanbanCardStickyTopStyle, KanbanCollapsedBandCaption, KanbanCollapsedBandCaptionProps, KanbanStickyTopStyle, resolveKanbanCardStickyTop };
+export declare const KanbanCollapsedBandCaption: ({ className, label, meta }: KanbanCollapsedBandCaptionProps) => import("react").JSX.Element;
+//#endregion

package/dist/kanban/subgroup-board.d.ts

@@ -3,26 +3,26 @@ import { KanbanColumnBand, KanbanGroup } from "./grouping.js";
 import { KanbanBoardCell, KanbanBoardColumn, KanbanBoardMatrix } from "./matrix.js";
 import { ReactNode } from "react";
 //#region src/kanban/subgroup-board.d.ts
-type KanbanSubgroupColumnHeaderContext = {
+export type KanbanSubgroupColumnHeaderContext = {
   column: KanbanBoardColumn;
   count: number;
 };
-type KanbanSubgroupLaneIdentityContext = {
+export type KanbanSubgroupLaneIdentityContext = {
   group: KanbanGroup;
   count: number;
 };
 /** One column's cell in a lane's own row, and what that cell stands for. */
-type KanbanSubgroupLaneColumnSummaryContext = {
+export type KanbanSubgroupLaneColumnSummaryContext = {
   lane: KanbanGroup;
   column: KanbanBoardColumn;
   /** Rows in this lane/column intersection, including zero. */
   count: number;
 };
-type KanbanSubgroupLaneColumnActionContext = {
+export type KanbanSubgroupLaneColumnActionContext = {
   lane: KanbanGroup;
   column: KanbanBoardColumn;
 };
-type KanbanSubgroupCellContext<TRow> = {
+export type KanbanSubgroupCellContext<TRow> = {
   cell: KanbanBoardCell<TRow>;
   /** Number of rows in this lane/column intersection, including zero. */
   count: number;
@@ -34,7 +34,7 @@ type KanbanSubgroupCellContext<TRow> = {
    */
   band: KanbanColumnBand | null;
 };
-type KanbanSubgroupBandHeaderContext = {
+export type KanbanSubgroupBandHeaderContext = {
   band: KanbanColumnBand;
   columns: KanbanBoardColumn[];
   /** Rows across the band's columns, every lane included. */
@@ -59,7 +59,7 @@ type KanbanSubgroupBandHeaderContext = {
  * register the slot as a drop target that lands in the band's first column
  * (or asks which), and the count it stands in for.
  */
-type KanbanSubgroupCollapsedBandCellContext<TRow> = {
+export type KanbanSubgroupCollapsedBandCellContext<TRow> = {
   band: KanbanColumnBand;
   cells: KanbanBoardCell<TRow>[];
   count: number;
@@ -72,7 +72,7 @@ type KanbanSubgroupCollapseControl = {
   isLaneCollapsed: (group: KanbanGroup, count: number) => boolean;
   onLaneCollapsedChange: (group: KanbanGroup, collapsed: boolean) => void;
 };
-type KanbanSubgroupBoardProps<TRow> = {
+export type KanbanSubgroupBoardProps<TRow> = {
   matrix: KanbanBoardMatrix<TRow>;
   renderColumnHeader: (context: KanbanSubgroupColumnHeaderContext) => ReactNode;
   renderLaneIdentity: (context: KanbanSubgroupLaneIdentityContext) => ReactNode;
@@ -152,6 +152,5 @@ type KanbanSubgroupBoardProps<TRow> = {
  * in every state; the caption line never grows past its own height, so a
  * folded band costs no vertical space.
  */
-declare const KanbanSubgroupBoard: <TRow>({ matrix, renderColumnHeader, renderLaneIdentity, renderCell, renderLaneColumnSummary, renderLaneColumnAction, renderBandHeader, renderCollapsedBandCell, formatBandToggleLabel, formatCount, isLaneCollapsed, onLaneCollapsedChange, isBandCollapsed, onBandCollapsedChange, footer, className, dragOverBandId, isDragging }: KanbanSubgroupBoardProps<TRow>) => import("react").JSX.Element;
-//#endregion
-export { KanbanSubgroupBandHeaderContext, KanbanSubgroupBoard, KanbanSubgroupBoardProps, KanbanSubgroupCellContext, KanbanSubgroupCollapsedBandCellContext, KanbanSubgroupColumnHeaderContext, KanbanSubgroupLaneColumnActionContext, KanbanSubgroupLaneColumnSummaryContext, KanbanSubgroupLaneIdentityContext };
+export declare const KanbanSubgroupBoard: <TRow>({ matrix, renderColumnHeader, renderLaneIdentity, renderCell, renderLaneColumnSummary, renderLaneColumnAction, renderBandHeader, renderCollapsedBandCell, formatBandToggleLabel, formatCount, isLaneCollapsed, onLaneCollapsedChange, isBandCollapsed, onBandCollapsedChange, footer, className, dragOverBandId, isDragging }: KanbanSubgroupBoardProps<TRow>) => import("react").JSX.Element;
+//#endregion

package/dist/kanban/subgroup-board.js

@@ -74,10 +74,14 @@ const KanbanSubgroupBoard = ({ matrix, renderColumnHeader, renderLaneIdentity, r
 		if (dragOverBandId === void 0 || dragOverBandId === previousDragOverBandId.current) return;
 		const previous = previousDragOverBandId.current;
 		previousDragOverBandId.current = dragOverBandId;
-		if (previous !== null) if (peekingBandId === previous) peek.openDragLeave(previous);
-		else peek.slotDragLeave(previous);
-		if (dragOverBandId !== null) if (peekingBandId === dragOverBandId) peek.openDragEnter(dragOverBandId);
-		else peek.slotDragOver(dragOverBandId);
+		if (previous !== null) {
+			if (peekingBandId === previous) peek.openDragLeave(previous);
+			else peek.slotDragLeave(previous);
+		}
+		if (dragOverBandId !== null) {
+			if (peekingBandId === dragOverBandId) peek.openDragEnter(dragOverBandId);
+			else peek.slotDragOver(dragOverBandId);
+		}
 	}, [
 		dragOverBandId,
 		peek,

package/dist/kanban/touch-identity.d.ts

@@ -3,6 +3,5 @@ type ActiveTouchChangeOptions = {
   activeTouchIdentifier: number | null;
   changedTouchIdentifiers: readonly number[];
 };
-declare const isActiveTouchChange: ({ activeTouchIdentifier, changedTouchIdentifiers }: ActiveTouchChangeOptions) => boolean;
-//#endregion
-export { isActiveTouchChange };
+export declare const isActiveTouchChange: ({ activeTouchIdentifier, changedTouchIdentifiers }: ActiveTouchChangeOptions) => boolean;
+//#endregion

package/dist/kanban/virtual-cell.d.ts

@@ -4,11 +4,11 @@ import { Key, ReactNode, RefObject } from "react";
 import { UniqueIdentifier } from "@dnd-kit/core";
 import { SortableContextProps, SortingStrategy } from "@dnd-kit/sortable";
 //#region src/kanban/virtual-cell.d.ts
-declare const KANBAN_VIRTUAL_CELL_PAGINATION: {
+export declare const KANBAN_VIRTUAL_CELL_PAGINATION: {
   readonly NONE: "none";
   readonly CURSOR: "cursor";
 };
-type KanbanVirtualCellPagination = {
+export type KanbanVirtualCellPagination = {
   type: "none";
 } | {
   type: "cursor";
@@ -24,13 +24,13 @@ type KanbanVirtualCellPagination = {
  * separate sortable identifier avoids narrowing an existing React key contract
  * merely to support dnd-kit consumers.
  */
-type KanbanVirtualCellSortableContext<TRow> = {
+export type KanbanVirtualCellSortableContext<TRow> = {
   dropTarget: Omit<UseKanbanDropTargetOptions, "itemIds" | "navigation">;
   getRowId: (row: TRow) => UniqueIdentifier;
   disabled?: SortableContextProps["disabled"] | undefined;
   strategy?: SortingStrategy | undefined;
 };
-type KanbanVirtualCellProps<TRow> = {
+export type KanbanVirtualCellProps<TRow> = {
   rows: readonly TRow[];
   getRowKey: (row: TRow) => Key;
   renderRow: (row: TRow) => ReactNode;
@@ -71,6 +71,5 @@ type KanbanVirtualCellProps<TRow> = {
   className?: string | undefined;
 };
 /** Bounded, virtualized Kanban cell with cursor-page request deduplication. */
-declare const KanbanVirtualCell: <TRow>({ rows, getRowKey, renderRow, pagination, sortable, containerRef, active, backgroundColor, accent, footer, footerPlacement, estimateSize, overscan, loadMoreThreshold, className }: KanbanVirtualCellProps<TRow>) => import("react").JSX.Element;
-//#endregion
-export { KANBAN_VIRTUAL_CELL_PAGINATION, KanbanVirtualCell, KanbanVirtualCellPagination, KanbanVirtualCellProps, KanbanVirtualCellSortableContext };
+export declare const KanbanVirtualCell: <TRow>({ rows, getRowKey, renderRow, pagination, sortable, containerRef, active, backgroundColor, accent, footer, footerPlacement, estimateSize, overscan, loadMoreThreshold, className }: KanbanVirtualCellProps<TRow>) => import("react").JSX.Element;
+//#endregion

package/dist/lib/button-disposition.d.ts

@@ -16,21 +16,21 @@ import * as React$1 from "react";
  * (`useFocusableWhenDisabled`): `aria-disabled` instead of `disabled`, focusable,
  * and non-`Tab` key defaults suppressed.
  */
-declare const BUTTON_DISPOSITION: {
+export declare const BUTTON_DISPOSITION: {
   readonly enabled: "enabled";
   /** Native `disabled`: out of the tab order, inert to pointer and keyboard. */
   readonly nativeDisabled: "native-disabled";
   /** `aria-disabled`: focusable and hoverable so its tooltip can still open. */
   readonly accessibleDisabled: "accessible-disabled";
 };
-type ButtonDisposition = (typeof BUTTON_DISPOSITION)[keyof typeof BUTTON_DISPOSITION];
+export type ButtonDisposition = (typeof BUTTON_DISPOSITION)[keyof typeof BUTTON_DISPOSITION];
 type ButtonDispositionInput = {
   disabled: boolean | undefined;
   loading: boolean | undefined;
   /** Resolved tooltip content, i.e. what `renderTooltipTrigger` would mount. */
   tooltip: React$1.ReactNode;
 };
-declare const resolveButtonDisposition: ({ disabled, loading, tooltip }: ButtonDispositionInput) => ButtonDisposition;
+export declare const resolveButtonDisposition: ({ disabled, loading, tooltip }: ButtonDispositionInput) => ButtonDisposition;
 /**
  * The parts of a React synthetic event these blockers touch.
  *
@@ -50,14 +50,13 @@ type BlockableEvent = {
  * implicit submission (Enter in a text field) dispatches a click at the form's
  * default button, so both paths funnel through here.
  */
-declare const blockDisabledActivation: (event: BlockableEvent) => void;
+export declare const blockDisabledActivation: (event: BlockableEvent) => void;
 /**
  * The keyboard counterpart. `Tab` keeps its default so focus can leave the
  * control; suppressing the default on `Enter`/`Space` stops the browser from
  * synthesizing the click that would activate or submit.
  */
-declare const blockDisabledKeyActivation: (event: BlockableEvent & {
+export declare const blockDisabledKeyActivation: (event: BlockableEvent & {
   key: string;
 }) => void;
-//#endregion
-export { BUTTON_DISPOSITION, ButtonDisposition, blockDisabledActivation, blockDisabledKeyActivation, resolveButtonDisposition };
+//#endregion

package/dist/lib/control-size.d.ts

@@ -5,6 +5,6 @@ declare const CONTROL_SIZE: Readonly<{
   readonly lg: "lg";
 }>;
 type ControlSize = (typeof CONTROL_SIZE)[keyof typeof CONTROL_SIZE];
-declare const CONTROL_SIZES: readonly ("default" | "lg" | "sm")[];
+declare const CONTROL_SIZES: readonly ("default" | "sm" | "lg")[];
 //#endregion
 export { CONTROL_SIZE, CONTROL_SIZES, type ControlSize };

package/dist/lib/initials.d.ts

@@ -11,6 +11,5 @@
  *   "王小明" → "王小"
  * - Null / empty: "?"
  */
-declare const getInitials: (name: string | null) => string;
-//#endregion
-export { getInitials };
+export declare const getInitials: (name: string | null) => string;
+//#endregion

package/dist/lib/option-color.d.ts

@@ -13,16 +13,15 @@
  * token was chosen for.
  */
 /** Named preset or arbitrary 6-character hex colour (e.g. "FF0000"). */
-type OptionColor = "red" | "orange" | "amber" | "yellow" | "lime" | "green" | "emerald" | "teal" | "cyan" | "sky" | "blue" | "indigo" | "violet" | "purple" | "fuchsia" | "gray" | (string & Record<never, never>);
-type ColorVariants = {
+export type OptionColor = "red" | "orange" | "amber" | "yellow" | "lime" | "green" | "emerald" | "teal" | "cyan" | "sky" | "blue" | "indigo" | "violet" | "purple" | "fuchsia" | "gray" | (string & Record<never, never>);
+export type ColorVariants = {
   background: string;
   foreground: string;
   color: string;
 };
-declare const emptyColor: ColorVariants;
+export declare const emptyColor: ColorVariants;
 /** Resolve any OptionColor (named or hex) to CSS color variants. */
-declare const resolveOptionColor: (color: OptionColor) => ColorVariants;
+export declare const resolveOptionColor: (color: OptionColor) => ColorVariants;
 /** The 16 named preset color keys. */
-declare const optionColors: readonly OptionColor[];
-//#endregion
-export { ColorVariants, OptionColor, emptyColor, optionColors, resolveOptionColor };
+export declare const optionColors: readonly OptionColor[];
+//#endregion