@cube-dev/ui-kit 0.164.0 → 0.165.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 * `'swap'` is an escalation ladder, tried in order: exchange with one of the\n * widgets under the drop, else downscale at the drop cell, else revert. A dense\n * 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 */\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 * 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":";;;AA0BA,SAAS,SAAS,QAAgB,GAAW,GAAoB;AAC/D,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,IAAI,OAAO;AACjB,MACE,MAAM,UACN,KAAK,EAAE,KACP,IAAI,EAAE,IAAI,EAAE,KACZ,KAAK,EAAE,KACP,IAAI,EAAE,IAAI,EAAE,EAEZ,QAAO;;AAGX,QAAO;;;;;;;;;;;;;;;;AAiBT,SAAgB,cACd,QACA,QACA,SACA,QACA,MACiC;AACjC,KAAI,OAAO,IAAI,KAAK,OAAO,IAAI,EAAG,QAAO;CAEzC,MAAM,OAAO,KAAK,IAAI,GAAG,MAAM,QAAQ,EAAE;CACzC,MAAM,OAAO,KAAK,IAAI,GAAG,MAAM,QAAQ,EAAE;CACzC,MAAM,UAAU,OAAO,WAAW;CAClC,MAAM,OAAO,KAAK,IAAI,QAAQ,GAAG,OAAO,OAAO,OAAO,EAAE;CACxD,MAAM,OAAO,KAAK,IAChB,QAAQ,GACR,OAAO,SAAS,QAAQ,GAAG,UAAU,OAAO,IAAI,QAAQ,EACzD;AAED,KAAI,OAAO,QAAQ,OAAO,KAAM,QAAO;CAIvC,MAAM,OAAiB,EAAE;AACzB,MAAK,IAAI,KAAK,GAAG,KAAK,MAAM,MAAM;EAChC,IAAI,IAAI;AACR,SAAO,IAAI,QAAQ,SAAS,QAAQ,OAAO,IAAI,IAAI,OAAO,IAAI,EAAE,CAAE;AAClE,OAAK,KAAK,EAAE;AAEZ,MAAI,MAAM,EAAG;;CAGf,IAAI,OAAwC;CAC5C,IAAI,WAAW;CACf,IAAI,QAAQ;AACZ,MAAK,IAAI,IAAI,GAAG,KAAK,KAAK,QAAQ,KAAK;AACrC,UAAQ,KAAK,IAAI,OAAO,KAAK,IAAI,GAAI;AACrC,MAAI,QAAQ,KAAM;AAClB,MAAI,IAAI,KAAM;EACd,MAAM,OAAO,IAAI;AAGjB,MAAI,QAAQ,UAAU;AACpB,UAAO;IAAE;IAAG,GAAG;IAAO;AACtB,cAAW;;;AAIf,QAAO;;;;;;AAOT,SAAS,iBACP,QACA,MACA,QACA,SACA,QACqB;CACrB,MAAM,MAAM,cACV,QACA;EAAE,GAAG,KAAK;EAAG,GAAG,KAAK;EAAG,EACxB,SACA,QACA,KACD;AACD,KAAI,CAAC,IAAK,QAAO;AAGjB,KAAI,IAAI,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,EAAG,QAAO;AAEjD,QAAO,OAAO,KAAK,MACjB,EAAE,MAAM,KAAK,IAAI;EAAE,GAAG;EAAG,GAAG,IAAI;EAAG,GAAG,IAAI;EAAG,OAAO;EAAM,GAAG,EAC9D;;;AAIH,SAAS,YAAY,GAAe,GAAuB;CACzD,MAAM,IAAI,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE;CAC7D,MAAM,IAAI,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE;AAC7D,QAAO,IAAI,KAAK,IAAI,IAAI,IAAI,IAAI;;;;;;;;;;;;;;;;;;AAmBlC,SAAS,sBACP,QACA,MACA,YACA,MACA,SACA,QACqB;AAGrB,KAAI,KAAK,MAAM,KAAK,KAAK,KAAK,MAAM,KAAK,EAAG,QAAO;CASnD,MAAM,aAAa,WAChB,QAAQ,MAAM,CAAC,EAAE,OAAO,CACxB,KAAK,OAAO;EAAE;EAAG,MAAM,YAAY,MAAM,EAAE;EAAE,EAAE,CAC/C,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,CACjE,KAAK,EAAE,QAAQ,EAAE;AAEpB,MAAK,MAAM,SAAS,YAAY;EAC9B,MAAM,YAAY,aAAa,QAAQ,MAAM,OAAO,MAAM,SAAS,OAAO;AAC1E,MAAI,UAAW,QAAO;;AAExB,QAAO;;;AAIT,SAAS,aACP,QACA,MACA,OACA,MACA,SACA,QACqB;CACrB,MAAM,OAAO,OAAO,QAAQ,MAAM,EAAE,MAAM,KAAK,KAAK,EAAE,MAAM,MAAM,EAAE;CAIpE,MAAM,aAAyB;EAC7B,GAAG;EACH,GAAG,KAAK;EACR,GAAG,KAAK;EACR,GAAG,QAAQ;EACX,GAAG,QAAQ;EACZ;CAED,MAAM,WAAW,cACf,CAAC,GAAG,MAAM,WAAW,EACrB;EAAE,GAAG,MAAM;EAAG,GAAG,MAAM;EAAG,EAC1B,SACA,QACA,KACD;AACD,KAAI,CAAC,SAAU,QAAO;CACtB,MAAM,QAAoB;EACxB,GAAG;EACH,GAAG,MAAM;EACT,GAAG,MAAM;EACT,GAAG,SAAS;EACZ,GAAG,SAAS;EACZ,OAAO;EACR;CAED,MAAM,eAAe,cACnB,CAAC,GAAG,MAAM,MAAM,EAChB;EAAE,GAAG,KAAK;EAAG,GAAG,KAAK;EAAG,EACxB;EAAE,GAAG,MAAM;EAAG,GAAG,MAAM;EAAG,EAC1B,QACA,MACD;AACD,KAAI,CAAC,aAAc,QAAO;CAC1B,MAAM,YAAwB;EAC5B,GAAG;EACH,GAAG,KAAK;EACR,GAAG,KAAK;EACR,GAAG,aAAa;EAChB,GAAG,aAAa;EAChB,OAAO;EACR;AAED,QAAO,OAAO,KAAK,MACjB,EAAE,MAAM,KAAK,IAAI,QAAQ,EAAE,MAAM,MAAM,IAAI,YAAY,EACxD;;;;;;;;;;;;;;;AAgBH,SAAgB,wBACd,MACA,SAC+B;AAC/B,KAAI,CAAC,QAAQ,SAAS,SAAU,QAAO;CAEvC,MAAM,SAAS;EAAE,MAAM,QAAQ;EAAM,SAAS,QAAQ;EAAS;AAE/D,SAAQ,EAAE,QAAQ,MAAM,YAAY,WAAW;EAC7C,MAAM,SAAS,OAAO,QAAQ,MAAM,EAAE,MAAM,KAAK,EAAE;EACnD,MAAM,UAAU,QAAQ,WAAW;GAAE,GAAG,KAAK;GAAG,GAAG,KAAK;GAAG;AAE3D,MAAI,SAAS,UAAU,QAAQ,kBAAkB,OAAO;GACtD,MAAM,YAAY,sBAChB,QACA,MACA,YACA,MACA,SACA,OACD;AACD,OAAI,UAAW,QAAO;;AAGxB,SAAO,iBAAiB,QAAQ,MAAM,QAAQ,SAAS,OAAO"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.0 | Cube Dev Team */
 import { getAllCollisions, getFirstCollision } from "./collision.js";
 import { sortLayoutItems } from "./sort.js";
 

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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/grid-core/types.d.ts

@@ -93,10 +93,12 @@ type CompactType = 'horizontal' | 'vertical' | 'wrap' | null;
  * - `'revert'` - snap the item back to where it was (the engine's own default).
  * - `'downscale'` - shrink the item into the free space at the cell it was
  *   dropped on, growing rightward and downward. Never upscales.
- * - `'swap'` - exchange with one widget: the dragged widget takes the cell of the
- *   widget the drop covers most, and that widget takes the cell the dragged one
- *   came from, each keeping as much of its own size as fits there. Never displaces
- *   more than that one widget. Else downscale, else revert.
+ * - `'swap'` - inside one board, exchange with one widget: the dragged widget
+ *   takes the cell of the widget the drop covers most, and that widget takes the
+ *   cell the dragged one came from, each keeping as much of its own size as fits
+ *   there. Across boards, insert only at an empty anchor and downscale without
+ *   exchanging or reflowing destination widgets; an invalid landing cancels the
+ *   transfer. Never displaces more than one widget. Else downscale, else revert.
  *
  * Only consulted where a move would otherwise be refused, so it has no effect in
  * the compacting modes (a collision pushes neighbours there) or under

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.0 | Cube Dev Team */
 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";
 import { BoardProvider } from "./BoardProvider.js";

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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.164.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.165.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";
@@ -140,6 +140,7 @@ 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);
@@ -254,6 +255,7 @@ 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
@@ -485,6 +487,7 @@ 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;
@@ -510,19 +513,47 @@ function useBoardRegistry(options) {
 			},
 			allowExchange: false
 		}) : void 0 });
-		const compacted = [...compactor.compact(moved, pp.cols)];
-		if (!compactor.allowOverlap && hasNewOverlap(overlappingPairs(base), compacted)) return;
+		const compacted = strictIncomingSwap ? cloneLayout(moved) : [...compactor.compact(moved, 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;
+		}
 		previewRef.current = {
 			boardId: target.id,
 			working: compacted
 		};
-		const landed = getLayoutItem(compacted, item.i) ?? {
+		targetLandingRef.current = {
+			boardId: target.id,
+			valid: true
+		};
+		const previewItem = landed ?? {
 			...item,
 			x,
 			y
 		};
 		target.applyLayout(compacted.filter((l) => l.i !== item.i), false);
-		target.setPlaceholders([{ ...landed }]);
+		target.setPlaceholders([{ ...previewItem }]);
 	}, []);
 	const onDragMove = useEvent((deltaX, deltaY, pointerType) => {
 		const ds = dragStateRef.current;
@@ -567,6 +598,7 @@ 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);
@@ -586,6 +618,7 @@ 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);
@@ -614,55 +647,63 @@ function useBoardRegistry(options) {
 				x: ds.item.x,
 				y: ds.item.y
 			};
-			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);
-			}
 			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;
-			let finalLayout;
-			if (carried) finalLayout = [...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, {
-				...ds.item,
-				x: landing.x,
-				y: landing.y
-			}, tp.cols, tp.maxRows)];
-			target.applyLayout(finalLayout, true);
-			onTransferRef.current?.({
-				widgetId: ds.itemId,
-				fromBoardId: ds.sourceBoardId,
-				toBoardId: target.id,
-				item: getLayoutItem(finalLayout, ds.itemId) ?? {
+			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);
+				}
+				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, {
 					...ds.item,
 					x: landing.x,
 					y: landing.y
-				}
-			});
+				}, tp.cols, tp.maxRows)];
+				target.applyLayout(finalLayout, true);
+				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);
@@ -674,6 +715,7 @@ function useBoardRegistry(options) {
 		frozenRectsRef.current.clear();
 		nestedInDraggedRef.current = /* @__PURE__ */ new Set();
 		previewRef.current = null;
+		targetLandingRef.current = null;
 		lastLandingRef.current = null;
 		setDragState(null);
 	});