@danxbot/ui 20.13.2 → 20.15.0

package/dist/types/components/Board.d.ts

@@ -1,5 +1,5 @@
 import { type ReactNode } from "react";
-import type { AutoScrollOptions, DragStrings } from "../lib/dnd";
+import type { AutoScrollOptions, CrossDrop, DragStrings } from "../lib/dnd";
 import type { BoardColumnModel, BoardItemId, UseBoardOptions, UseBoardResult } from "../lib/board";
 import { type BoardReorderLabels } from "./board/context";
 export interface BoardProps<T> extends UseBoardOptions<T> {
@@ -11,6 +11,23 @@ export interface BoardProps<T> extends UseBoardOptions<T> {
      * "Move to bottom".
      */
     reorderLabels?: Partial<BoardReorderLabels>;
+    /**
+     * DX-4583: what dropping a card on ANOTHER lane means.
+     *
+     * `"position"` (the default) is a drop at a place: the lane's cards part, a
+     * marker shows the slot, and the `BoardMove` carries that `index`.
+     *
+     * `"lane"` is a lane change and nothing else, for a board whose lanes are
+     * ordered by something a drop cannot set (a rank the card already has): the
+     * whole lane is highlighted, no marker shows and no card moves, and the
+     * `BoardMove` is `{ columnId, lane: true }` with no position. The card menu's
+     * "Move to <lane>" items send the same move, and the live region says the lane
+     * rather than a position. Inside the card's own lane a drag is still a
+     * positional drop either way. Whether a drag is over "another lane" is read
+     * from the drag session's own `from.container` and `over.container`, never
+     * from card counts.
+     */
+    crossLaneDrop?: CrossDrop;
     /** Forwarded to `DragDrop` — see its own doc; cannot be turned off. */
     autoScroll?: AutoScrollOptions;
     className?: string;
@@ -49,7 +66,7 @@ export interface BoardProps<T> extends UseBoardOptions<T> {
      *  returns. */
     children: (board: UseBoardResult<T>) => ReactNode;
 }
-export declare function Board<T>({ items, columns, accessors, validateMove, onMove, selection, strings, reorderLabels, autoScroll, className, columnsClassName, renderDragging, children, }: BoardProps<T>): import("react").JSX.Element;
+export declare function Board<T>({ items, columns, accessors, validateMove, onMove, selection, strings, reorderLabels, crossLaneDrop, autoScroll, className, columnsClassName, renderDragging, children, }: BoardProps<T>): import("react").JSX.Element;
 export interface BoardCardSurfaceProps {
     className?: string;
     children?: ReactNode;

package/dist/types/components/DragDrop.d.ts

@@ -1,5 +1,5 @@
 import { type ReactNode } from "react";
-import { type AutoScrollOptions, type ContainerId, type DragAxis, type DragId, type DragSessionCallbacks, type DragStrings } from "../lib/dnd";
+import { type AutoScrollOptions, type ContainerId, type CrossDrop, type DragAxis, type DragId, type DragSessionCallbacks, type DragStrings } from "../lib/dnd";
 export interface DragDropProps extends DragSessionCallbacks {
     /** Override any subset of the announcement grammar — localisation, or a domain noun. */
     strings?: Partial<DragStrings>;
@@ -46,10 +46,19 @@ export interface DragDropContainerProps {
     offset?: number;
     /** The whole list's length, counting the carried item when it lives here. See `offset`. */
     total?: number;
+    /**
+     * DX-4583: what a card carried in from ANOTHER container means here.
+     * `"position"` (the default) lands it at an index, siblings parting and a
+     * marker showing where. `"lane"` lands it in this container as a whole: no gap
+     * opens and no marker shows, because there is no position to show — the
+     * consumer decides what the drop writes (see `Board`'s `crossLaneDrop`). A
+     * card carried inside its own container is always positional.
+     */
+    crossDrop?: CrossDrop;
     className?: string;
     children?: ReactNode;
 }
-export declare function DragDropContainer({ id, label, axis, offset, total, className, children, }: DragDropContainerProps): import("react").JSX.Element;
+export declare function DragDropContainer({ id, label, axis, offset, total, crossDrop, className, children, }: DragDropContainerProps): import("react").JSX.Element;
 export interface DragDropItemProps {
     id: DragId;
     /**

package/dist/types/components/board/context.d.ts

@@ -1,4 +1,5 @@
 import type { BoardColumnId, BoardColumnModel, BoardItemId, BoardMoveRequest, BoardMoveVerdict } from "../../lib/board";
+import type { CrossDrop } from "../../lib/dnd";
 export declare const BoardCardSurfaceContext: import("react").Context<boolean>;
 /** `true` when an ancestor `BoardCardSurface` makes this whole card draggable. */
 export declare function useBoardCardIsDragSource(): boolean;
@@ -23,6 +24,8 @@ export interface BoardContextValue<T> {
     requestMove: (request: BoardMoveRequest) => BoardMoveVerdict;
     /** The words for the card menu's within-column items (`Board`'s `reorderLabels`). */
     reorderLabels: BoardReorderLabels;
+    /** What a card dropped on another lane means — `Board`'s `crossLaneDrop`. */
+    crossLaneDrop: CrossDrop;
 }
 /** The card menu's within-column items. DX-4575: a consumer that calls moving inside a list something else renames them. */
 export interface BoardReorderLabels {

package/dist/types/components/board/recipe.d.ts

@@ -28,6 +28,7 @@ export declare const board: import("tailwind-variants").TVReturnType<{
     handleCluster: string;
     menuTrigger: string[];
     reorderLocked: string[];
+    laneDrop: string[];
     rejection: string[];
 }, undefined, {
     overWip: {
@@ -59,6 +60,7 @@ export declare const board: import("tailwind-variants").TVReturnType<{
     handleCluster: string;
     menuTrigger: string[];
     reorderLocked: string[];
+    laneDrop: string[];
     rejection: string[];
 }, import("tailwind-variants").TVReturnTypeLike<{
     overWip: {
@@ -90,5 +92,6 @@ export declare const board: import("tailwind-variants").TVReturnType<{
     handleCluster: string;
     menuTrigger: string[];
     reorderLocked: string[];
+    laneDrop: string[];
     rejection: string[];
 }>>;

package/dist/types/index.d.ts

@@ -111,11 +111,11 @@ export { tokenize, listLanguages, resolveLanguage, defineGrammar, registerGramma
 export { parseMarkdown, MarkdownNodes, sanitizeHref, type MdNode, type MdInline, type MdCodeRenderer, } from "./lib/syntax/markdown";
 export { DragDrop, DragDropContainer, DragDropItem, DragDropHandle, DragDropSurface, type DragDropProps, type DragDropContainerProps, type DragDropItemProps, type DragDropHandleProps, type DragDropSurfaceProps, } from "./components/DragDrop";
 export { KanbanBoard, type KanbanBoardProps, type KanbanLane, type KanbanMove, type KanbanRefusal, } from "./components/kanban/KanbanBoard";
-export { DEFAULT_DRAG_STRINGS, DRAG_INSTRUCTIONS_ID, DragInstructions, DragLiveRegion, DragSession, DragSessionProvider, applyMove, attachAutoScroll, attachKeyboardSensor, attachPointerSensor, attachSessionWindowListeners, isNoOp, resolveTarget, sameTarget, scrollVelocity, useCreateDragSession, useDragAnnouncements, useDragSession, useDragState, useDragLive, useDraggable, useDropContainer, type ContainerId, type DragAxis, type DragCancelEvent, type DragEndEvent, type DragId, type DragMode, type DragPhase, type DragSessionCallbacks, type DragStartEvent, type DragState, type AutoScrollOptions, type DragAnnouncementContext, type DragAnnouncementOptions, type DragAnnouncements, type DragInstructionsProps, type DragLiveRegionProps, type DragStrings, type DropTarget, type KeyboardSensorOptions, type PointerActivation, } from "./lib/dnd";
+export { DEFAULT_DRAG_STRINGS, DRAG_INSTRUCTIONS_ID, DragInstructions, DragLiveRegion, DragSession, DragSessionProvider, applyMove, attachAutoScroll, attachKeyboardSensor, attachPointerSensor, attachSessionWindowListeners, isNoOp, resolveTarget, sameTarget, scrollVelocity, useCreateDragSession, useDragAnnouncements, useDragSession, useDragState, useDragLive, useDraggable, useDropContainer, type ContainerId, type CrossDrop, type DragAxis, type DragCancelEvent, type DragEndEvent, type DragId, type DragMode, type DragPhase, type DragSessionCallbacks, type DragStartEvent, type DragState, type AutoScrollOptions, type DragAnnouncementContext, type DragAnnouncementOptions, type DragAnnouncements, type DragInstructionsProps, type DragLiveRegionProps, type DragStrings, type DropTarget, type KeyboardSensorOptions, type PointerActivation, } from "./lib/dnd";
 export { Board, BoardColumn, BoardCard, BoardCardSurface, type BoardProps, type BoardColumnProps, type BoardCardProps, type BoardCardSurfaceProps, } from "./components/Board";
 export type { BoardReorderLabels } from "./components/board/context";
 export { buildBoardModel, resolveMove, applyBoardMoves, useBoard, moveAnchor, columnLength, positionInColumn, type BoardModel, type MoveAnchor, type UseBoardResult, } from "./lib/board";
-export type { BoardAccessors, BoardColumnDef, BoardEdge, BoardColumnId, BoardColumnModel, BoardItemId, BoardMove, BoardMoveRequest, BoardMoveSource, BoardMoveVerdict, UseBoardOptions, } from "./lib/board";
+export type { BoardAccessors, BoardColumnDef, BoardEdge, BoardColumnId, BoardColumnModel, BoardItemId, BoardMove, BoardMoveTarget, BoardMoveRequest, BoardMoveSource, BoardMoveVerdict, UseBoardOptions, } from "./lib/board";
 export { PagedWindowList, type PagedWindowItemPosition, type PagedWindowListProps, type PagedWindowStrings, } from "./components/PagedWindowList";
 export { PagedWindowStore, usePagedWindow, windowPageNumbers, type LoadCount, type LoadPage, type LoadPageContext, type PageResponse, type PageSnapshot, type PageStatus, type PagedWindow, type PagedWindowMode, type PagedWindowOptions, type PagedWindowSnapshot, type UsePagedWindowOptions, } from "./lib/paged-window";
 export type { MessageRole, MessagePart, TextPart, CodePart, ReasoningPart, ToolPart, ToolStatus, FilePart, ComponentPart, ChatFile, ChatMessage, RenderContext, PartRenderer, PartRenderers, ChatComponentRenderer, ChatComponents, } from "./components/chat/types";

package/dist/types/lib/board/anchor.d.ts

@@ -16,35 +16,51 @@
  * only at the end of the loaded run, where nothing is below, the card it lands
  * directly below (`afterId`). An empty destination names nothing.
  *
+ * A LANE MOVE IS ITS OWN ANSWER (DX-4583). It carries no position, so there is
+ * no neighbour to anchor to, and `{ lane: true }` says so: the server changes
+ * the card's lane and keeps its own rank. That is not the empty anchor, which
+ * says "the destination has no cards, so this is the first".
+ *
  * AN EDGE INTENT TRUMPS THE NEIGHBOURS. "Move to top" in a window that starts
  * at card 221 means the top of the column, which no loaded neighbour can say,
  * so the anchor carries the edge and no ids.
  */
 import type { BoardEdge, BoardItemId, BoardMove } from "./types";
 /**
- * EXACTLY ONE placement field is set — a server's lane-move takes one — or none
- * for an empty destination:
+ * EXACTLY ONE field is set — a server's lane-move takes one — or none for an
+ * empty destination:
  *   beforeId  the moved card lands directly above this loaded card
  *   afterId   it lands directly below this one: only when it lands after the last
  *             loaded card, where nothing is below to name
  *   edge      it goes to the very top or bottom of the whole column
+ *   lane      a lane move: no position at all, the card keeps its rank
+ * None is set for an empty destination.
  */
 export type MoveAnchor = {
     beforeId: BoardItemId;
     afterId?: never;
     edge?: never;
+    lane?: never;
 } | {
     afterId: BoardItemId;
     beforeId?: never;
     edge?: never;
+    lane?: never;
 } | {
     edge: BoardEdge;
     beforeId?: never;
     afterId?: never;
+    lane?: never;
+} | {
+    lane: true;
+    beforeId?: never;
+    afterId?: never;
+    edge?: never;
 } | {
     beforeId?: never;
     afterId?: never;
     edge?: never;
+    lane?: never;
 };
 /**
  * @param destinationItems the destination column's LOADED cards (the moved card

package/dist/types/lib/board/index.d.ts

@@ -8,7 +8,7 @@
  * NOT wired into the package's top-level `src/index.ts` — that barrel is
  * owned by the contract's author, not this agent (see this round's brief).
  */
-export type { BoardAccessors, BoardColumnDef, BoardEdge, BoardColumnId, BoardColumnModel, BoardItemId, BoardMove, BoardMoveRequest, BoardMoveSource, BoardMoveVerdict, UseBoardOptions, } from "./types";
+export type { BoardAccessors, BoardColumnDef, BoardEdge, BoardColumnId, BoardColumnModel, BoardItemId, BoardMove, BoardMoveTarget, BoardMoveRequest, BoardMoveSource, BoardMoveVerdict, UseBoardOptions, } from "./types";
 export { buildBoardModel, type BoardModel } from "./model";
 export { moveAnchor, type MoveAnchor } from "./anchor";
 export { columnLength, positionInColumn } from "./position";

package/dist/types/lib/board/move.d.ts

@@ -66,7 +66,7 @@
  * WITH THE DRAGGED ITEM ALREADY REMOVED — has no obvious generalisation to N
  * items removed from possibly-different columns at once, and `types.ts`
  * does not pick one; that is this module's decision to make and document.
- * THE RULE: every move's `to.index`, bulk or not, counts its destination
+ * THE RULE: every positional move's `to.index`, bulk or not, counts its destination
  * column's items with EVERY item named ANYWHERE in the same request already
  * removed — not just itself. For a single-move request that is identical to
  * the engine's own rule (nothing else is being removed). For a bulk request
@@ -92,7 +92,10 @@
  * order), each inserted at `to.index + (insertions already made into this
  * column)`. That running offset is exactly what accounts for earlier
  * insertions shifting the positions later ones land at, computed once
- * instead of re-derived per move. board-core.test.ts pins a concrete bulk
+ * instead of re-derived per move. A LANE MOVE (`to.lane`, DX-4583) has no
+ * index, so it takes no part in this pass: it neither leaves the residual nor
+ * is inserted, and the card stays where the consumer's order already holds it
+ * once the consumer has written its lane. board-core.test.ts pins a concrete bulk
  * case where the naive sequential-splice answer and this one visibly differ,
  * so the property is proven rather than incidentally true.
  *
@@ -146,6 +149,13 @@ export declare function resolveMove<T>(context: ResolveMoveContext<T>, request:
  * column membership on every subsequent `buildBoardModel` call, and
  * `buildBoardModel` only ever reads WITHIN-column order.
  *
+ * A LANE MOVE (`to.lane`, DX-4583) CHANGES MEMBERSHIP AND NOTHING ELSE. The
+ * card stays at its place in `items`, so it lands among the destination's cards
+ * where the consumer's own order puts it (its priority, its sort key). The
+ * consumer's lane write must already be made, because this function cannot make
+ * it: a lane move whose item still reports another lane throws, since the card
+ * would otherwise stay in its old lane without a sound.
+ *
  * `to.edge` IS NOT APPLIED HERE. This arranges the cards it was given, and in a
  * windowed column an edge move lands OUTSIDE the cards that are loaded — at the
  * top or bottom of a list this function cannot see — so the index it would

package/dist/types/lib/board/types.d.ts

@@ -126,12 +126,30 @@ export interface BoardMove {
         columnId: BoardColumnId;
         index: number;
     };
-    to: {
-        columnId: BoardColumnId;
-        index: number;
-        edge?: BoardEdge;
-    };
+    to: BoardMoveTarget;
 }
+/**
+ * Where a move lands: a place in the destination (`index`, and optionally the
+ * `edge` it stands for), or only the destination (`lane: true`).
+ *
+ * DX-4583: a lane move names no position, so it has no `index` to be wrong
+ * about. It is what a board produces when a card is carried into another lane
+ * and the consumer decided that a lane change is not also a reorder (`Board`'s
+ * `crossLaneDrop="lane"`): the card keeps whatever rank it already has in the
+ * consumer's data, and `applyBoardMoves` leaves it where the consumer's order holds it. Narrow on `to.lane` before reading `to.index`, so a consumer
+ * that turns the option on cannot miss that there is no position to write.
+ */
+export type BoardMoveTarget = {
+    columnId: BoardColumnId;
+    index: number;
+    edge?: BoardEdge;
+    lane?: never;
+} | {
+    columnId: BoardColumnId;
+    lane: true;
+    index?: never;
+    edge?: never;
+};
 /**
  * Which input produced the move. Kept on the request rather than inferred
  * downstream because the three that are not `"pointer"` are the ones with no

package/dist/types/lib/dnd/announce.d.ts

@@ -6,6 +6,12 @@ export interface DragAnnouncementContext {
     /** `labelOf(id)` if supplied, otherwise the id — which is at least speakable. */
     label: string;
     container: ContainerId;
+    /**
+     * DX-4583: the container the card was picked up from. A message whose
+     * `container` differs from it describes a card in another container, which is
+     * the case where a consumer may mean "this lane" and no position at all.
+     */
+    from: ContainerId;
     containerLabel: string;
     /** 1-based, as spoken, in the WHOLE container — a windowed container reports its real offset and length (DX-4540). */
     position: number;
@@ -23,6 +29,10 @@ export interface DragStrings {
     picked: (c: DragAnnouncementContext) => string;
     moved: (c: DragAnnouncementContext) => string;
     dropped: (c: DragAnnouncementContext) => string;
+    /** `moved`, for a card held over another container that takes it as a whole (`crossDrop: "lane"`): no position is spoken. */
+    movedToLane: (c: DragAnnouncementContext) => string;
+    /** `dropped`, for a card released over such a container. */
+    droppedInLane: (c: DragAnnouncementContext) => string;
     /** Describes the item's ORIGINAL position — cancel is a restore, not a move. */
     cancelled: (c: DragAnnouncementContext) => string;
 }

package/dist/types/lib/dnd/cross-drop.d.ts

@@ -0,0 +1,18 @@
+/**
+ * DX-4583: the one place that says what "a card dropped on another lane" means,
+ * so the drop, the highlight, the banner, the gap and the keyboard cannot drift
+ * into four spellings of the same predicate.
+ */
+import type { ContainerId, CrossDrop, DragState } from "./types";
+/**
+ * True when a card carried from `from` into `to` lands there as a whole: the
+ * destination takes a lane drop and it is not the card's own container. A card
+ * carried inside its own container is always positional.
+ */
+export declare function isLaneDrop(crossDrop: CrossDrop | undefined, from: ContainerId | null | undefined, to: ContainerId | null | undefined): boolean;
+/**
+ * Whose card is held over `container` right now: `"own"` when it was picked up
+ * from there, `"other"` when it came from another container, `null` when no card
+ * is held over it.
+ */
+export declare function heldOver(state: DragState, container: ContainerId): "own" | "other" | null;

package/dist/types/lib/dnd/index.d.ts

@@ -6,8 +6,9 @@
  * delete, and esbuild does; that is exactly how this project once shipped an
  * empty icon registry (CAV-11).
  */
-export type { ContainerId, ContainerRect, ContainerRegistration, DragAxis, DragCancelEvent, DragEndEvent, DragId, DragMode, DragPhase, DragSessionCallbacks, DragStartEvent, DragState, DropTarget, ItemRect, ItemRegistration, LayoutSnapshot, Point, } from "./types";
+export type { ContainerId, ContainerRect, ContainerRegistration, CrossDrop, DragAxis, DragCancelEvent, DragEndEvent, DragId, DragMode, DragPhase, DragSessionCallbacks, DragStartEvent, DragState, DropTarget, ItemRect, ItemRegistration, LayoutSnapshot, Point, } from "./types";
 export { applyMove, containerAt, indexAt, isNoOp, measure, nearestContainer, remainingItems, resolveTarget, sameTarget, } from "./geometry";
+export { heldOver, isLaneDrop } from "./cross-drop";
 export { DragSession, type StartArgs } from "./session";
 export { attachPointerSensor, attachSessionWindowListeners, type PointerActivation, type PointerSensorOptions, } from "./sensors/pointer";
 export { attachKeyboardSensor, type KeyboardSensorOptions, } from "./sensors/keyboard";

package/dist/types/lib/dnd/session.d.ts

@@ -1,4 +1,4 @@
-import type { ContainerRegistration, DragId, DragMode, DragSessionCallbacks, DragState, ItemRegistration, LayoutSnapshot, Point } from "./types";
+import type { ContainerRegistration, CrossDrop, DragId, DragMode, DragSessionCallbacks, DragState, ItemRegistration, LayoutSnapshot, Point } from "./types";
 export interface StartArgs {
     id: DragId;
     mode: DragMode;
@@ -106,6 +106,8 @@ export declare class DragSession {
         position: number;
         total: number;
     };
+    /** What a card carried in from another container means here — see `ContainerRegistration.crossDrop`. */
+    crossDropOf(container: string): CrossDrop | undefined;
     /** How many items a container holds once the carried one is taken out. */
     slotCount(container: string): number;
 }

package/dist/types/lib/dnd/types.d.ts

@@ -104,7 +104,17 @@ export interface ContainerRegistration {
     offset?: number;
     /** The whole list's length, the carried item counted in it when it lives here. See `offset`. */
     total?: number;
+    /**
+     * DX-4583: what a card carried in from ANOTHER container means here. Absent or
+     * `"position"`, it lands at an index: siblings part and a marker shows where.
+     * `"lane"`, it lands in the container as a whole and no index is meant: no gap
+     * opens, no marker shows, and the consumer decides what the drop writes. A
+     * card carried inside its own container is always positional.
+     */
+    crossDrop?: CrossDrop;
 }
+/** See `ContainerRegistration.crossDrop`. */
+export type CrossDrop = "position" | "lane";
 /** One item's measured box, taken at snapshot time. */
 export interface ItemRect {
     id: DragId;
@@ -115,6 +125,8 @@ export interface ItemRect {
 export interface ContainerRect {
     id: ContainerId;
     axis: DragAxis;
+    /** Copied from the registration — see `ContainerRegistration.crossDrop`. */
+    crossDrop?: CrossDrop;
     rect: DOMRect;
 }
 /**

package/dist/types/lib/dnd/use-drag.d.ts

@@ -1,6 +1,6 @@
 import { DragSession } from "./session";
 import type { PointerActivation } from "./sensors/pointer";
-import type { ContainerId, DragAxis, DragId, DragSessionCallbacks, DragState } from "./types";
+import type { ContainerId, CrossDrop, DragAxis, DragId, DragSessionCallbacks, DragState } from "./types";
 export declare const DragSessionProvider: import("react").Provider<DragSession | null>;
 export declare function useDragSession(component: string): DragSession;
 /**
@@ -59,6 +59,8 @@ export interface UseDropContainerOptions {
     offset?: number;
     /** See `ContainerRegistration.total` — a windowed container's whole length. */
     total?: number;
+    /** See `ContainerRegistration.crossDrop`. */
+    crossDrop?: CrossDrop;
 }
 export interface UseDropContainerResult {
     setContainerRef: (el: HTMLElement | null) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danxbot/ui",
-  "version": "20.13.2",
+  "version": "20.15.0",
   "type": "module",
   "description": "Danxbot — a domain-agnostic React design system with motion as a first-class primitive.",
   "license": "MIT",