[2f988f42] readme.md wiederhergestellt.
readme.md wiederhergestellt.
This commit is contained in:
717
heatmap-tool/frontend/.vite/deps/@dnd-kit_sortable.js
Normal file
717
heatmap-tool/frontend/.vite/deps/@dnd-kit_sortable.js
Normal file
@@ -0,0 +1,717 @@
|
||||
import {
|
||||
KeyboardCode,
|
||||
closestCorners,
|
||||
getClientRect,
|
||||
getFirstCollision,
|
||||
getScrollableAncestors,
|
||||
useDndContext,
|
||||
useDraggable,
|
||||
useDroppable
|
||||
} from "./chunk-KTM66X27.js";
|
||||
import {
|
||||
CSS,
|
||||
isKeyboardEvent,
|
||||
subtract,
|
||||
useCombinedRefs,
|
||||
useIsomorphicLayoutEffect,
|
||||
useUniqueId
|
||||
} from "./chunk-BC2PPIIJ.js";
|
||||
import "./chunk-AU2MKR2E.js";
|
||||
import {
|
||||
require_react
|
||||
} from "./chunk-VX2H6PUQ.js";
|
||||
import {
|
||||
__toESM
|
||||
} from "./chunk-G3PMV62Z.js";
|
||||
|
||||
// node_modules/@dnd-kit/sortable/dist/sortable.esm.js
|
||||
var import_react = __toESM(require_react());
|
||||
function arrayMove(array, from, to) {
|
||||
const newArray = array.slice();
|
||||
newArray.splice(to < 0 ? newArray.length + to : to, 0, newArray.splice(from, 1)[0]);
|
||||
return newArray;
|
||||
}
|
||||
function arraySwap(array, from, to) {
|
||||
const newArray = array.slice();
|
||||
newArray[from] = array[to];
|
||||
newArray[to] = array[from];
|
||||
return newArray;
|
||||
}
|
||||
function getSortedRects(items, rects) {
|
||||
return items.reduce((accumulator, id, index) => {
|
||||
const rect = rects.get(id);
|
||||
if (rect) {
|
||||
accumulator[index] = rect;
|
||||
}
|
||||
return accumulator;
|
||||
}, Array(items.length));
|
||||
}
|
||||
function isValidIndex(index) {
|
||||
return index !== null && index >= 0;
|
||||
}
|
||||
function itemsEqual(a, b) {
|
||||
if (a === b) {
|
||||
return true;
|
||||
}
|
||||
if (a.length !== b.length) {
|
||||
return false;
|
||||
}
|
||||
for (let i = 0; i < a.length; i++) {
|
||||
if (a[i] !== b[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function normalizeDisabled(disabled) {
|
||||
if (typeof disabled === "boolean") {
|
||||
return {
|
||||
draggable: disabled,
|
||||
droppable: disabled
|
||||
};
|
||||
}
|
||||
return disabled;
|
||||
}
|
||||
var defaultScale = {
|
||||
scaleX: 1,
|
||||
scaleY: 1
|
||||
};
|
||||
var horizontalListSortingStrategy = (_ref) => {
|
||||
var _rects$activeIndex;
|
||||
let {
|
||||
rects,
|
||||
activeNodeRect: fallbackActiveRect,
|
||||
activeIndex,
|
||||
overIndex,
|
||||
index
|
||||
} = _ref;
|
||||
const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;
|
||||
if (!activeNodeRect) {
|
||||
return null;
|
||||
}
|
||||
const itemGap = getItemGap(rects, index, activeIndex);
|
||||
if (index === activeIndex) {
|
||||
const newIndexRect = rects[overIndex];
|
||||
if (!newIndexRect) {
|
||||
return null;
|
||||
}
|
||||
return {
|
||||
x: activeIndex < overIndex ? newIndexRect.left + newIndexRect.width - (activeNodeRect.left + activeNodeRect.width) : newIndexRect.left - activeNodeRect.left,
|
||||
y: 0,
|
||||
...defaultScale
|
||||
};
|
||||
}
|
||||
if (index > activeIndex && index <= overIndex) {
|
||||
return {
|
||||
x: -activeNodeRect.width - itemGap,
|
||||
y: 0,
|
||||
...defaultScale
|
||||
};
|
||||
}
|
||||
if (index < activeIndex && index >= overIndex) {
|
||||
return {
|
||||
x: activeNodeRect.width + itemGap,
|
||||
y: 0,
|
||||
...defaultScale
|
||||
};
|
||||
}
|
||||
return {
|
||||
x: 0,
|
||||
y: 0,
|
||||
...defaultScale
|
||||
};
|
||||
};
|
||||
function getItemGap(rects, index, activeIndex) {
|
||||
const currentRect = rects[index];
|
||||
const previousRect = rects[index - 1];
|
||||
const nextRect = rects[index + 1];
|
||||
if (!currentRect || !previousRect && !nextRect) {
|
||||
return 0;
|
||||
}
|
||||
if (activeIndex < index) {
|
||||
return previousRect ? currentRect.left - (previousRect.left + previousRect.width) : nextRect.left - (currentRect.left + currentRect.width);
|
||||
}
|
||||
return nextRect ? nextRect.left - (currentRect.left + currentRect.width) : currentRect.left - (previousRect.left + previousRect.width);
|
||||
}
|
||||
var rectSortingStrategy = (_ref) => {
|
||||
let {
|
||||
rects,
|
||||
activeIndex,
|
||||
overIndex,
|
||||
index
|
||||
} = _ref;
|
||||
const newRects = arrayMove(rects, overIndex, activeIndex);
|
||||
const oldRect = rects[index];
|
||||
const newRect = newRects[index];
|
||||
if (!newRect || !oldRect) {
|
||||
return null;
|
||||
}
|
||||
return {
|
||||
x: newRect.left - oldRect.left,
|
||||
y: newRect.top - oldRect.top,
|
||||
scaleX: newRect.width / oldRect.width,
|
||||
scaleY: newRect.height / oldRect.height
|
||||
};
|
||||
};
|
||||
var rectSwappingStrategy = (_ref) => {
|
||||
let {
|
||||
activeIndex,
|
||||
index,
|
||||
rects,
|
||||
overIndex
|
||||
} = _ref;
|
||||
let oldRect;
|
||||
let newRect;
|
||||
if (index === activeIndex) {
|
||||
oldRect = rects[index];
|
||||
newRect = rects[overIndex];
|
||||
}
|
||||
if (index === overIndex) {
|
||||
oldRect = rects[index];
|
||||
newRect = rects[activeIndex];
|
||||
}
|
||||
if (!newRect || !oldRect) {
|
||||
return null;
|
||||
}
|
||||
return {
|
||||
x: newRect.left - oldRect.left,
|
||||
y: newRect.top - oldRect.top,
|
||||
scaleX: newRect.width / oldRect.width,
|
||||
scaleY: newRect.height / oldRect.height
|
||||
};
|
||||
};
|
||||
var defaultScale$1 = {
|
||||
scaleX: 1,
|
||||
scaleY: 1
|
||||
};
|
||||
var verticalListSortingStrategy = (_ref) => {
|
||||
var _rects$activeIndex;
|
||||
let {
|
||||
activeIndex,
|
||||
activeNodeRect: fallbackActiveRect,
|
||||
index,
|
||||
rects,
|
||||
overIndex
|
||||
} = _ref;
|
||||
const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;
|
||||
if (!activeNodeRect) {
|
||||
return null;
|
||||
}
|
||||
if (index === activeIndex) {
|
||||
const overIndexRect = rects[overIndex];
|
||||
if (!overIndexRect) {
|
||||
return null;
|
||||
}
|
||||
return {
|
||||
x: 0,
|
||||
y: activeIndex < overIndex ? overIndexRect.top + overIndexRect.height - (activeNodeRect.top + activeNodeRect.height) : overIndexRect.top - activeNodeRect.top,
|
||||
...defaultScale$1
|
||||
};
|
||||
}
|
||||
const itemGap = getItemGap$1(rects, index, activeIndex);
|
||||
if (index > activeIndex && index <= overIndex) {
|
||||
return {
|
||||
x: 0,
|
||||
y: -activeNodeRect.height - itemGap,
|
||||
...defaultScale$1
|
||||
};
|
||||
}
|
||||
if (index < activeIndex && index >= overIndex) {
|
||||
return {
|
||||
x: 0,
|
||||
y: activeNodeRect.height + itemGap,
|
||||
...defaultScale$1
|
||||
};
|
||||
}
|
||||
return {
|
||||
x: 0,
|
||||
y: 0,
|
||||
...defaultScale$1
|
||||
};
|
||||
};
|
||||
function getItemGap$1(clientRects, index, activeIndex) {
|
||||
const currentRect = clientRects[index];
|
||||
const previousRect = clientRects[index - 1];
|
||||
const nextRect = clientRects[index + 1];
|
||||
if (!currentRect) {
|
||||
return 0;
|
||||
}
|
||||
if (activeIndex < index) {
|
||||
return previousRect ? currentRect.top - (previousRect.top + previousRect.height) : nextRect ? nextRect.top - (currentRect.top + currentRect.height) : 0;
|
||||
}
|
||||
return nextRect ? nextRect.top - (currentRect.top + currentRect.height) : previousRect ? currentRect.top - (previousRect.top + previousRect.height) : 0;
|
||||
}
|
||||
var ID_PREFIX = "Sortable";
|
||||
var Context = import_react.default.createContext({
|
||||
activeIndex: -1,
|
||||
containerId: ID_PREFIX,
|
||||
disableTransforms: false,
|
||||
items: [],
|
||||
overIndex: -1,
|
||||
useDragOverlay: false,
|
||||
sortedRects: [],
|
||||
strategy: rectSortingStrategy,
|
||||
disabled: {
|
||||
draggable: false,
|
||||
droppable: false
|
||||
}
|
||||
});
|
||||
function SortableContext(_ref) {
|
||||
let {
|
||||
children,
|
||||
id,
|
||||
items: userDefinedItems,
|
||||
strategy = rectSortingStrategy,
|
||||
disabled: disabledProp = false
|
||||
} = _ref;
|
||||
const {
|
||||
active,
|
||||
dragOverlay,
|
||||
droppableRects,
|
||||
over,
|
||||
measureDroppableContainers
|
||||
} = useDndContext();
|
||||
const containerId = useUniqueId(ID_PREFIX, id);
|
||||
const useDragOverlay = Boolean(dragOverlay.rect !== null);
|
||||
const items = (0, import_react.useMemo)(() => userDefinedItems.map((item) => typeof item === "object" && "id" in item ? item.id : item), [userDefinedItems]);
|
||||
const isDragging = active != null;
|
||||
const activeIndex = active ? items.indexOf(active.id) : -1;
|
||||
const overIndex = over ? items.indexOf(over.id) : -1;
|
||||
const previousItemsRef = (0, import_react.useRef)(items);
|
||||
const itemsHaveChanged = !itemsEqual(items, previousItemsRef.current);
|
||||
const disableTransforms = overIndex !== -1 && activeIndex === -1 || itemsHaveChanged;
|
||||
const disabled = normalizeDisabled(disabledProp);
|
||||
useIsomorphicLayoutEffect(() => {
|
||||
if (itemsHaveChanged && isDragging) {
|
||||
measureDroppableContainers(items);
|
||||
}
|
||||
}, [itemsHaveChanged, items, isDragging, measureDroppableContainers]);
|
||||
(0, import_react.useEffect)(() => {
|
||||
previousItemsRef.current = items;
|
||||
}, [items]);
|
||||
const contextValue = (0, import_react.useMemo)(
|
||||
() => ({
|
||||
activeIndex,
|
||||
containerId,
|
||||
disabled,
|
||||
disableTransforms,
|
||||
items,
|
||||
overIndex,
|
||||
useDragOverlay,
|
||||
sortedRects: getSortedRects(items, droppableRects),
|
||||
strategy
|
||||
}),
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||
[activeIndex, containerId, disabled.draggable, disabled.droppable, disableTransforms, items, overIndex, droppableRects, useDragOverlay, strategy]
|
||||
);
|
||||
return import_react.default.createElement(Context.Provider, {
|
||||
value: contextValue
|
||||
}, children);
|
||||
}
|
||||
var defaultNewIndexGetter = (_ref) => {
|
||||
let {
|
||||
id,
|
||||
items,
|
||||
activeIndex,
|
||||
overIndex
|
||||
} = _ref;
|
||||
return arrayMove(items, activeIndex, overIndex).indexOf(id);
|
||||
};
|
||||
var defaultAnimateLayoutChanges = (_ref2) => {
|
||||
let {
|
||||
containerId,
|
||||
isSorting,
|
||||
wasDragging,
|
||||
index,
|
||||
items,
|
||||
newIndex,
|
||||
previousItems,
|
||||
previousContainerId,
|
||||
transition
|
||||
} = _ref2;
|
||||
if (!transition || !wasDragging) {
|
||||
return false;
|
||||
}
|
||||
if (previousItems !== items && index === newIndex) {
|
||||
return false;
|
||||
}
|
||||
if (isSorting) {
|
||||
return true;
|
||||
}
|
||||
return newIndex !== index && containerId === previousContainerId;
|
||||
};
|
||||
var defaultTransition = {
|
||||
duration: 200,
|
||||
easing: "ease"
|
||||
};
|
||||
var transitionProperty = "transform";
|
||||
var disabledTransition = CSS.Transition.toString({
|
||||
property: transitionProperty,
|
||||
duration: 0,
|
||||
easing: "linear"
|
||||
});
|
||||
var defaultAttributes = {
|
||||
roleDescription: "sortable"
|
||||
};
|
||||
function useDerivedTransform(_ref) {
|
||||
let {
|
||||
disabled,
|
||||
index,
|
||||
node,
|
||||
rect
|
||||
} = _ref;
|
||||
const [derivedTransform, setDerivedtransform] = (0, import_react.useState)(null);
|
||||
const previousIndex = (0, import_react.useRef)(index);
|
||||
useIsomorphicLayoutEffect(() => {
|
||||
if (!disabled && index !== previousIndex.current && node.current) {
|
||||
const initial = rect.current;
|
||||
if (initial) {
|
||||
const current = getClientRect(node.current, {
|
||||
ignoreTransform: true
|
||||
});
|
||||
const delta = {
|
||||
x: initial.left - current.left,
|
||||
y: initial.top - current.top,
|
||||
scaleX: initial.width / current.width,
|
||||
scaleY: initial.height / current.height
|
||||
};
|
||||
if (delta.x || delta.y) {
|
||||
setDerivedtransform(delta);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (index !== previousIndex.current) {
|
||||
previousIndex.current = index;
|
||||
}
|
||||
}, [disabled, index, node, rect]);
|
||||
(0, import_react.useEffect)(() => {
|
||||
if (derivedTransform) {
|
||||
setDerivedtransform(null);
|
||||
}
|
||||
}, [derivedTransform]);
|
||||
return derivedTransform;
|
||||
}
|
||||
function useSortable(_ref) {
|
||||
let {
|
||||
animateLayoutChanges = defaultAnimateLayoutChanges,
|
||||
attributes: userDefinedAttributes,
|
||||
disabled: localDisabled,
|
||||
data: customData,
|
||||
getNewIndex = defaultNewIndexGetter,
|
||||
id,
|
||||
strategy: localStrategy,
|
||||
resizeObserverConfig,
|
||||
transition = defaultTransition
|
||||
} = _ref;
|
||||
const {
|
||||
items,
|
||||
containerId,
|
||||
activeIndex,
|
||||
disabled: globalDisabled,
|
||||
disableTransforms,
|
||||
sortedRects,
|
||||
overIndex,
|
||||
useDragOverlay,
|
||||
strategy: globalStrategy
|
||||
} = (0, import_react.useContext)(Context);
|
||||
const disabled = normalizeLocalDisabled(localDisabled, globalDisabled);
|
||||
const index = items.indexOf(id);
|
||||
const data = (0, import_react.useMemo)(() => ({
|
||||
sortable: {
|
||||
containerId,
|
||||
index,
|
||||
items
|
||||
},
|
||||
...customData
|
||||
}), [containerId, customData, index, items]);
|
||||
const itemsAfterCurrentSortable = (0, import_react.useMemo)(() => items.slice(items.indexOf(id)), [items, id]);
|
||||
const {
|
||||
rect,
|
||||
node,
|
||||
isOver,
|
||||
setNodeRef: setDroppableNodeRef
|
||||
} = useDroppable({
|
||||
id,
|
||||
data,
|
||||
disabled: disabled.droppable,
|
||||
resizeObserverConfig: {
|
||||
updateMeasurementsFor: itemsAfterCurrentSortable,
|
||||
...resizeObserverConfig
|
||||
}
|
||||
});
|
||||
const {
|
||||
active,
|
||||
activatorEvent,
|
||||
activeNodeRect,
|
||||
attributes,
|
||||
setNodeRef: setDraggableNodeRef,
|
||||
listeners,
|
||||
isDragging,
|
||||
over,
|
||||
setActivatorNodeRef,
|
||||
transform
|
||||
} = useDraggable({
|
||||
id,
|
||||
data,
|
||||
attributes: {
|
||||
...defaultAttributes,
|
||||
...userDefinedAttributes
|
||||
},
|
||||
disabled: disabled.draggable
|
||||
});
|
||||
const setNodeRef = useCombinedRefs(setDroppableNodeRef, setDraggableNodeRef);
|
||||
const isSorting = Boolean(active);
|
||||
const displaceItem = isSorting && !disableTransforms && isValidIndex(activeIndex) && isValidIndex(overIndex);
|
||||
const shouldDisplaceDragSource = !useDragOverlay && isDragging;
|
||||
const dragSourceDisplacement = shouldDisplaceDragSource && displaceItem ? transform : null;
|
||||
const strategy = localStrategy != null ? localStrategy : globalStrategy;
|
||||
const finalTransform = displaceItem ? dragSourceDisplacement != null ? dragSourceDisplacement : strategy({
|
||||
rects: sortedRects,
|
||||
activeNodeRect,
|
||||
activeIndex,
|
||||
overIndex,
|
||||
index
|
||||
}) : null;
|
||||
const newIndex = isValidIndex(activeIndex) && isValidIndex(overIndex) ? getNewIndex({
|
||||
id,
|
||||
items,
|
||||
activeIndex,
|
||||
overIndex
|
||||
}) : index;
|
||||
const activeId = active == null ? void 0 : active.id;
|
||||
const previous = (0, import_react.useRef)({
|
||||
activeId,
|
||||
items,
|
||||
newIndex,
|
||||
containerId
|
||||
});
|
||||
const itemsHaveChanged = items !== previous.current.items;
|
||||
const shouldAnimateLayoutChanges = animateLayoutChanges({
|
||||
active,
|
||||
containerId,
|
||||
isDragging,
|
||||
isSorting,
|
||||
id,
|
||||
index,
|
||||
items,
|
||||
newIndex: previous.current.newIndex,
|
||||
previousItems: previous.current.items,
|
||||
previousContainerId: previous.current.containerId,
|
||||
transition,
|
||||
wasDragging: previous.current.activeId != null
|
||||
});
|
||||
const derivedTransform = useDerivedTransform({
|
||||
disabled: !shouldAnimateLayoutChanges,
|
||||
index,
|
||||
node,
|
||||
rect
|
||||
});
|
||||
(0, import_react.useEffect)(() => {
|
||||
if (isSorting && previous.current.newIndex !== newIndex) {
|
||||
previous.current.newIndex = newIndex;
|
||||
}
|
||||
if (containerId !== previous.current.containerId) {
|
||||
previous.current.containerId = containerId;
|
||||
}
|
||||
if (items !== previous.current.items) {
|
||||
previous.current.items = items;
|
||||
}
|
||||
}, [isSorting, newIndex, containerId, items]);
|
||||
(0, import_react.useEffect)(() => {
|
||||
if (activeId === previous.current.activeId) {
|
||||
return;
|
||||
}
|
||||
if (activeId != null && previous.current.activeId == null) {
|
||||
previous.current.activeId = activeId;
|
||||
return;
|
||||
}
|
||||
const timeoutId = setTimeout(() => {
|
||||
previous.current.activeId = activeId;
|
||||
}, 50);
|
||||
return () => clearTimeout(timeoutId);
|
||||
}, [activeId]);
|
||||
return {
|
||||
active,
|
||||
activeIndex,
|
||||
attributes,
|
||||
data,
|
||||
rect,
|
||||
index,
|
||||
newIndex,
|
||||
items,
|
||||
isOver,
|
||||
isSorting,
|
||||
isDragging,
|
||||
listeners,
|
||||
node,
|
||||
overIndex,
|
||||
over,
|
||||
setNodeRef,
|
||||
setActivatorNodeRef,
|
||||
setDroppableNodeRef,
|
||||
setDraggableNodeRef,
|
||||
transform: derivedTransform != null ? derivedTransform : finalTransform,
|
||||
transition: getTransition()
|
||||
};
|
||||
function getTransition() {
|
||||
if (
|
||||
// Temporarily disable transitions for a single frame to set up derived transforms
|
||||
derivedTransform || // Or to prevent items jumping to back to their "new" position when items change
|
||||
itemsHaveChanged && previous.current.newIndex === index
|
||||
) {
|
||||
return disabledTransition;
|
||||
}
|
||||
if (shouldDisplaceDragSource && !isKeyboardEvent(activatorEvent) || !transition) {
|
||||
return void 0;
|
||||
}
|
||||
if (isSorting || shouldAnimateLayoutChanges) {
|
||||
return CSS.Transition.toString({
|
||||
...transition,
|
||||
property: transitionProperty
|
||||
});
|
||||
}
|
||||
return void 0;
|
||||
}
|
||||
}
|
||||
function normalizeLocalDisabled(localDisabled, globalDisabled) {
|
||||
var _localDisabled$dragga, _localDisabled$droppa;
|
||||
if (typeof localDisabled === "boolean") {
|
||||
return {
|
||||
draggable: localDisabled,
|
||||
// Backwards compatibility
|
||||
droppable: false
|
||||
};
|
||||
}
|
||||
return {
|
||||
draggable: (_localDisabled$dragga = localDisabled == null ? void 0 : localDisabled.draggable) != null ? _localDisabled$dragga : globalDisabled.draggable,
|
||||
droppable: (_localDisabled$droppa = localDisabled == null ? void 0 : localDisabled.droppable) != null ? _localDisabled$droppa : globalDisabled.droppable
|
||||
};
|
||||
}
|
||||
function hasSortableData(entry) {
|
||||
if (!entry) {
|
||||
return false;
|
||||
}
|
||||
const data = entry.data.current;
|
||||
if (data && "sortable" in data && typeof data.sortable === "object" && "containerId" in data.sortable && "items" in data.sortable && "index" in data.sortable) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
var directions = [KeyboardCode.Down, KeyboardCode.Right, KeyboardCode.Up, KeyboardCode.Left];
|
||||
var sortableKeyboardCoordinates = (event, _ref) => {
|
||||
let {
|
||||
context: {
|
||||
active,
|
||||
collisionRect,
|
||||
droppableRects,
|
||||
droppableContainers,
|
||||
over,
|
||||
scrollableAncestors
|
||||
}
|
||||
} = _ref;
|
||||
if (directions.includes(event.code)) {
|
||||
event.preventDefault();
|
||||
if (!active || !collisionRect) {
|
||||
return;
|
||||
}
|
||||
const filteredContainers = [];
|
||||
droppableContainers.getEnabled().forEach((entry) => {
|
||||
if (!entry || entry != null && entry.disabled) {
|
||||
return;
|
||||
}
|
||||
const rect = droppableRects.get(entry.id);
|
||||
if (!rect) {
|
||||
return;
|
||||
}
|
||||
switch (event.code) {
|
||||
case KeyboardCode.Down:
|
||||
if (collisionRect.top < rect.top) {
|
||||
filteredContainers.push(entry);
|
||||
}
|
||||
break;
|
||||
case KeyboardCode.Up:
|
||||
if (collisionRect.top > rect.top) {
|
||||
filteredContainers.push(entry);
|
||||
}
|
||||
break;
|
||||
case KeyboardCode.Left:
|
||||
if (collisionRect.left > rect.left) {
|
||||
filteredContainers.push(entry);
|
||||
}
|
||||
break;
|
||||
case KeyboardCode.Right:
|
||||
if (collisionRect.left < rect.left) {
|
||||
filteredContainers.push(entry);
|
||||
}
|
||||
break;
|
||||
}
|
||||
});
|
||||
const collisions = closestCorners({
|
||||
active,
|
||||
collisionRect,
|
||||
droppableRects,
|
||||
droppableContainers: filteredContainers,
|
||||
pointerCoordinates: null
|
||||
});
|
||||
let closestId = getFirstCollision(collisions, "id");
|
||||
if (closestId === (over == null ? void 0 : over.id) && collisions.length > 1) {
|
||||
closestId = collisions[1].id;
|
||||
}
|
||||
if (closestId != null) {
|
||||
const activeDroppable = droppableContainers.get(active.id);
|
||||
const newDroppable = droppableContainers.get(closestId);
|
||||
const newRect = newDroppable ? droppableRects.get(newDroppable.id) : null;
|
||||
const newNode = newDroppable == null ? void 0 : newDroppable.node.current;
|
||||
if (newNode && newRect && activeDroppable && newDroppable) {
|
||||
const newScrollAncestors = getScrollableAncestors(newNode);
|
||||
const hasDifferentScrollAncestors = newScrollAncestors.some((element, index) => scrollableAncestors[index] !== element);
|
||||
const hasSameContainer = isSameContainer(activeDroppable, newDroppable);
|
||||
const isAfterActive = isAfter(activeDroppable, newDroppable);
|
||||
const offset = hasDifferentScrollAncestors || !hasSameContainer ? {
|
||||
x: 0,
|
||||
y: 0
|
||||
} : {
|
||||
x: isAfterActive ? collisionRect.width - newRect.width : 0,
|
||||
y: isAfterActive ? collisionRect.height - newRect.height : 0
|
||||
};
|
||||
const rectCoordinates = {
|
||||
x: newRect.left,
|
||||
y: newRect.top
|
||||
};
|
||||
const newCoordinates = offset.x && offset.y ? rectCoordinates : subtract(rectCoordinates, offset);
|
||||
return newCoordinates;
|
||||
}
|
||||
}
|
||||
}
|
||||
return void 0;
|
||||
};
|
||||
function isSameContainer(a, b) {
|
||||
if (!hasSortableData(a) || !hasSortableData(b)) {
|
||||
return false;
|
||||
}
|
||||
return a.data.current.sortable.containerId === b.data.current.sortable.containerId;
|
||||
}
|
||||
function isAfter(a, b) {
|
||||
if (!hasSortableData(a) || !hasSortableData(b)) {
|
||||
return false;
|
||||
}
|
||||
if (!isSameContainer(a, b)) {
|
||||
return false;
|
||||
}
|
||||
return a.data.current.sortable.index < b.data.current.sortable.index;
|
||||
}
|
||||
export {
|
||||
SortableContext,
|
||||
arrayMove,
|
||||
arraySwap,
|
||||
defaultAnimateLayoutChanges,
|
||||
defaultNewIndexGetter,
|
||||
hasSortableData,
|
||||
horizontalListSortingStrategy,
|
||||
rectSortingStrategy,
|
||||
rectSwappingStrategy,
|
||||
sortableKeyboardCoordinates,
|
||||
useSortable,
|
||||
verticalListSortingStrategy
|
||||
};
|
||||
//# sourceMappingURL=@dnd-kit_sortable.js.map
|
||||
Reference in New Issue
Block a user