vue-grid-layout-headless 4.3.3 → 4.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -5,12 +5,14 @@
5
5
  [![NPM downloads][badge-npm-downloads]][url-npm]
6
6
  [![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
7
7
 
8
- A headless grid: `useGridLayout` returns the placement of items on a grid of cells and the pointer handlers that move, resize, drop and compact them, with no styling. The pure placement functions are also exported from its `/placement` entry.
8
+ A headless grid: `useGridLayout` returns the placement of items on a grid of cells, their tiles and a `startGesture` handler that moves or resizes them, with no styling.
9
+
10
+ Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/vue-grid-layout-headless).
9
11
 
10
12
  ## Table of Contents
11
13
 
12
14
  - 🚀 [Getting Started](#getting-started)
13
- - 📖 [Documentation](#documentation)
15
+ - 🧩 [Key Exports](#key-exports)
14
16
  - ⚖️ [License](#license)
15
17
 
16
18
  ---
@@ -21,9 +23,65 @@ A headless grid: `useGridLayout` returns the placement of items on a grid of cel
21
23
  pnpm i vue-grid-layout-headless
22
24
  ```
23
25
 
24
- ## <a name="documentation">📖 Documentation</a>
26
+ ```vue
27
+ <script setup lang="ts">
28
+ import { CollisionMode, CompactType, useGridLayout } from "vue-grid-layout-headless";
29
+ import { shallowRef, useTemplateRef } from "vue";
30
+
31
+ const root = useTemplateRef<HTMLElement>("root");
32
+ const items = shallowRef([{ h: 2, id: "a", w: 4, x: 0, y: 0 }]);
33
+ const { gridHeight, startGesture, tiles } = useGridLayout(root, () => ({
34
+ collision: CollisionMode.Push,
35
+ columnNumber: 12,
36
+ compactType: CompactType.Vertical,
37
+ dragStartDistance: 4,
38
+ isEditable: true,
39
+ items: items.value,
40
+ rowHeight: 40,
41
+ spacing: { gap: 10, padding: 10 },
42
+ // A release replaces the cells it changed and drops the ids it removed
43
+ onCommit: ({ changes, removed }) => {
44
+ const changedIds = new Set(changes.map(({ id }) => id));
45
+ items.value = [...items.value.filter(({ id }) => !changedIds.has(id) && !removed.includes(id)), ...changes];
46
+ },
47
+ }));
48
+ </script>
49
+
50
+ <template>
51
+ <div ref="root" :style="{ height: `${gridHeight}px`, position: 'relative' }">
52
+ <div
53
+ v-for="{ geometry, item, offset } in tiles"
54
+ :key="item.id"
55
+ :style="{
56
+ height: `${geometry.height}px`,
57
+ left: `${geometry.left}px`,
58
+ position: 'absolute',
59
+ top: `${geometry.top}px`,
60
+ transform: `translate(${offset.x}px, ${offset.y}px)`,
61
+ width: `${geometry.width}px`,
62
+ }"
63
+ @pointerdown="startGesture($event, item)"
64
+ />
65
+ </div>
66
+ </template>
67
+ ```
68
+
69
+ Each tile's `geometry` is the box to draw it in, in pixels from the grid's top left corner, and its `offset` moves a dragged tile so it stays under the pointer.
70
+
71
+ ## <a name="key-exports">🧩 Key Exports</a>
25
72
 
26
- We highly recommend you take a look at the [documentation](https://github.com/Esposter/Esposter/tree/main/openspec/specs/vue-grid-layout-headless) to level up.
73
+ | Export | Kind | Purpose |
74
+ | ------------------- | ---------- | ---------------------------------------------------------------------------------------------------------- |
75
+ | `CollisionMode` | enum | What a dropped item does to the items it lands on: push, swap, or prevent the drop |
76
+ | `CompactType` | enum | The direction a layout compacts in: vertical, horizontal, or none |
77
+ | `GridCommit` | interface | What a release writes back: the cells one gesture changed or added, and the ids it removed |
78
+ | `GridItem` | interface | A cell the grid places, named by the entity it lays out |
79
+ | `GridLayout` | interface | What a grid hands its consumer: the tiles to draw, the drag placeholder, the height and the press handler |
80
+ | `GridLayoutOptions` | interface | What a grid lays out and how its gestures read the pointer, passed to the composable as a getter |
81
+ | `GridTile` | interface | An item as the grid draws it: its box, and the offset a dragged item is drawn at |
82
+ | `ResizeEdge` | enum | The edge or corner a resize pulls |
83
+ | `startExternalDrag` | function | Drags an item from outside every grid, such as a palette entry, and lands it on the grid under the release |
84
+ | `useGridLayout` | composable | Places items on a grid, and previews and commits the moves and resizes a pointer makes of them |
27
85
 
28
86
  ## <a name="license">⚖️ License</a>
29
87
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "vue-grid-layout-headless",
3
- "version": "4.3.3",
3
+ "version": "4.4.0",
4
4
  "description": "A headless grid: the placement of items on a grid of cells, and the pointer gestures that move and resize them, with no styling.",
5
5
  "keywords": [
6
6
  "dashboard",
@@ -31,7 +31,6 @@
31
31
  },
32
32
  "exports": {
33
33
  ".": "./dist/index.js",
34
- "./placement": "./dist/placement.js",
35
34
  "./package.json": "./package.json"
36
35
  },
37
36
  "publishConfig": {
@@ -42,19 +41,19 @@
42
41
  "lint": "eslint .",
43
42
  "lint:fix": "eslint --fix .",
44
43
  "test": "vitest",
45
- "typecheck": "tsc"
44
+ "typecheck": "tsrs --fast"
46
45
  },
47
46
  "dependencies": {
48
- "@esposter/shared": "4.3.3"
47
+ "@esposter/shared": "4.4.0"
49
48
  },
50
49
  "devDependencies": {
51
- "@esposter/configuration": "4.3.3",
50
+ "@esposter/configuration": "4.4.0",
52
51
  "@vue/test-utils": "^2.5.1",
53
52
  "happy-dom": "^21.0.4",
54
- "tsdown": "^0.23.1"
53
+ "tsdown": "0.23.2"
55
54
  },
56
55
  "peerDependencies": {
57
56
  "vue": "^3.5.44"
58
57
  },
59
- "gitHead": "955bbc130ad9b28877fd4ae8efc73a045141ce01"
58
+ "gitHead": "e1a416c4b91da69cc2aa259b50a4d656f204d272"
60
59
  }
@@ -1,50 +0,0 @@
1
- interface GridCell {
2
- h: number;
3
- w: number;
4
- x: number;
5
- y: number;
6
- }
7
- interface GridItem extends GridCell {
8
- id: string;
9
- isAutoHeight?: boolean;
10
- }
11
- declare enum CompactType {
12
- Horizontal = "Horizontal",
13
- None = "None",
14
- Vertical = "Vertical"
15
- }
16
- interface GridSpacing {
17
- gap: number;
18
- padding: number;
19
- }
20
- declare enum ResizeEdge {
21
- East = "East",
22
- North = "North",
23
- NorthEast = "NorthEast",
24
- NorthWest = "NorthWest",
25
- South = "South",
26
- SouthEast = "SouthEast",
27
- SouthWest = "SouthWest",
28
- West = "West"
29
- }
30
- declare enum CollisionMode {
31
- Prevent = "Prevent",
32
- Push = "Push",
33
- Swap = "Swap"
34
- }
35
- interface GridCommit {
36
- changes: GridItem[];
37
- removed: string[];
38
- }
39
- interface GridLayoutOptions<T extends GridItem = GridItem> {
40
- collision: CollisionMode;
41
- columnNumber: number;
42
- compactType: CompactType;
43
- dragStartDistance: number;
44
- isEditable: boolean;
45
- items: T[];
46
- onCommit: (commit: GridCommit) => void;
47
- rowHeight: number;
48
- spacing: GridSpacing;
49
- }
50
- export { GridSpacing as a, GridCell as c, ResizeEdge as i, GridCommit as n, CompactType as o, CollisionMode as r, GridItem as s, GridLayoutOptions as t };
package/dist/index.d.ts DELETED
@@ -1,38 +0,0 @@
1
- import { a as GridSpacing, c as GridCell, i as ResizeEdge, n as GridCommit, o as CompactType, r as CollisionMode, s as GridItem, t as GridLayoutOptions } from "./GridLayoutOptions-D0ot9xMz.js";
2
- import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
3
- interface GridGeometry {
4
- height: number;
5
- left: number;
6
- top: number;
7
- width: number;
8
- }
9
- interface GridPoint {
10
- x: number;
11
- y: number;
12
- }
13
- interface GridTile<T extends GridItem = GridItem> {
14
- geometry: GridGeometry;
15
- isDragged: boolean;
16
- item: T;
17
- offset: GridPoint;
18
- }
19
- interface GridLayout<T extends GridItem = GridItem> {
20
- gridHeight: ComputedRef<number>;
21
- placeholder: ComputedRef<GridGeometry | undefined>;
22
- reportContentHeight: (id: string, contentHeight: number) => void;
23
- startGesture: (event: PointerEvent, item: T, edge?: ResizeEdge) => void;
24
- tiles: ComputedRef<GridTile<T>[]>;
25
- }
26
- export declare const useGridLayout: <T extends GridItem>(root: Readonly<ShallowRef<HTMLElement | null>>, options: MaybeRefOrGetter<GridLayoutOptions<T>>) => GridLayout<T>;
27
- interface GridGesture<T extends GridItem = GridItem> {
28
- cell?: GridItem;
29
- edge?: ResizeEdge;
30
- element: Element;
31
- isStarted: boolean;
32
- offset: GridPoint;
33
- origin: T;
34
- pointerId: number;
35
- start: GridPoint;
36
- }
37
- export declare const startExternalDrag: (event: PointerEvent, item: Pick<GridItem, "h" | "id" | "w">) => void;
38
- export { CollisionMode, CompactType, type GridCell, type GridCommit, type GridGeometry, type GridGesture, type GridItem, type GridLayout, type GridLayoutOptions, type GridPoint, type GridSpacing, type GridTile, ResizeEdge };
package/dist/index.js DELETED
@@ -1,262 +0,0 @@
1
- import { _ as CollisionMode, a as getGestureCell, c as getCellSpan, d as fitLayout, f as correctBounds, g as checkIsColliding, h as checkIsSameCell, i as getLayoutBottom, l as getCellSize, m as CompactType, o as ResizeEdge, p as compactLayout, s as getColumnPitch, t as placeMove, u as getCellPosition } from "./placeMove-BPQPi70h.js";
2
- import { checkIsNestedControl, takeOne } from "@esposter/shared";
3
- import { computed, onMounted, onUnmounted, ref, shallowRef, toValue, watch } from "vue";
4
- // src/services/mountedGrids.ts
5
- const mountedGrids = /* @__PURE__ */ new Map();
6
- // src/services/findGridRoot.ts
7
- const findGridRoot = (element) => {
8
- let current = element;
9
- while (current && !mountedGrids.has(current)) current = current.parentElement;
10
- return current ?? void 0;
11
- };
12
- // src/services/findGridAt.ts
13
- const findGridAt = (point, element) => {
14
- const hit = window.document.elementsFromPoint(point.x, point.y).find((candidate) => !element.contains(candidate));
15
- const root = findGridRoot(hit ?? null);
16
- return root ? mountedGrids.get(root) : void 0;
17
- };
18
- // src/composables/useGridLayout.ts
19
- const useGridLayout = (root, options) => {
20
- const getOptions = () => toValue(options);
21
- const width = ref(0);
22
- const gesture = shallowRef();
23
- const preview = shallowRef();
24
- const columnPitch = computed(() => getColumnPitch(width.value, getOptions().columnNumber, getOptions().spacing));
25
- const rowPitch = computed(() => getOptions().rowHeight + getOptions().spacing.gap);
26
- const layout = computed(() => fitLayout(getOptions().items, getOptions().columnNumber, getOptions().compactType));
27
- const savedItemMap = computed(() => new Map(getOptions().items.map((item) => [item.id, item])));
28
- const previewItemMap = computed(() => new Map((preview.value ?? []).map((item) => [item.id, item])));
29
- const draggedGesture = computed(() => gesture.value?.isStarted && !gesture.value.edge ? gesture.value : void 0);
30
- const getGeometry = (cell) => {
31
- const { gap, padding } = getOptions().spacing;
32
- return {
33
- height: getCellSize(cell.h, rowPitch.value, gap),
34
- left: getCellPosition(cell.x, columnPitch.value, padding),
35
- top: getCellPosition(cell.y, rowPitch.value, padding),
36
- width: getCellSize(cell.w, columnPitch.value, gap)
37
- };
38
- };
39
- const tiles = computed(() => {
40
- if (width.value === 0) return [];
41
- return layout.value.map((item) => {
42
- const dragged = draggedGesture.value?.origin.id === item.id ? draggedGesture.value : void 0;
43
- const cell = dragged ? item : previewItemMap.value.get(item.id) ?? item;
44
- return {
45
- geometry: getGeometry(cell),
46
- isDragged: dragged !== void 0,
47
- item,
48
- offset: dragged?.offset ?? {
49
- x: 0,
50
- y: 0
51
- }
52
- };
53
- });
54
- });
55
- const placeholder = computed(() => {
56
- if (!gesture.value?.isStarted) return void 0;
57
- const target = previewItemMap.value.get(gesture.value.origin.id);
58
- return target ? getGeometry(target) : void 0;
59
- });
60
- const gridHeight = computed(() => {
61
- const { gap, padding } = getOptions().spacing;
62
- const layoutBottom = getLayoutBottom(preview.value ?? layout.value);
63
- return Math.max(0, getCellSize(layoutBottom, rowPitch.value, gap)) + 2 * padding;
64
- });
65
- const resetGesture = () => {
66
- gesture.value = void 0;
67
- preview.value = void 0;
68
- };
69
- watch(layout, () => resetGesture());
70
- const startGesture = (event, item, edge) => {
71
- if (event.button !== 0) return;
72
- if (!getOptions().isEditable || checkIsNestedControl(event)) return;
73
- if (gesture.value && gesture.value.pointerId !== event.pointerId) return;
74
- if (!(event.currentTarget instanceof Element) || !(event.target instanceof Element)) return;
75
- if (findGridRoot(event.target) !== root.value) return;
76
- gesture.value = {
77
- edge,
78
- element: event.currentTarget,
79
- isStarted: false,
80
- offset: {
81
- x: 0,
82
- y: 0
83
- },
84
- origin: item,
85
- pointerId: event.pointerId,
86
- start: {
87
- x: event.clientX,
88
- y: event.clientY
89
- }
90
- };
91
- };
92
- const handlePointerMove = (event) => {
93
- const activeGesture = gesture.value;
94
- if (!activeGesture || event.pointerId !== activeGesture.pointerId) return;
95
- if (!activeGesture.isStarted && event.buttons === 0) {
96
- resetGesture();
97
- return;
98
- }
99
- const offset = {
100
- x: event.clientX - activeGesture.start.x,
101
- y: event.clientY - activeGesture.start.y
102
- };
103
- if (!activeGesture.isStarted && Math.hypot(offset.x, offset.y) < getOptions().dragStartDistance) return;
104
- if (!activeGesture.isStarted) activeGesture.element.setPointerCapture(event.pointerId);
105
- const cell = getGestureCell({
106
- columnNumber: getOptions().columnNumber,
107
- columnPitch: columnPitch.value,
108
- edge: activeGesture.edge,
109
- offset,
110
- origin: activeGesture.origin,
111
- rowPitch: rowPitch.value
112
- });
113
- const isCellChanged = !activeGesture.cell || !checkIsSameCell(cell, activeGesture.cell);
114
- gesture.value = {
115
- ...activeGesture,
116
- cell,
117
- isStarted: true,
118
- offset
119
- };
120
- if (isCellChanged) preview.value = placeMove(layout.value, cell, getOptions());
121
- };
122
- const getChangedCells = (changedLayout) => changedLayout.flatMap((item) => {
123
- const savedItem = savedItemMap.value.get(item.id);
124
- return !savedItem || !checkIsSameCell(item, savedItem) ? [{
125
- h: item.h,
126
- id: item.id,
127
- w: item.w,
128
- x: item.x,
129
- y: item.y
130
- }] : [];
131
- });
132
- const accept = (item, point) => {
133
- const element = root.value;
134
- if (!element || !getOptions().isEditable) return false;
135
- const { left, top } = element.getBoundingClientRect();
136
- const { padding } = getOptions().spacing;
137
- const offset = {
138
- x: point.x - left - padding,
139
- y: point.y - top - padding
140
- };
141
- const columnIndex = Math.floor(offset.x / columnPitch.value);
142
- const rowIndex = Math.floor(offset.y / rowPitch.value);
143
- const y = Math.max(0, rowIndex);
144
- const cell = takeOne(correctBounds([{
145
- h: item.h,
146
- id: item.id,
147
- w: item.w,
148
- x: columnIndex,
149
- y
150
- }], getOptions().columnNumber));
151
- if (getOptions().collision === "Prevent" && layout.value.some((other) => checkIsColliding(cell, other))) return false;
152
- const landedLayout = placeMove([...layout.value, cell], cell, getOptions());
153
- const changes = getChangedCells(landedLayout);
154
- getOptions().onCommit({
155
- changes,
156
- removed: []
157
- });
158
- return true;
159
- };
160
- const self = { accept };
161
- const handlePointerUp = (event) => {
162
- const activeGesture = gesture.value;
163
- if (!activeGesture || event.pointerId !== activeGesture.pointerId) return;
164
- const point = {
165
- x: event.clientX,
166
- y: event.clientY
167
- };
168
- const dropGrid = draggedGesture.value ? findGridAt(point, activeGesture.element) : self;
169
- const changes = getChangedCells(preview.value ?? []);
170
- resetGesture();
171
- if (dropGrid === self) {
172
- if (changes.length > 0) getOptions().onCommit({
173
- changes,
174
- removed: []
175
- });
176
- return;
177
- }
178
- if (!dropGrid) return;
179
- if (!dropGrid.accept(activeGesture.origin, point)) return;
180
- const remainingItems = layout.value.filter((item) => item.id !== activeGesture.origin.id);
181
- const remainingLayout = compactLayout(remainingItems, getOptions().columnNumber, getOptions().compactType);
182
- getOptions().onCommit({
183
- changes: getChangedCells(remainingLayout),
184
- removed: [activeGesture.origin.id]
185
- });
186
- };
187
- const reportContentHeight = (id, contentHeight) => {
188
- const savedItem = savedItemMap.value.get(id);
189
- if (!savedItem?.isAutoHeight) return;
190
- const h = getCellSpan(contentHeight, rowPitch.value, getOptions().spacing.gap);
191
- if (h === savedItem.h) return;
192
- const otherItems = getOptions().items.filter((item) => item.id !== id);
193
- const changes = getChangedCells(fitLayout([...otherItems, {
194
- ...savedItem,
195
- h
196
- }], getOptions().columnNumber, getOptions().compactType));
197
- if (changes.length > 0) getOptions().onCommit({
198
- changes,
199
- removed: []
200
- });
201
- };
202
- const handlePointerCancel = (event) => {
203
- if (event.pointerId === gesture.value?.pointerId) resetGesture();
204
- };
205
- const attached = shallowRef();
206
- onMounted(() => {
207
- const element = root.value;
208
- if (!element) return;
209
- const controller = new AbortController();
210
- const { signal } = controller;
211
- const observer = new ResizeObserver(([entry]) => {
212
- width.value = entry?.contentRect.width ?? 0;
213
- });
214
- observer.observe(element);
215
- element.addEventListener("pointermove", handlePointerMove, { signal });
216
- element.addEventListener("pointerup", handlePointerUp, { signal });
217
- element.addEventListener("pointercancel", handlePointerCancel, { signal });
218
- mountedGrids.set(element, self);
219
- attached.value = {
220
- controller,
221
- element,
222
- observer
223
- };
224
- });
225
- onUnmounted(() => {
226
- if (!attached.value) return;
227
- const { controller, element, observer } = attached.value;
228
- observer.disconnect();
229
- mountedGrids.delete(element);
230
- controller.abort();
231
- });
232
- return {
233
- gridHeight,
234
- placeholder,
235
- reportContentHeight,
236
- startGesture,
237
- tiles
238
- };
239
- };
240
- // src/services/startExternalDrag.ts
241
- const startExternalDrag = (event, item) => {
242
- if (event.button !== 0) return;
243
- if (!(event.currentTarget instanceof HTMLElement)) return;
244
- const element = event.currentTarget;
245
- const { pointerId } = event;
246
- element.setPointerCapture(pointerId);
247
- const controller = new AbortController();
248
- const { signal } = controller;
249
- element.addEventListener("pointerup", (releaseEvent) => {
250
- if (releaseEvent.pointerId !== pointerId) return;
251
- controller.abort();
252
- const point = {
253
- x: releaseEvent.clientX,
254
- y: releaseEvent.clientY
255
- };
256
- findGridAt(point, element)?.accept(item, point);
257
- }, { signal });
258
- element.addEventListener("pointercancel", (cancelEvent) => {
259
- if (cancelEvent.pointerId === pointerId) controller.abort();
260
- }, { signal });
261
- };
262
- export { CollisionMode, CompactType, ResizeEdge, startExternalDrag, useGridLayout };
@@ -1,212 +0,0 @@
1
- // src/models/CollisionMode.ts
2
- let CollisionMode = /* @__PURE__ */ function(CollisionMode) {
3
- CollisionMode["Prevent"] = "Prevent";
4
- CollisionMode["Push"] = "Push";
5
- CollisionMode["Swap"] = "Swap";
6
- return CollisionMode;
7
- }({});
8
- // src/placement/checkIsColliding.ts
9
- const checkIsColliding = (item, other) => item.id !== other.id && item.x < other.x + other.w && item.x + item.w > other.x && item.y < other.y + other.h && item.y + item.h > other.y;
10
- // src/placement/checkIsSameCell.ts
11
- const checkIsSameCell = (cell, other) => cell.h === other.h && cell.w === other.w && cell.x === other.x && cell.y === other.y;
12
- // src/models/CompactType.ts
13
- let CompactType = /* @__PURE__ */ function(CompactType) {
14
- CompactType["Horizontal"] = "Horizontal";
15
- CompactType["None"] = "None";
16
- CompactType["Vertical"] = "Vertical";
17
- return CompactType;
18
- }({});
19
- // src/placement/compactLayout.ts
20
- const compactLayout = (layout, columnNumber, compactType) => {
21
- const copies = layout.map((item) => ({ ...item }));
22
- const isHorizontal = compactType === "Horizontal";
23
- const axis = isHorizontal ? "x" : "y";
24
- const crossAxis = isHorizontal ? "y" : "x";
25
- const placedItems = [];
26
- const checkIsBlocked = (candidate) => placedItems.some((placedItem) => checkIsColliding(candidate, placedItem));
27
- const riseAlongAxis = (item) => {
28
- while (item[axis] > 0 && !checkIsBlocked({
29
- ...item,
30
- [axis]: item[axis] - 1
31
- })) item[axis] -= 1;
32
- };
33
- const pushAlongAxis = (item) => {
34
- if (isHorizontal && item.x + item.w + 1 > columnNumber) {
35
- item.x = columnNumber - item.w;
36
- item.y += 1;
37
- riseAlongAxis(item);
38
- } else item[axis] += 1;
39
- };
40
- const sortedItems = copies.toSorted((firstItem, secondItem) => firstItem[axis] - secondItem[axis] || firstItem[crossAxis] - secondItem[crossAxis]);
41
- for (const item of sortedItems) {
42
- if (compactType !== "None") riseAlongAxis(item);
43
- while (checkIsBlocked(item)) pushAlongAxis(item);
44
- placedItems.push(item);
45
- }
46
- return placedItems;
47
- };
48
- // src/placement/correctBounds.ts
49
- const correctBounds = (layout, columnNumber) => layout.map((item) => {
50
- const h = Math.max(1, item.h);
51
- const w = Math.max(1, Math.min(item.w, columnNumber));
52
- const x = Math.min(Math.max(item.x, 0), columnNumber - w);
53
- return {
54
- ...item,
55
- h,
56
- w,
57
- x
58
- };
59
- });
60
- // src/placement/fitLayout.ts
61
- const fitLayout = (layout, columnNumber, compactType) => compactLayout(correctBounds(layout, columnNumber), columnNumber, compactType);
62
- // src/placement/getCellPosition.ts
63
- const getCellPosition = (index, pitch, padding) => Math.round(index * pitch + padding);
64
- // src/placement/getCellSize.ts
65
- const getCellSize = (span, pitch, gap) => span * pitch - gap;
66
- // src/placement/getCellSpan.ts
67
- const getCellSpan = (size, pitch, gap) => Math.max(1, Math.ceil((size + gap) / pitch));
68
- // src/placement/getColumnPitch.ts
69
- const getColumnPitch = (width, columnNumber, { gap, padding }) => (width - 2 * padding + gap) / columnNumber;
70
- // src/models/ResizeEdge.ts
71
- let ResizeEdge = /* @__PURE__ */ function(ResizeEdge) {
72
- ResizeEdge["East"] = "East";
73
- ResizeEdge["North"] = "North";
74
- ResizeEdge["NorthEast"] = "NorthEast";
75
- ResizeEdge["NorthWest"] = "NorthWest";
76
- ResizeEdge["South"] = "South";
77
- ResizeEdge["SouthEast"] = "SouthEast";
78
- ResizeEdge["SouthWest"] = "SouthWest";
79
- ResizeEdge["West"] = "West";
80
- return ResizeEdge;
81
- }({});
82
- // src/placement/getGestureCell.ts
83
- const ResizeEdgeSidesMap = {
84
- ["East"]: {
85
- isEast: true,
86
- isNorth: false,
87
- isSouth: false,
88
- isWest: false
89
- },
90
- ["North"]: {
91
- isEast: false,
92
- isNorth: true,
93
- isSouth: false,
94
- isWest: false
95
- },
96
- ["NorthEast"]: {
97
- isEast: true,
98
- isNorth: true,
99
- isSouth: false,
100
- isWest: false
101
- },
102
- ["NorthWest"]: {
103
- isEast: false,
104
- isNorth: true,
105
- isSouth: false,
106
- isWest: true
107
- },
108
- ["South"]: {
109
- isEast: false,
110
- isNorth: false,
111
- isSouth: true,
112
- isWest: false
113
- },
114
- ["SouthEast"]: {
115
- isEast: true,
116
- isNorth: false,
117
- isSouth: true,
118
- isWest: false
119
- },
120
- ["SouthWest"]: {
121
- isEast: false,
122
- isNorth: false,
123
- isSouth: true,
124
- isWest: true
125
- },
126
- ["West"]: {
127
- isEast: false,
128
- isNorth: false,
129
- isSouth: false,
130
- isWest: true
131
- }
132
- };
133
- const getGestureCell = ({ columnNumber, columnPitch, edge, offset, origin, rowPitch }) => {
134
- const columnDelta = Math.round(offset.x / columnPitch);
135
- const rowDelta = Math.round(offset.y / rowPitch);
136
- if (!edge) {
137
- const x = Math.min(Math.max(origin.x + columnDelta, 0), columnNumber - origin.w);
138
- const y = Math.max(0, origin.y + rowDelta);
139
- return {
140
- h: origin.h,
141
- id: origin.id,
142
- w: origin.w,
143
- x,
144
- y
145
- };
146
- }
147
- const { isEast, isNorth, isSouth, isWest } = ResizeEdgeSidesMap[edge];
148
- const right = origin.x + origin.w;
149
- const bottom = origin.y + origin.h;
150
- const leftX = Math.min(Math.max(origin.x + columnDelta, 0), right - 1);
151
- const eastWidth = Math.min(Math.max(1, origin.w + columnDelta), columnNumber - origin.x);
152
- const topY = Math.min(Math.max(origin.y + rowDelta, 0), bottom - 1);
153
- const southHeight = Math.max(1, origin.h + rowDelta);
154
- const x = isWest ? leftX : origin.x;
155
- const widthFromRight = isEast ? eastWidth : origin.w;
156
- const w = isWest ? right - leftX : widthFromRight;
157
- const y = isNorth ? topY : origin.y;
158
- const heightFromBottom = isSouth ? southHeight : origin.h;
159
- return {
160
- h: isNorth ? bottom - topY : heightFromBottom,
161
- id: origin.id,
162
- w,
163
- x,
164
- y
165
- };
166
- };
167
- // src/placement/getLayoutBottom.ts
168
- const getLayoutBottom = (layout) => Math.max(0, ...layout.map((item) => item.y + item.h));
169
- // src/placement/moveItem.ts
170
- const moveItem = (layout, target) => {
171
- const movedLayout = layout.map((item) => item.id === target.id ? {
172
- ...item,
173
- ...target
174
- } : { ...item });
175
- const pushedIds = /* @__PURE__ */ new Set([target.id]);
176
- const pushBelow = (pusher) => {
177
- for (const item of movedLayout) {
178
- if (pushedIds.has(item.id) || !checkIsColliding(pusher, item)) continue;
179
- if (item.y < pusher.y && pusher.y - item.y > item.h * .25) continue;
180
- pushedIds.add(item.id);
181
- item.y = pusher.y + pusher.h;
182
- pushBelow(item);
183
- }
184
- };
185
- const movedItem = movedLayout.find((item) => item.id === target.id);
186
- if (movedItem) pushBelow(movedItem);
187
- return movedLayout;
188
- };
189
- // src/placement/resolveMove.ts
190
- const resolveMove = (layout, target, collision) => {
191
- const landedItems = layout.filter((item) => item.id !== target.id && checkIsColliding(target, item));
192
- const [landedItem] = landedItems;
193
- const movedItem = layout.find((item) => item.id === target.id);
194
- if (collision === "Prevent" && landedItems.length > 0) return layout.map((item) => ({ ...item }));
195
- const isMove = movedItem !== void 0 && movedItem.w === target.w && movedItem.h === target.h;
196
- if (collision === "Swap" && isMove && landedItems.length === 1 && landedItem && movedItem) {
197
- const swappedLayout = layout.map((item) => item.id === landedItem.id ? {
198
- ...item,
199
- x: movedItem.x,
200
- y: movedItem.y
201
- } : { ...item });
202
- return moveItem(swappedLayout, {
203
- ...target,
204
- x: landedItem.x,
205
- y: landedItem.y
206
- });
207
- }
208
- return moveItem(layout, target);
209
- };
210
- // src/placement/placeMove.ts
211
- const placeMove = (layout, target, { collision, columnNumber, compactType }) => compactLayout(resolveMove(layout, target, collision), columnNumber, compactType);
212
- export { CollisionMode as _, getGestureCell as a, getCellSpan as c, fitLayout as d, correctBounds as f, checkIsColliding as g, checkIsSameCell as h, getLayoutBottom as i, getCellSize as l, CompactType as m, resolveMove as n, ResizeEdge as o, compactLayout as p, moveItem as r, getColumnPitch as s, placeMove as t, getCellPosition as u };
@@ -1,25 +0,0 @@
1
- import { a as GridSpacing, c as GridCell, i as ResizeEdge, o as CompactType, r as CollisionMode, s as GridItem, t as GridLayoutOptions } from "./GridLayoutOptions-D0ot9xMz.js";
2
- export declare const checkIsColliding: (item: GridItem, other: GridItem) => boolean;
3
- export declare const checkIsSameCell: (cell: GridCell, other: GridCell) => boolean;
4
- export declare const compactLayout: <T extends GridItem>(layout: T[], columnNumber: number, compactType: CompactType) => T[];
5
- export declare const correctBounds: <T extends GridItem>(layout: T[], columnNumber: number) => T[];
6
- export declare const fitLayout: <T extends GridItem>(layout: T[], columnNumber: number, compactType: CompactType) => T[];
7
- export declare const getCellPosition: (index: number, pitch: number, padding: number) => number;
8
- export declare const getCellSize: (span: number, pitch: number, gap: number) => number;
9
- export declare const getCellSpan: (size: number, pitch: number, gap: number) => number;
10
- export declare const getColumnPitch: (width: number, columnNumber: number, { gap, padding }: GridSpacing) => number;
11
- export declare const getGestureCell: ({ columnNumber, columnPitch, edge, offset, origin, rowPitch }: {
12
- columnNumber: number;
13
- columnPitch: number;
14
- edge?: ResizeEdge;
15
- offset: {
16
- x: number;
17
- y: number;
18
- };
19
- origin: GridItem;
20
- rowPitch: number;
21
- }) => GridItem;
22
- export declare const getLayoutBottom: (layout: GridItem[]) => number;
23
- export declare const moveItem: <T extends GridItem>(layout: T[], target: GridItem) => T[];
24
- export declare const placeMove: <T extends GridItem>(layout: T[], target: GridItem, { collision, columnNumber, compactType }: Pick<GridLayoutOptions, "collision" | "columnNumber" | "compactType">) => T[];
25
- export declare const resolveMove: <T extends GridItem>(layout: T[], target: GridItem, collision: CollisionMode) => T[];
package/dist/placement.js DELETED
@@ -1 +0,0 @@
1
- export { g as checkIsColliding, h as checkIsSameCell, p as compactLayout, f as correctBounds, d as fitLayout, u as getCellPosition, l as getCellSize, c as getCellSpan, s as getColumnPitch, a as getGestureCell, i as getLayoutBottom, r as moveItem, t as placeMove, n as resolveMove } from "./placeMove-BPQPi70h.js";