@cube-dev/ui-kit 0.163.0 → 0.164.0

package/dist/components/layout/Board/board-context.js.map

@@ -1 +1 @@
-{"version":3,"file":"board-context.js","names":[],"sources":["../../../../src/components/layout/Board/board-context.tsx"],"sourcesContent":["import { createContext, MutableRefObject, useContext } from 'react';\n\nimport type { BoardWidgetStore } from './board-store';\nimport type {\n  Compactor,\n  LayoutConstraint,\n  LayoutItem,\n  PositionParams,\n} from './grid-core';\n\n/** A rectangle in viewport (client) coordinates. */\nexport interface ViewportRect {\n  left: number;\n  top: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Everything the cross-board registry needs to read from / write to a single\n * board. Methods read live refs so a single stable entry can be registered once\n * per board and stay current across renders.\n */\nexport interface BoardEntry {\n  id: string;\n  /** Viewport rect of the content area where widgets are positioned. */\n  getContentRect: () => DOMRect | null;\n  /** The DOM node of the content area (used to detect nested-in-drag boards). */\n  getContentNode: () => HTMLElement | null;\n  getPositionParams: () => PositionParams;\n  getConstraints: () => LayoutConstraint[];\n  getCompactor: () => Compactor;\n  getMaxRows: () => number;\n  getContainerHeight: () => number;\n  getLayout: () => LayoutItem[];\n  /**\n   * Keys of the widgets currently selected on this board, or `null` when the\n   * board has no selection. Read at drag start to decide whether the gesture\n   * moves one widget or a whole group.\n   */\n  getSelectedKeys: () => ReadonlySet<string> | null;\n  /** Update the board layout. `commit` fires `onLayoutChange`. */\n  applyLayout: (layout: LayoutItem[], commit: boolean) => void;\n  /** Replace every drop-slot preview. Pass `[]` to clear. */\n  setPlaceholders: (items: LayoutItem[]) => void;\n  isDroppable: () => boolean;\n}\n\n/** Emitted when a widget is dropped from one board into another. */\nexport interface WidgetTransferInfo {\n  widgetId: string;\n  fromBoardId: string;\n  toBoardId: string;\n  item: LayoutItem;\n}\n\n/** Live drag state, shared across boards for overlay + placeholders. */\nexport interface BoardDragState {\n  sourceBoardId: string;\n  /** Board currently owning the dragged item (changes as it crosses boards). */\n  currentBoardId: string;\n  itemId: string;\n  /** Snapshot of the dragged item (grid units; w/h preserved across boards). */\n  item: LayoutItem;\n  /**\n   * Every widget moving in this gesture, the grabbed one first. Length 1 for an\n   * ordinary drag, so `itemIds[0] === itemId` always holds and any check against\n   * this set is a strict superset of the equivalent check against `itemId`.\n   */\n  itemIds: string[];\n  /** Drag-start snapshots of `itemIds`, in the same order. */\n  items: LayoutItem[];\n  /** Dragged widget rect in viewport coordinates (follows the pointer). */\n  rect: ViewportRect;\n  /** `rect` as measured at drag start — lets any host derive the gesture delta. */\n  startRect: ViewportRect;\n  /**\n   * Viewport rect of every group member's host, measured once at drag start.\n   * Drag start is the only safe window to measure (see `frozenRectsRef` in the\n   * registry); measuring later would feed the preview back into itself.\n   */\n  memberRects: Map<string, ViewportRect>;\n  pointerType: string;\n  /**\n   * Ids of boards nested inside the dragged widget, captured at drag start.\n   * Such a board is never a drop target, and it suppresses its own grid-line\n   * overlay while its host widget is being dragged (the whole widget floats, so\n   * the inner grid lines would only add clutter).\n   */\n  nestedBoardIds: Set<string>;\n}\n\nexport interface BoardRegistryContextValue {\n  store: BoardWidgetStore;\n  overlayRef: MutableRefObject<HTMLDivElement | null>;\n  registerBoard: (entry: BoardEntry) => () => void;\n  onDragStart: (\n    boardId: string,\n    itemId: string,\n    rect: ViewportRect,\n    pointerType: string,\n    /** The dragged widget's host node, used to exclude boards nested inside it. */\n    widgetNode: HTMLElement | null,\n  ) => void;\n  onDragMove: (deltaX: number, deltaY: number, pointerType: string) => void;\n  onDragEnd: () => void;\n  dragState: BoardDragState | null;\n  /**\n   * Synchronously-updated mirror of `dragState`. `dragState` is React state, so\n   * a handler running in the same tick as `onDragStart` — such as the drag\n   * lifecycle `WidgetHost` fires immediately afterwards — still sees the\n   * previous value and must read this instead.\n   */\n  getDragState: () => BoardDragState | null;\n}\n\nexport const BoardRegistryContext =\n  createContext<BoardRegistryContextValue | null>(null);\n\nexport function useBoardRegistry(): BoardRegistryContextValue | null {\n  return useContext(BoardRegistryContext);\n}\n\n/**\n * A stable boolean signalling whether a Board widget is currently being\n * dragged. Provided by `BoardProvider` (and therefore by any standalone\n * `Board`, which self-wraps in one). Unlike the full `dragState`, this only\n * flips on drag start/end, so components that only care about \"is a drag in\n * progress\" (e.g. `Tabs` spring-loading a tab on hover) can subscribe without\n * re-rendering on every pointer move. Defaults to `false` outside any Board.\n */\nexport const BoardDragActiveContext = createContext<boolean>(false);\n\nexport function useBoardDragActive(): boolean {\n  return useContext(BoardDragActiveContext);\n}\n\n/**\n * Whether an ancestor `Board` has its grid-line overlay enabled. A nested board\n * that does not set `showGridLines` explicitly reads this to inherit the\n * behaviour, showing its own grid lines while a drag is in progress. Defaults to\n * `false` outside any grid-lined board.\n */\nexport const BoardGridLinesContext = createContext<boolean>(false);\n\nexport function useBoardGridLines(): boolean {\n  return useContext(BoardGridLinesContext);\n}\n\n/**\n * The resolved grid metrics a `Board` exposes to any boards nested inside its\n * widgets. A nested board with `isAligned` reads these to inherit the parent's\n * column pitch (column width + horizontal margin) and target row height, so its\n * cells line up with the surrounding layout instead of stretching.\n */\nexport interface BoardMetrics {\n  /** Resolved pixel width of one parent column. */\n  colWidth: number;\n  /** Resolved parent row height in pixels (the alignment target). */\n  rowHeight: number;\n  /** Parent [horizontal, vertical] margin between widgets in pixels. */\n  margin: readonly [number, number];\n  /** Parent [horizontal, vertical] container padding in pixels. */\n  containerPadding: readonly [number, number];\n}\n\nexport const BoardMetricsContext = createContext<BoardMetrics | null>(null);\n\nexport function useBoardMetrics(): BoardMetrics | null {\n  return useContext(BoardMetricsContext);\n}\n\n/**\n * Information a `WidgetHost` exposes to the content it renders (including a\n * nested `Board`). Lets a nested board know whether its host widget auto-sizes\n * its height and, if so, ask the host to grow to fit the board's natural size.\n */\nexport interface BoardHost {\n  /** Whether the host widget grows its height to fit its content. */\n  isAutoHeight: boolean;\n  /**\n   * Ask the host widget to grow so it provides `px` more content height. Only\n   * ever increases the host's height. No-op when the host does not auto-size.\n   */\n  requestHeightDeficit: (px: number) => void;\n}\n\nexport const BoardHostContext = createContext<BoardHost | null>(null);\n\nexport function useBoardHost(): BoardHost | null {\n  return useContext(BoardHostContext);\n}\n"],"mappings":";;;;AAoHA,MAAa,uBACX,cAAgD,KAAK;AAEvD,SAAgB,mBAAqD;AACnE,QAAO,WAAW,qBAAqB;;;;;;;;;;AAWzC,MAAa,yBAAyB,cAAuB,MAAM;AAEnE,SAAgB,qBAA8B;AAC5C,QAAO,WAAW,uBAAuB;;;;;;;;AAS3C,MAAa,wBAAwB,cAAuB,MAAM;AAElE,SAAgB,oBAA6B;AAC3C,QAAO,WAAW,sBAAsB;;AAoB1C,MAAa,sBAAsB,cAAmC,KAAK;AAE3E,SAAgB,kBAAuC;AACrD,QAAO,WAAW,oBAAoB;;AAkBxC,MAAa,mBAAmB,cAAgC,KAAK;AAErE,SAAgB,eAAiC;AAC/C,QAAO,WAAW,iBAAiB"}
+{"version":3,"file":"board-context.js","names":[],"sources":["../../../../src/components/layout/Board/board-context.tsx"],"sourcesContent":["import { createContext, MutableRefObject, useContext } from 'react';\n\nimport type { BoardWidgetStore } from './board-store';\nimport type {\n  CollisionMode,\n  Compactor,\n  LayoutConstraint,\n  LayoutItem,\n  PositionParams,\n} from './grid-core';\n\n/** A rectangle in viewport (client) coordinates. */\nexport interface ViewportRect {\n  left: number;\n  top: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Everything the cross-board registry needs to read from / write to a single\n * board. Methods read live refs so a single stable entry can be registered once\n * per board and stay current across renders.\n */\nexport interface BoardEntry {\n  id: string;\n  /** Viewport rect of the content area where widgets are positioned. */\n  getContentRect: () => DOMRect | null;\n  /** The DOM node of the content area (used to detect nested-in-drag boards). */\n  getContentNode: () => HTMLElement | null;\n  getPositionParams: () => PositionParams;\n  getConstraints: () => LayoutConstraint[];\n  getCompactor: () => Compactor;\n  /**\n   * How this board resolves a placement its compactor would otherwise refuse.\n   * A board-level policy rather than part of the `Compactor`, which is a public\n   * type consumers implement.\n   */\n  getCollisionMode: () => CollisionMode;\n  getMaxRows: () => number;\n  getContainerHeight: () => number;\n  getLayout: () => LayoutItem[];\n  /**\n   * Keys of the widgets currently selected on this board, or `null` when the\n   * board has no selection. Read at drag start to decide whether the gesture\n   * moves one widget or a whole group.\n   */\n  getSelectedKeys: () => ReadonlySet<string> | null;\n  /** Update the board layout. `commit` fires `onLayoutChange`. */\n  applyLayout: (layout: LayoutItem[], commit: boolean) => void;\n  /** Replace every drop-slot preview. Pass `[]` to clear. */\n  setPlaceholders: (items: LayoutItem[]) => void;\n  isDroppable: () => boolean;\n}\n\n/** Emitted when a widget is dropped from one board into another. */\nexport interface WidgetTransferInfo {\n  widgetId: string;\n  fromBoardId: string;\n  toBoardId: string;\n  item: LayoutItem;\n}\n\n/** Live drag state, shared across boards for overlay + placeholders. */\nexport interface BoardDragState {\n  sourceBoardId: string;\n  /** Board currently owning the dragged item (changes as it crosses boards). */\n  currentBoardId: string;\n  itemId: string;\n  /** Snapshot of the dragged item (grid units; w/h preserved across boards). */\n  item: LayoutItem;\n  /**\n   * Every widget moving in this gesture, the grabbed one first. Length 1 for an\n   * ordinary drag, so `itemIds[0] === itemId` always holds and any check against\n   * this set is a strict superset of the equivalent check against `itemId`.\n   */\n  itemIds: string[];\n  /** Drag-start snapshots of `itemIds`, in the same order. */\n  items: LayoutItem[];\n  /** Dragged widget rect in viewport coordinates (follows the pointer). */\n  rect: ViewportRect;\n  /** `rect` as measured at drag start — lets any host derive the gesture delta. */\n  startRect: ViewportRect;\n  /**\n   * Viewport rect of every group member's host, measured once at drag start.\n   * Drag start is the only safe window to measure (see `frozenRectsRef` in the\n   * registry); measuring later would feed the preview back into itself.\n   */\n  memberRects: Map<string, ViewportRect>;\n  pointerType: string;\n  /**\n   * Ids of boards nested inside the dragged widget, captured at drag start.\n   * Such a board is never a drop target, and it suppresses its own grid-line\n   * overlay while its host widget is being dragged (the whole widget floats, so\n   * the inner grid lines would only add clutter).\n   */\n  nestedBoardIds: Set<string>;\n}\n\nexport interface BoardRegistryContextValue {\n  store: BoardWidgetStore;\n  overlayRef: MutableRefObject<HTMLDivElement | null>;\n  registerBoard: (entry: BoardEntry) => () => void;\n  onDragStart: (\n    boardId: string,\n    itemId: string,\n    rect: ViewportRect,\n    pointerType: string,\n    /** The dragged widget's host node, used to exclude boards nested inside it. */\n    widgetNode: HTMLElement | null,\n  ) => void;\n  onDragMove: (deltaX: number, deltaY: number, pointerType: string) => void;\n  onDragEnd: () => void;\n  dragState: BoardDragState | null;\n  /**\n   * Synchronously-updated mirror of `dragState`. `dragState` is React state, so\n   * a handler running in the same tick as `onDragStart` — such as the drag\n   * lifecycle `WidgetHost` fires immediately afterwards — still sees the\n   * previous value and must read this instead.\n   */\n  getDragState: () => BoardDragState | null;\n}\n\nexport const BoardRegistryContext =\n  createContext<BoardRegistryContextValue | null>(null);\n\nexport function useBoardRegistry(): BoardRegistryContextValue | null {\n  return useContext(BoardRegistryContext);\n}\n\n/**\n * A stable boolean signalling whether a Board widget is currently being\n * dragged. Provided by `BoardProvider` (and therefore by any standalone\n * `Board`, which self-wraps in one). Unlike the full `dragState`, this only\n * flips on drag start/end, so components that only care about \"is a drag in\n * progress\" (e.g. `Tabs` spring-loading a tab on hover) can subscribe without\n * re-rendering on every pointer move. Defaults to `false` outside any Board.\n */\nexport const BoardDragActiveContext = createContext<boolean>(false);\n\nexport function useBoardDragActive(): boolean {\n  return useContext(BoardDragActiveContext);\n}\n\n/**\n * What a nested `Board` inherits as its `showGridLines` default. The drag-scoped\n * subset of `BoardGridLines`: an ancestor's `true` is handed down as `'drag'`\n * (a nested board shows lines while a drag is in flight, not permanently), while\n * `'any-drag'` is handed down verbatim so the whole nested tree keeps advertising\n * every board a widget could land on.\n */\nexport type BoardInheritedGridLines = false | 'drag' | 'any-drag';\n\n/**\n * Whether an ancestor `Board` has its grid-line overlay enabled, and with which\n * drag scope. A nested board that does not set `showGridLines` explicitly reads\n * this to inherit the behaviour. Defaults to `false` outside any grid-lined\n * board.\n */\nexport const BoardGridLinesContext =\n  createContext<BoardInheritedGridLines>(false);\n\nexport function useBoardGridLines(): BoardInheritedGridLines {\n  return useContext(BoardGridLinesContext);\n}\n\n/**\n * The resolved grid metrics a `Board` exposes to any boards nested inside its\n * widgets. A nested board with `isAligned` reads these to inherit the parent's\n * column pitch (column width + horizontal margin) and target row height, so its\n * cells line up with the surrounding layout instead of stretching.\n */\nexport interface BoardMetrics {\n  /** Resolved pixel width of one parent column. */\n  colWidth: number;\n  /** Resolved parent row height in pixels (the alignment target). */\n  rowHeight: number;\n  /** Parent [horizontal, vertical] margin between widgets in pixels. */\n  margin: readonly [number, number];\n  /** Parent [horizontal, vertical] container padding in pixels. */\n  containerPadding: readonly [number, number];\n}\n\nexport const BoardMetricsContext = createContext<BoardMetrics | null>(null);\n\nexport function useBoardMetrics(): BoardMetrics | null {\n  return useContext(BoardMetricsContext);\n}\n\n/**\n * Information a `WidgetHost` exposes to the content it renders (including a\n * nested `Board`). Lets a nested board know whether its host widget auto-sizes\n * its height and, if so, ask the host to grow to fit the board's natural size.\n */\nexport interface BoardHost {\n  /** Whether the host widget grows its height to fit its content. */\n  isAutoHeight: boolean;\n  /**\n   * Ask the host widget to grow so it provides `px` more content height. Only\n   * ever increases the host's height. No-op when the host does not auto-size.\n   */\n  requestHeightDeficit: (px: number) => void;\n}\n\nexport const BoardHostContext = createContext<BoardHost | null>(null);\n\nexport function useBoardHost(): BoardHost | null {\n  return useContext(BoardHostContext);\n}\n"],"mappings":";;;;AA2HA,MAAa,uBACX,cAAgD,KAAK;AAEvD,SAAgB,mBAAqD;AACnE,QAAO,WAAW,qBAAqB;;;;;;;;;;AAWzC,MAAa,yBAAyB,cAAuB,MAAM;AAEnE,SAAgB,qBAA8B;AAC5C,QAAO,WAAW,uBAAuB;;;;;;;;AAkB3C,MAAa,wBACX,cAAuC,MAAM;AAE/C,SAAgB,oBAA6C;AAC3D,QAAO,WAAW,sBAAsB;;AAoB1C,MAAa,sBAAsB,cAAmC,KAAK;AAE3E,SAAgB,kBAAuC;AACrD,QAAO,WAAW,oBAAoB;;AAkBxC,MAAa,mBAAmB,cAAgC,KAAK;AAErE,SAAgB,eAAiC;AAC/C,QAAO,WAAW,iBAAiB"}

package/dist/components/layout/Board/board-store.d.ts

@@ -1,3 +1,4 @@
 
+import "./Widget.js";
 import { Styles } from "@tenphi/tasty";
 import { ReactNode } from "react";

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
 //#region src/components/layout/Board/board-store.ts
 /**
 * A tiny external store mapping widget id -> registration.
@@ -16,7 +16,7 @@ var BoardWidgetStore = class {
 		const prev = this.map.get(reg.id);
 		this.map.set(reg.id, reg);
 		this.owners.set(reg.id, owner);
-		if (!prev || prev.content !== reg.content || prev.isDraggable !== reg.isDraggable || prev.isResizable !== reg.isResizable || prev.resizeHandles !== reg.resizeHandles || prev.isCard !== reg.isCard || prev.minW !== reg.minW || prev.maxW !== reg.maxW || prev.minH !== reg.minH || prev.maxH !== reg.maxH || prev.constraints !== reg.constraints || prev.qa !== reg.qa || prev.styles !== reg.styles || prev.isAutoHeight !== reg.isAutoHeight || prev.dragCancel !== reg.dragCancel || prev.dragHandle !== reg.dragHandle || prev.isSelectable !== reg.isSelectable || prev.selectionCancel !== reg.selectionCancel || prev["aria-label"] !== reg["aria-label"]) {
+		if (!prev || prev.content !== reg.content || prev.isDraggable !== reg.isDraggable || prev.isResizable !== reg.isResizable || prev.resizeHandles !== reg.resizeHandles || prev.resizeGripPlacement !== reg.resizeGripPlacement || prev.isCard !== reg.isCard || prev.minW !== reg.minW || prev.maxW !== reg.maxW || prev.minH !== reg.minH || prev.maxH !== reg.maxH || prev.constraints !== reg.constraints || prev.qa !== reg.qa || prev.styles !== reg.styles || prev.isAutoHeight !== reg.isAutoHeight || prev.dragCancel !== reg.dragCancel || prev.dragHandle !== reg.dragHandle || prev.isSelectable !== reg.isSelectable || prev.selectionCancel !== reg.selectionCancel || prev["aria-label"] !== reg["aria-label"]) {
 			this.version++;
 			this.emit();
 		}

package/dist/components/layout/Board/board-store.js.map

@@ -1 +1 @@
-{"version":3,"file":"board-store.js","names":[],"sources":["../../../../src/components/layout/Board/board-store.ts"],"sourcesContent":["import type { Styles } from '@tenphi/tasty';\nimport type { ReactNode } from 'react';\nimport type { LayoutConstraint, ResizeHandleAxis } from './grid-core';\n\n/**\n * Declarative registration for a single widget.\n *\n * Widget *content* is decoupled from widget *position*: content is registered\n * here by `Board.Widget` keyed by id, while positioning/ownership lives in a\n * board's layout state. This decoupling is what allows a widget to be hosted\n * (and transferred) between different boards under the same `BoardProvider`.\n */\nexport interface WidgetRegistration {\n  id: string;\n  content: ReactNode;\n  isDraggable?: boolean;\n  isResizable?: boolean;\n  resizeHandles?: ResizeHandleAxis[];\n  /**\n   * Add a card border to this widget (widgets are always filled and rounded).\n   * Falls back to the owning board's `widgetProps.isCard` when unset here.\n   */\n  isCard?: boolean;\n  /** Minimum width in grid columns (fallback when the layout item omits `minW`). */\n  minW?: number;\n  /** Maximum width in grid columns (fallback when the layout item omits `maxW`). */\n  maxW?: number;\n  /** Minimum height in grid rows (fallback when the layout item omits `minH`). */\n  minH?: number;\n  /** Maximum height in grid rows (fallback when the layout item omits `maxH`). */\n  maxH?: number;\n  constraints?: LayoutConstraint[];\n  qa?: string;\n  styles?: Styles;\n  /** Grow this widget's height to fit its content (only ever increases). */\n  isAutoHeight?: boolean;\n  /** Override the board's `dragCancel` selector for this widget. */\n  dragCancel?: string;\n  /** Override the board's `dragHandle` selector for this widget. */\n  dragHandle?: string;\n  /** Disable selection for this widget while the board's selection is on. */\n  isSelectable?: boolean;\n  /** Override the board's `selectionCancel` selector for this widget. */\n  selectionCancel?: string;\n  /** Accessible name; falls back to `qa`, then the layout item id. */\n  'aria-label'?: string;\n}\n\n/**\n * A tiny external store mapping widget id -> registration.\n *\n * Boards read from it via `useSyncExternalStore`, so a change to any widget's\n * content or config re-renders the hosting board without prop drilling through\n * the (possibly cross-board) tree.\n */\nexport class BoardWidgetStore {\n  private map = new Map<string, WidgetRegistration>();\n  // Tracks which mounted `Board.Widget` instance currently owns each id. This\n  // guards against a stale unregister from an unmounting instance clobbering a\n  // freshly-mounted instance's registration - which happens when a widget's\n  // subtree is relocated (e.g. dragging a container widget that hosts a nested\n  // board moves it into the overlay portal, remounting the inner widgets).\n  private owners = new Map<string, object>();\n  private listeners = new Set<() => void>();\n  private version = 0;\n\n  register(reg: WidgetRegistration, owner: object): void {\n    const prev = this.map.get(reg.id);\n    this.map.set(reg.id, reg);\n    this.owners.set(reg.id, owner);\n\n    // Notify on any reference change. The hosting board reads registrations\n    // during render, but `Board.Widget` registers in a layout effect (after\n    // commit), so a content/config change lands one commit late and would never\n    // be shown without an emit. Reference comparison is loop-safe: a board's own\n    // re-render reuses the same `children` element references from its\n    // (un-rerendered) parent, so `content` only differs on a genuine parent\n    // update -> we emit once and then settle.\n    const changed =\n      !prev ||\n      prev.content !== reg.content ||\n      prev.isDraggable !== reg.isDraggable ||\n      prev.isResizable !== reg.isResizable ||\n      prev.resizeHandles !== reg.resizeHandles ||\n      prev.isCard !== reg.isCard ||\n      prev.minW !== reg.minW ||\n      prev.maxW !== reg.maxW ||\n      prev.minH !== reg.minH ||\n      prev.maxH !== reg.maxH ||\n      prev.constraints !== reg.constraints ||\n      prev.qa !== reg.qa ||\n      prev.styles !== reg.styles ||\n      prev.isAutoHeight !== reg.isAutoHeight ||\n      prev.dragCancel !== reg.dragCancel ||\n      prev.dragHandle !== reg.dragHandle ||\n      prev.isSelectable !== reg.isSelectable ||\n      prev.selectionCancel !== reg.selectionCancel ||\n      prev['aria-label'] !== reg['aria-label'];\n\n    if (changed) {\n      this.version++;\n      this.emit();\n    }\n  }\n\n  unregister(id: string, owner: object): void {\n    // Ignore unregister calls from an instance that no longer owns the id (a\n    // newer instance has already taken over).\n    if (this.owners.get(id) !== owner) return;\n\n    this.owners.delete(id);\n    if (this.map.delete(id)) {\n      this.version++;\n      this.emit();\n    }\n  }\n\n  get(id: string): WidgetRegistration | undefined {\n    return this.map.get(id);\n  }\n\n  getVersion = (): number => this.version;\n\n  subscribe = (listener: () => void): (() => void) => {\n    this.listeners.add(listener);\n    return () => {\n      this.listeners.delete(listener);\n    };\n  };\n\n  private emit(): void {\n    this.listeners.forEach((listener) => listener());\n  }\n}\n"],"mappings":";;;;;;;;;AAuDA,IAAa,mBAAb,MAA8B;CAC5B,AAAQ,sBAAM,IAAI,KAAiC;CAMnD,AAAQ,yBAAS,IAAI,KAAqB;CAC1C,AAAQ,4BAAY,IAAI,KAAiB;CACzC,AAAQ,UAAU;CAElB,SAAS,KAAyB,OAAqB;EACrD,MAAM,OAAO,KAAK,IAAI,IAAI,IAAI,GAAG;AACjC,OAAK,IAAI,IAAI,IAAI,IAAI,IAAI;AACzB,OAAK,OAAO,IAAI,IAAI,IAAI,MAAM;AA8B9B,MApBE,CAAC,QACD,KAAK,YAAY,IAAI,WACrB,KAAK,gBAAgB,IAAI,eACzB,KAAK,gBAAgB,IAAI,eACzB,KAAK,kBAAkB,IAAI,iBAC3B,KAAK,WAAW,IAAI,UACpB,KAAK,SAAS,IAAI,QAClB,KAAK,SAAS,IAAI,QAClB,KAAK,SAAS,IAAI,QAClB,KAAK,SAAS,IAAI,QAClB,KAAK,gBAAgB,IAAI,eACzB,KAAK,OAAO,IAAI,MAChB,KAAK,WAAW,IAAI,UACpB,KAAK,iBAAiB,IAAI,gBAC1B,KAAK,eAAe,IAAI,cACxB,KAAK,eAAe,IAAI,cACxB,KAAK,iBAAiB,IAAI,gBAC1B,KAAK,oBAAoB,IAAI,mBAC7B,KAAK,kBAAkB,IAAI,eAEhB;AACX,QAAK;AACL,QAAK,MAAM;;;CAIf,WAAW,IAAY,OAAqB;AAG1C,MAAI,KAAK,OAAO,IAAI,GAAG,KAAK,MAAO;AAEnC,OAAK,OAAO,OAAO,GAAG;AACtB,MAAI,KAAK,IAAI,OAAO,GAAG,EAAE;AACvB,QAAK;AACL,QAAK,MAAM;;;CAIf,IAAI,IAA4C;AAC9C,SAAO,KAAK,IAAI,IAAI,GAAG;;CAGzB,mBAA2B,KAAK;CAEhC,aAAa,aAAuC;AAClD,OAAK,UAAU,IAAI,SAAS;AAC5B,eAAa;AACX,QAAK,UAAU,OAAO,SAAS;;;CAInC,AAAQ,OAAa;AACnB,OAAK,UAAU,SAAS,aAAa,UAAU,CAAC"}
+{"version":3,"file":"board-store.js","names":[],"sources":["../../../../src/components/layout/Board/board-store.ts"],"sourcesContent":["import type { Styles } from '@tenphi/tasty';\nimport type { ReactNode } from 'react';\nimport type { LayoutConstraint, ResizeHandleAxis } from './grid-core';\nimport type { BoardResizeGripPlacement } from './Widget';\n\n/**\n * Declarative registration for a single widget.\n *\n * Widget *content* is decoupled from widget *position*: content is registered\n * here by `Board.Widget` keyed by id, while positioning/ownership lives in a\n * board's layout state. This decoupling is what allows a widget to be hosted\n * (and transferred) between different boards under the same `BoardProvider`.\n */\nexport interface WidgetRegistration {\n  id: string;\n  content: ReactNode;\n  isDraggable?: boolean;\n  isResizable?: boolean;\n  resizeHandles?: ResizeHandleAxis[];\n  /** Where the corner resize grips sit (falls back to the board's default). */\n  resizeGripPlacement?: BoardResizeGripPlacement;\n  /**\n   * Add a card border to this widget (widgets are always filled and rounded).\n   * Falls back to the owning board's `widgetProps.isCard` when unset here.\n   */\n  isCard?: boolean;\n  /** Minimum width in grid columns (fallback when the layout item omits `minW`). */\n  minW?: number;\n  /** Maximum width in grid columns (fallback when the layout item omits `maxW`). */\n  maxW?: number;\n  /** Minimum height in grid rows (fallback when the layout item omits `minH`). */\n  minH?: number;\n  /** Maximum height in grid rows (fallback when the layout item omits `maxH`). */\n  maxH?: number;\n  constraints?: LayoutConstraint[];\n  qa?: string;\n  styles?: Styles;\n  /** Grow this widget's height to fit its content (only ever increases). */\n  isAutoHeight?: boolean;\n  /** Override the board's `dragCancel` selector for this widget. */\n  dragCancel?: string;\n  /** Override the board's `dragHandle` selector for this widget. */\n  dragHandle?: string;\n  /** Disable selection for this widget while the board's selection is on. */\n  isSelectable?: boolean;\n  /** Override the board's `selectionCancel` selector for this widget. */\n  selectionCancel?: string;\n  /** Accessible name; falls back to `qa`, then the layout item id. */\n  'aria-label'?: string;\n}\n\n/**\n * A tiny external store mapping widget id -> registration.\n *\n * Boards read from it via `useSyncExternalStore`, so a change to any widget's\n * content or config re-renders the hosting board without prop drilling through\n * the (possibly cross-board) tree.\n */\nexport class BoardWidgetStore {\n  private map = new Map<string, WidgetRegistration>();\n  // Tracks which mounted `Board.Widget` instance currently owns each id. This\n  // guards against a stale unregister from an unmounting instance clobbering a\n  // freshly-mounted instance's registration - which happens when a widget's\n  // subtree is relocated (e.g. dragging a container widget that hosts a nested\n  // board moves it into the overlay portal, remounting the inner widgets).\n  private owners = new Map<string, object>();\n  private listeners = new Set<() => void>();\n  private version = 0;\n\n  register(reg: WidgetRegistration, owner: object): void {\n    const prev = this.map.get(reg.id);\n    this.map.set(reg.id, reg);\n    this.owners.set(reg.id, owner);\n\n    // Notify on any reference change. The hosting board reads registrations\n    // during render, but `Board.Widget` registers in a layout effect (after\n    // commit), so a content/config change lands one commit late and would never\n    // be shown without an emit. Reference comparison is loop-safe: a board's own\n    // re-render reuses the same `children` element references from its\n    // (un-rerendered) parent, so `content` only differs on a genuine parent\n    // update -> we emit once and then settle.\n    const changed =\n      !prev ||\n      prev.content !== reg.content ||\n      prev.isDraggable !== reg.isDraggable ||\n      prev.isResizable !== reg.isResizable ||\n      prev.resizeHandles !== reg.resizeHandles ||\n      prev.resizeGripPlacement !== reg.resizeGripPlacement ||\n      prev.isCard !== reg.isCard ||\n      prev.minW !== reg.minW ||\n      prev.maxW !== reg.maxW ||\n      prev.minH !== reg.minH ||\n      prev.maxH !== reg.maxH ||\n      prev.constraints !== reg.constraints ||\n      prev.qa !== reg.qa ||\n      prev.styles !== reg.styles ||\n      prev.isAutoHeight !== reg.isAutoHeight ||\n      prev.dragCancel !== reg.dragCancel ||\n      prev.dragHandle !== reg.dragHandle ||\n      prev.isSelectable !== reg.isSelectable ||\n      prev.selectionCancel !== reg.selectionCancel ||\n      prev['aria-label'] !== reg['aria-label'];\n\n    if (changed) {\n      this.version++;\n      this.emit();\n    }\n  }\n\n  unregister(id: string, owner: object): void {\n    // Ignore unregister calls from an instance that no longer owns the id (a\n    // newer instance has already taken over).\n    if (this.owners.get(id) !== owner) return;\n\n    this.owners.delete(id);\n    if (this.map.delete(id)) {\n      this.version++;\n      this.emit();\n    }\n  }\n\n  get(id: string): WidgetRegistration | undefined {\n    return this.map.get(id);\n  }\n\n  getVersion = (): number => this.version;\n\n  subscribe = (listener: () => void): (() => void) => {\n    this.listeners.add(listener);\n    return () => {\n      this.listeners.delete(listener);\n    };\n  };\n\n  private emit(): void {\n    this.listeners.forEach((listener) => listener());\n  }\n}\n"],"mappings":";;;;;;;;;AA0DA,IAAa,mBAAb,MAA8B;CAC5B,AAAQ,sBAAM,IAAI,KAAiC;CAMnD,AAAQ,yBAAS,IAAI,KAAqB;CAC1C,AAAQ,4BAAY,IAAI,KAAiB;CACzC,AAAQ,UAAU;CAElB,SAAS,KAAyB,OAAqB;EACrD,MAAM,OAAO,KAAK,IAAI,IAAI,IAAI,GAAG;AACjC,OAAK,IAAI,IAAI,IAAI,IAAI,IAAI;AACzB,OAAK,OAAO,IAAI,IAAI,IAAI,MAAM;AA+B9B,MArBE,CAAC,QACD,KAAK,YAAY,IAAI,WACrB,KAAK,gBAAgB,IAAI,eACzB,KAAK,gBAAgB,IAAI,eACzB,KAAK,kBAAkB,IAAI,iBAC3B,KAAK,wBAAwB,IAAI,uBACjC,KAAK,WAAW,IAAI,UACpB,KAAK,SAAS,IAAI,QAClB,KAAK,SAAS,IAAI,QAClB,KAAK,SAAS,IAAI,QAClB,KAAK,SAAS,IAAI,QAClB,KAAK,gBAAgB,IAAI,eACzB,KAAK,OAAO,IAAI,MAChB,KAAK,WAAW,IAAI,UACpB,KAAK,iBAAiB,IAAI,gBAC1B,KAAK,eAAe,IAAI,cACxB,KAAK,eAAe,IAAI,cACxB,KAAK,iBAAiB,IAAI,gBAC1B,KAAK,oBAAoB,IAAI,mBAC7B,KAAK,kBAAkB,IAAI,eAEhB;AACX,QAAK;AACL,QAAK,MAAM;;;CAIf,WAAW,IAAY,OAAqB;AAG1C,MAAI,KAAK,OAAO,IAAI,GAAG,KAAK,MAAO;AAEnC,OAAK,OAAO,OAAO,GAAG;AACtB,MAAI,KAAK,IAAI,OAAO,GAAG,EAAE;AACvB,QAAK;AACL,QAAK,MAAM;;;CAIf,IAAI,IAA4C;AAC9C,SAAO,KAAK,IAAI,IAAI,GAAG;;CAGzB,mBAA2B,KAAK;CAEhC,aAAa,aAAuC;AAClD,OAAK,UAAU,IAAI,SAAS;AAC5B,eAAa;AACX,QAAK,UAAU,OAAO,SAAS;;;CAInC,AAAQ,OAAa;AACnB,OAAK,UAAU,SAAS,aAAa,UAAU,CAAC"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
 //#region src/components/layout/Board/grid-core/calculate.ts
 /** Calculate the width of a single grid column in pixels. */
 function calcGridColWidth(positionParams) {

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

@@ -0,0 +1,183 @@
+/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
+//#region src/components/layout/Board/grid-core/collision-modes.ts
+/** Whether a single grid cell is free of every item in `others`. */
+function cellFree(others, x, y) {
+	for (let i = 0; i < others.length; i++) {
+		const o = others[i];
+		if (o !== void 0 && x >= o.x && x < o.x + o.w && y >= o.y && y < o.y + o.h) return false;
+	}
+	return true;
+}
+/**
+* The largest rectangle anchored at `anchor` that fits without overlapping
+* `others`, growing rightward and downward only.
+*
+* Never larger than `desired` (a drag must never *upscale* a widget - growing
+* things is an explicit, opt-in operation like "distribute evenly", not a side
+* effect of moving them), never smaller than the item's own `minW`/`minH`, and
+* never past `cols` / `maxRows`. Among the candidates the largest-area rectangle
+* wins, breaking ties on width: a grid is read left to right, so a wide-and-flat
+* result is the less surprising of two equal-area fits.
+*
+* Returns `null` when not even the minimum size fits, which the callers treat as
+* "no resolution" and fall back to reverting.
+*/
+function maxFreeRectAt(others, anchor, desired, limits, mins) {
+	if (anchor.x < 0 || anchor.y < 0) return null;
+	const minW = Math.max(1, mins?.minW ?? 1);
+	const minH = Math.max(1, mins?.minH ?? 1);
+	const maxRows = limits.maxRows ?? Infinity;
+	const maxW = Math.min(desired.w, limits.cols - anchor.x);
+	const maxH = Math.min(desired.h, Number.isFinite(maxRows) ? maxRows - anchor.y : desired.h);
+	if (maxW < minW || maxH < minH) return null;
+	const free = [];
+	for (let dx = 0; dx < maxW; dx++) {
+		let h = 0;
+		while (h < maxH && cellFree(others, anchor.x + dx, anchor.y + h)) h++;
+		free.push(h);
+		if (h === 0) break;
+	}
+	let best = null;
+	let bestArea = 0;
+	let limit = maxH;
+	for (let w = 1; w <= free.length; w++) {
+		limit = Math.min(limit, free[w - 1]);
+		if (limit < minH) break;
+		if (w < minW) continue;
+		const area = w * limit;
+		if (area >= bestArea) {
+			best = {
+				w,
+				h: limit
+			};
+			bestArea = area;
+		}
+	}
+	return best;
+}
+/**
+* Shrink the placement to the room actually available at the cell it was
+* dropped on.
+*/
+function downscaleInPlace(layout, item, others, desired, limits) {
+	const fit = maxFreeRectAt(others, {
+		x: item.x,
+		y: item.y
+	}, desired, limits, item);
+	if (!fit) return null;
+	if (fit.w === item.w && fit.h === item.h) return null;
+	return layout.map((l) => l.i === item.i ? {
+		...l,
+		w: fit.w,
+		h: fit.h,
+		moved: true
+	} : l);
+}
+/** Number of cells two items share. Zero when they do not overlap at all. */
+function overlapArea(a, b) {
+	const w = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x);
+	const h = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y);
+	return w > 0 && h > 0 ? w * h : 0;
+}
+/**
+* Exchange the placement with one of the widgets under it.
+*
+* The dragged widget takes the other's cell and the other takes the cell the
+* dragged widget came from. Each keeps as much of its own size as fits there -
+* that cell plus any free space adjacent to it - and neither ever grows.
+*
+* `from` is whatever the caller's layout says, so it is the caller that decides
+* what "came from" means. A pointer drag resolves every frame against the
+* arrangement the gesture started with, making it the cell the drag began at, and
+* keeping the result a pure function of where the pointer is; chaining frames off
+* each other instead would exchange with every widget swept over.
+* The slot the dragged widget is leaving is reserved for the displaced widget
+* while the dragged one is sized, so the two can never claim the same cells: the
+* result is overlap-free by construction, not by a follow-up check.
+*/
+function exchangeWithCollision(layout, item, collisions, from, desired, limits) {
+	if (from.x === item.x && from.y === item.y) return null;
+	const candidates = collisions.filter((c) => !c.static).map((c) => ({
+		c,
+		area: overlapArea(item, c)
+	})).sort((p, q) => q.area - p.area || p.c.y - q.c.y || p.c.x - q.c.x).map(({ c }) => c);
+	for (const other of candidates) {
+		const exchanged = exchangeWith(layout, item, other, from, desired, limits);
+		if (exchanged) return exchanged;
+	}
+	return null;
+}
+/** One concrete two-widget exchange, or `null` if either side cannot fit. */
+function exchangeWith(layout, item, other, from, desired, limits) {
+	const rest = layout.filter((l) => l.i !== item.i && l.i !== other.i);
+	const originSlot = {
+		i: "origin-slot-reservation",
+		x: from.x,
+		y: from.y,
+		w: desired.w,
+		h: desired.h
+	};
+	const movedFit = maxFreeRectAt([...rest, originSlot], {
+		x: other.x,
+		y: other.y
+	}, desired, limits, item);
+	if (!movedFit) return null;
+	const moved = {
+		...item,
+		x: other.x,
+		y: other.y,
+		w: movedFit.w,
+		h: movedFit.h,
+		moved: true
+	};
+	const displacedFit = maxFreeRectAt([...rest, moved], {
+		x: from.x,
+		y: from.y
+	}, {
+		w: other.w,
+		h: other.h
+	}, limits, other);
+	if (!displacedFit) return null;
+	const displaced = {
+		...other,
+		x: from.x,
+		y: from.y,
+		w: displacedFit.w,
+		h: displacedFit.h,
+		moved: true
+	};
+	return layout.map((l) => l.i === item.i ? moved : l.i === other.i ? displaced : l);
+}
+/**
+* Build the resolver `moveElement` consults instead of reverting a blocked move,
+* or `undefined` for `'revert'` (and for an unset mode), which keeps the engine
+* on its original path with no added work.
+*
+* `'swap'` is an escalation ladder, tried in order: exchange with one of the
+* widgets under the drop, else downscale at the drop cell, else revert. A dense
+* grid stays draggable that way - refusing everything that is not a clean
+* one-to-one trade would make the mode feel broken exactly where it is needed.
+*/
+function createCollisionResolver(mode, options) {
+	if (!mode || mode === "revert") return void 0;
+	const limits = {
+		cols: options.cols,
+		maxRows: options.maxRows
+	};
+	return ({ layout, item, collisions, from }) => {
+		const others = layout.filter((l) => l.i !== item.i);
+		const desired = options.desired ?? {
+			w: item.w,
+			h: item.h
+		};
+		if (mode === "swap" && options.allowExchange !== false) {
+			const exchanged = exchangeWithCollision(layout, item, collisions, from, desired, limits);
+			if (exchanged) return exchanged;
+		}
+		return downscaleInPlace(layout, item, others, desired, limits);
+	};
+}
+
+//#endregion
+export { createCollisionResolver };
+//# sourceMappingURL=collision-modes.js.map

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

@@ -0,0 +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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"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.0 | Cube Dev Team */
 import { getAllCollisions, getFirstCollision } from "./collision.js";
 import { sortLayoutItems } from "./sort.js";
 
@@ -107,7 +107,7 @@ function correctBounds(layout, bounds) {
 *
 * **Note**: mutates the `l` parameter directly for performance.
 */
-function moveElement(layout, l, x, y, isUserAction, preventCollision, compactType, cols, allowOverlap) {
+function moveElement(layout, l, x, y, isUserAction, preventCollision, compactType, cols, allowOverlap, options) {
 	if (l.static && l.isDraggable !== true) return [...layout];
 	if (l.y === y && l.x === x) return [...layout];
 	const oldX = l.x;
@@ -121,6 +121,16 @@ function moveElement(layout, l, x, y, isUserAction, preventCollision, compactTyp
 	const hasCollisions = collisions.length > 0;
 	if (hasCollisions && allowOverlap) return cloneLayout(layout);
 	if (hasCollisions && preventCollision) {
+		const resolved = options?.resolveCollision?.({
+			layout,
+			item: l,
+			collisions,
+			from: {
+				x: oldX,
+				y: oldY
+			}
+		});
+		if (resolved) return resolved;
 		l.x = oldX;
 		l.y = oldY;
 		l.moved = false;

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

@@ -1 +1 @@
-{"version":3,"file":"layout.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/layout.ts"],"sourcesContent":["/**\n * Core layout manipulation utilities.\n *\n * Vendored from react-grid-layout v2 (`src/core/layout.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * These functions create, modify, and query grid layouts. Most functions treat\n * layouts as immutable and return new arrays/objects, but a few mutate items in\n * place for performance (documented per function).\n */\n\nimport { getAllCollisions, getFirstCollision } from './collision';\nimport { sortLayoutItems } from './sort';\n\nimport type { CompactType, Layout, LayoutItem, Mutable } from './types';\n\n// ============================================================================\n// Layout Queries\n// ============================================================================\n\n/**\n * Get the bottom-most Y coordinate of the layout (max of y + h).\n */\nexport function bottom(layout: Layout): number {\n  let max = 0;\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined) {\n      const bottomY = item.y + item.h;\n      if (bottomY > max) max = bottomY;\n    }\n  }\n  return max;\n}\n\n/** Get a layout item by its ID. */\nexport function getLayoutItem(\n  layout: Layout,\n  id: string,\n): LayoutItem | undefined {\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined && item.i === id) {\n      return item;\n    }\n  }\n  return undefined;\n}\n\n/** Get all static items from the layout. */\nexport function getStatics(layout: Layout): LayoutItem[] {\n  return layout.filter((l): l is LayoutItem => l.static === true);\n}\n\n// ============================================================================\n// Layout Cloning\n// ============================================================================\n\n/** Clone a layout item (shallow copy, boolean flags normalized). */\nexport function cloneLayoutItem(layoutItem: LayoutItem): LayoutItem {\n  return {\n    i: layoutItem.i,\n    x: layoutItem.x,\n    y: layoutItem.y,\n    w: layoutItem.w,\n    h: layoutItem.h,\n    minW: layoutItem.minW,\n    maxW: layoutItem.maxW,\n    minH: layoutItem.minH,\n    maxH: layoutItem.maxH,\n    moved: Boolean(layoutItem.moved),\n    static: Boolean(layoutItem.static),\n    isDraggable: layoutItem.isDraggable,\n    isResizable: layoutItem.isResizable,\n    resizeHandles: layoutItem.resizeHandles,\n    constraints: layoutItem.constraints,\n    isBounded: layoutItem.isBounded,\n  };\n}\n\n/** Clone an entire layout. */\nexport function cloneLayout(layout: Layout): LayoutItem[] {\n  const newLayout: LayoutItem[] = new Array(layout.length);\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined) {\n      newLayout[i] = cloneLayoutItem(item);\n    }\n  }\n  return newLayout;\n}\n\n// ============================================================================\n// Layout Modification\n// ============================================================================\n\n/** Replace a layout item in a layout (matched by `i`). Other items untouched. */\nexport function modifyLayout(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem[] {\n  const newLayout: LayoutItem[] = new Array(layout.length);\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined) {\n      if (layoutItem.i === item.i) {\n        newLayout[i] = layoutItem;\n      } else {\n        newLayout[i] = item;\n      }\n    }\n  }\n  return newLayout;\n}\n\n/**\n * Apply a transformation to a layout item. Finds the item by key, clones it,\n * applies the callback, and returns [new layout, modified item | null].\n */\nexport function withLayoutItem(\n  layout: Layout,\n  itemKey: string,\n  cb: (item: LayoutItem) => LayoutItem,\n): [LayoutItem[], LayoutItem | null] {\n  let item = getLayoutItem(layout, itemKey);\n  if (!item) {\n    return [[...layout], null];\n  }\n\n  item = cb(cloneLayoutItem(item));\n  const newLayout = modifyLayout(layout, item);\n\n  return [newLayout, item];\n}\n\n// ============================================================================\n// Bounds Correction\n// ============================================================================\n\n/**\n * Ensure all layout items fit within the grid bounds.\n *\n * **IMPORTANT**: mutates the layout items in place for performance. Clone the\n * layout first (e.g. with `cloneLayout()`) if you need immutability.\n */\nexport function correctBounds(\n  layout: Mutable<LayoutItem>[],\n  bounds: { cols: number },\n): LayoutItem[] {\n  const collidesWith = getStatics(layout);\n\n  for (let i = 0; i < layout.length; i++) {\n    const l = layout[i];\n    if (l === undefined) continue;\n\n    // Overflows right\n    if (l.x + l.w > bounds.cols) {\n      l.x = bounds.cols - l.w;\n    }\n\n    // Overflows left\n    if (l.x < 0) {\n      l.x = 0;\n      l.w = bounds.cols;\n    }\n\n    if (!l.static) {\n      collidesWith.push(l);\n    } else {\n      // Static items that collide with other statics must be moved down\n      while (getFirstCollision(collidesWith, l)) {\n        l.y++;\n      }\n    }\n  }\n\n  return layout;\n}\n\n// ============================================================================\n// Move Operations\n// ============================================================================\n\n/**\n * Move a layout element to a new position.\n *\n * Handles collision detection and cascading movements. Does not compact the\n * layout - call the compactor separately.\n *\n * **Note**: mutates the `l` parameter directly for performance.\n */\nexport function moveElement(\n  layout: Layout,\n  l: LayoutItem,\n  x: number | undefined,\n  y: number | undefined,\n  isUserAction: boolean | undefined,\n  preventCollision: boolean | undefined,\n  compactType: CompactType,\n  cols: number,\n  allowOverlap?: boolean,\n): LayoutItem[] {\n  // Static items can't be moved unless explicitly draggable\n  if (l.static && l.isDraggable !== true) {\n    return [...layout];\n  }\n\n  // Short-circuit if position unchanged\n  if (l.y === y && l.x === x) {\n    return [...layout];\n  }\n\n  const oldX = l.x;\n  const oldY = l.y;\n\n  // Update position (mutates l directly - see JSDoc note)\n  if (typeof x === 'number') (l as Mutable<LayoutItem>).x = x;\n  if (typeof y === 'number') (l as Mutable<LayoutItem>).y = y;\n  (l as Mutable<LayoutItem>).moved = true;\n\n  // Sort for proper collision detection order\n  let sorted = sortLayoutItems(layout, compactType);\n  const movingUp =\n    compactType === 'vertical' && typeof y === 'number'\n      ? oldY >= y\n      : compactType === 'horizontal' && typeof x === 'number'\n        ? oldX >= x\n        : false;\n\n  if (movingUp) {\n    sorted = sorted.reverse();\n  }\n\n  const collisions = getAllCollisions(sorted, l);\n  const hasCollisions = collisions.length > 0;\n\n  // Handle overlap mode - just clone and return\n  if (hasCollisions && allowOverlap) {\n    return cloneLayout(layout);\n  }\n\n  // Handle prevent collision mode - revert position.\n  // Return same reference to signal no change occurred.\n  if (hasCollisions && preventCollision) {\n    (l as Mutable<LayoutItem>).x = oldX;\n    (l as Mutable<LayoutItem>).y = oldY;\n    (l as Mutable<LayoutItem>).moved = false;\n    return layout as LayoutItem[];\n  }\n\n  // Resolve collisions by moving other items\n  let resultLayout: LayoutItem[] = [...layout];\n  for (let i = 0; i < collisions.length; i++) {\n    const collision = collisions[i];\n    if (collision === undefined) continue;\n\n    // Skip already-moved items to prevent infinite loops\n    if (collision.moved) continue;\n\n    // Static items can't be moved - move the dragged item instead\n    if (collision.static) {\n      resultLayout = moveElementAwayFromCollision(\n        resultLayout,\n        collision,\n        l,\n        isUserAction,\n        compactType,\n        cols,\n      );\n    } else {\n      resultLayout = moveElementAwayFromCollision(\n        resultLayout,\n        l,\n        collision,\n        isUserAction,\n        compactType,\n        cols,\n      );\n    }\n  }\n\n  return resultLayout;\n}\n\n/**\n * Move an item away from a collision. Attempts to move up/left first if there's\n * room, otherwise moves it down/right.\n */\nexport function moveElementAwayFromCollision(\n  layout: Layout,\n  collidesWith: LayoutItem,\n  itemToMove: LayoutItem,\n  isUserAction: boolean | undefined,\n  compactType: CompactType,\n  cols: number,\n): LayoutItem[] {\n  const compactH = compactType === 'horizontal';\n  const compactV = compactType === 'vertical';\n  const preventCollision = collidesWith.static;\n\n  // Try to move up/left first (only on primary collision from user action)\n  if (isUserAction) {\n    isUserAction = false; // Only try this once\n\n    // Create a fake item to test if there's room above/left\n    const fakeItem: LayoutItem = {\n      x: compactH ? Math.max(collidesWith.x - itemToMove.w, 0) : itemToMove.x,\n      y: compactV ? Math.max(collidesWith.y - itemToMove.h, 0) : itemToMove.y,\n      w: itemToMove.w,\n      h: itemToMove.h,\n      i: '-1',\n    };\n\n    const firstCollision = getFirstCollision(layout, fakeItem);\n    const collisionNorth =\n      firstCollision !== undefined &&\n      firstCollision.y + firstCollision.h > collidesWith.y;\n    const collisionWest =\n      firstCollision !== undefined &&\n      collidesWith.x + collidesWith.w > firstCollision.x;\n\n    // No collision above/left - we can move there\n    if (!firstCollision) {\n      return moveElement(\n        layout,\n        itemToMove,\n        compactH ? fakeItem.x : undefined,\n        compactV ? fakeItem.y : undefined,\n        isUserAction,\n        preventCollision,\n        compactType,\n        cols,\n      );\n    }\n\n    // Handle specific collision cases\n    if (collisionNorth && compactV) {\n      return moveElement(\n        layout,\n        itemToMove,\n        undefined,\n        itemToMove.y + 1,\n        isUserAction,\n        preventCollision,\n        compactType,\n        cols,\n      );\n    }\n\n    if (collisionNorth && compactType === null) {\n      // Swap positions in free-form mode\n      (collidesWith as Mutable<LayoutItem>).y = itemToMove.y;\n      (itemToMove as Mutable<LayoutItem>).y = itemToMove.y + itemToMove.h;\n      return [...layout];\n    }\n\n    if (collisionWest && compactH) {\n      return moveElement(\n        layout,\n        collidesWith,\n        itemToMove.x,\n        undefined,\n        isUserAction,\n        preventCollision,\n        compactType,\n        cols,\n      );\n    }\n  }\n\n  // Default: move down/right by 1\n  const newX = compactH ? itemToMove.x + 1 : undefined;\n  const newY = compactV ? itemToMove.y + 1 : undefined;\n\n  if (newX === undefined && newY === undefined) {\n    return [...layout];\n  }\n\n  return moveElement(\n    layout,\n    itemToMove,\n    newX,\n    newY,\n    isUserAction,\n    preventCollision,\n    compactType,\n    cols,\n  );\n}\n\n// ============================================================================\n// Validation\n// ============================================================================\n\n/** Validate that a layout has the required numeric properties. */\nexport function validateLayout(\n  layout: Layout,\n  contextName: string = 'Layout',\n): void {\n  const requiredProps = ['x', 'y', 'w', 'h'] as const;\n\n  if (!Array.isArray(layout)) {\n    throw new Error(`${contextName} must be an array!`);\n  }\n\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item === undefined) continue;\n\n    for (const key of requiredProps) {\n      const value = item[key];\n      if (typeof value !== 'number' || Number.isNaN(value)) {\n        throw new Error(\n          `Board: ${contextName}[${i}].${key} must be a number! ` +\n            `Received: ${String(value)} (${typeof value})`,\n        );\n      }\n    }\n\n    if (item.i !== undefined && typeof item.i !== 'string') {\n      throw new Error(\n        `Board: ${contextName}[${i}].i must be a string! ` +\n          `Received: ${String(item.i)} (${typeof item.i})`,\n      );\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"layout.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/layout.ts"],"sourcesContent":["/**\n * Core layout manipulation utilities.\n *\n * Vendored from react-grid-layout v2 (`src/core/layout.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * These functions create, modify, and query grid layouts. Most functions treat\n * layouts as immutable and return new arrays/objects, but a few mutate items in\n * place for performance (documented per function).\n */\n\nimport { getAllCollisions, getFirstCollision } from './collision';\nimport { sortLayoutItems } from './sort';\n\nimport type {\n  CompactType,\n  Layout,\n  LayoutItem,\n  MoveElementOptions,\n  Mutable,\n} from './types';\n\n// ============================================================================\n// Layout Queries\n// ============================================================================\n\n/**\n * Get the bottom-most Y coordinate of the layout (max of y + h).\n */\nexport function bottom(layout: Layout): number {\n  let max = 0;\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined) {\n      const bottomY = item.y + item.h;\n      if (bottomY > max) max = bottomY;\n    }\n  }\n  return max;\n}\n\n/** Get a layout item by its ID. */\nexport function getLayoutItem(\n  layout: Layout,\n  id: string,\n): LayoutItem | undefined {\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined && item.i === id) {\n      return item;\n    }\n  }\n  return undefined;\n}\n\n/** Get all static items from the layout. */\nexport function getStatics(layout: Layout): LayoutItem[] {\n  return layout.filter((l): l is LayoutItem => l.static === true);\n}\n\n// ============================================================================\n// Layout Cloning\n// ============================================================================\n\n/** Clone a layout item (shallow copy, boolean flags normalized). */\nexport function cloneLayoutItem(layoutItem: LayoutItem): LayoutItem {\n  return {\n    i: layoutItem.i,\n    x: layoutItem.x,\n    y: layoutItem.y,\n    w: layoutItem.w,\n    h: layoutItem.h,\n    minW: layoutItem.minW,\n    maxW: layoutItem.maxW,\n    minH: layoutItem.minH,\n    maxH: layoutItem.maxH,\n    moved: Boolean(layoutItem.moved),\n    static: Boolean(layoutItem.static),\n    isDraggable: layoutItem.isDraggable,\n    isResizable: layoutItem.isResizable,\n    resizeHandles: layoutItem.resizeHandles,\n    constraints: layoutItem.constraints,\n    isBounded: layoutItem.isBounded,\n  };\n}\n\n/** Clone an entire layout. */\nexport function cloneLayout(layout: Layout): LayoutItem[] {\n  const newLayout: LayoutItem[] = new Array(layout.length);\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined) {\n      newLayout[i] = cloneLayoutItem(item);\n    }\n  }\n  return newLayout;\n}\n\n// ============================================================================\n// Layout Modification\n// ============================================================================\n\n/** Replace a layout item in a layout (matched by `i`). Other items untouched. */\nexport function modifyLayout(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem[] {\n  const newLayout: LayoutItem[] = new Array(layout.length);\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined) {\n      if (layoutItem.i === item.i) {\n        newLayout[i] = layoutItem;\n      } else {\n        newLayout[i] = item;\n      }\n    }\n  }\n  return newLayout;\n}\n\n/**\n * Apply a transformation to a layout item. Finds the item by key, clones it,\n * applies the callback, and returns [new layout, modified item | null].\n */\nexport function withLayoutItem(\n  layout: Layout,\n  itemKey: string,\n  cb: (item: LayoutItem) => LayoutItem,\n): [LayoutItem[], LayoutItem | null] {\n  let item = getLayoutItem(layout, itemKey);\n  if (!item) {\n    return [[...layout], null];\n  }\n\n  item = cb(cloneLayoutItem(item));\n  const newLayout = modifyLayout(layout, item);\n\n  return [newLayout, item];\n}\n\n// ============================================================================\n// Bounds Correction\n// ============================================================================\n\n/**\n * Ensure all layout items fit within the grid bounds.\n *\n * **IMPORTANT**: mutates the layout items in place for performance. Clone the\n * layout first (e.g. with `cloneLayout()`) if you need immutability.\n */\nexport function correctBounds(\n  layout: Mutable<LayoutItem>[],\n  bounds: { cols: number },\n): LayoutItem[] {\n  const collidesWith = getStatics(layout);\n\n  for (let i = 0; i < layout.length; i++) {\n    const l = layout[i];\n    if (l === undefined) continue;\n\n    // Overflows right\n    if (l.x + l.w > bounds.cols) {\n      l.x = bounds.cols - l.w;\n    }\n\n    // Overflows left\n    if (l.x < 0) {\n      l.x = 0;\n      l.w = bounds.cols;\n    }\n\n    if (!l.static) {\n      collidesWith.push(l);\n    } else {\n      // Static items that collide with other statics must be moved down\n      while (getFirstCollision(collidesWith, l)) {\n        l.y++;\n      }\n    }\n  }\n\n  return layout;\n}\n\n// ============================================================================\n// Move Operations\n// ============================================================================\n\n/**\n * Move a layout element to a new position.\n *\n * Handles collision detection and cascading movements. Does not compact the\n * layout - call the compactor separately.\n *\n * **Note**: mutates the `l` parameter directly for performance.\n */\nexport function moveElement(\n  layout: Layout,\n  l: LayoutItem,\n  x: number | undefined,\n  y: number | undefined,\n  isUserAction: boolean | undefined,\n  preventCollision: boolean | undefined,\n  compactType: CompactType,\n  cols: number,\n  allowOverlap?: boolean,\n  options?: MoveElementOptions,\n): LayoutItem[] {\n  // Static items can't be moved unless explicitly draggable\n  if (l.static && l.isDraggable !== true) {\n    return [...layout];\n  }\n\n  // Short-circuit if position unchanged\n  if (l.y === y && l.x === x) {\n    return [...layout];\n  }\n\n  const oldX = l.x;\n  const oldY = l.y;\n\n  // Update position (mutates l directly - see JSDoc note)\n  if (typeof x === 'number') (l as Mutable<LayoutItem>).x = x;\n  if (typeof y === 'number') (l as Mutable<LayoutItem>).y = y;\n  (l as Mutable<LayoutItem>).moved = true;\n\n  // Sort for proper collision detection order\n  let sorted = sortLayoutItems(layout, compactType);\n  const movingUp =\n    compactType === 'vertical' && typeof y === 'number'\n      ? oldY >= y\n      : compactType === 'horizontal' && typeof x === 'number'\n        ? oldX >= x\n        : false;\n\n  if (movingUp) {\n    sorted = sorted.reverse();\n  }\n\n  const collisions = getAllCollisions(sorted, l);\n  const hasCollisions = collisions.length > 0;\n\n  // Handle overlap mode - just clone and return\n  if (hasCollisions && allowOverlap) {\n    return cloneLayout(layout);\n  }\n\n  // Handle prevent collision mode. A resolver may rewrite the layout instead of\n  // refusing the move outright - shrinking the item into the room that is there,\n  // or trading places with the widget already in it (see `collision-modes.ts`).\n  // Its result is required to be overlap-free, so nothing downstream has to\n  // change; when it declines, we revert exactly as before.\n  if (hasCollisions && preventCollision) {\n    const resolved = options?.resolveCollision?.({\n      layout,\n      item: l,\n      collisions,\n      from: { x: oldX, y: oldY },\n    });\n    if (resolved) return resolved;\n\n    // Revert position. Return same reference to signal no change occurred.\n    (l as Mutable<LayoutItem>).x = oldX;\n    (l as Mutable<LayoutItem>).y = oldY;\n    (l as Mutable<LayoutItem>).moved = false;\n    return layout as LayoutItem[];\n  }\n\n  // Resolve collisions by moving other items\n  let resultLayout: LayoutItem[] = [...layout];\n  for (let i = 0; i < collisions.length; i++) {\n    const collision = collisions[i];\n    if (collision === undefined) continue;\n\n    // Skip already-moved items to prevent infinite loops\n    if (collision.moved) continue;\n\n    // Static items can't be moved - move the dragged item instead\n    if (collision.static) {\n      resultLayout = moveElementAwayFromCollision(\n        resultLayout,\n        collision,\n        l,\n        isUserAction,\n        compactType,\n        cols,\n      );\n    } else {\n      resultLayout = moveElementAwayFromCollision(\n        resultLayout,\n        l,\n        collision,\n        isUserAction,\n        compactType,\n        cols,\n      );\n    }\n  }\n\n  return resultLayout;\n}\n\n/**\n * Move an item away from a collision. Attempts to move up/left first if there's\n * room, otherwise moves it down/right.\n */\nexport function moveElementAwayFromCollision(\n  layout: Layout,\n  collidesWith: LayoutItem,\n  itemToMove: LayoutItem,\n  isUserAction: boolean | undefined,\n  compactType: CompactType,\n  cols: number,\n): LayoutItem[] {\n  const compactH = compactType === 'horizontal';\n  const compactV = compactType === 'vertical';\n  const preventCollision = collidesWith.static;\n\n  // Try to move up/left first (only on primary collision from user action)\n  if (isUserAction) {\n    isUserAction = false; // Only try this once\n\n    // Create a fake item to test if there's room above/left\n    const fakeItem: LayoutItem = {\n      x: compactH ? Math.max(collidesWith.x - itemToMove.w, 0) : itemToMove.x,\n      y: compactV ? Math.max(collidesWith.y - itemToMove.h, 0) : itemToMove.y,\n      w: itemToMove.w,\n      h: itemToMove.h,\n      i: '-1',\n    };\n\n    const firstCollision = getFirstCollision(layout, fakeItem);\n    const collisionNorth =\n      firstCollision !== undefined &&\n      firstCollision.y + firstCollision.h > collidesWith.y;\n    const collisionWest =\n      firstCollision !== undefined &&\n      collidesWith.x + collidesWith.w > firstCollision.x;\n\n    // No collision above/left - we can move there\n    if (!firstCollision) {\n      return moveElement(\n        layout,\n        itemToMove,\n        compactH ? fakeItem.x : undefined,\n        compactV ? fakeItem.y : undefined,\n        isUserAction,\n        preventCollision,\n        compactType,\n        cols,\n      );\n    }\n\n    // Handle specific collision cases\n    if (collisionNorth && compactV) {\n      return moveElement(\n        layout,\n        itemToMove,\n        undefined,\n        itemToMove.y + 1,\n        isUserAction,\n        preventCollision,\n        compactType,\n        cols,\n      );\n    }\n\n    if (collisionNorth && compactType === null) {\n      // Swap positions in free-form mode\n      (collidesWith as Mutable<LayoutItem>).y = itemToMove.y;\n      (itemToMove as Mutable<LayoutItem>).y = itemToMove.y + itemToMove.h;\n      return [...layout];\n    }\n\n    if (collisionWest && compactH) {\n      return moveElement(\n        layout,\n        collidesWith,\n        itemToMove.x,\n        undefined,\n        isUserAction,\n        preventCollision,\n        compactType,\n        cols,\n      );\n    }\n  }\n\n  // Default: move down/right by 1\n  const newX = compactH ? itemToMove.x + 1 : undefined;\n  const newY = compactV ? itemToMove.y + 1 : undefined;\n\n  if (newX === undefined && newY === undefined) {\n    return [...layout];\n  }\n\n  return moveElement(\n    layout,\n    itemToMove,\n    newX,\n    newY,\n    isUserAction,\n    preventCollision,\n    compactType,\n    cols,\n  );\n}\n\n// ============================================================================\n// Validation\n// ============================================================================\n\n/** Validate that a layout has the required numeric properties. */\nexport function validateLayout(\n  layout: Layout,\n  contextName: string = 'Layout',\n): void {\n  const requiredProps = ['x', 'y', 'w', 'h'] as const;\n\n  if (!Array.isArray(layout)) {\n    throw new Error(`${contextName} must be an array!`);\n  }\n\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item === undefined) continue;\n\n    for (const key of requiredProps) {\n      const value = item[key];\n      if (typeof value !== 'number' || Number.isNaN(value)) {\n        throw new Error(\n          `Board: ${contextName}[${i}].${key} must be a number! ` +\n            `Received: ${String(value)} (${typeof value})`,\n        );\n      }\n    }\n\n    if (item.i !== undefined && typeof item.i !== 'string') {\n      throw new Error(\n        `Board: ${contextName}[${i}].i must be a string! ` +\n          `Received: ${String(item.i)} (${typeof item.i})`,\n      );\n    }\n  }\n}\n"],"mappings":"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"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.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

@@ -87,6 +87,22 @@ type Layout = readonly LayoutItem[];
  * - null: No compaction (free-form positioning)
  */
 type CompactType = 'horizontal' | 'vertical' | 'wrap' | null;
+/**
+ * How a blocked placement is resolved when collisions are prevented.
+ *
+ * - `'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.
+ *
+ * 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
+ * `allowOverlap` (nothing is refused).
+ */
+type CollisionMode = 'revert' | 'downscale' | 'swap';
 /**
  * Interface for layout compaction strategies.
  *
@@ -164,5 +180,5 @@ interface LayoutConstraint {
   };
 }
 //#endregion
-export { CompactType, Compactor, Layout, LayoutConstraint, LayoutItem, ResizeHandleAxis };
+export { CollisionMode, CompactType, Compactor, Layout, LayoutConstraint, LayoutItem, ResizeHandleAxis };
 //# sourceMappingURL=types.d.ts.map

package/dist/components/layout/Board/index.d.ts

@@ -1,9 +1,9 @@
 
-import { Compactor, Layout, LayoutConstraint, LayoutItem, ResizeHandleAxis } from "./grid-core/types.js";
+import { CollisionMode, Compactor, Layout, LayoutConstraint, LayoutItem, ResizeHandleAxis } from "./grid-core/types.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";
 import { BoardSelectionMode } from "./use-board-selection.js";
-import { CubeBoardWidgetProps, Widget } from "./Widget.js";
+import { BoardResizeGripPlacement, CubeBoardWidgetProps, Widget } from "./Widget.js";
 import { BOARD_SELECTION_CANCEL, BoardCompactType, BoardGridLines, BoardInteractionInfo, CubeBoardProps } from "./Board.js";
 import { BreakpointCols, Breakpoints, ResponsiveLayouts } from "./responsive-utils.js";
 import { BoardResponsive, CubeBoardResponsiveProps } from "./BoardResponsive.js";

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.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/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["BoardBase"],"sources":["../../../../src/components/layout/Board/index.tsx"],"sourcesContent":["import { Board as BoardBase } from './Board';\nimport { BoardProvider } from './BoardProvider';\nimport { BoardResponsive } from './BoardResponsive';\nimport { Widget } from './Widget';\n\nconst Board = Object.assign(BoardBase, {\n  Widget,\n  Provider: BoardProvider,\n  Responsive: BoardResponsive,\n});\n\nexport { Board };\nexport { BoardProvider };\nexport { BoardResponsive };\nexport { Widget as BoardWidget };\nexport { BOARD_SELECTION_CANCEL } from './Board';\n\nexport type {\n  CubeBoardProps,\n  BoardCompactType,\n  BoardGridLines,\n  BoardInteractionInfo,\n} from './Board';\nexport type { BoardSelectionMode } from './use-board-selection';\nexport type { CubeBoardResponsiveProps } from './BoardResponsive';\nexport type { CubeBoardWidgetProps } from './Widget';\nexport type { CubeBoardProviderProps } from './BoardProvider';\nexport type { WidgetTransferInfo } from './board-context';\nexport type {\n  Breakpoints as BoardBreakpoints,\n  BreakpointCols as BoardBreakpointCols,\n  ResponsiveLayouts as BoardResponsiveLayouts,\n} from './responsive-utils';\n\nexport type {\n  Layout,\n  LayoutItem,\n  ResizeHandleAxis,\n  Compactor,\n  LayoutConstraint,\n  PositionParams,\n} from './grid-core';\n\nexport {\n  verticalCompactor,\n  horizontalCompactor,\n  noCompactor,\n  getCompactor,\n  gridBounds,\n  minMaxSize,\n  containerBounds,\n  boundedX,\n  boundedY,\n  aspectRatio,\n  snapToGrid,\n  minSize,\n  maxSize,\n} from './grid-core';\n"],"mappings":";;;;;;;;;AAKA,MAAM,QAAQ,OAAO,OAAOA,SAAW;CACrC;CACA,UAAU;CACV,YAAY;CACb,CAAC"}
+{"version":3,"file":"index.js","names":["BoardBase"],"sources":["../../../../src/components/layout/Board/index.tsx"],"sourcesContent":["import { Board as BoardBase } from './Board';\nimport { BoardProvider } from './BoardProvider';\nimport { BoardResponsive } from './BoardResponsive';\nimport { Widget } from './Widget';\n\nconst Board = Object.assign(BoardBase, {\n  Widget,\n  Provider: BoardProvider,\n  Responsive: BoardResponsive,\n});\n\nexport { Board };\nexport { BoardProvider };\nexport { BoardResponsive };\nexport { Widget as BoardWidget };\nexport { BOARD_SELECTION_CANCEL } from './Board';\n\nexport type {\n  CubeBoardProps,\n  BoardCompactType,\n  BoardGridLines,\n  BoardInteractionInfo,\n} from './Board';\nexport type { BoardSelectionMode } from './use-board-selection';\nexport type { CubeBoardResponsiveProps } from './BoardResponsive';\nexport type { CubeBoardWidgetProps, BoardResizeGripPlacement } from './Widget';\nexport type { CubeBoardProviderProps } from './BoardProvider';\nexport type { WidgetTransferInfo } from './board-context';\nexport type {\n  Breakpoints as BoardBreakpoints,\n  BreakpointCols as BoardBreakpointCols,\n  ResponsiveLayouts as BoardResponsiveLayouts,\n} from './responsive-utils';\n\nexport type {\n  Layout,\n  LayoutItem,\n  ResizeHandleAxis,\n  CollisionMode,\n  Compactor,\n  LayoutConstraint,\n  PositionParams,\n} from './grid-core';\n\nexport {\n  verticalCompactor,\n  horizontalCompactor,\n  noCompactor,\n  getCompactor,\n  gridBounds,\n  minMaxSize,\n  containerBounds,\n  boundedX,\n  boundedY,\n  aspectRatio,\n  snapToGrid,\n  minSize,\n  maxSize,\n} from './grid-core';\n"],"mappings":";;;;;;;;;AAKA,MAAM,QAAQ,OAAO,OAAOA,SAAW;CACrC;CACA,UAAU;CACV,YAAY;CACb,CAAC"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.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.163.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.164.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";