@cube-dev/ui-kit 0.170.0 → 0.171.0

package/dist/components/layout/Board/grid-core/collision-modes.js.map

@@ -1 +1 @@
-{"version":3,"file":"collision-modes.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/collision-modes.ts"],"sourcesContent":["/**\n * Collision resolution strategies for a grid that prevents collisions.\n *\n * Original UI Kit code (not vendored from react-grid-layout): the upstream\n * engine only ever reverts a blocked move.\n *\n * When `preventCollision` is on, `moveElement` refuses any placement that\n * overlaps an existing item and snaps the dragged item back. That is the right\n * default, but a free grid often wants the placement *resolved* instead of\n * refused - shrunk into whatever room is actually there, or exchanged with the\n * widget already sitting in the target slot. These strategies produce such a\n * resolution, and every resolution they return is overlap-free, so the caller's\n * own overlap guards keep working unchanged.\n */\n\nimport { collides } from './collision';\n\nimport type {\n  CollisionMode,\n  CollisionResolver,\n  CollisionResolverOptions,\n  Layout,\n  LayoutItem,\n} from './types';\n\n/** Whether a single grid cell is free of every item in `others`. */\nfunction cellFree(others: Layout, x: number, y: number): boolean {\n  for (let i = 0; i < others.length; i++) {\n    const o = others[i];\n    if (\n      o !== undefined &&\n      x >= o.x &&\n      x < o.x + o.w &&\n      y >= o.y &&\n      y < o.y + o.h\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * The largest rectangle anchored at `anchor` that fits without overlapping\n * `others`, growing rightward and downward only.\n *\n * Never larger than `desired` (a drag must never *upscale* a widget - growing\n * things is an explicit, opt-in operation like \"distribute evenly\", not a side\n * effect of moving them), never smaller than the item's own `minW`/`minH`, and\n * never past `cols` / `maxRows`. Among the candidates the largest-area rectangle\n * wins, breaking ties on width: a grid is read left to right, so a wide-and-flat\n * result is the less surprising of two equal-area fits.\n *\n * Returns `null` when not even the minimum size fits, which the callers treat as\n * \"no resolution\" and fall back to reverting.\n */\nexport function maxFreeRectAt(\n  others: Layout,\n  anchor: { x: number; y: number },\n  desired: { w: number; h: number },\n  limits: { cols: number; maxRows?: number },\n  mins?: { minW?: number; minH?: number },\n): { w: number; h: number } | null {\n  if (anchor.x < 0 || anchor.y < 0) return null;\n\n  const minW = Math.max(1, mins?.minW ?? 1);\n  const minH = Math.max(1, mins?.minH ?? 1);\n  const maxRows = limits.maxRows ?? Infinity;\n  const maxW = Math.min(desired.w, limits.cols - anchor.x);\n  const maxH = Math.min(\n    desired.h,\n    Number.isFinite(maxRows) ? maxRows - anchor.y : desired.h,\n  );\n\n  if (maxW < minW || maxH < minH) return null;\n\n  // Free height available in each column of the candidate band, measured down\n  // from the anchor row and capped at the tallest useful height.\n  const free: number[] = [];\n  for (let dx = 0; dx < maxW; dx++) {\n    let h = 0;\n    while (h < maxH && cellFree(others, anchor.x + dx, anchor.y + h)) h++;\n    free.push(h);\n    // A column with no room at all caps every wider candidate, so stop early.\n    if (h === 0) break;\n  }\n\n  let best: { w: number; h: number } | null = null;\n  let bestArea = 0;\n  let limit = maxH;\n  for (let w = 1; w <= free.length; w++) {\n    limit = Math.min(limit, free[w - 1]!);\n    if (limit < minH) break;\n    if (w < minW) continue;\n    const area = w * limit;\n    // `>=` so the widest of several equal-area fits wins: `w` only grows here, so\n    // the last match is the widest one.\n    if (area >= bestArea) {\n      best = { w, h: limit };\n      bestArea = area;\n    }\n  }\n\n  return best;\n}\n\n/**\n * Shrink the placement to the room actually available at the cell it was\n * dropped on.\n */\nfunction downscaleInPlace(\n  layout: Layout,\n  item: LayoutItem,\n  others: Layout,\n  desired: { w: number; h: number },\n  limits: { cols: number; maxRows?: number },\n): LayoutItem[] | null {\n  const fit = maxFreeRectAt(\n    others,\n    { x: item.x, y: item.y },\n    desired,\n    limits,\n    item,\n  );\n  if (!fit) return null;\n  // Nothing to resolve: the requested size already fits, so the collision was\n  // not a sizing problem and reverting is still the honest answer.\n  if (fit.w === item.w && fit.h === item.h) return null;\n\n  return layout.map((l) =>\n    l.i === item.i ? { ...l, w: fit.w, h: fit.h, moved: true } : l,\n  );\n}\n\n/** Number of cells two items share. Zero when they do not overlap at all. */\nfunction overlapArea(a: LayoutItem, b: LayoutItem): number {\n  const w = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x);\n  const h = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y);\n  return w > 0 && h > 0 ? w * h : 0;\n}\n\n/**\n * Exchange the placement with one of the widgets under it.\n *\n * The dragged widget takes the other's cell and the other takes the cell the\n * dragged widget came from. Each keeps as much of its own size as fits there -\n * that cell plus any free space adjacent to it - and neither ever grows.\n *\n * `from` is whatever the caller's layout says, so it is the caller that decides\n * what \"came from\" means. A pointer drag resolves every frame against the\n * arrangement the gesture started with, making it the cell the drag began at, and\n * keeping the result a pure function of where the pointer is; chaining frames off\n * each other instead would exchange with every widget swept over.\n * The slot the dragged widget is leaving is reserved for the displaced widget\n * while the dragged one is sized, so the two can never claim the same cells: the\n * result is overlap-free by construction, not by a follow-up check.\n */\nfunction exchangeWithCollision(\n  layout: Layout,\n  item: LayoutItem,\n  collisions: LayoutItem[],\n  from: { x: number; y: number },\n  desired: { w: number; h: number },\n  limits: { cols: number; maxRows?: number },\n): LayoutItem[] | null {\n  // Nothing to trade if the widget has not actually left a slot behind - a\n  // cross-board drop, where it never had one on this board.\n  if (from.x === item.x && from.y === item.y) return null;\n\n  // A drop that spans a boundary covers two widgets at once, and refusing those\n  // frames would leave a band mid-drag where nothing is swapped at all: the\n  // placeholder snaps back to the origin, then jumps to the far swap once the drop\n  // clears the first widget. Trade with the one the drop covers most instead, so\n  // the swap only ever changes which partner it is - never blinks away. Ties go to\n  // the widget earlier in reading order, so the choice is deterministic. Exactly\n  // one widget is ever displaced, whichever is picked.\n  const candidates = collisions\n    .filter((c) => !c.static)\n    .map((c) => ({ c, area: overlapArea(item, c) }))\n    .sort((p, q) => q.area - p.area || p.c.y - q.c.y || p.c.x - q.c.x)\n    .map(({ c }) => c);\n\n  for (const other of candidates) {\n    const exchanged = exchangeWith(layout, item, other, from, desired, limits);\n    if (exchanged) return exchanged;\n  }\n  return null;\n}\n\n/** One concrete two-widget exchange, or `null` if either side cannot fit. */\nfunction exchangeWith(\n  layout: Layout,\n  item: LayoutItem,\n  other: LayoutItem,\n  from: { x: number; y: number },\n  desired: { w: number; h: number },\n  limits: { cols: number; maxRows?: number },\n): LayoutItem[] | null {\n  const rest = layout.filter((l) => l.i !== item.i && l.i !== other.i);\n  // The slot being vacated, held back so the dragged widget cannot grow into the\n  // space the displaced one is about to need. Ids are never compared here (the\n  // scan works cell by cell), so this placeholder cannot clash with a real one.\n  const originSlot: LayoutItem = {\n    i: 'origin-slot-reservation',\n    x: from.x,\n    y: from.y,\n    w: desired.w,\n    h: desired.h,\n  };\n\n  const movedFit = maxFreeRectAt(\n    [...rest, originSlot],\n    { x: other.x, y: other.y },\n    desired,\n    limits,\n    item,\n  );\n  if (!movedFit) return null;\n  const moved: LayoutItem = {\n    ...item,\n    x: other.x,\n    y: other.y,\n    w: movedFit.w,\n    h: movedFit.h,\n    moved: true,\n  };\n\n  const displacedFit = maxFreeRectAt(\n    [...rest, moved],\n    { x: from.x, y: from.y },\n    { w: other.w, h: other.h },\n    limits,\n    other,\n  );\n  if (!displacedFit) return null;\n  const displaced: LayoutItem = {\n    ...other,\n    x: from.x,\n    y: from.y,\n    w: displacedFit.w,\n    h: displacedFit.h,\n    moved: true,\n  };\n\n  return layout.map((l) =>\n    l.i === item.i ? moved : l.i === other.i ? displaced : l,\n  );\n}\n\n/**\n * Build the resolver `moveElement` consults instead of reverting a blocked move,\n * or `undefined` for `'revert'` (and for an unset mode), which keeps the engine\n * on its original path with no added work.\n *\n * For an in-board drag, `'swap'` is an escalation ladder: exchange with one of\n * the widgets under the drop, else downscale at the drop cell, else revert. A\n * dense grid stays draggable that way - refusing everything that is not a clean\n * one-to-one trade would make the mode feel broken exactly where it is needed.\n * Cross-board callers pass `allowExchange: false`, which turns the same mode into\n * empty-anchor downscaling; the registry cancels the transfer if that resolution\n * cannot occupy the requested cell.\n */\nexport function createCollisionResolver(\n  mode: CollisionMode | undefined,\n  options: CollisionResolverOptions,\n): CollisionResolver | undefined {\n  if (!mode || mode === 'revert') return undefined;\n\n  const limits = { cols: options.cols, maxRows: options.maxRows };\n\n  return ({ layout, item, collisions, from }) => {\n    const others = layout.filter((l) => l.i !== item.i);\n    const desired = options.desired ?? { w: item.w, h: item.h };\n\n    if (mode === 'swap' && options.allowExchange !== false) {\n      const exchanged = exchangeWithCollision(\n        layout,\n        item,\n        collisions,\n        from,\n        desired,\n        limits,\n      );\n      if (exchanged) return exchanged;\n    }\n\n    return downscaleInPlace(layout, item, others, desired, limits);\n  };\n}\n\n/**\n * Whether a layout holds no overlapping pair. A resolution is only ever accepted\n * when this holds, so the specs assert it directly.\n */\nexport function isOverlapFree(layout: Layout): boolean {\n  for (let i = 0; i < layout.length; i++) {\n    for (let j = i + 1; j < layout.length; j++) {\n      if (collides(layout[i]!, layout[j]!)) return false;\n    }\n  }\n  return true;\n}\n"],"mappings":"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"}
+{"version":3,"file":"collision-modes.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/collision-modes.ts"],"sourcesContent":["/**\n * Collision resolution strategies for a grid that prevents collisions.\n *\n * Original UI Kit code (not vendored from react-grid-layout): the upstream\n * engine only ever reverts a blocked move.\n *\n * When `preventCollision` is on, `moveElement` refuses any placement that\n * overlaps an existing item and snaps the dragged item back. That is the right\n * default, but a free grid often wants the placement *resolved* instead of\n * refused - shrunk into whatever room is actually there, or exchanged with the\n * widget already sitting in the target slot. These strategies produce such a\n * resolution, and every resolution they return is overlap-free, so the caller's\n * own overlap guards keep working unchanged.\n */\n\nimport { collides } from './collision';\n\nimport type {\n  CollisionMode,\n  CollisionResolver,\n  CollisionResolverOptions,\n  Layout,\n  LayoutItem,\n} from './types';\n\n/** Whether a single grid cell is free of every item in `others`. */\nfunction cellFree(others: Layout, x: number, y: number): boolean {\n  for (let i = 0; i < others.length; i++) {\n    const o = others[i];\n    if (\n      o !== undefined &&\n      x >= o.x &&\n      x < o.x + o.w &&\n      y >= o.y &&\n      y < o.y + o.h\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * The largest rectangle anchored at `anchor` that fits without overlapping\n * `others`, growing rightward and downward only.\n *\n * Never larger than `desired` (a drag must never *upscale* a widget - growing\n * things is an explicit, opt-in operation like \"distribute evenly\", not a side\n * effect of moving them), never smaller than the item's own `minW`/`minH`, and\n * never past `cols` / `maxRows`. Among the candidates the largest-area rectangle\n * wins, breaking ties on width: a grid is read left to right, so a wide-and-flat\n * result is the less surprising of two equal-area fits.\n *\n * Returns `null` when not even the minimum size fits, which the callers treat as\n * \"no resolution\" and fall back to reverting.\n */\nexport function maxFreeRectAt(\n  others: Layout,\n  anchor: { x: number; y: number },\n  desired: { w: number; h: number },\n  limits: { cols: number; maxRows?: number },\n  mins?: { minW?: number; minH?: number },\n): { w: number; h: number } | null {\n  if (anchor.x < 0 || anchor.y < 0) return null;\n\n  const minW = Math.max(1, mins?.minW ?? 1);\n  const minH = Math.max(1, mins?.minH ?? 1);\n  const maxRows = limits.maxRows ?? Infinity;\n  const maxW = Math.min(desired.w, limits.cols - anchor.x);\n  const maxH = Math.min(\n    desired.h,\n    Number.isFinite(maxRows) ? maxRows - anchor.y : desired.h,\n  );\n\n  if (maxW < minW || maxH < minH) return null;\n\n  // Free height available in each column of the candidate band, measured down\n  // from the anchor row and capped at the tallest useful height.\n  const free: number[] = [];\n  for (let dx = 0; dx < maxW; dx++) {\n    let h = 0;\n    while (h < maxH && cellFree(others, anchor.x + dx, anchor.y + h)) h++;\n    free.push(h);\n    // A column with no room at all caps every wider candidate, so stop early.\n    if (h === 0) break;\n  }\n\n  let best: { w: number; h: number } | null = null;\n  let bestArea = 0;\n  let limit = maxH;\n  for (let w = 1; w <= free.length; w++) {\n    limit = Math.min(limit, free[w - 1]!);\n    if (limit < minH) break;\n    if (w < minW) continue;\n    const area = w * limit;\n    // `>=` so the widest of several equal-area fits wins: `w` only grows here, so\n    // the last match is the widest one.\n    if (area >= bestArea) {\n      best = { w, h: limit };\n      bestArea = area;\n    }\n  }\n\n  return best;\n}\n\n/**\n * The cells beyond a pinned anchor that a drag could never ask for.\n *\n * `gridBounds` clamps a drag anchor to `cols - w` (and `maxRows - h`), which\n * assumes the widget keeps the size it started with. So when the blocker is to\n * the LEFT of the free room and that room is narrower than the widget, every\n * anchor a pointer can produce lands inside the blocker - and the mode whose\n * whole job is to shrink the widget into that room never gets offered it. The\n * drop just reverts. The mirror case has no such problem, because the anchor at\n * column 0 is always reachable: that asymmetry is why downscaling into room on\n * the left has always worked and room on the right has not. The row axis clamps\n * the same way, so a board with a finite `maxRows` has the same blind spot below\n * a blocker.\n *\n * Nothing is offered unless the anchor is sitting ON the limit, pinned against\n * the far edge with the pointer unable to push it further. An anchor short of the\n * limit is the pointer's own choice - every cell between it and the limit was\n * available to ask for - so a blocked drop there still just reverts, exactly as\n * before. Without that gate a widget dropped on an occupied cell would skip over\n * free cells the pointer could perfectly well have aimed at.\n *\n * A pinned anchor's span ends at the last row/column of the grid, so every cell\n * returned - and every rectangle that can be measured from one - lies inside the\n * footprint the widget is already covering.\n */\nfunction clampedOutAnchors(\n  item: LayoutItem,\n  desired: { w: number; h: number },\n  limits: { cols: number; maxRows?: number },\n): { x: number; y: number }[] {\n  const maxRows = limits.maxRows ?? Infinity;\n  const bounded = Number.isFinite(maxRows);\n  const xLimit = Math.max(0, limits.cols - desired.w);\n  const yLimit = bounded ? Math.max(0, maxRows - desired.h) : Infinity;\n\n  const anchors: { x: number; y: number }[] = [];\n  // Each axis is clamped on its own, so each recovers on its own: slide along\n  // the one the limit actually pinned, never diagonally into open grid.\n  if (item.x === xLimit) {\n    const lastX = Math.min(item.x + desired.w - 1, limits.cols - 1);\n    for (let x = item.x + 1; x <= lastX; x++) anchors.push({ x, y: item.y });\n  }\n  if (bounded && item.y === yLimit) {\n    const lastY = Math.min(item.y + desired.h - 1, maxRows - 1);\n    for (let y = item.y + 1; y <= lastY; y++) anchors.push({ x: item.x, y });\n  }\n  return anchors;\n}\n\n/**\n * Shrink the placement to the room actually available at the cell it was\n * dropped on, or - when that cell cannot take the widget at any size and the\n * anchor is pinned against the grid edge - at a cell the clamp hid from the\n * pointer (see `clampedOutAnchors`). The largest fit among those wins, so the\n * widget takes as much of the room it is already hovering as there is.\n */\nfunction downscaleInPlace(\n  layout: Layout,\n  item: LayoutItem,\n  others: Layout,\n  desired: { w: number; h: number },\n  limits: { cols: number; maxRows?: number },\n): LayoutItem[] | null {\n  const fitAt = (anchor: { x: number; y: number }) =>\n    maxFreeRectAt(others, anchor, desired, limits, item);\n\n  let anchor = { x: item.x, y: item.y };\n  let fit = fitAt(anchor);\n\n  if (!fit) {\n    let bestArea = 0;\n    for (const candidate of clampedOutAnchors(item, desired, limits)) {\n      const candidateFit = fitAt(candidate);\n      if (!candidateFit) continue;\n      const area = candidateFit.w * candidateFit.h;\n      // `>` keeps the first of several equal-area fits, and the scan runs in\n      // reading order from the drop cell, so that is the closest one to it.\n      if (area > bestArea) {\n        bestArea = area;\n        fit = candidateFit;\n        anchor = candidate;\n      }\n    }\n  }\n\n  if (!fit) return null;\n  // Nothing to resolve: the requested cell takes the requested size, so the\n  // collision was not a sizing problem and reverting is still the honest answer.\n  if (\n    fit.w === item.w &&\n    fit.h === item.h &&\n    anchor.x === item.x &&\n    anchor.y === item.y\n  ) {\n    return null;\n  }\n\n  return layout.map((l) =>\n    l.i === item.i\n      ? { ...l, x: anchor.x, y: anchor.y, w: fit!.w, h: fit!.h, moved: true }\n      : l,\n  );\n}\n\n/** Number of cells two items share. Zero when they do not overlap at all. */\nfunction overlapArea(a: LayoutItem, b: LayoutItem): number {\n  const w = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x);\n  const h = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y);\n  return w > 0 && h > 0 ? w * h : 0;\n}\n\n/**\n * Exchange the placement with one of the widgets under it.\n *\n * The dragged widget takes the other's cell and the other takes the cell the\n * dragged widget came from. Each keeps as much of its own size as fits there -\n * that cell plus any free space adjacent to it - and neither ever grows.\n *\n * `from` is whatever the caller's layout says, so it is the caller that decides\n * what \"came from\" means. A pointer drag resolves every frame against the\n * arrangement the gesture started with, making it the cell the drag began at, and\n * keeping the result a pure function of where the pointer is; chaining frames off\n * each other instead would exchange with every widget swept over.\n * The slot the dragged widget is leaving is reserved for the displaced widget\n * while the dragged one is sized, so the two can never claim the same cells: the\n * result is overlap-free by construction, not by a follow-up check.\n */\nfunction exchangeWithCollision(\n  layout: Layout,\n  item: LayoutItem,\n  collisions: LayoutItem[],\n  from: { x: number; y: number },\n  desired: { w: number; h: number },\n  limits: { cols: number; maxRows?: number },\n): LayoutItem[] | null {\n  // Nothing to trade if the widget has not actually left a slot behind - a\n  // cross-board drop, where it never had one on this board.\n  if (from.x === item.x && from.y === item.y) return null;\n\n  // A drop that spans a boundary covers two widgets at once, and refusing those\n  // frames would leave a band mid-drag where nothing is swapped at all: the\n  // placeholder snaps back to the origin, then jumps to the far swap once the drop\n  // clears the first widget. Trade with the one the drop covers most instead, so\n  // the swap only ever changes which partner it is - never blinks away. Ties go to\n  // the widget earlier in reading order, so the choice is deterministic. Exactly\n  // one widget is ever displaced, whichever is picked.\n  const candidates = collisions\n    .filter((c) => !c.static)\n    .map((c) => ({ c, area: overlapArea(item, c) }))\n    .sort((p, q) => q.area - p.area || p.c.y - q.c.y || p.c.x - q.c.x)\n    .map(({ c }) => c);\n\n  for (const other of candidates) {\n    const exchanged = exchangeWith(layout, item, other, from, desired, limits);\n    if (exchanged) return exchanged;\n  }\n  return null;\n}\n\n/** One concrete two-widget exchange, or `null` if either side cannot fit. */\nfunction exchangeWith(\n  layout: Layout,\n  item: LayoutItem,\n  other: LayoutItem,\n  from: { x: number; y: number },\n  desired: { w: number; h: number },\n  limits: { cols: number; maxRows?: number },\n): LayoutItem[] | null {\n  const rest = layout.filter((l) => l.i !== item.i && l.i !== other.i);\n  // The slot being vacated, held back so the dragged widget cannot grow into the\n  // space the displaced one is about to need. Ids are never compared here (the\n  // scan works cell by cell), so this placeholder cannot clash with a real one.\n  const originSlot: LayoutItem = {\n    i: 'origin-slot-reservation',\n    x: from.x,\n    y: from.y,\n    w: desired.w,\n    h: desired.h,\n  };\n\n  const movedFit = maxFreeRectAt(\n    [...rest, originSlot],\n    { x: other.x, y: other.y },\n    desired,\n    limits,\n    item,\n  );\n  if (!movedFit) return null;\n  const moved: LayoutItem = {\n    ...item,\n    x: other.x,\n    y: other.y,\n    w: movedFit.w,\n    h: movedFit.h,\n    moved: true,\n  };\n\n  const displacedFit = maxFreeRectAt(\n    [...rest, moved],\n    { x: from.x, y: from.y },\n    { w: other.w, h: other.h },\n    limits,\n    other,\n  );\n  if (!displacedFit) return null;\n  const displaced: LayoutItem = {\n    ...other,\n    x: from.x,\n    y: from.y,\n    w: displacedFit.w,\n    h: displacedFit.h,\n    moved: true,\n  };\n\n  return layout.map((l) =>\n    l.i === item.i ? moved : l.i === other.i ? displaced : l,\n  );\n}\n\n/**\n * Build the resolver `moveElement` consults instead of reverting a blocked move,\n * or `undefined` for `'revert'` (and for an unset mode), which keeps the engine\n * on its original path with no added work.\n *\n * For an in-board drag, `'swap'` is an escalation ladder: exchange with one of\n * the widgets under the drop, else downscale at the drop cell, else revert. A\n * dense grid stays draggable that way - refusing everything that is not a clean\n * one-to-one trade would make the mode feel broken exactly where it is needed.\n * Cross-board callers pass `allowExchange: false`, which turns the same mode into\n * downscaling at the drop cell - there is no slot on the destination to trade\n * back, and a transfer that cannot resolve is placed in a free cell rather than\n * refused, since a widget dropped somewhere has to end up somewhere.\n */\nexport function createCollisionResolver(\n  mode: CollisionMode | undefined,\n  options: CollisionResolverOptions,\n): CollisionResolver | undefined {\n  if (!mode || mode === 'revert') return undefined;\n\n  const limits = { cols: options.cols, maxRows: options.maxRows };\n\n  return ({ layout, item, collisions, from }) => {\n    const others = layout.filter((l) => l.i !== item.i);\n    const desired = options.desired ?? { w: item.w, h: item.h };\n\n    if (mode === 'swap' && options.allowExchange !== false) {\n      const exchanged = exchangeWithCollision(\n        layout,\n        item,\n        collisions,\n        from,\n        desired,\n        limits,\n      );\n      if (exchanged) return exchanged;\n    }\n\n    return downscaleInPlace(layout, item, others, desired, limits);\n  };\n}\n\n/**\n * Whether a layout holds no overlapping pair. A resolution is only ever accepted\n * when this holds, so the specs assert it directly.\n */\nexport function isOverlapFree(layout: Layout): boolean {\n  for (let i = 0; i < layout.length; i++) {\n    for (let j = i + 1; j < layout.length; j++) {\n      if (collides(layout[i]!, layout[j]!)) return false;\n    }\n  }\n  return true;\n}\n"],"mappings":"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"}

package/dist/components/layout/Board/grid-core/collision.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 //#region src/components/layout/Board/grid-core/collision.ts
 /**
 * Check if two layout items collide (overlap).

package/dist/components/layout/Board/grid-core/compactors.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 import { collides, getFirstCollision } from "./collision.js";
 import { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from "./sort.js";
 import { bottom, cloneLayout, cloneLayoutItem, getStatics } from "./layout.js";

package/dist/components/layout/Board/grid-core/constraints.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 //#region src/components/layout/Board/grid-core/constraints.ts
 function clamp(value, min, max) {
 	return Math.max(min, Math.min(max, value));

package/dist/components/layout/Board/grid-core/group-move.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 import { collides, getFirstCollision } from "./collision.js";
 import { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from "./sort.js";
 import { bottom, cloneLayout, cloneLayoutItem, getStatics } from "./layout.js";

package/dist/components/layout/Board/grid-core/layout.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 import { getAllCollisions, getFirstCollision } from "./collision.js";
 import { sortLayoutItems } from "./sort.js";
 

package/dist/components/layout/Board/grid-core/placement.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 import { collides } from "./collision.js";
 
 //#region src/components/layout/Board/grid-core/placement.ts

package/dist/components/layout/Board/grid-core/sort.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 //#region src/components/layout/Board/grid-core/sort.ts
 /**
 * Sort layout items based on the compaction type.

package/dist/components/layout/Board/index.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 import { distributeEvenly, placeInFreeSlot } from "./grid-core/placement.js";
 import { getCompactor, horizontalCompactor, noCompactor, verticalCompactor } from "./grid-core/compactors.js";
 import { aspectRatio, boundedX, boundedY, containerBounds, gridBounds, maxSize, minMaxSize, minSize, snapToGrid } from "./grid-core/constraints.js";

package/dist/components/layout/Board/responsive-utils.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 import { cloneLayout, correctBounds } from "./grid-core/layout.js";
 
 //#region src/components/layout/Board/responsive-utils.ts

package/dist/components/layout/Board/use-board-layout.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { cloneLayout } from "./grid-core/layout.js";
 import { useCallback, useEffect, useRef, useState } from "react";

package/dist/components/layout/Board/use-board-registry.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.170.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.171.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { BoardWidgetStore } from "./board-store.js";
 import { collides } from "./grid-core/collision.js";
@@ -70,6 +70,41 @@ function hasNewOverlap(before, after) {
 	return false;
 }
 /**
+* Where a cross-board arrival ends up when the destination refuses the very first
+* cell it was offered.
+*
+* `moveElement` answers a refused placement by restoring the item to where it
+* came from. Every frame after the first has a real cell to go back to - the one
+* the previous frame settled on - so the preview simply holds there, which is
+* what keeps the placeholder from jumping about as the pointer sweeps across an
+* occupied widget. The *first* frame on a board has no such cell: its origin is
+* the synthetic seed one row above (or column left of) the anchor, which sits off
+* the board entirely whenever the anchor is in row 0 or column 0. Holding that
+* would preview - and commit - a widget outside the grid.
+*
+* So only that first frame relocates, to the nearest cell that can hold the
+* widget. The destination's own widgets are the fixed `others`: an arrival is
+* placed around them and never displaces one.
+*
+* A refusal is read off `origin` - the seed itself - rather than off the
+* requested cell, because a resolver is allowed to place the widget somewhere
+* other than the exact cell asked for (downscaling into room the anchor clamp hid
+* from the pointer does exactly that). Only an item sitting back on its origin was
+* actually refused; anything else is a resolution and stands.
+*/
+function landIncoming(layout, others, itemId, origin, landing, cols, maxRows) {
+	const placed = getLayoutItem(layout, itemId);
+	if (!placed || placed.x !== origin.x || placed.y !== origin.y) return layout;
+	const landed = placeInFreeSlot(others, {
+		...placed,
+		...landing
+	}, cols, maxRows);
+	return layout.map((l) => l.i === itemId ? {
+		...l,
+		...landed
+	} : l);
+}
+/**
 * Whether any item in `after` has a different size than it had in `before`.
 */
 function resizesAnything(before, after) {
@@ -89,7 +124,6 @@ function useBoardRegistry(options) {
 	const sourceSnapshotRef = useRef([]);
 	const targetSnapshotsRef = useRef(/* @__PURE__ */ new Map());
 	const previewRef = useRef(null);
-	const targetLandingRef = useRef(null);
 	const frozenRectsRef = useRef(/* @__PURE__ */ new Map());
 	const nestedInDraggedRef = useRef(/* @__PURE__ */ new Set());
 	const lastLandingRef = useRef(null);
@@ -204,7 +238,6 @@ function useBoardRegistry(options) {
 		affectedRef.current = new Set([boardId]);
 		sourceSnapshotRef.current = cloneLayout(entry.getLayout());
 		previewRef.current = null;
-		targetLandingRef.current = null;
 		lastLandingRef.current = {
 			x: item.x,
 			y: item.y
@@ -436,7 +469,6 @@ function useBoardRegistry(options) {
 	const previewOnTarget = useCallback((target, item, x, y) => {
 		const pp = target.getPositionParams();
 		const compactor = target.getCompactor();
-		const strictIncomingSwap = compactor.preventCollision === true && !compactor.allowOverlap && target.getCollisionMode() === "swap";
 		const carried = previewRef.current?.boardId === target.id ? previewRef.current.working : null;
 		const base = cloneLayout(carried ?? targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== item.i);
 		const prevItem = carried ? getLayoutItem(carried, item.i) : void 0;
@@ -453,7 +485,12 @@ function useBoardRegistry(options) {
 			x,
 			y: Math.max(0, y) - 1
 		};
-		const moved = moveElement([...base, dragged], dragged, x, y, true, compactor.preventCollision, compactor.type, pp.cols, compactor.allowOverlap, { resolveCollision: compactor.preventCollision ? createCollisionResolver(target.getCollisionMode(), {
+		const working = [...base, dragged];
+		const origin = {
+			x: dragged.x,
+			y: dragged.y
+		};
+		const moved = moveElement(working, dragged, x, y, true, compactor.preventCollision, compactor.type, pp.cols, compactor.allowOverlap, { resolveCollision: compactor.preventCollision ? createCollisionResolver(target.getCollisionMode(), {
 			cols: pp.cols,
 			maxRows: target.getMaxRows(),
 			desired: {
@@ -462,40 +499,16 @@ function useBoardRegistry(options) {
 			},
 			allowExchange: false
 		}) : void 0 });
-		const compacted = strictIncomingSwap ? cloneLayout(moved) : [...compactor.compact(moved, pp.cols)];
+		const compacted = [...compactor.compact(prevItem ? moved : landIncoming(moved, base, item.i, origin, {
+			x,
+			y
+		}, pp.cols, target.getMaxRows()), pp.cols)];
 		const landed = getLayoutItem(compacted, item.i);
-		if (!compactor.allowOverlap && hasNewOverlap(overlappingPairs(base), compacted)) {
-			if (strictIncomingSwap) {
-				const snapshot = targetSnapshotsRef.current.get(target.id);
-				if (snapshot) target.applyLayout(cloneLayout(snapshot), false);
-				target.setPlaceholders([]);
-				previewRef.current = null;
-				targetLandingRef.current = {
-					boardId: target.id,
-					valid: false
-				};
-			}
-			return;
-		}
-		if (strictIncomingSwap && (!landed || landed.x !== x || landed.y !== y)) {
-			const snapshot = targetSnapshotsRef.current.get(target.id);
-			if (snapshot) target.applyLayout(cloneLayout(snapshot), false);
-			target.setPlaceholders([]);
-			previewRef.current = null;
-			targetLandingRef.current = {
-				boardId: target.id,
-				valid: false
-			};
-			return;
-		}
+		if (!compactor.allowOverlap && hasNewOverlap(overlappingPairs(base), compacted)) return;
 		previewRef.current = {
 			boardId: target.id,
 			working: compacted
 		};
-		targetLandingRef.current = {
-			boardId: target.id,
-			valid: true
-		};
 		const previewItem = landed ?? {
 			...item,
 			x,
@@ -547,7 +560,6 @@ function useBoardRegistry(options) {
 				if (snap) prev?.applyLayout(cloneLayout(snap), false);
 				prev?.setPlaceholders([]);
 				previewRef.current = null;
-				targetLandingRef.current = null;
 			}
 			if (isGroup) moveGroupWithinBoard(target, ds, x - ds.item.x, y - ds.item.y);
 			else moveWithinBoard(target, ds.item, x, y);
@@ -567,7 +579,6 @@ function useBoardRegistry(options) {
 			}
 			prev?.setPlaceholders([]);
 			previewRef.current = null;
-			targetLandingRef.current = null;
 			if (!targetSnapshotsRef.current.has(target.id)) targetSnapshotsRef.current.set(target.id, cloneLayout(target.getLayout()));
 		}
 		previewOnTarget(target, ds.item, x, y);
@@ -598,61 +609,58 @@ function useBoardRegistry(options) {
 			};
 			const tp = target.getPositionParams();
 			const tc = target.getCompactor();
-			const strictIncomingSwap = tc.preventCollision === true && !tc.allowOverlap && target.getCollisionMode() === "swap";
 			const carried = previewRef.current?.boardId === target.id && getLayoutItem(previewRef.current.working, ds.itemId) ? previewRef.current.working : null;
-			const hasValidStrictLanding = targetLandingRef.current?.boardId === target.id && targetLandingRef.current.valid && carried != null;
-			if (strictIncomingSwap && !hasValidStrictLanding) {
-				if (source) source.applyLayout(cloneLayout(sourceSnapshotRef.current), false);
-				const targetSnapshot = targetSnapshotsRef.current.get(target.id);
-				if (targetSnapshot) target.applyLayout(cloneLayout(targetSnapshot), false);
-			} else {
-				if (source) {
-					const sp = source.getPositionParams();
-					const sc = source.getCompactor();
-					const remaining = source.getLayout().filter((l) => l.i !== ds.itemId);
-					source.applyLayout([...sc.compact(remaining, sp.cols)], true, "transfer");
-				}
-				let finalLayout;
-				if (carried) finalLayout = strictIncomingSwap ? cloneLayout(carried) : [...tc.compact(cloneLayout(carried), tp.cols)];
-				else {
-					const newItem = tc.type === "horizontal" ? {
-						...ds.item,
-						x: Math.max(0, landing.x) - 1,
-						y: landing.y
-					} : {
-						...ds.item,
-						x: landing.x,
-						y: Math.max(0, landing.y) - 1
-					};
-					const moved = moveElement([...cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId)), newItem], newItem, landing.x, landing.y, true, tc.preventCollision, tc.type, tp.cols, tc.allowOverlap, { resolveCollision: createCollisionResolver(target.getCollisionMode(), {
-						cols: tp.cols,
-						maxRows: tp.maxRows,
-						desired: {
-							w: ds.item.w,
-							h: ds.item.h
-						},
-						allowExchange: false
-					}) });
-					finalLayout = [...tc.compact(moved, tp.cols)];
-				}
-				const targetOthers = cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId));
-				if (!tc.allowOverlap && hasNewOverlap(overlappingPairs(targetOthers), finalLayout)) finalLayout = [...targetOthers, placeInFreeSlot(targetOthers, {
+			if (source) {
+				const sp = source.getPositionParams();
+				const sc = source.getCompactor();
+				const remaining = source.getLayout().filter((l) => l.i !== ds.itemId);
+				source.applyLayout([...sc.compact(remaining, sp.cols)], true, "transfer");
+			}
+			let finalLayout;
+			if (carried) finalLayout = [...tc.compact(cloneLayout(carried), tp.cols)];
+			else {
+				const newItem = tc.type === "horizontal" ? {
 					...ds.item,
-					x: landing.x,
+					x: Math.max(0, landing.x) - 1,
 					y: landing.y
-				}, tp.cols, tp.maxRows)];
-				target.applyLayout(finalLayout, true, "transfer");
-				onTransferRef.current?.({
-					widgetId: ds.itemId,
-					fromBoardId: ds.sourceBoardId,
-					toBoardId: target.id,
-					item: getLayoutItem(finalLayout, ds.itemId) ?? {
-						...ds.item,
-						x: landing.x,
-						y: landing.y
-					}
-				});
+				} : {
+					...ds.item,
+					x: landing.x,
+					y: Math.max(0, landing.y) - 1
+				};
+				const base = [...cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId)), newItem];
+				const seed = {
+					x: newItem.x,
+					y: newItem.y
+				};
+				const moved = moveElement(base, newItem, landing.x, landing.y, true, tc.preventCollision, tc.type, tp.cols, tc.allowOverlap, { resolveCollision: createCollisionResolver(target.getCollisionMode(), {
+					cols: tp.cols,
+					maxRows: tp.maxRows,
+					desired: {
+						w: ds.item.w,
+						h: ds.item.h
+					},
+					allowExchange: false
+				}) });
+				finalLayout = [...tc.compact(landIncoming(moved, base.filter((l) => l.i !== ds.itemId), ds.itemId, seed, landing, tp.cols, tp.maxRows), tp.cols)];
 			}
+			const targetOthers = cloneLayout((targetSnapshotsRef.current.get(target.id) ?? target.getLayout()).filter((l) => l.i !== ds.itemId));
+			if (!tc.allowOverlap && hasNewOverlap(overlappingPairs(targetOthers), finalLayout)) finalLayout = [...targetOthers, placeInFreeSlot(targetOthers, {
+				...ds.item,
+				x: landing.x,
+				y: landing.y
+			}, tp.cols, tp.maxRows)];
+			target.applyLayout(finalLayout, true, "transfer");
+			onTransferRef.current?.({
+				widgetId: ds.itemId,
+				fromBoardId: ds.sourceBoardId,
+				toBoardId: target.id,
+				item: getLayoutItem(finalLayout, ds.itemId) ?? {
+					...ds.item,
+					x: landing.x,
+					y: landing.y
+				}
+			});
 		}
 		const ids = new Set(affectedRef.current);
 		ids.add(ds.sourceBoardId);
@@ -664,7 +672,6 @@ function useBoardRegistry(options) {
 		frozenRectsRef.current.clear();
 		nestedInDraggedRef.current = /* @__PURE__ */ new Set();
 		previewRef.current = null;
-		targetLandingRef.current = null;
 		lastLandingRef.current = null;
 		setDragState(null);
 	});