926 lines
29 KiB
JavaScript
926 lines
29 KiB
JavaScript
import {
|
|
__export
|
|
} from "./chunk-PLDDJCW6.js";
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/utils/js_utils.js
|
|
function memoize(fn) {
|
|
let result = null;
|
|
const memoized = () => {
|
|
if (result == null) {
|
|
result = fn();
|
|
}
|
|
return result;
|
|
};
|
|
return memoized;
|
|
}
|
|
function without(items, item) {
|
|
return items.filter(
|
|
(i) => i !== item
|
|
);
|
|
}
|
|
function union(itemsA, itemsB) {
|
|
const set = /* @__PURE__ */ new Set();
|
|
const insertItem = (item) => set.add(item);
|
|
itemsA.forEach(insertItem);
|
|
itemsB.forEach(insertItem);
|
|
const result = [];
|
|
set.forEach(
|
|
(key) => result.push(key)
|
|
);
|
|
return result;
|
|
}
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/EnterLeaveCounter.js
|
|
var EnterLeaveCounter = class {
|
|
enter(enteringNode) {
|
|
const previousLength = this.entered.length;
|
|
const isNodeEntered = (node) => this.isNodeInDocument(node) && (!node.contains || node.contains(enteringNode));
|
|
this.entered = union(this.entered.filter(isNodeEntered), [
|
|
enteringNode
|
|
]);
|
|
return previousLength === 0 && this.entered.length > 0;
|
|
}
|
|
leave(leavingNode) {
|
|
const previousLength = this.entered.length;
|
|
this.entered = without(this.entered.filter(this.isNodeInDocument), leavingNode);
|
|
return previousLength > 0 && this.entered.length === 0;
|
|
}
|
|
reset() {
|
|
this.entered = [];
|
|
}
|
|
constructor(isNodeInDocument) {
|
|
this.entered = [];
|
|
this.isNodeInDocument = isNodeInDocument;
|
|
}
|
|
};
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/NativeDragSources/NativeDragSource.js
|
|
var NativeDragSource = class {
|
|
initializeExposedProperties() {
|
|
Object.keys(this.config.exposeProperties).forEach((property) => {
|
|
Object.defineProperty(this.item, property, {
|
|
configurable: true,
|
|
enumerable: true,
|
|
get() {
|
|
console.warn(`Browser doesn't allow reading "${property}" until the drop event.`);
|
|
return null;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
loadDataTransfer(dataTransfer) {
|
|
if (dataTransfer) {
|
|
const newProperties = {};
|
|
Object.keys(this.config.exposeProperties).forEach((property) => {
|
|
const propertyFn = this.config.exposeProperties[property];
|
|
if (propertyFn != null) {
|
|
newProperties[property] = {
|
|
value: propertyFn(dataTransfer, this.config.matchesTypes),
|
|
configurable: true,
|
|
enumerable: true
|
|
};
|
|
}
|
|
});
|
|
Object.defineProperties(this.item, newProperties);
|
|
}
|
|
}
|
|
canDrag() {
|
|
return true;
|
|
}
|
|
beginDrag() {
|
|
return this.item;
|
|
}
|
|
isDragging(monitor, handle) {
|
|
return handle === monitor.getSourceId();
|
|
}
|
|
endDrag() {
|
|
}
|
|
constructor(config) {
|
|
this.config = config;
|
|
this.item = {};
|
|
this.initializeExposedProperties();
|
|
}
|
|
};
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/NativeTypes.js
|
|
var NativeTypes_exports = {};
|
|
__export(NativeTypes_exports, {
|
|
FILE: () => FILE,
|
|
HTML: () => HTML,
|
|
TEXT: () => TEXT,
|
|
URL: () => URL
|
|
});
|
|
var FILE = "__NATIVE_FILE__";
|
|
var URL = "__NATIVE_URL__";
|
|
var TEXT = "__NATIVE_TEXT__";
|
|
var HTML = "__NATIVE_HTML__";
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/NativeDragSources/getDataFromDataTransfer.js
|
|
function getDataFromDataTransfer(dataTransfer, typesToTry, defaultValue) {
|
|
const result = typesToTry.reduce(
|
|
(resultSoFar, typeToTry) => resultSoFar || dataTransfer.getData(typeToTry),
|
|
""
|
|
);
|
|
return result != null ? result : defaultValue;
|
|
}
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/NativeDragSources/nativeTypesConfig.js
|
|
var nativeTypesConfig = {
|
|
[FILE]: {
|
|
exposeProperties: {
|
|
files: (dataTransfer) => Array.prototype.slice.call(dataTransfer.files),
|
|
items: (dataTransfer) => dataTransfer.items,
|
|
dataTransfer: (dataTransfer) => dataTransfer
|
|
},
|
|
matchesTypes: [
|
|
"Files"
|
|
]
|
|
},
|
|
[HTML]: {
|
|
exposeProperties: {
|
|
html: (dataTransfer, matchesTypes) => getDataFromDataTransfer(dataTransfer, matchesTypes, ""),
|
|
dataTransfer: (dataTransfer) => dataTransfer
|
|
},
|
|
matchesTypes: [
|
|
"Html",
|
|
"text/html"
|
|
]
|
|
},
|
|
[URL]: {
|
|
exposeProperties: {
|
|
urls: (dataTransfer, matchesTypes) => getDataFromDataTransfer(dataTransfer, matchesTypes, "").split("\n"),
|
|
dataTransfer: (dataTransfer) => dataTransfer
|
|
},
|
|
matchesTypes: [
|
|
"Url",
|
|
"text/uri-list"
|
|
]
|
|
},
|
|
[TEXT]: {
|
|
exposeProperties: {
|
|
text: (dataTransfer, matchesTypes) => getDataFromDataTransfer(dataTransfer, matchesTypes, ""),
|
|
dataTransfer: (dataTransfer) => dataTransfer
|
|
},
|
|
matchesTypes: [
|
|
"Text",
|
|
"text/plain"
|
|
]
|
|
}
|
|
};
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/NativeDragSources/index.js
|
|
function createNativeDragSource(type, dataTransfer) {
|
|
const config = nativeTypesConfig[type];
|
|
if (!config) {
|
|
throw new Error(`native type ${type} has no configuration`);
|
|
}
|
|
const result = new NativeDragSource(config);
|
|
result.loadDataTransfer(dataTransfer);
|
|
return result;
|
|
}
|
|
function matchNativeItemType(dataTransfer) {
|
|
if (!dataTransfer) {
|
|
return null;
|
|
}
|
|
const dataTransferTypes = Array.prototype.slice.call(dataTransfer.types || []);
|
|
return Object.keys(nativeTypesConfig).filter((nativeItemType) => {
|
|
const typeConfig = nativeTypesConfig[nativeItemType];
|
|
if (!(typeConfig === null || typeConfig === void 0 ? void 0 : typeConfig.matchesTypes)) {
|
|
return false;
|
|
}
|
|
return typeConfig.matchesTypes.some(
|
|
(t) => dataTransferTypes.indexOf(t) > -1
|
|
);
|
|
})[0] || null;
|
|
}
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/BrowserDetector.js
|
|
var isFirefox = memoize(
|
|
() => /firefox/i.test(navigator.userAgent)
|
|
);
|
|
var isSafari = memoize(
|
|
() => Boolean(window.safari)
|
|
);
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/MonotonicInterpolant.js
|
|
var MonotonicInterpolant = class {
|
|
interpolate(x) {
|
|
const { xs, ys, c1s, c2s, c3s } = this;
|
|
let i = xs.length - 1;
|
|
if (x === xs[i]) {
|
|
return ys[i];
|
|
}
|
|
let low = 0;
|
|
let high = c3s.length - 1;
|
|
let mid;
|
|
while (low <= high) {
|
|
mid = Math.floor(0.5 * (low + high));
|
|
const xHere = xs[mid];
|
|
if (xHere < x) {
|
|
low = mid + 1;
|
|
} else if (xHere > x) {
|
|
high = mid - 1;
|
|
} else {
|
|
return ys[mid];
|
|
}
|
|
}
|
|
i = Math.max(0, high);
|
|
const diff = x - xs[i];
|
|
const diffSq = diff * diff;
|
|
return ys[i] + c1s[i] * diff + c2s[i] * diffSq + c3s[i] * diff * diffSq;
|
|
}
|
|
constructor(xs, ys) {
|
|
const { length } = xs;
|
|
const indexes = [];
|
|
for (let i = 0; i < length; i++) {
|
|
indexes.push(i);
|
|
}
|
|
indexes.sort(
|
|
(a, b) => xs[a] < xs[b] ? -1 : 1
|
|
);
|
|
const dys = [];
|
|
const dxs = [];
|
|
const ms = [];
|
|
let dx;
|
|
let dy;
|
|
for (let i1 = 0; i1 < length - 1; i1++) {
|
|
dx = xs[i1 + 1] - xs[i1];
|
|
dy = ys[i1 + 1] - ys[i1];
|
|
dxs.push(dx);
|
|
dys.push(dy);
|
|
ms.push(dy / dx);
|
|
}
|
|
const c1s = [
|
|
ms[0]
|
|
];
|
|
for (let i2 = 0; i2 < dxs.length - 1; i2++) {
|
|
const m2 = ms[i2];
|
|
const mNext = ms[i2 + 1];
|
|
if (m2 * mNext <= 0) {
|
|
c1s.push(0);
|
|
} else {
|
|
dx = dxs[i2];
|
|
const dxNext = dxs[i2 + 1];
|
|
const common = dx + dxNext;
|
|
c1s.push(3 * common / ((common + dxNext) / m2 + (common + dx) / mNext));
|
|
}
|
|
}
|
|
c1s.push(ms[ms.length - 1]);
|
|
const c2s = [];
|
|
const c3s = [];
|
|
let m;
|
|
for (let i3 = 0; i3 < c1s.length - 1; i3++) {
|
|
m = ms[i3];
|
|
const c1 = c1s[i3];
|
|
const invDx = 1 / dxs[i3];
|
|
const common = c1 + c1s[i3 + 1] - m - m;
|
|
c2s.push((m - c1 - common) * invDx);
|
|
c3s.push(common * invDx * invDx);
|
|
}
|
|
this.xs = xs;
|
|
this.ys = ys;
|
|
this.c1s = c1s;
|
|
this.c2s = c2s;
|
|
this.c3s = c3s;
|
|
}
|
|
};
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/OffsetUtils.js
|
|
var ELEMENT_NODE = 1;
|
|
function getNodeClientOffset(node) {
|
|
const el = node.nodeType === ELEMENT_NODE ? node : node.parentElement;
|
|
if (!el) {
|
|
return null;
|
|
}
|
|
const { top, left } = el.getBoundingClientRect();
|
|
return {
|
|
x: left,
|
|
y: top
|
|
};
|
|
}
|
|
function getEventClientOffset(e) {
|
|
return {
|
|
x: e.clientX,
|
|
y: e.clientY
|
|
};
|
|
}
|
|
function isImageNode(node) {
|
|
var ref;
|
|
return node.nodeName === "IMG" && (isFirefox() || !((ref = document.documentElement) === null || ref === void 0 ? void 0 : ref.contains(node)));
|
|
}
|
|
function getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight) {
|
|
let dragPreviewWidth = isImage ? dragPreview.width : sourceWidth;
|
|
let dragPreviewHeight = isImage ? dragPreview.height : sourceHeight;
|
|
if (isSafari() && isImage) {
|
|
dragPreviewHeight /= window.devicePixelRatio;
|
|
dragPreviewWidth /= window.devicePixelRatio;
|
|
}
|
|
return {
|
|
dragPreviewWidth,
|
|
dragPreviewHeight
|
|
};
|
|
}
|
|
function getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint, offsetPoint) {
|
|
const isImage = isImageNode(dragPreview);
|
|
const dragPreviewNode = isImage ? sourceNode : dragPreview;
|
|
const dragPreviewNodeOffsetFromClient = getNodeClientOffset(dragPreviewNode);
|
|
const offsetFromDragPreview = {
|
|
x: clientOffset.x - dragPreviewNodeOffsetFromClient.x,
|
|
y: clientOffset.y - dragPreviewNodeOffsetFromClient.y
|
|
};
|
|
const { offsetWidth: sourceWidth, offsetHeight: sourceHeight } = sourceNode;
|
|
const { anchorX, anchorY } = anchorPoint;
|
|
const { dragPreviewWidth, dragPreviewHeight } = getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight);
|
|
const calculateYOffset = () => {
|
|
const interpolantY = new MonotonicInterpolant([
|
|
0,
|
|
0.5,
|
|
1
|
|
], [
|
|
// Dock to the top
|
|
offsetFromDragPreview.y,
|
|
// Align at the center
|
|
offsetFromDragPreview.y / sourceHeight * dragPreviewHeight,
|
|
// Dock to the bottom
|
|
offsetFromDragPreview.y + dragPreviewHeight - sourceHeight
|
|
]);
|
|
let y = interpolantY.interpolate(anchorY);
|
|
if (isSafari() && isImage) {
|
|
y += (window.devicePixelRatio - 1) * dragPreviewHeight;
|
|
}
|
|
return y;
|
|
};
|
|
const calculateXOffset = () => {
|
|
const interpolantX = new MonotonicInterpolant([
|
|
0,
|
|
0.5,
|
|
1
|
|
], [
|
|
// Dock to the left
|
|
offsetFromDragPreview.x,
|
|
// Align at the center
|
|
offsetFromDragPreview.x / sourceWidth * dragPreviewWidth,
|
|
// Dock to the right
|
|
offsetFromDragPreview.x + dragPreviewWidth - sourceWidth
|
|
]);
|
|
return interpolantX.interpolate(anchorX);
|
|
};
|
|
const { offsetX, offsetY } = offsetPoint;
|
|
const isManualOffsetX = offsetX === 0 || offsetX;
|
|
const isManualOffsetY = offsetY === 0 || offsetY;
|
|
return {
|
|
x: isManualOffsetX ? offsetX : calculateXOffset(),
|
|
y: isManualOffsetY ? offsetY : calculateYOffset()
|
|
};
|
|
}
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/OptionsReader.js
|
|
var OptionsReader = class {
|
|
get window() {
|
|
if (this.globalContext) {
|
|
return this.globalContext;
|
|
} else if (typeof window !== "undefined") {
|
|
return window;
|
|
}
|
|
return void 0;
|
|
}
|
|
get document() {
|
|
var ref;
|
|
if ((ref = this.globalContext) === null || ref === void 0 ? void 0 : ref.document) {
|
|
return this.globalContext.document;
|
|
} else if (this.window) {
|
|
return this.window.document;
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
get rootElement() {
|
|
var ref;
|
|
return ((ref = this.optionsArgs) === null || ref === void 0 ? void 0 : ref.rootElement) || this.window;
|
|
}
|
|
constructor(globalContext, options) {
|
|
this.ownerDocument = null;
|
|
this.globalContext = globalContext;
|
|
this.optionsArgs = options;
|
|
}
|
|
};
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/HTML5BackendImpl.js
|
|
function _defineProperty(obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
function _objectSpread(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i] != null ? arguments[i] : {};
|
|
var ownKeys = Object.keys(source);
|
|
if (typeof Object.getOwnPropertySymbols === "function") {
|
|
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
|
|
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
|
|
}));
|
|
}
|
|
ownKeys.forEach(function(key) {
|
|
_defineProperty(target, key, source[key]);
|
|
});
|
|
}
|
|
return target;
|
|
}
|
|
var HTML5BackendImpl = class {
|
|
/**
|
|
* Generate profiling statistics for the HTML5Backend.
|
|
*/
|
|
profile() {
|
|
var ref, ref1;
|
|
return {
|
|
sourcePreviewNodes: this.sourcePreviewNodes.size,
|
|
sourcePreviewNodeOptions: this.sourcePreviewNodeOptions.size,
|
|
sourceNodeOptions: this.sourceNodeOptions.size,
|
|
sourceNodes: this.sourceNodes.size,
|
|
dragStartSourceIds: ((ref = this.dragStartSourceIds) === null || ref === void 0 ? void 0 : ref.length) || 0,
|
|
dropTargetIds: this.dropTargetIds.length,
|
|
dragEnterTargetIds: this.dragEnterTargetIds.length,
|
|
dragOverTargetIds: ((ref1 = this.dragOverTargetIds) === null || ref1 === void 0 ? void 0 : ref1.length) || 0
|
|
};
|
|
}
|
|
// public for test
|
|
get window() {
|
|
return this.options.window;
|
|
}
|
|
get document() {
|
|
return this.options.document;
|
|
}
|
|
/**
|
|
* Get the root element to use for event subscriptions
|
|
*/
|
|
get rootElement() {
|
|
return this.options.rootElement;
|
|
}
|
|
setup() {
|
|
const root = this.rootElement;
|
|
if (root === void 0) {
|
|
return;
|
|
}
|
|
if (root.__isReactDndBackendSetUp) {
|
|
throw new Error("Cannot have two HTML5 backends at the same time.");
|
|
}
|
|
root.__isReactDndBackendSetUp = true;
|
|
this.addEventListeners(root);
|
|
}
|
|
teardown() {
|
|
const root = this.rootElement;
|
|
if (root === void 0) {
|
|
return;
|
|
}
|
|
root.__isReactDndBackendSetUp = false;
|
|
this.removeEventListeners(this.rootElement);
|
|
this.clearCurrentDragSourceNode();
|
|
if (this.asyncEndDragFrameId) {
|
|
var ref;
|
|
(ref = this.window) === null || ref === void 0 ? void 0 : ref.cancelAnimationFrame(this.asyncEndDragFrameId);
|
|
}
|
|
}
|
|
connectDragPreview(sourceId, node, options) {
|
|
this.sourcePreviewNodeOptions.set(sourceId, options);
|
|
this.sourcePreviewNodes.set(sourceId, node);
|
|
return () => {
|
|
this.sourcePreviewNodes.delete(sourceId);
|
|
this.sourcePreviewNodeOptions.delete(sourceId);
|
|
};
|
|
}
|
|
connectDragSource(sourceId, node, options) {
|
|
this.sourceNodes.set(sourceId, node);
|
|
this.sourceNodeOptions.set(sourceId, options);
|
|
const handleDragStart = (e) => this.handleDragStart(e, sourceId);
|
|
const handleSelectStart = (e) => this.handleSelectStart(e);
|
|
node.setAttribute("draggable", "true");
|
|
node.addEventListener("dragstart", handleDragStart);
|
|
node.addEventListener("selectstart", handleSelectStart);
|
|
return () => {
|
|
this.sourceNodes.delete(sourceId);
|
|
this.sourceNodeOptions.delete(sourceId);
|
|
node.removeEventListener("dragstart", handleDragStart);
|
|
node.removeEventListener("selectstart", handleSelectStart);
|
|
node.setAttribute("draggable", "false");
|
|
};
|
|
}
|
|
connectDropTarget(targetId, node) {
|
|
const handleDragEnter = (e) => this.handleDragEnter(e, targetId);
|
|
const handleDragOver = (e) => this.handleDragOver(e, targetId);
|
|
const handleDrop = (e) => this.handleDrop(e, targetId);
|
|
node.addEventListener("dragenter", handleDragEnter);
|
|
node.addEventListener("dragover", handleDragOver);
|
|
node.addEventListener("drop", handleDrop);
|
|
return () => {
|
|
node.removeEventListener("dragenter", handleDragEnter);
|
|
node.removeEventListener("dragover", handleDragOver);
|
|
node.removeEventListener("drop", handleDrop);
|
|
};
|
|
}
|
|
addEventListeners(target) {
|
|
if (!target.addEventListener) {
|
|
return;
|
|
}
|
|
target.addEventListener("dragstart", this.handleTopDragStart);
|
|
target.addEventListener("dragstart", this.handleTopDragStartCapture, true);
|
|
target.addEventListener("dragend", this.handleTopDragEndCapture, true);
|
|
target.addEventListener("dragenter", this.handleTopDragEnter);
|
|
target.addEventListener("dragenter", this.handleTopDragEnterCapture, true);
|
|
target.addEventListener("dragleave", this.handleTopDragLeaveCapture, true);
|
|
target.addEventListener("dragover", this.handleTopDragOver);
|
|
target.addEventListener("dragover", this.handleTopDragOverCapture, true);
|
|
target.addEventListener("drop", this.handleTopDrop);
|
|
target.addEventListener("drop", this.handleTopDropCapture, true);
|
|
}
|
|
removeEventListeners(target) {
|
|
if (!target.removeEventListener) {
|
|
return;
|
|
}
|
|
target.removeEventListener("dragstart", this.handleTopDragStart);
|
|
target.removeEventListener("dragstart", this.handleTopDragStartCapture, true);
|
|
target.removeEventListener("dragend", this.handleTopDragEndCapture, true);
|
|
target.removeEventListener("dragenter", this.handleTopDragEnter);
|
|
target.removeEventListener("dragenter", this.handleTopDragEnterCapture, true);
|
|
target.removeEventListener("dragleave", this.handleTopDragLeaveCapture, true);
|
|
target.removeEventListener("dragover", this.handleTopDragOver);
|
|
target.removeEventListener("dragover", this.handleTopDragOverCapture, true);
|
|
target.removeEventListener("drop", this.handleTopDrop);
|
|
target.removeEventListener("drop", this.handleTopDropCapture, true);
|
|
}
|
|
getCurrentSourceNodeOptions() {
|
|
const sourceId = this.monitor.getSourceId();
|
|
const sourceNodeOptions = this.sourceNodeOptions.get(sourceId);
|
|
return _objectSpread({
|
|
dropEffect: this.altKeyPressed ? "copy" : "move"
|
|
}, sourceNodeOptions || {});
|
|
}
|
|
getCurrentDropEffect() {
|
|
if (this.isDraggingNativeItem()) {
|
|
return "copy";
|
|
}
|
|
return this.getCurrentSourceNodeOptions().dropEffect;
|
|
}
|
|
getCurrentSourcePreviewNodeOptions() {
|
|
const sourceId = this.monitor.getSourceId();
|
|
const sourcePreviewNodeOptions = this.sourcePreviewNodeOptions.get(sourceId);
|
|
return _objectSpread({
|
|
anchorX: 0.5,
|
|
anchorY: 0.5,
|
|
captureDraggingState: false
|
|
}, sourcePreviewNodeOptions || {});
|
|
}
|
|
isDraggingNativeItem() {
|
|
const itemType = this.monitor.getItemType();
|
|
return Object.keys(NativeTypes_exports).some(
|
|
(key) => NativeTypes_exports[key] === itemType
|
|
);
|
|
}
|
|
beginDragNativeItem(type, dataTransfer) {
|
|
this.clearCurrentDragSourceNode();
|
|
this.currentNativeSource = createNativeDragSource(type, dataTransfer);
|
|
this.currentNativeHandle = this.registry.addSource(type, this.currentNativeSource);
|
|
this.actions.beginDrag([
|
|
this.currentNativeHandle
|
|
]);
|
|
}
|
|
setCurrentDragSourceNode(node) {
|
|
this.clearCurrentDragSourceNode();
|
|
this.currentDragSourceNode = node;
|
|
const MOUSE_MOVE_TIMEOUT = 1e3;
|
|
this.mouseMoveTimeoutTimer = setTimeout(() => {
|
|
var ref;
|
|
return (ref = this.rootElement) === null || ref === void 0 ? void 0 : ref.addEventListener("mousemove", this.endDragIfSourceWasRemovedFromDOM, true);
|
|
}, MOUSE_MOVE_TIMEOUT);
|
|
}
|
|
clearCurrentDragSourceNode() {
|
|
if (this.currentDragSourceNode) {
|
|
this.currentDragSourceNode = null;
|
|
if (this.rootElement) {
|
|
var ref;
|
|
(ref = this.window) === null || ref === void 0 ? void 0 : ref.clearTimeout(this.mouseMoveTimeoutTimer || void 0);
|
|
this.rootElement.removeEventListener("mousemove", this.endDragIfSourceWasRemovedFromDOM, true);
|
|
}
|
|
this.mouseMoveTimeoutTimer = null;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
handleDragStart(e, sourceId) {
|
|
if (e.defaultPrevented) {
|
|
return;
|
|
}
|
|
if (!this.dragStartSourceIds) {
|
|
this.dragStartSourceIds = [];
|
|
}
|
|
this.dragStartSourceIds.unshift(sourceId);
|
|
}
|
|
handleDragEnter(_e, targetId) {
|
|
this.dragEnterTargetIds.unshift(targetId);
|
|
}
|
|
handleDragOver(_e, targetId) {
|
|
if (this.dragOverTargetIds === null) {
|
|
this.dragOverTargetIds = [];
|
|
}
|
|
this.dragOverTargetIds.unshift(targetId);
|
|
}
|
|
handleDrop(_e, targetId) {
|
|
this.dropTargetIds.unshift(targetId);
|
|
}
|
|
constructor(manager, globalContext, options) {
|
|
this.sourcePreviewNodes = /* @__PURE__ */ new Map();
|
|
this.sourcePreviewNodeOptions = /* @__PURE__ */ new Map();
|
|
this.sourceNodes = /* @__PURE__ */ new Map();
|
|
this.sourceNodeOptions = /* @__PURE__ */ new Map();
|
|
this.dragStartSourceIds = null;
|
|
this.dropTargetIds = [];
|
|
this.dragEnterTargetIds = [];
|
|
this.currentNativeSource = null;
|
|
this.currentNativeHandle = null;
|
|
this.currentDragSourceNode = null;
|
|
this.altKeyPressed = false;
|
|
this.mouseMoveTimeoutTimer = null;
|
|
this.asyncEndDragFrameId = null;
|
|
this.dragOverTargetIds = null;
|
|
this.lastClientOffset = null;
|
|
this.hoverRafId = null;
|
|
this.getSourceClientOffset = (sourceId) => {
|
|
const source = this.sourceNodes.get(sourceId);
|
|
return source && getNodeClientOffset(source) || null;
|
|
};
|
|
this.endDragNativeItem = () => {
|
|
if (!this.isDraggingNativeItem()) {
|
|
return;
|
|
}
|
|
this.actions.endDrag();
|
|
if (this.currentNativeHandle) {
|
|
this.registry.removeSource(this.currentNativeHandle);
|
|
}
|
|
this.currentNativeHandle = null;
|
|
this.currentNativeSource = null;
|
|
};
|
|
this.isNodeInDocument = (node) => {
|
|
return Boolean(node && this.document && this.document.body && this.document.body.contains(node));
|
|
};
|
|
this.endDragIfSourceWasRemovedFromDOM = () => {
|
|
const node = this.currentDragSourceNode;
|
|
if (node == null || this.isNodeInDocument(node)) {
|
|
return;
|
|
}
|
|
if (this.clearCurrentDragSourceNode() && this.monitor.isDragging()) {
|
|
this.actions.endDrag();
|
|
}
|
|
this.cancelHover();
|
|
};
|
|
this.scheduleHover = (dragOverTargetIds) => {
|
|
if (this.hoverRafId === null && typeof requestAnimationFrame !== "undefined") {
|
|
this.hoverRafId = requestAnimationFrame(() => {
|
|
if (this.monitor.isDragging()) {
|
|
this.actions.hover(dragOverTargetIds || [], {
|
|
clientOffset: this.lastClientOffset
|
|
});
|
|
}
|
|
this.hoverRafId = null;
|
|
});
|
|
}
|
|
};
|
|
this.cancelHover = () => {
|
|
if (this.hoverRafId !== null && typeof cancelAnimationFrame !== "undefined") {
|
|
cancelAnimationFrame(this.hoverRafId);
|
|
this.hoverRafId = null;
|
|
}
|
|
};
|
|
this.handleTopDragStartCapture = () => {
|
|
this.clearCurrentDragSourceNode();
|
|
this.dragStartSourceIds = [];
|
|
};
|
|
this.handleTopDragStart = (e) => {
|
|
if (e.defaultPrevented) {
|
|
return;
|
|
}
|
|
const { dragStartSourceIds } = this;
|
|
this.dragStartSourceIds = null;
|
|
const clientOffset = getEventClientOffset(e);
|
|
if (this.monitor.isDragging()) {
|
|
this.actions.endDrag();
|
|
this.cancelHover();
|
|
}
|
|
this.actions.beginDrag(dragStartSourceIds || [], {
|
|
publishSource: false,
|
|
getSourceClientOffset: this.getSourceClientOffset,
|
|
clientOffset
|
|
});
|
|
const { dataTransfer } = e;
|
|
const nativeType = matchNativeItemType(dataTransfer);
|
|
if (this.monitor.isDragging()) {
|
|
if (dataTransfer && typeof dataTransfer.setDragImage === "function") {
|
|
const sourceId = this.monitor.getSourceId();
|
|
const sourceNode = this.sourceNodes.get(sourceId);
|
|
const dragPreview = this.sourcePreviewNodes.get(sourceId) || sourceNode;
|
|
if (dragPreview) {
|
|
const { anchorX, anchorY, offsetX, offsetY } = this.getCurrentSourcePreviewNodeOptions();
|
|
const anchorPoint = {
|
|
anchorX,
|
|
anchorY
|
|
};
|
|
const offsetPoint = {
|
|
offsetX,
|
|
offsetY
|
|
};
|
|
const dragPreviewOffset = getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint, offsetPoint);
|
|
dataTransfer.setDragImage(dragPreview, dragPreviewOffset.x, dragPreviewOffset.y);
|
|
}
|
|
}
|
|
try {
|
|
dataTransfer === null || dataTransfer === void 0 ? void 0 : dataTransfer.setData("application/json", {});
|
|
} catch (err) {
|
|
}
|
|
this.setCurrentDragSourceNode(e.target);
|
|
const { captureDraggingState } = this.getCurrentSourcePreviewNodeOptions();
|
|
if (!captureDraggingState) {
|
|
setTimeout(
|
|
() => this.actions.publishDragSource(),
|
|
0
|
|
);
|
|
} else {
|
|
this.actions.publishDragSource();
|
|
}
|
|
} else if (nativeType) {
|
|
this.beginDragNativeItem(nativeType);
|
|
} else if (dataTransfer && !dataTransfer.types && (e.target && !e.target.hasAttribute || !e.target.hasAttribute("draggable"))) {
|
|
return;
|
|
} else {
|
|
e.preventDefault();
|
|
}
|
|
};
|
|
this.handleTopDragEndCapture = () => {
|
|
if (this.clearCurrentDragSourceNode() && this.monitor.isDragging()) {
|
|
this.actions.endDrag();
|
|
}
|
|
this.cancelHover();
|
|
};
|
|
this.handleTopDragEnterCapture = (e) => {
|
|
this.dragEnterTargetIds = [];
|
|
if (this.isDraggingNativeItem()) {
|
|
var ref;
|
|
(ref = this.currentNativeSource) === null || ref === void 0 ? void 0 : ref.loadDataTransfer(e.dataTransfer);
|
|
}
|
|
const isFirstEnter = this.enterLeaveCounter.enter(e.target);
|
|
if (!isFirstEnter || this.monitor.isDragging()) {
|
|
return;
|
|
}
|
|
const { dataTransfer } = e;
|
|
const nativeType = matchNativeItemType(dataTransfer);
|
|
if (nativeType) {
|
|
this.beginDragNativeItem(nativeType, dataTransfer);
|
|
}
|
|
};
|
|
this.handleTopDragEnter = (e) => {
|
|
const { dragEnterTargetIds } = this;
|
|
this.dragEnterTargetIds = [];
|
|
if (!this.monitor.isDragging()) {
|
|
return;
|
|
}
|
|
this.altKeyPressed = e.altKey;
|
|
if (dragEnterTargetIds.length > 0) {
|
|
this.actions.hover(dragEnterTargetIds, {
|
|
clientOffset: getEventClientOffset(e)
|
|
});
|
|
}
|
|
const canDrop = dragEnterTargetIds.some(
|
|
(targetId) => this.monitor.canDropOnTarget(targetId)
|
|
);
|
|
if (canDrop) {
|
|
e.preventDefault();
|
|
if (e.dataTransfer) {
|
|
e.dataTransfer.dropEffect = this.getCurrentDropEffect();
|
|
}
|
|
}
|
|
};
|
|
this.handleTopDragOverCapture = (e) => {
|
|
this.dragOverTargetIds = [];
|
|
if (this.isDraggingNativeItem()) {
|
|
var ref;
|
|
(ref = this.currentNativeSource) === null || ref === void 0 ? void 0 : ref.loadDataTransfer(e.dataTransfer);
|
|
}
|
|
};
|
|
this.handleTopDragOver = (e) => {
|
|
const { dragOverTargetIds } = this;
|
|
this.dragOverTargetIds = [];
|
|
if (!this.monitor.isDragging()) {
|
|
e.preventDefault();
|
|
if (e.dataTransfer) {
|
|
e.dataTransfer.dropEffect = "none";
|
|
}
|
|
return;
|
|
}
|
|
this.altKeyPressed = e.altKey;
|
|
this.lastClientOffset = getEventClientOffset(e);
|
|
this.scheduleHover(dragOverTargetIds);
|
|
const canDrop = (dragOverTargetIds || []).some(
|
|
(targetId) => this.monitor.canDropOnTarget(targetId)
|
|
);
|
|
if (canDrop) {
|
|
e.preventDefault();
|
|
if (e.dataTransfer) {
|
|
e.dataTransfer.dropEffect = this.getCurrentDropEffect();
|
|
}
|
|
} else if (this.isDraggingNativeItem()) {
|
|
e.preventDefault();
|
|
} else {
|
|
e.preventDefault();
|
|
if (e.dataTransfer) {
|
|
e.dataTransfer.dropEffect = "none";
|
|
}
|
|
}
|
|
};
|
|
this.handleTopDragLeaveCapture = (e) => {
|
|
if (this.isDraggingNativeItem()) {
|
|
e.preventDefault();
|
|
}
|
|
const isLastLeave = this.enterLeaveCounter.leave(e.target);
|
|
if (!isLastLeave) {
|
|
return;
|
|
}
|
|
if (this.isDraggingNativeItem()) {
|
|
setTimeout(
|
|
() => this.endDragNativeItem(),
|
|
0
|
|
);
|
|
}
|
|
this.cancelHover();
|
|
};
|
|
this.handleTopDropCapture = (e) => {
|
|
this.dropTargetIds = [];
|
|
if (this.isDraggingNativeItem()) {
|
|
var ref;
|
|
e.preventDefault();
|
|
(ref = this.currentNativeSource) === null || ref === void 0 ? void 0 : ref.loadDataTransfer(e.dataTransfer);
|
|
} else if (matchNativeItemType(e.dataTransfer)) {
|
|
e.preventDefault();
|
|
}
|
|
this.enterLeaveCounter.reset();
|
|
};
|
|
this.handleTopDrop = (e) => {
|
|
const { dropTargetIds } = this;
|
|
this.dropTargetIds = [];
|
|
this.actions.hover(dropTargetIds, {
|
|
clientOffset: getEventClientOffset(e)
|
|
});
|
|
this.actions.drop({
|
|
dropEffect: this.getCurrentDropEffect()
|
|
});
|
|
if (this.isDraggingNativeItem()) {
|
|
this.endDragNativeItem();
|
|
} else if (this.monitor.isDragging()) {
|
|
this.actions.endDrag();
|
|
}
|
|
this.cancelHover();
|
|
};
|
|
this.handleSelectStart = (e) => {
|
|
const target = e.target;
|
|
if (typeof target.dragDrop !== "function") {
|
|
return;
|
|
}
|
|
if (target.tagName === "INPUT" || target.tagName === "SELECT" || target.tagName === "TEXTAREA" || target.isContentEditable) {
|
|
return;
|
|
}
|
|
e.preventDefault();
|
|
target.dragDrop();
|
|
};
|
|
this.options = new OptionsReader(globalContext, options);
|
|
this.actions = manager.getActions();
|
|
this.monitor = manager.getMonitor();
|
|
this.registry = manager.getRegistry();
|
|
this.enterLeaveCounter = new EnterLeaveCounter(this.isNodeInDocument);
|
|
}
|
|
};
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/getEmptyImage.js
|
|
var emptyImage;
|
|
function getEmptyImage() {
|
|
if (!emptyImage) {
|
|
emptyImage = new Image();
|
|
emptyImage.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
|
|
}
|
|
return emptyImage;
|
|
}
|
|
|
|
// node_modules/react-dnd-html5-backend/dist/index.js
|
|
var HTML5Backend = function createBackend(manager, context, options) {
|
|
return new HTML5BackendImpl(manager, context, options);
|
|
};
|
|
|
|
export {
|
|
getEmptyImage,
|
|
HTML5Backend
|
|
};
|
|
//# sourceMappingURL=chunk-SYWYLB7I.js.map
|