@snapgridjs/dnd 0.4.0

package/dist/index.cjs

@@ -0,0 +1,676 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _snapgridjs_core = require("@snapgridjs/core");
+let _dnd_kit_collision = require("@dnd-kit/collision");
+let _dnd_kit_abstract = require("@dnd-kit/abstract");
+let _dnd_kit_dom = require("@dnd-kit/dom");
+//#region src/controller/GridController.ts
+function sameItem(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.i === b.i && a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+}
+/**
+* Live per-grid drag/resize state as a plain observable: the provider writes
+* (`setSession`/`setKeyboard`/`setCommitted`), hooks subscribe to just their own
+* slice via `useSyncExternalStore`. Value-cached snapshots mean a drag re-renders
+* only the tiles whose slice changed, not the whole subtree (the old
+* context-value model re-rendered every tile every frame).
+*/
+var GridController = class {
+	id;
+	#committed;
+	#session = null;
+	#keyboard = false;
+	#listeners = /* @__PURE__ */ new Set();
+	config = null;
+	#itemCache = /* @__PURE__ */ new Map();
+	#resizeCache = /* @__PURE__ */ new Map();
+	#placeholderCache = null;
+	#renderedMap = null;
+	#renderedMapSource = null;
+	#indexById = /* @__PURE__ */ new Map();
+	#nextIndex = 0;
+	/** The dnd-kit manager this grid is registered with (set by useInstance). */
+	manager;
+	/**
+	* This grid's container element, reported by the host. The engine reads it to
+	* map a pointer to a cell when receiving a tile (its `getBoundingClientRect`).
+	*/
+	element = null;
+	constructor(id, committed = [], manager) {
+		this.id = id;
+		this.#committed = committed;
+		this.manager = manager;
+	}
+	/** The committed (base) layout — the engine's source of truth during a drag. */
+	getCommitted() {
+		return this.#committed;
+	}
+	/** Replace the per-grid config (called by the container host during render). */
+	setConfig(config) {
+		this.config = config;
+	}
+	/**
+	* Re-point this grid's id. The container host syncs it (during render, before
+	* the droppable/group read it) when the controlled `id` prop changes, so the
+	* returned `group`, the droppable id, and the registry key never drift apart.
+	*/
+	setId(id) {
+		this.id = id;
+	}
+	register = () => {};
+	subscribe = (listener) => {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	};
+	#emit() {
+		for (const listener of this.#listeners) listener();
+	}
+	/** The layout currently shown: the drag preview while dragging, else committed. */
+	#rendered() {
+		return this.#session ? this.#session.preview : this.#committed;
+	}
+	#renderedById() {
+		const rendered = this.#rendered();
+		if (this.#renderedMapSource !== rendered) {
+			this.#renderedMap = new Map(rendered.map((it) => [it.i, it]));
+			this.#renderedMapSource = rendered;
+		}
+		return this.#renderedMap;
+	}
+	/**
+	* Sync the committed layout from the controlled `layout` prop. Called during
+	* the provider's render, so it must NOT notify — emitting here would update
+	* subscribed GridItems mid-render (a React "setState while rendering" error).
+	* No notify is needed: a `layout` prop change already re-renders the whole
+	* provider subtree, so every GridItem re-reads its snapshot on that pass.
+	*/
+	setCommitted(layout) {
+		if (this.#committed === layout) return;
+		this.#committed = layout;
+		const present = new Set(layout.map((it) => it.i));
+		for (const id of this.#indexById.keys()) if (!present.has(id)) this.#indexById.delete(id);
+		for (const id of this.#itemCache.keys()) if (!present.has(id)) this.#itemCache.delete(id);
+		for (const id of this.#resizeCache.keys()) if (!present.has(id)) this.#resizeCache.delete(id);
+	}
+	setSession(next) {
+		this.#session = next;
+		this.#emit();
+	}
+	getSession() {
+		return this.#session;
+	}
+	/** Record whether the active drag is keyboard-driven (drives `hidden`). */
+	setKeyboard(value) {
+		if (this.#keyboard === value) return;
+		this.#keyboard = value;
+		this.#emit();
+	}
+	itemSnapshot = (id) => {
+		const item = this.#renderedById().get(id);
+		const isDragging = this.#session?.activeId === id;
+		const hidden = isDragging && this.#session?.kind === "move" && !this.#keyboard;
+		const prev = this.#itemCache.get(id);
+		if (prev && prev.isDragging === isDragging && prev.hidden === hidden && sameItem(prev.item, item)) return prev;
+		const snap = {
+			item,
+			isDragging,
+			hidden
+		};
+		this.#itemCache.set(id, snap);
+		return snap;
+	};
+	placeholderSnapshot = () => {
+		const next = this.#session?.placeholder ?? null;
+		if (sameItem(this.#placeholderCache ?? void 0, next ?? void 0)) return this.#placeholderCache;
+		this.#placeholderCache = next;
+		return next;
+	};
+	resizeSnapshot = (itemId) => {
+		const isResizing = this.#session?.kind === "resize" && this.#session.activeId === itemId;
+		const prev = this.#resizeCache.get(itemId);
+		if (prev && prev.isResizing === isResizing) return prev;
+		const snap = { isResizing };
+		this.#resizeCache.set(itemId, snap);
+		return snap;
+	};
+	renderedSnapshot = () => this.#rendered();
+	/** A stable index for `id` (see {@link GridController.#indexById}). */
+	itemIndex(id) {
+		let i = this.#indexById.get(id);
+		if (i === void 0) {
+			i = this.#nextIndex++;
+			this.#indexById.set(id, i);
+		}
+		return i;
+	}
+};
+//#endregion
+//#region src/controller/registry.ts
+/**
+* Resolves a grid's {@link GridController} by its id, scoped to the dnd-kit
+* manager the grid is registered with. A container registers its controller
+* here (during render, so child items resolve it on their first render); items
+* look it up by their `group` (= the grid id). Replaces the old geometry
+* `GridRegistry` — which grid the pointer is over now comes from the collision
+* target, so the registry's only job is id → controller resolution.
+*
+* Keyed by manager so two apps (or two providers) never collide, and grids in
+* one provider share a map (the cross-grid seam).
+*/
+const byManager = /* @__PURE__ */ new WeakMap();
+const noManager = /* @__PURE__ */ new Map();
+function mapFor(manager) {
+	if (!manager) return noManager;
+	let map = byManager.get(manager);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		byManager.set(manager, map);
+	}
+	return map;
+}
+/** Register a controller under `id` for `manager`. Returns an unregister fn. */
+function registerController(manager, id, controller) {
+	const map = mapFor(manager);
+	map.set(id, controller);
+	return () => {
+		if (map.get(id) === controller) map.delete(id);
+	};
+}
+/** The controller registered under `id` for `manager`, or undefined. */
+function getController(manager, id) {
+	return mapFor(manager).get(id);
+}
+const grabOffsets = /* @__PURE__ */ new WeakMap();
+const noManagerGrab = { current: null };
+function setGrabOffset(manager, offset) {
+	if (!manager) {
+		noManagerGrab.current = offset;
+		return;
+	}
+	if (offset) grabOffsets.set(manager, offset);
+	else grabOffsets.delete(manager);
+}
+function getGrabOffset(manager) {
+	return (manager ? grabOffsets.get(manager) : noManagerGrab.current) ?? {
+		x: 0,
+		y: 0
+	};
+}
+//#endregion
+//#region src/dnd/dragFlow.ts
+/**
+* Pure decision helpers for the drag interaction so the tricky bits — grab-offset
+* cell mapping, the cross-grid drop lifecycle, and external-drop acceptance — are
+* unit-testable without a DOM or dnd-kit.
+*/
+/** Read snapgrid's payload off a dnd-kit drag source. */
+function dragData(event) {
+	return (event.operation.source?.data)?.snapGrid;
+}
+/** Size/id spec for an external (non-grid) draggable the grid may accept, or null. */
+function externalDropSpec(source, dropConfig) {
+	if (!dropConfig?.enabled || !source) return null;
+	const data = source.data;
+	if (data?.snapGrid) return null;
+	if (dropConfig.accept && !dropConfig.accept(source)) return null;
+	const spec = data?.snapGridDrop;
+	return {
+		i: spec?.i,
+		w: spec?.w ?? dropConfig.defaultItem?.w ?? 1,
+		h: spec?.h ?? dropConfig.defaultItem?.h ?? 1
+	};
+}
+/**
+* Map a client-space pointer to a grid cell, accounting for where *within* the
+* dragged tile the pointer grabbed it. Subtracting the grab offset means the
+* tile's top-left (not the cursor) maps to the cell, so a received tile's
+* placeholder aligns with the floating overlay instead of jumping its corner to
+* the cursor. External drops pass `{ x: 0, y: 0 }` (no meaningful grab point).
+*/
+function receiveCell(pointer, gridRect, grabOffset, w, h, pp) {
+	return (0, _snapgridjs_core.calcXY)(pp, pointer.y - grabOffset.y - gridRect.top, pointer.x - grabOffset.x - gridRect.left, w, h);
+}
+/**
+* Map a keyboard event key to a one-cell grid step while a keyboard drag is
+* active, or null for keys snapgrid doesn't own — Enter/Space (drop) and Escape
+* (cancel) fall through to dnd-kit's KeyboardSensor.
+*/
+function arrowStep(key) {
+	switch (key) {
+		case "ArrowLeft": return [-1, 0];
+		case "ArrowRight": return [1, 0];
+		case "ArrowUp": return [0, -1];
+		case "ArrowDown": return [0, 1];
+		default: return null;
+	}
+}
+/** Pure classification of a drag end. See {@link DropAction}. */
+function classifyDrop(s) {
+	if (s.canceled) {
+		if (s.kind === "resize") return "cancel-resize";
+		if (s.ownsItem) return "cancel-move";
+		return "noop";
+	}
+	if (s.kind === "resize") return "commit-resize";
+	if (s.ownsItem && s.hasData) {
+		if (s.dest === s.myId && s.kind === "move") return "commit-in-grid";
+		if (s.dest) return "remove-source";
+		return "revert";
+	}
+	if (s.dest === s.myId && s.kind === "move") return s.hasData ? "commit-dest" : "external-drop";
+	return "noop";
+}
+//#endregion
+//#region src/dnd/entity.ts
+/**
+* The DOM element of a dnd-kit entity (a draggable, droppable, or drag source).
+* dnd-kit's abstract types don't expose `element`, but the DOM layer snapgrid
+* runs on always sets it — this centralizes that one assumption (and the cast)
+* in a single place instead of scattering it across the drag code.
+*/
+function domElement(entity) {
+	return entity?.element ?? null;
+}
+//#endregion
+//#region src/dnd/SnapGridEngine.ts
+const hasWindow = typeof window !== "undefined";
+function dragCtx(ctrl) {
+	const cfg = ctrl.config;
+	return {
+		positionParams: cfg.positionParams,
+		compactor: cfg.compactor,
+		cols: cfg.gridConfig.cols
+	};
+}
+/** Map a client-space pointer to a cell within `ctrl`, via its element rect. */
+function cellFromPointer(ctrl, pointer, item, manager) {
+	const el = ctrl.element;
+	const cfg = ctrl.config;
+	if (!el || !cfg) return null;
+	return receiveCell(pointer, el.getBoundingClientRect(), getGrabOffset(manager), item.w, item.h, cfg.positionParams);
+}
+var SnapGridEngine = class {
+	#manager;
+	#unsub = [];
+	#source = null;
+	#dest = null;
+	#keyboard = false;
+	#dropSpec = null;
+	#dropCounter = 0;
+	#lastTargetId = null;
+	#lastDest = void 0;
+	constructor(manager) {
+		this.#manager = manager;
+		const mon = manager.monitor;
+		this.#unsub.push(mon.addEventListener("dragstart", (event) => {
+			const op = event.operation;
+			const p = op.position.current;
+			this.#start(dragData(event), {
+				x: p.x,
+				y: p.y
+			}, op.source, op.activatorEvent);
+		}), mon.addEventListener("dragmove", (event) => {
+			const op = event.operation;
+			const p = op.position.current;
+			this.#move(dragData(event), {
+				x: p.x,
+				y: p.y
+			}, op.source, op.target?.id ?? null, op.activatorEvent);
+		}), mon.addEventListener("dragend", (event) => {
+			const op = event.operation;
+			this.#end(dragData(event), op.target?.id ?? null, event.nativeEvent ?? null, event.canceled);
+		}));
+		if (hasWindow) window.addEventListener("keydown", this.#onKeyDown, true);
+	}
+	destroy() {
+		for (const u of this.#unsub) u();
+		this.#unsub = [];
+		if (hasWindow) window.removeEventListener("keydown", this.#onKeyDown, true);
+	}
+	#reset() {
+		this.#source = null;
+		this.#dest = null;
+		this.#keyboard = false;
+		this.#dropSpec = null;
+		this.#lastTargetId = null;
+		this.#lastDest = void 0;
+	}
+	/** Resolve the grid under the pointer from the collision target id (cached per drag). */
+	#resolveDest(targetId) {
+		if (targetId == null) return void 0;
+		if (targetId !== this.#lastTargetId) {
+			this.#lastTargetId = targetId;
+			this.#lastDest = getController(this.#manager, String(targetId));
+		}
+		return this.#lastDest;
+	}
+	#setDest(next) {
+		if (this.#dest && this.#dest !== next && this.#dest !== this.#source) this.#dest.setSession(null);
+		this.#dest = next;
+	}
+	#start(data, pointer, source, activatorEvent) {
+		this.#reset();
+		if (!data) return;
+		const owner = getController(this.#manager, data.group);
+		const cfg = owner?.config;
+		if (!owner || !cfg) return;
+		const layout = owner.getCommitted();
+		const item = layout.find((it) => it.i === data.itemId);
+		if (!item) return;
+		if (data.kind === "resize") {
+			const rect = (0, _snapgridjs_core.calcGridItemPosition)(cfg.positionParams, item.x, item.y, item.w, item.h);
+			owner.setSession((0, _snapgridjs_core.beginResize)(layout, {
+				item,
+				rect,
+				pointer
+			}, data.handle));
+			this.#source = owner;
+			owner.setKeyboard(false);
+			cfg.callbacks.onResizeStart?.(layout, item, item, item, activatorEvent, null);
+			return;
+		}
+		const isKeyboard = hasWindow && activatorEvent instanceof KeyboardEvent;
+		this.#keyboard = isKeyboard;
+		owner.setKeyboard(isKeyboard);
+		const rect = (0, _snapgridjs_core.calcGridItemPosition)(cfg.positionParams, item.x, item.y, item.w, item.h);
+		owner.setSession((0, _snapgridjs_core.beginDrag)(layout, {
+			item,
+			left: rect.left,
+			top: rect.top,
+			pointer
+		}));
+		this.#source = owner;
+		const cr = domElement(source)?.getBoundingClientRect();
+		if (cr) setGrabOffset(this.#manager, {
+			x: pointer.x - cr.left,
+			y: pointer.y - cr.top
+		});
+		cfg.callbacks.onDragStart?.(layout, item, item, item, activatorEvent, null);
+	}
+	#move(data, pointer, source, targetId, activatorEvent) {
+		if (this.#keyboard) return;
+		const owner = this.#source;
+		const ownerSession = owner?.getSession();
+		if (owner && ownerSession?.kind === "resize") {
+			const cfg = owner.config;
+			const next = (0, _snapgridjs_core.dragResize)(ownerSession, pointer, dragCtx(owner));
+			owner.setSession(next);
+			cfg.callbacks.onResize?.(next.preview, next.anchor.item, next.placeholder, next.placeholder, activatorEvent, null);
+			return;
+		}
+		const destCtrl = this.#resolveDest(targetId);
+		if (!data) {
+			this.#setDest(destCtrl ? this.#receiveExternalInto(destCtrl, source, pointer) : null);
+			return;
+		}
+		if (data.kind !== "move") return;
+		if (owner && destCtrl === owner) {
+			this.#setDest(null);
+			const cur = owner.getSession();
+			if (!cur) return;
+			const cfg = owner.config;
+			const next = (0, _snapgridjs_core.dragTo)(cur, pointer, dragCtx(owner));
+			owner.setSession(next);
+			cfg.callbacks.onDrag?.(next.preview, next.anchor.item, next.placeholder, next.placeholder, activatorEvent, null);
+			return;
+		}
+		if (owner) {
+			const cur = owner.getSession();
+			if (cur) {
+				const cfg = owner.config;
+				const hidden = (0, _snapgridjs_core.hideActive)(cur);
+				owner.setSession(hidden);
+				cfg.callbacks.onDrag?.(hidden.preview, hidden.anchor.item, null, null, activatorEvent, null);
+			}
+		}
+		this.#setDest(destCtrl && destCtrl !== owner ? this.#receiveInto(destCtrl, data.item, pointer) : null);
+	}
+	/** Build a receive preview for `foreign` in `dest`; returns `dest` on success, else null. */
+	#receiveInto(dest, foreign, pointer) {
+		if (!dest.config) return null;
+		const committed = dest.getCommitted();
+		const cell = cellFromPointer(dest, pointer, foreign, this.#manager) ?? {
+			x: 0,
+			y: 0
+		};
+		dest.setSession((0, _snapgridjs_core.beginReceive)(committed, foreign, cell.x, cell.y, pointer, dragCtx(dest)));
+		return dest;
+	}
+	/** Receive an external (non-grid) draggable into `dest`, synthesizing its item. */
+	#receiveExternalInto(dest, source, pointer) {
+		const spec = this.#externalSpecFor(dest, source);
+		if (!spec) return null;
+		return this.#receiveInto(dest, {
+			i: spec.i,
+			x: 0,
+			y: 0,
+			w: spec.w,
+			h: spec.h
+		}, pointer);
+	}
+	#externalSpecFor(dest, source) {
+		const spec = externalDropSpec(source, dest.config?.dropConfig);
+		if (!spec) return null;
+		if (!this.#dropSpec) {
+			this.#dropCounter += 1;
+			this.#dropSpec = {
+				i: spec.i ?? `${dest.id}-dropped-${this.#dropCounter}`,
+				w: spec.w,
+				h: spec.h
+			};
+		}
+		return this.#dropSpec;
+	}
+	#end(data, targetId, nativeEvent, canceled) {
+		const source = this.#source;
+		const dest = this.#dest;
+		try {
+			if (source) {
+				const cfg = source.config;
+				const cur = source.getSession();
+				const destId = dest ? dest.id : this.#keyboard || targetId != null && String(targetId) === source.id ? source.id : null;
+				const action = classifyDrop({
+					kind: cur?.kind ?? null,
+					canceled,
+					ownsItem: true,
+					hasData: !!data,
+					dest: destId,
+					myId: source.id
+				});
+				switch (action) {
+					case "cancel-resize":
+						cfg.callbacks.onResizeStop?.(source.getCommitted(), cur?.anchor.item ?? null, null, null, nativeEvent, null);
+						break;
+					case "cancel-move":
+						cfg.callbacks.onDragStop?.(source.getCommitted(), cur?.anchor.item ?? null, null, null, nativeEvent, null);
+						break;
+					case "commit-resize":
+						if (cur) {
+							cfg.callbacks.onLayoutChange?.((0, _snapgridjs_core.commitLayout)(cur));
+							cfg.callbacks.onResizeStop?.(cur.preview, cur.anchor.item, cur.placeholder, cur.placeholder, nativeEvent, null);
+						}
+						break;
+					case "commit-in-grid":
+					case "remove-source":
+					case "revert":
+						if (action === "commit-in-grid" && cur) cfg.callbacks.onLayoutChange?.((0, _snapgridjs_core.commitLayout)(cur));
+						else if (action === "remove-source" && data) {
+							const { compactor, cols } = dragCtx(source);
+							cfg.callbacks.onLayoutChange?.((0, _snapgridjs_core.removeItemWithCompactor)(source.getCommitted(), data.itemId, {
+								compactor,
+								cols
+							}));
+						}
+						cfg.callbacks.onDragStop?.(cur?.preview ?? source.getCommitted(), cur?.anchor.item ?? null, cur?.placeholder ?? null, cur?.placeholder ?? null, nativeEvent, null);
+						break;
+				}
+			}
+			if (dest && dest !== source) {
+				const cfg = dest.config;
+				const cur = dest.getSession();
+				const action = classifyDrop({
+					kind: cur?.kind ?? null,
+					canceled,
+					ownsItem: false,
+					hasData: !!data,
+					dest: dest.id,
+					myId: dest.id
+				});
+				if (action === "commit-dest") {
+					if (cur) cfg.callbacks.onLayoutChange?.((0, _snapgridjs_core.commitLayout)(cur));
+				} else if (action === "external-drop" && cur) {
+					const committed = (0, _snapgridjs_core.commitLayout)(cur);
+					const dropped = committed.find((it) => it.i === cur.activeId);
+					if (dropped) cfg.callbacks.onDrop?.(committed, dropped, nativeEvent);
+				}
+			}
+		} finally {
+			setGrabOffset(this.#manager, null);
+			source?.setKeyboard(false);
+			source?.setSession(null);
+			if (dest && dest !== source) dest.setSession(null);
+			this.#reset();
+		}
+	}
+	#onKeyDown = (e) => {
+		if (!this.#keyboard) return;
+		const source = this.#source;
+		const session = source?.getSession();
+		if (!source || !session || session.kind !== "move") return;
+		const step = arrowStep(e.key);
+		if (!step) return;
+		e.preventDefault();
+		e.stopImmediatePropagation();
+		source.setSession((0, _snapgridjs_core.nudge)(session, step[0], step[1], dragCtx(source)));
+	};
+};
+const engines = /* @__PURE__ */ new WeakMap();
+/** Ensure the engine is attached to `manager`; returns a detach (ref-decrement) fn. */
+function attachEngine(manager) {
+	let entry = engines.get(manager);
+	if (!entry) {
+		entry = {
+			engine: new SnapGridEngine(manager),
+			refs: 0
+		};
+		engines.set(manager, entry);
+	}
+	entry.refs += 1;
+	let detached = false;
+	return () => {
+		if (detached) return;
+		detached = true;
+		const e = engines.get(manager);
+		if (!e) return;
+		e.refs -= 1;
+		if (e.refs <= 0) {
+			e.engine.destroy();
+			engines.delete(manager);
+		}
+	};
+}
+//#endregion
+//#region src/dnd/collision.ts
+/**
+* Marker attribute set on every grid container element. Used by {@link gridDepth}
+* to measure how deeply a grid is nested, purely from the DOM.
+*/
+const SNAPGRID_GRID_ATTR = "data-snapgrid-grid";
+const GRID_COLLISION_PRIORITY = 10;
+/**
+* How deeply `el`'s grid is nested: the number of ancestor grid containers above
+* it. A top-level grid is 0; a grid rendered inside another grid's tile is 1; and
+* so on. DOM containment is the ground truth, so this is correct regardless of the
+* React tree shape or how priorities are assigned elsewhere.
+*/
+function gridDepth(el) {
+	let depth = 0;
+	let node = el?.parentElement ?? null;
+	while (node) {
+		if (node.hasAttribute("data-snapgrid-grid")) depth++;
+		node = node.parentElement;
+	}
+	return depth;
+}
+/**
+* Collision detector for grid droppables. Runs dnd-kit's default detector, then —
+* when nested grid rects overlap (the pointer is over both an inner grid and its
+* outer one) — ranks the **innermost** grid highest by boosting priority with the
+* grid's nesting depth. Without this, overlapping grids tie on priority and the
+* winner is arbitrary. For non-nested grids depth is 0, so priority is unchanged.
+*/
+const gridCollisionDetector = (input) => {
+	const collision = (0, _dnd_kit_collision.defaultCollisionDetection)(input);
+	if (!collision) return null;
+	return {
+		...collision,
+		priority: GRID_COLLISION_PRIORITY + gridDepth(domElement(input.droppable))
+	};
+};
+//#endregion
+//#region src/dnd/snapToGrid.ts
+/**
+* Quantizes the dragged item's transform to whole grid cells, so the floating
+* <DragOverlay> clone jumps cell-to-cell in lockstep with the (always-snapped)
+* placeholder instead of tracking the pointer smoothly. Applied on the item
+* draggable; a no-op unless `dragConfig.snapToGrid` is set.
+*/
+var SnapToGrid = class extends _dnd_kit_abstract.Modifier {
+	apply({ transform }) {
+		const opts = this.options;
+		if (!opts?.isEnabled()) return transform;
+		const pp = opts.getPositionParams();
+		const colStep = (0, _snapgridjs_core.calcGridColWidth)(pp) + pp.margin[0];
+		const rowStep = pp.rowHeight + pp.margin[1];
+		if (colStep <= 0 || rowStep <= 0) return transform;
+		return {
+			x: Math.round(transform.x / colStep) * colStep,
+			y: Math.round(transform.y / rowStep) * rowStep
+		};
+	}
+};
+//#endregion
+//#region src/dndShared.ts
+/** Marker attribute placed on resize-handle elements. */
+const RESIZE_HANDLE_ATTR = "data-snapgrid-resize-handle";
+const NO_FEEDBACK = [_dnd_kit_dom.Feedback.configure({ feedback: "none" })];
+/**
+* Whether a pointer-down on `target` should NOT start an item move. Pure and
+* exported for testing. Honors three rules, in order:
+*  - never start a move from a resize handle;
+*  - never start from a region matching `dragConfig.cancel`;
+*  - if `dragConfig.handle` is set, only start from within it.
+*/
+function shouldPreventItemDrag(target, cfg) {
+	if (!(target instanceof Element)) return false;
+	if (target.closest(`[data-snapgrid-resize-handle]`)) return true;
+	if (cfg?.cancel && target.closest(cfg.cancel)) return true;
+	if (cfg?.handle && !target.closest(cfg.handle)) return true;
+	return false;
+}
+/**
+* Sensors for item (move) draggables, built from the drag config: a distance
+* activation threshold (so clicks don't start drags) plus handle/cancel/resize
+* gating, with the keyboard sensor kept for accessibility.
+*/
+function buildItemSensors(threshold, getDragConfig) {
+	return [_dnd_kit_dom.PointerSensor.configure({
+		activationConstraints: () => threshold > 0 ? [new _dnd_kit_dom.PointerActivationConstraints.Distance({ value: threshold })] : void 0,
+		preventActivation: (event) => shouldPreventItemDrag(event.target, getDragConfig())
+	}), _dnd_kit_dom.KeyboardSensor];
+}
+//#endregion
+exports.GridController = GridController;
+exports.NO_FEEDBACK = NO_FEEDBACK;
+exports.RESIZE_HANDLE_ATTR = RESIZE_HANDLE_ATTR;
+exports.SNAPGRID_GRID_ATTR = SNAPGRID_GRID_ATTR;
+exports.SnapToGrid = SnapToGrid;
+exports.attachEngine = attachEngine;
+exports.buildItemSensors = buildItemSensors;
+exports.domElement = domElement;
+exports.getController = getController;
+exports.gridCollisionDetector = gridCollisionDetector;
+exports.registerController = registerController;