@cube-dev/ui-kit 0.165.0 → 0.167.0

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

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

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

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

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

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

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

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

package/dist/components/layout/Board/grid-core/placement.d.ts

@@ -0,0 +1,58 @@
+
+import { Layout, LayoutItem } from "./types.js";
+
+//#region src/components/layout/Board/grid-core/placement.d.ts
+/**
+ * The first position at or below the preferred cell where `item` fits without
+ * overlapping any of `others` (which must themselves be overlap-free), scanning
+ * left-to-right then top-to-bottom and never past `maxRows`; if the band below
+ * is full, upward toward the top.
+ *
+ * This is the rule the board itself applies when it has to land a widget that
+ * cannot stay where it was dropped, so using it for a programmatic add is what
+ * makes the two agree.
+ *
+ * A finite `maxRows` mirrors the `gridBounds` constraint the normal landing path
+ * applies (`clamp(y, 0, maxRows - h)`): the item's bottom edge stays within the
+ * row limit even when the landing cell is blocked, so the downward scan cannot
+ * push it off the board. If the whole valid band is full the item is clamped to
+ * the limit — bounds win over overlap, exactly as `gridBounds` does. With an
+ * unbounded `maxRows` there is always a free slot below every existing item, so
+ * the downward scan terminates on its own.
+ *
+ * The returned item is a copy; `item` is not mutated. Its `w` is capped to
+ * `cols`, and no other dimension is changed — this never resizes to fit.
+ */
+declare function placeInFreeSlot(others: Layout, item: LayoutItem, cols: number, maxRows?: number): LayoutItem;
+/**
+ * Tile every item evenly across both axes of a `cols × rows` grid, keeping the
+ * row structure the layout already has: items are grouped into visual rows by
+ * their current `y`, `rows` is divided across those groups, and `cols` across
+ * each group's members.
+ *
+ * So three items on one line become three equal full-height columns; move one
+ * below and the top line becomes two half-width cells while the lower item
+ * spans the full width at half height. Grouping by `y` rather than reflowing
+ * from scratch is what makes the result recognisably the user's arrangement
+ * instead of an arbitrary repack.
+ *
+ * A visual row holding more items than the grid is wide is wrapped into
+ * sub-rows of at most `cols`, so nothing tiles past the right edge. That can
+ * take the result past `rows`; the caller decides whether to grow the grid or
+ * let its bounds clip.
+ *
+ * This is the one operation that deliberately GROWS items — every gesture-driven
+ * path refuses to, because growing on a move is a surprise. Here it is the whole
+ * point, which is why it is a call the app makes rather than a mode the board is
+ * in. Returns new items in the input's order; the input is not mutated.
+ */
+declare function distributeEvenly(layout: Layout, {
+  cols,
+  rows
+}: {
+  cols: number;
+  rows: number;
+}): LayoutItem[];
+//#endregion
+export { distributeEvenly, placeInFreeSlot };
+//# sourceMappingURL=placement.d.ts.map

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

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

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

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

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

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

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

@@ -1,9 +1,11 @@
 
 import { CollisionMode, Compactor, Layout, LayoutConstraint, LayoutItem, ResizeHandleAxis } from "./grid-core/types.js";
+import { distributeEvenly, placeInFreeSlot } from "./grid-core/placement.js";
 import { getCompactor, horizontalCompactor, noCompactor, verticalCompactor } from "./grid-core/compactors.js";
 import { aspectRatio, boundedX, boundedY, containerBounds, gridBounds, maxSize, minMaxSize, minSize, snapToGrid } from "./grid-core/constraints.js";
 import { BoardSelectionMode } from "./use-board-selection.js";
-import { BoardResizeGripPlacement, CubeBoardWidgetProps, Widget } from "./Widget.js";
+import { BoardLayoutChangeInfo, BoardLayoutChangeReason } from "./use-board-layout.js";
+import { BoardCornerPlacement, BoardResizeGripPlacement, CubeBoardWidgetProps, Widget } from "./Widget.js";
 import { BOARD_SELECTION_CANCEL, BoardCompactType, BoardGridLines, BoardInteractionInfo, CubeBoardProps } from "./Board.js";
 import { BreakpointCols, Breakpoints, ResponsiveLayouts } from "./responsive-utils.js";
 import { BoardResponsive, CubeBoardResponsiveProps } from "./BoardResponsive.js";

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

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

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

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

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

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

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

@@ -0,0 +1,26 @@
+
+//#region src/components/layout/Board/use-board-layout.d.ts
+/**
+ * Why the layout changed.
+ *
+ * A board commits for two different kinds of reason, and an app usually cares
+ * which: a gesture is the user arranging their board, while a normalization is
+ * the board fitting an existing arrangement to a constraint that moved
+ * underneath it. Without this, an app that persists `onLayoutChange` has no way
+ * to tell "the user dragged a widget" from "the column count changed and the
+ * board reflowed", so it writes the reflow back as if it were an edit — marking
+ * a document dirty nobody touched.
+ *
+ * - `drag` / `resize` — a pointer or keyboard gesture on this board.
+ * - `transfer` — a widget arrived from, or left for, another board.
+ * - `normalize` — no gesture: a reflow for a changed column count, or an
+ *   auto-height widget growing to fit its content.
+ */
+type BoardLayoutChangeReason = 'drag' | 'resize' | 'transfer' | 'normalize';
+/** What `onLayoutChange` reports alongside the new layout. */
+interface BoardLayoutChangeInfo {
+  reason: BoardLayoutChangeReason;
+}
+//#endregion
+export { BoardLayoutChangeInfo, BoardLayoutChangeReason };
+//# sourceMappingURL=use-board-layout.d.ts.map

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

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.165.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.167.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";
@@ -25,7 +25,7 @@ function useBoardLayout(options) {
 		placeholderRef.current = items[0] ?? null;
 		setPlaceholdersState(items);
 	}, []);
-	const onLayoutChangeEvent = useEvent((next) => onLayoutChange?.(next));
+	const onLayoutChangeEvent = useEvent((next, reason) => onLayoutChange?.(next, { reason }));
 	const prevControlledRef = useRef(controlledLayout);
 	useEffect(() => {
 		if (isControlled && controlledLayout !== prevControlledRef.current) {
@@ -35,10 +35,10 @@ function useBoardLayout(options) {
 			setLayout(next);
 		}
 	}, [controlledLayout, isControlled]);
-	const applyLayout = useCallback((next, commit) => {
+	const applyLayout = useCallback((next, commit, reason = "normalize") => {
 		layoutRef.current = next;
 		setLayout(next);
-		if (commit) onLayoutChangeEvent(next);
+		if (commit) onLayoutChangeEvent(next, reason);
 	}, [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\nexport interface UseBoardLayoutOptions {\n  /** Controlled layout. */\n  layout?: LayoutItem[];\n  /** Initial layout for uncontrolled usage. */\n  defaultLayout?: LayoutItem[];\n  onLayoutChange?: (layout: LayoutItem[]) => 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  /** Update the layout. `commit` fires `onLayoutChange`. */\n  applyLayout: (layout: LayoutItem[], commit: boolean) => 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((next: LayoutItem[]) =>\n    onLayoutChange?.(next),\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    (next: LayoutItem[], commit: boolean) => {\n      layoutRef.current = next;\n      setLayout(next);\n      if (commit) {\n        onLayoutChangeEvent(next);\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":";;;;;;;;;;;;;AAgDA,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,UAAU,SACpC,iBAAiB,KAAK,CACvB;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,aACjB,MAAoB,WAAoB;AACvC,YAAU,UAAU;AACpB,YAAU,KAAK;AACf,MAAI,OACF,qBAAoB,KAAK;IAG7B,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":[],"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"}

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

@@ -1,8 +1,9 @@
-/** @license MIT | @cube-dev/ui-kit v0.165.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.167.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { BoardWidgetStore } from "./board-store.js";
 import { collides } from "./grid-core/collision.js";
 import { createCollisionResolver } from "./grid-core/collision-modes.js";
+import { placeInFreeSlot } from "./grid-core/placement.js";
 import { bottom, cloneLayout, getLayoutItem, moveElement } from "./grid-core/layout.js";
 import { moveElements } from "./grid-core/group-move.js";
 import { calcXYRaw } from "./grid-core/calculate.js";
@@ -77,58 +78,6 @@ function resizesAnything(before, after) {
 		return !!b && (b.w !== a.w || b.h !== a.h);
 	});
 }
-/**
-* First position at or below the preferred cell where `item` fits without
-* overlapping any of `others` (assumed overlap-free), scanning left-to-right
-* then top-to-bottom, never past `maxRows`. Last-resort placement for a legacy
-* (no-op compaction) cross-board drop that would otherwise stack widgets.
-*
-* A finite `maxRows` mirrors the `gridBounds` constraint the normal landing path
-* applies (`clamp(y, 0, maxRows - h)`): the widget's bottom edge (`y + h`) stays
-* within the row limit even when the landing cell is blocked, so the downward
-* scan can't push it off the board. Rows are searched from the (clamped) landing
-* row down to the limit first, then upward toward the top; if the whole valid
-* band is full the widget is clamped to the limit (bounds win over overlap, as
-* `gridBounds` does). With an unbounded `maxRows` there is always a free slot
-* below every existing item, so the downward scan terminates on its own.
-*/
-function placeInFreeSlot(others, item, cols, maxRows = Infinity) {
-	const w = Math.min(item.w, cols);
-	const maxY = Number.isFinite(maxRows) ? Math.max(0, maxRows - item.h) : Infinity;
-	const fits = (x, y) => !others.some((o) => collides(o, {
-		...item,
-		x,
-		y,
-		w
-	}));
-	const preferX = Math.min(Math.max(0, item.x), cols - w);
-	const startY = Math.min(Math.max(0, item.y), maxY);
-	if (fits(preferX, startY)) return {
-		...item,
-		x: preferX,
-		y: startY,
-		w
-	};
-	const scanBottom = Number.isFinite(maxRows) ? maxY : startY + others.reduce((m, o) => Math.max(m, o.y + o.h), 0) + 1;
-	for (let y = startY; y <= scanBottom; y++) for (let x = 0; x <= cols - w; x++) if (fits(x, y)) return {
-		...item,
-		x,
-		y,
-		w
-	};
-	for (let y = startY - 1; y >= 0; y--) for (let x = 0; x <= cols - w; x++) if (fits(x, y)) return {
-		...item,
-		x,
-		y,
-		w
-	};
-	return {
-		...item,
-		x: preferX,
-		y: startY,
-		w
-	};
-}
 function useBoardRegistry(options) {
 	const store = useMemo(() => new BoardWidgetStore(), []);
 	const onTransferRef = useRef(options?.onWidgetTransfer);
@@ -640,7 +589,7 @@ function useBoardRegistry(options) {
 			if (source) {
 				const sp = source.getPositionParams();
 				const sc = source.getCompactor();
-				source.applyLayout([...sc.compact(source.getLayout(), sp.cols)], true);
+				source.applyLayout([...sc.compact(source.getLayout(), sp.cols)], true, "drag");
 			}
 		} else {
 			const landing = lastLandingRef.current ?? {
@@ -661,7 +610,7 @@ function useBoardRegistry(options) {
 					const sp = source.getPositionParams();
 					const sc = source.getCompactor();
 					const remaining = source.getLayout().filter((l) => l.i !== ds.itemId);
-					source.applyLayout([...sc.compact(remaining, sp.cols)], true);
+					source.applyLayout([...sc.compact(remaining, sp.cols)], true, "transfer");
 				}
 				let finalLayout;
 				if (carried) finalLayout = strictIncomingSwap ? cloneLayout(carried) : [...tc.compact(cloneLayout(carried), tp.cols)];
@@ -692,7 +641,7 @@ function useBoardRegistry(options) {
 					x: landing.x,
 					y: landing.y
 				}, tp.cols, tp.maxRows)];
-				target.applyLayout(finalLayout, true);
+				target.applyLayout(finalLayout, true, "transfer");
 				onTransferRef.current?.({
 					widgetId: ds.itemId,
 					fromBoardId: ds.sourceBoardId,