@sguisse/react-grid-layout 2.2.3-sguisse.3

package/dist/react.d.ts

@@ -0,0 +1,214 @@
+import React__default, { ReactElement, CSSProperties, RefObject } from 'react';
+import { p as PositionStrategy, D as DroppingPosition, R as ResizeHandleAxis, f as LayoutConstraint, d as LayoutItem, L as Layout, G as GridDragEvent, c as GridResizeEvent, b as Compactor, a as Breakpoints, B as Breakpoint, e as ResponsiveLayouts } from './types-Dbg8jAWj.js';
+export { C as CompactType, E as EventCallback, P as Position } from './types-Dbg8jAWj.js';
+export { G as GridLayout, a as GridLayoutProps, R as ResponsiveGridLayout, b as ResponsiveGridLayoutProps } from './ResponsiveGridLayout-B_6TXsWM.js';
+export { b as bottom, c as cloneLayout, a as cloneLayoutItem, g as getCompactor, d as getLayoutItem, h as horizontalCompactor, n as noCompactor, s as setTopLeft, e as setTransform, f as verticalCompactor } from './position-BeP60S5h.js';
+export { c as calcGridItemPosition, a as calcWH, b as calcXY } from './calculate-K0IBpu53.js';
+
+/**
+ * GridItem component
+ *
+ * Workspace migration version: removes direct react-draggable/react-resizable
+ * coupling and preserves the existing grid math/callback contracts with native
+ * pointer-driven drag and resize interactions.
+ */
+
+type GridItemCallback<Data extends GridDragEvent | GridResizeEvent> = (i: string, w: number, h: number, data: Data) => void;
+type ResizeHandle = ReactElement | ((resizeHandleAxis: ResizeHandleAxis, ref: React__default.Ref<HTMLElement>) => ReactElement);
+interface GridItemProps {
+    children: ReactElement;
+    cols: number;
+    containerWidth: number;
+    margin: readonly [number, number];
+    containerPadding: readonly [number, number];
+    rowHeight: number;
+    maxRows: number;
+    isDraggable: boolean;
+    isResizable: boolean;
+    isBounded: boolean;
+    static?: boolean;
+    useCSSTransforms?: boolean;
+    usePercentages?: boolean;
+    transformScale?: number;
+    positionStrategy?: PositionStrategy;
+    dragThreshold?: number;
+    droppingPosition?: DroppingPosition;
+    enableSortable?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    handle?: string;
+    cancel?: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    minW?: number;
+    maxW?: number;
+    minH?: number;
+    maxH?: number;
+    i: string;
+    resizeHandles?: ResizeHandleAxis[];
+    resizeHandle?: ResizeHandle;
+    constraints?: LayoutConstraint[];
+    layoutItem?: LayoutItem;
+    layout?: Layout;
+    onDragStart?: GridItemCallback<GridDragEvent>;
+    onDrag?: GridItemCallback<GridDragEvent>;
+    onDragStop?: GridItemCallback<GridDragEvent>;
+    onResizeStart?: GridItemCallback<GridResizeEvent>;
+    onResize?: GridItemCallback<GridResizeEvent>;
+    onResizeStop?: GridItemCallback<GridResizeEvent>;
+    onResizeCancel?: (itemId: string) => void;
+    /**
+     * When true, this item is currently the dnd-kit drag source (tracked by our
+     * own React state via dragOverlayId). We use this — not dnd-kit's own
+     * `isSortableDragSource` — to apply `visibility:hidden`, because dnd-kit's
+     * reset is asynchronous and may lag behind our state update, leaving the
+     * element invisible and un-clickable after the drag completes.
+     */
+    isDndKitDragSource?: boolean;
+}
+declare function GridItem(props: GridItemProps): ReactElement;
+
+/**
+ * useContainerWidth hook
+ *
+ * Observes container width using ResizeObserver and provides
+ * reactive width updates for responsive layouts.
+ */
+
+interface UseContainerWidthOptions {
+    /**
+     * If true, delays initial render until width is measured.
+     * Useful for SSR or when you need accurate initial measurements.
+     */
+    measureBeforeMount?: boolean;
+    /**
+     * Initial width to use before measurement.
+     * Defaults to 1280.
+     */
+    initialWidth?: number;
+}
+interface UseContainerWidthResult {
+    /**
+     * Current container width in pixels.
+     */
+    width: number;
+    /**
+     * Whether the container has been measured at least once.
+     */
+    mounted: boolean;
+    /**
+     * Ref to attach to the container element.
+     */
+    containerRef: RefObject<HTMLDivElement | null>;
+    /**
+     * Manually trigger a width measurement.
+     * Useful when the container size might change without a resize event.
+     */
+    measureWidth: () => void;
+}
+/**
+ * Hook to observe and track container width.
+ *
+ * Replaces the WidthProvider HOC with a more composable approach.
+ *
+ * @example
+ * ```tsx
+ * function MyGrid() {
+ *   const { width, containerRef, mounted } = useContainerWidth();
+ *
+ *   return (
+ *     <div ref={containerRef}>
+ *       {mounted && <GridLayout width={width} {...props} />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */ declare function useContainerWidth(options?: UseContainerWidthOptions): UseContainerWidthResult;
+
+/**
+ * useGridLayout hook
+ *
+ * Core hook for managing grid layout state, including drag, resize, and drop operations.
+ * This extracts the state management logic from ReactGridLayout into a reusable hook.
+ */
+
+interface DragState {
+    activeDrag: LayoutItem | null;
+    oldDragItem: LayoutItem | null;
+    oldLayout: Layout | null;
+}
+interface ResizeState {
+    resizing: boolean;
+    oldResizeItem: LayoutItem | null;
+    oldLayout: Layout | null;
+}
+interface DropState {
+    droppingDOMNode: React.ReactElement | null;
+    droppingPosition: DroppingPosition | null;
+}
+interface UseGridLayoutOptions {
+    layout: Layout;
+    cols: number;
+    preventCollision?: boolean;
+    onLayoutChange?: (layout: Layout) => void;
+    compactor?: Compactor;
+    droppingItemId?: string;
+}
+interface UseGridLayoutResult {
+    layout: Layout;
+    setLayout: (layout: Layout) => void;
+    dragState: DragState;
+    resizeState: ResizeState;
+    dropState: DropState;
+    onDragStart: (itemId: string, x: number, y: number) => LayoutItem | null;
+    onDrag: (itemId: string, x: number, y: number) => void;
+    onDragStop: (itemId: string, x: number, y: number) => void;
+    cancelDrag: () => void;
+    onResizeStart: (itemId: string) => LayoutItem | null;
+    onResize: (itemId: string, w: number, h: number, x?: number, y?: number) => void;
+    onResizeStop: (itemId: string, w: number, h: number, x?: number, y?: number) => void;
+    cancelResize: () => void;
+    onDropDragOver: (droppingItem: LayoutItem, position: DroppingPosition) => void;
+    onDropDragLeave: () => void;
+    onDrop: (droppingItem: LayoutItem) => void;
+    containerHeight: number;
+    isInteracting: boolean;
+    compactor: Compactor;
+}
+declare function useGridLayout(options: UseGridLayoutOptions): UseGridLayoutResult;
+
+/**
+ * useResponsiveLayout hook
+ *
+ * Manages responsive breakpoints and layout generation for different screen sizes.
+ * Extracts state management from ResponsiveReactGridLayout into a reusable hook.
+ */
+
+type DefaultBreakpoints = "lg" | "md" | "sm" | "xs" | "xxs";
+declare const DEFAULT_BREAKPOINTS: Breakpoints<DefaultBreakpoints>;
+declare const DEFAULT_COLS: Breakpoints<DefaultBreakpoints>;
+interface UseResponsiveLayoutOptions<B extends Breakpoint = DefaultBreakpoints> {
+    width: number;
+    breakpoint?: B;
+    breakpoints?: Breakpoints<B>;
+    cols?: Breakpoints<B>;
+    layouts?: ResponsiveLayouts<B>;
+    compactor?: Compactor;
+    onBreakpointChange?: (newBreakpoint: B, cols: number) => void;
+    onLayoutChange?: (layout: Layout, layouts: ResponsiveLayouts<B>) => void;
+    onWidthChange?: (width: number, margin: readonly [number, number], cols: number, containerPadding: readonly [number, number] | null) => void;
+}
+interface UseResponsiveLayoutResult<B extends Breakpoint = DefaultBreakpoints> {
+    layout: Layout;
+    layouts: ResponsiveLayouts<B>;
+    breakpoint: B;
+    cols: number;
+    setLayoutForBreakpoint: (breakpoint: B, layout: Layout) => void;
+    setLayouts: (layouts: ResponsiveLayouts<B>) => void;
+    sortedBreakpoints: B[];
+}
+declare function useResponsiveLayout<B extends Breakpoint = DefaultBreakpoints>(options: UseResponsiveLayoutOptions<B>): UseResponsiveLayoutResult<B>;
+
+export { Breakpoint, Breakpoints, Compactor, DEFAULT_BREAKPOINTS, DEFAULT_COLS, type DefaultBreakpoints, type DragState, type DropState, DroppingPosition, GridDragEvent, GridItem, type GridItemCallback, type GridItemProps, GridResizeEvent, Layout, LayoutItem, type ResizeHandle, ResizeHandleAxis, type ResizeState, ResponsiveLayouts, type UseContainerWidthOptions, type UseContainerWidthResult, type UseGridLayoutOptions, type UseGridLayoutResult, type UseResponsiveLayoutOptions, type UseResponsiveLayoutResult, useContainerWidth, useGridLayout, useResponsiveLayout };

package/dist/react.js

@@ -0,0 +1,94 @@
+'use strict';
+
+var chunk7BT7XXIT_js = require('./chunk-7BT7XXIT.js');
+require('./chunk-ZJHF4QM5.js');
+var chunkSTBCV65G_js = require('./chunk-STBCV65G.js');
+var chunkLQOPWRJR_js = require('./chunk-LQOPWRJR.js');
+var chunkJ4LTYI7L_js = require('./chunk-J4LTYI7L.js');
+
+
+
+Object.defineProperty(exports, "useContainerWidth", {
+  enumerable: true,
+  get: function () { return chunk7BT7XXIT_js.useContainerWidth; }
+});
+Object.defineProperty(exports, "DEFAULT_BREAKPOINTS", {
+  enumerable: true,
+  get: function () { return chunkSTBCV65G_js.DEFAULT_BREAKPOINTS; }
+});
+Object.defineProperty(exports, "DEFAULT_COLS", {
+  enumerable: true,
+  get: function () { return chunkSTBCV65G_js.DEFAULT_COLS; }
+});
+Object.defineProperty(exports, "GridItem", {
+  enumerable: true,
+  get: function () { return chunkSTBCV65G_js.GridItem; }
+});
+Object.defineProperty(exports, "GridLayout", {
+  enumerable: true,
+  get: function () { return chunkSTBCV65G_js.GridLayout; }
+});
+Object.defineProperty(exports, "ResponsiveGridLayout", {
+  enumerable: true,
+  get: function () { return chunkSTBCV65G_js.ResponsiveGridLayout; }
+});
+Object.defineProperty(exports, "useGridLayout", {
+  enumerable: true,
+  get: function () { return chunkSTBCV65G_js.useGridLayout; }
+});
+Object.defineProperty(exports, "useResponsiveLayout", {
+  enumerable: true,
+  get: function () { return chunkSTBCV65G_js.useResponsiveLayout; }
+});
+Object.defineProperty(exports, "getCompactor", {
+  enumerable: true,
+  get: function () { return chunkLQOPWRJR_js.getCompactor; }
+});
+Object.defineProperty(exports, "horizontalCompactor", {
+  enumerable: true,
+  get: function () { return chunkLQOPWRJR_js.horizontalCompactor; }
+});
+Object.defineProperty(exports, "noCompactor", {
+  enumerable: true,
+  get: function () { return chunkLQOPWRJR_js.noCompactor; }
+});
+Object.defineProperty(exports, "setTopLeft", {
+  enumerable: true,
+  get: function () { return chunkLQOPWRJR_js.setTopLeft; }
+});
+Object.defineProperty(exports, "setTransform", {
+  enumerable: true,
+  get: function () { return chunkLQOPWRJR_js.setTransform; }
+});
+Object.defineProperty(exports, "verticalCompactor", {
+  enumerable: true,
+  get: function () { return chunkLQOPWRJR_js.verticalCompactor; }
+});
+Object.defineProperty(exports, "bottom", {
+  enumerable: true,
+  get: function () { return chunkJ4LTYI7L_js.bottom; }
+});
+Object.defineProperty(exports, "calcGridItemPosition", {
+  enumerable: true,
+  get: function () { return chunkJ4LTYI7L_js.calcGridItemPosition; }
+});
+Object.defineProperty(exports, "calcWH", {
+  enumerable: true,
+  get: function () { return chunkJ4LTYI7L_js.calcWH; }
+});
+Object.defineProperty(exports, "calcXY", {
+  enumerable: true,
+  get: function () { return chunkJ4LTYI7L_js.calcXY; }
+});
+Object.defineProperty(exports, "cloneLayout", {
+  enumerable: true,
+  get: function () { return chunkJ4LTYI7L_js.cloneLayout; }
+});
+Object.defineProperty(exports, "cloneLayoutItem", {
+  enumerable: true,
+  get: function () { return chunkJ4LTYI7L_js.cloneLayoutItem; }
+});
+Object.defineProperty(exports, "getLayoutItem", {
+  enumerable: true,
+  get: function () { return chunkJ4LTYI7L_js.getLayoutItem; }
+});

package/dist/react.mjs

@@ -0,0 +1,5 @@
+export { useContainerWidth } from './chunk-G3PAJYGP.mjs';
+import './chunk-O3KX3VYW.mjs';
+export { DEFAULT_BREAKPOINTS, DEFAULT_COLS, GridItem, GridLayout, ResponsiveGridLayout, useGridLayout, useResponsiveLayout } from './chunk-UZL6BMXQ.mjs';
+export { getCompactor, horizontalCompactor, noCompactor, setTopLeft, setTransform, verticalCompactor } from './chunk-KKV4ZCG4.mjs';
+export { bottom, calcGridItemPosition, calcWH, calcXY, cloneLayout, cloneLayoutItem, getLayoutItem } from './chunk-ITLZ7N2R.mjs';

package/dist/responsive-D4zBXLkH.d.ts

@@ -0,0 +1,145 @@
+import { d as LayoutItem, L as Layout, C as CompactType, B as Breakpoint, e as ResponsiveLayouts, a as Breakpoints, b as Compactor } from './types-Dbg8jAWj.js';
+
+/**
+ * Collision detection utilities for grid layouts.
+ *
+ * These functions determine if and where layout items overlap.
+ */
+
+/**
+ * Check if two layout items collide (overlap).
+ *
+ * Two items collide if their bounding boxes overlap and they are
+ * not the same item.
+ *
+ * @param l1 - First layout item
+ * @param l2 - Second layout item
+ * @returns true if the items collide
+ */
+declare function collides(l1: LayoutItem, l2: LayoutItem): boolean;
+/**
+ * Find the first item in the layout that collides with the given item.
+ *
+ * @param layout - Layout to search
+ * @param layoutItem - Item to check for collisions
+ * @returns The first colliding item, or undefined if none
+ */
+declare function getFirstCollision(layout: Layout, layoutItem: LayoutItem): LayoutItem | undefined;
+/**
+ * Find all items in the layout that collide with the given item.
+ *
+ * @param layout - Layout to search
+ * @param layoutItem - Item to check for collisions
+ * @returns Array of all colliding items (may be empty)
+ */
+declare function getAllCollisions(layout: Layout, layoutItem: LayoutItem): LayoutItem[];
+
+/**
+ * Sorting utilities for grid layouts.
+ *
+ * These functions sort layout items for compaction and iteration.
+ */
+
+/**
+ * Sort layout items based on the compaction type.
+ *
+ * - Vertical compaction: sort by row (y) then column (x)
+ * - Horizontal compaction: sort by column (x) then row (y)
+ * - No compaction (null): return original order
+ *
+ * Does not modify the original layout.
+ *
+ * @param layout - Layout to sort
+ * @param compactType - Type of compaction
+ * @returns Sorted layout
+ */
+declare function sortLayoutItems(layout: Layout, compactType: CompactType): LayoutItem[];
+/**
+ * Sort layout items by row ascending, then column ascending.
+ *
+ * Items are ordered from top-left to bottom-right, row by row.
+ * This is the natural reading order for vertical compaction.
+ *
+ * Does not modify the original layout.
+ *
+ * @param layout - Layout to sort
+ * @returns Sorted array of layout items
+ */
+declare function sortLayoutItemsByRowCol(layout: Layout): LayoutItem[];
+/**
+ * Sort layout items by column ascending, then row ascending.
+ *
+ * Items are ordered from top-left to bottom-right, column by column.
+ * This is the natural order for horizontal compaction.
+ *
+ * Does not modify the original layout.
+ *
+ * @param layout - Layout to sort
+ * @returns Sorted array of layout items
+ */
+declare function sortLayoutItemsByColRow(layout: Layout): LayoutItem[];
+
+/**
+ * Responsive layout utilities.
+ *
+ * Functions for handling responsive breakpoints and layout generation.
+ */
+
+/**
+ * Sort breakpoints by width (ascending).
+ *
+ * Returns an array of breakpoint names sorted from smallest to largest.
+ * E.g., ['xxs', 'xs', 'sm', 'md', 'lg']
+ *
+ * @param breakpoints - Map of breakpoint names to widths
+ * @returns Sorted array of breakpoint names
+ */
+declare function sortBreakpoints<B extends Breakpoint>(breakpoints: Breakpoints<B>): B[];
+/**
+ * Get the active breakpoint for a given width.
+ *
+ * Returns the highest breakpoint that is valid for the width (width > breakpoint).
+ *
+ * @param breakpoints - Map of breakpoint names to widths
+ * @param width - Container width in pixels
+ * @returns Active breakpoint name
+ */
+declare function getBreakpointFromWidth<B extends Breakpoint>(breakpoints: Breakpoints<B>, width: number): B;
+/**
+ * Get the column count for a breakpoint.
+ *
+ * @param breakpoint - Breakpoint name
+ * @param cols - Map of breakpoint names to column counts
+ * @returns Number of columns for the breakpoint
+ * @throws Error if breakpoint is not defined in cols
+ */
+declare function getColsFromBreakpoint<B extends Breakpoint>(breakpoint: B, cols: Breakpoints<B>): number;
+/**
+ * Find or generate a layout for a breakpoint.
+ *
+ * If a layout exists for the breakpoint, returns a clone.
+ * Otherwise, generates a new layout from the nearest larger breakpoint.
+ *
+ * @param layouts - Existing layouts by breakpoint
+ * @param breakpoints - Breakpoint definitions
+ * @param breakpoint - Target breakpoint
+ * @param lastBreakpoint - Previous breakpoint (for fallback)
+ * @param cols - Column count for the target breakpoint
+ * @param compactTypeOrCompactor - Compaction type string (legacy) or Compactor object
+ * @returns Layout for the breakpoint
+ */
+declare function findOrGenerateResponsiveLayout<B extends Breakpoint>(layouts: ResponsiveLayouts<B>, breakpoints: Breakpoints<B>, breakpoint: B, lastBreakpoint: B, cols: number, compactTypeOrCompactor: CompactType | Compactor): Layout;
+type IndentationValue<B extends Breakpoint> = readonly [number, number] | Partial<Record<B, readonly [number, number]>>;
+/**
+ * Get margin or padding value for a breakpoint.
+ *
+ * Supports both fixed values ([x, y]) and breakpoint-specific values
+ * ({ lg: [x, y], md: [x, y], ... }).
+ *
+ * @param value - Fixed value or breakpoint-specific map
+ * @param breakpoint - Current breakpoint
+ * @returns Margin/padding tuple [x, y]
+ */
+declare function getIndentationValue<B extends Breakpoint>(value: IndentationValue<B>, breakpoint: B): readonly [number, number];
+
+export { getBreakpointFromWidth as a, getColsFromBreakpoint as b, collides as c, getFirstCollision as d, sortLayoutItemsByColRow as e, findOrGenerateResponsiveLayout as f, getAllCollisions as g, sortLayoutItemsByRowCol as h, getIndentationValue as i, sortBreakpoints as j, sortLayoutItems as s };

package/dist/responsive-DQi_9rBi.d.mts

@@ -0,0 +1,145 @@
+import { d as LayoutItem, L as Layout, C as CompactType, B as Breakpoint, e as ResponsiveLayouts, a as Breakpoints, b as Compactor } from './types-Dbg8jAWj.mjs';
+
+/**
+ * Collision detection utilities for grid layouts.
+ *
+ * These functions determine if and where layout items overlap.
+ */
+
+/**
+ * Check if two layout items collide (overlap).
+ *
+ * Two items collide if their bounding boxes overlap and they are
+ * not the same item.
+ *
+ * @param l1 - First layout item
+ * @param l2 - Second layout item
+ * @returns true if the items collide
+ */
+declare function collides(l1: LayoutItem, l2: LayoutItem): boolean;
+/**
+ * Find the first item in the layout that collides with the given item.
+ *
+ * @param layout - Layout to search
+ * @param layoutItem - Item to check for collisions
+ * @returns The first colliding item, or undefined if none
+ */
+declare function getFirstCollision(layout: Layout, layoutItem: LayoutItem): LayoutItem | undefined;
+/**
+ * Find all items in the layout that collide with the given item.
+ *
+ * @param layout - Layout to search
+ * @param layoutItem - Item to check for collisions
+ * @returns Array of all colliding items (may be empty)
+ */
+declare function getAllCollisions(layout: Layout, layoutItem: LayoutItem): LayoutItem[];
+
+/**
+ * Sorting utilities for grid layouts.
+ *
+ * These functions sort layout items for compaction and iteration.
+ */
+
+/**
+ * Sort layout items based on the compaction type.
+ *
+ * - Vertical compaction: sort by row (y) then column (x)
+ * - Horizontal compaction: sort by column (x) then row (y)
+ * - No compaction (null): return original order
+ *
+ * Does not modify the original layout.
+ *
+ * @param layout - Layout to sort
+ * @param compactType - Type of compaction
+ * @returns Sorted layout
+ */
+declare function sortLayoutItems(layout: Layout, compactType: CompactType): LayoutItem[];
+/**
+ * Sort layout items by row ascending, then column ascending.
+ *
+ * Items are ordered from top-left to bottom-right, row by row.
+ * This is the natural reading order for vertical compaction.
+ *
+ * Does not modify the original layout.
+ *
+ * @param layout - Layout to sort
+ * @returns Sorted array of layout items
+ */
+declare function sortLayoutItemsByRowCol(layout: Layout): LayoutItem[];
+/**
+ * Sort layout items by column ascending, then row ascending.
+ *
+ * Items are ordered from top-left to bottom-right, column by column.
+ * This is the natural order for horizontal compaction.
+ *
+ * Does not modify the original layout.
+ *
+ * @param layout - Layout to sort
+ * @returns Sorted array of layout items
+ */
+declare function sortLayoutItemsByColRow(layout: Layout): LayoutItem[];
+
+/**
+ * Responsive layout utilities.
+ *
+ * Functions for handling responsive breakpoints and layout generation.
+ */
+
+/**
+ * Sort breakpoints by width (ascending).
+ *
+ * Returns an array of breakpoint names sorted from smallest to largest.
+ * E.g., ['xxs', 'xs', 'sm', 'md', 'lg']
+ *
+ * @param breakpoints - Map of breakpoint names to widths
+ * @returns Sorted array of breakpoint names
+ */
+declare function sortBreakpoints<B extends Breakpoint>(breakpoints: Breakpoints<B>): B[];
+/**
+ * Get the active breakpoint for a given width.
+ *
+ * Returns the highest breakpoint that is valid for the width (width > breakpoint).
+ *
+ * @param breakpoints - Map of breakpoint names to widths
+ * @param width - Container width in pixels
+ * @returns Active breakpoint name
+ */
+declare function getBreakpointFromWidth<B extends Breakpoint>(breakpoints: Breakpoints<B>, width: number): B;
+/**
+ * Get the column count for a breakpoint.
+ *
+ * @param breakpoint - Breakpoint name
+ * @param cols - Map of breakpoint names to column counts
+ * @returns Number of columns for the breakpoint
+ * @throws Error if breakpoint is not defined in cols
+ */
+declare function getColsFromBreakpoint<B extends Breakpoint>(breakpoint: B, cols: Breakpoints<B>): number;
+/**
+ * Find or generate a layout for a breakpoint.
+ *
+ * If a layout exists for the breakpoint, returns a clone.
+ * Otherwise, generates a new layout from the nearest larger breakpoint.
+ *
+ * @param layouts - Existing layouts by breakpoint
+ * @param breakpoints - Breakpoint definitions
+ * @param breakpoint - Target breakpoint
+ * @param lastBreakpoint - Previous breakpoint (for fallback)
+ * @param cols - Column count for the target breakpoint
+ * @param compactTypeOrCompactor - Compaction type string (legacy) or Compactor object
+ * @returns Layout for the breakpoint
+ */
+declare function findOrGenerateResponsiveLayout<B extends Breakpoint>(layouts: ResponsiveLayouts<B>, breakpoints: Breakpoints<B>, breakpoint: B, lastBreakpoint: B, cols: number, compactTypeOrCompactor: CompactType | Compactor): Layout;
+type IndentationValue<B extends Breakpoint> = readonly [number, number] | Partial<Record<B, readonly [number, number]>>;
+/**
+ * Get margin or padding value for a breakpoint.
+ *
+ * Supports both fixed values ([x, y]) and breakpoint-specific values
+ * ({ lg: [x, y], md: [x, y], ... }).
+ *
+ * @param value - Fixed value or breakpoint-specific map
+ * @param breakpoint - Current breakpoint
+ * @returns Margin/padding tuple [x, y]
+ */
+declare function getIndentationValue<B extends Breakpoint>(value: IndentationValue<B>, breakpoint: B): readonly [number, number];
+
+export { getBreakpointFromWidth as a, getColsFromBreakpoint as b, collides as c, getFirstCollision as d, sortLayoutItemsByColRow as e, findOrGenerateResponsiveLayout as f, getAllCollisions as g, sortLayoutItemsByRowCol as h, getIndentationValue as i, sortBreakpoints as j, sortLayoutItems as s };