mirror of
https://github.com/pure-admin/vue-pure-admin.git
synced 2025-06-06 00:18:51 +08:00
2608 lines
79 KiB
JavaScript
2608 lines
79 KiB
JavaScript
/*! Sortable 1.13.0 - MIT | git://github.com/SortableJS/Sortable.git */
|
|
!(function (t, e) {
|
|
"object" == typeof exports && "undefined" != typeof module
|
|
? (module.exports = e())
|
|
: "function" == typeof define && define.amd
|
|
? define(e)
|
|
: ((t = t || self).Sortable = e());
|
|
})(this, function () {
|
|
"use strict";
|
|
function o(t) {
|
|
return (o =
|
|
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
|
|
? function (t) {
|
|
return typeof t;
|
|
}
|
|
: function (t) {
|
|
return t &&
|
|
"function" == typeof Symbol &&
|
|
t.constructor === Symbol &&
|
|
t !== Symbol.prototype
|
|
? "symbol"
|
|
: typeof t;
|
|
})(t);
|
|
}
|
|
function a() {
|
|
return (a =
|
|
Object.assign ||
|
|
function (t) {
|
|
for (var e = 1; e < arguments.length; e++) {
|
|
var n = arguments[e];
|
|
for (var o in n)
|
|
Object.prototype.hasOwnProperty.call(n, o) && (t[o] = n[o]);
|
|
}
|
|
return t;
|
|
}).apply(this, arguments);
|
|
}
|
|
function I(i) {
|
|
for (var t = 1; t < arguments.length; t++) {
|
|
var r = null != arguments[t] ? arguments[t] : {},
|
|
e = Object.keys(r);
|
|
"function" == typeof Object.getOwnPropertySymbols &&
|
|
(e = e.concat(
|
|
Object.getOwnPropertySymbols(r).filter(function (t) {
|
|
return Object.getOwnPropertyDescriptor(r, t).enumerable;
|
|
})
|
|
)),
|
|
e.forEach(function (t) {
|
|
var e, n, o;
|
|
(e = i),
|
|
(o = r[(n = t)]),
|
|
n in e
|
|
? Object.defineProperty(e, n, {
|
|
value: o,
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
writable: !0
|
|
})
|
|
: (e[n] = o);
|
|
});
|
|
}
|
|
return i;
|
|
}
|
|
function l(t, e) {
|
|
if (null == t) return {};
|
|
var n,
|
|
o,
|
|
i = (function (t, e) {
|
|
if (null == t) return {};
|
|
var n,
|
|
o,
|
|
i = {},
|
|
r = Object.keys(t);
|
|
for (o = 0; o < r.length; o++)
|
|
(n = r[o]), 0 <= e.indexOf(n) || (i[n] = t[n]);
|
|
return i;
|
|
})(t, e);
|
|
if (Object.getOwnPropertySymbols) {
|
|
var r = Object.getOwnPropertySymbols(t);
|
|
for (o = 0; o < r.length; o++)
|
|
(n = r[o]),
|
|
0 <= e.indexOf(n) ||
|
|
(Object.prototype.propertyIsEnumerable.call(t, n) && (i[n] = t[n]));
|
|
}
|
|
return i;
|
|
}
|
|
function e(t) {
|
|
return (
|
|
(function (t) {
|
|
if (Array.isArray(t)) {
|
|
for (var e = 0, n = new Array(t.length); e < t.length; e++)
|
|
n[e] = t[e];
|
|
return n;
|
|
}
|
|
})(t) ||
|
|
(function (t) {
|
|
if (
|
|
Symbol.iterator in Object(t) ||
|
|
"[object Arguments]" === Object.prototype.toString.call(t)
|
|
)
|
|
return Array.from(t);
|
|
})(t) ||
|
|
(function () {
|
|
throw new TypeError("Invalid attempt to spread non-iterable instance");
|
|
})()
|
|
);
|
|
}
|
|
function t(t) {
|
|
if ("undefined" != typeof window && window.navigator)
|
|
return !!navigator.userAgent.match(t);
|
|
}
|
|
var w = t(/(?:Trident.*rv[ :]?11\.|msie|iemobile|Windows Phone)/i),
|
|
E = t(/Edge/i),
|
|
c = t(/firefox/i),
|
|
u = t(/safari/i) && !t(/chrome/i) && !t(/android/i),
|
|
n = t(/iP(ad|od|hone)/i),
|
|
i = t(/chrome/i) && t(/android/i),
|
|
r = { capture: !1, passive: !1 };
|
|
function d(t, e, n) {
|
|
t.addEventListener(e, n, !w && r);
|
|
}
|
|
function s(t, e, n) {
|
|
t.removeEventListener(e, n, !w && r);
|
|
}
|
|
function h(t, e) {
|
|
if (e) {
|
|
if ((">" === e[0] && (e = e.substring(1)), t))
|
|
try {
|
|
if (t.matches) return t.matches(e);
|
|
if (t.msMatchesSelector) return t.msMatchesSelector(e);
|
|
if (t.webkitMatchesSelector) return t.webkitMatchesSelector(e);
|
|
} catch (t) {
|
|
return !1;
|
|
}
|
|
return !1;
|
|
}
|
|
}
|
|
function P(t, e, n, o) {
|
|
if (t) {
|
|
n = n || document;
|
|
do {
|
|
if (
|
|
(null != e &&
|
|
(">" === e[0] ? t.parentNode === n && h(t, e) : h(t, e))) ||
|
|
(o && t === n)
|
|
)
|
|
return t;
|
|
if (t === n) break;
|
|
} while (
|
|
(t =
|
|
(i = t).host && i !== document && i.host.nodeType
|
|
? i.host
|
|
: i.parentNode)
|
|
);
|
|
}
|
|
var i;
|
|
return null;
|
|
}
|
|
var f,
|
|
p = /\s+/g;
|
|
function k(t, e, n) {
|
|
if (t && e)
|
|
if (t.classList) t.classList[n ? "add" : "remove"](e);
|
|
else {
|
|
var o = (" " + t.className + " ")
|
|
.replace(p, " ")
|
|
.replace(" " + e + " ", " ");
|
|
t.className = (o + (n ? " " + e : "")).replace(p, " ");
|
|
}
|
|
}
|
|
function R(t, e, n) {
|
|
var o = t && t.style;
|
|
if (o) {
|
|
if (void 0 === n)
|
|
return (
|
|
document.defaultView && document.defaultView.getComputedStyle
|
|
? (n = document.defaultView.getComputedStyle(t, ""))
|
|
: t.currentStyle && (n = t.currentStyle),
|
|
void 0 === e ? n : n[e]
|
|
);
|
|
e in o || -1 !== e.indexOf("webkit") || (e = "-webkit-" + e),
|
|
(o[e] = n + ("string" == typeof n ? "" : "px"));
|
|
}
|
|
}
|
|
function v(t, e) {
|
|
var n = "";
|
|
if ("string" == typeof t) n = t;
|
|
else
|
|
do {
|
|
var o = R(t, "transform");
|
|
o && "none" !== o && (n = o + " " + n);
|
|
} while (!e && (t = t.parentNode));
|
|
var i =
|
|
window.DOMMatrix ||
|
|
window.WebKitCSSMatrix ||
|
|
window.CSSMatrix ||
|
|
window.MSCSSMatrix;
|
|
return i && new i(n);
|
|
}
|
|
function g(t, e, n) {
|
|
if (t) {
|
|
var o = t.getElementsByTagName(e),
|
|
i = 0,
|
|
r = o.length;
|
|
if (n) for (; i < r; i++) n(o[i], i);
|
|
return o;
|
|
}
|
|
return [];
|
|
}
|
|
function A() {
|
|
var t = document.scrollingElement;
|
|
return t || document.documentElement;
|
|
}
|
|
function X(t, e, n, o, i) {
|
|
if (t.getBoundingClientRect || t === window) {
|
|
var r, a, l, s, c, u, d;
|
|
if (
|
|
((d =
|
|
t !== window && t.parentNode && t !== A()
|
|
? ((a = (r = t.getBoundingClientRect()).top),
|
|
(l = r.left),
|
|
(s = r.bottom),
|
|
(c = r.right),
|
|
(u = r.height),
|
|
r.width)
|
|
: ((l = a = 0),
|
|
(s = window.innerHeight),
|
|
(c = window.innerWidth),
|
|
(u = window.innerHeight),
|
|
window.innerWidth)),
|
|
(e || n) && t !== window && ((i = i || t.parentNode), !w))
|
|
)
|
|
do {
|
|
if (
|
|
i &&
|
|
i.getBoundingClientRect &&
|
|
("none" !== R(i, "transform") ||
|
|
(n && "static" !== R(i, "position")))
|
|
) {
|
|
var h = i.getBoundingClientRect();
|
|
(a -= h.top + parseInt(R(i, "border-top-width"))),
|
|
(l -= h.left + parseInt(R(i, "border-left-width"))),
|
|
(s = a + r.height),
|
|
(c = l + r.width);
|
|
break;
|
|
}
|
|
} while ((i = i.parentNode));
|
|
if (o && t !== window) {
|
|
var f = v(i || t),
|
|
p = f && f.a,
|
|
g = f && f.d;
|
|
f && ((s = (a /= g) + (u /= g)), (c = (l /= p) + (d /= p)));
|
|
}
|
|
return { top: a, left: l, bottom: s, right: c, width: d, height: u };
|
|
}
|
|
}
|
|
function Y(t, e, n) {
|
|
for (var o = H(t, !0), i = X(t)[e]; o; ) {
|
|
var r = X(o)[n];
|
|
if (!("top" === n || "left" === n ? r <= i : i <= r)) return o;
|
|
if (o === A()) break;
|
|
o = H(o, !1);
|
|
}
|
|
return !1;
|
|
}
|
|
function m(t, e, n) {
|
|
for (var o = 0, i = 0, r = t.children; i < r.length; ) {
|
|
if (
|
|
"none" !== r[i].style.display &&
|
|
r[i] !== Rt.ghost &&
|
|
r[i] !== Rt.dragged &&
|
|
P(r[i], n.draggable, t, !1)
|
|
) {
|
|
if (o === e) return r[i];
|
|
o++;
|
|
}
|
|
i++;
|
|
}
|
|
return null;
|
|
}
|
|
function B(t, e) {
|
|
for (
|
|
var n = t.lastElementChild;
|
|
n && (n === Rt.ghost || "none" === R(n, "display") || (e && !h(n, e)));
|
|
|
|
)
|
|
n = n.previousElementSibling;
|
|
return n || null;
|
|
}
|
|
function F(t, e) {
|
|
var n = 0;
|
|
if (!t || !t.parentNode) return -1;
|
|
for (; (t = t.previousElementSibling); )
|
|
"TEMPLATE" === t.nodeName.toUpperCase() ||
|
|
t === Rt.clone ||
|
|
(e && !h(t, e)) ||
|
|
n++;
|
|
return n;
|
|
}
|
|
function b(t) {
|
|
var e = 0,
|
|
n = 0,
|
|
o = A();
|
|
if (t)
|
|
do {
|
|
var i = v(t),
|
|
r = i.a,
|
|
a = i.d;
|
|
(e += t.scrollLeft * r), (n += t.scrollTop * a);
|
|
} while (t !== o && (t = t.parentNode));
|
|
return [e, n];
|
|
}
|
|
function H(t, e) {
|
|
if (!t || !t.getBoundingClientRect) return A();
|
|
var n = t,
|
|
o = !1;
|
|
do {
|
|
if (n.clientWidth < n.scrollWidth || n.clientHeight < n.scrollHeight) {
|
|
var i = R(n);
|
|
if (
|
|
(n.clientWidth < n.scrollWidth &&
|
|
("auto" == i.overflowX || "scroll" == i.overflowX)) ||
|
|
(n.clientHeight < n.scrollHeight &&
|
|
("auto" == i.overflowY || "scroll" == i.overflowY))
|
|
) {
|
|
if (!n.getBoundingClientRect || n === document.body) return A();
|
|
if (o || e) return n;
|
|
o = !0;
|
|
}
|
|
}
|
|
} while ((n = n.parentNode));
|
|
return A();
|
|
}
|
|
function y(t, e) {
|
|
return (
|
|
Math.round(t.top) === Math.round(e.top) &&
|
|
Math.round(t.left) === Math.round(e.left) &&
|
|
Math.round(t.height) === Math.round(e.height) &&
|
|
Math.round(t.width) === Math.round(e.width)
|
|
);
|
|
}
|
|
function D(e, n) {
|
|
return function () {
|
|
if (!f) {
|
|
var t = arguments;
|
|
1 === t.length ? e.call(this, t[0]) : e.apply(this, t),
|
|
(f = setTimeout(function () {
|
|
f = void 0;
|
|
}, n));
|
|
}
|
|
};
|
|
}
|
|
function L(t, e, n) {
|
|
(t.scrollLeft += e), (t.scrollTop += n);
|
|
}
|
|
function S(t) {
|
|
var e = window.Polymer,
|
|
n = window.jQuery || window.Zepto;
|
|
return e && e.dom
|
|
? e.dom(t).cloneNode(!0)
|
|
: n
|
|
? n(t).clone(!0)[0]
|
|
: t.cloneNode(!0);
|
|
}
|
|
function _(t, e) {
|
|
R(t, "position", "absolute"),
|
|
R(t, "top", e.top),
|
|
R(t, "left", e.left),
|
|
R(t, "width", e.width),
|
|
R(t, "height", e.height);
|
|
}
|
|
function C(t) {
|
|
R(t, "position", ""),
|
|
R(t, "top", ""),
|
|
R(t, "left", ""),
|
|
R(t, "width", ""),
|
|
R(t, "height", "");
|
|
}
|
|
var j = "Sortable" + new Date().getTime();
|
|
function T() {
|
|
var e,
|
|
o = [];
|
|
return {
|
|
captureAnimationState: function () {
|
|
(o = []),
|
|
this.options.animation &&
|
|
[].slice.call(this.el.children).forEach(function (t) {
|
|
if ("none" !== R(t, "display") && t !== Rt.ghost) {
|
|
o.push({ target: t, rect: X(t) });
|
|
var e = I({}, o[o.length - 1].rect);
|
|
if (t.thisAnimationDuration) {
|
|
var n = v(t, !0);
|
|
n && ((e.top -= n.f), (e.left -= n.e));
|
|
}
|
|
t.fromRect = e;
|
|
}
|
|
});
|
|
},
|
|
addAnimationState: function (t) {
|
|
o.push(t);
|
|
},
|
|
removeAnimationState: function (t) {
|
|
o.splice(
|
|
(function (t, e) {
|
|
for (var n in t)
|
|
if (t.hasOwnProperty(n))
|
|
for (var o in e)
|
|
if (e.hasOwnProperty(o) && e[o] === t[n][o]) return Number(n);
|
|
return -1;
|
|
})(o, { target: t }),
|
|
1
|
|
);
|
|
},
|
|
animateAll: function (t) {
|
|
var c = this;
|
|
if (!this.options.animation)
|
|
return clearTimeout(e), void ("function" == typeof t && t());
|
|
var u = !1,
|
|
d = 0;
|
|
o.forEach(function (t) {
|
|
var e = 0,
|
|
n = t.target,
|
|
o = n.fromRect,
|
|
i = X(n),
|
|
r = n.prevFromRect,
|
|
a = n.prevToRect,
|
|
l = t.rect,
|
|
s = v(n, !0);
|
|
s && ((i.top -= s.f), (i.left -= s.e)),
|
|
(n.toRect = i),
|
|
n.thisAnimationDuration &&
|
|
y(r, i) &&
|
|
!y(o, i) &&
|
|
(l.top - i.top) / (l.left - i.left) ==
|
|
(o.top - i.top) / (o.left - i.left) &&
|
|
(e = (function (t, e, n, o) {
|
|
return (
|
|
(Math.sqrt(
|
|
Math.pow(e.top - t.top, 2) + Math.pow(e.left - t.left, 2)
|
|
) /
|
|
Math.sqrt(
|
|
Math.pow(e.top - n.top, 2) + Math.pow(e.left - n.left, 2)
|
|
)) *
|
|
o.animation
|
|
);
|
|
})(l, r, a, c.options)),
|
|
y(i, o) ||
|
|
((n.prevFromRect = o),
|
|
(n.prevToRect = i),
|
|
e || (e = c.options.animation),
|
|
c.animate(n, l, i, e)),
|
|
e &&
|
|
((u = !0),
|
|
(d = Math.max(d, e)),
|
|
clearTimeout(n.animationResetTimer),
|
|
(n.animationResetTimer = setTimeout(function () {
|
|
(n.animationTime = 0),
|
|
(n.prevFromRect = null),
|
|
(n.fromRect = null),
|
|
(n.prevToRect = null),
|
|
(n.thisAnimationDuration = null);
|
|
}, e)),
|
|
(n.thisAnimationDuration = e));
|
|
}),
|
|
clearTimeout(e),
|
|
u
|
|
? (e = setTimeout(function () {
|
|
"function" == typeof t && t();
|
|
}, d))
|
|
: "function" == typeof t && t(),
|
|
(o = []);
|
|
},
|
|
animate: function (t, e, n, o) {
|
|
if (o) {
|
|
R(t, "transition", ""), R(t, "transform", "");
|
|
var i = v(this.el),
|
|
r = i && i.a,
|
|
a = i && i.d,
|
|
l = (e.left - n.left) / (r || 1),
|
|
s = (e.top - n.top) / (a || 1);
|
|
(t.animatingX = !!l),
|
|
(t.animatingY = !!s),
|
|
R(t, "transform", "translate3d(" + l + "px," + s + "px,0)"),
|
|
(this.forRepaintDummy = (function (t) {
|
|
return t.offsetWidth;
|
|
})(t)),
|
|
R(
|
|
t,
|
|
"transition",
|
|
"transform " +
|
|
o +
|
|
"ms" +
|
|
(this.options.easing ? " " + this.options.easing : "")
|
|
),
|
|
R(t, "transform", "translate3d(0,0,0)"),
|
|
"number" == typeof t.animated && clearTimeout(t.animated),
|
|
(t.animated = setTimeout(function () {
|
|
R(t, "transition", ""),
|
|
R(t, "transform", ""),
|
|
(t.animated = !1),
|
|
(t.animatingX = !1),
|
|
(t.animatingY = !1);
|
|
}, o));
|
|
}
|
|
}
|
|
};
|
|
}
|
|
var x = [],
|
|
M = { initializeByDefault: !0 },
|
|
O = {
|
|
mount: function (e) {
|
|
for (var t in M) !M.hasOwnProperty(t) || t in e || (e[t] = M[t]);
|
|
x.forEach(function (t) {
|
|
if (t.pluginName === e.pluginName)
|
|
throw "Sortable: Cannot mount plugin ".concat(
|
|
e.pluginName,
|
|
" more than once"
|
|
);
|
|
}),
|
|
x.push(e);
|
|
},
|
|
pluginEvent: function (e, n, o) {
|
|
var t = this;
|
|
(this.eventCanceled = !1),
|
|
(o.cancel = function () {
|
|
t.eventCanceled = !0;
|
|
});
|
|
var i = e + "Global";
|
|
x.forEach(function (t) {
|
|
n[t.pluginName] &&
|
|
(n[t.pluginName][i] && n[t.pluginName][i](I({ sortable: n }, o)),
|
|
n.options[t.pluginName] &&
|
|
n[t.pluginName][e] &&
|
|
n[t.pluginName][e](I({ sortable: n }, o)));
|
|
});
|
|
},
|
|
initializePlugins: function (o, i, r, t) {
|
|
for (var e in (x.forEach(function (t) {
|
|
var e = t.pluginName;
|
|
if (o.options[e] || t.initializeByDefault) {
|
|
var n = new t(o, i, o.options);
|
|
(n.sortable = o),
|
|
(n.options = o.options),
|
|
(o[e] = n),
|
|
a(r, n.defaults);
|
|
}
|
|
}),
|
|
o.options))
|
|
if (o.options.hasOwnProperty(e)) {
|
|
var n = this.modifyOption(o, e, o.options[e]);
|
|
void 0 !== n && (o.options[e] = n);
|
|
}
|
|
},
|
|
getEventProperties: function (e, n) {
|
|
var o = {};
|
|
return (
|
|
x.forEach(function (t) {
|
|
"function" == typeof t.eventProperties &&
|
|
a(o, t.eventProperties.call(n[t.pluginName], e));
|
|
}),
|
|
o
|
|
);
|
|
},
|
|
modifyOption: function (e, n, o) {
|
|
var i;
|
|
return (
|
|
x.forEach(function (t) {
|
|
e[t.pluginName] &&
|
|
t.optionListeners &&
|
|
"function" == typeof t.optionListeners[n] &&
|
|
(i = t.optionListeners[n].call(e[t.pluginName], o));
|
|
}),
|
|
i
|
|
);
|
|
}
|
|
};
|
|
function N(t) {
|
|
var e = t.sortable,
|
|
n = t.rootEl,
|
|
o = t.name,
|
|
i = t.targetEl,
|
|
r = t.cloneEl,
|
|
a = t.toEl,
|
|
l = t.fromEl,
|
|
s = t.oldIndex,
|
|
c = t.newIndex,
|
|
u = t.oldDraggableIndex,
|
|
d = t.newDraggableIndex,
|
|
h = t.originalEvent,
|
|
f = t.putSortable,
|
|
p = t.extraEventProperties;
|
|
if ((e = e || (n && n[j]))) {
|
|
var g,
|
|
v = e.options,
|
|
m = "on" + o.charAt(0).toUpperCase() + o.substr(1);
|
|
!window.CustomEvent || w || E
|
|
? (g = document.createEvent("Event")).initEvent(o, !0, !0)
|
|
: (g = new CustomEvent(o, { bubbles: !0, cancelable: !0 })),
|
|
(g.to = a || n),
|
|
(g.from = l || n),
|
|
(g.item = i || n),
|
|
(g.clone = r),
|
|
(g.oldIndex = s),
|
|
(g.newIndex = c),
|
|
(g.oldDraggableIndex = u),
|
|
(g.newDraggableIndex = d),
|
|
(g.originalEvent = h),
|
|
(g.pullMode = f ? f.lastPutMode : void 0);
|
|
var b = I({}, p, O.getEventProperties(o, e));
|
|
for (var y in b) g[y] = b[y];
|
|
n && n.dispatchEvent(g), v[m] && v[m].call(e, g);
|
|
}
|
|
}
|
|
function K(t, e, n) {
|
|
var o = 2 < arguments.length && void 0 !== n ? n : {},
|
|
i = o.evt,
|
|
r = l(o, ["evt"]);
|
|
O.pluginEvent.bind(Rt)(
|
|
t,
|
|
e,
|
|
I(
|
|
{
|
|
dragEl: z,
|
|
parentEl: G,
|
|
ghostEl: U,
|
|
rootEl: q,
|
|
nextEl: V,
|
|
lastDownEl: Z,
|
|
cloneEl: Q,
|
|
cloneHidden: $,
|
|
dragStarted: dt,
|
|
putSortable: it,
|
|
activeSortable: Rt.active,
|
|
originalEvent: i,
|
|
oldIndex: J,
|
|
oldDraggableIndex: et,
|
|
newIndex: tt,
|
|
newDraggableIndex: nt,
|
|
hideGhostForTarget: At,
|
|
unhideGhostForTarget: It,
|
|
cloneNowHidden: function () {
|
|
$ = !0;
|
|
},
|
|
cloneNowShown: function () {
|
|
$ = !1;
|
|
},
|
|
dispatchSortableEvent: function (t) {
|
|
W({ sortable: e, name: t, originalEvent: i });
|
|
}
|
|
},
|
|
r
|
|
)
|
|
);
|
|
}
|
|
function W(t) {
|
|
N(
|
|
I(
|
|
{
|
|
putSortable: it,
|
|
cloneEl: Q,
|
|
targetEl: z,
|
|
rootEl: q,
|
|
oldIndex: J,
|
|
oldDraggableIndex: et,
|
|
newIndex: tt,
|
|
newDraggableIndex: nt
|
|
},
|
|
t
|
|
)
|
|
);
|
|
}
|
|
var z,
|
|
G,
|
|
U,
|
|
q,
|
|
V,
|
|
Z,
|
|
Q,
|
|
$,
|
|
J,
|
|
tt,
|
|
et,
|
|
nt,
|
|
ot,
|
|
it,
|
|
rt,
|
|
at,
|
|
lt,
|
|
st,
|
|
ct,
|
|
ut,
|
|
dt,
|
|
ht,
|
|
ft,
|
|
pt,
|
|
gt,
|
|
vt = !1,
|
|
mt = !1,
|
|
bt = [],
|
|
yt = !1,
|
|
wt = !1,
|
|
Et = [],
|
|
Dt = !1,
|
|
St = [],
|
|
_t = "undefined" != typeof document,
|
|
Ct = n,
|
|
Tt = E || w ? "cssFloat" : "float",
|
|
xt = _t && !i && !n && "draggable" in document.createElement("div"),
|
|
Mt = (function () {
|
|
if (_t) {
|
|
if (w) return !1;
|
|
var t = document.createElement("x");
|
|
return (
|
|
(t.style.cssText = "pointer-events:auto"),
|
|
"auto" === t.style.pointerEvents
|
|
);
|
|
}
|
|
})(),
|
|
Ot = function (t, e) {
|
|
var n = R(t),
|
|
o =
|
|
parseInt(n.width) -
|
|
parseInt(n.paddingLeft) -
|
|
parseInt(n.paddingRight) -
|
|
parseInt(n.borderLeftWidth) -
|
|
parseInt(n.borderRightWidth),
|
|
i = m(t, 0, e),
|
|
r = m(t, 1, e),
|
|
a = i && R(i),
|
|
l = r && R(r),
|
|
s = a && parseInt(a.marginLeft) + parseInt(a.marginRight) + X(i).width,
|
|
c = l && parseInt(l.marginLeft) + parseInt(l.marginRight) + X(r).width;
|
|
if ("flex" === n.display)
|
|
return "column" === n.flexDirection ||
|
|
"column-reverse" === n.flexDirection
|
|
? "vertical"
|
|
: "horizontal";
|
|
if ("grid" === n.display)
|
|
return n.gridTemplateColumns.split(" ").length <= 1
|
|
? "vertical"
|
|
: "horizontal";
|
|
if (i && a.float && "none" !== a.float) {
|
|
var u = "left" === a.float ? "left" : "right";
|
|
return !r || ("both" !== l.clear && l.clear !== u)
|
|
? "horizontal"
|
|
: "vertical";
|
|
}
|
|
return i &&
|
|
("block" === a.display ||
|
|
"flex" === a.display ||
|
|
"table" === a.display ||
|
|
"grid" === a.display ||
|
|
(o <= s && "none" === n[Tt]) ||
|
|
(r && "none" === n[Tt] && o < s + c))
|
|
? "vertical"
|
|
: "horizontal";
|
|
},
|
|
Nt = function (t) {
|
|
function s(a, l) {
|
|
return function (t, e, n, o) {
|
|
var i =
|
|
t.options.group.name &&
|
|
e.options.group.name &&
|
|
t.options.group.name === e.options.group.name;
|
|
if (null == a && (l || i)) return !0;
|
|
if (null == a || !1 === a) return !1;
|
|
if (l && "clone" === a) return a;
|
|
if ("function" == typeof a) return s(a(t, e, n, o), l)(t, e, n, o);
|
|
var r = (l ? t : e).options.group.name;
|
|
return (
|
|
!0 === a ||
|
|
("string" == typeof a && a === r) ||
|
|
(a.join && -1 < a.indexOf(r))
|
|
);
|
|
};
|
|
}
|
|
var e = {},
|
|
n = t.group;
|
|
(n && "object" == o(n)) || (n = { name: n }),
|
|
(e.name = n.name),
|
|
(e.checkPull = s(n.pull, !0)),
|
|
(e.checkPut = s(n.put)),
|
|
(e.revertClone = n.revertClone),
|
|
(t.group = e);
|
|
},
|
|
At = function () {
|
|
!Mt && U && R(U, "display", "none");
|
|
},
|
|
It = function () {
|
|
!Mt && U && R(U, "display", "");
|
|
};
|
|
_t &&
|
|
document.addEventListener(
|
|
"click",
|
|
function (t) {
|
|
if (mt)
|
|
return (
|
|
t.preventDefault(),
|
|
t.stopPropagation && t.stopPropagation(),
|
|
t.stopImmediatePropagation && t.stopImmediatePropagation(),
|
|
(mt = !1)
|
|
);
|
|
},
|
|
!0
|
|
);
|
|
function Pt(t) {
|
|
if (z) {
|
|
var e = (function (r, a) {
|
|
var l;
|
|
return (
|
|
bt.some(function (t) {
|
|
if (!B(t)) {
|
|
var e = X(t),
|
|
n = t[j].options.emptyInsertThreshold,
|
|
o = r >= e.left - n && r <= e.right + n,
|
|
i = a >= e.top - n && a <= e.bottom + n;
|
|
return n && o && i ? (l = t) : void 0;
|
|
}
|
|
}),
|
|
l
|
|
);
|
|
})((t = t.touches ? t.touches[0] : t).clientX, t.clientY);
|
|
if (e) {
|
|
var n = {};
|
|
for (var o in t) t.hasOwnProperty(o) && (n[o] = t[o]);
|
|
(n.target = n.rootEl = e),
|
|
(n.preventDefault = void 0),
|
|
(n.stopPropagation = void 0),
|
|
e[j]._onDragOver(n);
|
|
}
|
|
}
|
|
}
|
|
function kt(t) {
|
|
z && z.parentNode[j]._isOutsideThisEl(t.target);
|
|
}
|
|
function Rt(t, e) {
|
|
if (!t || !t.nodeType || 1 !== t.nodeType)
|
|
throw "Sortable: `el` must be an HTMLElement, not ".concat(
|
|
{}.toString.call(t)
|
|
);
|
|
(this.el = t), (this.options = e = a({}, e)), (t[j] = this);
|
|
var n = {
|
|
group: null,
|
|
sort: !0,
|
|
disabled: !1,
|
|
store: null,
|
|
handle: null,
|
|
draggable: /^[uo]l$/i.test(t.nodeName) ? ">li" : ">*",
|
|
swapThreshold: 1,
|
|
invertSwap: !1,
|
|
invertedSwapThreshold: null,
|
|
removeCloneOnHide: !0,
|
|
direction: function () {
|
|
return Ot(t, this.options);
|
|
},
|
|
ghostClass: "sortable-ghost",
|
|
chosenClass: "sortable-chosen",
|
|
dragClass: "sortable-drag",
|
|
ignore: "a, img",
|
|
filter: null,
|
|
preventOnFilter: !0,
|
|
animation: 0,
|
|
easing: null,
|
|
setData: function (t, e) {
|
|
t.setData("Text", e.textContent);
|
|
},
|
|
dropBubble: !1,
|
|
dragoverBubble: !1,
|
|
dataIdAttr: "data-id",
|
|
delay: 0,
|
|
delayOnTouchOnly: !1,
|
|
touchStartThreshold:
|
|
(Number.parseInt ? Number : window).parseInt(
|
|
window.devicePixelRatio,
|
|
10
|
|
) || 1,
|
|
forceFallback: !1,
|
|
fallbackClass: "sortable-fallback",
|
|
fallbackOnBody: !1,
|
|
fallbackTolerance: 0,
|
|
fallbackOffset: { x: 0, y: 0 },
|
|
supportPointer:
|
|
!1 !== Rt.supportPointer && "PointerEvent" in window && !u,
|
|
emptyInsertThreshold: 5
|
|
};
|
|
for (var o in (O.initializePlugins(this, t, n), n)) o in e || (e[o] = n[o]);
|
|
for (var i in (Nt(e), this))
|
|
"_" === i.charAt(0) &&
|
|
"function" == typeof this[i] &&
|
|
(this[i] = this[i].bind(this));
|
|
(this.nativeDraggable = !e.forceFallback && xt),
|
|
this.nativeDraggable && (this.options.touchStartThreshold = 1),
|
|
e.supportPointer
|
|
? d(t, "pointerdown", this._onTapStart)
|
|
: (d(t, "mousedown", this._onTapStart),
|
|
d(t, "touchstart", this._onTapStart)),
|
|
this.nativeDraggable && (d(t, "dragover", this), d(t, "dragenter", this)),
|
|
bt.push(this.el),
|
|
e.store && e.store.get && this.sort(e.store.get(this) || []),
|
|
a(this, T());
|
|
}
|
|
function Xt(t, e, n, o, i, r, a, l) {
|
|
var s,
|
|
c,
|
|
u = t[j],
|
|
d = u.options.onMove;
|
|
return (
|
|
!window.CustomEvent || w || E
|
|
? (s = document.createEvent("Event")).initEvent("move", !0, !0)
|
|
: (s = new CustomEvent("move", { bubbles: !0, cancelable: !0 })),
|
|
(s.to = e),
|
|
(s.from = t),
|
|
(s.dragged = n),
|
|
(s.draggedRect = o),
|
|
(s.related = i || e),
|
|
(s.relatedRect = r || X(e)),
|
|
(s.willInsertAfter = l),
|
|
(s.originalEvent = a),
|
|
t.dispatchEvent(s),
|
|
d && (c = d.call(u, s, a)),
|
|
c
|
|
);
|
|
}
|
|
function Yt(t) {
|
|
t.draggable = !1;
|
|
}
|
|
function Bt() {
|
|
Dt = !1;
|
|
}
|
|
function Ft(t) {
|
|
for (
|
|
var e = t.tagName + t.className + t.src + t.href + t.textContent,
|
|
n = e.length,
|
|
o = 0;
|
|
n--;
|
|
|
|
)
|
|
o += e.charCodeAt(n);
|
|
return o.toString(36);
|
|
}
|
|
function Ht(t) {
|
|
return setTimeout(t, 0);
|
|
}
|
|
function Lt(t) {
|
|
return clearTimeout(t);
|
|
}
|
|
(Rt.prototype = {
|
|
constructor: Rt,
|
|
_isOutsideThisEl: function (t) {
|
|
this.el.contains(t) || t === this.el || (ht = null);
|
|
},
|
|
_getDirection: function (t, e) {
|
|
return "function" == typeof this.options.direction
|
|
? this.options.direction.call(this, t, e, z)
|
|
: this.options.direction;
|
|
},
|
|
_onTapStart: function (e) {
|
|
if (e.cancelable) {
|
|
var n = this,
|
|
o = this.el,
|
|
t = this.options,
|
|
i = t.preventOnFilter,
|
|
r = e.type,
|
|
a =
|
|
(e.touches && e.touches[0]) ||
|
|
(e.pointerType && "touch" === e.pointerType && e),
|
|
l = (a || e).target,
|
|
s =
|
|
(e.target.shadowRoot &&
|
|
((e.path && e.path[0]) ||
|
|
(e.composedPath && e.composedPath()[0]))) ||
|
|
l,
|
|
c = t.filter;
|
|
if (
|
|
((function (t) {
|
|
St.length = 0;
|
|
var e = t.getElementsByTagName("input"),
|
|
n = e.length;
|
|
for (; n--; ) {
|
|
var o = e[n];
|
|
o.checked && St.push(o);
|
|
}
|
|
})(o),
|
|
!z &&
|
|
!(
|
|
(/mousedown|pointerdown/.test(r) && 0 !== e.button) ||
|
|
t.disabled
|
|
) &&
|
|
!s.isContentEditable &&
|
|
(this.nativeDraggable ||
|
|
!u ||
|
|
!l ||
|
|
"SELECT" !== l.tagName.toUpperCase()) &&
|
|
!(((l = P(l, t.draggable, o, !1)) && l.animated) || Z === l))
|
|
) {
|
|
if (((J = F(l)), (et = F(l, t.draggable)), "function" == typeof c)) {
|
|
if (c.call(this, e, l, this))
|
|
return (
|
|
W({
|
|
sortable: n,
|
|
rootEl: s,
|
|
name: "filter",
|
|
targetEl: l,
|
|
toEl: o,
|
|
fromEl: o
|
|
}),
|
|
K("filter", n, { evt: e }),
|
|
void (i && e.cancelable && e.preventDefault())
|
|
);
|
|
} else if (
|
|
c &&
|
|
(c = c.split(",").some(function (t) {
|
|
if ((t = P(s, t.trim(), o, !1)))
|
|
return (
|
|
W({
|
|
sortable: n,
|
|
rootEl: t,
|
|
name: "filter",
|
|
targetEl: l,
|
|
fromEl: o,
|
|
toEl: o
|
|
}),
|
|
K("filter", n, { evt: e }),
|
|
!0
|
|
);
|
|
}))
|
|
)
|
|
return void (i && e.cancelable && e.preventDefault());
|
|
(t.handle && !P(s, t.handle, o, !1)) ||
|
|
this._prepareDragStart(e, a, l);
|
|
}
|
|
}
|
|
},
|
|
_prepareDragStart: function (t, e, n) {
|
|
var o,
|
|
i = this,
|
|
r = i.el,
|
|
a = i.options,
|
|
l = r.ownerDocument;
|
|
if (n && !z && n.parentNode === r) {
|
|
var s = X(n);
|
|
if (
|
|
((q = r),
|
|
(G = (z = n).parentNode),
|
|
(V = z.nextSibling),
|
|
(Z = n),
|
|
(ot = a.group),
|
|
(rt = {
|
|
target: (Rt.dragged = z),
|
|
clientX: (e || t).clientX,
|
|
clientY: (e || t).clientY
|
|
}),
|
|
(ct = rt.clientX - s.left),
|
|
(ut = rt.clientY - s.top),
|
|
(this._lastX = (e || t).clientX),
|
|
(this._lastY = (e || t).clientY),
|
|
(z.style["will-change"] = "all"),
|
|
(o = function () {
|
|
K("delayEnded", i, { evt: t }),
|
|
Rt.eventCanceled
|
|
? i._onDrop()
|
|
: (i._disableDelayedDragEvents(),
|
|
!c && i.nativeDraggable && (z.draggable = !0),
|
|
i._triggerDragStart(t, e),
|
|
W({ sortable: i, name: "choose", originalEvent: t }),
|
|
k(z, a.chosenClass, !0));
|
|
}),
|
|
a.ignore.split(",").forEach(function (t) {
|
|
g(z, t.trim(), Yt);
|
|
}),
|
|
d(l, "dragover", Pt),
|
|
d(l, "mousemove", Pt),
|
|
d(l, "touchmove", Pt),
|
|
d(l, "mouseup", i._onDrop),
|
|
d(l, "touchend", i._onDrop),
|
|
d(l, "touchcancel", i._onDrop),
|
|
c &&
|
|
this.nativeDraggable &&
|
|
((this.options.touchStartThreshold = 4), (z.draggable = !0)),
|
|
K("delayStart", this, { evt: t }),
|
|
!a.delay ||
|
|
(a.delayOnTouchOnly && !e) ||
|
|
(this.nativeDraggable && (E || w)))
|
|
)
|
|
o();
|
|
else {
|
|
if (Rt.eventCanceled) return void this._onDrop();
|
|
d(l, "mouseup", i._disableDelayedDrag),
|
|
d(l, "touchend", i._disableDelayedDrag),
|
|
d(l, "touchcancel", i._disableDelayedDrag),
|
|
d(l, "mousemove", i._delayedDragTouchMoveHandler),
|
|
d(l, "touchmove", i._delayedDragTouchMoveHandler),
|
|
a.supportPointer &&
|
|
d(l, "pointermove", i._delayedDragTouchMoveHandler),
|
|
(i._dragStartTimer = setTimeout(o, a.delay));
|
|
}
|
|
}
|
|
},
|
|
_delayedDragTouchMoveHandler: function (t) {
|
|
var e = t.touches ? t.touches[0] : t;
|
|
Math.max(
|
|
Math.abs(e.clientX - this._lastX),
|
|
Math.abs(e.clientY - this._lastY)
|
|
) >=
|
|
Math.floor(
|
|
this.options.touchStartThreshold /
|
|
((this.nativeDraggable && window.devicePixelRatio) || 1)
|
|
) && this._disableDelayedDrag();
|
|
},
|
|
_disableDelayedDrag: function () {
|
|
z && Yt(z),
|
|
clearTimeout(this._dragStartTimer),
|
|
this._disableDelayedDragEvents();
|
|
},
|
|
_disableDelayedDragEvents: function () {
|
|
var t = this.el.ownerDocument;
|
|
s(t, "mouseup", this._disableDelayedDrag),
|
|
s(t, "touchend", this._disableDelayedDrag),
|
|
s(t, "touchcancel", this._disableDelayedDrag),
|
|
s(t, "mousemove", this._delayedDragTouchMoveHandler),
|
|
s(t, "touchmove", this._delayedDragTouchMoveHandler),
|
|
s(t, "pointermove", this._delayedDragTouchMoveHandler);
|
|
},
|
|
_triggerDragStart: function (t, e) {
|
|
(e = e || ("touch" == t.pointerType && t)),
|
|
!this.nativeDraggable || e
|
|
? this.options.supportPointer
|
|
? d(document, "pointermove", this._onTouchMove)
|
|
: d(document, e ? "touchmove" : "mousemove", this._onTouchMove)
|
|
: (d(z, "dragend", this), d(q, "dragstart", this._onDragStart));
|
|
try {
|
|
document.selection
|
|
? Ht(function () {
|
|
document.selection.empty();
|
|
})
|
|
: window.getSelection().removeAllRanges();
|
|
} catch (t) {}
|
|
},
|
|
_dragStarted: function (t, e) {
|
|
if (((vt = !1), q && z)) {
|
|
K("dragStarted", this, { evt: e }),
|
|
this.nativeDraggable && d(document, "dragover", kt);
|
|
var n = this.options;
|
|
t || k(z, n.dragClass, !1),
|
|
k(z, n.ghostClass, !0),
|
|
(Rt.active = this),
|
|
t && this._appendGhost(),
|
|
W({ sortable: this, name: "start", originalEvent: e });
|
|
} else this._nulling();
|
|
},
|
|
_emulateDragOver: function () {
|
|
if (at) {
|
|
(this._lastX = at.clientX), (this._lastY = at.clientY), At();
|
|
for (
|
|
var t = document.elementFromPoint(at.clientX, at.clientY), e = t;
|
|
t &&
|
|
t.shadowRoot &&
|
|
(t = t.shadowRoot.elementFromPoint(at.clientX, at.clientY)) !== e;
|
|
|
|
)
|
|
e = t;
|
|
if ((z.parentNode[j]._isOutsideThisEl(t), e))
|
|
do {
|
|
if (e[j]) {
|
|
if (
|
|
e[j]._onDragOver({
|
|
clientX: at.clientX,
|
|
clientY: at.clientY,
|
|
target: t,
|
|
rootEl: e
|
|
}) &&
|
|
!this.options.dragoverBubble
|
|
)
|
|
break;
|
|
}
|
|
t = e;
|
|
} while ((e = e.parentNode));
|
|
It();
|
|
}
|
|
},
|
|
_onTouchMove: function (t) {
|
|
if (rt) {
|
|
var e = this.options,
|
|
n = e.fallbackTolerance,
|
|
o = e.fallbackOffset,
|
|
i = t.touches ? t.touches[0] : t,
|
|
r = U && v(U, !0),
|
|
a = U && r && r.a,
|
|
l = U && r && r.d,
|
|
s = Ct && gt && b(gt),
|
|
c =
|
|
(i.clientX - rt.clientX + o.x) / (a || 1) +
|
|
(s ? s[0] - Et[0] : 0) / (a || 1),
|
|
u =
|
|
(i.clientY - rt.clientY + o.y) / (l || 1) +
|
|
(s ? s[1] - Et[1] : 0) / (l || 1);
|
|
if (!Rt.active && !vt) {
|
|
if (
|
|
n &&
|
|
Math.max(
|
|
Math.abs(i.clientX - this._lastX),
|
|
Math.abs(i.clientY - this._lastY)
|
|
) < n
|
|
)
|
|
return;
|
|
this._onDragStart(t, !0);
|
|
}
|
|
if (U) {
|
|
r
|
|
? ((r.e += c - (lt || 0)), (r.f += u - (st || 0)))
|
|
: (r = { a: 1, b: 0, c: 0, d: 1, e: c, f: u });
|
|
var d = "matrix("
|
|
.concat(r.a, ",")
|
|
.concat(r.b, ",")
|
|
.concat(r.c, ",")
|
|
.concat(r.d, ",")
|
|
.concat(r.e, ",")
|
|
.concat(r.f, ")");
|
|
R(U, "webkitTransform", d),
|
|
R(U, "mozTransform", d),
|
|
R(U, "msTransform", d),
|
|
R(U, "transform", d),
|
|
(lt = c),
|
|
(st = u),
|
|
(at = i);
|
|
}
|
|
t.cancelable && t.preventDefault();
|
|
}
|
|
},
|
|
_appendGhost: function () {
|
|
if (!U) {
|
|
var t = this.options.fallbackOnBody ? document.body : q,
|
|
e = X(z, !0, Ct, !0, t),
|
|
n = this.options;
|
|
if (Ct) {
|
|
for (
|
|
gt = t;
|
|
"static" === R(gt, "position") &&
|
|
"none" === R(gt, "transform") &&
|
|
gt !== document;
|
|
|
|
)
|
|
gt = gt.parentNode;
|
|
gt !== document.body && gt !== document.documentElement
|
|
? (gt === document && (gt = A()),
|
|
(e.top += gt.scrollTop),
|
|
(e.left += gt.scrollLeft))
|
|
: (gt = A()),
|
|
(Et = b(gt));
|
|
}
|
|
k((U = z.cloneNode(!0)), n.ghostClass, !1),
|
|
k(U, n.fallbackClass, !0),
|
|
k(U, n.dragClass, !0),
|
|
R(U, "transition", ""),
|
|
R(U, "transform", ""),
|
|
R(U, "box-sizing", "border-box"),
|
|
R(U, "margin", 0),
|
|
R(U, "top", e.top),
|
|
R(U, "left", e.left),
|
|
R(U, "width", e.width),
|
|
R(U, "height", e.height),
|
|
R(U, "opacity", "0.8"),
|
|
R(U, "position", Ct ? "absolute" : "fixed"),
|
|
R(U, "zIndex", "100000"),
|
|
R(U, "pointerEvents", "none"),
|
|
(Rt.ghost = U),
|
|
t.appendChild(U),
|
|
R(
|
|
U,
|
|
"transform-origin",
|
|
(ct / parseInt(U.style.width)) * 100 +
|
|
"% " +
|
|
(ut / parseInt(U.style.height)) * 100 +
|
|
"%"
|
|
);
|
|
}
|
|
},
|
|
_onDragStart: function (t, e) {
|
|
var n = this,
|
|
o = t.dataTransfer,
|
|
i = n.options;
|
|
K("dragStart", this, { evt: t }),
|
|
Rt.eventCanceled
|
|
? this._onDrop()
|
|
: (K("setupClone", this),
|
|
Rt.eventCanceled ||
|
|
(((Q = S(z)).draggable = !1),
|
|
(Q.style["will-change"] = ""),
|
|
this._hideClone(),
|
|
k(Q, this.options.chosenClass, !1),
|
|
(Rt.clone = Q)),
|
|
(n.cloneId = Ht(function () {
|
|
K("clone", n),
|
|
Rt.eventCanceled ||
|
|
(n.options.removeCloneOnHide || q.insertBefore(Q, z),
|
|
n._hideClone(),
|
|
W({ sortable: n, name: "clone" }));
|
|
})),
|
|
e || k(z, i.dragClass, !0),
|
|
e
|
|
? ((mt = !0), (n._loopId = setInterval(n._emulateDragOver, 50)))
|
|
: (s(document, "mouseup", n._onDrop),
|
|
s(document, "touchend", n._onDrop),
|
|
s(document, "touchcancel", n._onDrop),
|
|
o &&
|
|
((o.effectAllowed = "move"),
|
|
i.setData && i.setData.call(n, o, z)),
|
|
d(document, "drop", n),
|
|
R(z, "transform", "translateZ(0)")),
|
|
(vt = !0),
|
|
(n._dragStartId = Ht(n._dragStarted.bind(n, e, t))),
|
|
d(document, "selectstart", n),
|
|
(dt = !0),
|
|
u && R(document.body, "user-select", "none"));
|
|
},
|
|
_onDragOver: function (n) {
|
|
var o,
|
|
i,
|
|
r,
|
|
a,
|
|
l = this.el,
|
|
s = n.target,
|
|
e = this.options,
|
|
t = e.group,
|
|
c = Rt.active,
|
|
u = ot === t,
|
|
d = e.sort,
|
|
h = it || c,
|
|
f = this,
|
|
p = !1;
|
|
if (!Dt) {
|
|
if (
|
|
(void 0 !== n.preventDefault && n.cancelable && n.preventDefault(),
|
|
(s = P(s, e.draggable, l, !0)),
|
|
M("dragOver"),
|
|
Rt.eventCanceled)
|
|
)
|
|
return p;
|
|
if (
|
|
z.contains(n.target) ||
|
|
(s.animated && s.animatingX && s.animatingY) ||
|
|
f._ignoreWhileAnimating === s
|
|
)
|
|
return N(!1);
|
|
if (
|
|
((mt = !1),
|
|
c &&
|
|
!e.disabled &&
|
|
(u
|
|
? d || (r = !q.contains(z))
|
|
: it === this ||
|
|
((this.lastPutMode = ot.checkPull(this, c, z, n)) &&
|
|
t.checkPut(this, c, z, n))))
|
|
) {
|
|
if (
|
|
((a = "vertical" === this._getDirection(n, s)),
|
|
(o = X(z)),
|
|
M("dragOverValid"),
|
|
Rt.eventCanceled)
|
|
)
|
|
return p;
|
|
if (r)
|
|
return (
|
|
(G = q),
|
|
O(),
|
|
this._hideClone(),
|
|
M("revert"),
|
|
Rt.eventCanceled || (V ? q.insertBefore(z, V) : q.appendChild(z)),
|
|
N(!0)
|
|
);
|
|
var g = B(l, e.draggable);
|
|
if (
|
|
!g ||
|
|
((function (t, e, n) {
|
|
var o = X(B(n.el, n.options.draggable));
|
|
return e
|
|
? t.clientX > o.right + 10 ||
|
|
(t.clientX <= o.right &&
|
|
t.clientY > o.bottom &&
|
|
t.clientX >= o.left)
|
|
: (t.clientX > o.right && t.clientY > o.top) ||
|
|
(t.clientX <= o.right && t.clientY > o.bottom + 10);
|
|
})(n, a, this) &&
|
|
!g.animated)
|
|
) {
|
|
if (g === z) return N(!1);
|
|
if (
|
|
(g && l === n.target && (s = g),
|
|
s && (i = X(s)),
|
|
!1 !== Xt(q, l, z, o, s, i, n, !!s))
|
|
)
|
|
return O(), l.appendChild(z), (G = l), A(), N(!0);
|
|
} else if (s.parentNode === l) {
|
|
i = X(s);
|
|
var v,
|
|
m,
|
|
b,
|
|
y = z.parentNode !== l,
|
|
w = !(function (t, e, n) {
|
|
var o = n ? t.left : t.top,
|
|
i = n ? t.right : t.bottom,
|
|
r = n ? t.width : t.height,
|
|
a = n ? e.left : e.top,
|
|
l = n ? e.right : e.bottom,
|
|
s = n ? e.width : e.height;
|
|
return o === a || i === l || o + r / 2 === a + s / 2;
|
|
})(
|
|
(z.animated && z.toRect) || o,
|
|
(s.animated && s.toRect) || i,
|
|
a
|
|
),
|
|
E = a ? "top" : "left",
|
|
D = Y(s, "top", "top") || Y(z, "top", "top"),
|
|
S = D ? D.scrollTop : void 0;
|
|
if (
|
|
(ht !== s &&
|
|
((m = i[E]), (yt = !1), (wt = (!w && e.invertSwap) || y)),
|
|
0 !==
|
|
(v = (function (t, e, n, o, i, r, a, l) {
|
|
var s = o ? t.clientY : t.clientX,
|
|
c = o ? n.height : n.width,
|
|
u = o ? n.top : n.left,
|
|
d = o ? n.bottom : n.right,
|
|
h = !1;
|
|
if (!a)
|
|
if (l && pt < c * i) {
|
|
if (
|
|
(!yt &&
|
|
(1 === ft
|
|
? u + (c * r) / 2 < s
|
|
: s < d - (c * r) / 2) &&
|
|
(yt = !0),
|
|
yt)
|
|
)
|
|
h = !0;
|
|
else if (1 === ft ? s < u + pt : d - pt < s) return -ft;
|
|
} else if (
|
|
u + (c * (1 - i)) / 2 < s &&
|
|
s < d - (c * (1 - i)) / 2
|
|
)
|
|
return (function (t) {
|
|
return F(z) < F(t) ? 1 : -1;
|
|
})(e);
|
|
if (
|
|
(h = h || a) &&
|
|
(s < u + (c * r) / 2 || d - (c * r) / 2 < s)
|
|
)
|
|
return u + c / 2 < s ? 1 : -1;
|
|
return 0;
|
|
})(
|
|
n,
|
|
s,
|
|
i,
|
|
a,
|
|
w ? 1 : e.swapThreshold,
|
|
null == e.invertedSwapThreshold
|
|
? e.swapThreshold
|
|
: e.invertedSwapThreshold,
|
|
wt,
|
|
ht === s
|
|
)))
|
|
)
|
|
for (
|
|
var _ = F(z);
|
|
(_ -= v),
|
|
(b = G.children[_]) &&
|
|
("none" === R(b, "display") || b === U);
|
|
|
|
);
|
|
if (0 === v || b === s) return N(!1);
|
|
ft = v;
|
|
var C = (ht = s).nextElementSibling,
|
|
T = !1,
|
|
x = Xt(q, l, z, o, s, i, n, (T = 1 === v));
|
|
if (!1 !== x)
|
|
return (
|
|
(1 !== x && -1 !== x) || (T = 1 === x),
|
|
(Dt = !0),
|
|
setTimeout(Bt, 30),
|
|
O(),
|
|
T && !C
|
|
? l.appendChild(z)
|
|
: s.parentNode.insertBefore(z, T ? C : s),
|
|
D && L(D, 0, S - D.scrollTop),
|
|
(G = z.parentNode),
|
|
void 0 === m || wt || (pt = Math.abs(m - X(s)[E])),
|
|
A(),
|
|
N(!0)
|
|
);
|
|
}
|
|
if (l.contains(z)) return N(!1);
|
|
}
|
|
return !1;
|
|
}
|
|
function M(t, e) {
|
|
K(
|
|
t,
|
|
f,
|
|
I(
|
|
{
|
|
evt: n,
|
|
isOwner: u,
|
|
axis: a ? "vertical" : "horizontal",
|
|
revert: r,
|
|
dragRect: o,
|
|
targetRect: i,
|
|
canSort: d,
|
|
fromSortable: h,
|
|
target: s,
|
|
completed: N,
|
|
onMove: function (t, e) {
|
|
return Xt(q, l, z, o, t, X(t), n, e);
|
|
},
|
|
changed: A
|
|
},
|
|
e
|
|
)
|
|
);
|
|
}
|
|
function O() {
|
|
M("dragOverAnimationCapture"),
|
|
f.captureAnimationState(),
|
|
f !== h && h.captureAnimationState();
|
|
}
|
|
function N(t) {
|
|
return (
|
|
M("dragOverCompleted", { insertion: t }),
|
|
t &&
|
|
(u ? c._hideClone() : c._showClone(f),
|
|
f !== h &&
|
|
(k(z, it ? it.options.ghostClass : c.options.ghostClass, !1),
|
|
k(z, e.ghostClass, !0)),
|
|
it !== f && f !== Rt.active
|
|
? (it = f)
|
|
: f === Rt.active && it && (it = null),
|
|
h === f && (f._ignoreWhileAnimating = s),
|
|
f.animateAll(function () {
|
|
M("dragOverAnimationComplete"), (f._ignoreWhileAnimating = null);
|
|
}),
|
|
f !== h && (h.animateAll(), (h._ignoreWhileAnimating = null))),
|
|
((s === z && !z.animated) || (s === l && !s.animated)) && (ht = null),
|
|
e.dragoverBubble ||
|
|
n.rootEl ||
|
|
s === document ||
|
|
(z.parentNode[j]._isOutsideThisEl(n.target), t || Pt(n)),
|
|
!e.dragoverBubble && n.stopPropagation && n.stopPropagation(),
|
|
(p = !0)
|
|
);
|
|
}
|
|
function A() {
|
|
(tt = F(z)),
|
|
(nt = F(z, e.draggable)),
|
|
W({
|
|
sortable: f,
|
|
name: "change",
|
|
toEl: l,
|
|
newIndex: tt,
|
|
newDraggableIndex: nt,
|
|
originalEvent: n
|
|
});
|
|
}
|
|
},
|
|
_ignoreWhileAnimating: null,
|
|
_offMoveEvents: function () {
|
|
s(document, "mousemove", this._onTouchMove),
|
|
s(document, "touchmove", this._onTouchMove),
|
|
s(document, "pointermove", this._onTouchMove),
|
|
s(document, "dragover", Pt),
|
|
s(document, "mousemove", Pt),
|
|
s(document, "touchmove", Pt);
|
|
},
|
|
_offUpEvents: function () {
|
|
var t = this.el.ownerDocument;
|
|
s(t, "mouseup", this._onDrop),
|
|
s(t, "touchend", this._onDrop),
|
|
s(t, "pointerup", this._onDrop),
|
|
s(t, "touchcancel", this._onDrop),
|
|
s(document, "selectstart", this);
|
|
},
|
|
_onDrop: function (t) {
|
|
var e = this.el,
|
|
n = this.options;
|
|
(tt = F(z)),
|
|
(nt = F(z, n.draggable)),
|
|
K("drop", this, { evt: t }),
|
|
(G = z && z.parentNode),
|
|
(tt = F(z)),
|
|
(nt = F(z, n.draggable)),
|
|
Rt.eventCanceled ||
|
|
((yt = wt = vt = !1),
|
|
clearInterval(this._loopId),
|
|
clearTimeout(this._dragStartTimer),
|
|
Lt(this.cloneId),
|
|
Lt(this._dragStartId),
|
|
this.nativeDraggable &&
|
|
(s(document, "drop", this), s(e, "dragstart", this._onDragStart)),
|
|
this._offMoveEvents(),
|
|
this._offUpEvents(),
|
|
u && R(document.body, "user-select", ""),
|
|
R(z, "transform", ""),
|
|
t &&
|
|
(dt &&
|
|
(t.cancelable && t.preventDefault(),
|
|
n.dropBubble || t.stopPropagation()),
|
|
U && U.parentNode && U.parentNode.removeChild(U),
|
|
(q === G || (it && "clone" !== it.lastPutMode)) &&
|
|
Q &&
|
|
Q.parentNode &&
|
|
Q.parentNode.removeChild(Q),
|
|
z &&
|
|
(this.nativeDraggable && s(z, "dragend", this),
|
|
Yt(z),
|
|
(z.style["will-change"] = ""),
|
|
dt &&
|
|
!vt &&
|
|
k(z, it ? it.options.ghostClass : this.options.ghostClass, !1),
|
|
k(z, this.options.chosenClass, !1),
|
|
W({
|
|
sortable: this,
|
|
name: "unchoose",
|
|
toEl: G,
|
|
newIndex: null,
|
|
newDraggableIndex: null,
|
|
originalEvent: t
|
|
}),
|
|
q !== G
|
|
? (0 <= tt &&
|
|
(W({
|
|
rootEl: G,
|
|
name: "add",
|
|
toEl: G,
|
|
fromEl: q,
|
|
originalEvent: t
|
|
}),
|
|
W({
|
|
sortable: this,
|
|
name: "remove",
|
|
toEl: G,
|
|
originalEvent: t
|
|
}),
|
|
W({
|
|
rootEl: G,
|
|
name: "sort",
|
|
toEl: G,
|
|
fromEl: q,
|
|
originalEvent: t
|
|
}),
|
|
W({
|
|
sortable: this,
|
|
name: "sort",
|
|
toEl: G,
|
|
originalEvent: t
|
|
})),
|
|
it && it.save())
|
|
: tt !== J &&
|
|
0 <= tt &&
|
|
(W({
|
|
sortable: this,
|
|
name: "update",
|
|
toEl: G,
|
|
originalEvent: t
|
|
}),
|
|
W({
|
|
sortable: this,
|
|
name: "sort",
|
|
toEl: G,
|
|
originalEvent: t
|
|
})),
|
|
Rt.active &&
|
|
((null != tt && -1 !== tt) || ((tt = J), (nt = et)),
|
|
W({ sortable: this, name: "end", toEl: G, originalEvent: t }),
|
|
this.save())))),
|
|
this._nulling();
|
|
},
|
|
_nulling: function () {
|
|
K("nulling", this),
|
|
(q =
|
|
z =
|
|
G =
|
|
U =
|
|
V =
|
|
Q =
|
|
Z =
|
|
$ =
|
|
rt =
|
|
at =
|
|
dt =
|
|
tt =
|
|
nt =
|
|
J =
|
|
et =
|
|
ht =
|
|
ft =
|
|
it =
|
|
ot =
|
|
Rt.dragged =
|
|
Rt.ghost =
|
|
Rt.clone =
|
|
Rt.active =
|
|
null),
|
|
St.forEach(function (t) {
|
|
t.checked = !0;
|
|
}),
|
|
(St.length = lt = st = 0);
|
|
},
|
|
handleEvent: function (t) {
|
|
switch (t.type) {
|
|
case "drop":
|
|
case "dragend":
|
|
this._onDrop(t);
|
|
break;
|
|
case "dragenter":
|
|
case "dragover":
|
|
z &&
|
|
(this._onDragOver(t),
|
|
(function (t) {
|
|
t.dataTransfer && (t.dataTransfer.dropEffect = "move");
|
|
t.cancelable && t.preventDefault();
|
|
})(t));
|
|
break;
|
|
case "selectstart":
|
|
t.preventDefault();
|
|
}
|
|
},
|
|
toArray: function () {
|
|
for (
|
|
var t,
|
|
e = [],
|
|
n = this.el.children,
|
|
o = 0,
|
|
i = n.length,
|
|
r = this.options;
|
|
o < i;
|
|
o++
|
|
)
|
|
P((t = n[o]), r.draggable, this.el, !1) &&
|
|
e.push(t.getAttribute(r.dataIdAttr) || Ft(t));
|
|
return e;
|
|
},
|
|
sort: function (t, e) {
|
|
var o = {},
|
|
i = this.el;
|
|
this.toArray().forEach(function (t, e) {
|
|
var n = i.children[e];
|
|
P(n, this.options.draggable, i, !1) && (o[t] = n);
|
|
}, this),
|
|
e && this.captureAnimationState(),
|
|
t.forEach(function (t) {
|
|
o[t] && (i.removeChild(o[t]), i.appendChild(o[t]));
|
|
}),
|
|
e && this.animateAll();
|
|
},
|
|
save: function () {
|
|
var t = this.options.store;
|
|
t && t.set && t.set(this);
|
|
},
|
|
closest: function (t, e) {
|
|
return P(t, e || this.options.draggable, this.el, !1);
|
|
},
|
|
option: function (t, e) {
|
|
var n = this.options;
|
|
if (void 0 === e) return n[t];
|
|
var o = O.modifyOption(this, t, e);
|
|
(n[t] = void 0 !== o ? o : e), "group" === t && Nt(n);
|
|
},
|
|
destroy: function () {
|
|
K("destroy", this);
|
|
var t = this.el;
|
|
(t[j] = null),
|
|
s(t, "mousedown", this._onTapStart),
|
|
s(t, "touchstart", this._onTapStart),
|
|
s(t, "pointerdown", this._onTapStart),
|
|
this.nativeDraggable &&
|
|
(s(t, "dragover", this), s(t, "dragenter", this)),
|
|
Array.prototype.forEach.call(
|
|
t.querySelectorAll("[draggable]"),
|
|
function (t) {
|
|
t.removeAttribute("draggable");
|
|
}
|
|
),
|
|
this._onDrop(),
|
|
this._disableDelayedDragEvents(),
|
|
bt.splice(bt.indexOf(this.el), 1),
|
|
(this.el = t = null);
|
|
},
|
|
_hideClone: function () {
|
|
if (!$) {
|
|
if ((K("hideClone", this), Rt.eventCanceled)) return;
|
|
R(Q, "display", "none"),
|
|
this.options.removeCloneOnHide &&
|
|
Q.parentNode &&
|
|
Q.parentNode.removeChild(Q),
|
|
($ = !0);
|
|
}
|
|
},
|
|
_showClone: function (t) {
|
|
if ("clone" === t.lastPutMode) {
|
|
if ($) {
|
|
if ((K("showClone", this), Rt.eventCanceled)) return;
|
|
z.parentNode != q || this.options.group.revertClone
|
|
? V
|
|
? q.insertBefore(Q, V)
|
|
: q.appendChild(Q)
|
|
: q.insertBefore(Q, z),
|
|
this.options.group.revertClone && this.animate(z, Q),
|
|
R(Q, "display", ""),
|
|
($ = !1);
|
|
}
|
|
} else this._hideClone();
|
|
}
|
|
}),
|
|
_t &&
|
|
d(document, "touchmove", function (t) {
|
|
(Rt.active || vt) && t.cancelable && t.preventDefault();
|
|
}),
|
|
(Rt.utils = {
|
|
on: d,
|
|
off: s,
|
|
css: R,
|
|
find: g,
|
|
is: function (t, e) {
|
|
return !!P(t, e, t, !1);
|
|
},
|
|
extend: function (t, e) {
|
|
if (t && e) for (var n in e) e.hasOwnProperty(n) && (t[n] = e[n]);
|
|
return t;
|
|
},
|
|
throttle: D,
|
|
closest: P,
|
|
toggleClass: k,
|
|
clone: S,
|
|
index: F,
|
|
nextTick: Ht,
|
|
cancelNextTick: Lt,
|
|
detectDirection: Ot,
|
|
getChild: m
|
|
}),
|
|
(Rt.get = function (t) {
|
|
return t[j];
|
|
}),
|
|
(Rt.mount = function () {
|
|
for (var t = arguments.length, e = new Array(t), n = 0; n < t; n++)
|
|
e[n] = arguments[n];
|
|
e[0].constructor === Array && (e = e[0]),
|
|
e.forEach(function (t) {
|
|
if (!t.prototype || !t.prototype.constructor)
|
|
throw "Sortable: Mounted plugin must be a constructor function, not ".concat(
|
|
{}.toString.call(t)
|
|
);
|
|
t.utils && (Rt.utils = I({}, Rt.utils, t.utils)), O.mount(t);
|
|
});
|
|
}),
|
|
(Rt.create = function (t, e) {
|
|
return new Rt(t, e);
|
|
});
|
|
var jt,
|
|
Kt,
|
|
Wt,
|
|
zt,
|
|
Gt,
|
|
Ut,
|
|
qt = [],
|
|
Vt = !(Rt.version = "1.13.0");
|
|
function Zt() {
|
|
qt.forEach(function (t) {
|
|
clearInterval(t.pid);
|
|
}),
|
|
(qt = []);
|
|
}
|
|
function Qt() {
|
|
clearInterval(Ut);
|
|
}
|
|
function $t(t) {
|
|
var e = t.originalEvent,
|
|
n = t.putSortable,
|
|
o = t.dragEl,
|
|
i = t.activeSortable,
|
|
r = t.dispatchSortableEvent,
|
|
a = t.hideGhostForTarget,
|
|
l = t.unhideGhostForTarget;
|
|
if (e) {
|
|
var s = n || i;
|
|
a();
|
|
var c =
|
|
e.changedTouches && e.changedTouches.length ? e.changedTouches[0] : e,
|
|
u = document.elementFromPoint(c.clientX, c.clientY);
|
|
l(),
|
|
s &&
|
|
!s.el.contains(u) &&
|
|
(r("spill"), this.onSpill({ dragEl: o, putSortable: n }));
|
|
}
|
|
}
|
|
var Jt,
|
|
te = D(function (n, t, e, o) {
|
|
if (t.scroll) {
|
|
var i,
|
|
r = (n.touches ? n.touches[0] : n).clientX,
|
|
a = (n.touches ? n.touches[0] : n).clientY,
|
|
l = t.scrollSensitivity,
|
|
s = t.scrollSpeed,
|
|
c = A(),
|
|
u = !1;
|
|
Kt !== e &&
|
|
((Kt = e),
|
|
Zt(),
|
|
(jt = t.scroll),
|
|
(i = t.scrollFn),
|
|
!0 === jt && (jt = H(e, !0)));
|
|
var d = 0,
|
|
h = jt;
|
|
do {
|
|
var f = h,
|
|
p = X(f),
|
|
g = p.top,
|
|
v = p.bottom,
|
|
m = p.left,
|
|
b = p.right,
|
|
y = p.width,
|
|
w = p.height,
|
|
E = void 0,
|
|
D = void 0,
|
|
S = f.scrollWidth,
|
|
_ = f.scrollHeight,
|
|
C = R(f),
|
|
T = f.scrollLeft,
|
|
x = f.scrollTop;
|
|
D =
|
|
f === c
|
|
? ((E =
|
|
y < S &&
|
|
("auto" === C.overflowX ||
|
|
"scroll" === C.overflowX ||
|
|
"visible" === C.overflowX)),
|
|
w < _ &&
|
|
("auto" === C.overflowY ||
|
|
"scroll" === C.overflowY ||
|
|
"visible" === C.overflowY))
|
|
: ((E =
|
|
y < S &&
|
|
("auto" === C.overflowX || "scroll" === C.overflowX)),
|
|
w < _ && ("auto" === C.overflowY || "scroll" === C.overflowY));
|
|
var M =
|
|
E &&
|
|
(Math.abs(b - r) <= l && T + y < S) -
|
|
(Math.abs(m - r) <= l && !!T),
|
|
O =
|
|
D &&
|
|
(Math.abs(v - a) <= l && x + w < _) -
|
|
(Math.abs(g - a) <= l && !!x);
|
|
if (!qt[d]) for (var N = 0; N <= d; N++) qt[N] || (qt[N] = {});
|
|
(qt[d].vx == M && qt[d].vy == O && qt[d].el === f) ||
|
|
((qt[d].el = f),
|
|
(qt[d].vx = M),
|
|
(qt[d].vy = O),
|
|
clearInterval(qt[d].pid),
|
|
(0 == M && 0 == O) ||
|
|
((u = !0),
|
|
(qt[d].pid = setInterval(
|
|
function () {
|
|
o && 0 === this.layer && Rt.active._onTouchMove(Gt);
|
|
var t = qt[this.layer].vy ? qt[this.layer].vy * s : 0,
|
|
e = qt[this.layer].vx ? qt[this.layer].vx * s : 0;
|
|
("function" == typeof i &&
|
|
"continue" !==
|
|
i.call(
|
|
Rt.dragged.parentNode[j],
|
|
e,
|
|
t,
|
|
n,
|
|
Gt,
|
|
qt[this.layer].el
|
|
)) ||
|
|
L(qt[this.layer].el, e, t);
|
|
}.bind({ layer: d }),
|
|
24
|
|
)))),
|
|
d++;
|
|
} while (t.bubbleScroll && h !== c && (h = H(h, !1)));
|
|
Vt = u;
|
|
}
|
|
}, 30);
|
|
function ee() {}
|
|
function ne() {}
|
|
(ee.prototype = {
|
|
startIndex: null,
|
|
dragStart: function (t) {
|
|
var e = t.oldDraggableIndex;
|
|
this.startIndex = e;
|
|
},
|
|
onSpill: function (t) {
|
|
var e = t.dragEl,
|
|
n = t.putSortable;
|
|
this.sortable.captureAnimationState(), n && n.captureAnimationState();
|
|
var o = m(this.sortable.el, this.startIndex, this.options);
|
|
o ? this.sortable.el.insertBefore(e, o) : this.sortable.el.appendChild(e),
|
|
this.sortable.animateAll(),
|
|
n && n.animateAll();
|
|
},
|
|
drop: $t
|
|
}),
|
|
a(ee, { pluginName: "revertOnSpill" }),
|
|
(ne.prototype = {
|
|
onSpill: function (t) {
|
|
var e = t.dragEl,
|
|
n = t.putSortable || this.sortable;
|
|
n.captureAnimationState(),
|
|
e.parentNode && e.parentNode.removeChild(e),
|
|
n.animateAll();
|
|
},
|
|
drop: $t
|
|
}),
|
|
a(ne, { pluginName: "removeOnSpill" });
|
|
var oe,
|
|
ie,
|
|
re,
|
|
ae,
|
|
le,
|
|
se = [],
|
|
ce = [],
|
|
ue = !1,
|
|
de = !1,
|
|
he = !1;
|
|
function fe(o, i) {
|
|
ce.forEach(function (t, e) {
|
|
var n = i.children[t.sortableIndex + (o ? Number(e) : 0)];
|
|
n ? i.insertBefore(t, n) : i.appendChild(t);
|
|
});
|
|
}
|
|
function pe() {
|
|
se.forEach(function (t) {
|
|
t !== re && t.parentNode && t.parentNode.removeChild(t);
|
|
});
|
|
}
|
|
return (
|
|
Rt.mount(
|
|
new (function () {
|
|
function t() {
|
|
for (var t in ((this.defaults = {
|
|
scroll: !0,
|
|
scrollSensitivity: 30,
|
|
scrollSpeed: 10,
|
|
bubbleScroll: !0
|
|
}),
|
|
this))
|
|
"_" === t.charAt(0) &&
|
|
"function" == typeof this[t] &&
|
|
(this[t] = this[t].bind(this));
|
|
}
|
|
return (
|
|
(t.prototype = {
|
|
dragStarted: function (t) {
|
|
var e = t.originalEvent;
|
|
this.sortable.nativeDraggable
|
|
? d(document, "dragover", this._handleAutoScroll)
|
|
: this.options.supportPointer
|
|
? d(document, "pointermove", this._handleFallbackAutoScroll)
|
|
: e.touches
|
|
? d(document, "touchmove", this._handleFallbackAutoScroll)
|
|
: d(document, "mousemove", this._handleFallbackAutoScroll);
|
|
},
|
|
dragOverCompleted: function (t) {
|
|
var e = t.originalEvent;
|
|
this.options.dragOverBubble ||
|
|
e.rootEl ||
|
|
this._handleAutoScroll(e);
|
|
},
|
|
drop: function () {
|
|
this.sortable.nativeDraggable
|
|
? s(document, "dragover", this._handleAutoScroll)
|
|
: (s(document, "pointermove", this._handleFallbackAutoScroll),
|
|
s(document, "touchmove", this._handleFallbackAutoScroll),
|
|
s(document, "mousemove", this._handleFallbackAutoScroll)),
|
|
Qt(),
|
|
Zt(),
|
|
clearTimeout(f),
|
|
(f = void 0);
|
|
},
|
|
nulling: function () {
|
|
(Gt = Kt = jt = Vt = Ut = Wt = zt = null), (qt.length = 0);
|
|
},
|
|
_handleFallbackAutoScroll: function (t) {
|
|
this._handleAutoScroll(t, !0);
|
|
},
|
|
_handleAutoScroll: function (e, n) {
|
|
var o = this,
|
|
i = (e.touches ? e.touches[0] : e).clientX,
|
|
r = (e.touches ? e.touches[0] : e).clientY,
|
|
t = document.elementFromPoint(i, r);
|
|
if (((Gt = e), n || E || w || u)) {
|
|
te(e, this.options, t, n);
|
|
var a = H(t, !0);
|
|
!Vt ||
|
|
(Ut && i === Wt && r === zt) ||
|
|
(Ut && Qt(),
|
|
(Ut = setInterval(function () {
|
|
var t = H(document.elementFromPoint(i, r), !0);
|
|
t !== a && ((a = t), Zt()), te(e, o.options, t, n);
|
|
}, 10)),
|
|
(Wt = i),
|
|
(zt = r));
|
|
} else {
|
|
if (!this.options.bubbleScroll || H(t, !0) === A())
|
|
return void Zt();
|
|
te(e, this.options, H(t, !1), !1);
|
|
}
|
|
}
|
|
}),
|
|
a(t, { pluginName: "scroll", initializeByDefault: !0 })
|
|
);
|
|
})()
|
|
),
|
|
Rt.mount(ne, ee),
|
|
Rt.mount(
|
|
new (function () {
|
|
function t() {
|
|
this.defaults = { swapClass: "sortable-swap-highlight" };
|
|
}
|
|
return (
|
|
(t.prototype = {
|
|
dragStart: function (t) {
|
|
var e = t.dragEl;
|
|
Jt = e;
|
|
},
|
|
dragOverValid: function (t) {
|
|
var e = t.completed,
|
|
n = t.target,
|
|
o = t.onMove,
|
|
i = t.activeSortable,
|
|
r = t.changed,
|
|
a = t.cancel;
|
|
if (i.options.swap) {
|
|
var l = this.sortable.el,
|
|
s = this.options;
|
|
if (n && n !== l) {
|
|
var c = Jt;
|
|
(Jt = !1 !== o(n) ? (k(n, s.swapClass, !0), n) : null),
|
|
c && c !== Jt && k(c, s.swapClass, !1);
|
|
}
|
|
r(), e(!0), a();
|
|
}
|
|
},
|
|
drop: function (t) {
|
|
var e = t.activeSortable,
|
|
n = t.putSortable,
|
|
o = t.dragEl,
|
|
i = n || this.sortable,
|
|
r = this.options;
|
|
Jt && k(Jt, r.swapClass, !1),
|
|
Jt &&
|
|
(r.swap || (n && n.options.swap)) &&
|
|
o !== Jt &&
|
|
(i.captureAnimationState(),
|
|
i !== e && e.captureAnimationState(),
|
|
(function (t, e) {
|
|
var n,
|
|
o,
|
|
i = t.parentNode,
|
|
r = e.parentNode;
|
|
if (!i || !r || i.isEqualNode(e) || r.isEqualNode(t))
|
|
return;
|
|
(n = F(t)), (o = F(e)), i.isEqualNode(r) && n < o && o++;
|
|
i.insertBefore(e, i.children[n]),
|
|
r.insertBefore(t, r.children[o]);
|
|
})(o, Jt),
|
|
i.animateAll(),
|
|
i !== e && e.animateAll());
|
|
},
|
|
nulling: function () {
|
|
Jt = null;
|
|
}
|
|
}),
|
|
a(t, {
|
|
pluginName: "swap",
|
|
eventProperties: function () {
|
|
return { swapItem: Jt };
|
|
}
|
|
})
|
|
);
|
|
})()
|
|
),
|
|
Rt.mount(
|
|
new (function () {
|
|
function t(o) {
|
|
for (var t in this)
|
|
"_" === t.charAt(0) &&
|
|
"function" == typeof this[t] &&
|
|
(this[t] = this[t].bind(this));
|
|
o.options.supportPointer
|
|
? d(document, "pointerup", this._deselectMultiDrag)
|
|
: (d(document, "mouseup", this._deselectMultiDrag),
|
|
d(document, "touchend", this._deselectMultiDrag)),
|
|
d(document, "keydown", this._checkKeyDown),
|
|
d(document, "keyup", this._checkKeyUp),
|
|
(this.defaults = {
|
|
selectedClass: "sortable-selected",
|
|
multiDragKey: null,
|
|
setData: function (t, e) {
|
|
var n = "";
|
|
se.length && ie === o
|
|
? se.forEach(function (t, e) {
|
|
n += (e ? ", " : "") + t.textContent;
|
|
})
|
|
: (n = e.textContent),
|
|
t.setData("Text", n);
|
|
}
|
|
});
|
|
}
|
|
return (
|
|
(t.prototype = {
|
|
multiDragKeyDown: !1,
|
|
isMultiDrag: !1,
|
|
delayStartGlobal: function (t) {
|
|
var e = t.dragEl;
|
|
re = e;
|
|
},
|
|
delayEnded: function () {
|
|
this.isMultiDrag = ~se.indexOf(re);
|
|
},
|
|
setupClone: function (t) {
|
|
var e = t.sortable,
|
|
n = t.cancel;
|
|
if (this.isMultiDrag) {
|
|
for (var o = 0; o < se.length; o++)
|
|
ce.push(S(se[o])),
|
|
(ce[o].sortableIndex = se[o].sortableIndex),
|
|
(ce[o].draggable = !1),
|
|
(ce[o].style["will-change"] = ""),
|
|
k(ce[o], this.options.selectedClass, !1),
|
|
se[o] === re && k(ce[o], this.options.chosenClass, !1);
|
|
e._hideClone(), n();
|
|
}
|
|
},
|
|
clone: function (t) {
|
|
var e = t.sortable,
|
|
n = t.rootEl,
|
|
o = t.dispatchSortableEvent,
|
|
i = t.cancel;
|
|
this.isMultiDrag &&
|
|
(this.options.removeCloneOnHide ||
|
|
(se.length && ie === e && (fe(!0, n), o("clone"), i())));
|
|
},
|
|
showClone: function (t) {
|
|
var e = t.cloneNowShown,
|
|
n = t.rootEl,
|
|
o = t.cancel;
|
|
this.isMultiDrag &&
|
|
(fe(!1, n),
|
|
ce.forEach(function (t) {
|
|
R(t, "display", "");
|
|
}),
|
|
e(),
|
|
(le = !1),
|
|
o());
|
|
},
|
|
hideClone: function (t) {
|
|
var e = this,
|
|
n = (t.sortable, t.cloneNowHidden),
|
|
o = t.cancel;
|
|
this.isMultiDrag &&
|
|
(ce.forEach(function (t) {
|
|
R(t, "display", "none"),
|
|
e.options.removeCloneOnHide &&
|
|
t.parentNode &&
|
|
t.parentNode.removeChild(t);
|
|
}),
|
|
n(),
|
|
(le = !0),
|
|
o());
|
|
},
|
|
dragStartGlobal: function (t) {
|
|
t.sortable;
|
|
!this.isMultiDrag && ie && ie.multiDrag._deselectMultiDrag(),
|
|
se.forEach(function (t) {
|
|
t.sortableIndex = F(t);
|
|
}),
|
|
(se = se.sort(function (t, e) {
|
|
return t.sortableIndex - e.sortableIndex;
|
|
})),
|
|
(he = !0);
|
|
},
|
|
dragStarted: function (t) {
|
|
var e = this,
|
|
n = t.sortable;
|
|
if (this.isMultiDrag) {
|
|
if (
|
|
this.options.sort &&
|
|
(n.captureAnimationState(), this.options.animation)
|
|
) {
|
|
se.forEach(function (t) {
|
|
t !== re && R(t, "position", "absolute");
|
|
});
|
|
var o = X(re, !1, !0, !0);
|
|
se.forEach(function (t) {
|
|
t !== re && _(t, o);
|
|
}),
|
|
(ue = de = !0);
|
|
}
|
|
n.animateAll(function () {
|
|
(ue = de = !1),
|
|
e.options.animation &&
|
|
se.forEach(function (t) {
|
|
C(t);
|
|
}),
|
|
e.options.sort && pe();
|
|
});
|
|
}
|
|
},
|
|
dragOver: function (t) {
|
|
var e = t.target,
|
|
n = t.completed,
|
|
o = t.cancel;
|
|
de && ~se.indexOf(e) && (n(!1), o());
|
|
},
|
|
revert: function (t) {
|
|
var e = t.fromSortable,
|
|
n = t.rootEl,
|
|
o = t.sortable,
|
|
i = t.dragRect;
|
|
1 < se.length &&
|
|
(se.forEach(function (t) {
|
|
o.addAnimationState({ target: t, rect: de ? X(t) : i }),
|
|
C(t),
|
|
(t.fromRect = i),
|
|
e.removeAnimationState(t);
|
|
}),
|
|
(de = !1),
|
|
(function (o, i) {
|
|
se.forEach(function (t, e) {
|
|
var n = i.children[t.sortableIndex + (o ? Number(e) : 0)];
|
|
n ? i.insertBefore(t, n) : i.appendChild(t);
|
|
});
|
|
})(!this.options.removeCloneOnHide, n));
|
|
},
|
|
dragOverCompleted: function (t) {
|
|
var e = t.sortable,
|
|
n = t.isOwner,
|
|
o = t.insertion,
|
|
i = t.activeSortable,
|
|
r = t.parentEl,
|
|
a = t.putSortable,
|
|
l = this.options;
|
|
if (o) {
|
|
if (
|
|
(n && i._hideClone(),
|
|
(ue = !1),
|
|
l.animation &&
|
|
1 < se.length &&
|
|
(de || (!n && !i.options.sort && !a)))
|
|
) {
|
|
var s = X(re, !1, !0, !0);
|
|
se.forEach(function (t) {
|
|
t !== re && (_(t, s), r.appendChild(t));
|
|
}),
|
|
(de = !0);
|
|
}
|
|
if (!n)
|
|
if ((de || pe(), 1 < se.length)) {
|
|
var c = le;
|
|
i._showClone(e),
|
|
i.options.animation &&
|
|
!le &&
|
|
c &&
|
|
ce.forEach(function (t) {
|
|
i.addAnimationState({ target: t, rect: ae }),
|
|
(t.fromRect = ae),
|
|
(t.thisAnimationDuration = null);
|
|
});
|
|
} else i._showClone(e);
|
|
}
|
|
},
|
|
dragOverAnimationCapture: function (t) {
|
|
var e = t.dragRect,
|
|
n = t.isOwner,
|
|
o = t.activeSortable;
|
|
if (
|
|
(se.forEach(function (t) {
|
|
t.thisAnimationDuration = null;
|
|
}),
|
|
o.options.animation && !n && o.multiDrag.isMultiDrag)
|
|
) {
|
|
ae = a({}, e);
|
|
var i = v(re, !0);
|
|
(ae.top -= i.f), (ae.left -= i.e);
|
|
}
|
|
},
|
|
dragOverAnimationComplete: function () {
|
|
de && ((de = !1), pe());
|
|
},
|
|
drop: function (t) {
|
|
var e = t.originalEvent,
|
|
n = t.rootEl,
|
|
o = t.parentEl,
|
|
i = t.sortable,
|
|
r = t.dispatchSortableEvent,
|
|
a = t.oldIndex,
|
|
l = t.putSortable,
|
|
s = l || this.sortable;
|
|
if (e) {
|
|
var c = this.options,
|
|
u = o.children;
|
|
if (!he)
|
|
if (
|
|
(c.multiDragKey &&
|
|
!this.multiDragKeyDown &&
|
|
this._deselectMultiDrag(),
|
|
k(re, c.selectedClass, !~se.indexOf(re)),
|
|
~se.indexOf(re))
|
|
)
|
|
se.splice(se.indexOf(re), 1),
|
|
(oe = null),
|
|
N({
|
|
sortable: i,
|
|
rootEl: n,
|
|
name: "deselect",
|
|
targetEl: re,
|
|
originalEvt: e
|
|
});
|
|
else {
|
|
if (
|
|
(se.push(re),
|
|
N({
|
|
sortable: i,
|
|
rootEl: n,
|
|
name: "select",
|
|
targetEl: re,
|
|
originalEvt: e
|
|
}),
|
|
e.shiftKey && oe && i.el.contains(oe))
|
|
) {
|
|
var d,
|
|
h,
|
|
f = F(oe),
|
|
p = F(re);
|
|
if (~f && ~p && f !== p)
|
|
for (
|
|
d = f < p ? ((h = f), p) : ((h = p), f + 1);
|
|
h < d;
|
|
h++
|
|
)
|
|
~se.indexOf(u[h]) ||
|
|
(k(u[h], c.selectedClass, !0),
|
|
se.push(u[h]),
|
|
N({
|
|
sortable: i,
|
|
rootEl: n,
|
|
name: "select",
|
|
targetEl: u[h],
|
|
originalEvt: e
|
|
}));
|
|
} else oe = re;
|
|
ie = s;
|
|
}
|
|
if (he && this.isMultiDrag) {
|
|
if ((o[j].options.sort || o !== n) && 1 < se.length) {
|
|
var g = X(re),
|
|
v = F(re, ":not(." + this.options.selectedClass + ")");
|
|
if (
|
|
(!ue && c.animation && (re.thisAnimationDuration = null),
|
|
s.captureAnimationState(),
|
|
!ue &&
|
|
(c.animation &&
|
|
((re.fromRect = g),
|
|
se.forEach(function (t) {
|
|
if (((t.thisAnimationDuration = null), t !== re)) {
|
|
var e = de ? X(t) : g;
|
|
(t.fromRect = e),
|
|
s.addAnimationState({ target: t, rect: e });
|
|
}
|
|
})),
|
|
pe(),
|
|
se.forEach(function (t) {
|
|
u[v] ? o.insertBefore(t, u[v]) : o.appendChild(t),
|
|
v++;
|
|
}),
|
|
a === F(re)))
|
|
) {
|
|
var m = !1;
|
|
se.forEach(function (t) {
|
|
t.sortableIndex === F(t) || (m = !0);
|
|
}),
|
|
m && r("update");
|
|
}
|
|
se.forEach(function (t) {
|
|
C(t);
|
|
}),
|
|
s.animateAll();
|
|
}
|
|
ie = s;
|
|
}
|
|
(n === o || (l && "clone" !== l.lastPutMode)) &&
|
|
ce.forEach(function (t) {
|
|
t.parentNode && t.parentNode.removeChild(t);
|
|
});
|
|
}
|
|
},
|
|
nullingGlobal: function () {
|
|
(this.isMultiDrag = he = !1), (ce.length = 0);
|
|
},
|
|
destroyGlobal: function () {
|
|
this._deselectMultiDrag(),
|
|
s(document, "pointerup", this._deselectMultiDrag),
|
|
s(document, "mouseup", this._deselectMultiDrag),
|
|
s(document, "touchend", this._deselectMultiDrag),
|
|
s(document, "keydown", this._checkKeyDown),
|
|
s(document, "keyup", this._checkKeyUp);
|
|
},
|
|
_deselectMultiDrag: function (t) {
|
|
if (
|
|
!(
|
|
(void 0 !== he && he) ||
|
|
ie !== this.sortable ||
|
|
(t &&
|
|
P(
|
|
t.target,
|
|
this.options.draggable,
|
|
this.sortable.el,
|
|
!1
|
|
)) ||
|
|
(t && 0 !== t.button)
|
|
)
|
|
)
|
|
for (; se.length; ) {
|
|
var e = se[0];
|
|
k(e, this.options.selectedClass, !1),
|
|
se.shift(),
|
|
N({
|
|
sortable: this.sortable,
|
|
rootEl: this.sortable.el,
|
|
name: "deselect",
|
|
targetEl: e,
|
|
originalEvt: t
|
|
});
|
|
}
|
|
},
|
|
_checkKeyDown: function (t) {
|
|
t.key === this.options.multiDragKey &&
|
|
(this.multiDragKeyDown = !0);
|
|
},
|
|
_checkKeyUp: function (t) {
|
|
t.key === this.options.multiDragKey &&
|
|
(this.multiDragKeyDown = !1);
|
|
}
|
|
}),
|
|
a(t, {
|
|
pluginName: "multiDrag",
|
|
utils: {
|
|
select: function (t) {
|
|
var e = t.parentNode[j];
|
|
e &&
|
|
e.options.multiDrag &&
|
|
!~se.indexOf(t) &&
|
|
(ie &&
|
|
ie !== e &&
|
|
(ie.multiDrag._deselectMultiDrag(), (ie = e)),
|
|
k(t, e.options.selectedClass, !0),
|
|
se.push(t));
|
|
},
|
|
deselect: function (t) {
|
|
var e = t.parentNode[j],
|
|
n = se.indexOf(t);
|
|
e &&
|
|
e.options.multiDrag &&
|
|
~n &&
|
|
(k(t, e.options.selectedClass, !1), se.splice(n, 1));
|
|
}
|
|
},
|
|
eventProperties: function () {
|
|
var n = this,
|
|
o = [],
|
|
i = [];
|
|
return (
|
|
se.forEach(function (t) {
|
|
var e;
|
|
o.push({ multiDragElement: t, index: t.sortableIndex }),
|
|
(e =
|
|
de && t !== re
|
|
? -1
|
|
: de
|
|
? F(t, ":not(." + n.options.selectedClass + ")")
|
|
: F(t)),
|
|
i.push({ multiDragElement: t, index: e });
|
|
}),
|
|
{
|
|
items: e(se),
|
|
clones: [].concat(ce),
|
|
oldIndicies: o,
|
|
newIndicies: i
|
|
}
|
|
);
|
|
},
|
|
optionListeners: {
|
|
multiDragKey: function (t) {
|
|
return (
|
|
"ctrl" === (t = t.toLowerCase())
|
|
? (t = "Control")
|
|
: 1 < t.length &&
|
|
(t = t.charAt(0).toUpperCase() + t.substr(1)),
|
|
t
|
|
);
|
|
}
|
|
}
|
|
})
|
|
);
|
|
})()
|
|
),
|
|
Rt
|
|
);
|
|
});
|