@cube-dev/ui-kit 0.0.0-canary-c26fe9d → 0.0.0-canary-223b7e5

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

@@ -1,16 +0,0 @@
-
-import { LayoutItem } from "./grid-core/types.js";
-import "./board-store.js";
-import { MutableRefObject } from "react";
-
-//#region src/components/layout/Board/board-context.d.ts
-/** Emitted when a widget is dropped from one board into another. */
-interface WidgetTransferInfo {
-  widgetId: string;
-  fromBoardId: string;
-  toBoardId: string;
-  item: LayoutItem;
-}
-//#endregion
-export { WidgetTransferInfo };
-//# sourceMappingURL=board-context.d.ts.map

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

@@ -1,32 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c26fe9d | Cube Dev Team */
-import { createContext, useContext } from "react";
-
-//#region src/components/layout/Board/board-context.tsx
-const BoardRegistryContext = createContext(null);
-function useBoardRegistry() {
-	return useContext(BoardRegistryContext);
-}
-/**
-* A stable boolean signalling whether a Board widget is currently being
-* dragged. Provided by `BoardProvider` (and therefore by any standalone
-* `Board`, which self-wraps in one). Unlike the full `dragState`, this only
-* flips on drag start/end, so components that only care about "is a drag in
-* progress" (e.g. `Tabs` spring-loading a tab on hover) can subscribe without
-* re-rendering on every pointer move. Defaults to `false` outside any Board.
-*/
-const BoardDragActiveContext = createContext(false);
-function useBoardDragActive() {
-	return useContext(BoardDragActiveContext);
-}
-const BoardMetricsContext = createContext(null);
-function useBoardMetrics() {
-	return useContext(BoardMetricsContext);
-}
-const BoardHostContext = createContext(null);
-function useBoardHost() {
-	return useContext(BoardHostContext);
-}
-
-//#endregion
-export { BoardDragActiveContext, BoardHostContext, BoardMetricsContext, BoardRegistryContext, useBoardDragActive, useBoardHost, useBoardMetrics, useBoardRegistry };
-//# sourceMappingURL=board-context.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"board-context.js","names":[],"sources":["../../../../src/components/layout/Board/board-context.tsx"],"sourcesContent":["import { createContext, MutableRefObject, useContext } from 'react';\n\nimport type { BoardWidgetStore } from './board-store';\nimport type {\n  Compactor,\n  LayoutConstraint,\n  LayoutItem,\n  PositionParams,\n} from './grid-core';\n\n/** A rectangle in viewport (client) coordinates. */\nexport interface ViewportRect {\n  left: number;\n  top: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Everything the cross-board registry needs to read from / write to a single\n * board. Methods read live refs so a single stable entry can be registered once\n * per board and stay current across renders.\n */\nexport interface BoardEntry {\n  id: string;\n  /** Viewport rect of the content area where widgets are positioned. */\n  getContentRect: () => DOMRect | null;\n  /** The DOM node of the content area (used to detect nested-in-drag boards). */\n  getContentNode: () => HTMLElement | null;\n  getPositionParams: () => PositionParams;\n  getConstraints: () => LayoutConstraint[];\n  getCompactor: () => Compactor;\n  getMaxRows: () => number;\n  getContainerHeight: () => number;\n  getLayout: () => LayoutItem[];\n  /** Update the board layout. `commit` fires `onLayoutChange`. */\n  applyLayout: (layout: LayoutItem[], commit: boolean) => void;\n  setPlaceholder: (item: LayoutItem | null) => void;\n  isDroppable: () => boolean;\n}\n\n/** Emitted when a widget is dropped from one board into another. */\nexport interface WidgetTransferInfo {\n  widgetId: string;\n  fromBoardId: string;\n  toBoardId: string;\n  item: LayoutItem;\n}\n\n/** Live drag state, shared across boards for overlay + placeholders. */\nexport interface BoardDragState {\n  sourceBoardId: string;\n  /** Board currently owning the dragged item (changes as it crosses boards). */\n  currentBoardId: string;\n  itemId: string;\n  /** Snapshot of the dragged item (grid units; w/h preserved across boards). */\n  item: LayoutItem;\n  /** Dragged widget rect in viewport coordinates (follows the pointer). */\n  rect: ViewportRect;\n  pointerType: string;\n}\n\nexport interface BoardRegistryContextValue {\n  store: BoardWidgetStore;\n  overlayRef: MutableRefObject<HTMLDivElement | null>;\n  registerBoard: (entry: BoardEntry) => () => void;\n  onDragStart: (\n    boardId: string,\n    itemId: string,\n    rect: ViewportRect,\n    pointerType: string,\n    /** The dragged widget's host node, used to exclude boards nested inside it. */\n    widgetNode: HTMLElement | null,\n  ) => void;\n  onDragMove: (deltaX: number, deltaY: number, pointerType: string) => void;\n  onDragEnd: () => void;\n  dragState: BoardDragState | null;\n}\n\nexport const BoardRegistryContext =\n  createContext<BoardRegistryContextValue | null>(null);\n\nexport function useBoardRegistry(): BoardRegistryContextValue | null {\n  return useContext(BoardRegistryContext);\n}\n\n/**\n * A stable boolean signalling whether a Board widget is currently being\n * dragged. Provided by `BoardProvider` (and therefore by any standalone\n * `Board`, which self-wraps in one). Unlike the full `dragState`, this only\n * flips on drag start/end, so components that only care about \"is a drag in\n * progress\" (e.g. `Tabs` spring-loading a tab on hover) can subscribe without\n * re-rendering on every pointer move. Defaults to `false` outside any Board.\n */\nexport const BoardDragActiveContext = createContext<boolean>(false);\n\nexport function useBoardDragActive(): boolean {\n  return useContext(BoardDragActiveContext);\n}\n\n/**\n * The resolved grid metrics a `Board` exposes to any boards nested inside its\n * widgets. A nested board with `isAligned` reads these to inherit the parent's\n * column pitch (column width + horizontal margin) and target row height, so its\n * cells line up with the surrounding layout instead of stretching.\n */\nexport interface BoardMetrics {\n  /** Resolved pixel width of one parent column. */\n  colWidth: number;\n  /** Resolved parent row height in pixels (the alignment target). */\n  rowHeight: number;\n  /** Parent [horizontal, vertical] margin between widgets in pixels. */\n  margin: readonly [number, number];\n  /** Parent [horizontal, vertical] container padding in pixels. */\n  containerPadding: readonly [number, number];\n}\n\nexport const BoardMetricsContext = createContext<BoardMetrics | null>(null);\n\nexport function useBoardMetrics(): BoardMetrics | null {\n  return useContext(BoardMetricsContext);\n}\n\n/**\n * Information a `WidgetHost` exposes to the content it renders (including a\n * nested `Board`). Lets a nested board know whether its host widget auto-sizes\n * its height and, if so, ask the host to grow to fit the board's natural size.\n */\nexport interface BoardHost {\n  /** Whether the host widget grows its height to fit its content. */\n  isAutoHeight: boolean;\n  /**\n   * Ask the host widget to grow so it provides `px` more content height. Only\n   * ever increases the host's height. No-op when the host does not auto-size.\n   */\n  requestHeightDeficit: (px: number) => void;\n}\n\nexport const BoardHostContext = createContext<BoardHost | null>(null);\n\nexport function useBoardHost(): BoardHost | null {\n  return useContext(BoardHostContext);\n}\n"],"mappings":";;;;AA+EA,MAAa,uBACX,cAAgD,KAAK;AAEvD,SAAgB,mBAAqD;AACnE,QAAO,WAAW,qBAAqB;;;;;;;;;;AAWzC,MAAa,yBAAyB,cAAuB,MAAM;AAEnE,SAAgB,qBAA8B;AAC5C,QAAO,WAAW,uBAAuB;;AAoB3C,MAAa,sBAAsB,cAAmC,KAAK;AAE3E,SAAgB,kBAAuC;AACrD,QAAO,WAAW,oBAAoB;;AAkBxC,MAAa,mBAAmB,cAAgC,KAAK;AAErE,SAAgB,eAAiC;AAC/C,QAAO,WAAW,iBAAiB"}

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

@@ -1,3 +0,0 @@
-
-import { Styles } from "@tenphi/tasty";
-import { ReactNode } from "react";

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

@@ -1,49 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c26fe9d | Cube Dev Team */
-//#region src/components/layout/Board/board-store.ts
-/**
-* A tiny external store mapping widget id -> registration.
-*
-* Boards read from it via `useSyncExternalStore`, so a change to any widget's
-* content or config re-renders the hosting board without prop drilling through
-* the (possibly cross-board) tree.
-*/
-var BoardWidgetStore = class {
-	map = /* @__PURE__ */ new Map();
-	owners = /* @__PURE__ */ new Map();
-	listeners = /* @__PURE__ */ new Set();
-	version = 0;
-	register(reg, owner) {
-		const prev = this.map.get(reg.id);
-		this.map.set(reg.id, reg);
-		this.owners.set(reg.id, owner);
-		if (!prev || prev.content !== reg.content || prev.isDraggable !== reg.isDraggable || prev.isResizable !== reg.isResizable || prev.resizeHandles !== reg.resizeHandles || prev.constraints !== reg.constraints || prev.qa !== reg.qa || prev.styles !== reg.styles || prev.isAutoHeight !== reg.isAutoHeight || prev.dragCancel !== reg.dragCancel || prev.dragHandle !== reg.dragHandle) {
-			this.version++;
-			this.emit();
-		}
-	}
-	unregister(id, owner) {
-		if (this.owners.get(id) !== owner) return;
-		this.owners.delete(id);
-		if (this.map.delete(id)) {
-			this.version++;
-			this.emit();
-		}
-	}
-	get(id) {
-		return this.map.get(id);
-	}
-	getVersion = () => this.version;
-	subscribe = (listener) => {
-		this.listeners.add(listener);
-		return () => {
-			this.listeners.delete(listener);
-		};
-	};
-	emit() {
-		this.listeners.forEach((listener) => listener());
-	}
-};
-
-//#endregion
-export { BoardWidgetStore };
-//# sourceMappingURL=board-store.js.map

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

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

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

@@ -1,90 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c26fe9d | Cube Dev Team */
-//#region src/components/layout/Board/grid-core/calculate.ts
-/** Calculate the width of a single grid column in pixels. */
-function calcGridColWidth(positionParams) {
-	const { margin, containerPadding, containerWidth, cols } = positionParams;
-	return (containerWidth - margin[0] * (cols - 1) - containerPadding[0] * 2) / cols;
-}
-/**
-* Calculate the pixel size for a grid unit dimension (width or height).
-*/
-function calcGridItemWHPx(gridUnits, colOrRowSize, marginPx) {
-	if (!Number.isFinite(gridUnits)) return gridUnits;
-	return Math.round(colOrRowSize * gridUnits + Math.max(0, gridUnits - 1) * marginPx);
-}
-/**
-* Calculate pixel position for a grid item. Returns left, top, width, height.
-*/
-function calcGridItemPosition(positionParams, x, y, w, h, dragPosition, resizePosition) {
-	const { margin, containerPadding, rowHeight } = positionParams;
-	const colWidth = calcGridColWidth(positionParams);
-	let width;
-	let height;
-	let top;
-	let left;
-	if (resizePosition) {
-		width = Math.round(resizePosition.width);
-		height = Math.round(resizePosition.height);
-	} else {
-		width = calcGridItemWHPx(w, colWidth, margin[0]);
-		height = calcGridItemWHPx(h, rowHeight, margin[1]);
-	}
-	if (dragPosition) {
-		top = Math.round(dragPosition.top);
-		left = Math.round(dragPosition.left);
-	} else if (resizePosition) {
-		top = Math.round(resizePosition.top);
-		left = Math.round(resizePosition.left);
-	} else {
-		top = Math.round((rowHeight + margin[1]) * y + containerPadding[1]);
-		left = Math.round((colWidth + margin[0]) * x + containerPadding[0]);
-	}
-	if (!dragPosition && !resizePosition) {
-		if (Number.isFinite(w)) {
-			const actualMarginRight = Math.round((colWidth + margin[0]) * (x + w) + containerPadding[0]) - left - width;
-			if (actualMarginRight !== margin[0]) width += actualMarginRight - margin[0];
-		}
-		if (Number.isFinite(h)) {
-			const actualMarginBottom = Math.round((rowHeight + margin[1]) * (y + h) + containerPadding[1]) - top - height;
-			if (actualMarginBottom !== margin[1]) height += actualMarginBottom - margin[1];
-		}
-	}
-	return {
-		top,
-		left,
-		width,
-		height
-	};
-}
-/** Translate pixel coordinates to grid units without clamping. */
-function calcXYRaw(positionParams, top, left) {
-	const { margin, containerPadding, rowHeight } = positionParams;
-	const colWidth = calcGridColWidth(positionParams);
-	return {
-		x: Math.round((left - containerPadding[0]) / (colWidth + margin[0])),
-		y: Math.round((top - containerPadding[1]) / (rowHeight + margin[1]))
-	};
-}
-/** Calculate grid units from pixel dimensions (clamped by handle direction). */
-function calcWH(positionParams, width, height, x, y, handle) {
-	const { margin, maxRows, cols, rowHeight } = positionParams;
-	const colWidth = calcGridColWidth(positionParams);
-	const w = Math.round((width + margin[0]) / (colWidth + margin[0]));
-	const h = Math.round((height + margin[1]) / (rowHeight + margin[1]));
-	let _w = clamp(w, 0, cols - x);
-	let _h = clamp(h, 0, maxRows - y);
-	if (handle === "sw" || handle === "w" || handle === "nw") _w = clamp(w, 0, cols);
-	if (handle === "nw" || handle === "n" || handle === "ne") _h = clamp(h, 0, maxRows);
-	return {
-		w: _w,
-		h: _h
-	};
-}
-/** Clamp a number between bounds. */
-function clamp(num, lowerBound, upperBound) {
-	return Math.max(Math.min(num, upperBound), lowerBound);
-}
-
-//#endregion
-export { calcGridColWidth, calcGridItemPosition, calcWH, calcXYRaw, clamp };
-//# sourceMappingURL=calculate.js.map

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

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

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

@@ -1,35 +0,0 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-c26fe9d | 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":[],"sources":["../../../../../src/components/layout/Board/grid-core/collision.ts"],"sourcesContent":["/**\n * Collision detection utilities for grid layouts.\n *\n * Vendored from react-grid-layout v2 (`src/core/collision.ts`).\n * See ./NOTICE.md for attribution and license.\n */\n\nimport type { Layout, LayoutItem } from './types';\n\n/**\n * Check if two layout items collide (overlap).\n *\n * Two items collide if their bounding boxes overlap and they are not the same\n * item.\n */\nexport function collides(l1: LayoutItem, l2: LayoutItem): boolean {\n  // Same element - can't collide with itself\n  if (l1.i === l2.i) return false;\n\n  // Check if bounding boxes don't overlap (any gap means no collision)\n  if (l1.x + l1.w <= l2.x) return false; // l1 is completely left of l2\n  if (l1.x >= l2.x + l2.w) return false; // l1 is completely right of l2\n  if (l1.y + l1.h <= l2.y) return false; // l1 is completely above l2\n  if (l1.y >= l2.y + l2.h) return false; // l1 is completely below l2\n\n  // Bounding boxes overlap\n  return true;\n}\n\n/**\n * Find the first item in the layout that collides with the given item.\n */\nexport function getFirstCollision(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem | undefined {\n  for (let i = 0; i < layout.length; i++) {\n    const item = layout[i];\n    if (item !== undefined && collides(item, layoutItem)) {\n      return item;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Find all items in the layout that collide with the given item.\n */\nexport function getAllCollisions(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem[] {\n  return layout.filter((l): l is LayoutItem => collides(l, layoutItem));\n}\n"],"mappings":";;;;;;;;AAeA,SAAgB,SAAS,IAAgB,IAAyB;AAEhE,KAAI,GAAG,MAAM,GAAG,EAAG,QAAO;AAG1B,KAAI,GAAG,IAAI,GAAG,KAAK,GAAG,EAAG,QAAO;AAChC,KAAI,GAAG,KAAK,GAAG,IAAI,GAAG,EAAG,QAAO;AAChC,KAAI,GAAG,IAAI,GAAG,KAAK,GAAG,EAAG,QAAO;AAChC,KAAI,GAAG,KAAK,GAAG,IAAI,GAAG,EAAG,QAAO;AAGhC,QAAO;;;;;AAMT,SAAgB,kBACd,QACA,YACwB;AACxB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,OAAO,OAAO;AACpB,MAAI,SAAS,UAAa,SAAS,MAAM,WAAW,CAClD,QAAO;;;;;;AASb,SAAgB,iBACd,QACA,YACc;AACd,QAAO,OAAO,QAAQ,MAAuB,SAAS,GAAG,WAAW,CAAC"}

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-c26fe9d | 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 { 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":[],"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