@snapgridjs/react 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,390 @@
+import { BreakpointCols, BreakpointCols as BreakpointCols$1, Breakpoints, Breakpoints as Breakpoints$1, CompactType, Compactor, Compactor as Compactor$1, GridConfig, GridConfig as GridConfig$1, Layout, Layout as Layout$1, LayoutItem, LayoutItem as LayoutItem$1, PositionParams, ResizeHandleAxis, ResizeHandleAxis as ResizeHandleAxis$1, ResponsiveLayouts, ResponsiveLayouts as ResponsiveLayouts$1, getCompactor, horizontalCompactor, noCompactor, verticalCompactor } from "@snapgridjs/core";
+import { CSSProperties, ReactNode } from "react";
+import { Feedback, KeyboardSensor, PointerSensor } from "@dnd-kit/dom";
+import { useDraggable, useDroppable } from "@dnd-kit/react";
+
+//#region src/types.d.ts
+/**
+ * Drag behaviour configuration (mirrors react-grid-layout v2's `dragConfig`).
+ * The interaction itself is driven by dnd-kit.
+ */
+interface DragConfig {
+  /** Whether items can be dragged. @default true */
+  enabled?: boolean;
+  /** Keep the dragged item within the grid container bounds. @default false */
+  bounded?: boolean;
+  /** CSS selector for a drag handle inside each item. */
+  handle?: string;
+  /** CSS selector for regions that should cancel a drag. */
+  cancel?: string;
+  /** Pixels the pointer must move before a drag starts. @default 3 */
+  threshold?: number;
+  /**
+   * snapgrid extra: snap the dragged tile itself to grid cells while dragging.
+   * When `false` (the default, matching react-grid-layout) the tile follows the
+   * pointer smoothly and only the placeholder snaps.
+   */
+  snapToGrid?: boolean;
+}
+/**
+ * Resize behaviour configuration (mirrors react-grid-layout v2's `resizeConfig`).
+ */
+interface ResizeConfig {
+  /** Whether items can be resized. @default true */
+  enabled?: boolean;
+  /** Which handles to show on each item (item-level `resizeHandles` overrides). @default ['se'] */
+  handles?: ResizeHandleAxis$1[];
+}
+/** Minimal source shape passed to a {@link DropConfig.accept} predicate. */
+interface DragSourceInfo {
+  id: string | number;
+  type?: unknown;
+  data?: unknown;
+}
+/**
+ * Accept arbitrary (non-grid) dnd-kit draggables dropped into the grid. The
+ * external draggable should carry `data.snapGridDrop = { i?, w?, h? }` to control
+ * the inserted item's id/size; otherwise `defaultItem` is used. On drop the grid
+ * fires `onDrop(layout, item, event)` rather than `onLayoutChange`.
+ *
+ * Requires the grid and the external draggable to share one provider
+ * (e.g. both inside a `<SnapGridGroup>`).
+ */
+interface DropConfig {
+  /** Accept external draggables. @default false */
+  enabled?: boolean;
+  /** Default size for a dropped item when the source omits `snapGridDrop`. @default { w: 1, h: 1 } */
+  defaultItem?: {
+    w: number;
+    h: number;
+  };
+  /** Restrict which external sources are accepted. @default accept any non-grid draggable */
+  accept?: (source: DragSourceInfo) => boolean;
+}
+/** The `data.snapGridDrop` payload an external draggable carries to drop into a grid. */
+interface GridDropData {
+  /** Id for the inserted item (a unique one is generated if omitted). */
+  i?: string;
+  /** Width in grid units. */
+  w?: number;
+  /** Height in grid units. */
+  h?: number;
+}
+/**
+ * react-grid-layout-compatible lifecycle callback.
+ * `(layout, oldItem, newItem, placeholder, event, node)`
+ */
+type GridEventCallback = (layout: Layout$1, oldItem: LayoutItem$1 | null, newItem: LayoutItem$1 | null, placeholder: LayoutItem$1 | null, event: Event | null, node: HTMLElement | null) => void;
+//#endregion
+//#region src/SnapGridProvider.d.ts
+interface SnapGridProviderProps {
+  children: ReactNode;
+  /** Container width in pixels (e.g. from {@link useContainerWidth}). */
+  width: number;
+  /** Controlled layout. Never mutated. */
+  layout: Layout$1;
+  /** Called with the next layout after a drag/resize commits (incl. cross-grid add/remove). */
+  onLayoutChange?: (layout: Layout$1) => void;
+  gridConfig?: Partial<GridConfig$1>;
+  dragConfig?: DragConfig;
+  resizeConfig?: ResizeConfig;
+  /** Accept external (non-grid) dnd-kit draggables dropped into this grid. */
+  dropConfig?: DropConfig;
+  compactor?: Compactor$1;
+  /** Grid-level draggable toggle (item-level `isDraggable`/`static` override). @default true */
+  isDraggable?: boolean;
+  /** Grid-level resizable toggle (item-level `isResizable`/`static` override). @default true */
+  isResizable?: boolean;
+  /** Grow container height to fit content. @default true */
+  autoSize?: boolean;
+  /** Stable id for the grid's droppable surface (auto-generated if omitted). */
+  id?: string;
+  onDragStart?: GridEventCallback;
+  onDrag?: GridEventCallback;
+  onDragStop?: GridEventCallback;
+  onResizeStart?: GridEventCallback;
+  onResize?: GridEventCallback;
+  onResizeStop?: GridEventCallback;
+  /** Called when an external draggable is dropped into the grid: the next layout, the new item, and the event. */
+  onDrop?: (layout: Layout$1, item: LayoutItem$1, event: Event | null) => void;
+}
+/**
+ * Headless provider for a grid. Standalone grids get their own isolated dnd-kit
+ * provider; grids inside a {@link SnapGridGroup} share that group's provider and
+ * registry so tiles can be dragged between them. Owns this grid's drag/resize
+ * session; the consumer owns all markup/styling.
+ */
+declare function SnapGridProvider(props: SnapGridProviderProps): React.JSX.Element;
+//#endregion
+//#region src/SnapGridGroup.d.ts
+interface SnapGridGroupProps {
+  children: ReactNode;
+}
+/**
+ * Wrap multiple grids to let tiles be dragged **between** them. Provides one
+ * shared dnd-kit `DragDropProvider` and a registry so each grid can tell which
+ * grid the pointer is over.
+ *
+ * Item ids must be unique across all grids in a group (they share one manager).
+ */
+declare function SnapGridGroup({
+  children
+}: SnapGridGroupProps): React.JSX.Element;
+//#endregion
+//#region src/hooks/useGridContainer.d.ts
+interface GridContainerProps {
+  /** Attach to your container element. */
+  ref: (element: Element | null) => void;
+  /** Positioning style (relative + width + auto-sized height). Spread onto your element. */
+  style: CSSProperties;
+  /** Present while a compatible draggable is over the grid. */
+  "data-drop-target"?: true;
+}
+interface UseGridContainerResult {
+  /** Spread onto your container element. */
+  containerProps: GridContainerProps;
+  /** True while a compatible draggable is over the grid. */
+  isDropTarget: boolean;
+}
+/**
+ * Headless hook for the grid container. Registers the droppable surface (the
+ * seam for cross-grid drops) and returns props (ref + sizing style) to spread
+ * onto your own container element.
+ */
+declare function useGridContainer(): UseGridContainerResult;
+//#endregion
+//#region src/hooks/useGridItem.d.ts
+interface UseGridItemResult {
+  /** Attach to the element that represents this grid item. */
+  ref: (element: Element | null) => void;
+  /** Positioning style to spread onto your element (left/top/size). */
+  style: CSSProperties;
+  /** True while this item is the active drag source. */
+  isDragging: boolean;
+  /** The item's current (possibly reflowed) layout entry. */
+  item: LayoutItem$1 | undefined;
+}
+/**
+ * Headless hook for a single grid item. Returns a ref, a positioning `style`,
+ * and drag state — spread them onto whatever element you render. You own the
+ * tag, className, content, and any cosmetic styling.
+ */
+declare function useGridItem(id: string): UseGridItemResult;
+//#endregion
+//#region src/hooks/useGridPlaceholder.d.ts
+interface GridPlaceholderInfo {
+  /** The layout entry marking where the dragged item will land. */
+  item: LayoutItem$1;
+  /** Positioning style (left/top/size) to spread onto your placeholder element. */
+  style: CSSProperties;
+}
+/**
+ * Headless hook returning where the drag placeholder should be rendered, or
+ * `null` when no drag is in progress. You render the element however you like.
+ */
+declare function useGridPlaceholder(): GridPlaceholderInfo | null;
+//#endregion
+//#region src/hooks/dndShared.d.ts
+/** Marker attribute placed on resize-handle elements. */
+declare const RESIZE_HANDLE_ATTR = "data-snapgrid-resize-handle";
+//#endregion
+//#region src/hooks/useGridResizeHandle.d.ts
+interface UseGridResizeHandleResult {
+  /** Attach to your resize-handle element. */
+  ref: (element: Element | null) => void;
+  /** Spread onto the handle element so item drags ignore pointer-downs on it. */
+  handleProps: {
+    [RESIZE_HANDLE_ATTR]: true;
+  };
+  /** True while this item is actively being resized. */
+  isResizing: boolean;
+}
+/**
+ * Headless hook for a single resize handle. Model a handle as its own draggable;
+ * dragging it resizes the item from the given edge/corner. Position and style
+ * the handle however you like — spread `ref` and `handleProps` onto it.
+ */
+declare function useGridResizeHandle(itemId: string, handle: ResizeHandleAxis$1): UseGridResizeHandleResult;
+//#endregion
+//#region src/hooks/useGridDragOverlay.d.ts
+interface GridDragOverlay$1 {
+  /** The item being dragged from this grid. */
+  item: LayoutItem$1;
+  /** Fixed-position style for the floating preview; render it in a body portal. */
+  style: CSSProperties;
+}
+/**
+ * Headless hook for the floating drag preview. Returns `null` unless this grid
+ * is the source of an in-progress drag. Render the returned `item` with `style`
+ * in a portal at `document.body` so it can float across grids unclipped (see
+ * {@link GridDragOverlay} for the convenience component).
+ */
+declare function useGridDragOverlay(): GridDragOverlay$1 | null;
+//#endregion
+//#region src/hooks/useResponsiveLayout.d.ts
+/** react-grid-layout's default breakpoints (px) and column counts. */
+declare const DEFAULT_BREAKPOINTS: Breakpoints$1;
+declare const DEFAULT_BREAKPOINT_COLS: BreakpointCols$1;
+interface UseResponsiveLayoutOptions {
+  /** Current container width in pixels. */
+  width: number;
+  /** Controlled per-breakpoint layouts. Missing breakpoints are generated from the nearest one. */
+  layouts: ResponsiveLayouts$1;
+  /** Breakpoint → min width (px). @default lg/md/sm/xs/xxs */
+  breakpoints?: Breakpoints$1;
+  /** Breakpoint → column count. @default 12/10/6/4/2 */
+  cols?: BreakpointCols$1;
+  /** Compaction strategy used when generating a missing breakpoint's layout. */
+  compactor?: Compactor$1;
+  /** Called when a layout commits: the active layout and the updated map. */
+  onLayoutChange?: (layout: Layout$1, layouts: ResponsiveLayouts$1) => void;
+  /** Called when the active breakpoint changes. */
+  onBreakpointChange?: (breakpoint: string, cols: number) => void;
+}
+interface UseResponsiveLayoutResult {
+  /** The active breakpoint name. */
+  breakpoint: string;
+  /** Column count for the active breakpoint. */
+  cols: number;
+  /** The resolved layout for the active breakpoint (generated if absent). */
+  layout: Layout$1;
+  /** Pass to the grid's `onLayoutChange`; updates the active breakpoint's layout. */
+  onLayoutChange: (layout: Layout$1) => void;
+}
+/**
+ * Headless responsive layout engine: resolves the active breakpoint and its
+ * column count/layout from the container width, generating a layout for the
+ * active breakpoint from the nearest one when missing.
+ */
+declare function useResponsiveLayout(options: UseResponsiveLayoutOptions): UseResponsiveLayoutResult;
+//#endregion
+//#region src/GridLayout.d.ts
+interface GridLayoutProps extends SnapGridProviderProps {
+  /** Appended to the default `snapgrid` class on the surface. */
+  className?: string;
+  /** Merged over (and able to override) the surface's positioning style. */
+  style?: CSSProperties;
+}
+/**
+ * Drop-in grid component: a controlled, react-grid-layout v2-compatible layout
+ * backed by dnd-kit. A thin shell over {@link SnapGridProvider} and the headless
+ * hooks — children are keyed by their layout item's `i`. For full control over
+ * markup/styling, use the provider + hooks directly.
+ */
+declare function GridLayout(props: GridLayoutProps): React.JSX.Element;
+//#endregion
+//#region src/ResponsiveGridLayout.d.ts
+interface ResponsiveGridLayoutProps {
+  /** Container width in pixels (e.g. from {@link useContainerWidth}). */
+  width: number;
+  /** Controlled per-breakpoint layouts. Children are keyed by item `i`. */
+  layouts: ResponsiveLayouts$1;
+  /** Called when a layout commits: the active layout and the updated map. */
+  onLayoutChange?: (layout: Layout$1, layouts: ResponsiveLayouts$1) => void;
+  /** Called when the active breakpoint changes. */
+  onBreakpointChange?: (breakpoint: string, cols: number) => void;
+  /** Breakpoint → min width (px). @default lg/md/sm/xs/xxs */
+  breakpoints?: Breakpoints$1;
+  /** Breakpoint → column count. @default 12/10/6/4/2 */
+  cols?: BreakpointCols$1;
+  rowHeight?: number;
+  margin?: [number, number];
+  containerPadding?: [number, number] | null;
+  compactor?: Compactor$1;
+  dragConfig?: DragConfig;
+  resizeConfig?: ResizeConfig;
+  isDraggable?: boolean;
+  isResizable?: boolean;
+  autoSize?: boolean;
+  className?: string;
+  style?: CSSProperties;
+  children: ReactNode;
+}
+/**
+ * A responsive grid: switches column count and layout by breakpoint as `width`
+ * changes, generating a breakpoint's layout from the nearest one when absent.
+ * A thin wrapper over {@link useResponsiveLayout} + {@link GridLayout}; mirrors
+ * react-grid-layout v2's `ResponsiveGridLayout`.
+ */
+declare function ResponsiveGridLayout(props: ResponsiveGridLayoutProps): React.JSX.Element;
+//#endregion
+//#region src/GridItem.d.ts
+interface GridItemProps {
+  /** Matches the layout item's `i`. */
+  id: string;
+  children: ReactNode;
+  /** Appended to the default `snapgrid-item` class. */
+  className?: string;
+  /** Merged over (and able to override) the positioning style. */
+  style?: CSSProperties;
+}
+/**
+ * Convenience wrapper over {@link useGridItem}: an absolutely-positioned `<div>`
+ * with stable hooks (`.snapgrid-item`, `data-grid-id`, `data-dragging`) and the
+ * configured resize handles. For full control, use the hooks directly.
+ */
+declare function GridItem({
+  id,
+  children,
+  className,
+  style
+}: GridItemProps): import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/GridPlaceholder.d.ts
+interface GridPlaceholderProps {
+  /** Appended to the default `snapgrid-placeholder` class. */
+  className?: string;
+  /** Merged over (and able to override) the default look. */
+  style?: CSSProperties;
+}
+/**
+ * Convenience placeholder rendered from {@link useGridPlaceholder}. Renders
+ * nothing when no drag is active. For a custom placeholder, call the hook
+ * directly and render your own element with the returned `style`.
+ */
+declare function GridPlaceholder({
+  className,
+  style
+}: GridPlaceholderProps): import("react/jsx-runtime").JSX.Element | null;
+//#endregion
+//#region src/GridDragOverlay.d.ts
+interface GridDragOverlayProps {
+  /** Render the floating preview for the dragged item. */
+  children: (item: LayoutItem$1) => ReactNode;
+  /** Appended to the default `snapgrid-overlay` class on the portal element. */
+  className?: string;
+  /** Merged over the positioning style. */
+  style?: CSSProperties;
+}
+/**
+ * Renders the floating drag preview in a portal at `document.body` — so it
+ * follows the pointer across grids without being clipped by any container.
+ * Renders nothing when this grid isn't the drag source.
+ */
+declare function GridDragOverlay({
+  children,
+  className,
+  style
+}: GridDragOverlayProps): import("react").ReactPortal | null;
+//#endregion
+//#region src/hooks/useContainerWidth.d.ts
+interface UseContainerWidthOptions {
+  /** Width to use until the element has been measured. @default 1280 */
+  initialWidth?: number;
+}
+interface UseContainerWidthResult {
+  /** Measured container width in pixels (or `initialWidth` before mount). */
+  width: number;
+  /** Whether the element has been measured at least once. */
+  mounted: boolean;
+  /** Attach to the element whose width should drive the grid. */
+  containerRef: (element: HTMLElement | null) => void;
+}
+/**
+ * Measure a container's width with a `ResizeObserver`. Replaces react-grid-layout's
+ * `WidthProvider` HOC with a hook, mirroring RGL v2's `useContainerWidth`.
+ */
+declare function useContainerWidth(options?: UseContainerWidthOptions): UseContainerWidthResult;
+//#endregion
+export { type BreakpointCols, type Breakpoints, type CompactType, type Compactor, DEFAULT_BREAKPOINTS, DEFAULT_BREAKPOINT_COLS, type DragConfig, type DragSourceInfo, type DropConfig, Feedback, type GridConfig, type GridContainerProps, GridDragOverlay, type GridDragOverlay$1 as GridDragOverlayInfo, type GridDragOverlayProps, type GridDropData, type GridEventCallback, GridItem, type GridItemProps, GridLayout, type GridLayoutProps, GridPlaceholder, type GridPlaceholderInfo, type GridPlaceholderProps, KeyboardSensor, type Layout, type LayoutItem, PointerSensor, type PositionParams, type ResizeConfig, type ResizeHandleAxis, ResponsiveGridLayout, type ResponsiveGridLayoutProps, type ResponsiveLayouts, SnapGridGroup, type SnapGridGroupProps, SnapGridProvider, type SnapGridProviderProps, type UseContainerWidthOptions, type UseContainerWidthResult, type UseGridContainerResult, type UseGridItemResult, type UseGridResizeHandleResult, type UseResponsiveLayoutOptions, type UseResponsiveLayoutResult, getCompactor, horizontalCompactor, noCompactor, useContainerWidth, useDraggable, useDroppable, useGridContainer, useGridDragOverlay, useGridItem, useGridPlaceholder, useGridResizeHandle, useResponsiveLayout, verticalCompactor };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/SnapGridProvider.tsx","../src/SnapGridGroup.tsx","../src/hooks/useGridContainer.ts","../src/hooks/useGridItem.ts","../src/hooks/useGridPlaceholder.ts","../src/hooks/dndShared.ts","../src/hooks/useGridResizeHandle.ts","../src/hooks/useGridDragOverlay.ts","../src/hooks/useResponsiveLayout.ts","../src/GridLayout.tsx","../src/ResponsiveGridLayout.tsx","../src/GridItem.tsx","../src/GridPlaceholder.tsx","../src/GridDragOverlay.tsx","../src/hooks/useContainerWidth.ts"],"mappings":"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"}