@danxbot/ui 20.14.0 → 20.15.0

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

@@ -16,9 +16,10 @@
  * 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 NAMES NOTHING (DX-4583). It carries no position, so there is no
- * neighbour to anchor to: the anchor is empty and the server keeps the card's
- * own rank in the new lane.
+ * 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,
@@ -26,30 +27,40 @@
  */
 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
- * None is set for an empty destination and for a lane move.
+ *   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/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

@@ -136,7 +136,7 @@ export interface BoardMove {
  * 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. Narrow on `to.lane` before reading `to.index`, so a consumer
+ * 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 = {

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

@@ -29,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

@@ -8,6 +8,7 @@
  */
 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/package.json

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