@cube-dev/ui-kit 0.182.0 → 0.184.0

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"placement.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/placement.ts"],"sourcesContent":["/**\n * Placing items into a grid without dragging them there.\n *\n * A board's own gestures resolve placement through the compactor and the\n * collision resolver. An app that adds a widget programmatically — a toolbar\n * drop, a widget moved between boards by code, an \"arrange these for me\"\n * command — has to answer the same question with no gesture in hand, and had no\n * way to ask the engine for the answer. Left to solve it themselves, apps\n * re-implement the scan, and the same drop lands in two different cells\n * depending on whether a pointer or a code path served it.\n *\n * Original UI Kit code (not vendored from react-grid-layout).\n */\n\nimport { collides } from './collision';\n\nimport type { Layout, LayoutItem } from './types';\n\n/**\n * The first position at or below the preferred cell where `item` fits without\n * overlapping any of `others` (which must themselves be overlap-free), scanning\n * left-to-right then top-to-bottom and never past `maxRows`; if the band below\n * is full, upward toward the top.\n *\n * This is the rule the board itself applies when it has to land a widget that\n * cannot stay where it was dropped, so using it for a programmatic add is what\n * makes the two agree.\n *\n * A finite `maxRows` mirrors the `gridBounds` constraint the normal landing path\n * applies (`clamp(y, 0, maxRows - h)`): the item's bottom edge stays within the\n * row limit even when the landing cell is blocked, so the downward scan cannot\n * push it off the board. If the whole valid band is full the item is clamped to\n * the limit — bounds win over overlap, exactly as `gridBounds` does. With an\n * unbounded `maxRows` there is always a free slot below every existing item, so\n * the downward scan terminates on its own.\n *\n * The returned item is a copy; `item` is not mutated. Its `w` is capped to\n * `cols`, and no other dimension is changed — this never resizes to fit.\n */\nexport function placeInFreeSlot(\n  others: Layout,\n  item: LayoutItem,\n  cols: number,\n  maxRows = Infinity,\n): LayoutItem {\n  const w = Math.min(item.w, cols);\n  const maxY = Number.isFinite(maxRows)\n    ? Math.max(0, maxRows - item.h)\n    : Infinity;\n  const fits = (x: number, y: number) =>\n    !others.some((o) => collides(o, { ...item, x, y, w }));\n  const preferX = Math.min(Math.max(0, item.x), cols - w);\n  const startY = Math.min(Math.max(0, item.y), maxY);\n  if (fits(preferX, startY)) return { ...item, x: preferX, y: startY, w };\n  const scanBottom = Number.isFinite(maxRows)\n    ? maxY\n    : startY + others.reduce((m, o) => Math.max(m, o.y + o.h), 0) + 1;\n  for (let y = startY; y <= scanBottom; y++) {\n    for (let x = 0; x <= cols - w; x++) {\n      if (fits(x, y)) return { ...item, x, y, w };\n    }\n  }\n  // The landing row (clamped to the limit) and everything below it were full;\n  // look upward for a free slot still inside the board before giving up.\n  for (let y = startY - 1; y >= 0; y--) {\n    for (let x = 0; x <= cols - w; x++) {\n      if (fits(x, y)) return { ...item, x, y, w };\n    }\n  }\n  return { ...item, x: preferX, y: startY, w };\n}\n\n/**\n * Split `total` cells across `parts` groups as evenly as possible: each group\n * gets at least one, and the first `total % parts` groups get one extra so the\n * pieces sum to `total`. With more groups than cells every group still gets one\n * and the sum overflows, which the grid's own bounds then clip — the best\n * available answer when there is less than a cell to go round.\n */\nfunction splitEvenly(total: number, parts: number): number[] {\n  if (parts <= 0) return [];\n  const base = Math.max(1, Math.floor(total / parts));\n  const remainder = base * parts >= total ? 0 : total - base * parts;\n  return Array.from(\n    { length: parts },\n    (_, i) => base + (i < remainder ? 1 : 0),\n  );\n}\n\n/**\n * Tile every item evenly across both axes of a `cols × rows` grid, keeping the\n * row structure the layout already has: items are grouped into visual rows by\n * their current `y`, `rows` is divided across those groups, and `cols` across\n * each group's members.\n *\n * So three items on one line become three equal full-height columns; move one\n * below and the top line becomes two half-width cells while the lower item\n * spans the full width at half height. Grouping by `y` rather than reflowing\n * from scratch is what makes the result recognisably the user's arrangement\n * instead of an arbitrary repack.\n *\n * A visual row holding more items than the grid is wide is wrapped into\n * sub-rows of at most `cols`, so nothing tiles past the right edge. That can\n * take the result past `rows`; the caller decides whether to grow the grid or\n * let its bounds clip.\n *\n * This is the one operation that deliberately GROWS items — every gesture-driven\n * path refuses to, because growing on a move is a surprise. Here it is the whole\n * point, which is why it is a call the app makes rather than a mode the board is\n * in. Returns new items in the input's order; the input is not mutated.\n */\nexport function distributeEvenly(\n  layout: Layout,\n  { cols, rows }: { cols: number; rows: number },\n): LayoutItem[] {\n  if (layout.length === 0) return [];\n\n  const gridCols = Math.max(1, cols);\n  const gridRows = Math.max(1, rows);\n\n  const sorted = [...layout].sort((a, b) =>\n    a.y !== b.y ? a.y - b.y : a.x - b.x,\n  );\n\n  const groups: LayoutItem[][] = [];\n  let lastY: number | null = null;\n  for (const item of sorted) {\n    if (lastY === null || item.y !== lastY) {\n      groups.push([]);\n      lastY = item.y;\n    }\n    groups[groups.length - 1].push(item);\n  }\n\n  const rowGroups: LayoutItem[][] = [];\n  for (const group of groups) {\n    if (group.length <= gridCols) {\n      rowGroups.push(group);\n    } else {\n      for (let i = 0; i < group.length; i += gridCols) {\n        rowGroups.push(group.slice(i, i + gridCols));\n      }\n    }\n  }\n\n  const rowHeights = splitEvenly(gridRows, rowGroups.length);\n  const placed = new Map<string, LayoutItem>();\n  let y = 0;\n  rowGroups.forEach((group, gi) => {\n    const h = rowHeights[gi];\n    const widths = splitEvenly(gridCols, group.length);\n    let x = 0;\n    group.forEach((item, ci) => {\n      const w = widths[ci];\n      placed.set(item.i, { ...item, x, y, w, h });\n      x += w;\n    });\n    y += h;\n  });\n\n  // Emit in the caller's order, not the sort's: a layout is keyed by `i`, and\n  // reordering it would churn every consumer that diffs the array positionally.\n  return layout.map((item) => placed.get(item.i) ?? item);\n}\n"],"mappings":"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"}
+{"version":3,"file":"placement.js","names":["collides","Layout","LayoutItem","placeInFreeSlot","others","item","cols","maxRows","Infinity","w","Math","min","maxY","Number","isFinite","max","h","fits","x","y","some","o","preferX","startY","scanBottom","reduce","m","splitEvenly","total","parts","base","floor","remainder","Array","from","length","_","i","distributeEvenly","layout","rows","gridCols","gridRows","sorted","sort","a","b","groups","lastY","push","rowGroups","group","slice","rowHeights","placed","Map","forEach","gi","widths","ci","set","map","get"],"sources":["../../../../../src/components/layout/Board/grid-core/placement.ts"],"sourcesContent":["/**\n * Placing items into a grid without dragging them there.\n *\n * A board's own gestures resolve placement through the compactor and the\n * collision resolver. An app that adds a widget programmatically — a toolbar\n * drop, a widget moved between boards by code, an \"arrange these for me\"\n * command — has to answer the same question with no gesture in hand, and had no\n * way to ask the engine for the answer. Left to solve it themselves, apps\n * re-implement the scan, and the same drop lands in two different cells\n * depending on whether a pointer or a code path served it.\n *\n * Original UI Kit code (not vendored from react-grid-layout).\n */\n\nimport { collides } from './collision';\n\nimport type { Layout, LayoutItem } from './types';\n\n/**\n * The first position at or below the preferred cell where `item` fits without\n * overlapping any of `others` (which must themselves be overlap-free), scanning\n * left-to-right then top-to-bottom and never past `maxRows`; if the band below\n * is full, upward toward the top.\n *\n * This is the rule the board itself applies when it has to land a widget that\n * cannot stay where it was dropped, so using it for a programmatic add is what\n * makes the two agree.\n *\n * A finite `maxRows` mirrors the `gridBounds` constraint the normal landing path\n * applies (`clamp(y, 0, maxRows - h)`): the item's bottom edge stays within the\n * row limit even when the landing cell is blocked, so the downward scan cannot\n * push it off the board. If the whole valid band is full the item is clamped to\n * the limit — bounds win over overlap, exactly as `gridBounds` does. With an\n * unbounded `maxRows` there is always a free slot below every existing item, so\n * the downward scan terminates on its own.\n *\n * The returned item is a copy; `item` is not mutated. Its `w` is capped to\n * `cols`, and no other dimension is changed — this never resizes to fit.\n */\nexport function placeInFreeSlot(\n  others: Layout,\n  item: LayoutItem,\n  cols: number,\n  maxRows = Infinity,\n): LayoutItem {\n  const w = Math.min(item.w, cols);\n  const maxY = Number.isFinite(maxRows)\n    ? Math.max(0, maxRows - item.h)\n    : Infinity;\n  const fits = (x: number, y: number) =>\n    !others.some((o) => collides(o, { ...item, x, y, w }));\n  const preferX = Math.min(Math.max(0, item.x), cols - w);\n  const startY = Math.min(Math.max(0, item.y), maxY);\n  if (fits(preferX, startY)) return { ...item, x: preferX, y: startY, w };\n  const scanBottom = Number.isFinite(maxRows)\n    ? maxY\n    : startY + others.reduce((m, o) => Math.max(m, o.y + o.h), 0) + 1;\n  for (let y = startY; y <= scanBottom; y++) {\n    for (let x = 0; x <= cols - w; x++) {\n      if (fits(x, y)) return { ...item, x, y, w };\n    }\n  }\n  // The landing row (clamped to the limit) and everything below it were full;\n  // look upward for a free slot still inside the board before giving up.\n  for (let y = startY - 1; y >= 0; y--) {\n    for (let x = 0; x <= cols - w; x++) {\n      if (fits(x, y)) return { ...item, x, y, w };\n    }\n  }\n  return { ...item, x: preferX, y: startY, w };\n}\n\n/**\n * Split `total` cells across `parts` groups as evenly as possible: each group\n * gets at least one, and the first `total % parts` groups get one extra so the\n * pieces sum to `total`. With more groups than cells every group still gets one\n * and the sum overflows, which the grid's own bounds then clip — the best\n * available answer when there is less than a cell to go round.\n */\nfunction splitEvenly(total: number, parts: number): number[] {\n  if (parts <= 0) return [];\n  const base = Math.max(1, Math.floor(total / parts));\n  const remainder = base * parts >= total ? 0 : total - base * parts;\n  return Array.from(\n    { length: parts },\n    (_, i) => base + (i < remainder ? 1 : 0),\n  );\n}\n\n/**\n * Tile every item evenly across both axes of a `cols × rows` grid, keeping the\n * row structure the layout already has: items are grouped into visual rows by\n * their current `y`, `rows` is divided across those groups, and `cols` across\n * each group's members.\n *\n * So three items on one line become three equal full-height columns; move one\n * below and the top line becomes two half-width cells while the lower item\n * spans the full width at half height. Grouping by `y` rather than reflowing\n * from scratch is what makes the result recognisably the user's arrangement\n * instead of an arbitrary repack.\n *\n * A visual row holding more items than the grid is wide is wrapped into\n * sub-rows of at most `cols`, so nothing tiles past the right edge. That can\n * take the result past `rows`; the caller decides whether to grow the grid or\n * let its bounds clip.\n *\n * This is the one operation that deliberately GROWS items — every gesture-driven\n * path refuses to, because growing on a move is a surprise. Here it is the whole\n * point, which is why it is a call the app makes rather than a mode the board is\n * in. Returns new items in the input's order; the input is not mutated.\n */\nexport function distributeEvenly(\n  layout: Layout,\n  { cols, rows }: { cols: number; rows: number },\n): LayoutItem[] {\n  if (layout.length === 0) return [];\n\n  const gridCols = Math.max(1, cols);\n  const gridRows = Math.max(1, rows);\n\n  const sorted = [...layout].sort((a, b) =>\n    a.y !== b.y ? a.y - b.y : a.x - b.x,\n  );\n\n  const groups: LayoutItem[][] = [];\n  let lastY: number | null = null;\n  for (const item of sorted) {\n    if (lastY === null || item.y !== lastY) {\n      groups.push([]);\n      lastY = item.y;\n    }\n    groups[groups.length - 1].push(item);\n  }\n\n  const rowGroups: LayoutItem[][] = [];\n  for (const group of groups) {\n    if (group.length <= gridCols) {\n      rowGroups.push(group);\n    } else {\n      for (let i = 0; i < group.length; i += gridCols) {\n        rowGroups.push(group.slice(i, i + gridCols));\n      }\n    }\n  }\n\n  const rowHeights = splitEvenly(gridRows, rowGroups.length);\n  const placed = new Map<string, LayoutItem>();\n  let y = 0;\n  rowGroups.forEach((group, gi) => {\n    const h = rowHeights[gi];\n    const widths = splitEvenly(gridCols, group.length);\n    let x = 0;\n    group.forEach((item, ci) => {\n      const w = widths[ci];\n      placed.set(item.i, { ...item, x, y, w, h });\n      x += w;\n    });\n    y += h;\n  });\n\n  // Emit in the caller's order, not the sort's: a layout is keyed by `i`, and\n  // reordering it would churn every consumer that diffs the array positionally.\n  return layout.map((item) => placed.get(item.i) ?? item);\n}\n"],"mappings":"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"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"sort.js","names":[],"sources":["../../../../../src/components/layout/Board/grid-core/sort.ts"],"sourcesContent":["/**\n * Sorting utilities for grid layouts.\n *\n * Vendored from react-grid-layout v2 (`src/core/sort.ts`).\n * See ./NOTICE.md for attribution and license.\n */\n\nimport type { CompactType, Layout, LayoutItem } from './types';\n\n/**\n * Sort layout items based on the compaction type.\n *\n * - Vertical compaction: sort by row (y) then column (x)\n * - Horizontal compaction: sort by column (x) then row (y)\n * - No compaction (null): return original order\n */\nexport function sortLayoutItems(\n  layout: Layout,\n  compactType: CompactType,\n): LayoutItem[] {\n  if (compactType === 'horizontal') {\n    return sortLayoutItemsByColRow(layout);\n  }\n  if (compactType === 'vertical') {\n    return sortLayoutItemsByRowCol(layout);\n  }\n  if (compactType === 'wrap') {\n    // Wrap mode uses row-col order (reading order: left-to-right, top-to-bottom)\n    return sortLayoutItemsByRowCol(layout);\n  }\n  // No compaction - return a copy to maintain immutability\n  return [...layout];\n}\n\n/**\n * Sort layout items by row ascending, then column ascending.\n */\nexport function sortLayoutItemsByRowCol(layout: Layout): LayoutItem[] {\n  return [...layout].sort((a, b) => {\n    if (a.y !== b.y) {\n      return a.y - b.y;\n    }\n    return a.x - b.x;\n  });\n}\n\n/**\n * Sort layout items by column ascending, then row ascending.\n */\nexport function sortLayoutItemsByColRow(layout: Layout): LayoutItem[] {\n  return [...layout].sort((a, b) => {\n    if (a.x !== b.x) {\n      return a.x - b.x;\n    }\n    return a.y - b.y;\n  });\n}\n"],"mappings":";;;;;;;;;AAgBA,SAAgB,gBACd,QACA,aACc;AACd,KAAI,gBAAgB,aAClB,QAAO,wBAAwB,OAAO;AAExC,KAAI,gBAAgB,WAClB,QAAO,wBAAwB,OAAO;AAExC,KAAI,gBAAgB,OAElB,QAAO,wBAAwB,OAAO;AAGxC,QAAO,CAAC,GAAG,OAAO;;;;;AAMpB,SAAgB,wBAAwB,QAA8B;AACpE,QAAO,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM;AAChC,MAAI,EAAE,MAAM,EAAE,EACZ,QAAO,EAAE,IAAI,EAAE;AAEjB,SAAO,EAAE,IAAI,EAAE;GACf;;;;;AAMJ,SAAgB,wBAAwB,QAA8B;AACpE,QAAO,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,MAAM;AAChC,MAAI,EAAE,MAAM,EAAE,EACZ,QAAO,EAAE,IAAI,EAAE;AAEjB,SAAO,EAAE,IAAI,EAAE;GACf"}
+{"version":3,"file":"sort.js","names":["CompactType","Layout","LayoutItem","sortLayoutItems","layout","compactType","sortLayoutItemsByColRow","sortLayoutItemsByRowCol","sort","a","b","y","x"],"sources":["../../../../../src/components/layout/Board/grid-core/sort.ts"],"sourcesContent":["/**\n * Sorting utilities for grid layouts.\n *\n * Vendored from react-grid-layout v2 (`src/core/sort.ts`).\n * See ./NOTICE.md for attribution and license.\n */\n\nimport type { CompactType, Layout, LayoutItem } from './types';\n\n/**\n * Sort layout items based on the compaction type.\n *\n * - Vertical compaction: sort by row (y) then column (x)\n * - Horizontal compaction: sort by column (x) then row (y)\n * - No compaction (null): return original order\n */\nexport function sortLayoutItems(\n  layout: Layout,\n  compactType: CompactType,\n): LayoutItem[] {\n  if (compactType === 'horizontal') {\n    return sortLayoutItemsByColRow(layout);\n  }\n  if (compactType === 'vertical') {\n    return sortLayoutItemsByRowCol(layout);\n  }\n  if (compactType === 'wrap') {\n    // Wrap mode uses row-col order (reading order: left-to-right, top-to-bottom)\n    return sortLayoutItemsByRowCol(layout);\n  }\n  // No compaction - return a copy to maintain immutability\n  return [...layout];\n}\n\n/**\n * Sort layout items by row ascending, then column ascending.\n */\nexport function sortLayoutItemsByRowCol(layout: Layout): LayoutItem[] {\n  return [...layout].sort((a, b) => {\n    if (a.y !== b.y) {\n      return a.y - b.y;\n    }\n    return a.x - b.x;\n  });\n}\n\n/**\n * Sort layout items by column ascending, then row ascending.\n */\nexport function sortLayoutItemsByColRow(layout: Layout): LayoutItem[] {\n  return [...layout].sort((a, b) => {\n    if (a.x !== b.x) {\n      return a.x - b.x;\n    }\n    return a.y - b.y;\n  });\n}\n"],"mappings":";;;;;;;;;AAgBA,SAAgBG,gBACdC,QACAC,aACc;AACd,KAAIA,gBAAgB,aAClB,QAAOC,wBAAwBF,OAAO;AAExC,KAAIC,gBAAgB,WAClB,QAAOE,wBAAwBH,OAAO;AAExC,KAAIC,gBAAgB,OAElB,QAAOE,wBAAwBH,OAAO;AAGxC,QAAO,CAAC,GAAGA,OAAO;;;;;AAMpB,SAAgBG,wBAAwBH,QAA8B;AACpE,QAAO,CAAC,GAAGA,OAAO,CAACI,MAAMC,GAAGC,MAAM;AAChC,MAAID,EAAEE,MAAMD,EAAEC,EACZ,QAAOF,EAAEE,IAAID,EAAEC;AAEjB,SAAOF,EAAEG,IAAIF,EAAEE;GACf;;;;;AAMJ,SAAgBN,wBAAwBF,QAA8B;AACpE,QAAO,CAAC,GAAGA,OAAO,CAACI,MAAMC,GAAGC,MAAM;AAChC,MAAID,EAAEG,MAAMF,EAAEE,EACZ,QAAOH,EAAEG,IAAIF,EAAEE;AAEjB,SAAOH,EAAEE,IAAID,EAAEC;GACf"}

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.184.0 | Cube Dev Team */
 import { BoardDragActiveProvider } from "./board-context.js";
 import { distributeEvenly, placeInFreeSlot } from "./grid-core/placement.js";
 import { getCompactor, horizontalCompactor, noCompactor, verticalCompactor } from "./grid-core/compactors.js";

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"responsive-utils.js","names":[],"sources":["../../../../src/components/layout/Board/responsive-utils.ts"],"sourcesContent":["/**\n * Responsive helpers for `Board.Responsive`.\n *\n * Framework-agnostic breakpoint math adapted (MIT) from react-grid-layout's\n * `responsiveUtils`, rewritten to use this package's grid-core primitives. See\n * ./grid-core/NOTICE.md for the upstream attribution and license.\n */\nimport { cloneLayout, Compactor, correctBounds, LayoutItem } from './grid-core';\n\n/** Map of breakpoint name -> minimum container width (px). */\nexport type Breakpoints = Record<string, number>;\n/** Map of breakpoint name -> column count. */\nexport type BreakpointCols = Record<string, number>;\n/** Map of breakpoint name -> layout. */\nexport type ResponsiveLayouts = Record<string, LayoutItem[]>;\n\n/** Breakpoint names sorted ascending by their minimum width. */\nexport function sortBreakpoints(breakpoints: Breakpoints): string[] {\n  return Object.keys(breakpoints).sort(\n    (a, b) => breakpoints[a] - breakpoints[b],\n  );\n}\n\n/**\n * The largest breakpoint whose minimum width is at or below `width`. Falls back\n * to the smallest breakpoint when `width` is narrower than all of them.\n */\nexport function getBreakpointFromWidth(\n  breakpoints: Breakpoints,\n  width: number,\n): string {\n  const sorted = sortBreakpoints(breakpoints);\n  let matching = sorted[0];\n  for (let i = 1; i < sorted.length; i++) {\n    const name = sorted[i];\n    if (width >= breakpoints[name]) matching = name;\n  }\n  return matching;\n}\n\n/** Column count for a breakpoint. */\nexport function getColsFromBreakpoint(\n  breakpoint: string,\n  cols: BreakpointCols,\n): number {\n  const value = cols[breakpoint];\n  if (value == null) {\n    throw new Error(\n      `Board.Responsive: no columns defined for breakpoint \"${breakpoint}\".`,\n    );\n  }\n  return value;\n}\n\n/**\n * The layout for `breakpoint`, or one synthesized from the nearest available\n * breakpoint (preferring `lastBreakpoint`, then breakpoints at or above the\n * target) corrected into bounds and compacted for the target column count.\n */\nexport function findOrGenerateResponsiveLayout(\n  layouts: ResponsiveLayouts,\n  breakpoints: Breakpoints,\n  breakpoint: string,\n  lastBreakpoint: string,\n  cols: number,\n  compactor: Compactor,\n): LayoutItem[] {\n  if (layouts[breakpoint]) return cloneLayout(layouts[breakpoint]);\n\n  let layout = layouts[lastBreakpoint];\n  const sorted = sortBreakpoints(breakpoints);\n  const above = sorted.slice(sorted.indexOf(breakpoint));\n  for (const name of above) {\n    if (layouts[name]) {\n      layout = layouts[name];\n      break;\n    }\n  }\n\n  layout = cloneLayout(layout || []);\n  return [...compactor.compact(correctBounds(layout, { cols }), cols)];\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,SAAgB,gBAAgB,aAAoC;AAClE,QAAO,OAAO,KAAK,YAAY,CAAC,MAC7B,GAAG,MAAM,YAAY,KAAK,YAAY,GACxC;;;;;;AAOH,SAAgB,uBACd,aACA,OACQ;CACR,MAAM,SAAS,gBAAgB,YAAY;CAC3C,IAAI,WAAW,OAAO;AACtB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,OAAO,OAAO;AACpB,MAAI,SAAS,YAAY,MAAO,YAAW;;AAE7C,QAAO;;;AAIT,SAAgB,sBACd,YACA,MACQ;CACR,MAAM,QAAQ,KAAK;AACnB,KAAI,SAAS,KACX,OAAM,IAAI,MACR,wDAAwD,WAAW,IACpE;AAEH,QAAO;;;;;;;AAQT,SAAgB,+BACd,SACA,aACA,YACA,gBACA,MACA,WACc;AACd,KAAI,QAAQ,YAAa,QAAO,YAAY,QAAQ,YAAY;CAEhE,IAAI,SAAS,QAAQ;CACrB,MAAM,SAAS,gBAAgB,YAAY;CAC3C,MAAM,QAAQ,OAAO,MAAM,OAAO,QAAQ,WAAW,CAAC;AACtD,MAAK,MAAM,QAAQ,MACjB,KAAI,QAAQ,OAAO;AACjB,WAAS,QAAQ;AACjB;;AAIJ,UAAS,YAAY,UAAU,EAAE,CAAC;AAClC,QAAO,CAAC,GAAG,UAAU,QAAQ,cAAc,QAAQ,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC"}
+{"version":3,"file":"responsive-utils.js","names":["cloneLayout","Compactor","correctBounds","LayoutItem","Breakpoints","Record","BreakpointCols","ResponsiveLayouts","sortBreakpoints","breakpoints","Object","keys","sort","a","b","getBreakpointFromWidth","width","sorted","matching","i","length","name","getColsFromBreakpoint","breakpoint","cols","value","Error","findOrGenerateResponsiveLayout","layouts","lastBreakpoint","compactor","layout","above","slice","indexOf","compact"],"sources":["../../../../src/components/layout/Board/responsive-utils.ts"],"sourcesContent":["/**\n * Responsive helpers for `Board.Responsive`.\n *\n * Framework-agnostic breakpoint math adapted (MIT) from react-grid-layout's\n * `responsiveUtils`, rewritten to use this package's grid-core primitives. See\n * ./grid-core/NOTICE.md for the upstream attribution and license.\n */\nimport { cloneLayout, Compactor, correctBounds, LayoutItem } from './grid-core';\n\n/** Map of breakpoint name -> minimum container width (px). */\nexport type Breakpoints = Record<string, number>;\n/** Map of breakpoint name -> column count. */\nexport type BreakpointCols = Record<string, number>;\n/** Map of breakpoint name -> layout. */\nexport type ResponsiveLayouts = Record<string, LayoutItem[]>;\n\n/** Breakpoint names sorted ascending by their minimum width. */\nexport function sortBreakpoints(breakpoints: Breakpoints): string[] {\n  return Object.keys(breakpoints).sort(\n    (a, b) => breakpoints[a] - breakpoints[b],\n  );\n}\n\n/**\n * The largest breakpoint whose minimum width is at or below `width`. Falls back\n * to the smallest breakpoint when `width` is narrower than all of them.\n */\nexport function getBreakpointFromWidth(\n  breakpoints: Breakpoints,\n  width: number,\n): string {\n  const sorted = sortBreakpoints(breakpoints);\n  let matching = sorted[0];\n  for (let i = 1; i < sorted.length; i++) {\n    const name = sorted[i];\n    if (width >= breakpoints[name]) matching = name;\n  }\n  return matching;\n}\n\n/** Column count for a breakpoint. */\nexport function getColsFromBreakpoint(\n  breakpoint: string,\n  cols: BreakpointCols,\n): number {\n  const value = cols[breakpoint];\n  if (value == null) {\n    throw new Error(\n      `Board.Responsive: no columns defined for breakpoint \"${breakpoint}\".`,\n    );\n  }\n  return value;\n}\n\n/**\n * The layout for `breakpoint`, or one synthesized from the nearest available\n * breakpoint (preferring `lastBreakpoint`, then breakpoints at or above the\n * target) corrected into bounds and compacted for the target column count.\n */\nexport function findOrGenerateResponsiveLayout(\n  layouts: ResponsiveLayouts,\n  breakpoints: Breakpoints,\n  breakpoint: string,\n  lastBreakpoint: string,\n  cols: number,\n  compactor: Compactor,\n): LayoutItem[] {\n  if (layouts[breakpoint]) return cloneLayout(layouts[breakpoint]);\n\n  let layout = layouts[lastBreakpoint];\n  const sorted = sortBreakpoints(breakpoints);\n  const above = sorted.slice(sorted.indexOf(breakpoint));\n  for (const name of above) {\n    if (layouts[name]) {\n      layout = layouts[name];\n      break;\n    }\n  }\n\n  layout = cloneLayout(layout || []);\n  return [...compactor.compact(correctBounds(layout, { cols }), cols)];\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,SAAgBQ,gBAAgBC,aAAoC;AAClE,QAAOC,OAAOC,KAAKF,YAAY,CAACG,MAC7BC,GAAGC,MAAML,YAAYI,KAAKJ,YAAYK,GACxC;;;;;;AAOH,SAAgBC,uBACdN,aACAO,OACQ;CACR,MAAMC,SAAST,gBAAgBC,YAAY;CAC3C,IAAIS,WAAWD,OAAO;AACtB,MAAK,IAAIE,IAAI,GAAGA,IAAIF,OAAOG,QAAQD,KAAK;EACtC,MAAME,OAAOJ,OAAOE;AACpB,MAAIH,SAASP,YAAYY,MAAOH,YAAWG;;AAE7C,QAAOH;;;AAIT,SAAgBI,sBACdC,YACAC,MACQ;CACR,MAAMC,QAAQD,KAAKD;AACnB,KAAIE,SAAS,KACX,OAAM,IAAIC,MACR,wDAAwDH,WAAU,IACnE;AAEH,QAAOE;;;;;;;AAQT,SAAgBE,+BACdC,SACAnB,aACAc,YACAM,gBACAL,MACAM,WACc;AACd,KAAIF,QAAQL,YAAa,QAAOvB,YAAY4B,QAAQL,YAAY;CAEhE,IAAIQ,SAASH,QAAQC;CACrB,MAAMZ,SAAST,gBAAgBC,YAAY;CAC3C,MAAMuB,QAAQf,OAAOgB,MAAMhB,OAAOiB,QAAQX,WAAW,CAAC;AACtD,MAAK,MAAMF,QAAQW,MACjB,KAAIJ,QAAQP,OAAO;AACjBU,WAASH,QAAQP;AACjB;;AAIJU,UAAS/B,YAAY+B,UAAU,EAAE,CAAC;AAClC,QAAO,CAAC,GAAGD,UAAUK,QAAQjC,cAAc6B,QAAQ,EAAEP,MAAM,CAAC,EAAEA,KAAK,CAAC"}

package/dist/components/layout/Board/use-board-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.184.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { cloneLayout } from "./grid-core/layout.js";
 import { useCallback, useEffect, useRef, useState } from "react";
@@ -30,15 +30,15 @@ function useBoardLayout(options) {
 	useEffect(() => {
 		if (isControlled && controlledLayout !== prevControlledRef.current) {
 			prevControlledRef.current = controlledLayout;
-			const next = cloneLayout(controlledLayout ?? []);
-			layoutRef.current = next;
-			setLayout(next);
+			const next_0 = cloneLayout(controlledLayout ?? []);
+			layoutRef.current = next_0;
+			setLayout(next_0);
 		}
 	}, [controlledLayout, isControlled]);
-	const applyLayout = useCallback((next, commit, reason = "normalize") => {
-		layoutRef.current = next;
-		setLayout(next);
-		if (commit) onLayoutChangeEvent(next, reason);
+	const applyLayout = useCallback((next_1, commit, reason_0 = "normalize") => {
+		layoutRef.current = next_1;
+		setLayout(next_1);
+		if (commit) onLayoutChangeEvent(next_1, reason_0);
 	}, [onLayoutChangeEvent]);
 	return {
 		layout,

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

@@ -1 +1 @@
-{"version":3,"file":"use-board-layout.js","names":[],"sources":["../../../../src/components/layout/Board/use-board-layout.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { cloneLayout, LayoutItem } from './grid-core';\n\n/**\n * Why the layout changed.\n *\n * A board commits for two different kinds of reason, and an app usually cares\n * which: a gesture is the user arranging their board, while a normalization is\n * the board fitting an existing arrangement to a constraint that moved\n * underneath it. Without this, an app that persists `onLayoutChange` has no way\n * to tell \"the user dragged a widget\" from \"the column count changed and the\n * board reflowed\", so it writes the reflow back as if it were an edit — marking\n * a document dirty nobody touched.\n *\n * - `drag` / `resize` — a pointer or keyboard gesture on this board.\n * - `transfer` — a widget arrived from, or left for, another board.\n * - `normalize` — no gesture: a reflow for a changed column count, or an\n *   auto-height widget growing to fit its content.\n */\nexport type BoardLayoutChangeReason =\n  | 'drag'\n  | 'resize'\n  | 'transfer'\n  | 'normalize';\n\n/** What `onLayoutChange` reports alongside the new layout. */\nexport interface BoardLayoutChangeInfo {\n  reason: BoardLayoutChangeReason;\n}\n\nexport interface UseBoardLayoutOptions {\n  /** Controlled layout. */\n  layout?: LayoutItem[];\n  /** Initial layout for uncontrolled usage. */\n  defaultLayout?: LayoutItem[];\n  onLayoutChange?: (layout: LayoutItem[], info: BoardLayoutChangeInfo) => void;\n}\n\nexport interface UseBoardLayoutResult {\n  layout: LayoutItem[];\n  layoutRef: React.MutableRefObject<LayoutItem[]>;\n  /**\n   * Every drop-slot preview for the gesture in flight. A single-widget drag or\n   * resize produces one; a group drag produces one per moving widget.\n   */\n  placeholders: LayoutItem[];\n  /**\n   * The grabbed widget's placeholder — `placeholders[0]`, or `null` when there\n   * is none. Kept as a derived singular so the public `BoardInteractionInfo`\n   * keeps its exact shape.\n   */\n  placeholder: LayoutItem | null;\n  /**\n   * Synchronously-updated mirrors of the two above. `setPlaceholders` only\n   * schedules a re-render, so consumers that run in the same tick as a\n   * `setPlaceholders` call (e.g. drag lifecycle callbacks fired right after the\n   * registry updates the placeholders) must read a ref to see the live value.\n   */\n  placeholdersRef: React.MutableRefObject<LayoutItem[]>;\n  placeholderRef: React.MutableRefObject<LayoutItem | null>;\n  setPlaceholders: (items: LayoutItem[]) => void;\n  /**\n   * Update the layout. `commit` fires `onLayoutChange` with `reason`, which is\n   * required on a commit so a new commit path cannot forget to say why it\n   * fired.\n   */\n  applyLayout: (\n    layout: LayoutItem[],\n    commit: boolean,\n    reason?: BoardLayoutChangeReason,\n  ) => void;\n}\n\n/**\n * Headless layout state for a single board.\n *\n * Supports both controlled (`layout`) and uncontrolled (`defaultLayout`) usage.\n * Intermediate drag/resize previews always update local state; only committed\n * changes call `onLayoutChange`.\n */\nexport function useBoardLayout(\n  options: UseBoardLayoutOptions,\n): UseBoardLayoutResult {\n  const { layout: controlledLayout, defaultLayout, onLayoutChange } = options;\n  const isControlled = controlledLayout !== undefined;\n\n  const [layout, setLayout] = useState<LayoutItem[]>(() =>\n    cloneLayout(controlledLayout ?? defaultLayout ?? []),\n  );\n  const layoutRef = useRef<LayoutItem[]>(layout);\n  layoutRef.current = layout;\n\n  const [placeholders, setPlaceholdersState] = useState<LayoutItem[]>([]);\n  const placeholdersRef = useRef<LayoutItem[]>([]);\n  const placeholderRef = useRef<LayoutItem | null>(null);\n  const setPlaceholders = useCallback((items: LayoutItem[]) => {\n    placeholdersRef.current = items;\n    // Both mirrors move in the same synchronous call, so a same-tick reader can\n    // never see the two disagree.\n    placeholderRef.current = items[0] ?? null;\n    setPlaceholdersState(items);\n  }, []);\n\n  const onLayoutChangeEvent = useEvent(\n    (next: LayoutItem[], reason: BoardLayoutChangeReason) =>\n      onLayoutChange?.(next, { reason }),\n  );\n\n  // Sync controlled prop into local state when it changes by reference.\n  const prevControlledRef = useRef(controlledLayout);\n  useEffect(() => {\n    if (isControlled && controlledLayout !== prevControlledRef.current) {\n      prevControlledRef.current = controlledLayout;\n      const next = cloneLayout(controlledLayout ?? []);\n      layoutRef.current = next;\n      setLayout(next);\n    }\n  }, [controlledLayout, isControlled]);\n\n  const applyLayout = useCallback(\n    (\n      next: LayoutItem[],\n      commit: boolean,\n      reason: BoardLayoutChangeReason = 'normalize',\n    ) => {\n      layoutRef.current = next;\n      setLayout(next);\n      if (commit) {\n        onLayoutChangeEvent(next, reason);\n      }\n    },\n    [onLayoutChangeEvent],\n  );\n\n  return {\n    layout,\n    layoutRef,\n    placeholders,\n    placeholder: placeholders[0] ?? null,\n    placeholdersRef,\n    placeholderRef,\n    setPlaceholders,\n    applyLayout,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAmFA,SAAgB,eACd,SACsB;CACtB,MAAM,EAAE,QAAQ,kBAAkB,eAAe,mBAAmB;CACpE,MAAM,eAAe,qBAAqB;CAE1C,MAAM,CAAC,QAAQ,aAAa,eAC1B,YAAY,oBAAoB,iBAAiB,EAAE,CAAC,CACrD;CACD,MAAM,YAAY,OAAqB,OAAO;AAC9C,WAAU,UAAU;CAEpB,MAAM,CAAC,cAAc,wBAAwB,SAAuB,EAAE,CAAC;CACvE,MAAM,kBAAkB,OAAqB,EAAE,CAAC;CAChD,MAAM,iBAAiB,OAA0B,KAAK;CACtD,MAAM,kBAAkB,aAAa,UAAwB;AAC3D,kBAAgB,UAAU;AAG1B,iBAAe,UAAU,MAAM,MAAM;AACrC,uBAAqB,MAAM;IAC1B,EAAE,CAAC;CAEN,MAAM,sBAAsB,UACzB,MAAoB,WACnB,iBAAiB,MAAM,EAAE,QAAQ,CAAC,CACrC;CAGD,MAAM,oBAAoB,OAAO,iBAAiB;AAClD,iBAAgB;AACd,MAAI,gBAAgB,qBAAqB,kBAAkB,SAAS;AAClE,qBAAkB,UAAU;GAC5B,MAAM,OAAO,YAAY,oBAAoB,EAAE,CAAC;AAChD,aAAU,UAAU;AACpB,aAAU,KAAK;;IAEhB,CAAC,kBAAkB,aAAa,CAAC;CAEpC,MAAM,cAAc,aAEhB,MACA,QACA,SAAkC,gBAC/B;AACH,YAAU,UAAU;AACpB,YAAU,KAAK;AACf,MAAI,OACF,qBAAoB,MAAM,OAAO;IAGrC,CAAC,oBAAoB,CACtB;AAED,QAAO;EACL;EACA;EACA;EACA,aAAa,aAAa,MAAM;EAChC;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"use-board-layout.js","names":["useCallback","useEffect","useRef","useState","useEvent","cloneLayout","LayoutItem","BoardLayoutChangeReason","BoardLayoutChangeInfo","reason","UseBoardLayoutOptions","layout","defaultLayout","onLayoutChange","info","UseBoardLayoutResult","layoutRef","React","MutableRefObject","placeholders","placeholder","placeholdersRef","placeholderRef","setPlaceholders","items","applyLayout","commit","useBoardLayout","options","controlledLayout","isControlled","undefined","setLayout","current","setPlaceholdersState","onLayoutChangeEvent","next","prevControlledRef"],"sources":["../../../../src/components/layout/Board/use-board-layout.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport { cloneLayout, LayoutItem } from './grid-core';\n\n/**\n * Why the layout changed.\n *\n * A board commits for two different kinds of reason, and an app usually cares\n * which: a gesture is the user arranging their board, while a normalization is\n * the board fitting an existing arrangement to a constraint that moved\n * underneath it. Without this, an app that persists `onLayoutChange` has no way\n * to tell \"the user dragged a widget\" from \"the column count changed and the\n * board reflowed\", so it writes the reflow back as if it were an edit — marking\n * a document dirty nobody touched.\n *\n * - `drag` / `resize` — a pointer or keyboard gesture on this board.\n * - `transfer` — a widget arrived from, or left for, another board.\n * - `normalize` — no gesture: a reflow for a changed column count, or an\n *   auto-height widget growing to fit its content.\n */\nexport type BoardLayoutChangeReason =\n  | 'drag'\n  | 'resize'\n  | 'transfer'\n  | 'normalize';\n\n/** What `onLayoutChange` reports alongside the new layout. */\nexport interface BoardLayoutChangeInfo {\n  reason: BoardLayoutChangeReason;\n}\n\nexport interface UseBoardLayoutOptions {\n  /** Controlled layout. */\n  layout?: LayoutItem[];\n  /** Initial layout for uncontrolled usage. */\n  defaultLayout?: LayoutItem[];\n  onLayoutChange?: (layout: LayoutItem[], info: BoardLayoutChangeInfo) => void;\n}\n\nexport interface UseBoardLayoutResult {\n  layout: LayoutItem[];\n  layoutRef: React.MutableRefObject<LayoutItem[]>;\n  /**\n   * Every drop-slot preview for the gesture in flight. A single-widget drag or\n   * resize produces one; a group drag produces one per moving widget.\n   */\n  placeholders: LayoutItem[];\n  /**\n   * The grabbed widget's placeholder — `placeholders[0]`, or `null` when there\n   * is none. Kept as a derived singular so the public `BoardInteractionInfo`\n   * keeps its exact shape.\n   */\n  placeholder: LayoutItem | null;\n  /**\n   * Synchronously-updated mirrors of the two above. `setPlaceholders` only\n   * schedules a re-render, so consumers that run in the same tick as a\n   * `setPlaceholders` call (e.g. drag lifecycle callbacks fired right after the\n   * registry updates the placeholders) must read a ref to see the live value.\n   */\n  placeholdersRef: React.MutableRefObject<LayoutItem[]>;\n  placeholderRef: React.MutableRefObject<LayoutItem | null>;\n  setPlaceholders: (items: LayoutItem[]) => void;\n  /**\n   * Update the layout. `commit` fires `onLayoutChange` with `reason`, which is\n   * required on a commit so a new commit path cannot forget to say why it\n   * fired.\n   */\n  applyLayout: (\n    layout: LayoutItem[],\n    commit: boolean,\n    reason?: BoardLayoutChangeReason,\n  ) => void;\n}\n\n/**\n * Headless layout state for a single board.\n *\n * Supports both controlled (`layout`) and uncontrolled (`defaultLayout`) usage.\n * Intermediate drag/resize previews always update local state; only committed\n * changes call `onLayoutChange`.\n */\nexport function useBoardLayout(\n  options: UseBoardLayoutOptions,\n): UseBoardLayoutResult {\n  const { layout: controlledLayout, defaultLayout, onLayoutChange } = options;\n  const isControlled = controlledLayout !== undefined;\n\n  const [layout, setLayout] = useState<LayoutItem[]>(() =>\n    cloneLayout(controlledLayout ?? defaultLayout ?? []),\n  );\n  const layoutRef = useRef<LayoutItem[]>(layout);\n  layoutRef.current = layout;\n\n  const [placeholders, setPlaceholdersState] = useState<LayoutItem[]>([]);\n  const placeholdersRef = useRef<LayoutItem[]>([]);\n  const placeholderRef = useRef<LayoutItem | null>(null);\n  const setPlaceholders = useCallback((items: LayoutItem[]) => {\n    placeholdersRef.current = items;\n    // Both mirrors move in the same synchronous call, so a same-tick reader can\n    // never see the two disagree.\n    placeholderRef.current = items[0] ?? null;\n    setPlaceholdersState(items);\n  }, []);\n\n  const onLayoutChangeEvent = useEvent(\n    (next: LayoutItem[], reason: BoardLayoutChangeReason) =>\n      onLayoutChange?.(next, { reason }),\n  );\n\n  // Sync controlled prop into local state when it changes by reference.\n  const prevControlledRef = useRef(controlledLayout);\n  useEffect(() => {\n    if (isControlled && controlledLayout !== prevControlledRef.current) {\n      prevControlledRef.current = controlledLayout;\n      const next = cloneLayout(controlledLayout ?? []);\n      layoutRef.current = next;\n      setLayout(next);\n    }\n  }, [controlledLayout, isControlled]);\n\n  const applyLayout = useCallback(\n    (\n      next: LayoutItem[],\n      commit: boolean,\n      reason: BoardLayoutChangeReason = 'normalize',\n    ) => {\n      layoutRef.current = next;\n      setLayout(next);\n      if (commit) {\n        onLayoutChangeEvent(next, reason);\n      }\n    },\n    [onLayoutChangeEvent],\n  );\n\n  return {\n    layout,\n    layoutRef,\n    placeholders,\n    placeholder: placeholders[0] ?? null,\n    placeholdersRef,\n    placeholderRef,\n    setPlaceholders,\n    applyLayout,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAmFA,SAAgB2B,eACdC,SACsB;CACtB,MAAM,EAAEjB,QAAQkB,kBAAkBjB,eAAeC,mBAAmBe;CACpE,MAAME,eAAeD,qBAAqBE;CAE1C,MAAM,CAACpB,QAAQqB,aAAa7B,eAC1BE,YAAYwB,oBAAoBjB,iBAAiB,EAAE,CACrD,CAAC;CACD,MAAMI,YAAYd,OAAqBS,OAAO;AAC9CK,WAAUiB,UAAUtB;CAEpB,MAAM,CAACQ,cAAce,wBAAwB/B,SAAuB,EAAE,CAAC;CACvE,MAAMkB,kBAAkBnB,OAAqB,EAAE,CAAC;CAChD,MAAMoB,iBAAiBpB,OAA0B,KAAK;CACtD,MAAMqB,kBAAkBvB,aAAawB,UAAwB;AAC3DH,kBAAgBY,UAAUT;AAG1BF,iBAAeW,UAAUT,MAAM,MAAM;AACrCU,uBAAqBV,MAAM;IAC1B,EAAE,CAAC;CAEN,MAAMW,sBAAsB/B,UACzBgC,MAAoB3B,WACnBI,iBAAiBuB,MAAM,EAAE3B,QAAQ,CACrC,CAAC;CAGD,MAAM4B,oBAAoBnC,OAAO2B,iBAAiB;AAClD5B,iBAAgB;AACd,MAAI6B,gBAAgBD,qBAAqBQ,kBAAkBJ,SAAS;AAClEI,qBAAkBJ,UAAUJ;GAC5B,MAAMO,SAAO/B,YAAYwB,oBAAoB,EAAE,CAAC;AAChDb,aAAUiB,UAAUG;AACpBJ,aAAUI,OAAK;;IAEhB,CAACP,kBAAkBC,aAAa,CAAC;CAEpC,MAAML,cAAczB,aAEhBoC,QACAV,QACAjB,WAAkC,gBAC/B;AACHO,YAAUiB,UAAUG;AACpBJ,YAAUI,OAAK;AACf,MAAIV,OACFS,qBAAoBC,QAAM3B,SAAO;IAGrC,CAAC0B,oBACH,CAAC;AAED,QAAO;EACLxB;EACAK;EACAG;EACAC,aAAaD,aAAa,MAAM;EAChCE;EACAC;EACAC;EACAE;EACD"}