@cube-dev/ui-kit 0.0.0-canary-c325dcb → 0.0.0-canary-162cdb3

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

@@ -1,254 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c325dcb | Cube Dev Team */
-//#region src/components/layout/Board/grid-core/collision-modes.ts
-/** Whether a single grid cell is free of every item in `others`. */
-function cellFree(others, x, y) {
-	for (let i = 0; i < others.length; i++) {
-		const o = others[i];
-		if (o !== void 0 && x >= o.x && x < o.x + o.w && y >= o.y && y < o.y + o.h) return false;
-	}
-	return true;
-}
-/**
-* The largest rectangle anchored at `anchor` that fits without overlapping
-* `others`, growing rightward and downward only.
-*
-* Never larger than `desired` (a drag must never *upscale* a widget - growing
-* things is an explicit, opt-in operation like "distribute evenly", not a side
-* effect of moving them), never smaller than the item's own `minW`/`minH`, and
-* never past `cols` / `maxRows`. Among the candidates the largest-area rectangle
-* wins, breaking ties on width: a grid is read left to right, so a wide-and-flat
-* result is the less surprising of two equal-area fits.
-*
-* Returns `null` when not even the minimum size fits, which the callers treat as
-* "no resolution" and fall back to reverting.
-*/
-function maxFreeRectAt(others, anchor, desired, limits, mins) {
-	if (anchor.x < 0 || anchor.y < 0) return null;
-	const minW = Math.max(1, mins?.minW ?? 1);
-	const minH = Math.max(1, mins?.minH ?? 1);
-	const maxRows = limits.maxRows ?? Infinity;
-	const maxW = Math.min(desired.w, limits.cols - anchor.x);
-	const maxH = Math.min(desired.h, Number.isFinite(maxRows) ? maxRows - anchor.y : desired.h);
-	if (maxW < minW || maxH < minH) return null;
-	const free = [];
-	for (let dx = 0; dx < maxW; dx++) {
-		let h = 0;
-		while (h < maxH && cellFree(others, anchor.x + dx, anchor.y + h)) h++;
-		free.push(h);
-		if (h === 0) break;
-	}
-	let best = null;
-	let bestArea = 0;
-	let limit = maxH;
-	for (let w = 1; w <= free.length; w++) {
-		limit = Math.min(limit, free[w - 1]);
-		if (limit < minH) break;
-		if (w < minW) continue;
-		const area = w * limit;
-		if (area >= bestArea) {
-			best = {
-				w,
-				h: limit
-			};
-			bestArea = area;
-		}
-	}
-	return best;
-}
-/**
-* The cells beyond a pinned anchor that a drag could never ask for.
-*
-* `gridBounds` clamps a drag anchor to `cols - w` (and `maxRows - h`), which
-* assumes the widget keeps the size it started with. So when the blocker is to
-* the LEFT of the free room and that room is narrower than the widget, every
-* anchor a pointer can produce lands inside the blocker - and the mode whose
-* whole job is to shrink the widget into that room never gets offered it. The
-* drop just reverts. The mirror case has no such problem, because the anchor at
-* column 0 is always reachable: that asymmetry is why downscaling into room on
-* the left has always worked and room on the right has not. The row axis clamps
-* the same way, so a board with a finite `maxRows` has the same blind spot below
-* a blocker.
-*
-* Nothing is offered unless the anchor is sitting ON the limit, pinned against
-* the far edge with the pointer unable to push it further. An anchor short of the
-* limit is the pointer's own choice - every cell between it and the limit was
-* available to ask for - so a blocked drop there still just reverts, exactly as
-* before. Without that gate a widget dropped on an occupied cell would skip over
-* free cells the pointer could perfectly well have aimed at.
-*
-* A pinned anchor's span ends at the last row/column of the grid, so every cell
-* returned - and every rectangle that can be measured from one - lies inside the
-* footprint the widget is already covering.
-*/
-function clampedOutAnchors(item, desired, limits) {
-	const maxRows = limits.maxRows ?? Infinity;
-	const bounded = Number.isFinite(maxRows);
-	const xLimit = Math.max(0, limits.cols - desired.w);
-	const yLimit = bounded ? Math.max(0, maxRows - desired.h) : Infinity;
-	const anchors = [];
-	if (item.x === xLimit) {
-		const lastX = Math.min(item.x + desired.w - 1, limits.cols - 1);
-		for (let x = item.x + 1; x <= lastX; x++) anchors.push({
-			x,
-			y: item.y
-		});
-	}
-	if (bounded && item.y === yLimit) {
-		const lastY = Math.min(item.y + desired.h - 1, maxRows - 1);
-		for (let y = item.y + 1; y <= lastY; y++) anchors.push({
-			x: item.x,
-			y
-		});
-	}
-	return anchors;
-}
-/**
-* Shrink the placement to the room actually available at the cell it was
-* dropped on, or - when that cell cannot take the widget at any size and the
-* anchor is pinned against the grid edge - at a cell the clamp hid from the
-* pointer (see `clampedOutAnchors`). The largest fit among those wins, so the
-* widget takes as much of the room it is already hovering as there is.
-*/
-function downscaleInPlace(layout, item, others, desired, limits) {
-	const fitAt = (anchor) => maxFreeRectAt(others, anchor, desired, limits, item);
-	let anchor = {
-		x: item.x,
-		y: item.y
-	};
-	let fit = fitAt(anchor);
-	if (!fit) {
-		let bestArea = 0;
-		for (const candidate of clampedOutAnchors(item, desired, limits)) {
-			const candidateFit = fitAt(candidate);
-			if (!candidateFit) continue;
-			const area = candidateFit.w * candidateFit.h;
-			if (area > bestArea) {
-				bestArea = area;
-				fit = candidateFit;
-				anchor = candidate;
-			}
-		}
-	}
-	if (!fit) return null;
-	if (fit.w === item.w && fit.h === item.h && anchor.x === item.x && anchor.y === item.y) return null;
-	return layout.map((l) => l.i === item.i ? {
-		...l,
-		x: anchor.x,
-		y: anchor.y,
-		w: fit.w,
-		h: fit.h,
-		moved: true
-	} : l);
-}
-/** Number of cells two items share. Zero when they do not overlap at all. */
-function overlapArea(a, b) {
-	const w = Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x);
-	const h = Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y);
-	return w > 0 && h > 0 ? w * h : 0;
-}
-/**
-* Exchange the placement with one of the widgets under it.
-*
-* The dragged widget takes the other's cell and the other takes the cell the
-* dragged widget came from. Each keeps as much of its own size as fits there -
-* that cell plus any free space adjacent to it - and neither ever grows.
-*
-* `from` is whatever the caller's layout says, so it is the caller that decides
-* what "came from" means. A pointer drag resolves every frame against the
-* arrangement the gesture started with, making it the cell the drag began at, and
-* keeping the result a pure function of where the pointer is; chaining frames off
-* each other instead would exchange with every widget swept over.
-* The slot the dragged widget is leaving is reserved for the displaced widget
-* while the dragged one is sized, so the two can never claim the same cells: the
-* result is overlap-free by construction, not by a follow-up check.
-*/
-function exchangeWithCollision(layout, item, collisions, from, desired, limits) {
-	if (from.x === item.x && from.y === item.y) return null;
-	const candidates = collisions.filter((c) => !c.static).map((c) => ({
-		c,
-		area: overlapArea(item, c)
-	})).sort((p, q) => q.area - p.area || p.c.y - q.c.y || p.c.x - q.c.x).map(({ c }) => c);
-	for (const other of candidates) {
-		const exchanged = exchangeWith(layout, item, other, from, desired, limits);
-		if (exchanged) return exchanged;
-	}
-	return null;
-}
-/** One concrete two-widget exchange, or `null` if either side cannot fit. */
-function exchangeWith(layout, item, other, from, desired, limits) {
-	const rest = layout.filter((l) => l.i !== item.i && l.i !== other.i);
-	const originSlot = {
-		i: "origin-slot-reservation",
-		x: from.x,
-		y: from.y,
-		w: desired.w,
-		h: desired.h
-	};
-	const movedFit = maxFreeRectAt([...rest, originSlot], {
-		x: other.x,
-		y: other.y
-	}, desired, limits, item);
-	if (!movedFit) return null;
-	const moved = {
-		...item,
-		x: other.x,
-		y: other.y,
-		w: movedFit.w,
-		h: movedFit.h,
-		moved: true
-	};
-	const displacedFit = maxFreeRectAt([...rest, moved], {
-		x: from.x,
-		y: from.y
-	}, {
-		w: other.w,
-		h: other.h
-	}, limits, other);
-	if (!displacedFit) return null;
-	const displaced = {
-		...other,
-		x: from.x,
-		y: from.y,
-		w: displacedFit.w,
-		h: displacedFit.h,
-		moved: true
-	};
-	return layout.map((l) => l.i === item.i ? moved : l.i === other.i ? displaced : l);
-}
-/**
-* Build the resolver `moveElement` consults instead of reverting a blocked move,
-* or `undefined` for `'revert'` (and for an unset mode), which keeps the engine
-* on its original path with no added work.
-*
-* For an in-board drag, `'swap'` is an escalation ladder: exchange with one of
-* the widgets under the drop, else downscale at the drop cell, else revert. A
-* dense grid stays draggable that way - refusing everything that is not a clean
-* one-to-one trade would make the mode feel broken exactly where it is needed.
-* Cross-board callers pass `allowExchange: false`, which turns the same mode into
-* downscaling at the drop cell - there is no slot on the destination to trade
-* back, and a transfer that cannot resolve is placed in a free cell rather than
-* refused, since a widget dropped somewhere has to end up somewhere.
-*/
-function createCollisionResolver(mode, options) {
-	if (!mode || mode === "revert") return void 0;
-	const limits = {
-		cols: options.cols,
-		maxRows: options.maxRows
-	};
-	return ({ layout, item, collisions, from }) => {
-		const others = layout.filter((l) => l.i !== item.i);
-		const desired = options.desired ?? {
-			w: item.w,
-			h: item.h
-		};
-		if (mode === "swap" && options.allowExchange !== false) {
-			const exchanged = exchangeWithCollision(layout, item, collisions, from, desired, limits);
-			if (exchanged) return exchanged;
-		}
-		return downscaleInPlace(layout, item, others, desired, limits);
-	};
-}
-
-//#endregion
-export { createCollisionResolver };
-//# sourceMappingURL=collision-modes.js.map

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

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

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

@@ -1,35 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c325dcb | Cube Dev Team */
-//#region src/components/layout/Board/grid-core/collision.ts
-/**
-* Check if two layout items collide (overlap).
-*
-* Two items collide if their bounding boxes overlap and they are not the same
-* item.
-*/
-function collides(l1, l2) {
-	if (l1.i === l2.i) return false;
-	if (l1.x + l1.w <= l2.x) return false;
-	if (l1.x >= l2.x + l2.w) return false;
-	if (l1.y + l1.h <= l2.y) return false;
-	if (l1.y >= l2.y + l2.h) return false;
-	return true;
-}
-/**
-* Find the first item in the layout that collides with the given item.
-*/
-function getFirstCollision(layout, layoutItem) {
-	for (let i = 0; i < layout.length; i++) {
-		const item = layout[i];
-		if (item !== void 0 && collides(item, layoutItem)) return item;
-	}
-}
-/**
-* Find all items in the layout that collide with the given item.
-*/
-function getAllCollisions(layout, layoutItem) {
-	return layout.filter((l) => collides(l, layoutItem));
-}
-
-//#endregion
-export { collides, getAllCollisions, getFirstCollision };
-//# sourceMappingURL=collision.js.map

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

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

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

@@ -1,23 +0,0 @@
-
-import { CompactType, Compactor } from "./types.js";
-
-//#region src/components/layout/Board/grid-core/compactors.d.ts
-/**
- * Vertical compactor - moves items up to fill gaps. Default compaction mode.
- */
-declare const verticalCompactor: Compactor;
-/**
- * Horizontal compactor - moves items left to fill gaps.
- */
-declare const horizontalCompactor: Compactor;
-/**
- * No compaction - items stay where placed (free-form layouts).
- */
-declare const noCompactor: Compactor;
-/**
- * Get a compactor by type (convenience for the string-based compactType API).
- */
-declare function getCompactor(compactType: CompactType, allowOverlap?: boolean, preventCollision?: boolean): Compactor;
-//#endregion
-export { getCompactor, horizontalCompactor, noCompactor, verticalCompactor };
-//# sourceMappingURL=compactors.d.ts.map

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

@@ -1,166 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c325dcb | Cube Dev Team */
-import { collides, getFirstCollision } from "./collision.js";
-import { sortLayoutItemsByColRow, sortLayoutItemsByRowCol } from "./sort.js";
-import { bottom, cloneLayout, cloneLayoutItem, getStatics } from "./layout.js";
-
-//#region src/components/layout/Board/grid-core/compactors.ts
-/**
-* Compactor implementations.
-*
-* Vendored from react-grid-layout v2 (`src/core/compactors.ts`).
-* See ./NOTICE.md for attribution and license.
-*
-* Compactors are pluggable strategies for removing gaps between grid items.
-*/
-/**
-* Resolve a compaction collision by moving items.
-*
-* Before moving an item to a position, checks if that movement would cause
-* collisions and recursively moves those items first.
-*/
-function resolveCompactionCollision(layout, item, moveToCoord, axis, hasStatics) {
-	const sizeProp = axis === "x" ? "w" : "h";
-	item[axis] += 1;
-	const itemIndex = layout.findIndex((l) => l.i === item.i);
-	const layoutHasStatics = hasStatics ?? getStatics(layout).length > 0;
-	for (let i = itemIndex + 1; i < layout.length; i++) {
-		const otherItem = layout[i];
-		if (otherItem === void 0) continue;
-		if (otherItem.static) continue;
-		if (!layoutHasStatics && otherItem.y > item.y + item.h) break;
-		if (collides(item, otherItem)) resolveCompactionCollision(layout, otherItem, moveToCoord + item[sizeProp], axis, layoutHasStatics);
-	}
-	item[axis] = moveToCoord;
-}
-/** Compact a single item vertically (move up). Mutates `l`. */
-function compactItemVertical(compareWith, l, fullLayout, maxY) {
-	l.x = Math.max(l.x, 0);
-	l.y = Math.max(l.y, 0);
-	l.y = Math.min(maxY, l.y);
-	while (l.y > 0 && !getFirstCollision(compareWith, l)) l.y--;
-	let collision;
-	while ((collision = getFirstCollision(compareWith, l)) !== void 0) resolveCompactionCollision(fullLayout, l, collision.y + collision.h, "y");
-	l.y = Math.max(l.y, 0);
-	return l;
-}
-/** Compact a single item horizontally (move left). Mutates `l`. */
-function compactItemHorizontal(compareWith, l, cols, fullLayout) {
-	l.x = Math.max(l.x, 0);
-	l.y = Math.max(l.y, 0);
-	while (l.x > 0 && !getFirstCollision(compareWith, l)) l.x--;
-	let collision;
-	while ((collision = getFirstCollision(compareWith, l)) !== void 0) {
-		resolveCompactionCollision(fullLayout, l, collision.x + collision.w, "x");
-		if (l.x + l.w > cols) {
-			l.x = cols - l.w;
-			l.y++;
-			while (l.x > 0 && !getFirstCollision(compareWith, l)) l.x--;
-		}
-	}
-	l.x = Math.max(l.x, 0);
-	return l;
-}
-/**
-* Vertical compactor - moves items up to fill gaps. Default compaction mode.
-*/
-const verticalCompactor = {
-	type: "vertical",
-	allowOverlap: false,
-	compact(layout, _cols) {
-		const compareWith = getStatics(layout);
-		let maxY = bottom(compareWith);
-		const sorted = sortLayoutItemsByRowCol(layout);
-		const out = new Array(layout.length);
-		for (let i = 0; i < sorted.length; i++) {
-			const sortedItem = sorted[i];
-			if (sortedItem === void 0) continue;
-			let l = cloneLayoutItem(sortedItem);
-			if (!l.static) {
-				l = compactItemVertical(compareWith, l, sorted, maxY);
-				maxY = Math.max(maxY, l.y + l.h);
-				compareWith.push(l);
-			}
-			const originalIndex = layout.indexOf(sortedItem);
-			out[originalIndex] = l;
-			l.moved = false;
-		}
-		return out;
-	}
-};
-/**
-* Horizontal compactor - moves items left to fill gaps.
-*/
-const horizontalCompactor = {
-	type: "horizontal",
-	allowOverlap: false,
-	compact(layout, cols) {
-		const compareWith = getStatics(layout);
-		const sorted = sortLayoutItemsByColRow(layout);
-		const out = new Array(layout.length);
-		for (let i = 0; i < sorted.length; i++) {
-			const sortedItem = sorted[i];
-			if (sortedItem === void 0) continue;
-			let l = cloneLayoutItem(sortedItem);
-			if (!l.static) {
-				l = compactItemHorizontal(compareWith, l, cols, sorted);
-				compareWith.push(l);
-			}
-			const originalIndex = layout.indexOf(sortedItem);
-			out[originalIndex] = l;
-			l.moved = false;
-		}
-		return out;
-	}
-};
-/**
-* No compaction - items stay where placed (free-form layouts).
-*/
-const noCompactor = {
-	type: null,
-	allowOverlap: false,
-	compact(layout, _cols) {
-		return cloneLayout(layout);
-	}
-};
-/** Vertical compactor that allows overlapping items. */
-const verticalOverlapCompactor = {
-	...verticalCompactor,
-	allowOverlap: true,
-	compact(layout, _cols) {
-		return cloneLayout(layout);
-	}
-};
-/** Horizontal compactor that allows overlapping items. */
-const horizontalOverlapCompactor = {
-	...horizontalCompactor,
-	allowOverlap: true,
-	compact(layout, _cols) {
-		return cloneLayout(layout);
-	}
-};
-/** No compaction, with overlapping allowed. */
-const noOverlapCompactor = {
-	...noCompactor,
-	allowOverlap: true
-};
-/**
-* Get a compactor by type (convenience for the string-based compactType API).
-*/
-function getCompactor(compactType, allowOverlap = false, preventCollision = false) {
-	let baseCompactor;
-	if (allowOverlap) if (compactType === "vertical") baseCompactor = verticalOverlapCompactor;
-	else if (compactType === "horizontal") baseCompactor = horizontalOverlapCompactor;
-	else baseCompactor = noOverlapCompactor;
-	else if (compactType === "vertical") baseCompactor = verticalCompactor;
-	else if (compactType === "horizontal") baseCompactor = horizontalCompactor;
-	else baseCompactor = noCompactor;
-	if (preventCollision) return {
-		...baseCompactor,
-		preventCollision
-	};
-	return baseCompactor;
-}
-
-//#endregion
-export { compactItemHorizontal, compactItemVertical, getCompactor, horizontalCompactor, noCompactor, verticalCompactor };
-//# sourceMappingURL=compactors.js.map

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

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

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

@@ -1,35 +0,0 @@
-
-import { LayoutConstraint } from "./types.js";
-
-//#region src/components/layout/Board/grid-core/constraints.d.ts
-/**
- * Grid boundary constraint. Ensures items stay within the grid bounds. This is
- * the default position constraint.
- */
-declare const gridBounds: LayoutConstraint;
-/**
- * Min/max size constraint. Enforces per-item minW/maxW/minH/maxH.
- */
-declare const minMaxSize: LayoutConstraint;
-/**
- * Container bounds constraint. Constrains items to stay within the visible
- * container (a replacement for the legacy `isBounded` prop).
- */
-declare const containerBounds: LayoutConstraint;
-/** Bounded X constraint. Only constrains horizontal position. */
-declare const boundedX: LayoutConstraint;
-/** Bounded Y constraint. Only constrains vertical position. */
-declare const boundedY: LayoutConstraint;
-/**
- * Create an aspect ratio constraint (maintains width-to-height ratio in pixels).
- */
-declare function aspectRatio(ratio: number): LayoutConstraint;
-/** Create a snap-to-grid constraint. */
-declare function snapToGrid(stepX: number, stepY?: number): LayoutConstraint;
-/** Create a minimum size constraint (grid-wide). */
-declare function minSize(minW: number, minH: number): LayoutConstraint;
-/** Create a maximum size constraint (grid-wide). */
-declare function maxSize(maxW: number, maxH: number): LayoutConstraint;
-//#endregion
-export { aspectRatio, boundedX, boundedY, containerBounds, gridBounds, maxSize, minMaxSize, minSize, snapToGrid };
-//# sourceMappingURL=constraints.d.ts.map