@cube-dev/ui-kit 0.182.0 → 0.183.0

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';\nimport type { BoardCornerPlacement, 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  /**\n   * Whether this widget shows the resting hover ring. Falls back to the owning\n   * board's `widgetProps.hoverRing` when unset here.\n   */\n  hoverRing?: boolean;\n  /** Corner-anchored chrome for this widget. */\n  cornerChrome?: ReactNode;\n  /** Which corner the chrome sits on. */\n  cornerChromePlacement?: BoardCornerPlacement;\n  /** App-defined modifiers merged into the host's own. */\n  mods?: Record<string, boolean | string | undefined>;\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.hoverRing !== reg.hoverRing ||\n      prev.cornerChrome !== reg.cornerChrome ||\n      prev.cornerChromePlacement !== reg.cornerChromePlacement ||\n      prev.mods !== reg.mods ||\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":";;;;;;;;;AAqEA,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;AAmC9B,MAzBE,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,cAAc,IAAI,aACvB,KAAK,iBAAiB,IAAI,gBAC1B,KAAK,0BAA0B,IAAI,yBACnC,KAAK,SAAS,IAAI,QAClB,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":["Styles","ReactNode","LayoutConstraint","ResizeHandleAxis","BoardCornerPlacement","BoardResizeGripPlacement","WidgetRegistration","id","content","isDraggable","isResizable","resizeHandles","resizeGripPlacement","isCard","hoverRing","cornerChrome","cornerChromePlacement","mods","Record","minW","maxW","minH","maxH","constraints","qa","styles","isAutoHeight","dragCancel","dragHandle","isSelectable","selectionCancel","BoardWidgetStore","map","Map","owners","listeners","Set","version","register","reg","owner","prev","get","set","changed","emit","unregister","delete","getVersion","subscribe","listener","add","forEach"],"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 { BoardCornerPlacement, 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  /**\n   * Whether this widget shows the resting hover ring. Falls back to the owning\n   * board's `widgetProps.hoverRing` when unset here.\n   */\n  hoverRing?: boolean;\n  /** Corner-anchored chrome for this widget. */\n  cornerChrome?: ReactNode;\n  /** Which corner the chrome sits on. */\n  cornerChromePlacement?: BoardCornerPlacement;\n  /** App-defined modifiers merged into the host's own. */\n  mods?: Record<string, boolean | string | undefined>;\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.hoverRing !== reg.hoverRing ||\n      prev.cornerChrome !== reg.cornerChrome ||\n      prev.cornerChromePlacement !== reg.cornerChromePlacement ||\n      prev.mods !== reg.mods ||\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":";;;;;;;;;AAqEA,IAAa+B,mBAAb,MAA8B;CAC5B,AAAQC,sBAAM,IAAIC,KAAiC;CAMnD,AAAQC,yBAAS,IAAID,KAAqB;CAC1C,AAAQE,4BAAY,IAAIC,KAAiB;CACzC,AAAQC,UAAU;CAElBC,SAASC,KAAyBC,OAAqB;EACrD,MAAMC,OAAO,KAAKT,IAAIU,IAAIH,IAAIhC,GAAG;AACjC,OAAKyB,IAAIW,IAAIJ,IAAIhC,IAAIgC,IAAI;AACzB,OAAKL,OAAOS,IAAIJ,IAAIhC,IAAIiC,MAAM;AAmC9B,MAzBE,CAACC,QACDA,KAAKjC,YAAY+B,IAAI/B,WACrBiC,KAAKhC,gBAAgB8B,IAAI9B,eACzBgC,KAAK/B,gBAAgB6B,IAAI7B,eACzB+B,KAAK9B,kBAAkB4B,IAAI5B,iBAC3B8B,KAAK7B,wBAAwB2B,IAAI3B,uBACjC6B,KAAK5B,WAAW0B,IAAI1B,UACpB4B,KAAK3B,cAAcyB,IAAIzB,aACvB2B,KAAK1B,iBAAiBwB,IAAIxB,gBAC1B0B,KAAKzB,0BAA0BuB,IAAIvB,yBACnCyB,KAAKxB,SAASsB,IAAItB,QAClBwB,KAAKtB,SAASoB,IAAIpB,QAClBsB,KAAKrB,SAASmB,IAAInB,QAClBqB,KAAKpB,SAASkB,IAAIlB,QAClBoB,KAAKnB,SAASiB,IAAIjB,QAClBmB,KAAKlB,gBAAgBgB,IAAIhB,eACzBkB,KAAKjB,OAAOe,IAAIf,MAChBiB,KAAKhB,WAAWc,IAAId,UACpBgB,KAAKf,iBAAiBa,IAAIb,gBAC1Be,KAAKd,eAAeY,IAAIZ,cACxBc,KAAKb,eAAeW,IAAIX,cACxBa,KAAKZ,iBAAiBU,IAAIV,gBAC1BY,KAAKX,oBAAoBS,IAAIT,mBAC7BW,KAAK,kBAAkBF,IAAI,eAEhB;AACX,QAAKF;AACL,QAAKQ,MAAM;;;CAIfC,WAAWvC,IAAYiC,OAAqB;AAG1C,MAAI,KAAKN,OAAOQ,IAAInC,GAAG,KAAKiC,MAAO;AAEnC,OAAKN,OAAOa,OAAOxC,GAAG;AACtB,MAAI,KAAKyB,IAAIe,OAAOxC,GAAG,EAAE;AACvB,QAAK8B;AACL,QAAKQ,MAAM;;;CAIfH,IAAInC,IAA4C;AAC9C,SAAO,KAAKyB,IAAIU,IAAInC,GAAG;;CAGzByC,mBAA2B,KAAKX;CAEhCY,aAAaC,aAAuC;AAClD,OAAKf,UAAUgB,IAAID,SAAS;AAC5B,eAAa;AACX,QAAKf,UAAUY,OAAOG,SAAS;;;CAInC,AAAQL,OAAa;AACnB,OAAKV,UAAUiB,SAASF,aAAaA,UAAU,CAAC"}

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

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

@@ -1 +1 @@
-{"version":3,"file":"calculate.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/calculate.ts"],"sourcesContent":["/**\n * Grid calculation utilities.\n *\n * Vendored from react-grid-layout v2 (`src/core/calculate.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * These functions convert between grid units and pixel positions.\n */\n\nimport type { Position, ResizeHandleAxis } from './types';\n\n/** Parameters needed for position calculations. */\nexport interface PositionParams {\n  readonly margin: readonly [number, number];\n  readonly containerPadding: readonly [number, number];\n  readonly containerWidth: number;\n  readonly cols: number;\n  readonly rowHeight: number;\n  readonly maxRows: number;\n}\n\n// ============================================================================\n// Grid Column/Row Calculations\n// ============================================================================\n\n/** Calculate the width of a single grid column in pixels. */\nexport function calcGridColWidth(positionParams: PositionParams): number {\n  const { margin, containerPadding, containerWidth, cols } = positionParams;\n  return (\n    (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols\n  );\n}\n\n/**\n * Calculate the pixel size for a grid unit dimension (width or height).\n */\nexport function calcGridItemWHPx(\n  gridUnits: number,\n  colOrRowSize: number,\n  marginPx: number,\n): number {\n  // 0 * Infinity === NaN, which causes problems with resize constraints\n  if (!Number.isFinite(gridUnits)) return gridUnits;\n  return Math.round(\n    colOrRowSize * gridUnits + Math.max(0, gridUnits - 1) * marginPx,\n  );\n}\n\n// ============================================================================\n// Position Calculations\n// ============================================================================\n\n/**\n * Calculate pixel position for a grid item. Returns left, top, width, height.\n */\nexport function calcGridItemPosition(\n  positionParams: PositionParams,\n  x: number,\n  y: number,\n  w: number,\n  h: number,\n  dragPosition?: { top: number; left: number } | null,\n  resizePosition?: {\n    top: number;\n    left: number;\n    height: number;\n    width: number;\n  } | null,\n): Position {\n  const { margin, containerPadding, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  let width: number;\n  let height: number;\n  let top: number;\n  let left: number;\n\n  // If resizing, use the exact width and height from resize callbacks\n  if (resizePosition) {\n    width = Math.round(resizePosition.width);\n    height = Math.round(resizePosition.height);\n  } else {\n    width = calcGridItemWHPx(w, colWidth, margin[0]);\n    height = calcGridItemWHPx(h, rowHeight, margin[1]);\n  }\n\n  // If dragging, use the exact left/top from drag callbacks\n  if (dragPosition) {\n    top = Math.round(dragPosition.top);\n    left = Math.round(dragPosition.left);\n  } else if (resizePosition) {\n    top = Math.round(resizePosition.top);\n    left = Math.round(resizePosition.left);\n  } else {\n    top = Math.round((rowHeight + margin[1]) * y + containerPadding[1]);\n    left = Math.round((colWidth + margin[0]) * x + containerPadding[0]);\n  }\n\n  // When not dragging or resizing, fix margin inconsistencies caused by\n  // rounding by comparing where the next sibling would start.\n  if (!dragPosition && !resizePosition) {\n    if (Number.isFinite(w)) {\n      const siblingLeft = Math.round(\n        (colWidth + margin[0]) * (x + w) + containerPadding[0],\n      );\n      const actualMarginRight = siblingLeft - left - width;\n      if (actualMarginRight !== margin[0]) {\n        width += actualMarginRight - margin[0];\n      }\n    }\n\n    if (Number.isFinite(h)) {\n      const siblingTop = Math.round(\n        (rowHeight + margin[1]) * (y + h) + containerPadding[1],\n      );\n      const actualMarginBottom = siblingTop - top - height;\n      if (actualMarginBottom !== margin[1]) {\n        height += actualMarginBottom - margin[1];\n      }\n    }\n  }\n\n  return { top, left, width, height };\n}\n\n/** Translate pixel coordinates to grid units (clamped). */\nexport function calcXY(\n  positionParams: PositionParams,\n  top: number,\n  left: number,\n  w: number,\n  h: number,\n): { x: number; y: number } {\n  const { margin, containerPadding, cols, rowHeight, maxRows } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  let x = Math.round((left - containerPadding[0]) / (colWidth + margin[0]));\n  let y = Math.round((top - containerPadding[1]) / (rowHeight + margin[1]));\n\n  x = clamp(x, 0, cols - w);\n  y = clamp(y, 0, maxRows - h);\n\n  return { x, y };\n}\n\n/** Translate pixel coordinates to grid units without clamping. */\nexport function calcXYRaw(\n  positionParams: PositionParams,\n  top: number,\n  left: number,\n): { x: number; y: number } {\n  const { margin, containerPadding, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  const x = Math.round((left - containerPadding[0]) / (colWidth + margin[0]));\n  const y = Math.round((top - containerPadding[1]) / (rowHeight + margin[1]));\n\n  return { x, y };\n}\n\n/** Calculate grid units from pixel dimensions (clamped by handle direction). */\nexport function calcWH(\n  positionParams: PositionParams,\n  width: number,\n  height: number,\n  x: number,\n  y: number,\n  handle: ResizeHandleAxis,\n): { w: number; h: number } {\n  const { margin, maxRows, cols, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  const w = Math.round((width + margin[0]) / (colWidth + margin[0]));\n  const h = Math.round((height + margin[1]) / (rowHeight + margin[1]));\n\n  let _w = clamp(w, 0, cols - x);\n  let _h = clamp(h, 0, maxRows - y);\n\n  // West handles can resize to full width\n  if (handle === 'sw' || handle === 'w' || handle === 'nw') {\n    _w = clamp(w, 0, cols);\n  }\n\n  // North handles can resize to full height\n  if (handle === 'nw' || handle === 'n' || handle === 'ne') {\n    _h = clamp(h, 0, maxRows);\n  }\n\n  return { w: _w, h: _h };\n}\n\n/** Calculate grid units from pixel dimensions without clamping (min 1). */\nexport function calcWHRaw(\n  positionParams: PositionParams,\n  width: number,\n  height: number,\n): { w: number; h: number } {\n  const { margin, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  const w = Math.max(\n    1,\n    Math.round((width + margin[0]) / (colWidth + margin[0])),\n  );\n  const h = Math.max(\n    1,\n    Math.round((height + margin[1]) / (rowHeight + margin[1])),\n  );\n\n  return { w, h };\n}\n\n// ============================================================================\n// Utility Functions\n// ============================================================================\n\n/** Clamp a number between bounds. */\nexport function clamp(\n  num: number,\n  lowerBound: number,\n  upperBound: number,\n): number {\n  return Math.max(Math.min(num, upperBound), lowerBound);\n}\n"],"mappings":"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"}
+{"version":3,"file":"calculate.js","names":["Position","ResizeHandleAxis","PositionParams","margin","containerPadding","containerWidth","cols","rowHeight","maxRows","calcGridColWidth","positionParams","calcGridItemWHPx","gridUnits","colOrRowSize","marginPx","Number","isFinite","Math","round","max","calcGridItemPosition","x","y","w","h","dragPosition","top","left","resizePosition","height","width","colWidth","siblingLeft","actualMarginRight","siblingTop","actualMarginBottom","calcXY","clamp","calcXYRaw","calcWH","handle","_w","_h","calcWHRaw","num","lowerBound","upperBound","min"],"sources":["../../../../../src/components/layout/Board/grid-core/calculate.ts"],"sourcesContent":["/**\n * Grid calculation utilities.\n *\n * Vendored from react-grid-layout v2 (`src/core/calculate.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * These functions convert between grid units and pixel positions.\n */\n\nimport type { Position, ResizeHandleAxis } from './types';\n\n/** Parameters needed for position calculations. */\nexport interface PositionParams {\n  readonly margin: readonly [number, number];\n  readonly containerPadding: readonly [number, number];\n  readonly containerWidth: number;\n  readonly cols: number;\n  readonly rowHeight: number;\n  readonly maxRows: number;\n}\n\n// ============================================================================\n// Grid Column/Row Calculations\n// ============================================================================\n\n/** Calculate the width of a single grid column in pixels. */\nexport function calcGridColWidth(positionParams: PositionParams): number {\n  const { margin, containerPadding, containerWidth, cols } = positionParams;\n  return (\n    (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols\n  );\n}\n\n/**\n * Calculate the pixel size for a grid unit dimension (width or height).\n */\nexport function calcGridItemWHPx(\n  gridUnits: number,\n  colOrRowSize: number,\n  marginPx: number,\n): number {\n  // 0 * Infinity === NaN, which causes problems with resize constraints\n  if (!Number.isFinite(gridUnits)) return gridUnits;\n  return Math.round(\n    colOrRowSize * gridUnits + Math.max(0, gridUnits - 1) * marginPx,\n  );\n}\n\n// ============================================================================\n// Position Calculations\n// ============================================================================\n\n/**\n * Calculate pixel position for a grid item. Returns left, top, width, height.\n */\nexport function calcGridItemPosition(\n  positionParams: PositionParams,\n  x: number,\n  y: number,\n  w: number,\n  h: number,\n  dragPosition?: { top: number; left: number } | null,\n  resizePosition?: {\n    top: number;\n    left: number;\n    height: number;\n    width: number;\n  } | null,\n): Position {\n  const { margin, containerPadding, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  let width: number;\n  let height: number;\n  let top: number;\n  let left: number;\n\n  // If resizing, use the exact width and height from resize callbacks\n  if (resizePosition) {\n    width = Math.round(resizePosition.width);\n    height = Math.round(resizePosition.height);\n  } else {\n    width = calcGridItemWHPx(w, colWidth, margin[0]);\n    height = calcGridItemWHPx(h, rowHeight, margin[1]);\n  }\n\n  // If dragging, use the exact left/top from drag callbacks\n  if (dragPosition) {\n    top = Math.round(dragPosition.top);\n    left = Math.round(dragPosition.left);\n  } else if (resizePosition) {\n    top = Math.round(resizePosition.top);\n    left = Math.round(resizePosition.left);\n  } else {\n    top = Math.round((rowHeight + margin[1]) * y + containerPadding[1]);\n    left = Math.round((colWidth + margin[0]) * x + containerPadding[0]);\n  }\n\n  // When not dragging or resizing, fix margin inconsistencies caused by\n  // rounding by comparing where the next sibling would start.\n  if (!dragPosition && !resizePosition) {\n    if (Number.isFinite(w)) {\n      const siblingLeft = Math.round(\n        (colWidth + margin[0]) * (x + w) + containerPadding[0],\n      );\n      const actualMarginRight = siblingLeft - left - width;\n      if (actualMarginRight !== margin[0]) {\n        width += actualMarginRight - margin[0];\n      }\n    }\n\n    if (Number.isFinite(h)) {\n      const siblingTop = Math.round(\n        (rowHeight + margin[1]) * (y + h) + containerPadding[1],\n      );\n      const actualMarginBottom = siblingTop - top - height;\n      if (actualMarginBottom !== margin[1]) {\n        height += actualMarginBottom - margin[1];\n      }\n    }\n  }\n\n  return { top, left, width, height };\n}\n\n/** Translate pixel coordinates to grid units (clamped). */\nexport function calcXY(\n  positionParams: PositionParams,\n  top: number,\n  left: number,\n  w: number,\n  h: number,\n): { x: number; y: number } {\n  const { margin, containerPadding, cols, rowHeight, maxRows } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  let x = Math.round((left - containerPadding[0]) / (colWidth + margin[0]));\n  let y = Math.round((top - containerPadding[1]) / (rowHeight + margin[1]));\n\n  x = clamp(x, 0, cols - w);\n  y = clamp(y, 0, maxRows - h);\n\n  return { x, y };\n}\n\n/** Translate pixel coordinates to grid units without clamping. */\nexport function calcXYRaw(\n  positionParams: PositionParams,\n  top: number,\n  left: number,\n): { x: number; y: number } {\n  const { margin, containerPadding, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  const x = Math.round((left - containerPadding[0]) / (colWidth + margin[0]));\n  const y = Math.round((top - containerPadding[1]) / (rowHeight + margin[1]));\n\n  return { x, y };\n}\n\n/** Calculate grid units from pixel dimensions (clamped by handle direction). */\nexport function calcWH(\n  positionParams: PositionParams,\n  width: number,\n  height: number,\n  x: number,\n  y: number,\n  handle: ResizeHandleAxis,\n): { w: number; h: number } {\n  const { margin, maxRows, cols, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  const w = Math.round((width + margin[0]) / (colWidth + margin[0]));\n  const h = Math.round((height + margin[1]) / (rowHeight + margin[1]));\n\n  let _w = clamp(w, 0, cols - x);\n  let _h = clamp(h, 0, maxRows - y);\n\n  // West handles can resize to full width\n  if (handle === 'sw' || handle === 'w' || handle === 'nw') {\n    _w = clamp(w, 0, cols);\n  }\n\n  // North handles can resize to full height\n  if (handle === 'nw' || handle === 'n' || handle === 'ne') {\n    _h = clamp(h, 0, maxRows);\n  }\n\n  return { w: _w, h: _h };\n}\n\n/** Calculate grid units from pixel dimensions without clamping (min 1). */\nexport function calcWHRaw(\n  positionParams: PositionParams,\n  width: number,\n  height: number,\n): { w: number; h: number } {\n  const { margin, rowHeight } = positionParams;\n  const colWidth = calcGridColWidth(positionParams);\n\n  const w = Math.max(\n    1,\n    Math.round((width + margin[0]) / (colWidth + margin[0])),\n  );\n  const h = Math.max(\n    1,\n    Math.round((height + margin[1]) / (rowHeight + margin[1])),\n  );\n\n  return { w, h };\n}\n\n// ============================================================================\n// Utility Functions\n// ============================================================================\n\n/** Clamp a number between bounds. */\nexport function clamp(\n  num: number,\n  lowerBound: number,\n  upperBound: number,\n): number {\n  return Math.max(Math.min(num, upperBound), lowerBound);\n}\n"],"mappings":"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"}

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"collision.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/collision.ts"],"sourcesContent":["/**\n * Collision detection utilities for grid layouts.\n *\n * Vendored from react-grid-layout v2 (`src/core/collision.ts`).\n * See ./NOTICE.md for attribution and license.\n */\n\nimport type { Layout, LayoutItem } from './types';\n\n/**\n * Check if two layout items collide (overlap).\n *\n * Two items collide if their bounding boxes overlap and they are not the same\n * item.\n */\nexport function collides(l1: LayoutItem, l2: LayoutItem): boolean {\n  // Same element - can't collide with itself\n  if (l1.i === l2.i) return false;\n\n  // Check if bounding boxes don't overlap (any gap means no collision)\n  if (l1.x + l1.w <= l2.x) return false; // l1 is completely left of l2\n  if (l1.x >= l2.x + l2.w) return false; // l1 is completely right of l2\n  if (l1.y + l1.h <= l2.y) return false; // l1 is completely above l2\n  if (l1.y >= l2.y + l2.h) return false; // l1 is completely below l2\n\n  // Bounding boxes overlap\n  return true;\n}\n\n/**\n * Find the first item in the layout that collides with the given item.\n */\nexport function getFirstCollision(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem | undefined {\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined && collides(item, layoutItem)) {\n      return item;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Find all items in the layout that collide with the given item.\n */\nexport function getAllCollisions(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem[] {\n  return layout.filter((l): l is LayoutItem => collides(l, layoutItem));\n}\n"],"mappings":";;;;;;;;AAeA,SAAgB,SAAS,IAAgB,IAAyB;AAEhE,KAAI,GAAG,MAAM,GAAG,EAAG,QAAO;AAG1B,KAAI,GAAG,IAAI,GAAG,KAAK,GAAG,EAAG,QAAO;AAChC,KAAI,GAAG,KAAK,GAAG,IAAI,GAAG,EAAG,QAAO;AAChC,KAAI,GAAG,IAAI,GAAG,KAAK,GAAG,EAAG,QAAO;AAChC,KAAI,GAAG,KAAK,GAAG,IAAI,GAAG,EAAG,QAAO;AAGhC,QAAO;;;;;AAMT,SAAgB,kBACd,QACA,YACwB;AACxB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,OAAO,OAAO;AACpB,MAAI,SAAS,UAAa,SAAS,MAAM,WAAW,CAClD,QAAO;;;;;;AASb,SAAgB,iBACd,QACA,YACc;AACd,QAAO,OAAO,QAAQ,MAAuB,SAAS,GAAG,WAAW,CAAC"}
+{"version":3,"file":"collision.js","names":["Layout","LayoutItem","collides","l1","l2","i","x","w","y","h","getFirstCollision","layout","layoutItem","length","item","undefined","getAllCollisions","filter","l"],"sources":["../../../../../src/components/layout/Board/grid-core/collision.ts"],"sourcesContent":["/**\n * Collision detection utilities for grid layouts.\n *\n * Vendored from react-grid-layout v2 (`src/core/collision.ts`).\n * See ./NOTICE.md for attribution and license.\n */\n\nimport type { Layout, LayoutItem } from './types';\n\n/**\n * Check if two layout items collide (overlap).\n *\n * Two items collide if their bounding boxes overlap and they are not the same\n * item.\n */\nexport function collides(l1: LayoutItem, l2: LayoutItem): boolean {\n  // Same element - can't collide with itself\n  if (l1.i === l2.i) return false;\n\n  // Check if bounding boxes don't overlap (any gap means no collision)\n  if (l1.x + l1.w <= l2.x) return false; // l1 is completely left of l2\n  if (l1.x >= l2.x + l2.w) return false; // l1 is completely right of l2\n  if (l1.y + l1.h <= l2.y) return false; // l1 is completely above l2\n  if (l1.y >= l2.y + l2.h) return false; // l1 is completely below l2\n\n  // Bounding boxes overlap\n  return true;\n}\n\n/**\n * Find the first item in the layout that collides with the given item.\n */\nexport function getFirstCollision(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem | undefined {\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined && collides(item, layoutItem)) {\n      return item;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Find all items in the layout that collide with the given item.\n */\nexport function getAllCollisions(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem[] {\n  return layout.filter((l): l is LayoutItem => collides(l, layoutItem));\n}\n"],"mappings":";;;;;;;;AAeA,SAAgBE,SAASC,IAAgBC,IAAyB;AAEhE,KAAID,GAAGE,MAAMD,GAAGC,EAAG,QAAO;AAG1B,KAAIF,GAAGG,IAAIH,GAAGI,KAAKH,GAAGE,EAAG,QAAO;AAChC,KAAIH,GAAGG,KAAKF,GAAGE,IAAIF,GAAGG,EAAG,QAAO;AAChC,KAAIJ,GAAGK,IAAIL,GAAGM,KAAKL,GAAGI,EAAG,QAAO;AAChC,KAAIL,GAAGK,KAAKJ,GAAGI,IAAIJ,GAAGK,EAAG,QAAO;AAGhC,QAAO;;;;;AAMT,SAAgBC,kBACdC,QACAC,YACwB;AACxB,MAAK,IAAIP,IAAI,GAAGA,IAAIM,OAAOE,QAAQR,KAAK;EACtC,MAAMS,OAAOH,OAAON;AACpB,MAAIS,SAASC,UAAab,SAASY,MAAMF,WAAW,CAClD,QAAOE;;;;;;AASb,SAAgBE,iBACdL,QACAC,YACc;AACd,QAAOD,OAAOM,QAAQC,MAAuBhB,SAASgB,GAAGN,WAAW,CAAC"}

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

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

@@ -1 +1 @@
-{"version":3,"file":"compactors.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/compactors.ts"],"sourcesContent":["/**\n * Compactor implementations.\n *\n * Vendored from react-grid-layout v2 (`src/core/compactors.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * Compactors are pluggable strategies for removing gaps between grid items.\n */\n\nimport { collides, getFirstCollision } from './collision';\nimport { bottom, cloneLayout, cloneLayoutItem, getStatics } from './layout';\nimport { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from './sort';\n\nimport type {\n  Compactor,\n  CompactType,\n  Layout,\n  LayoutItem,\n  Mutable,\n} from './types';\n\n// ============================================================================\n// Helpers for Custom Compactors\n// ============================================================================\n\n/**\n * Resolve a compaction collision by moving items.\n *\n * Before moving an item to a position, checks if that movement would cause\n * collisions and recursively moves those items first.\n */\nexport function resolveCompactionCollision(\n  layout: Layout,\n  item: LayoutItem,\n  moveToCoord: number,\n  axis: 'x' | 'y',\n  hasStatics?: boolean,\n): void {\n  const sizeProp = axis === 'x' ? 'w' : 'h';\n\n  // Temporarily increment position to check for collisions\n  (item as Mutable<LayoutItem>)[axis] += 1;\n\n  const itemIndex = layout.findIndex((l) => l.i === item.i);\n\n  const layoutHasStatics = hasStatics ?? getStatics(layout).length > 0;\n\n  for (let i = itemIndex + 1; i < layout.length; i++) {\n    const otherItem = layout[i];\n    if (otherItem === undefined) continue;\n    if (otherItem.static) continue;\n    // Optimization: break early if past this element, but only if no statics\n    // are present. Static items can be scattered throughout the layout.\n    if (!layoutHasStatics && otherItem.y > item.y + item.h) break;\n\n    if (collides(item, otherItem)) {\n      resolveCompactionCollision(\n        layout,\n        otherItem,\n        moveToCoord + item[sizeProp],\n        axis,\n        layoutHasStatics,\n      );\n    }\n  }\n\n  (item as Mutable<LayoutItem>)[axis] = moveToCoord;\n}\n\n/** Compact a single item vertically (move up). Mutates `l`. */\nexport function compactItemVertical(\n  compareWith: Layout,\n  l: LayoutItem,\n  fullLayout: Layout,\n  maxY: number,\n): LayoutItem {\n  // Correct negative positions first\n  (l as Mutable<LayoutItem>).x = Math.max(l.x, 0);\n  (l as Mutable<LayoutItem>).y = Math.max(l.y, 0);\n\n  // Limit Y to the current bottom\n  (l as Mutable<LayoutItem>).y = Math.min(maxY, l.y);\n\n  // Move up as far as possible\n  while (l.y > 0 && !getFirstCollision(compareWith, l)) {\n    (l as Mutable<LayoutItem>).y--;\n  }\n\n  // Resolve collisions by moving down\n  let collision: LayoutItem | undefined;\n  while ((collision = getFirstCollision(compareWith, l)) !== undefined) {\n    resolveCompactionCollision(fullLayout, l, collision.y + collision.h, 'y');\n  }\n\n  (l as Mutable<LayoutItem>).y = Math.max(l.y, 0);\n  return l;\n}\n\n/** Compact a single item horizontally (move left). Mutates `l`. */\nexport function compactItemHorizontal(\n  compareWith: Layout,\n  l: LayoutItem,\n  cols: number,\n  fullLayout: Layout,\n): LayoutItem {\n  // Correct negative positions first\n  (l as Mutable<LayoutItem>).x = Math.max(l.x, 0);\n  (l as Mutable<LayoutItem>).y = Math.max(l.y, 0);\n\n  // Move left as far as possible\n  while (l.x > 0 && !getFirstCollision(compareWith, l)) {\n    (l as Mutable<LayoutItem>).x--;\n  }\n\n  // Resolve collisions\n  let collision: LayoutItem | undefined;\n  while ((collision = getFirstCollision(compareWith, l)) !== undefined) {\n    resolveCompactionCollision(fullLayout, l, collision.x + collision.w, 'x');\n\n    // Horizontal overflow: wrap to next row\n    if (l.x + l.w > cols) {\n      (l as Mutable<LayoutItem>).x = cols - l.w;\n      (l as Mutable<LayoutItem>).y++;\n\n      while (l.x > 0 && !getFirstCollision(compareWith, l)) {\n        (l as Mutable<LayoutItem>).x--;\n      }\n    }\n  }\n\n  (l as Mutable<LayoutItem>).x = Math.max(l.x, 0);\n  return l;\n}\n\n// ============================================================================\n// Vertical Compactor\n// ============================================================================\n\n/**\n * Vertical compactor - moves items up to fill gaps. Default compaction mode.\n */\nexport const verticalCompactor: Compactor = {\n  type: 'vertical',\n  allowOverlap: false,\n\n  compact(layout: Layout, _cols: number): Layout {\n    const compareWith = getStatics(layout);\n    let maxY = bottom(compareWith);\n    const sorted = sortLayoutItemsByRowCol(layout);\n    const out: LayoutItem[] = new Array(layout.length);\n\n    for (let i = 0; i < sorted.length; i++) {\n      const sortedItem = sorted[i];\n      if (sortedItem === undefined) continue;\n\n      let l = cloneLayoutItem(sortedItem);\n\n      if (!l.static) {\n        l = compactItemVertical(compareWith, l, sorted, maxY);\n        maxY = Math.max(maxY, l.y + l.h);\n        compareWith.push(l);\n      }\n\n      const originalIndex = layout.indexOf(sortedItem);\n      out[originalIndex] = l;\n      l.moved = false;\n    }\n\n    return out;\n  },\n};\n\n// ============================================================================\n// Horizontal Compactor\n// ============================================================================\n\n/**\n * Horizontal compactor - moves items left to fill gaps.\n */\nexport const horizontalCompactor: Compactor = {\n  type: 'horizontal',\n  allowOverlap: false,\n\n  compact(layout: Layout, cols: number): Layout {\n    const compareWith = getStatics(layout);\n    const sorted = sortLayoutItemsByColRow(layout);\n    const out: LayoutItem[] = new Array(layout.length);\n\n    for (let i = 0; i < sorted.length; i++) {\n      const sortedItem = sorted[i];\n      if (sortedItem === undefined) continue;\n\n      let l = cloneLayoutItem(sortedItem);\n\n      if (!l.static) {\n        l = compactItemHorizontal(compareWith, l, cols, sorted);\n        compareWith.push(l);\n      }\n\n      const originalIndex = layout.indexOf(sortedItem);\n      out[originalIndex] = l;\n      l.moved = false;\n    }\n\n    return out;\n  },\n};\n\n// ============================================================================\n// No Compaction\n// ============================================================================\n\n/**\n * No compaction - items stay where placed (free-form layouts).\n */\nexport const noCompactor: Compactor = {\n  type: null,\n  allowOverlap: false,\n\n  compact(layout: Layout, _cols: number): Layout {\n    return cloneLayout(layout);\n  },\n};\n\n// ============================================================================\n// Overlap-Allowing Variants\n// ============================================================================\n\n/** Vertical compactor that allows overlapping items. */\nexport const verticalOverlapCompactor: Compactor = {\n  ...verticalCompactor,\n  allowOverlap: true,\n\n  compact(layout: Layout, _cols: number): Layout {\n    return cloneLayout(layout);\n  },\n};\n\n/** Horizontal compactor that allows overlapping items. */\nexport const horizontalOverlapCompactor: Compactor = {\n  ...horizontalCompactor,\n  allowOverlap: true,\n\n  compact(layout: Layout, _cols: number): Layout {\n    return cloneLayout(layout);\n  },\n};\n\n/** No compaction, with overlapping allowed. */\nexport const noOverlapCompactor: Compactor = {\n  ...noCompactor,\n  allowOverlap: true,\n};\n\n// ============================================================================\n// Factory Function\n// ============================================================================\n\n/**\n * Get a compactor by type (convenience for the string-based compactType API).\n */\nexport function getCompactor(\n  compactType: CompactType,\n  allowOverlap: boolean = false,\n  preventCollision: boolean = false,\n): Compactor {\n  let baseCompactor: Compactor;\n\n  if (allowOverlap) {\n    if (compactType === 'vertical') baseCompactor = verticalOverlapCompactor;\n    else if (compactType === 'horizontal')\n      baseCompactor = horizontalOverlapCompactor;\n    else baseCompactor = noOverlapCompactor;\n  } else {\n    if (compactType === 'vertical') baseCompactor = verticalCompactor;\n    else if (compactType === 'horizontal') baseCompactor = horizontalCompactor;\n    // For 'wrap' and null, use noCompactor\n    else baseCompactor = noCompactor;\n  }\n\n  if (preventCollision) {\n    return { ...baseCompactor, preventCollision };\n  }\n  return baseCompactor;\n}\n"],"mappings":"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"}
+{"version":3,"file":"compactors.js","names":["collides","getFirstCollision","bottom","cloneLayout","cloneLayoutItem","getStatics","sortLayoutItemsByColRow","sortLayoutItemsByRowCol","Compactor","CompactType","Layout","LayoutItem","Mutable","resolveCompactionCollision","layout","item","moveToCoord","axis","hasStatics","sizeProp","itemIndex","findIndex","l","i","layoutHasStatics","length","otherItem","undefined","static","y","h","compactItemVertical","compareWith","fullLayout","maxY","x","Math","max","min","collision","compactItemHorizontal","cols","w","verticalCompactor","type","allowOverlap","compact","_cols","sorted","out","Array","sortedItem","push","originalIndex","indexOf","moved","horizontalCompactor","noCompactor","verticalOverlapCompactor","horizontalOverlapCompactor","noOverlapCompactor","getCompactor","compactType","preventCollision","baseCompactor"],"sources":["../../../../../src/components/layout/Board/grid-core/compactors.ts"],"sourcesContent":["/**\n * Compactor implementations.\n *\n * Vendored from react-grid-layout v2 (`src/core/compactors.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * Compactors are pluggable strategies for removing gaps between grid items.\n */\n\nimport { collides, getFirstCollision } from './collision';\nimport { bottom, cloneLayout, cloneLayoutItem, getStatics } from './layout';\nimport { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from './sort';\n\nimport type {\n  Compactor,\n  CompactType,\n  Layout,\n  LayoutItem,\n  Mutable,\n} from './types';\n\n// ============================================================================\n// Helpers for Custom Compactors\n// ============================================================================\n\n/**\n * Resolve a compaction collision by moving items.\n *\n * Before moving an item to a position, checks if that movement would cause\n * collisions and recursively moves those items first.\n */\nexport function resolveCompactionCollision(\n  layout: Layout,\n  item: LayoutItem,\n  moveToCoord: number,\n  axis: 'x' | 'y',\n  hasStatics?: boolean,\n): void {\n  const sizeProp = axis === 'x' ? 'w' : 'h';\n\n  // Temporarily increment position to check for collisions\n  (item as Mutable<LayoutItem>)[axis] += 1;\n\n  const itemIndex = layout.findIndex((l) => l.i === item.i);\n\n  const layoutHasStatics = hasStatics ?? getStatics(layout).length > 0;\n\n  for (let i = itemIndex + 1; i < layout.length; i++) {\n    const otherItem = layout[i];\n    if (otherItem === undefined) continue;\n    if (otherItem.static) continue;\n    // Optimization: break early if past this element, but only if no statics\n    // are present. Static items can be scattered throughout the layout.\n    if (!layoutHasStatics && otherItem.y > item.y + item.h) break;\n\n    if (collides(item, otherItem)) {\n      resolveCompactionCollision(\n        layout,\n        otherItem,\n        moveToCoord + item[sizeProp],\n        axis,\n        layoutHasStatics,\n      );\n    }\n  }\n\n  (item as Mutable<LayoutItem>)[axis] = moveToCoord;\n}\n\n/** Compact a single item vertically (move up). Mutates `l`. */\nexport function compactItemVertical(\n  compareWith: Layout,\n  l: LayoutItem,\n  fullLayout: Layout,\n  maxY: number,\n): LayoutItem {\n  // Correct negative positions first\n  (l as Mutable<LayoutItem>).x = Math.max(l.x, 0);\n  (l as Mutable<LayoutItem>).y = Math.max(l.y, 0);\n\n  // Limit Y to the current bottom\n  (l as Mutable<LayoutItem>).y = Math.min(maxY, l.y);\n\n  // Move up as far as possible\n  while (l.y > 0 && !getFirstCollision(compareWith, l)) {\n    (l as Mutable<LayoutItem>).y--;\n  }\n\n  // Resolve collisions by moving down\n  let collision: LayoutItem | undefined;\n  while ((collision = getFirstCollision(compareWith, l)) !== undefined) {\n    resolveCompactionCollision(fullLayout, l, collision.y + collision.h, 'y');\n  }\n\n  (l as Mutable<LayoutItem>).y = Math.max(l.y, 0);\n  return l;\n}\n\n/** Compact a single item horizontally (move left). Mutates `l`. */\nexport function compactItemHorizontal(\n  compareWith: Layout,\n  l: LayoutItem,\n  cols: number,\n  fullLayout: Layout,\n): LayoutItem {\n  // Correct negative positions first\n  (l as Mutable<LayoutItem>).x = Math.max(l.x, 0);\n  (l as Mutable<LayoutItem>).y = Math.max(l.y, 0);\n\n  // Move left as far as possible\n  while (l.x > 0 && !getFirstCollision(compareWith, l)) {\n    (l as Mutable<LayoutItem>).x--;\n  }\n\n  // Resolve collisions\n  let collision: LayoutItem | undefined;\n  while ((collision = getFirstCollision(compareWith, l)) !== undefined) {\n    resolveCompactionCollision(fullLayout, l, collision.x + collision.w, 'x');\n\n    // Horizontal overflow: wrap to next row\n    if (l.x + l.w > cols) {\n      (l as Mutable<LayoutItem>).x = cols - l.w;\n      (l as Mutable<LayoutItem>).y++;\n\n      while (l.x > 0 && !getFirstCollision(compareWith, l)) {\n        (l as Mutable<LayoutItem>).x--;\n      }\n    }\n  }\n\n  (l as Mutable<LayoutItem>).x = Math.max(l.x, 0);\n  return l;\n}\n\n// ============================================================================\n// Vertical Compactor\n// ============================================================================\n\n/**\n * Vertical compactor - moves items up to fill gaps. Default compaction mode.\n */\nexport const verticalCompactor: Compactor = {\n  type: 'vertical',\n  allowOverlap: false,\n\n  compact(layout: Layout, _cols: number): Layout {\n    const compareWith = getStatics(layout);\n    let maxY = bottom(compareWith);\n    const sorted = sortLayoutItemsByRowCol(layout);\n    const out: LayoutItem[] = new Array(layout.length);\n\n    for (let i = 0; i < sorted.length; i++) {\n      const sortedItem = sorted[i];\n      if (sortedItem === undefined) continue;\n\n      let l = cloneLayoutItem(sortedItem);\n\n      if (!l.static) {\n        l = compactItemVertical(compareWith, l, sorted, maxY);\n        maxY = Math.max(maxY, l.y + l.h);\n        compareWith.push(l);\n      }\n\n      const originalIndex = layout.indexOf(sortedItem);\n      out[originalIndex] = l;\n      l.moved = false;\n    }\n\n    return out;\n  },\n};\n\n// ============================================================================\n// Horizontal Compactor\n// ============================================================================\n\n/**\n * Horizontal compactor - moves items left to fill gaps.\n */\nexport const horizontalCompactor: Compactor = {\n  type: 'horizontal',\n  allowOverlap: false,\n\n  compact(layout: Layout, cols: number): Layout {\n    const compareWith = getStatics(layout);\n    const sorted = sortLayoutItemsByColRow(layout);\n    const out: LayoutItem[] = new Array(layout.length);\n\n    for (let i = 0; i < sorted.length; i++) {\n      const sortedItem = sorted[i];\n      if (sortedItem === undefined) continue;\n\n      let l = cloneLayoutItem(sortedItem);\n\n      if (!l.static) {\n        l = compactItemHorizontal(compareWith, l, cols, sorted);\n        compareWith.push(l);\n      }\n\n      const originalIndex = layout.indexOf(sortedItem);\n      out[originalIndex] = l;\n      l.moved = false;\n    }\n\n    return out;\n  },\n};\n\n// ============================================================================\n// No Compaction\n// ============================================================================\n\n/**\n * No compaction - items stay where placed (free-form layouts).\n */\nexport const noCompactor: Compactor = {\n  type: null,\n  allowOverlap: false,\n\n  compact(layout: Layout, _cols: number): Layout {\n    return cloneLayout(layout);\n  },\n};\n\n// ============================================================================\n// Overlap-Allowing Variants\n// ============================================================================\n\n/** Vertical compactor that allows overlapping items. */\nexport const verticalOverlapCompactor: Compactor = {\n  ...verticalCompactor,\n  allowOverlap: true,\n\n  compact(layout: Layout, _cols: number): Layout {\n    return cloneLayout(layout);\n  },\n};\n\n/** Horizontal compactor that allows overlapping items. */\nexport const horizontalOverlapCompactor: Compactor = {\n  ...horizontalCompactor,\n  allowOverlap: true,\n\n  compact(layout: Layout, _cols: number): Layout {\n    return cloneLayout(layout);\n  },\n};\n\n/** No compaction, with overlapping allowed. */\nexport const noOverlapCompactor: Compactor = {\n  ...noCompactor,\n  allowOverlap: true,\n};\n\n// ============================================================================\n// Factory Function\n// ============================================================================\n\n/**\n * Get a compactor by type (convenience for the string-based compactType API).\n */\nexport function getCompactor(\n  compactType: CompactType,\n  allowOverlap: boolean = false,\n  preventCollision: boolean = false,\n): Compactor {\n  let baseCompactor: Compactor;\n\n  if (allowOverlap) {\n    if (compactType === 'vertical') baseCompactor = verticalOverlapCompactor;\n    else if (compactType === 'horizontal')\n      baseCompactor = horizontalOverlapCompactor;\n    else baseCompactor = noOverlapCompactor;\n  } else {\n    if (compactType === 'vertical') baseCompactor = verticalCompactor;\n    else if (compactType === 'horizontal') baseCompactor = horizontalCompactor;\n    // For 'wrap' and null, use noCompactor\n    else baseCompactor = noCompactor;\n  }\n\n  if (preventCollision) {\n    return { ...baseCompactor, preventCollision };\n  }\n  return baseCompactor;\n}\n"],"mappings":"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"}

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

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

@@ -1 +1 @@
-{"version":3,"file":"constraints.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/constraints.ts"],"sourcesContent":["/**\n * Pluggable layout constraints.\n *\n * Vendored from react-grid-layout v2 (`src/core/constraints.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * Constraints control position and size limits during drag/resize operations.\n */\n\nimport type {\n  ConstraintContext,\n  LayoutConstraint,\n  LayoutItem,\n  ResizeHandleAxis,\n} from './types';\n\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.max(min, Math.min(max, value));\n}\n\n// ============================================================================\n// Built-in Constraints\n// ============================================================================\n\n/**\n * Grid boundary constraint. Ensures items stay within the grid bounds. This is\n * the default position constraint.\n */\nexport const gridBounds: LayoutConstraint = {\n  name: 'gridBounds',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { cols, maxRows }: ConstraintContext,\n  ): { x: number; y: number } {\n    return {\n      x: clamp(x, 0, Math.max(0, cols - item.w)),\n      y: clamp(y, 0, Math.max(0, maxRows - item.h)),\n    };\n  },\n\n  constrainSize(\n    item: LayoutItem,\n    w: number,\n    h: number,\n    handle: ResizeHandleAxis,\n    { cols, maxRows }: ConstraintContext,\n  ): { w: number; h: number } {\n    const maxW =\n      handle === 'w' || handle === 'nw' || handle === 'sw'\n        ? item.x + item.w\n        : cols - item.x;\n\n    const maxH =\n      handle === 'n' || handle === 'nw' || handle === 'ne'\n        ? item.y + item.h\n        : maxRows - item.y;\n\n    return {\n      w: clamp(w, 1, Math.max(1, maxW)),\n      h: clamp(h, 1, Math.max(1, maxH)),\n    };\n  },\n};\n\n/**\n * Min/max size constraint. Enforces per-item minW/maxW/minH/maxH.\n */\nexport const minMaxSize: LayoutConstraint = {\n  name: 'minMaxSize',\n\n  constrainSize(\n    item: LayoutItem,\n    w: number,\n    h: number,\n  ): { w: number; h: number } {\n    return {\n      w: clamp(w, item.minW ?? 1, item.maxW ?? Infinity),\n      h: clamp(h, item.minH ?? 1, item.maxH ?? Infinity),\n    };\n  },\n};\n\n/**\n * Container bounds constraint. Constrains items to stay within the visible\n * container (a replacement for the legacy `isBounded` prop).\n */\nexport const containerBounds: LayoutConstraint = {\n  name: 'containerBounds',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { cols, maxRows, containerHeight, rowHeight, margin }: ConstraintContext,\n  ): { x: number; y: number } {\n    const visibleRows =\n      containerHeight > 0\n        ? Math.floor((containerHeight + margin[1]) / (rowHeight + margin[1]))\n        : maxRows;\n\n    return {\n      x: clamp(x, 0, Math.max(0, cols - item.w)),\n      y: clamp(y, 0, Math.max(0, visibleRows - item.h)),\n    };\n  },\n};\n\n/** Bounded X constraint. Only constrains horizontal position. */\nexport const boundedX: LayoutConstraint = {\n  name: 'boundedX',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { cols }: ConstraintContext,\n  ): { x: number; y: number } {\n    return {\n      x: clamp(x, 0, Math.max(0, cols - item.w)),\n      y,\n    };\n  },\n};\n\n/** Bounded Y constraint. Only constrains vertical position. */\nexport const boundedY: LayoutConstraint = {\n  name: 'boundedY',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { maxRows }: ConstraintContext,\n  ): { x: number; y: number } {\n    return {\n      x,\n      y: clamp(y, 0, Math.max(0, maxRows - item.h)),\n    };\n  },\n};\n\n// ============================================================================\n// Constraint Factories\n// ============================================================================\n\n/**\n * Create an aspect ratio constraint (maintains width-to-height ratio in pixels).\n */\nexport function aspectRatio(ratio: number): LayoutConstraint {\n  return {\n    name: `aspectRatio(${ratio})`,\n\n    constrainSize(\n      _item: LayoutItem,\n      w: number,\n      _h: number,\n      _handle: ResizeHandleAxis,\n      context: ConstraintContext,\n    ): { w: number; h: number } {\n      const { cols, containerWidth, rowHeight, margin } = context;\n      const colWidth = (containerWidth - margin[0] * (cols - 1)) / cols;\n      const pixelWidth = colWidth * w + margin[0] * Math.max(0, w - 1);\n      const pixelHeight = pixelWidth / ratio;\n      const h = Math.max(\n        1,\n        Math.round((pixelHeight + margin[1]) / (rowHeight + margin[1])),\n      );\n\n      return { w, h };\n    },\n  };\n}\n\n/** Create a snap-to-grid constraint. */\nexport function snapToGrid(\n  stepX: number,\n  stepY: number = stepX,\n): LayoutConstraint {\n  if (stepX <= 0 || stepY <= 0) {\n    throw new Error(\n      `snapToGrid: step values must be positive (got stepX=${stepX}, stepY=${stepY})`,\n    );\n  }\n\n  return {\n    name: `snapToGrid(${stepX}, ${stepY})`,\n\n    constrainPosition(\n      _item: LayoutItem,\n      x: number,\n      y: number,\n    ): { x: number; y: number } {\n      return {\n        x: Math.round(x / stepX) * stepX,\n        y: Math.round(y / stepY) * stepY,\n      };\n    },\n  };\n}\n\n/** Create a minimum size constraint (grid-wide). */\nexport function minSize(minW: number, minH: number): LayoutConstraint {\n  return {\n    name: `minSize(${minW}, ${minH})`,\n\n    constrainSize(\n      _item: LayoutItem,\n      w: number,\n      h: number,\n    ): { w: number; h: number } {\n      return {\n        w: Math.max(minW, w),\n        h: Math.max(minH, h),\n      };\n    },\n  };\n}\n\n/** Create a maximum size constraint (grid-wide). */\nexport function maxSize(maxW: number, maxH: number): LayoutConstraint {\n  return {\n    name: `maxSize(${maxW}, ${maxH})`,\n\n    constrainSize(\n      _item: LayoutItem,\n      w: number,\n      h: number,\n    ): { w: number; h: number } {\n      return {\n        w: Math.min(maxW, w),\n        h: Math.min(maxH, h),\n      };\n    },\n  };\n}\n\n// ============================================================================\n// Default Constraints\n// ============================================================================\n\n/** Default constraints applied when none are specified. */\nexport const defaultConstraints: LayoutConstraint[] = [gridBounds, minMaxSize];\n\n// ============================================================================\n// Constraint Application Functions\n// ============================================================================\n\n/** Apply position constraints to a proposed position. */\nexport function applyPositionConstraints(\n  constraints: LayoutConstraint[],\n  item: LayoutItem,\n  x: number,\n  y: number,\n  context: ConstraintContext,\n): { x: number; y: number } {\n  let result = { x, y };\n\n  for (const constraint of constraints) {\n    if (constraint.constrainPosition) {\n      result = constraint.constrainPosition(item, result.x, result.y, context);\n    }\n  }\n\n  if (item.constraints) {\n    for (const constraint of item.constraints) {\n      if (constraint.constrainPosition) {\n        result = constraint.constrainPosition(\n          item,\n          result.x,\n          result.y,\n          context,\n        );\n      }\n    }\n  }\n\n  return result;\n}\n\n/** Apply size constraints to a proposed size. */\nexport function applySizeConstraints(\n  constraints: LayoutConstraint[],\n  item: LayoutItem,\n  w: number,\n  h: number,\n  handle: ResizeHandleAxis,\n  context: ConstraintContext,\n): { w: number; h: number } {\n  let result = { w, h };\n\n  for (const constraint of constraints) {\n    if (constraint.constrainSize) {\n      result = constraint.constrainSize(\n        item,\n        result.w,\n        result.h,\n        handle,\n        context,\n      );\n    }\n  }\n\n  if (item.constraints) {\n    for (const constraint of item.constraints) {\n      if (constraint.constrainSize) {\n        result = constraint.constrainSize(\n          item,\n          result.w,\n          result.h,\n          handle,\n          context,\n        );\n      }\n    }\n  }\n\n  return result;\n}\n"],"mappings":"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"}
+{"version":3,"file":"constraints.js","names":["ConstraintContext","LayoutConstraint","LayoutItem","ResizeHandleAxis","clamp","value","min","max","Math","gridBounds","name","constrainPosition","item","x","y","cols","maxRows","w","h","constrainSize","handle","maxW","maxH","minMaxSize","minW","Infinity","minH","containerBounds","containerHeight","rowHeight","margin","visibleRows","floor","boundedX","boundedY","aspectRatio","ratio","_item","_h","_handle","context","containerWidth","colWidth","pixelWidth","pixelHeight","round","snapToGrid","stepX","stepY","Error","minSize","maxSize","defaultConstraints","applyPositionConstraints","constraints","result","constraint","applySizeConstraints"],"sources":["../../../../../src/components/layout/Board/grid-core/constraints.ts"],"sourcesContent":["/**\n * Pluggable layout constraints.\n *\n * Vendored from react-grid-layout v2 (`src/core/constraints.ts`).\n * See ./NOTICE.md for attribution and license.\n *\n * Constraints control position and size limits during drag/resize operations.\n */\n\nimport type {\n  ConstraintContext,\n  LayoutConstraint,\n  LayoutItem,\n  ResizeHandleAxis,\n} from './types';\n\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.max(min, Math.min(max, value));\n}\n\n// ============================================================================\n// Built-in Constraints\n// ============================================================================\n\n/**\n * Grid boundary constraint. Ensures items stay within the grid bounds. This is\n * the default position constraint.\n */\nexport const gridBounds: LayoutConstraint = {\n  name: 'gridBounds',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { cols, maxRows }: ConstraintContext,\n  ): { x: number; y: number } {\n    return {\n      x: clamp(x, 0, Math.max(0, cols - item.w)),\n      y: clamp(y, 0, Math.max(0, maxRows - item.h)),\n    };\n  },\n\n  constrainSize(\n    item: LayoutItem,\n    w: number,\n    h: number,\n    handle: ResizeHandleAxis,\n    { cols, maxRows }: ConstraintContext,\n  ): { w: number; h: number } {\n    const maxW =\n      handle === 'w' || handle === 'nw' || handle === 'sw'\n        ? item.x + item.w\n        : cols - item.x;\n\n    const maxH =\n      handle === 'n' || handle === 'nw' || handle === 'ne'\n        ? item.y + item.h\n        : maxRows - item.y;\n\n    return {\n      w: clamp(w, 1, Math.max(1, maxW)),\n      h: clamp(h, 1, Math.max(1, maxH)),\n    };\n  },\n};\n\n/**\n * Min/max size constraint. Enforces per-item minW/maxW/minH/maxH.\n */\nexport const minMaxSize: LayoutConstraint = {\n  name: 'minMaxSize',\n\n  constrainSize(\n    item: LayoutItem,\n    w: number,\n    h: number,\n  ): { w: number; h: number } {\n    return {\n      w: clamp(w, item.minW ?? 1, item.maxW ?? Infinity),\n      h: clamp(h, item.minH ?? 1, item.maxH ?? Infinity),\n    };\n  },\n};\n\n/**\n * Container bounds constraint. Constrains items to stay within the visible\n * container (a replacement for the legacy `isBounded` prop).\n */\nexport const containerBounds: LayoutConstraint = {\n  name: 'containerBounds',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { cols, maxRows, containerHeight, rowHeight, margin }: ConstraintContext,\n  ): { x: number; y: number } {\n    const visibleRows =\n      containerHeight > 0\n        ? Math.floor((containerHeight + margin[1]) / (rowHeight + margin[1]))\n        : maxRows;\n\n    return {\n      x: clamp(x, 0, Math.max(0, cols - item.w)),\n      y: clamp(y, 0, Math.max(0, visibleRows - item.h)),\n    };\n  },\n};\n\n/** Bounded X constraint. Only constrains horizontal position. */\nexport const boundedX: LayoutConstraint = {\n  name: 'boundedX',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { cols }: ConstraintContext,\n  ): { x: number; y: number } {\n    return {\n      x: clamp(x, 0, Math.max(0, cols - item.w)),\n      y,\n    };\n  },\n};\n\n/** Bounded Y constraint. Only constrains vertical position. */\nexport const boundedY: LayoutConstraint = {\n  name: 'boundedY',\n\n  constrainPosition(\n    item: LayoutItem,\n    x: number,\n    y: number,\n    { maxRows }: ConstraintContext,\n  ): { x: number; y: number } {\n    return {\n      x,\n      y: clamp(y, 0, Math.max(0, maxRows - item.h)),\n    };\n  },\n};\n\n// ============================================================================\n// Constraint Factories\n// ============================================================================\n\n/**\n * Create an aspect ratio constraint (maintains width-to-height ratio in pixels).\n */\nexport function aspectRatio(ratio: number): LayoutConstraint {\n  return {\n    name: `aspectRatio(${ratio})`,\n\n    constrainSize(\n      _item: LayoutItem,\n      w: number,\n      _h: number,\n      _handle: ResizeHandleAxis,\n      context: ConstraintContext,\n    ): { w: number; h: number } {\n      const { cols, containerWidth, rowHeight, margin } = context;\n      const colWidth = (containerWidth - margin[0] * (cols - 1)) / cols;\n      const pixelWidth = colWidth * w + margin[0] * Math.max(0, w - 1);\n      const pixelHeight = pixelWidth / ratio;\n      const h = Math.max(\n        1,\n        Math.round((pixelHeight + margin[1]) / (rowHeight + margin[1])),\n      );\n\n      return { w, h };\n    },\n  };\n}\n\n/** Create a snap-to-grid constraint. */\nexport function snapToGrid(\n  stepX: number,\n  stepY: number = stepX,\n): LayoutConstraint {\n  if (stepX <= 0 || stepY <= 0) {\n    throw new Error(\n      `snapToGrid: step values must be positive (got stepX=${stepX}, stepY=${stepY})`,\n    );\n  }\n\n  return {\n    name: `snapToGrid(${stepX}, ${stepY})`,\n\n    constrainPosition(\n      _item: LayoutItem,\n      x: number,\n      y: number,\n    ): { x: number; y: number } {\n      return {\n        x: Math.round(x / stepX) * stepX,\n        y: Math.round(y / stepY) * stepY,\n      };\n    },\n  };\n}\n\n/** Create a minimum size constraint (grid-wide). */\nexport function minSize(minW: number, minH: number): LayoutConstraint {\n  return {\n    name: `minSize(${minW}, ${minH})`,\n\n    constrainSize(\n      _item: LayoutItem,\n      w: number,\n      h: number,\n    ): { w: number; h: number } {\n      return {\n        w: Math.max(minW, w),\n        h: Math.max(minH, h),\n      };\n    },\n  };\n}\n\n/** Create a maximum size constraint (grid-wide). */\nexport function maxSize(maxW: number, maxH: number): LayoutConstraint {\n  return {\n    name: `maxSize(${maxW}, ${maxH})`,\n\n    constrainSize(\n      _item: LayoutItem,\n      w: number,\n      h: number,\n    ): { w: number; h: number } {\n      return {\n        w: Math.min(maxW, w),\n        h: Math.min(maxH, h),\n      };\n    },\n  };\n}\n\n// ============================================================================\n// Default Constraints\n// ============================================================================\n\n/** Default constraints applied when none are specified. */\nexport const defaultConstraints: LayoutConstraint[] = [gridBounds, minMaxSize];\n\n// ============================================================================\n// Constraint Application Functions\n// ============================================================================\n\n/** Apply position constraints to a proposed position. */\nexport function applyPositionConstraints(\n  constraints: LayoutConstraint[],\n  item: LayoutItem,\n  x: number,\n  y: number,\n  context: ConstraintContext,\n): { x: number; y: number } {\n  let result = { x, y };\n\n  for (const constraint of constraints) {\n    if (constraint.constrainPosition) {\n      result = constraint.constrainPosition(item, result.x, result.y, context);\n    }\n  }\n\n  if (item.constraints) {\n    for (const constraint of item.constraints) {\n      if (constraint.constrainPosition) {\n        result = constraint.constrainPosition(\n          item,\n          result.x,\n          result.y,\n          context,\n        );\n      }\n    }\n  }\n\n  return result;\n}\n\n/** Apply size constraints to a proposed size. */\nexport function applySizeConstraints(\n  constraints: LayoutConstraint[],\n  item: LayoutItem,\n  w: number,\n  h: number,\n  handle: ResizeHandleAxis,\n  context: ConstraintContext,\n): { w: number; h: number } {\n  let result = { w, h };\n\n  for (const constraint of constraints) {\n    if (constraint.constrainSize) {\n      result = constraint.constrainSize(\n        item,\n        result.w,\n        result.h,\n        handle,\n        context,\n      );\n    }\n  }\n\n  if (item.constraints) {\n    for (const constraint of item.constraints) {\n      if (constraint.constrainSize) {\n        result = constraint.constrainSize(\n          item,\n          result.w,\n          result.h,\n          handle,\n          context,\n        );\n      }\n    }\n  }\n\n  return result;\n}\n"],"mappings":"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"}

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

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

@@ -1 +1 @@
-{"version":3,"file":"group-move.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/group-move.ts"],"sourcesContent":["/**\n * Rigid multi-item movement.\n *\n * `moveElement` (see ./layout.ts) moves exactly one item and is free to displace\n * any other item — including one the caller also wanted to move — as a collision\n * victim. That makes it unusable for moving a *selection* as a block: the shape\n * of the group would be destroyed by the very collision resolution meant to make\n * room for it.\n *\n * `moveElements` moves a set of items rigidly instead. Every mover receives the\n * same `(dx, dy)`, so the group's shape is invariant *by construction* rather\n * than by repair — and the compaction that follows both orders and places the\n * group as one block, so it cannot undo that (see `compactWithGroupOrder`).\n *\n * This module is UI-Kit-specific; it is not part of the vendored react-grid-layout\n * core (see ./NOTICE.md).\n */\n\nimport { collides, getFirstCollision } from './collision';\nimport { compactItemHorizontal, compactItemVertical } from './compactors';\nimport { bottom, cloneLayout, cloneLayoutItem, getStatics } from './layout';\nimport { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from './sort';\n\nimport type { Compactor, Layout, LayoutItem, Mutable } from './types';\n\nexport interface MoveElementsOptions {\n  /**\n   * The board's compactor. Supplies `type`, `allowOverlap` and\n   * `preventCollision` as one consistent unit, and performs the tidy-up pass —\n   * taking it whole is what keeps this function from ever disagreeing with the\n   * board about compaction mode.\n   */\n  compactor: Compactor;\n  cols: number;\n  /** @default Infinity */\n  maxRows?: number;\n}\n\nexport interface MoveElementsResult {\n  layout: LayoutItem[];\n  /** The delta actually applied, after clamping the group to the grid. */\n  dx: number;\n  dy: number;\n  /**\n   * Whether a valid arrangement was produced. `false` means the frame must be\n   * discarded and the previous one kept — never partially applied, since a\n   * partial delta is precisely what shears the group apart.\n   */\n  moved: boolean;\n}\n\n/** An item may be moved unless it is static and does not opt back in. */\nfunction isMovable(item: LayoutItem): boolean {\n  return !item.static || item.isDraggable === true;\n}\n\n/**\n * Move every item in `ids` by the same delta, resolving collisions with the\n * items that are *not* moving.\n *\n * Semantics, all deliberate:\n *\n * - **Group-clamped, not item-clamped.** The delta is clamped once against the\n *   whole group, so dragging into an edge parks the block against it. Clamping\n *   each item into bounds separately would collapse the group's shape the first\n *   time it touched a wall, and it would never recover.\n * - **All-or-nothing.** If the frame cannot be resolved, nothing moves.\n * - **Movers never collide with each other.** They keep their relative\n *   positions, so only mover↔non-mover and non-mover↔non-mover overlaps resolve.\n * - **A static item is never a mover**, matching `moveElement`'s own guard, and\n *   a mover can never displace a static item — that frame is rejected instead.\n * - **Gravity still wins, but it cannot reach inside the group.** A compacting\n *   board floats the block along with everyone else, so it is not held in\n *   mid-air; it just floats as *one rigid unit*, which is what stops a\n *   displaced neighbour being packed between two members or one member being\n *   floated out from under another.\n *\n * Returns a new layout in the input's item order; the input is never mutated.\n */\nexport function moveElements(\n  layout: Layout,\n  ids: ReadonlySet<string>,\n  dx: number,\n  dy: number,\n  options: MoveElementsOptions,\n): MoveElementsResult {\n  const { compactor, cols, maxRows = Infinity } = options;\n\n  const working = cloneLayout(layout);\n  const movers = working.filter((it) => ids.has(it.i) && isMovable(it));\n\n  if (movers.length === 0) {\n    return { layout: working, dx: 0, dy: 0, moved: false };\n  }\n\n  const moverIds = new Set(movers.map((it) => it.i));\n  const others = working.filter((it) => !moverIds.has(it.i));\n\n  // ---- Clamp the delta to the group ----------------------------------------\n  //\n  // The group can travel until its *first* item hits an edge. `Math.max` on the\n  // upper bounds guards the degenerate case of an item wider/taller than the\n  // grid, where the max would otherwise fall below the min and invert the range.\n  let minDx = -Infinity;\n  let maxDx = Infinity;\n  let minDy = -Infinity;\n  let maxDy = Infinity;\n\n  for (const it of movers) {\n    minDx = Math.max(minDx, -it.x);\n    maxDx = Math.min(maxDx, cols - it.w - it.x);\n    minDy = Math.max(minDy, -it.y);\n    maxDy = Math.min(maxDy, maxRows - it.h - it.y);\n  }\n  maxDx = Math.max(minDx, maxDx);\n  maxDy = Math.max(minDy, maxDy);\n\n  // `|| 0` collapses `-0`, which `Math.max` produces whenever a mover sits at\n  // coordinate 0. It compares equal to `0` but not under `Object.is`, and it\n  // would otherwise be handed back to callers as a delta.\n  const clampedDx = Math.min(Math.max(dx, minDx), maxDx) || 0;\n  const clampedDy = Math.min(Math.max(dy, minDy), maxDy) || 0;\n\n  for (const it of movers) {\n    (it as Mutable<LayoutItem>).x = it.x + clampedDx;\n    (it as Mutable<LayoutItem>).y = it.y + clampedDy;\n  }\n\n  const rejected: MoveElementsResult = {\n    layout: cloneLayout(layout),\n    dx: 0,\n    dy: 0,\n    moved: false,\n  };\n\n  // The axis the board compacts along; `null` has none, but its pre-push has to\n  // pick a direction and down is the one a grid always has room in.\n  const axis: 'x' | 'y' = compactor.type === 'horizontal' ? 'x' : 'y';\n  const travel = axis === 'x' ? clampedDx : clampedDy;\n  const drift = axis === 'x' ? clampedDy : clampedDx;\n  /**\n   * Whether the group is taking ground rather than giving it up — the question\n   * that decides who has to move aside.\n   *\n   * Only a move *along* the compaction axis gives ground up: the group leaves\n   * rows behind it, and the widgets below fall into them. Moving against the\n   * axis, or purely *across* it, takes ground instead: every cell the group\n   * lands on has to be vacated for it.\n   */\n  const takesGround = travel < 0 || (travel === 0 && drift !== 0);\n\n  if (!compactor.allowOverlap) {\n    // A static non-mover cannot be pushed out of the way, so overlapping one is\n    // never resolvable.\n    for (const it of others) {\n      if (it.static && getFirstCollision(movers, it)) {\n        return rejected;\n      }\n    }\n\n    if (compactor.preventCollision) {\n      // `compact=\"free\"` / legacy no-compaction with collisions prevented: the\n      // group may only land where it fits outright.\n      for (const it of movers) {\n        if (getFirstCollision(others, it)) {\n          return rejected;\n        }\n      }\n    } else if (\n      compactor.type === null ||\n      ((compactor.type === 'vertical' || compactor.type === 'horizontal') &&\n        takesGround)\n    ) {\n      // Nothing else will resolve it:\n      //\n      // - `type === null` has no compaction pass at all.\n      // - Whenever the group *takes* ground, the widgets standing on it have to\n      //   be moved off first. Compaction alone cannot do that: it places items\n      //   in `head` order, so a non-mover on the group's landing row is placed\n      //   first and then blocks it. Against the axis the group stops short (or\n      //   does not move at all) while the widgets it did overlap slide down —\n      //   the \"only some of them moved\" symptom. Across the axis it is worse:\n      //   the group is the one gravity shoves aside, so dragging a pair\n      //   sideways slides *it* down under the widgets it was supposed to\n      //   displace, and they look pinned in place.\n      //\n      //   Displacing first is what the single-widget path does too\n      //   (`moveElementAwayFromCollision` runs before compaction), and it costs\n      //   nothing extra: `compactWithGroupOrder` reads each unit's `head` from\n      //   these updated coordinates, so the pushed items sort after the group\n      //   and gravity floats them straight back to their minimal positions in\n      //   the same frame.\n      //\n      // Giving ground up needs the opposite: the non-movers must claim the\n      // vacated rows first, or the group lands back where it started and the\n      // drag reads as a no-op.\n      if (!displaceOthers(movers, others, axis)) {\n        return rejected;\n      }\n    }\n  }\n\n  // Compact exactly as the single-widget path does — the group is not held in\n  // place. On a vertically-compacted board a lone widget can never be parked in\n  // empty space, and a group must not be able to either: neighbours have to\n  // close the gap the moment it opens, or the board reads as a step behind.\n  //\n  // But the group is placed as *one block*. A plain compaction sorts every item\n  // by `(y, x)` and packs each one independently, with no idea a group exists —\n  // so a displaced neighbour gets packed between two members, or one member\n  // floats out from under another and the selection comes apart mid-drag. Check\n  // `allowOverlap` first: the overlap compactors report a `type` but their\n  // `compact` is a plain clone, so there is nothing to order.\n  const groupAware =\n    !compactor.allowOverlap &&\n    (compactor.type === 'vertical' || compactor.type === 'horizontal');\n\n  const out = groupAware\n    ? compactWithGroupOrder(working, moverIds, {\n        axis: compactor.type as CompactionAxis,\n        travel,\n        cols,\n      })\n    : [...compactor.compact(working, cols)];\n\n  return { layout: out, dx: clampedDx, dy: clampedDy, moved: true };\n}\n\ntype CompactionAxis = 'vertical' | 'horizontal';\n\ninterface GroupOrderOptions {\n  /** The axis the board compacts along. */\n  axis: CompactionAxis;\n  /**\n   * The group's clamped travel along that axis. Only the sign is read — it\n   * decides who wins a tie for the same row (or column).\n   */\n  travel: number;\n  cols: number;\n}\n\n/** A group of movers, or a single non-mover, as one thing to place. */\ninterface CompactionUnit {\n  isGroup: boolean;\n  /** Leading edge along the compaction axis. */\n  head: number;\n  /** Leading edge across it, among the members sitting at `head`. */\n  cross: number;\n  members: LayoutItem[];\n  /**\n   * Where the members sat before *anything* was placed, in `members` order.\n   *\n   * The group's shape has to be read from here rather than from the live items:\n   * packing a non-mover runs `resolveCompactionCollision`, which shoves items\n   * later in the placement order out of its way — and for any drag where the\n   * group is placed after a non-mover, that cascade reaches inside the group and\n   * moves one member without the others. Left alone it would be baked into the\n   * block as if it were the shape the user is holding, and two members can end\n   * up on top of each other.\n   */\n  origin?: Array<{ x: number; y: number }>;\n}\n\n/**\n * Compact a layout the way the board's own compactor would, except that the\n * movers are placed as one rigid block instead of being packed one by one by a\n * global `(y, x)` sort.\n *\n * The block still floats under gravity — it is never parked in mid-air — but it\n * floats as a unit: one shift is applied to every member, so relative offsets\n * are invariant for the whole drag. Nothing can be packed between two members,\n * and no member can float out from under another.\n *\n * The cost, deliberately accepted: a *ragged* group (one whose members could\n * individually float further) is no longer a fixed point of the plain compactor,\n * so the drop — which re-compacts the source board — settles it. Holding the\n * shape while the pointer is down is what the gesture is about; the resting\n * layout stays an ordinary compacted layout.\n *\n * Placement order decides everything, and it turns on the direction of travel:\n *\n * - Moving **against** gravity (`travel < 0`), the group claims the row it was\n *   dropped on and the widgets it passed fall in below it.\n * - Moving **with** gravity, the non-movers close the vacated space first.\n *   Handing the group the tie here would leave it exactly where it started and\n *   the drag would read as a no-op.\n *\n * The comparison is a strict `travel < 0`, so a zero-travel re-run lands in the\n * second branch — that is what makes the pass idempotent, which the live drag\n * and the keyboard path both depend on.\n */\nfunction compactWithGroupOrder(\n  layout: Layout,\n  moverIds: ReadonlySet<string>,\n  { axis, travel, cols }: GroupOrderOptions,\n): LayoutItem[] {\n  const horizontal = axis === 'horizontal';\n  const head = horizontal ? 'x' : 'y';\n  const cross = horizontal ? 'y' : 'x';\n  const groupFirst = travel < 0;\n\n  const clones = layout.map(cloneLayoutItem);\n  const movers: LayoutItem[] = [];\n  const units: CompactionUnit[] = [];\n\n  for (const it of clones) {\n    if (moverIds.has(it.i)) {\n      movers.push(it);\n    } else {\n      units.push({\n        isGroup: false,\n        head: it[head],\n        cross: it[cross],\n        members: [it],\n      });\n    }\n  }\n\n  if (movers.length > 0) {\n    const groupHead = Math.min(...movers.map((it) => it[head]));\n    // Members are placed in the same reading order the compactor would have\n    // used, so a block that has to fall back to item-by-item packing lands\n    // exactly where it would have.\n    const members = horizontal\n      ? sortLayoutItemsByColRow(movers)\n      : sortLayoutItemsByRowCol(movers);\n\n    units.push({\n      isGroup: true,\n      head: groupHead,\n      cross: Math.min(\n        ...movers.filter((it) => it[head] === groupHead).map((it) => it[cross]),\n      ),\n      members,\n      origin: members.map((it) => ({ x: it.x, y: it.y })),\n    });\n  }\n\n  units.sort((a, b) => {\n    if (a.head !== b.head) return a.head - b.head;\n    // Same row: direction decides whether the group or the displaced non-movers\n    // get first claim on it.\n    if (a.isGroup !== b.isGroup) return a.isGroup === groupFirst ? -1 : 1;\n    if (a.cross !== b.cross) return a.cross - b.cross;\n\n    return 0;\n  });\n\n  // From here on this mirrors `verticalCompactor` / `horizontalCompactor`\n  // exactly: statics seed the obstacle set and are never floated, every other\n  // item is packed against what is already placed, and `maxY` tracks how far\n  // down the board has filled. The one departure is a group of two or more,\n  // which is floated as a block instead of item by item.\n  const order = units.flatMap((unit) => unit.members);\n  const compareWith = getStatics(clones);\n  let maxY = bottom(compareWith);\n\n  for (const unit of units) {\n    const asBlock =\n      unit.isGroup &&\n      unit.members.length > 1 &&\n      unit.origin !== undefined &&\n      placeBlock(compareWith, unit.members, unit.origin, {\n        horizontal,\n        cols,\n        maxHead: horizontal ? Infinity : maxY,\n      });\n\n    // A single mover, a non-mover, or a block that could not be placed in one\n    // piece: pack each item on its own, exactly as the plain compactor would. A\n    // one-item group must stay byte-identical to dragging that widget alone.\n    if (!asBlock) {\n      for (const l of unit.members) {\n        if (!l.static) {\n          if (horizontal) {\n            compactItemHorizontal(compareWith, l, cols, order);\n          } else {\n            compactItemVertical(compareWith, l, order, maxY);\n            maxY = Math.max(maxY, l.y + l.h);\n          }\n          compareWith.push(l);\n        }\n        l.moved = false;\n      }\n      continue;\n    }\n\n    for (const l of unit.members) {\n      compareWith.push(l);\n      if (!horizontal) maxY = Math.max(maxY, l.y + l.h);\n      l.moved = false;\n    }\n  }\n\n  return clones;\n}\n\ninterface PlaceBlockOptions {\n  horizontal: boolean;\n  cols: number;\n  /**\n   * How far the board has filled along the compaction axis. The block's leading\n   * edge is pulled back to it before floating, mirroring `compactItemVertical`'s\n   * `y = Math.min(maxY, y)` — a group dropped far past the end of the board must\n   * not be able to park out there any more than a single widget can.\n   * `Infinity` disables the clamp (the horizontal compactor has no equivalent).\n   */\n  maxHead: number;\n}\n\n/**\n * Float a whole group into place with a single shift, so every member keeps its\n * exact offset from every other.\n *\n * The shape is taken from `origin` — where the members sat before any placement\n * ran — not from their live coordinates, which an earlier unit's collision\n * cascade may already have pulled apart (see `CompactionUnit.origin`).\n *\n * Members are mutated only on success; a failure restores them, which is what\n * lets the caller fall back to packing them individually. Failure is reserved\n * for the one case a block genuinely cannot express: a horizontal board where\n * settling the overlap would push a member past the last column.\n *\n * Returns whether the block was placed.\n */\nfunction placeBlock(\n  compareWith: Layout,\n  members: LayoutItem[],\n  origin: ReadonlyArray<{ x: number; y: number }>,\n  { horizontal, cols, maxHead }: PlaceBlockOptions,\n): boolean {\n  const head = horizontal ? 'x' : 'y';\n  const size = horizontal ? 'w' : 'h';\n\n  const restore = () => {\n    members.forEach((it, index) => {\n      const at = origin[index] as { x: number; y: number };\n      (it as Mutable<LayoutItem>).x = at.x;\n      (it as Mutable<LayoutItem>).y = at.y;\n    });\n  };\n\n  restore();\n\n  const shift = (delta: number) => {\n    for (const it of members) {\n      (it as Mutable<LayoutItem>)[head] += delta;\n    }\n  };\n  const leadingEdge = () => Math.min(...members.map((it) => it[head]));\n  const trailingEdge = () =>\n    Math.max(...members.map((it) => it[head] + it[size]));\n  const overlaps = () =>\n    members.some((it) => getFirstCollision(compareWith, it) !== undefined);\n\n  // Correct the block into the grid, then pull it back to the fill line.\n  if (leadingEdge() < 0) shift(-leadingEdge());\n  const overshoot = leadingEdge() - maxHead;\n  if (overshoot > 0) shift(-overshoot);\n\n  // Float against gravity for as long as the *whole* block is clear one step\n  // earlier. Testing the next position rather than the current one (which is\n  // how `compactItemVertical` is written) matters here: a block can straddle\n  // several rows, so stepping into an overlap and unwinding it afterwards would\n  // let the settle loop below carry it past where it should have stopped.\n  while (leadingEdge() > 0) {\n    shift(-1);\n    if (overlaps()) {\n      shift(1);\n      break;\n    }\n  }\n\n  if (!overlaps()) {\n    // Clear where it floated to — as long as it is still on the grid. Only the\n    // horizontal axis can fail that: `cols` bounds it, and the delta clamp has\n    // already guaranteed every member fits before this ran.\n    if (!horizontal || trailingEdge() <= cols) return true;\n    restore();\n\n    return false;\n  }\n\n  // Landed on something already placed — push the block forward until it is\n  // clear. Bounded by how far the placed items reach plus the block's own\n  // extent, so an unresolvable frame cannot spin.\n  const span = members.reduce((total, it) => total + it[size], 0);\n  const limit =\n    Math.max(0, ...compareWith.map((it) => it[head] + it[size])) +\n    span +\n    members.length +\n    1;\n\n  for (let step = 0; step < limit; step++) {\n    shift(1);\n    if (horizontal && trailingEdge() > cols) {\n      restore();\n      return false;\n    }\n    if (!overlaps()) return true;\n  }\n\n  restore();\n  return false;\n}\n\n/**\n * Push every non-mover that overlaps the group (or another displaced item) past\n * it along `axis`, until nothing overlaps.\n *\n * `axis` is the board's compaction axis, so the compactor re-packs along the same\n * line immediately afterwards and pulls each displaced item back to its minimal\n * position. A board that does not compact at all (`compact=\"free\"`) is pushed\n * down: down is the one direction a grid always has room in.\n *\n * Pushing along `x` can carry an item past the last column. That is fine and\n * deliberate: `compactItemHorizontal` wraps an overflowing item to the next row,\n * which is a resolution — rejecting the frame here instead would freeze better\n * than a quarter of all leftward group drags.\n *\n * Mutates `others` in place. Returns `false` if the cascade fails to settle,\n * which the caller turns into a rejected frame.\n */\nfunction displaceOthers(\n  movers: LayoutItem[],\n  others: LayoutItem[],\n  axis: 'x' | 'y',\n): boolean {\n  const size = axis === 'x' ? 'w' : 'h';\n  // Place one at a time, in reading order, against a set that starts as the\n  // group. Each push moves an item strictly past a placed item's far edge, so it\n  // advances monotonically and the loop is bounded by the stack extent.\n  const ordered = [...others].sort((a, b) =>\n    a.y === b.y ? a.x - b.x : a.y - b.y,\n  );\n  const placed: LayoutItem[] = [...movers];\n  const reach = (items: LayoutItem[]) =>\n    Math.max(0, ...items.map((it) => it[axis] + it[size]));\n  const limit = reach(movers) + reach(others) + others.length + 1;\n\n  for (const item of ordered) {\n    if (item.static) {\n      // Verified collision-free against the movers by the caller; other statics\n      // are pre-existing and not ours to resolve.\n      placed.push(item);\n      continue;\n    }\n\n    let steps = 0;\n    let shifted = true;\n\n    while (shifted) {\n      shifted = false;\n      for (const other of placed) {\n        if (collides(item, other)) {\n          (item as Mutable<LayoutItem>)[axis] = other[axis] + other[size];\n          shifted = true;\n        }\n      }\n      if (++steps > limit) {\n        return false;\n      }\n    }\n\n    placed.push(item);\n  }\n\n  return true;\n}\n"],"mappings":"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"}
+{"version":3,"file":"group-move.js","names":["collides","getFirstCollision","compactItemHorizontal","compactItemVertical","bottom","cloneLayout","cloneLayoutItem","getStatics","sortLayoutItemsByColRow","sortLayoutItemsByRowCol","Compactor","Layout","LayoutItem","Mutable","MoveElementsOptions","compactor","cols","maxRows","MoveElementsResult","layout","dx","dy","moved","isMovable","item","static","isDraggable","moveElements","ids","ReadonlySet","options","Infinity","working","movers","filter","it","has","i","length","moverIds","Set","map","others","minDx","maxDx","minDy","maxDy","Math","max","x","min","w","y","h","clampedDx","clampedDy","rejected","axis","type","travel","drift","takesGround","allowOverlap","preventCollision","displaceOthers","groupAware","out","compactWithGroupOrder","CompactionAxis","compact","GroupOrderOptions","CompactionUnit","isGroup","head","cross","members","origin","Array","horizontal","groupFirst","clones","units","push","groupHead","sort","a","b","order","flatMap","unit","compareWith","maxY","asBlock","undefined","placeBlock","maxHead","l","PlaceBlockOptions","ReadonlyArray","size","restore","forEach","index","at","shift","delta","leadingEdge","trailingEdge","overlaps","some","overshoot","span","reduce","total","limit","step","ordered","placed","reach","items","steps","shifted","other"],"sources":["../../../../../src/components/layout/Board/grid-core/group-move.ts"],"sourcesContent":["/**\n * Rigid multi-item movement.\n *\n * `moveElement` (see ./layout.ts) moves exactly one item and is free to displace\n * any other item — including one the caller also wanted to move — as a collision\n * victim. That makes it unusable for moving a *selection* as a block: the shape\n * of the group would be destroyed by the very collision resolution meant to make\n * room for it.\n *\n * `moveElements` moves a set of items rigidly instead. Every mover receives the\n * same `(dx, dy)`, so the group's shape is invariant *by construction* rather\n * than by repair — and the compaction that follows both orders and places the\n * group as one block, so it cannot undo that (see `compactWithGroupOrder`).\n *\n * This module is UI-Kit-specific; it is not part of the vendored react-grid-layout\n * core (see ./NOTICE.md).\n */\n\nimport { collides, getFirstCollision } from './collision';\nimport { compactItemHorizontal, compactItemVertical } from './compactors';\nimport { bottom, cloneLayout, cloneLayoutItem, getStatics } from './layout';\nimport { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from './sort';\n\nimport type { Compactor, Layout, LayoutItem, Mutable } from './types';\n\nexport interface MoveElementsOptions {\n  /**\n   * The board's compactor. Supplies `type`, `allowOverlap` and\n   * `preventCollision` as one consistent unit, and performs the tidy-up pass —\n   * taking it whole is what keeps this function from ever disagreeing with the\n   * board about compaction mode.\n   */\n  compactor: Compactor;\n  cols: number;\n  /** @default Infinity */\n  maxRows?: number;\n}\n\nexport interface MoveElementsResult {\n  layout: LayoutItem[];\n  /** The delta actually applied, after clamping the group to the grid. */\n  dx: number;\n  dy: number;\n  /**\n   * Whether a valid arrangement was produced. `false` means the frame must be\n   * discarded and the previous one kept — never partially applied, since a\n   * partial delta is precisely what shears the group apart.\n   */\n  moved: boolean;\n}\n\n/** An item may be moved unless it is static and does not opt back in. */\nfunction isMovable(item: LayoutItem): boolean {\n  return !item.static || item.isDraggable === true;\n}\n\n/**\n * Move every item in `ids` by the same delta, resolving collisions with the\n * items that are *not* moving.\n *\n * Semantics, all deliberate:\n *\n * - **Group-clamped, not item-clamped.** The delta is clamped once against the\n *   whole group, so dragging into an edge parks the block against it. Clamping\n *   each item into bounds separately would collapse the group's shape the first\n *   time it touched a wall, and it would never recover.\n * - **All-or-nothing.** If the frame cannot be resolved, nothing moves.\n * - **Movers never collide with each other.** They keep their relative\n *   positions, so only mover↔non-mover and non-mover↔non-mover overlaps resolve.\n * - **A static item is never a mover**, matching `moveElement`'s own guard, and\n *   a mover can never displace a static item — that frame is rejected instead.\n * - **Gravity still wins, but it cannot reach inside the group.** A compacting\n *   board floats the block along with everyone else, so it is not held in\n *   mid-air; it just floats as *one rigid unit*, which is what stops a\n *   displaced neighbour being packed between two members or one member being\n *   floated out from under another.\n *\n * Returns a new layout in the input's item order; the input is never mutated.\n */\nexport function moveElements(\n  layout: Layout,\n  ids: ReadonlySet<string>,\n  dx: number,\n  dy: number,\n  options: MoveElementsOptions,\n): MoveElementsResult {\n  const { compactor, cols, maxRows = Infinity } = options;\n\n  const working = cloneLayout(layout);\n  const movers = working.filter((it) => ids.has(it.i) && isMovable(it));\n\n  if (movers.length === 0) {\n    return { layout: working, dx: 0, dy: 0, moved: false };\n  }\n\n  const moverIds = new Set(movers.map((it) => it.i));\n  const others = working.filter((it) => !moverIds.has(it.i));\n\n  // ---- Clamp the delta to the group ----------------------------------------\n  //\n  // The group can travel until its *first* item hits an edge. `Math.max` on the\n  // upper bounds guards the degenerate case of an item wider/taller than the\n  // grid, where the max would otherwise fall below the min and invert the range.\n  let minDx = -Infinity;\n  let maxDx = Infinity;\n  let minDy = -Infinity;\n  let maxDy = Infinity;\n\n  for (const it of movers) {\n    minDx = Math.max(minDx, -it.x);\n    maxDx = Math.min(maxDx, cols - it.w - it.x);\n    minDy = Math.max(minDy, -it.y);\n    maxDy = Math.min(maxDy, maxRows - it.h - it.y);\n  }\n  maxDx = Math.max(minDx, maxDx);\n  maxDy = Math.max(minDy, maxDy);\n\n  // `|| 0` collapses `-0`, which `Math.max` produces whenever a mover sits at\n  // coordinate 0. It compares equal to `0` but not under `Object.is`, and it\n  // would otherwise be handed back to callers as a delta.\n  const clampedDx = Math.min(Math.max(dx, minDx), maxDx) || 0;\n  const clampedDy = Math.min(Math.max(dy, minDy), maxDy) || 0;\n\n  for (const it of movers) {\n    (it as Mutable<LayoutItem>).x = it.x + clampedDx;\n    (it as Mutable<LayoutItem>).y = it.y + clampedDy;\n  }\n\n  const rejected: MoveElementsResult = {\n    layout: cloneLayout(layout),\n    dx: 0,\n    dy: 0,\n    moved: false,\n  };\n\n  // The axis the board compacts along; `null` has none, but its pre-push has to\n  // pick a direction and down is the one a grid always has room in.\n  const axis: 'x' | 'y' = compactor.type === 'horizontal' ? 'x' : 'y';\n  const travel = axis === 'x' ? clampedDx : clampedDy;\n  const drift = axis === 'x' ? clampedDy : clampedDx;\n  /**\n   * Whether the group is taking ground rather than giving it up — the question\n   * that decides who has to move aside.\n   *\n   * Only a move *along* the compaction axis gives ground up: the group leaves\n   * rows behind it, and the widgets below fall into them. Moving against the\n   * axis, or purely *across* it, takes ground instead: every cell the group\n   * lands on has to be vacated for it.\n   */\n  const takesGround = travel < 0 || (travel === 0 && drift !== 0);\n\n  if (!compactor.allowOverlap) {\n    // A static non-mover cannot be pushed out of the way, so overlapping one is\n    // never resolvable.\n    for (const it of others) {\n      if (it.static && getFirstCollision(movers, it)) {\n        return rejected;\n      }\n    }\n\n    if (compactor.preventCollision) {\n      // `compact=\"free\"` / legacy no-compaction with collisions prevented: the\n      // group may only land where it fits outright.\n      for (const it of movers) {\n        if (getFirstCollision(others, it)) {\n          return rejected;\n        }\n      }\n    } else if (\n      compactor.type === null ||\n      ((compactor.type === 'vertical' || compactor.type === 'horizontal') &&\n        takesGround)\n    ) {\n      // Nothing else will resolve it:\n      //\n      // - `type === null` has no compaction pass at all.\n      // - Whenever the group *takes* ground, the widgets standing on it have to\n      //   be moved off first. Compaction alone cannot do that: it places items\n      //   in `head` order, so a non-mover on the group's landing row is placed\n      //   first and then blocks it. Against the axis the group stops short (or\n      //   does not move at all) while the widgets it did overlap slide down —\n      //   the \"only some of them moved\" symptom. Across the axis it is worse:\n      //   the group is the one gravity shoves aside, so dragging a pair\n      //   sideways slides *it* down under the widgets it was supposed to\n      //   displace, and they look pinned in place.\n      //\n      //   Displacing first is what the single-widget path does too\n      //   (`moveElementAwayFromCollision` runs before compaction), and it costs\n      //   nothing extra: `compactWithGroupOrder` reads each unit's `head` from\n      //   these updated coordinates, so the pushed items sort after the group\n      //   and gravity floats them straight back to their minimal positions in\n      //   the same frame.\n      //\n      // Giving ground up needs the opposite: the non-movers must claim the\n      // vacated rows first, or the group lands back where it started and the\n      // drag reads as a no-op.\n      if (!displaceOthers(movers, others, axis)) {\n        return rejected;\n      }\n    }\n  }\n\n  // Compact exactly as the single-widget path does — the group is not held in\n  // place. On a vertically-compacted board a lone widget can never be parked in\n  // empty space, and a group must not be able to either: neighbours have to\n  // close the gap the moment it opens, or the board reads as a step behind.\n  //\n  // But the group is placed as *one block*. A plain compaction sorts every item\n  // by `(y, x)` and packs each one independently, with no idea a group exists —\n  // so a displaced neighbour gets packed between two members, or one member\n  // floats out from under another and the selection comes apart mid-drag. Check\n  // `allowOverlap` first: the overlap compactors report a `type` but their\n  // `compact` is a plain clone, so there is nothing to order.\n  const groupAware =\n    !compactor.allowOverlap &&\n    (compactor.type === 'vertical' || compactor.type === 'horizontal');\n\n  const out = groupAware\n    ? compactWithGroupOrder(working, moverIds, {\n        axis: compactor.type as CompactionAxis,\n        travel,\n        cols,\n      })\n    : [...compactor.compact(working, cols)];\n\n  return { layout: out, dx: clampedDx, dy: clampedDy, moved: true };\n}\n\ntype CompactionAxis = 'vertical' | 'horizontal';\n\ninterface GroupOrderOptions {\n  /** The axis the board compacts along. */\n  axis: CompactionAxis;\n  /**\n   * The group's clamped travel along that axis. Only the sign is read — it\n   * decides who wins a tie for the same row (or column).\n   */\n  travel: number;\n  cols: number;\n}\n\n/** A group of movers, or a single non-mover, as one thing to place. */\ninterface CompactionUnit {\n  isGroup: boolean;\n  /** Leading edge along the compaction axis. */\n  head: number;\n  /** Leading edge across it, among the members sitting at `head`. */\n  cross: number;\n  members: LayoutItem[];\n  /**\n   * Where the members sat before *anything* was placed, in `members` order.\n   *\n   * The group's shape has to be read from here rather than from the live items:\n   * packing a non-mover runs `resolveCompactionCollision`, which shoves items\n   * later in the placement order out of its way — and for any drag where the\n   * group is placed after a non-mover, that cascade reaches inside the group and\n   * moves one member without the others. Left alone it would be baked into the\n   * block as if it were the shape the user is holding, and two members can end\n   * up on top of each other.\n   */\n  origin?: Array<{ x: number; y: number }>;\n}\n\n/**\n * Compact a layout the way the board's own compactor would, except that the\n * movers are placed as one rigid block instead of being packed one by one by a\n * global `(y, x)` sort.\n *\n * The block still floats under gravity — it is never parked in mid-air — but it\n * floats as a unit: one shift is applied to every member, so relative offsets\n * are invariant for the whole drag. Nothing can be packed between two members,\n * and no member can float out from under another.\n *\n * The cost, deliberately accepted: a *ragged* group (one whose members could\n * individually float further) is no longer a fixed point of the plain compactor,\n * so the drop — which re-compacts the source board — settles it. Holding the\n * shape while the pointer is down is what the gesture is about; the resting\n * layout stays an ordinary compacted layout.\n *\n * Placement order decides everything, and it turns on the direction of travel:\n *\n * - Moving **against** gravity (`travel < 0`), the group claims the row it was\n *   dropped on and the widgets it passed fall in below it.\n * - Moving **with** gravity, the non-movers close the vacated space first.\n *   Handing the group the tie here would leave it exactly where it started and\n *   the drag would read as a no-op.\n *\n * The comparison is a strict `travel < 0`, so a zero-travel re-run lands in the\n * second branch — that is what makes the pass idempotent, which the live drag\n * and the keyboard path both depend on.\n */\nfunction compactWithGroupOrder(\n  layout: Layout,\n  moverIds: ReadonlySet<string>,\n  { axis, travel, cols }: GroupOrderOptions,\n): LayoutItem[] {\n  const horizontal = axis === 'horizontal';\n  const head = horizontal ? 'x' : 'y';\n  const cross = horizontal ? 'y' : 'x';\n  const groupFirst = travel < 0;\n\n  const clones = layout.map(cloneLayoutItem);\n  const movers: LayoutItem[] = [];\n  const units: CompactionUnit[] = [];\n\n  for (const it of clones) {\n    if (moverIds.has(it.i)) {\n      movers.push(it);\n    } else {\n      units.push({\n        isGroup: false,\n        head: it[head],\n        cross: it[cross],\n        members: [it],\n      });\n    }\n  }\n\n  if (movers.length > 0) {\n    const groupHead = Math.min(...movers.map((it) => it[head]));\n    // Members are placed in the same reading order the compactor would have\n    // used, so a block that has to fall back to item-by-item packing lands\n    // exactly where it would have.\n    const members = horizontal\n      ? sortLayoutItemsByColRow(movers)\n      : sortLayoutItemsByRowCol(movers);\n\n    units.push({\n      isGroup: true,\n      head: groupHead,\n      cross: Math.min(\n        ...movers.filter((it) => it[head] === groupHead).map((it) => it[cross]),\n      ),\n      members,\n      origin: members.map((it) => ({ x: it.x, y: it.y })),\n    });\n  }\n\n  units.sort((a, b) => {\n    if (a.head !== b.head) return a.head - b.head;\n    // Same row: direction decides whether the group or the displaced non-movers\n    // get first claim on it.\n    if (a.isGroup !== b.isGroup) return a.isGroup === groupFirst ? -1 : 1;\n    if (a.cross !== b.cross) return a.cross - b.cross;\n\n    return 0;\n  });\n\n  // From here on this mirrors `verticalCompactor` / `horizontalCompactor`\n  // exactly: statics seed the obstacle set and are never floated, every other\n  // item is packed against what is already placed, and `maxY` tracks how far\n  // down the board has filled. The one departure is a group of two or more,\n  // which is floated as a block instead of item by item.\n  const order = units.flatMap((unit) => unit.members);\n  const compareWith = getStatics(clones);\n  let maxY = bottom(compareWith);\n\n  for (const unit of units) {\n    const asBlock =\n      unit.isGroup &&\n      unit.members.length > 1 &&\n      unit.origin !== undefined &&\n      placeBlock(compareWith, unit.members, unit.origin, {\n        horizontal,\n        cols,\n        maxHead: horizontal ? Infinity : maxY,\n      });\n\n    // A single mover, a non-mover, or a block that could not be placed in one\n    // piece: pack each item on its own, exactly as the plain compactor would. A\n    // one-item group must stay byte-identical to dragging that widget alone.\n    if (!asBlock) {\n      for (const l of unit.members) {\n        if (!l.static) {\n          if (horizontal) {\n            compactItemHorizontal(compareWith, l, cols, order);\n          } else {\n            compactItemVertical(compareWith, l, order, maxY);\n            maxY = Math.max(maxY, l.y + l.h);\n          }\n          compareWith.push(l);\n        }\n        l.moved = false;\n      }\n      continue;\n    }\n\n    for (const l of unit.members) {\n      compareWith.push(l);\n      if (!horizontal) maxY = Math.max(maxY, l.y + l.h);\n      l.moved = false;\n    }\n  }\n\n  return clones;\n}\n\ninterface PlaceBlockOptions {\n  horizontal: boolean;\n  cols: number;\n  /**\n   * How far the board has filled along the compaction axis. The block's leading\n   * edge is pulled back to it before floating, mirroring `compactItemVertical`'s\n   * `y = Math.min(maxY, y)` — a group dropped far past the end of the board must\n   * not be able to park out there any more than a single widget can.\n   * `Infinity` disables the clamp (the horizontal compactor has no equivalent).\n   */\n  maxHead: number;\n}\n\n/**\n * Float a whole group into place with a single shift, so every member keeps its\n * exact offset from every other.\n *\n * The shape is taken from `origin` — where the members sat before any placement\n * ran — not from their live coordinates, which an earlier unit's collision\n * cascade may already have pulled apart (see `CompactionUnit.origin`).\n *\n * Members are mutated only on success; a failure restores them, which is what\n * lets the caller fall back to packing them individually. Failure is reserved\n * for the one case a block genuinely cannot express: a horizontal board where\n * settling the overlap would push a member past the last column.\n *\n * Returns whether the block was placed.\n */\nfunction placeBlock(\n  compareWith: Layout,\n  members: LayoutItem[],\n  origin: ReadonlyArray<{ x: number; y: number }>,\n  { horizontal, cols, maxHead }: PlaceBlockOptions,\n): boolean {\n  const head = horizontal ? 'x' : 'y';\n  const size = horizontal ? 'w' : 'h';\n\n  const restore = () => {\n    members.forEach((it, index) => {\n      const at = origin[index] as { x: number; y: number };\n      (it as Mutable<LayoutItem>).x = at.x;\n      (it as Mutable<LayoutItem>).y = at.y;\n    });\n  };\n\n  restore();\n\n  const shift = (delta: number) => {\n    for (const it of members) {\n      (it as Mutable<LayoutItem>)[head] += delta;\n    }\n  };\n  const leadingEdge = () => Math.min(...members.map((it) => it[head]));\n  const trailingEdge = () =>\n    Math.max(...members.map((it) => it[head] + it[size]));\n  const overlaps = () =>\n    members.some((it) => getFirstCollision(compareWith, it) !== undefined);\n\n  // Correct the block into the grid, then pull it back to the fill line.\n  if (leadingEdge() < 0) shift(-leadingEdge());\n  const overshoot = leadingEdge() - maxHead;\n  if (overshoot > 0) shift(-overshoot);\n\n  // Float against gravity for as long as the *whole* block is clear one step\n  // earlier. Testing the next position rather than the current one (which is\n  // how `compactItemVertical` is written) matters here: a block can straddle\n  // several rows, so stepping into an overlap and unwinding it afterwards would\n  // let the settle loop below carry it past where it should have stopped.\n  while (leadingEdge() > 0) {\n    shift(-1);\n    if (overlaps()) {\n      shift(1);\n      break;\n    }\n  }\n\n  if (!overlaps()) {\n    // Clear where it floated to — as long as it is still on the grid. Only the\n    // horizontal axis can fail that: `cols` bounds it, and the delta clamp has\n    // already guaranteed every member fits before this ran.\n    if (!horizontal || trailingEdge() <= cols) return true;\n    restore();\n\n    return false;\n  }\n\n  // Landed on something already placed — push the block forward until it is\n  // clear. Bounded by how far the placed items reach plus the block's own\n  // extent, so an unresolvable frame cannot spin.\n  const span = members.reduce((total, it) => total + it[size], 0);\n  const limit =\n    Math.max(0, ...compareWith.map((it) => it[head] + it[size])) +\n    span +\n    members.length +\n    1;\n\n  for (let step = 0; step < limit; step++) {\n    shift(1);\n    if (horizontal && trailingEdge() > cols) {\n      restore();\n      return false;\n    }\n    if (!overlaps()) return true;\n  }\n\n  restore();\n  return false;\n}\n\n/**\n * Push every non-mover that overlaps the group (or another displaced item) past\n * it along `axis`, until nothing overlaps.\n *\n * `axis` is the board's compaction axis, so the compactor re-packs along the same\n * line immediately afterwards and pulls each displaced item back to its minimal\n * position. A board that does not compact at all (`compact=\"free\"`) is pushed\n * down: down is the one direction a grid always has room in.\n *\n * Pushing along `x` can carry an item past the last column. That is fine and\n * deliberate: `compactItemHorizontal` wraps an overflowing item to the next row,\n * which is a resolution — rejecting the frame here instead would freeze better\n * than a quarter of all leftward group drags.\n *\n * Mutates `others` in place. Returns `false` if the cascade fails to settle,\n * which the caller turns into a rejected frame.\n */\nfunction displaceOthers(\n  movers: LayoutItem[],\n  others: LayoutItem[],\n  axis: 'x' | 'y',\n): boolean {\n  const size = axis === 'x' ? 'w' : 'h';\n  // Place one at a time, in reading order, against a set that starts as the\n  // group. Each push moves an item strictly past a placed item's far edge, so it\n  // advances monotonically and the loop is bounded by the stack extent.\n  const ordered = [...others].sort((a, b) =>\n    a.y === b.y ? a.x - b.x : a.y - b.y,\n  );\n  const placed: LayoutItem[] = [...movers];\n  const reach = (items: LayoutItem[]) =>\n    Math.max(0, ...items.map((it) => it[axis] + it[size]));\n  const limit = reach(movers) + reach(others) + others.length + 1;\n\n  for (const item of ordered) {\n    if (item.static) {\n      // Verified collision-free against the movers by the caller; other statics\n      // are pre-existing and not ours to resolve.\n      placed.push(item);\n      continue;\n    }\n\n    let steps = 0;\n    let shifted = true;\n\n    while (shifted) {\n      shifted = false;\n      for (const other of placed) {\n        if (collides(item, other)) {\n          (item as Mutable<LayoutItem>)[axis] = other[axis] + other[size];\n          shifted = true;\n        }\n      }\n      if (++steps > limit) {\n        return false;\n      }\n    }\n\n    placed.push(item);\n  }\n\n  return true;\n}\n"],"mappings":"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"}

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

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