From b9b04f1ab23e8bfa7a42dcbe2152b1d9fb8ec658 Mon Sep 17 00:00:00 2001 From: ro Date: Thu, 7 Mar 2024 15:42:11 -0600 Subject: [PATCH] page api rewire, pt 1 start building out the new version of the page editing api while making some changes to the original scripts for added flexibility and using the full range of HTTP methods that weren't being used before. currenlty, it's just an end to end test to make sure the plumbing works as it should data is being passed and can be processed. now that it all works, the guts of page editing can be completed update sortablejs to the latest since it's been awhile and got rid of the old version --- .../Controllers/API/PageAPIController.php | 30 + .../dash/app/controllers/PageEditor.js | 7 +- .../scripts/dash/app/events/DataEvent.js | 97 +- .../assets/scripts/dash/app/ui/FileManager.js | 20 +- .../dash/app/vendor/sortable.core.esm.js | 3350 +++++++++++++++++ .../scripts/dash/app/vendor/sortable.js | 1513 -------- .../scripts/dash/libraries/FipamoAdminAPI.js | 7 +- resources/views/back/page.blade.php | 3 +- routes/api.php | 3 + 9 files changed, 3458 insertions(+), 1572 deletions(-) create mode 100644 app/Http/Controllers/API/PageAPIController.php create mode 100644 public/assets/scripts/dash/app/vendor/sortable.core.esm.js delete mode 100644 public/assets/scripts/dash/app/vendor/sortable.js diff --git a/app/Http/Controllers/API/PageAPIController.php b/app/Http/Controllers/API/PageAPIController.php new file mode 100644 index 0000000..ad9355a --- /dev/null +++ b/app/Http/Controllers/API/PageAPIController.php @@ -0,0 +1,30 @@ +auth = $authService; + } + + public function write(Request $request) + { + $body = json_decode($request->getContent()); + //var_dump($body); + + $result = [ + 'message' => 'API IS CONNECTED', + 'type' => 'apiTesting', + 'uuid' => $body->uuid, + ]; + + return response()->json($result)->header('Content-Type', 'application/json'); + } +} diff --git a/public/assets/scripts/dash/app/controllers/PageEditor.js b/public/assets/scripts/dash/app/controllers/PageEditor.js index 9d7f134..57ab0e7 100644 --- a/public/assets/scripts/dash/app/controllers/PageEditor.js +++ b/public/assets/scripts/dash/app/controllers/PageEditor.js @@ -94,7 +94,7 @@ export default class PostEditor { this.fm = new FileManager( document.querySelector('[role="file-drop"]'), document.getElementById('page-files-upload'), - document.querySelector('[role="page-images-list"]'), + document.getElementById('page-images-list'), document.querySelector('[role="page-files-list"]') ); var optionButtons = document.querySelectorAll('.post-option-btn'); @@ -156,7 +156,10 @@ export default class PostEditor { ) { notify.alert(r.message, false); } else { - if (r.type === DataEvent.PAGE_UPDATED) { + if ( + r.type === DataEvent.PAGE_UPDATED || + r.type === DataEvent.API_TESTING + ) { notify.alert(r.message, true); } else { notify.alert(r.message, true); diff --git a/public/assets/scripts/dash/app/events/DataEvent.js b/public/assets/scripts/dash/app/events/DataEvent.js index fd0a8f2..cffdce3 100644 --- a/public/assets/scripts/dash/app/events/DataEvent.js +++ b/public/assets/scripts/dash/app/events/DataEvent.js @@ -1,51 +1,52 @@ -export const AUTH_STATUS = "getAuthStatus"; -export const REQUEST_GOOD = "requestGood"; -export const REQUEST_LAME = "requestLame"; -export const API_REQUEST_GOOD = "apiUseAuthorized"; -export const API_REQUEST_LAME = "apiUseNotAuthorized"; -export const IMG_REQUEST_GOOD = "imgRequestGood"; -export const IMG_REQUEST_LAME = "imgRequestLame"; -export const SETTINGS_LOADED = "settingsLoaded"; -export const POST_IMAGE_ADDED = "postImageAdded"; -export const FEATURE_IMAGE_ADDED = "featureImageAdded"; -export const PAGE_ERROR = "postError"; -export const PAGE_ADDED = "postAdded"; -export const PAGE_UPDATED = "postUpdated"; -export const PAGE_DELETED = "postImageAdded"; -export const PAGES_RENDERED = "pagesRendered"; -export const PAGES_NOT_RENDERED = "pagesNotRendered"; -export const TAG_PAGES_RENDERED = "tagPagesRendered"; -export const TAG_PAGES_NOT_RENDERED = "tagPagesNotRendered"; -export const SETTINGS_UPDATED = "settingsUpdated"; -export const SETTINGS_NOT_UPDATED = "settingsNotUpdated"; -export const MENU_ADD_ITEM = "menuAddItem"; -export const MENU_DELETE_ITEM = "menuDeleteItem"; -export const MENU_UPDATED = "menuUpdated"; -export const AVATAR_UPLOADED = "avatarUploaded"; -export const SITE_BACKGROUND_UPLOADED = "siteBackgroundUploaded"; -export const UPLOAD_PROGRESS = "uploadProgress"; -export const API_PAGE_WRITE = "writingItDown"; -export const API_PAGE_CREATE = "writingNewEntry"; -export const API_PAGE_DELETE = "erasingPage"; -export const API_SETTINGS_WRITE = "savingSettings"; -export const API_BACKUP_CREATE = "createBackup"; -export const API_BACKUP_DOWNLOAD = "downloadBackup"; -export const API_BACKUP_RESTORE = "downloadBackup"; -export const API_IMAGES_UPLOAD = "uploadProfileImages"; -export const API_RENDER_PAGES = "renderPages"; -export const API_REINDEX_PAGES = "reindexPages"; -export const API_INIT = "blogInit"; -export const API_INIT_GOOD = "blogInitGood"; -export const API_INIT_LAME = "blogInitLame"; -export const API_GET_SECRET = "retrieveSecret"; -export const API_RESET_PASS = "resetPassword"; -export const SEND_MAIL = "sendMail"; +export const AUTH_STATUS = 'getAuthStatus'; +export const REQUEST_GOOD = 'requestGood'; +export const REQUEST_LAME = 'requestLame'; +export const API_REQUEST_GOOD = 'apiUseAuthorized'; +export const API_REQUEST_LAME = 'apiUseNotAuthorized'; +export const IMG_REQUEST_GOOD = 'imgRequestGood'; +export const IMG_REQUEST_LAME = 'imgRequestLame'; +export const SETTINGS_LOADED = 'settingsLoaded'; +export const POST_IMAGE_ADDED = 'postImageAdded'; +export const FEATURE_IMAGE_ADDED = 'featureImageAdded'; +export const PAGE_ERROR = 'postError'; +export const PAGE_ADDED = 'postAdded'; +export const PAGE_UPDATED = 'postUpdated'; +export const PAGE_DELETED = 'postImageAdded'; +export const PAGES_RENDERED = 'pagesRendered'; +export const PAGES_NOT_RENDERED = 'pagesNotRendered'; +export const TAG_PAGES_RENDERED = 'tagPagesRendered'; +export const TAG_PAGES_NOT_RENDERED = 'tagPagesNotRendered'; +export const SETTINGS_UPDATED = 'settingsUpdated'; +export const SETTINGS_NOT_UPDATED = 'settingsNotUpdated'; +export const MENU_ADD_ITEM = 'menuAddItem'; +export const MENU_DELETE_ITEM = 'menuDeleteItem'; +export const MENU_UPDATED = 'menuUpdated'; +export const AVATAR_UPLOADED = 'avatarUploaded'; +export const SITE_BACKGROUND_UPLOADED = 'siteBackgroundUploaded'; +export const UPLOAD_PROGRESS = 'uploadProgress'; +export const API_PAGE_WRITE = 'writingItDown'; +export const API_PAGE_CREATE = 'writingNewEntry'; +export const API_PAGE_DELETE = 'erasingPage'; +export const API_SETTINGS_WRITE = 'savingSettings'; +export const API_BACKUP_CREATE = 'createBackup'; +export const API_BACKUP_DOWNLOAD = 'downloadBackup'; +export const API_BACKUP_RESTORE = 'downloadBackup'; +export const API_IMAGES_UPLOAD = 'uploadProfileImages'; +export const API_RENDER_PAGES = 'renderPages'; +export const API_REINDEX_PAGES = 'reindexPages'; +export const API_INIT = 'blogInit'; +export const API_INIT_GOOD = 'blogInitGood'; +export const API_INIT_LAME = 'blogInitLame'; +export const API_GET_SECRET = 'retrieveSecret'; +export const API_RESET_PASS = 'resetPassword'; +export const API_TESTING = 'apiTesting'; +export const SEND_MAIL = 'sendMail'; class DataEvent { - //-------------------------- - // methods - //-------------------------- - //-------------------------- - // event handlers - //-------------------------- + //-------------------------- + // methods + //-------------------------- + //-------------------------- + // event handlers + //-------------------------- } export default new DataEvent(); diff --git a/public/assets/scripts/dash/app/ui/FileManager.js b/public/assets/scripts/dash/app/ui/FileManager.js index c90e83a..a88904c 100644 --- a/public/assets/scripts/dash/app/ui/FileManager.js +++ b/public/assets/scripts/dash/app/ui/FileManager.js @@ -1,4 +1,4 @@ -import Sortable from '../vendor/sortable.js'; +import Sortable from '../vendor/sortable.core.esm.js'; import anime from '../vendor/anime.es.js'; import DataUtils from '../utils/DataUtils.js'; import Notfications from './Notifications.js'; @@ -64,13 +64,23 @@ export default class FileManager { getFileOrder() { let imgList = ''; let fileList = ''; + //change file order this and chance data-source to data-id + //console.log('ORDER', this.mediaSort.toArray()); for (var i = 0, length = this.imageList.childNodes.length; i < length; i++) { - let div = this.imageList.childNodes[i]; - imgList = imgList + div.getAttribute('data-source') + ','; + try { + let div = this.imageList.childNodes[i]; + imgList = imgList + div.getAttribute('data-source') + ','; + } catch (e) { + //something is function + } } for (var i = 0, length = this.fileList.childNodes.length; i < length; i++) { - let div = this.fileList.childNodes[i]; - fileList = fileList + div.getAttribute('data-source') + ','; + try { + let div = this.fileList.childNodes[i]; + fileList = fileList + div.getAttribute('data-source') + ','; + } catch (e) { + //something is function + } } let media = { images: imgList, files: fileList }; return media; diff --git a/public/assets/scripts/dash/app/vendor/sortable.core.esm.js b/public/assets/scripts/dash/app/vendor/sortable.core.esm.js new file mode 100644 index 0000000..93ba175 --- /dev/null +++ b/public/assets/scripts/dash/app/vendor/sortable.core.esm.js @@ -0,0 +1,3350 @@ +/**! + * Sortable 1.15.2 + * @author RubaXa + * @author owenm + * @license MIT + */ +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) { + symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + } + keys.push.apply(keys, symbols); + } + return keys; +} +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + return target; +} +function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + return _typeof(obj); +} +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); +} +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + return target; +} +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + var target = _objectWithoutPropertiesLoose(source, excluded); + var key, i; + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + return target; +} +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); +} +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + return arr2; +} +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +var version = "1.15.2"; + +function userAgent(pattern) { + if (typeof window !== 'undefined' && window.navigator) { + return !! /*@__PURE__*/navigator.userAgent.match(pattern); + } +} +var IE11OrLess = userAgent(/(?:Trident.*rv[ :]?11\.|msie|iemobile|Windows Phone)/i); +var Edge = userAgent(/Edge/i); +var FireFox = userAgent(/firefox/i); +var Safari = userAgent(/safari/i) && !userAgent(/chrome/i) && !userAgent(/android/i); +var IOS = userAgent(/iP(ad|od|hone)/i); +var ChromeForAndroid = userAgent(/chrome/i) && userAgent(/android/i); + +var captureMode = { + capture: false, + passive: false +}; +function on(el, event, fn) { + el.addEventListener(event, fn, !IE11OrLess && captureMode); +} +function off(el, event, fn) { + el.removeEventListener(event, fn, !IE11OrLess && captureMode); +} +function matches( /**HTMLElement*/el, /**String*/selector) { + if (!selector) return; + selector[0] === '>' && (selector = selector.substring(1)); + if (el) { + try { + if (el.matches) { + return el.matches(selector); + } else if (el.msMatchesSelector) { + return el.msMatchesSelector(selector); + } else if (el.webkitMatchesSelector) { + return el.webkitMatchesSelector(selector); + } + } catch (_) { + return false; + } + } + return false; +} +function getParentOrHost(el) { + return el.host && el !== document && el.host.nodeType ? el.host : el.parentNode; +} +function closest( /**HTMLElement*/el, /**String*/selector, /**HTMLElement*/ctx, includeCTX) { + if (el) { + ctx = ctx || document; + do { + if (selector != null && (selector[0] === '>' ? el.parentNode === ctx && matches(el, selector) : matches(el, selector)) || includeCTX && el === ctx) { + return el; + } + if (el === ctx) break; + /* jshint boss:true */ + } while (el = getParentOrHost(el)); + } + return null; +} +var R_SPACE = /\s+/g; +function toggleClass(el, name, state) { + if (el && name) { + if (el.classList) { + el.classList[state ? 'add' : 'remove'](name); + } else { + var className = (' ' + el.className + ' ').replace(R_SPACE, ' ').replace(' ' + name + ' ', ' '); + el.className = (className + (state ? ' ' + name : '')).replace(R_SPACE, ' '); + } + } +} +function css(el, prop, val) { + var style = el && el.style; + if (style) { + if (val === void 0) { + if (document.defaultView && document.defaultView.getComputedStyle) { + val = document.defaultView.getComputedStyle(el, ''); + } else if (el.currentStyle) { + val = el.currentStyle; + } + return prop === void 0 ? val : val[prop]; + } else { + if (!(prop in style) && prop.indexOf('webkit') === -1) { + prop = '-webkit-' + prop; + } + style[prop] = val + (typeof val === 'string' ? '' : 'px'); + } + } +} +function matrix(el, selfOnly) { + var appliedTransforms = ''; + if (typeof el === 'string') { + appliedTransforms = el; + } else { + do { + var transform = css(el, 'transform'); + if (transform && transform !== 'none') { + appliedTransforms = transform + ' ' + appliedTransforms; + } + /* jshint boss:true */ + } while (!selfOnly && (el = el.parentNode)); + } + var matrixFn = window.DOMMatrix || window.WebKitCSSMatrix || window.CSSMatrix || window.MSCSSMatrix; + /*jshint -W056 */ + return matrixFn && new matrixFn(appliedTransforms); +} +function find(ctx, tagName, iterator) { + if (ctx) { + var list = ctx.getElementsByTagName(tagName), + i = 0, + n = list.length; + if (iterator) { + for (; i < n; i++) { + iterator(list[i], i); + } + } + return list; + } + return []; +} +function getWindowScrollingElement() { + var scrollingElement = document.scrollingElement; + if (scrollingElement) { + return scrollingElement; + } else { + return document.documentElement; + } +} + +/** + * Returns the "bounding client rect" of given element + * @param {HTMLElement} el The element whose boundingClientRect is wanted + * @param {[Boolean]} relativeToContainingBlock Whether the rect should be relative to the containing block of (including) the container + * @param {[Boolean]} relativeToNonStaticParent Whether the rect should be relative to the relative parent of (including) the contaienr + * @param {[Boolean]} undoScale Whether the container's scale() should be undone + * @param {[HTMLElement]} container The parent the element will be placed in + * @return {Object} The boundingClientRect of el, with specified adjustments + */ +function getRect(el, relativeToContainingBlock, relativeToNonStaticParent, undoScale, container) { + if (!el.getBoundingClientRect && el !== window) return; + var elRect, top, left, bottom, right, height, width; + if (el !== window && el.parentNode && el !== getWindowScrollingElement()) { + elRect = el.getBoundingClientRect(); + top = elRect.top; + left = elRect.left; + bottom = elRect.bottom; + right = elRect.right; + height = elRect.height; + width = elRect.width; + } else { + top = 0; + left = 0; + bottom = window.innerHeight; + right = window.innerWidth; + height = window.innerHeight; + width = window.innerWidth; + } + if ((relativeToContainingBlock || relativeToNonStaticParent) && el !== window) { + // Adjust for translate() + container = container || el.parentNode; + + // solves #1123 (see: https://stackoverflow.com/a/37953806/6088312) + // Not needed on <= IE11 + if (!IE11OrLess) { + do { + if (container && container.getBoundingClientRect && (css(container, 'transform') !== 'none' || relativeToNonStaticParent && css(container, 'position') !== 'static')) { + var containerRect = container.getBoundingClientRect(); + + // Set relative to edges of padding box of container + top -= containerRect.top + parseInt(css(container, 'border-top-width')); + left -= containerRect.left + parseInt(css(container, 'border-left-width')); + bottom = top + elRect.height; + right = left + elRect.width; + break; + } + /* jshint boss:true */ + } while (container = container.parentNode); + } + } + if (undoScale && el !== window) { + // Adjust for scale() + var elMatrix = matrix(container || el), + scaleX = elMatrix && elMatrix.a, + scaleY = elMatrix && elMatrix.d; + if (elMatrix) { + top /= scaleY; + left /= scaleX; + width /= scaleX; + height /= scaleY; + bottom = top + height; + right = left + width; + } + } + return { + top: top, + left: left, + bottom: bottom, + right: right, + width: width, + height: height + }; +} + +/** + * Checks if a side of an element is scrolled past a side of its parents + * @param {HTMLElement} el The element who's side being scrolled out of view is in question + * @param {String} elSide Side of the element in question ('top', 'left', 'right', 'bottom') + * @param {String} parentSide Side of the parent in question ('top', 'left', 'right', 'bottom') + * @return {HTMLElement} The parent scroll element that the el's side is scrolled past, or null if there is no such element + */ +function isScrolledPast(el, elSide, parentSide) { + var parent = getParentAutoScrollElement(el, true), + elSideVal = getRect(el)[elSide]; + + /* jshint boss:true */ + while (parent) { + var parentSideVal = getRect(parent)[parentSide], + visible = void 0; + if (parentSide === 'top' || parentSide === 'left') { + visible = elSideVal >= parentSideVal; + } else { + visible = elSideVal <= parentSideVal; + } + if (!visible) return parent; + if (parent === getWindowScrollingElement()) break; + parent = getParentAutoScrollElement(parent, false); + } + return false; +} + +/** + * Gets nth child of el, ignoring hidden children, sortable's elements (does not ignore clone if it's visible) + * and non-draggable elements + * @param {HTMLElement} el The parent element + * @param {Number} childNum The index of the child + * @param {Object} options Parent Sortable's options + * @return {HTMLElement} The child at index childNum, or null if not found + */ +function getChild(el, childNum, options, includeDragEl) { + var currentChild = 0, + i = 0, + children = el.children; + while (i < children.length) { + if (children[i].style.display !== 'none' && children[i] !== Sortable.ghost && (includeDragEl || children[i] !== Sortable.dragged) && closest(children[i], options.draggable, el, false)) { + if (currentChild === childNum) { + return children[i]; + } + currentChild++; + } + i++; + } + return null; +} + +/** + * Gets the last child in the el, ignoring ghostEl or invisible elements (clones) + * @param {HTMLElement} el Parent element + * @param {selector} selector Any other elements that should be ignored + * @return {HTMLElement} The last child, ignoring ghostEl + */ +function lastChild(el, selector) { + var last = el.lastElementChild; + while (last && (last === Sortable.ghost || css(last, 'display') === 'none' || selector && !matches(last, selector))) { + last = last.previousElementSibling; + } + return last || null; +} + +/** + * Returns the index of an element within its parent for a selected set of + * elements + * @param {HTMLElement} el + * @param {selector} selector + * @return {number} + */ +function index(el, selector) { + var index = 0; + if (!el || !el.parentNode) { + return -1; + } + + /* jshint boss:true */ + while (el = el.previousElementSibling) { + if (el.nodeName.toUpperCase() !== 'TEMPLATE' && el !== Sortable.clone && (!selector || matches(el, selector))) { + index++; + } + } + return index; +} + +/** + * Returns the scroll offset of the given element, added with all the scroll offsets of parent elements. + * The value is returned in real pixels. + * @param {HTMLElement} el + * @return {Array} Offsets in the format of [left, top] + */ +function getRelativeScrollOffset(el) { + var offsetLeft = 0, + offsetTop = 0, + winScroller = getWindowScrollingElement(); + if (el) { + do { + var elMatrix = matrix(el), + scaleX = elMatrix.a, + scaleY = elMatrix.d; + offsetLeft += el.scrollLeft * scaleX; + offsetTop += el.scrollTop * scaleY; + } while (el !== winScroller && (el = el.parentNode)); + } + return [offsetLeft, offsetTop]; +} + +/** + * Returns the index of the object within the given array + * @param {Array} arr Array that may or may not hold the object + * @param {Object} obj An object that has a key-value pair unique to and identical to a key-value pair in the object you want to find + * @return {Number} The index of the object in the array, or -1 + */ +function indexOfObject(arr, obj) { + for (var i in arr) { + if (!arr.hasOwnProperty(i)) continue; + for (var key in obj) { + if (obj.hasOwnProperty(key) && obj[key] === arr[i][key]) return Number(i); + } + } + return -1; +} +function getParentAutoScrollElement(el, includeSelf) { + // skip to window + if (!el || !el.getBoundingClientRect) return getWindowScrollingElement(); + var elem = el; + var gotSelf = false; + do { + // we don't need to get elem css if it isn't even overflowing in the first place (performance) + if (elem.clientWidth < elem.scrollWidth || elem.clientHeight < elem.scrollHeight) { + var elemCSS = css(elem); + if (elem.clientWidth < elem.scrollWidth && (elemCSS.overflowX == 'auto' || elemCSS.overflowX == 'scroll') || elem.clientHeight < elem.scrollHeight && (elemCSS.overflowY == 'auto' || elemCSS.overflowY == 'scroll')) { + if (!elem.getBoundingClientRect || elem === document.body) return getWindowScrollingElement(); + if (gotSelf || includeSelf) return elem; + gotSelf = true; + } + } + /* jshint boss:true */ + } while (elem = elem.parentNode); + return getWindowScrollingElement(); +} +function extend(dst, src) { + if (dst && src) { + for (var key in src) { + if (src.hasOwnProperty(key)) { + dst[key] = src[key]; + } + } + } + return dst; +} +function isRectEqual(rect1, rect2) { + return Math.round(rect1.top) === Math.round(rect2.top) && Math.round(rect1.left) === Math.round(rect2.left) && Math.round(rect1.height) === Math.round(rect2.height) && Math.round(rect1.width) === Math.round(rect2.width); +} +var _throttleTimeout; +function throttle(callback, ms) { + return function () { + if (!_throttleTimeout) { + var args = arguments, + _this = this; + if (args.length === 1) { + callback.call(_this, args[0]); + } else { + callback.apply(_this, args); + } + _throttleTimeout = setTimeout(function () { + _throttleTimeout = void 0; + }, ms); + } + }; +} +function cancelThrottle() { + clearTimeout(_throttleTimeout); + _throttleTimeout = void 0; +} +function scrollBy(el, x, y) { + el.scrollLeft += x; + el.scrollTop += y; +} +function clone(el) { + var Polymer = window.Polymer; + var $ = window.jQuery || window.Zepto; + if (Polymer && Polymer.dom) { + return Polymer.dom(el).cloneNode(true); + } else if ($) { + return $(el).clone(true)[0]; + } else { + return el.cloneNode(true); + } +} +function setRect(el, rect) { + css(el, 'position', 'absolute'); + css(el, 'top', rect.top); + css(el, 'left', rect.left); + css(el, 'width', rect.width); + css(el, 'height', rect.height); +} +function unsetRect(el) { + css(el, 'position', ''); + css(el, 'top', ''); + css(el, 'left', ''); + css(el, 'width', ''); + css(el, 'height', ''); +} +function getChildContainingRectFromElement(container, options, ghostEl) { + var rect = {}; + Array.from(container.children).forEach(function (child) { + var _rect$left, _rect$top, _rect$right, _rect$bottom; + if (!closest(child, options.draggable, container, false) || child.animated || child === ghostEl) return; + var childRect = getRect(child); + rect.left = Math.min((_rect$left = rect.left) !== null && _rect$left !== void 0 ? _rect$left : Infinity, childRect.left); + rect.top = Math.min((_rect$top = rect.top) !== null && _rect$top !== void 0 ? _rect$top : Infinity, childRect.top); + rect.right = Math.max((_rect$right = rect.right) !== null && _rect$right !== void 0 ? _rect$right : -Infinity, childRect.right); + rect.bottom = Math.max((_rect$bottom = rect.bottom) !== null && _rect$bottom !== void 0 ? _rect$bottom : -Infinity, childRect.bottom); + }); + rect.width = rect.right - rect.left; + rect.height = rect.bottom - rect.top; + rect.x = rect.left; + rect.y = rect.top; + return rect; +} +var expando = 'Sortable' + new Date().getTime(); + +function AnimationStateManager() { + var animationStates = [], + animationCallbackId; + return { + captureAnimationState: function captureAnimationState() { + animationStates = []; + if (!this.options.animation) return; + var children = [].slice.call(this.el.children); + children.forEach(function (child) { + if (css(child, 'display') === 'none' || child === Sortable.ghost) return; + animationStates.push({ + target: child, + rect: getRect(child) + }); + var fromRect = _objectSpread2({}, animationStates[animationStates.length - 1].rect); + + // If animating: compensate for current animation + if (child.thisAnimationDuration) { + var childMatrix = matrix(child, true); + if (childMatrix) { + fromRect.top -= childMatrix.f; + fromRect.left -= childMatrix.e; + } + } + child.fromRect = fromRect; + }); + }, + addAnimationState: function addAnimationState(state) { + animationStates.push(state); + }, + removeAnimationState: function removeAnimationState(target) { + animationStates.splice(indexOfObject(animationStates, { + target: target + }), 1); + }, + animateAll: function animateAll(callback) { + var _this = this; + if (!this.options.animation) { + clearTimeout(animationCallbackId); + if (typeof callback === 'function') callback(); + return; + } + var animating = false, + animationTime = 0; + animationStates.forEach(function (state) { + var time = 0, + target = state.target, + fromRect = target.fromRect, + toRect = getRect(target), + prevFromRect = target.prevFromRect, + prevToRect = target.prevToRect, + animatingRect = state.rect, + targetMatrix = matrix(target, true); + if (targetMatrix) { + // Compensate for current animation + toRect.top -= targetMatrix.f; + toRect.left -= targetMatrix.e; + } + target.toRect = toRect; + if (target.thisAnimationDuration) { + // Could also check if animatingRect is between fromRect and toRect + if (isRectEqual(prevFromRect, toRect) && !isRectEqual(fromRect, toRect) && + // Make sure animatingRect is on line between toRect & fromRect + (animatingRect.top - toRect.top) / (animatingRect.left - toRect.left) === (fromRect.top - toRect.top) / (fromRect.left - toRect.left)) { + // If returning to same place as started from animation and on same axis + time = calculateRealTime(animatingRect, prevFromRect, prevToRect, _this.options); + } + } + + // if fromRect != toRect: animate + if (!isRectEqual(toRect, fromRect)) { + target.prevFromRect = fromRect; + target.prevToRect = toRect; + if (!time) { + time = _this.options.animation; + } + _this.animate(target, animatingRect, toRect, time); + } + if (time) { + animating = true; + animationTime = Math.max(animationTime, time); + clearTimeout(target.animationResetTimer); + target.animationResetTimer = setTimeout(function () { + target.animationTime = 0; + target.prevFromRect = null; + target.fromRect = null; + target.prevToRect = null; + target.thisAnimationDuration = null; + }, time); + target.thisAnimationDuration = time; + } + }); + clearTimeout(animationCallbackId); + if (!animating) { + if (typeof callback === 'function') callback(); + } else { + animationCallbackId = setTimeout(function () { + if (typeof callback === 'function') callback(); + }, animationTime); + } + animationStates = []; + }, + animate: function animate(target, currentRect, toRect, duration) { + if (duration) { + css(target, 'transition', ''); + css(target, 'transform', ''); + var elMatrix = matrix(this.el), + scaleX = elMatrix && elMatrix.a, + scaleY = elMatrix && elMatrix.d, + translateX = (currentRect.left - toRect.left) / (scaleX || 1), + translateY = (currentRect.top - toRect.top) / (scaleY || 1); + target.animatingX = !!translateX; + target.animatingY = !!translateY; + css(target, 'transform', 'translate3d(' + translateX + 'px,' + translateY + 'px,0)'); + this.forRepaintDummy = repaint(target); // repaint + + css(target, 'transition', 'transform ' + duration + 'ms' + (this.options.easing ? ' ' + this.options.easing : '')); + css(target, 'transform', 'translate3d(0,0,0)'); + typeof target.animated === 'number' && clearTimeout(target.animated); + target.animated = setTimeout(function () { + css(target, 'transition', ''); + css(target, 'transform', ''); + target.animated = false; + target.animatingX = false; + target.animatingY = false; + }, duration); + } + } + }; +} +function repaint(target) { + return target.offsetWidth; +} +function calculateRealTime(animatingRect, fromRect, toRect, options) { + return Math.sqrt(Math.pow(fromRect.top - animatingRect.top, 2) + Math.pow(fromRect.left - animatingRect.left, 2)) / Math.sqrt(Math.pow(fromRect.top - toRect.top, 2) + Math.pow(fromRect.left - toRect.left, 2)) * options.animation; +} + +var plugins = []; +var defaults = { + initializeByDefault: true +}; +var PluginManager = { + mount: function mount(plugin) { + // Set default static properties + for (var option in defaults) { + if (defaults.hasOwnProperty(option) && !(option in plugin)) { + plugin[option] = defaults[option]; + } + } + plugins.forEach(function (p) { + if (p.pluginName === plugin.pluginName) { + throw "Sortable: Cannot mount plugin ".concat(plugin.pluginName, " more than once"); + } + }); + plugins.push(plugin); + }, + pluginEvent: function pluginEvent(eventName, sortable, evt) { + var _this = this; + this.eventCanceled = false; + evt.cancel = function () { + _this.eventCanceled = true; + }; + var eventNameGlobal = eventName + 'Global'; + plugins.forEach(function (plugin) { + if (!sortable[plugin.pluginName]) return; + // Fire global events if it exists in this sortable + if (sortable[plugin.pluginName][eventNameGlobal]) { + sortable[plugin.pluginName][eventNameGlobal](_objectSpread2({ + sortable: sortable + }, evt)); + } + + // Only fire plugin event if plugin is enabled in this sortable, + // and plugin has event defined + if (sortable.options[plugin.pluginName] && sortable[plugin.pluginName][eventName]) { + sortable[plugin.pluginName][eventName](_objectSpread2({ + sortable: sortable + }, evt)); + } + }); + }, + initializePlugins: function initializePlugins(sortable, el, defaults, options) { + plugins.forEach(function (plugin) { + var pluginName = plugin.pluginName; + if (!sortable.options[pluginName] && !plugin.initializeByDefault) return; + var initialized = new plugin(sortable, el, sortable.options); + initialized.sortable = sortable; + initialized.options = sortable.options; + sortable[pluginName] = initialized; + + // Add default options from plugin + _extends(defaults, initialized.defaults); + }); + for (var option in sortable.options) { + if (!sortable.options.hasOwnProperty(option)) continue; + var modified = this.modifyOption(sortable, option, sortable.options[option]); + if (typeof modified !== 'undefined') { + sortable.options[option] = modified; + } + } + }, + getEventProperties: function getEventProperties(name, sortable) { + var eventProperties = {}; + plugins.forEach(function (plugin) { + if (typeof plugin.eventProperties !== 'function') return; + _extends(eventProperties, plugin.eventProperties.call(sortable[plugin.pluginName], name)); + }); + return eventProperties; + }, + modifyOption: function modifyOption(sortable, name, value) { + var modifiedValue; + plugins.forEach(function (plugin) { + // Plugin must exist on the Sortable + if (!sortable[plugin.pluginName]) return; + + // If static option listener exists for this option, call in the context of the Sortable's instance of this plugin + if (plugin.optionListeners && typeof plugin.optionListeners[name] === 'function') { + modifiedValue = plugin.optionListeners[name].call(sortable[plugin.pluginName], value); + } + }); + return modifiedValue; + } +}; + +function dispatchEvent(_ref) { + var sortable = _ref.sortable, + rootEl = _ref.rootEl, + name = _ref.name, + targetEl = _ref.targetEl, + cloneEl = _ref.cloneEl, + toEl = _ref.toEl, + fromEl = _ref.fromEl, + oldIndex = _ref.oldIndex, + newIndex = _ref.newIndex, + oldDraggableIndex = _ref.oldDraggableIndex, + newDraggableIndex = _ref.newDraggableIndex, + originalEvent = _ref.originalEvent, + putSortable = _ref.putSortable, + extraEventProperties = _ref.extraEventProperties; + sortable = sortable || rootEl && rootEl[expando]; + if (!sortable) return; + var evt, + options = sortable.options, + onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1); + // Support for new CustomEvent feature + if (window.CustomEvent && !IE11OrLess && !Edge) { + evt = new CustomEvent(name, { + bubbles: true, + cancelable: true + }); + } else { + evt = document.createEvent('Event'); + evt.initEvent(name, true, true); + } + evt.to = toEl || rootEl; + evt.from = fromEl || rootEl; + evt.item = targetEl || rootEl; + evt.clone = cloneEl; + evt.oldIndex = oldIndex; + evt.newIndex = newIndex; + evt.oldDraggableIndex = oldDraggableIndex; + evt.newDraggableIndex = newDraggableIndex; + evt.originalEvent = originalEvent; + evt.pullMode = putSortable ? putSortable.lastPutMode : undefined; + var allEventProperties = _objectSpread2(_objectSpread2({}, extraEventProperties), PluginManager.getEventProperties(name, sortable)); + for (var option in allEventProperties) { + evt[option] = allEventProperties[option]; + } + if (rootEl) { + rootEl.dispatchEvent(evt); + } + if (options[onName]) { + options[onName].call(sortable, evt); + } +} + +var _excluded = ["evt"]; +var pluginEvent = function pluginEvent(eventName, sortable) { + var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}, + originalEvent = _ref.evt, + data = _objectWithoutProperties(_ref, _excluded); + PluginManager.pluginEvent.bind(Sortable)(eventName, sortable, _objectSpread2({ + dragEl: dragEl, + parentEl: parentEl, + ghostEl: ghostEl, + rootEl: rootEl, + nextEl: nextEl, + lastDownEl: lastDownEl, + cloneEl: cloneEl, + cloneHidden: cloneHidden, + dragStarted: moved, + putSortable: putSortable, + activeSortable: Sortable.active, + originalEvent: originalEvent, + oldIndex: oldIndex, + oldDraggableIndex: oldDraggableIndex, + newIndex: newIndex, + newDraggableIndex: newDraggableIndex, + hideGhostForTarget: _hideGhostForTarget, + unhideGhostForTarget: _unhideGhostForTarget, + cloneNowHidden: function cloneNowHidden() { + cloneHidden = true; + }, + cloneNowShown: function cloneNowShown() { + cloneHidden = false; + }, + dispatchSortableEvent: function dispatchSortableEvent(name) { + _dispatchEvent({ + sortable: sortable, + name: name, + originalEvent: originalEvent + }); + } + }, data)); +}; +function _dispatchEvent(info) { + dispatchEvent(_objectSpread2({ + putSortable: putSortable, + cloneEl: cloneEl, + targetEl: dragEl, + rootEl: rootEl, + oldIndex: oldIndex, + oldDraggableIndex: oldDraggableIndex, + newIndex: newIndex, + newDraggableIndex: newDraggableIndex + }, info)); +} +var dragEl, + parentEl, + ghostEl, + rootEl, + nextEl, + lastDownEl, + cloneEl, + cloneHidden, + oldIndex, + newIndex, + oldDraggableIndex, + newDraggableIndex, + activeGroup, + putSortable, + awaitingDragStarted = false, + ignoreNextClick = false, + sortables = [], + tapEvt, + touchEvt, + lastDx, + lastDy, + tapDistanceLeft, + tapDistanceTop, + moved, + lastTarget, + lastDirection, + pastFirstInvertThresh = false, + isCircumstantialInvert = false, + targetMoveDistance, + // For positioning ghost absolutely + ghostRelativeParent, + ghostRelativeParentInitialScroll = [], + // (left, top) + + _silent = false, + savedInputChecked = []; + +/** @const */ +var documentExists = typeof document !== 'undefined', + PositionGhostAbsolutely = IOS, + CSSFloatProperty = Edge || IE11OrLess ? 'cssFloat' : 'float', + // This will not pass for IE9, because IE9 DnD only works on anchors + supportDraggable = documentExists && !ChromeForAndroid && !IOS && 'draggable' in document.createElement('div'), + supportCssPointerEvents = function () { + if (!documentExists) return; + // false when <= IE11 + if (IE11OrLess) { + return false; + } + var el = document.createElement('x'); + el.style.cssText = 'pointer-events:auto'; + return el.style.pointerEvents === 'auto'; + }(), + _detectDirection = function _detectDirection(el, options) { + var elCSS = css(el), + elWidth = parseInt(elCSS.width) - parseInt(elCSS.paddingLeft) - parseInt(elCSS.paddingRight) - parseInt(elCSS.borderLeftWidth) - parseInt(elCSS.borderRightWidth), + child1 = getChild(el, 0, options), + child2 = getChild(el, 1, options), + firstChildCSS = child1 && css(child1), + secondChildCSS = child2 && css(child2), + firstChildWidth = firstChildCSS && parseInt(firstChildCSS.marginLeft) + parseInt(firstChildCSS.marginRight) + getRect(child1).width, + secondChildWidth = secondChildCSS && parseInt(secondChildCSS.marginLeft) + parseInt(secondChildCSS.marginRight) + getRect(child2).width; + if (elCSS.display === 'flex') { + return elCSS.flexDirection === 'column' || elCSS.flexDirection === 'column-reverse' ? 'vertical' : 'horizontal'; + } + if (elCSS.display === 'grid') { + return elCSS.gridTemplateColumns.split(' ').length <= 1 ? 'vertical' : 'horizontal'; + } + if (child1 && firstChildCSS["float"] && firstChildCSS["float"] !== 'none') { + var touchingSideChild2 = firstChildCSS["float"] === 'left' ? 'left' : 'right'; + return child2 && (secondChildCSS.clear === 'both' || secondChildCSS.clear === touchingSideChild2) ? 'vertical' : 'horizontal'; + } + return child1 && (firstChildCSS.display === 'block' || firstChildCSS.display === 'flex' || firstChildCSS.display === 'table' || firstChildCSS.display === 'grid' || firstChildWidth >= elWidth && elCSS[CSSFloatProperty] === 'none' || child2 && elCSS[CSSFloatProperty] === 'none' && firstChildWidth + secondChildWidth > elWidth) ? 'vertical' : 'horizontal'; + }, + _dragElInRowColumn = function _dragElInRowColumn(dragRect, targetRect, vertical) { + var dragElS1Opp = vertical ? dragRect.left : dragRect.top, + dragElS2Opp = vertical ? dragRect.right : dragRect.bottom, + dragElOppLength = vertical ? dragRect.width : dragRect.height, + targetS1Opp = vertical ? targetRect.left : targetRect.top, + targetS2Opp = vertical ? targetRect.right : targetRect.bottom, + targetOppLength = vertical ? targetRect.width : targetRect.height; + return dragElS1Opp === targetS1Opp || dragElS2Opp === targetS2Opp || dragElS1Opp + dragElOppLength / 2 === targetS1Opp + targetOppLength / 2; + }, + /** + * Detects first nearest empty sortable to X and Y position using emptyInsertThreshold. + * @param {Number} x X position + * @param {Number} y Y position + * @return {HTMLElement} Element of the first found nearest Sortable + */ + _detectNearestEmptySortable = function _detectNearestEmptySortable(x, y) { + var ret; + sortables.some(function (sortable) { + var threshold = sortable[expando].options.emptyInsertThreshold; + if (!threshold || lastChild(sortable)) return; + var rect = getRect(sortable), + insideHorizontally = x >= rect.left - threshold && x <= rect.right + threshold, + insideVertically = y >= rect.top - threshold && y <= rect.bottom + threshold; + if (insideHorizontally && insideVertically) { + return ret = sortable; + } + }); + return ret; + }, + _prepareGroup = function _prepareGroup(options) { + function toFn(value, pull) { + return function (to, from, dragEl, evt) { + var sameGroup = to.options.group.name && from.options.group.name && to.options.group.name === from.options.group.name; + if (value == null && (pull || sameGroup)) { + // Default pull value + // Default pull and put value if same group + return true; + } else if (value == null || value === false) { + return false; + } else if (pull && value === 'clone') { + return value; + } else if (typeof value === 'function') { + return toFn(value(to, from, dragEl, evt), pull)(to, from, dragEl, evt); + } else { + var otherGroup = (pull ? to : from).options.group.name; + return value === true || typeof value === 'string' && value === otherGroup || value.join && value.indexOf(otherGroup) > -1; + } + }; + } + var group = {}; + var originalGroup = options.group; + if (!originalGroup || _typeof(originalGroup) != 'object') { + originalGroup = { + name: originalGroup + }; + } + group.name = originalGroup.name; + group.checkPull = toFn(originalGroup.pull, true); + group.checkPut = toFn(originalGroup.put); + group.revertClone = originalGroup.revertClone; + options.group = group; + }, + _hideGhostForTarget = function _hideGhostForTarget() { + if (!supportCssPointerEvents && ghostEl) { + css(ghostEl, 'display', 'none'); + } + }, + _unhideGhostForTarget = function _unhideGhostForTarget() { + if (!supportCssPointerEvents && ghostEl) { + css(ghostEl, 'display', ''); + } + }; + +// #1184 fix - Prevent click event on fallback if dragged but item not changed position +if (documentExists && !ChromeForAndroid) { + document.addEventListener('click', function (evt) { + if (ignoreNextClick) { + evt.preventDefault(); + evt.stopPropagation && evt.stopPropagation(); + evt.stopImmediatePropagation && evt.stopImmediatePropagation(); + ignoreNextClick = false; + return false; + } + }, true); +} +var nearestEmptyInsertDetectEvent = function nearestEmptyInsertDetectEvent(evt) { + if (dragEl) { + evt = evt.touches ? evt.touches[0] : evt; + var nearest = _detectNearestEmptySortable(evt.clientX, evt.clientY); + if (nearest) { + // Create imitation event + var event = {}; + for (var i in evt) { + if (evt.hasOwnProperty(i)) { + event[i] = evt[i]; + } + } + event.target = event.rootEl = nearest; + event.preventDefault = void 0; + event.stopPropagation = void 0; + nearest[expando]._onDragOver(event); + } + } +}; +var _checkOutsideTargetEl = function _checkOutsideTargetEl(evt) { + if (dragEl) { + dragEl.parentNode[expando]._isOutsideThisEl(evt.target); + } +}; + +/** + * @class Sortable + * @param {HTMLElement} el + * @param {Object} [options] + */ +function Sortable(el, options) { + if (!(el && el.nodeType && el.nodeType === 1)) { + throw "Sortable: `el` must be an HTMLElement, not ".concat({}.toString.call(el)); + } + this.el = el; // root element + this.options = options = _extends({}, options); + + // Export instance + el[expando] = this; + var defaults = { + group: null, + sort: true, + disabled: false, + store: null, + handle: null, + draggable: /^[uo]l$/i.test(el.nodeName) ? '>li' : '>*', + swapThreshold: 1, + // percentage; 0 <= x <= 1 + invertSwap: false, + // invert always + invertedSwapThreshold: null, + // will be set to same as swapThreshold if default + removeCloneOnHide: true, + direction: function direction() { + return _detectDirection(el, this.options); + }, + ghostClass: 'sortable-ghost', + chosenClass: 'sortable-chosen', + dragClass: 'sortable-drag', + ignore: 'a, img', + filter: null, + preventOnFilter: true, + animation: 0, + easing: null, + setData: function setData(dataTransfer, dragEl) { + dataTransfer.setData('Text', dragEl.textContent); + }, + dropBubble: false, + dragoverBubble: false, + dataIdAttr: 'data-id', + delay: 0, + delayOnTouchOnly: false, + touchStartThreshold: (Number.parseInt ? Number : window).parseInt(window.devicePixelRatio, 10) || 1, + forceFallback: false, + fallbackClass: 'sortable-fallback', + fallbackOnBody: false, + fallbackTolerance: 0, + fallbackOffset: { + x: 0, + y: 0 + }, + supportPointer: Sortable.supportPointer !== false && 'PointerEvent' in window && !Safari, + emptyInsertThreshold: 5 + }; + PluginManager.initializePlugins(this, el, defaults); + + // Set default options + for (var name in defaults) { + !(name in options) && (options[name] = defaults[name]); + } + _prepareGroup(options); + + // Bind all private methods + for (var fn in this) { + if (fn.charAt(0) === '_' && typeof this[fn] === 'function') { + this[fn] = this[fn].bind(this); + } + } + + // Setup drag mode + this.nativeDraggable = options.forceFallback ? false : supportDraggable; + if (this.nativeDraggable) { + // Touch start threshold cannot be greater than the native dragstart threshold + this.options.touchStartThreshold = 1; + } + + // Bind events + if (options.supportPointer) { + on(el, 'pointerdown', this._onTapStart); + } else { + on(el, 'mousedown', this._onTapStart); + on(el, 'touchstart', this._onTapStart); + } + if (this.nativeDraggable) { + on(el, 'dragover', this); + on(el, 'dragenter', this); + } + sortables.push(this.el); + + // Restore sorting + options.store && options.store.get && this.sort(options.store.get(this) || []); + + // Add animation state manager + _extends(this, AnimationStateManager()); +} +Sortable.prototype = /** @lends Sortable.prototype */{ + constructor: Sortable, + _isOutsideThisEl: function _isOutsideThisEl(target) { + if (!this.el.contains(target) && target !== this.el) { + lastTarget = null; + } + }, + _getDirection: function _getDirection(evt, target) { + return typeof this.options.direction === 'function' ? this.options.direction.call(this, evt, target, dragEl) : this.options.direction; + }, + _onTapStart: function _onTapStart( /** Event|TouchEvent */evt) { + if (!evt.cancelable) return; + var _this = this, + el = this.el, + options = this.options, + preventOnFilter = options.preventOnFilter, + type = evt.type, + touch = evt.touches && evt.touches[0] || evt.pointerType && evt.pointerType === 'touch' && evt, + target = (touch || evt).target, + originalTarget = evt.target.shadowRoot && (evt.path && evt.path[0] || evt.composedPath && evt.composedPath()[0]) || target, + filter = options.filter; + _saveInputCheckedState(el); + + // Don't trigger start event when an element is been dragged, otherwise the evt.oldindex always wrong when set option.group. + if (dragEl) { + return; + } + if (/mousedown|pointerdown/.test(type) && evt.button !== 0 || options.disabled) { + return; // only left button and enabled + } + + // cancel dnd if original target is content editable + if (originalTarget.isContentEditable) { + return; + } + + // Safari ignores further event handling after mousedown + if (!this.nativeDraggable && Safari && target && target.tagName.toUpperCase() === 'SELECT') { + return; + } + target = closest(target, options.draggable, el, false); + if (target && target.animated) { + return; + } + if (lastDownEl === target) { + // Ignoring duplicate `down` + return; + } + + // Get the index of the dragged element within its parent + oldIndex = index(target); + oldDraggableIndex = index(target, options.draggable); + + // Check filter + if (typeof filter === 'function') { + if (filter.call(this, evt, target, this)) { + _dispatchEvent({ + sortable: _this, + rootEl: originalTarget, + name: 'filter', + targetEl: target, + toEl: el, + fromEl: el + }); + pluginEvent('filter', _this, { + evt: evt + }); + preventOnFilter && evt.cancelable && evt.preventDefault(); + return; // cancel dnd + } + } else if (filter) { + filter = filter.split(',').some(function (criteria) { + criteria = closest(originalTarget, criteria.trim(), el, false); + if (criteria) { + _dispatchEvent({ + sortable: _this, + rootEl: criteria, + name: 'filter', + targetEl: target, + fromEl: el, + toEl: el + }); + pluginEvent('filter', _this, { + evt: evt + }); + return true; + } + }); + if (filter) { + preventOnFilter && evt.cancelable && evt.preventDefault(); + return; // cancel dnd + } + } + if (options.handle && !closest(originalTarget, options.handle, el, false)) { + return; + } + + // Prepare `dragstart` + this._prepareDragStart(evt, touch, target); + }, + _prepareDragStart: function _prepareDragStart( /** Event */evt, /** Touch */touch, /** HTMLElement */target) { + var _this = this, + el = _this.el, + options = _this.options, + ownerDocument = el.ownerDocument, + dragStartFn; + if (target && !dragEl && target.parentNode === el) { + var dragRect = getRect(target); + rootEl = el; + dragEl = target; + parentEl = dragEl.parentNode; + nextEl = dragEl.nextSibling; + lastDownEl = target; + activeGroup = options.group; + Sortable.dragged = dragEl; + tapEvt = { + target: dragEl, + clientX: (touch || evt).clientX, + clientY: (touch || evt).clientY + }; + tapDistanceLeft = tapEvt.clientX - dragRect.left; + tapDistanceTop = tapEvt.clientY - dragRect.top; + this._lastX = (touch || evt).clientX; + this._lastY = (touch || evt).clientY; + dragEl.style['will-change'] = 'all'; + dragStartFn = function dragStartFn() { + pluginEvent('delayEnded', _this, { + evt: evt + }); + if (Sortable.eventCanceled) { + _this._onDrop(); + return; + } + // Delayed drag has been triggered + // we can re-enable the events: touchmove/mousemove + _this._disableDelayedDragEvents(); + if (!FireFox && _this.nativeDraggable) { + dragEl.draggable = true; + } + + // Bind the events: dragstart/dragend + _this._triggerDragStart(evt, touch); + + // Drag start event + _dispatchEvent({ + sortable: _this, + name: 'choose', + originalEvent: evt + }); + + // Chosen item + toggleClass(dragEl, options.chosenClass, true); + }; + + // Disable "draggable" + options.ignore.split(',').forEach(function (criteria) { + find(dragEl, criteria.trim(), _disableDraggable); + }); + on(ownerDocument, 'dragover', nearestEmptyInsertDetectEvent); + on(ownerDocument, 'mousemove', nearestEmptyInsertDetectEvent); + on(ownerDocument, 'touchmove', nearestEmptyInsertDetectEvent); + on(ownerDocument, 'mouseup', _this._onDrop); + on(ownerDocument, 'touchend', _this._onDrop); + on(ownerDocument, 'touchcancel', _this._onDrop); + + // Make dragEl draggable (must be before delay for FireFox) + if (FireFox && this.nativeDraggable) { + this.options.touchStartThreshold = 4; + dragEl.draggable = true; + } + pluginEvent('delayStart', this, { + evt: evt + }); + + // Delay is impossible for native DnD in Edge or IE + if (options.delay && (!options.delayOnTouchOnly || touch) && (!this.nativeDraggable || !(Edge || IE11OrLess))) { + if (Sortable.eventCanceled) { + this._onDrop(); + return; + } + // If the user moves the pointer or let go the click or touch + // before the delay has been reached: + // disable the delayed drag + on(ownerDocument, 'mouseup', _this._disableDelayedDrag); + on(ownerDocument, 'touchend', _this._disableDelayedDrag); + on(ownerDocument, 'touchcancel', _this._disableDelayedDrag); + on(ownerDocument, 'mousemove', _this._delayedDragTouchMoveHandler); + on(ownerDocument, 'touchmove', _this._delayedDragTouchMoveHandler); + options.supportPointer && on(ownerDocument, 'pointermove', _this._delayedDragTouchMoveHandler); + _this._dragStartTimer = setTimeout(dragStartFn, options.delay); + } else { + dragStartFn(); + } + } + }, + _delayedDragTouchMoveHandler: function _delayedDragTouchMoveHandler( /** TouchEvent|PointerEvent **/e) { + var touch = e.touches ? e.touches[0] : e; + if (Math.max(Math.abs(touch.clientX - this._lastX), Math.abs(touch.clientY - this._lastY)) >= Math.floor(this.options.touchStartThreshold / (this.nativeDraggable && window.devicePixelRatio || 1))) { + this._disableDelayedDrag(); + } + }, + _disableDelayedDrag: function _disableDelayedDrag() { + dragEl && _disableDraggable(dragEl); + clearTimeout(this._dragStartTimer); + this._disableDelayedDragEvents(); + }, + _disableDelayedDragEvents: function _disableDelayedDragEvents() { + var ownerDocument = this.el.ownerDocument; + off(ownerDocument, 'mouseup', this._disableDelayedDrag); + off(ownerDocument, 'touchend', this._disableDelayedDrag); + off(ownerDocument, 'touchcancel', this._disableDelayedDrag); + off(ownerDocument, 'mousemove', this._delayedDragTouchMoveHandler); + off(ownerDocument, 'touchmove', this._delayedDragTouchMoveHandler); + off(ownerDocument, 'pointermove', this._delayedDragTouchMoveHandler); + }, + _triggerDragStart: function _triggerDragStart( /** Event */evt, /** Touch */touch) { + touch = touch || evt.pointerType == 'touch' && evt; + if (!this.nativeDraggable || touch) { + if (this.options.supportPointer) { + on(document, 'pointermove', this._onTouchMove); + } else if (touch) { + on(document, 'touchmove', this._onTouchMove); + } else { + on(document, 'mousemove', this._onTouchMove); + } + } else { + on(dragEl, 'dragend', this); + on(rootEl, 'dragstart', this._onDragStart); + } + try { + if (document.selection) { + // Timeout neccessary for IE9 + _nextTick(function () { + document.selection.empty(); + }); + } else { + window.getSelection().removeAllRanges(); + } + } catch (err) {} + }, + _dragStarted: function _dragStarted(fallback, evt) { + awaitingDragStarted = false; + if (rootEl && dragEl) { + pluginEvent('dragStarted', this, { + evt: evt + }); + if (this.nativeDraggable) { + on(document, 'dragover', _checkOutsideTargetEl); + } + var options = this.options; + + // Apply effect + !fallback && toggleClass(dragEl, options.dragClass, false); + toggleClass(dragEl, options.ghostClass, true); + Sortable.active = this; + fallback && this._appendGhost(); + + // Drag start event + _dispatchEvent({ + sortable: this, + name: 'start', + originalEvent: evt + }); + } else { + this._nulling(); + } + }, + _emulateDragOver: function _emulateDragOver() { + if (touchEvt) { + this._lastX = touchEvt.clientX; + this._lastY = touchEvt.clientY; + _hideGhostForTarget(); + var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY); + var parent = target; + while (target && target.shadowRoot) { + target = target.shadowRoot.elementFromPoint(touchEvt.clientX, touchEvt.clientY); + if (target === parent) break; + parent = target; + } + dragEl.parentNode[expando]._isOutsideThisEl(target); + if (parent) { + do { + if (parent[expando]) { + var inserted = void 0; + inserted = parent[expando]._onDragOver({ + clientX: touchEvt.clientX, + clientY: touchEvt.clientY, + target: target, + rootEl: parent + }); + if (inserted && !this.options.dragoverBubble) { + break; + } + } + target = parent; // store last element + } + /* jshint boss:true */ while (parent = parent.parentNode); + } + _unhideGhostForTarget(); + } + }, + _onTouchMove: function _onTouchMove( /**TouchEvent*/evt) { + if (tapEvt) { + var options = this.options, + fallbackTolerance = options.fallbackTolerance, + fallbackOffset = options.fallbackOffset, + touch = evt.touches ? evt.touches[0] : evt, + ghostMatrix = ghostEl && matrix(ghostEl, true), + scaleX = ghostEl && ghostMatrix && ghostMatrix.a, + scaleY = ghostEl && ghostMatrix && ghostMatrix.d, + relativeScrollOffset = PositionGhostAbsolutely && ghostRelativeParent && getRelativeScrollOffset(ghostRelativeParent), + dx = (touch.clientX - tapEvt.clientX + fallbackOffset.x) / (scaleX || 1) + (relativeScrollOffset ? relativeScrollOffset[0] - ghostRelativeParentInitialScroll[0] : 0) / (scaleX || 1), + dy = (touch.clientY - tapEvt.clientY + fallbackOffset.y) / (scaleY || 1) + (relativeScrollOffset ? relativeScrollOffset[1] - ghostRelativeParentInitialScroll[1] : 0) / (scaleY || 1); + + // only set the status to dragging, when we are actually dragging + if (!Sortable.active && !awaitingDragStarted) { + if (fallbackTolerance && Math.max(Math.abs(touch.clientX - this._lastX), Math.abs(touch.clientY - this._lastY)) < fallbackTolerance) { + return; + } + this._onDragStart(evt, true); + } + if (ghostEl) { + if (ghostMatrix) { + ghostMatrix.e += dx - (lastDx || 0); + ghostMatrix.f += dy - (lastDy || 0); + } else { + ghostMatrix = { + a: 1, + b: 0, + c: 0, + d: 1, + e: dx, + f: dy + }; + } + var cssMatrix = "matrix(".concat(ghostMatrix.a, ",").concat(ghostMatrix.b, ",").concat(ghostMatrix.c, ",").concat(ghostMatrix.d, ",").concat(ghostMatrix.e, ",").concat(ghostMatrix.f, ")"); + css(ghostEl, 'webkitTransform', cssMatrix); + css(ghostEl, 'mozTransform', cssMatrix); + css(ghostEl, 'msTransform', cssMatrix); + css(ghostEl, 'transform', cssMatrix); + lastDx = dx; + lastDy = dy; + touchEvt = touch; + } + evt.cancelable && evt.preventDefault(); + } + }, + _appendGhost: function _appendGhost() { + // Bug if using scale(): https://stackoverflow.com/questions/2637058 + // Not being adjusted for + if (!ghostEl) { + var container = this.options.fallbackOnBody ? document.body : rootEl, + rect = getRect(dragEl, true, PositionGhostAbsolutely, true, container), + options = this.options; + + // Position absolutely + if (PositionGhostAbsolutely) { + // Get relatively positioned parent + ghostRelativeParent = container; + while (css(ghostRelativeParent, 'position') === 'static' && css(ghostRelativeParent, 'transform') === 'none' && ghostRelativeParent !== document) { + ghostRelativeParent = ghostRelativeParent.parentNode; + } + if (ghostRelativeParent !== document.body && ghostRelativeParent !== document.documentElement) { + if (ghostRelativeParent === document) ghostRelativeParent = getWindowScrollingElement(); + rect.top += ghostRelativeParent.scrollTop; + rect.left += ghostRelativeParent.scrollLeft; + } else { + ghostRelativeParent = getWindowScrollingElement(); + } + ghostRelativeParentInitialScroll = getRelativeScrollOffset(ghostRelativeParent); + } + ghostEl = dragEl.cloneNode(true); + toggleClass(ghostEl, options.ghostClass, false); + toggleClass(ghostEl, options.fallbackClass, true); + toggleClass(ghostEl, options.dragClass, true); + css(ghostEl, 'transition', ''); + css(ghostEl, 'transform', ''); + css(ghostEl, 'box-sizing', 'border-box'); + css(ghostEl, 'margin', 0); + css(ghostEl, 'top', rect.top); + css(ghostEl, 'left', rect.left); + css(ghostEl, 'width', rect.width); + css(ghostEl, 'height', rect.height); + css(ghostEl, 'opacity', '0.8'); + css(ghostEl, 'position', PositionGhostAbsolutely ? 'absolute' : 'fixed'); + css(ghostEl, 'zIndex', '100000'); + css(ghostEl, 'pointerEvents', 'none'); + Sortable.ghost = ghostEl; + container.appendChild(ghostEl); + + // Set transform-origin + css(ghostEl, 'transform-origin', tapDistanceLeft / parseInt(ghostEl.style.width) * 100 + '% ' + tapDistanceTop / parseInt(ghostEl.style.height) * 100 + '%'); + } + }, + _onDragStart: function _onDragStart( /**Event*/evt, /**boolean*/fallback) { + var _this = this; + var dataTransfer = evt.dataTransfer; + var options = _this.options; + pluginEvent('dragStart', this, { + evt: evt + }); + if (Sortable.eventCanceled) { + this._onDrop(); + return; + } + pluginEvent('setupClone', this); + if (!Sortable.eventCanceled) { + cloneEl = clone(dragEl); + cloneEl.removeAttribute("id"); + cloneEl.draggable = false; + cloneEl.style['will-change'] = ''; + this._hideClone(); + toggleClass(cloneEl, this.options.chosenClass, false); + Sortable.clone = cloneEl; + } + + // #1143: IFrame support workaround + _this.cloneId = _nextTick(function () { + pluginEvent('clone', _this); + if (Sortable.eventCanceled) return; + if (!_this.options.removeCloneOnHide) { + rootEl.insertBefore(cloneEl, dragEl); + } + _this._hideClone(); + _dispatchEvent({ + sortable: _this, + name: 'clone' + }); + }); + !fallback && toggleClass(dragEl, options.dragClass, true); + + // Set proper drop events + if (fallback) { + ignoreNextClick = true; + _this._loopId = setInterval(_this._emulateDragOver, 50); + } else { + // Undo what was set in _prepareDragStart before drag started + off(document, 'mouseup', _this._onDrop); + off(document, 'touchend', _this._onDrop); + off(document, 'touchcancel', _this._onDrop); + if (dataTransfer) { + dataTransfer.effectAllowed = 'move'; + options.setData && options.setData.call(_this, dataTransfer, dragEl); + } + on(document, 'drop', _this); + + // #1276 fix: + css(dragEl, 'transform', 'translateZ(0)'); + } + awaitingDragStarted = true; + _this._dragStartId = _nextTick(_this._dragStarted.bind(_this, fallback, evt)); + on(document, 'selectstart', _this); + moved = true; + if (Safari) { + css(document.body, 'user-select', 'none'); + } + }, + // Returns true - if no further action is needed (either inserted or another condition) + _onDragOver: function _onDragOver( /**Event*/evt) { + var el = this.el, + target = evt.target, + dragRect, + targetRect, + revert, + options = this.options, + group = options.group, + activeSortable = Sortable.active, + isOwner = activeGroup === group, + canSort = options.sort, + fromSortable = putSortable || activeSortable, + vertical, + _this = this, + completedFired = false; + if (_silent) return; + function dragOverEvent(name, extra) { + pluginEvent(name, _this, _objectSpread2({ + evt: evt, + isOwner: isOwner, + axis: vertical ? 'vertical' : 'horizontal', + revert: revert, + dragRect: dragRect, + targetRect: targetRect, + canSort: canSort, + fromSortable: fromSortable, + target: target, + completed: completed, + onMove: function onMove(target, after) { + return _onMove(rootEl, el, dragEl, dragRect, target, getRect(target), evt, after); + }, + changed: changed + }, extra)); + } + + // Capture animation state + function capture() { + dragOverEvent('dragOverAnimationCapture'); + _this.captureAnimationState(); + if (_this !== fromSortable) { + fromSortable.captureAnimationState(); + } + } + + // Return invocation when dragEl is inserted (or completed) + function completed(insertion) { + dragOverEvent('dragOverCompleted', { + insertion: insertion + }); + if (insertion) { + // Clones must be hidden before folding animation to capture dragRectAbsolute properly + if (isOwner) { + activeSortable._hideClone(); + } else { + activeSortable._showClone(_this); + } + if (_this !== fromSortable) { + // Set ghost class to new sortable's ghost class + toggleClass(dragEl, putSortable ? putSortable.options.ghostClass : activeSortable.options.ghostClass, false); + toggleClass(dragEl, options.ghostClass, true); + } + if (putSortable !== _this && _this !== Sortable.active) { + putSortable = _this; + } else if (_this === Sortable.active && putSortable) { + putSortable = null; + } + + // Animation + if (fromSortable === _this) { + _this._ignoreWhileAnimating = target; + } + _this.animateAll(function () { + dragOverEvent('dragOverAnimationComplete'); + _this._ignoreWhileAnimating = null; + }); + if (_this !== fromSortable) { + fromSortable.animateAll(); + fromSortable._ignoreWhileAnimating = null; + } + } + + // Null lastTarget if it is not inside a previously swapped element + if (target === dragEl && !dragEl.animated || target === el && !target.animated) { + lastTarget = null; + } + + // no bubbling and not fallback + if (!options.dragoverBubble && !evt.rootEl && target !== document) { + dragEl.parentNode[expando]._isOutsideThisEl(evt.target); + + // Do not detect for empty insert if already inserted + !insertion && nearestEmptyInsertDetectEvent(evt); + } + !options.dragoverBubble && evt.stopPropagation && evt.stopPropagation(); + return completedFired = true; + } + + // Call when dragEl has been inserted + function changed() { + newIndex = index(dragEl); + newDraggableIndex = index(dragEl, options.draggable); + _dispatchEvent({ + sortable: _this, + name: 'change', + toEl: el, + newIndex: newIndex, + newDraggableIndex: newDraggableIndex, + originalEvent: evt + }); + } + if (evt.preventDefault !== void 0) { + evt.cancelable && evt.preventDefault(); + } + target = closest(target, options.draggable, el, true); + dragOverEvent('dragOver'); + if (Sortable.eventCanceled) return completedFired; + if (dragEl.contains(evt.target) || target.animated && target.animatingX && target.animatingY || _this._ignoreWhileAnimating === target) { + return completed(false); + } + ignoreNextClick = false; + if (activeSortable && !options.disabled && (isOwner ? canSort || (revert = parentEl !== rootEl) // Reverting item into the original list + : putSortable === this || (this.lastPutMode = activeGroup.checkPull(this, activeSortable, dragEl, evt)) && group.checkPut(this, activeSortable, dragEl, evt))) { + vertical = this._getDirection(evt, target) === 'vertical'; + dragRect = getRect(dragEl); + dragOverEvent('dragOverValid'); + if (Sortable.eventCanceled) return completedFired; + if (revert) { + parentEl = rootEl; // actualization + capture(); + this._hideClone(); + dragOverEvent('revert'); + if (!Sortable.eventCanceled) { + if (nextEl) { + rootEl.insertBefore(dragEl, nextEl); + } else { + rootEl.appendChild(dragEl); + } + } + return completed(true); + } + var elLastChild = lastChild(el, options.draggable); + if (!elLastChild || _ghostIsLast(evt, vertical, this) && !elLastChild.animated) { + // Insert to end of list + + // If already at end of list: Do not insert + if (elLastChild === dragEl) { + return completed(false); + } + + // if there is a last element, it is the target + if (elLastChild && el === evt.target) { + target = elLastChild; + } + if (target) { + targetRect = getRect(target); + } + if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, !!target) !== false) { + capture(); + if (elLastChild && elLastChild.nextSibling) { + // the last draggable element is not the last node + el.insertBefore(dragEl, elLastChild.nextSibling); + } else { + el.appendChild(dragEl); + } + parentEl = el; // actualization + + changed(); + return completed(true); + } + } else if (elLastChild && _ghostIsFirst(evt, vertical, this)) { + // Insert to start of list + var firstChild = getChild(el, 0, options, true); + if (firstChild === dragEl) { + return completed(false); + } + target = firstChild; + targetRect = getRect(target); + if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, false) !== false) { + capture(); + el.insertBefore(dragEl, firstChild); + parentEl = el; // actualization + + changed(); + return completed(true); + } + } else if (target.parentNode === el) { + targetRect = getRect(target); + var direction = 0, + targetBeforeFirstSwap, + differentLevel = dragEl.parentNode !== el, + differentRowCol = !_dragElInRowColumn(dragEl.animated && dragEl.toRect || dragRect, target.animated && target.toRect || targetRect, vertical), + side1 = vertical ? 'top' : 'left', + scrolledPastTop = isScrolledPast(target, 'top', 'top') || isScrolledPast(dragEl, 'top', 'top'), + scrollBefore = scrolledPastTop ? scrolledPastTop.scrollTop : void 0; + if (lastTarget !== target) { + targetBeforeFirstSwap = targetRect[side1]; + pastFirstInvertThresh = false; + isCircumstantialInvert = !differentRowCol && options.invertSwap || differentLevel; + } + direction = _getSwapDirection(evt, target, targetRect, vertical, differentRowCol ? 1 : options.swapThreshold, options.invertedSwapThreshold == null ? options.swapThreshold : options.invertedSwapThreshold, isCircumstantialInvert, lastTarget === target); + var sibling; + if (direction !== 0) { + // Check if target is beside dragEl in respective direction (ignoring hidden elements) + var dragIndex = index(dragEl); + do { + dragIndex -= direction; + sibling = parentEl.children[dragIndex]; + } while (sibling && (css(sibling, 'display') === 'none' || sibling === ghostEl)); + } + // If dragEl is already beside target: Do not insert + if (direction === 0 || sibling === target) { + return completed(false); + } + lastTarget = target; + lastDirection = direction; + var nextSibling = target.nextElementSibling, + after = false; + after = direction === 1; + var moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, after); + if (moveVector !== false) { + if (moveVector === 1 || moveVector === -1) { + after = moveVector === 1; + } + _silent = true; + setTimeout(_unsilent, 30); + capture(); + if (after && !nextSibling) { + el.appendChild(dragEl); + } else { + target.parentNode.insertBefore(dragEl, after ? nextSibling : target); + } + + // Undo chrome's scroll adjustment (has no effect on other browsers) + if (scrolledPastTop) { + scrollBy(scrolledPastTop, 0, scrollBefore - scrolledPastTop.scrollTop); + } + parentEl = dragEl.parentNode; // actualization + + // must be done before animation + if (targetBeforeFirstSwap !== undefined && !isCircumstantialInvert) { + targetMoveDistance = Math.abs(targetBeforeFirstSwap - getRect(target)[side1]); + } + changed(); + return completed(true); + } + } + if (el.contains(dragEl)) { + return completed(false); + } + } + return false; + }, + _ignoreWhileAnimating: null, + _offMoveEvents: function _offMoveEvents() { + off(document, 'mousemove', this._onTouchMove); + off(document, 'touchmove', this._onTouchMove); + off(document, 'pointermove', this._onTouchMove); + off(document, 'dragover', nearestEmptyInsertDetectEvent); + off(document, 'mousemove', nearestEmptyInsertDetectEvent); + off(document, 'touchmove', nearestEmptyInsertDetectEvent); + }, + _offUpEvents: function _offUpEvents() { + var ownerDocument = this.el.ownerDocument; + off(ownerDocument, 'mouseup', this._onDrop); + off(ownerDocument, 'touchend', this._onDrop); + off(ownerDocument, 'pointerup', this._onDrop); + off(ownerDocument, 'touchcancel', this._onDrop); + off(document, 'selectstart', this); + }, + _onDrop: function _onDrop( /**Event*/evt) { + var el = this.el, + options = this.options; + + // Get the index of the dragged element within its parent + newIndex = index(dragEl); + newDraggableIndex = index(dragEl, options.draggable); + pluginEvent('drop', this, { + evt: evt + }); + parentEl = dragEl && dragEl.parentNode; + + // Get again after plugin event + newIndex = index(dragEl); + newDraggableIndex = index(dragEl, options.draggable); + if (Sortable.eventCanceled) { + this._nulling(); + return; + } + awaitingDragStarted = false; + isCircumstantialInvert = false; + pastFirstInvertThresh = false; + clearInterval(this._loopId); + clearTimeout(this._dragStartTimer); + _cancelNextTick(this.cloneId); + _cancelNextTick(this._dragStartId); + + // Unbind events + if (this.nativeDraggable) { + off(document, 'drop', this); + off(el, 'dragstart', this._onDragStart); + } + this._offMoveEvents(); + this._offUpEvents(); + if (Safari) { + css(document.body, 'user-select', ''); + } + css(dragEl, 'transform', ''); + if (evt) { + if (moved) { + evt.cancelable && evt.preventDefault(); + !options.dropBubble && evt.stopPropagation(); + } + ghostEl && ghostEl.parentNode && ghostEl.parentNode.removeChild(ghostEl); + if (rootEl === parentEl || putSortable && putSortable.lastPutMode !== 'clone') { + // Remove clone(s) + cloneEl && cloneEl.parentNode && cloneEl.parentNode.removeChild(cloneEl); + } + if (dragEl) { + if (this.nativeDraggable) { + off(dragEl, 'dragend', this); + } + _disableDraggable(dragEl); + dragEl.style['will-change'] = ''; + + // Remove classes + // ghostClass is added in dragStarted + if (moved && !awaitingDragStarted) { + toggleClass(dragEl, putSortable ? putSortable.options.ghostClass : this.options.ghostClass, false); + } + toggleClass(dragEl, this.options.chosenClass, false); + + // Drag stop event + _dispatchEvent({ + sortable: this, + name: 'unchoose', + toEl: parentEl, + newIndex: null, + newDraggableIndex: null, + originalEvent: evt + }); + if (rootEl !== parentEl) { + if (newIndex >= 0) { + // Add event + _dispatchEvent({ + rootEl: parentEl, + name: 'add', + toEl: parentEl, + fromEl: rootEl, + originalEvent: evt + }); + + // Remove event + _dispatchEvent({ + sortable: this, + name: 'remove', + toEl: parentEl, + originalEvent: evt + }); + + // drag from one list and drop into another + _dispatchEvent({ + rootEl: parentEl, + name: 'sort', + toEl: parentEl, + fromEl: rootEl, + originalEvent: evt + }); + _dispatchEvent({ + sortable: this, + name: 'sort', + toEl: parentEl, + originalEvent: evt + }); + } + putSortable && putSortable.save(); + } else { + if (newIndex !== oldIndex) { + if (newIndex >= 0) { + // drag & drop within the same list + _dispatchEvent({ + sortable: this, + name: 'update', + toEl: parentEl, + originalEvent: evt + }); + _dispatchEvent({ + sortable: this, + name: 'sort', + toEl: parentEl, + originalEvent: evt + }); + } + } + } + if (Sortable.active) { + /* jshint eqnull:true */ + if (newIndex == null || newIndex === -1) { + newIndex = oldIndex; + newDraggableIndex = oldDraggableIndex; + } + _dispatchEvent({ + sortable: this, + name: 'end', + toEl: parentEl, + originalEvent: evt + }); + + // Save sorting + this.save(); + } + } + } + this._nulling(); + }, + _nulling: function _nulling() { + pluginEvent('nulling', this); + rootEl = dragEl = parentEl = ghostEl = nextEl = cloneEl = lastDownEl = cloneHidden = tapEvt = touchEvt = moved = newIndex = newDraggableIndex = oldIndex = oldDraggableIndex = lastTarget = lastDirection = putSortable = activeGroup = Sortable.dragged = Sortable.ghost = Sortable.clone = Sortable.active = null; + savedInputChecked.forEach(function (el) { + el.checked = true; + }); + savedInputChecked.length = lastDx = lastDy = 0; + }, + handleEvent: function handleEvent( /**Event*/evt) { + switch (evt.type) { + case 'drop': + case 'dragend': + this._onDrop(evt); + break; + case 'dragenter': + case 'dragover': + if (dragEl) { + this._onDragOver(evt); + _globalDragOver(evt); + } + break; + case 'selectstart': + evt.preventDefault(); + break; + } + }, + /** + * Serializes the item into an array of string. + * @returns {String[]} + */ + toArray: function toArray() { + var order = [], + el, + children = this.el.children, + i = 0, + n = children.length, + options = this.options; + for (; i < n; i++) { + el = children[i]; + if (closest(el, options.draggable, this.el, false)) { + order.push(el.getAttribute(options.dataIdAttr) || _generateId(el)); + } + } + return order; + }, + /** + * Sorts the elements according to the array. + * @param {String[]} order order of the items + */ + sort: function sort(order, useAnimation) { + var items = {}, + rootEl = this.el; + this.toArray().forEach(function (id, i) { + var el = rootEl.children[i]; + if (closest(el, this.options.draggable, rootEl, false)) { + items[id] = el; + } + }, this); + useAnimation && this.captureAnimationState(); + order.forEach(function (id) { + if (items[id]) { + rootEl.removeChild(items[id]); + rootEl.appendChild(items[id]); + } + }); + useAnimation && this.animateAll(); + }, + /** + * Save the current sorting + */ + save: function save() { + var store = this.options.store; + store && store.set && store.set(this); + }, + /** + * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree. + * @param {HTMLElement} el + * @param {String} [selector] default: `options.draggable` + * @returns {HTMLElement|null} + */ + closest: function closest$1(el, selector) { + return closest(el, selector || this.options.draggable, this.el, false); + }, + /** + * Set/get option + * @param {string} name + * @param {*} [value] + * @returns {*} + */ + option: function option(name, value) { + var options = this.options; + if (value === void 0) { + return options[name]; + } else { + var modifiedValue = PluginManager.modifyOption(this, name, value); + if (typeof modifiedValue !== 'undefined') { + options[name] = modifiedValue; + } else { + options[name] = value; + } + if (name === 'group') { + _prepareGroup(options); + } + } + }, + /** + * Destroy + */ + destroy: function destroy() { + pluginEvent('destroy', this); + var el = this.el; + el[expando] = null; + off(el, 'mousedown', this._onTapStart); + off(el, 'touchstart', this._onTapStart); + off(el, 'pointerdown', this._onTapStart); + if (this.nativeDraggable) { + off(el, 'dragover', this); + off(el, 'dragenter', this); + } + // Remove draggable attributes + Array.prototype.forEach.call(el.querySelectorAll('[draggable]'), function (el) { + el.removeAttribute('draggable'); + }); + this._onDrop(); + this._disableDelayedDragEvents(); + sortables.splice(sortables.indexOf(this.el), 1); + this.el = el = null; + }, + _hideClone: function _hideClone() { + if (!cloneHidden) { + pluginEvent('hideClone', this); + if (Sortable.eventCanceled) return; + css(cloneEl, 'display', 'none'); + if (this.options.removeCloneOnHide && cloneEl.parentNode) { + cloneEl.parentNode.removeChild(cloneEl); + } + cloneHidden = true; + } + }, + _showClone: function _showClone(putSortable) { + if (putSortable.lastPutMode !== 'clone') { + this._hideClone(); + return; + } + if (cloneHidden) { + pluginEvent('showClone', this); + if (Sortable.eventCanceled) return; + + // show clone at dragEl or original position + if (dragEl.parentNode == rootEl && !this.options.group.revertClone) { + rootEl.insertBefore(cloneEl, dragEl); + } else if (nextEl) { + rootEl.insertBefore(cloneEl, nextEl); + } else { + rootEl.appendChild(cloneEl); + } + if (this.options.group.revertClone) { + this.animate(dragEl, cloneEl); + } + css(cloneEl, 'display', ''); + cloneHidden = false; + } + } +}; +function _globalDragOver( /**Event*/evt) { + if (evt.dataTransfer) { + evt.dataTransfer.dropEffect = 'move'; + } + evt.cancelable && evt.preventDefault(); +} +function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect, originalEvent, willInsertAfter) { + var evt, + sortable = fromEl[expando], + onMoveFn = sortable.options.onMove, + retVal; + // Support for new CustomEvent feature + if (window.CustomEvent && !IE11OrLess && !Edge) { + evt = new CustomEvent('move', { + bubbles: true, + cancelable: true + }); + } else { + evt = document.createEvent('Event'); + evt.initEvent('move', true, true); + } + evt.to = toEl; + evt.from = fromEl; + evt.dragged = dragEl; + evt.draggedRect = dragRect; + evt.related = targetEl || toEl; + evt.relatedRect = targetRect || getRect(toEl); + evt.willInsertAfter = willInsertAfter; + evt.originalEvent = originalEvent; + fromEl.dispatchEvent(evt); + if (onMoveFn) { + retVal = onMoveFn.call(sortable, evt, originalEvent); + } + return retVal; +} +function _disableDraggable(el) { + el.draggable = false; +} +function _unsilent() { + _silent = false; +} +function _ghostIsFirst(evt, vertical, sortable) { + var firstElRect = getRect(getChild(sortable.el, 0, sortable.options, true)); + var childContainingRect = getChildContainingRectFromElement(sortable.el, sortable.options, ghostEl); + var spacer = 10; + return vertical ? evt.clientX < childContainingRect.left - spacer || evt.clientY < firstElRect.top && evt.clientX < firstElRect.right : evt.clientY < childContainingRect.top - spacer || evt.clientY < firstElRect.bottom && evt.clientX < firstElRect.left; +} +function _ghostIsLast(evt, vertical, sortable) { + var lastElRect = getRect(lastChild(sortable.el, sortable.options.draggable)); + var childContainingRect = getChildContainingRectFromElement(sortable.el, sortable.options, ghostEl); + var spacer = 10; + return vertical ? evt.clientX > childContainingRect.right + spacer || evt.clientY > lastElRect.bottom && evt.clientX > lastElRect.left : evt.clientY > childContainingRect.bottom + spacer || evt.clientX > lastElRect.right && evt.clientY > lastElRect.top; +} +function _getSwapDirection(evt, target, targetRect, vertical, swapThreshold, invertedSwapThreshold, invertSwap, isLastTarget) { + var mouseOnAxis = vertical ? evt.clientY : evt.clientX, + targetLength = vertical ? targetRect.height : targetRect.width, + targetS1 = vertical ? targetRect.top : targetRect.left, + targetS2 = vertical ? targetRect.bottom : targetRect.right, + invert = false; + if (!invertSwap) { + // Never invert or create dragEl shadow when target movemenet causes mouse to move past the end of regular swapThreshold + if (isLastTarget && targetMoveDistance < targetLength * swapThreshold) { + // multiplied only by swapThreshold because mouse will already be inside target by (1 - threshold) * targetLength / 2 + // check if past first invert threshold on side opposite of lastDirection + if (!pastFirstInvertThresh && (lastDirection === 1 ? mouseOnAxis > targetS1 + targetLength * invertedSwapThreshold / 2 : mouseOnAxis < targetS2 - targetLength * invertedSwapThreshold / 2)) { + // past first invert threshold, do not restrict inverted threshold to dragEl shadow + pastFirstInvertThresh = true; + } + if (!pastFirstInvertThresh) { + // dragEl shadow (target move distance shadow) + if (lastDirection === 1 ? mouseOnAxis < targetS1 + targetMoveDistance // over dragEl shadow + : mouseOnAxis > targetS2 - targetMoveDistance) { + return -lastDirection; + } + } else { + invert = true; + } + } else { + // Regular + if (mouseOnAxis > targetS1 + targetLength * (1 - swapThreshold) / 2 && mouseOnAxis < targetS2 - targetLength * (1 - swapThreshold) / 2) { + return _getInsertDirection(target); + } + } + } + invert = invert || invertSwap; + if (invert) { + // Invert of regular + if (mouseOnAxis < targetS1 + targetLength * invertedSwapThreshold / 2 || mouseOnAxis > targetS2 - targetLength * invertedSwapThreshold / 2) { + return mouseOnAxis > targetS1 + targetLength / 2 ? 1 : -1; + } + } + return 0; +} + +/** + * Gets the direction dragEl must be swapped relative to target in order to make it + * seem that dragEl has been "inserted" into that element's position + * @param {HTMLElement} target The target whose position dragEl is being inserted at + * @return {Number} Direction dragEl must be swapped + */ +function _getInsertDirection(target) { + if (index(dragEl) < index(target)) { + return 1; + } else { + return -1; + } +} + +/** + * Generate id + * @param {HTMLElement} el + * @returns {String} + * @private + */ +function _generateId(el) { + var str = el.tagName + el.className + el.src + el.href + el.textContent, + i = str.length, + sum = 0; + while (i--) { + sum += str.charCodeAt(i); + } + return sum.toString(36); +} +function _saveInputCheckedState(root) { + savedInputChecked.length = 0; + var inputs = root.getElementsByTagName('input'); + var idx = inputs.length; + while (idx--) { + var el = inputs[idx]; + el.checked && savedInputChecked.push(el); + } +} +function _nextTick(fn) { + return setTimeout(fn, 0); +} +function _cancelNextTick(id) { + return clearTimeout(id); +} + +// Fixed #973: +if (documentExists) { + on(document, 'touchmove', function (evt) { + if ((Sortable.active || awaitingDragStarted) && evt.cancelable) { + evt.preventDefault(); + } + }); +} + +// Export utils +Sortable.utils = { + on: on, + off: off, + css: css, + find: find, + is: function is(el, selector) { + return !!closest(el, selector, el, false); + }, + extend: extend, + throttle: throttle, + closest: closest, + toggleClass: toggleClass, + clone: clone, + index: index, + nextTick: _nextTick, + cancelNextTick: _cancelNextTick, + detectDirection: _detectDirection, + getChild: getChild +}; + +/** + * Get the Sortable instance of an element + * @param {HTMLElement} element The element + * @return {Sortable|undefined} The instance of Sortable + */ +Sortable.get = function (element) { + return element[expando]; +}; + +/** + * Mount a plugin to Sortable + * @param {...SortablePlugin|SortablePlugin[]} plugins Plugins being mounted + */ +Sortable.mount = function () { + for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) { + plugins[_key] = arguments[_key]; + } + if (plugins[0].constructor === Array) plugins = plugins[0]; + plugins.forEach(function (plugin) { + if (!plugin.prototype || !plugin.prototype.constructor) { + throw "Sortable: Mounted plugin must be a constructor function, not ".concat({}.toString.call(plugin)); + } + if (plugin.utils) Sortable.utils = _objectSpread2(_objectSpread2({}, Sortable.utils), plugin.utils); + PluginManager.mount(plugin); + }); +}; + +/** + * Create sortable instance + * @param {HTMLElement} el + * @param {Object} [options] + */ +Sortable.create = function (el, options) { + return new Sortable(el, options); +}; + +// Export +Sortable.version = version; + +var autoScrolls = [], + scrollEl, + scrollRootEl, + scrolling = false, + lastAutoScrollX, + lastAutoScrollY, + touchEvt$1, + pointerElemChangedInterval; +function AutoScrollPlugin() { + function AutoScroll() { + this.defaults = { + scroll: true, + forceAutoScrollFallback: false, + scrollSensitivity: 30, + scrollSpeed: 10, + bubbleScroll: true + }; + + // Bind all private methods + for (var fn in this) { + if (fn.charAt(0) === '_' && typeof this[fn] === 'function') { + this[fn] = this[fn].bind(this); + } + } + } + AutoScroll.prototype = { + dragStarted: function dragStarted(_ref) { + var originalEvent = _ref.originalEvent; + if (this.sortable.nativeDraggable) { + on(document, 'dragover', this._handleAutoScroll); + } else { + if (this.options.supportPointer) { + on(document, 'pointermove', this._handleFallbackAutoScroll); + } else if (originalEvent.touches) { + on(document, 'touchmove', this._handleFallbackAutoScroll); + } else { + on(document, 'mousemove', this._handleFallbackAutoScroll); + } + } + }, + dragOverCompleted: function dragOverCompleted(_ref2) { + var originalEvent = _ref2.originalEvent; + // For when bubbling is canceled and using fallback (fallback 'touchmove' always reached) + if (!this.options.dragOverBubble && !originalEvent.rootEl) { + this._handleAutoScroll(originalEvent); + } + }, + drop: function drop() { + if (this.sortable.nativeDraggable) { + off(document, 'dragover', this._handleAutoScroll); + } else { + off(document, 'pointermove', this._handleFallbackAutoScroll); + off(document, 'touchmove', this._handleFallbackAutoScroll); + off(document, 'mousemove', this._handleFallbackAutoScroll); + } + clearPointerElemChangedInterval(); + clearAutoScrolls(); + cancelThrottle(); + }, + nulling: function nulling() { + touchEvt$1 = scrollRootEl = scrollEl = scrolling = pointerElemChangedInterval = lastAutoScrollX = lastAutoScrollY = null; + autoScrolls.length = 0; + }, + _handleFallbackAutoScroll: function _handleFallbackAutoScroll(evt) { + this._handleAutoScroll(evt, true); + }, + _handleAutoScroll: function _handleAutoScroll(evt, fallback) { + var _this = this; + var x = (evt.touches ? evt.touches[0] : evt).clientX, + y = (evt.touches ? evt.touches[0] : evt).clientY, + elem = document.elementFromPoint(x, y); + touchEvt$1 = evt; + + // IE does not seem to have native autoscroll, + // Edge's autoscroll seems too conditional, + // MACOS Safari does not have autoscroll, + // Firefox and Chrome are good + if (fallback || this.options.forceAutoScrollFallback || Edge || IE11OrLess || Safari) { + autoScroll(evt, this.options, elem, fallback); + + // Listener for pointer element change + var ogElemScroller = getParentAutoScrollElement(elem, true); + if (scrolling && (!pointerElemChangedInterval || x !== lastAutoScrollX || y !== lastAutoScrollY)) { + pointerElemChangedInterval && clearPointerElemChangedInterval(); + // Detect for pointer elem change, emulating native DnD behaviour + pointerElemChangedInterval = setInterval(function () { + var newElem = getParentAutoScrollElement(document.elementFromPoint(x, y), true); + if (newElem !== ogElemScroller) { + ogElemScroller = newElem; + clearAutoScrolls(); + } + autoScroll(evt, _this.options, newElem, fallback); + }, 10); + lastAutoScrollX = x; + lastAutoScrollY = y; + } + } else { + // if DnD is enabled (and browser has good autoscrolling), first autoscroll will already scroll, so get parent autoscroll of first autoscroll + if (!this.options.bubbleScroll || getParentAutoScrollElement(elem, true) === getWindowScrollingElement()) { + clearAutoScrolls(); + return; + } + autoScroll(evt, this.options, getParentAutoScrollElement(elem, false), false); + } + } + }; + return _extends(AutoScroll, { + pluginName: 'scroll', + initializeByDefault: true + }); +} +function clearAutoScrolls() { + autoScrolls.forEach(function (autoScroll) { + clearInterval(autoScroll.pid); + }); + autoScrolls = []; +} +function clearPointerElemChangedInterval() { + clearInterval(pointerElemChangedInterval); +} +var autoScroll = throttle(function (evt, options, rootEl, isFallback) { + // Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=505521 + if (!options.scroll) return; + var x = (evt.touches ? evt.touches[0] : evt).clientX, + y = (evt.touches ? evt.touches[0] : evt).clientY, + sens = options.scrollSensitivity, + speed = options.scrollSpeed, + winScroller = getWindowScrollingElement(); + var scrollThisInstance = false, + scrollCustomFn; + + // New scroll root, set scrollEl + if (scrollRootEl !== rootEl) { + scrollRootEl = rootEl; + clearAutoScrolls(); + scrollEl = options.scroll; + scrollCustomFn = options.scrollFn; + if (scrollEl === true) { + scrollEl = getParentAutoScrollElement(rootEl, true); + } + } + var layersOut = 0; + var currentParent = scrollEl; + do { + var el = currentParent, + rect = getRect(el), + top = rect.top, + bottom = rect.bottom, + left = rect.left, + right = rect.right, + width = rect.width, + height = rect.height, + canScrollX = void 0, + canScrollY = void 0, + scrollWidth = el.scrollWidth, + scrollHeight = el.scrollHeight, + elCSS = css(el), + scrollPosX = el.scrollLeft, + scrollPosY = el.scrollTop; + if (el === winScroller) { + canScrollX = width < scrollWidth && (elCSS.overflowX === 'auto' || elCSS.overflowX === 'scroll' || elCSS.overflowX === 'visible'); + canScrollY = height < scrollHeight && (elCSS.overflowY === 'auto' || elCSS.overflowY === 'scroll' || elCSS.overflowY === 'visible'); + } else { + canScrollX = width < scrollWidth && (elCSS.overflowX === 'auto' || elCSS.overflowX === 'scroll'); + canScrollY = height < scrollHeight && (elCSS.overflowY === 'auto' || elCSS.overflowY === 'scroll'); + } + var vx = canScrollX && (Math.abs(right - x) <= sens && scrollPosX + width < scrollWidth) - (Math.abs(left - x) <= sens && !!scrollPosX); + var vy = canScrollY && (Math.abs(bottom - y) <= sens && scrollPosY + height < scrollHeight) - (Math.abs(top - y) <= sens && !!scrollPosY); + if (!autoScrolls[layersOut]) { + for (var i = 0; i <= layersOut; i++) { + if (!autoScrolls[i]) { + autoScrolls[i] = {}; + } + } + } + if (autoScrolls[layersOut].vx != vx || autoScrolls[layersOut].vy != vy || autoScrolls[layersOut].el !== el) { + autoScrolls[layersOut].el = el; + autoScrolls[layersOut].vx = vx; + autoScrolls[layersOut].vy = vy; + clearInterval(autoScrolls[layersOut].pid); + if (vx != 0 || vy != 0) { + scrollThisInstance = true; + /* jshint loopfunc:true */ + autoScrolls[layersOut].pid = setInterval(function () { + // emulate drag over during autoscroll (fallback), emulating native DnD behaviour + if (isFallback && this.layer === 0) { + Sortable.active._onTouchMove(touchEvt$1); // To move ghost if it is positioned absolutely + } + var scrollOffsetY = autoScrolls[this.layer].vy ? autoScrolls[this.layer].vy * speed : 0; + var scrollOffsetX = autoScrolls[this.layer].vx ? autoScrolls[this.layer].vx * speed : 0; + if (typeof scrollCustomFn === 'function') { + if (scrollCustomFn.call(Sortable.dragged.parentNode[expando], scrollOffsetX, scrollOffsetY, evt, touchEvt$1, autoScrolls[this.layer].el) !== 'continue') { + return; + } + } + scrollBy(autoScrolls[this.layer].el, scrollOffsetX, scrollOffsetY); + }.bind({ + layer: layersOut + }), 24); + } + } + layersOut++; + } while (options.bubbleScroll && currentParent !== winScroller && (currentParent = getParentAutoScrollElement(currentParent, false))); + scrolling = scrollThisInstance; // in case another function catches scrolling as false in between when it is not +}, 30); + +var drop = function drop(_ref) { + var originalEvent = _ref.originalEvent, + putSortable = _ref.putSortable, + dragEl = _ref.dragEl, + activeSortable = _ref.activeSortable, + dispatchSortableEvent = _ref.dispatchSortableEvent, + hideGhostForTarget = _ref.hideGhostForTarget, + unhideGhostForTarget = _ref.unhideGhostForTarget; + if (!originalEvent) return; + var toSortable = putSortable || activeSortable; + hideGhostForTarget(); + var touch = originalEvent.changedTouches && originalEvent.changedTouches.length ? originalEvent.changedTouches[0] : originalEvent; + var target = document.elementFromPoint(touch.clientX, touch.clientY); + unhideGhostForTarget(); + if (toSortable && !toSortable.el.contains(target)) { + dispatchSortableEvent('spill'); + this.onSpill({ + dragEl: dragEl, + putSortable: putSortable + }); + } +}; +function Revert() {} +Revert.prototype = { + startIndex: null, + dragStart: function dragStart(_ref2) { + var oldDraggableIndex = _ref2.oldDraggableIndex; + this.startIndex = oldDraggableIndex; + }, + onSpill: function onSpill(_ref3) { + var dragEl = _ref3.dragEl, + putSortable = _ref3.putSortable; + this.sortable.captureAnimationState(); + if (putSortable) { + putSortable.captureAnimationState(); + } + var nextSibling = getChild(this.sortable.el, this.startIndex, this.options); + if (nextSibling) { + this.sortable.el.insertBefore(dragEl, nextSibling); + } else { + this.sortable.el.appendChild(dragEl); + } + this.sortable.animateAll(); + if (putSortable) { + putSortable.animateAll(); + } + }, + drop: drop +}; +_extends(Revert, { + pluginName: 'revertOnSpill' +}); +function Remove() {} +Remove.prototype = { + onSpill: function onSpill(_ref4) { + var dragEl = _ref4.dragEl, + putSortable = _ref4.putSortable; + var parentSortable = putSortable || this.sortable; + parentSortable.captureAnimationState(); + dragEl.parentNode && dragEl.parentNode.removeChild(dragEl); + parentSortable.animateAll(); + }, + drop: drop +}; +_extends(Remove, { + pluginName: 'removeOnSpill' +}); +var OnSpill = [Remove, Revert]; + +var lastSwapEl; +function SwapPlugin() { + function Swap() { + this.defaults = { + swapClass: 'sortable-swap-highlight' + }; + } + Swap.prototype = { + dragStart: function dragStart(_ref) { + var dragEl = _ref.dragEl; + lastSwapEl = dragEl; + }, + dragOverValid: function dragOverValid(_ref2) { + var completed = _ref2.completed, + target = _ref2.target, + onMove = _ref2.onMove, + activeSortable = _ref2.activeSortable, + changed = _ref2.changed, + cancel = _ref2.cancel; + if (!activeSortable.options.swap) return; + var el = this.sortable.el, + options = this.options; + if (target && target !== el) { + var prevSwapEl = lastSwapEl; + if (onMove(target) !== false) { + toggleClass(target, options.swapClass, true); + lastSwapEl = target; + } else { + lastSwapEl = null; + } + if (prevSwapEl && prevSwapEl !== lastSwapEl) { + toggleClass(prevSwapEl, options.swapClass, false); + } + } + changed(); + completed(true); + cancel(); + }, + drop: function drop(_ref3) { + var activeSortable = _ref3.activeSortable, + putSortable = _ref3.putSortable, + dragEl = _ref3.dragEl; + var toSortable = putSortable || this.sortable; + var options = this.options; + lastSwapEl && toggleClass(lastSwapEl, options.swapClass, false); + if (lastSwapEl && (options.swap || putSortable && putSortable.options.swap)) { + if (dragEl !== lastSwapEl) { + toSortable.captureAnimationState(); + if (toSortable !== activeSortable) activeSortable.captureAnimationState(); + swapNodes(dragEl, lastSwapEl); + toSortable.animateAll(); + if (toSortable !== activeSortable) activeSortable.animateAll(); + } + } + }, + nulling: function nulling() { + lastSwapEl = null; + } + }; + return _extends(Swap, { + pluginName: 'swap', + eventProperties: function eventProperties() { + return { + swapItem: lastSwapEl + }; + } + }); +} +function swapNodes(n1, n2) { + var p1 = n1.parentNode, + p2 = n2.parentNode, + i1, + i2; + if (!p1 || !p2 || p1.isEqualNode(n2) || p2.isEqualNode(n1)) return; + i1 = index(n1); + i2 = index(n2); + if (p1.isEqualNode(p2) && i1 < i2) { + i2++; + } + p1.insertBefore(n2, p1.children[i1]); + p2.insertBefore(n1, p2.children[i2]); +} + +var multiDragElements = [], + multiDragClones = [], + lastMultiDragSelect, + // for selection with modifier key down (SHIFT) + multiDragSortable, + initialFolding = false, + // Initial multi-drag fold when drag started + folding = false, + // Folding any other time + dragStarted = false, + dragEl$1, + clonesFromRect, + clonesHidden; +function MultiDragPlugin() { + function MultiDrag(sortable) { + // Bind all private methods + for (var fn in this) { + if (fn.charAt(0) === '_' && typeof this[fn] === 'function') { + this[fn] = this[fn].bind(this); + } + } + if (!sortable.options.avoidImplicitDeselect) { + if (sortable.options.supportPointer) { + on(document, 'pointerup', this._deselectMultiDrag); + } else { + on(document, 'mouseup', this._deselectMultiDrag); + on(document, 'touchend', this._deselectMultiDrag); + } + } + on(document, 'keydown', this._checkKeyDown); + on(document, 'keyup', this._checkKeyUp); + this.defaults = { + selectedClass: 'sortable-selected', + multiDragKey: null, + avoidImplicitDeselect: false, + setData: function setData(dataTransfer, dragEl) { + var data = ''; + if (multiDragElements.length && multiDragSortable === sortable) { + multiDragElements.forEach(function (multiDragElement, i) { + data += (!i ? '' : ', ') + multiDragElement.textContent; + }); + } else { + data = dragEl.textContent; + } + dataTransfer.setData('Text', data); + } + }; + } + MultiDrag.prototype = { + multiDragKeyDown: false, + isMultiDrag: false, + delayStartGlobal: function delayStartGlobal(_ref) { + var dragged = _ref.dragEl; + dragEl$1 = dragged; + }, + delayEnded: function delayEnded() { + this.isMultiDrag = ~multiDragElements.indexOf(dragEl$1); + }, + setupClone: function setupClone(_ref2) { + var sortable = _ref2.sortable, + cancel = _ref2.cancel; + if (!this.isMultiDrag) return; + for (var i = 0; i < multiDragElements.length; i++) { + multiDragClones.push(clone(multiDragElements[i])); + multiDragClones[i].sortableIndex = multiDragElements[i].sortableIndex; + multiDragClones[i].draggable = false; + multiDragClones[i].style['will-change'] = ''; + toggleClass(multiDragClones[i], this.options.selectedClass, false); + multiDragElements[i] === dragEl$1 && toggleClass(multiDragClones[i], this.options.chosenClass, false); + } + sortable._hideClone(); + cancel(); + }, + clone: function clone(_ref3) { + var sortable = _ref3.sortable, + rootEl = _ref3.rootEl, + dispatchSortableEvent = _ref3.dispatchSortableEvent, + cancel = _ref3.cancel; + if (!this.isMultiDrag) return; + if (!this.options.removeCloneOnHide) { + if (multiDragElements.length && multiDragSortable === sortable) { + insertMultiDragClones(true, rootEl); + dispatchSortableEvent('clone'); + cancel(); + } + } + }, + showClone: function showClone(_ref4) { + var cloneNowShown = _ref4.cloneNowShown, + rootEl = _ref4.rootEl, + cancel = _ref4.cancel; + if (!this.isMultiDrag) return; + insertMultiDragClones(false, rootEl); + multiDragClones.forEach(function (clone) { + css(clone, 'display', ''); + }); + cloneNowShown(); + clonesHidden = false; + cancel(); + }, + hideClone: function hideClone(_ref5) { + var _this = this; + var sortable = _ref5.sortable, + cloneNowHidden = _ref5.cloneNowHidden, + cancel = _ref5.cancel; + if (!this.isMultiDrag) return; + multiDragClones.forEach(function (clone) { + css(clone, 'display', 'none'); + if (_this.options.removeCloneOnHide && clone.parentNode) { + clone.parentNode.removeChild(clone); + } + }); + cloneNowHidden(); + clonesHidden = true; + cancel(); + }, + dragStartGlobal: function dragStartGlobal(_ref6) { + var sortable = _ref6.sortable; + if (!this.isMultiDrag && multiDragSortable) { + multiDragSortable.multiDrag._deselectMultiDrag(); + } + multiDragElements.forEach(function (multiDragElement) { + multiDragElement.sortableIndex = index(multiDragElement); + }); + + // Sort multi-drag elements + multiDragElements = multiDragElements.sort(function (a, b) { + return a.sortableIndex - b.sortableIndex; + }); + dragStarted = true; + }, + dragStarted: function dragStarted(_ref7) { + var _this2 = this; + var sortable = _ref7.sortable; + if (!this.isMultiDrag) return; + if (this.options.sort) { + // Capture rects, + // hide multi drag elements (by positioning them absolute), + // set multi drag elements rects to dragRect, + // show multi drag elements, + // animate to rects, + // unset rects & remove from DOM + + sortable.captureAnimationState(); + if (this.options.animation) { + multiDragElements.forEach(function (multiDragElement) { + if (multiDragElement === dragEl$1) return; + css(multiDragElement, 'position', 'absolute'); + }); + var dragRect = getRect(dragEl$1, false, true, true); + multiDragElements.forEach(function (multiDragElement) { + if (multiDragElement === dragEl$1) return; + setRect(multiDragElement, dragRect); + }); + folding = true; + initialFolding = true; + } + } + sortable.animateAll(function () { + folding = false; + initialFolding = false; + if (_this2.options.animation) { + multiDragElements.forEach(function (multiDragElement) { + unsetRect(multiDragElement); + }); + } + + // Remove all auxiliary multidrag items from el, if sorting enabled + if (_this2.options.sort) { + removeMultiDragElements(); + } + }); + }, + dragOver: function dragOver(_ref8) { + var target = _ref8.target, + completed = _ref8.completed, + cancel = _ref8.cancel; + if (folding && ~multiDragElements.indexOf(target)) { + completed(false); + cancel(); + } + }, + revert: function revert(_ref9) { + var fromSortable = _ref9.fromSortable, + rootEl = _ref9.rootEl, + sortable = _ref9.sortable, + dragRect = _ref9.dragRect; + if (multiDragElements.length > 1) { + // Setup unfold animation + multiDragElements.forEach(function (multiDragElement) { + sortable.addAnimationState({ + target: multiDragElement, + rect: folding ? getRect(multiDragElement) : dragRect + }); + unsetRect(multiDragElement); + multiDragElement.fromRect = dragRect; + fromSortable.removeAnimationState(multiDragElement); + }); + folding = false; + insertMultiDragElements(!this.options.removeCloneOnHide, rootEl); + } + }, + dragOverCompleted: function dragOverCompleted(_ref10) { + var sortable = _ref10.sortable, + isOwner = _ref10.isOwner, + insertion = _ref10.insertion, + activeSortable = _ref10.activeSortable, + parentEl = _ref10.parentEl, + putSortable = _ref10.putSortable; + var options = this.options; + if (insertion) { + // Clones must be hidden before folding animation to capture dragRectAbsolute properly + if (isOwner) { + activeSortable._hideClone(); + } + initialFolding = false; + // If leaving sort:false root, or already folding - Fold to new location + if (options.animation && multiDragElements.length > 1 && (folding || !isOwner && !activeSortable.options.sort && !putSortable)) { + // Fold: Set all multi drag elements's rects to dragEl's rect when multi-drag elements are invisible + var dragRectAbsolute = getRect(dragEl$1, false, true, true); + multiDragElements.forEach(function (multiDragElement) { + if (multiDragElement === dragEl$1) return; + setRect(multiDragElement, dragRectAbsolute); + + // Move element(s) to end of parentEl so that it does not interfere with multi-drag clones insertion if they are inserted + // while folding, and so that we can capture them again because old sortable will no longer be fromSortable + parentEl.appendChild(multiDragElement); + }); + folding = true; + } + + // Clones must be shown (and check to remove multi drags) after folding when interfering multiDragElements are moved out + if (!isOwner) { + // Only remove if not folding (folding will remove them anyways) + if (!folding) { + removeMultiDragElements(); + } + if (multiDragElements.length > 1) { + var clonesHiddenBefore = clonesHidden; + activeSortable._showClone(sortable); + + // Unfold animation for clones if showing from hidden + if (activeSortable.options.animation && !clonesHidden && clonesHiddenBefore) { + multiDragClones.forEach(function (clone) { + activeSortable.addAnimationState({ + target: clone, + rect: clonesFromRect + }); + clone.fromRect = clonesFromRect; + clone.thisAnimationDuration = null; + }); + } + } else { + activeSortable._showClone(sortable); + } + } + } + }, + dragOverAnimationCapture: function dragOverAnimationCapture(_ref11) { + var dragRect = _ref11.dragRect, + isOwner = _ref11.isOwner, + activeSortable = _ref11.activeSortable; + multiDragElements.forEach(function (multiDragElement) { + multiDragElement.thisAnimationDuration = null; + }); + if (activeSortable.options.animation && !isOwner && activeSortable.multiDrag.isMultiDrag) { + clonesFromRect = _extends({}, dragRect); + var dragMatrix = matrix(dragEl$1, true); + clonesFromRect.top -= dragMatrix.f; + clonesFromRect.left -= dragMatrix.e; + } + }, + dragOverAnimationComplete: function dragOverAnimationComplete() { + if (folding) { + folding = false; + removeMultiDragElements(); + } + }, + drop: function drop(_ref12) { + var evt = _ref12.originalEvent, + rootEl = _ref12.rootEl, + parentEl = _ref12.parentEl, + sortable = _ref12.sortable, + dispatchSortableEvent = _ref12.dispatchSortableEvent, + oldIndex = _ref12.oldIndex, + putSortable = _ref12.putSortable; + var toSortable = putSortable || this.sortable; + if (!evt) return; + var options = this.options, + children = parentEl.children; + + // Multi-drag selection + if (!dragStarted) { + if (options.multiDragKey && !this.multiDragKeyDown) { + this._deselectMultiDrag(); + } + toggleClass(dragEl$1, options.selectedClass, !~multiDragElements.indexOf(dragEl$1)); + if (!~multiDragElements.indexOf(dragEl$1)) { + multiDragElements.push(dragEl$1); + dispatchEvent({ + sortable: sortable, + rootEl: rootEl, + name: 'select', + targetEl: dragEl$1, + originalEvent: evt + }); + + // Modifier activated, select from last to dragEl + if (evt.shiftKey && lastMultiDragSelect && sortable.el.contains(lastMultiDragSelect)) { + var lastIndex = index(lastMultiDragSelect), + currentIndex = index(dragEl$1); + if (~lastIndex && ~currentIndex && lastIndex !== currentIndex) { + // Must include lastMultiDragSelect (select it), in case modified selection from no selection + // (but previous selection existed) + var n, i; + if (currentIndex > lastIndex) { + i = lastIndex; + n = currentIndex; + } else { + i = currentIndex; + n = lastIndex + 1; + } + for (; i < n; i++) { + if (~multiDragElements.indexOf(children[i])) continue; + toggleClass(children[i], options.selectedClass, true); + multiDragElements.push(children[i]); + dispatchEvent({ + sortable: sortable, + rootEl: rootEl, + name: 'select', + targetEl: children[i], + originalEvent: evt + }); + } + } + } else { + lastMultiDragSelect = dragEl$1; + } + multiDragSortable = toSortable; + } else { + multiDragElements.splice(multiDragElements.indexOf(dragEl$1), 1); + lastMultiDragSelect = null; + dispatchEvent({ + sortable: sortable, + rootEl: rootEl, + name: 'deselect', + targetEl: dragEl$1, + originalEvent: evt + }); + } + } + + // Multi-drag drop + if (dragStarted && this.isMultiDrag) { + folding = false; + // Do not "unfold" after around dragEl if reverted + if ((parentEl[expando].options.sort || parentEl !== rootEl) && multiDragElements.length > 1) { + var dragRect = getRect(dragEl$1), + multiDragIndex = index(dragEl$1, ':not(.' + this.options.selectedClass + ')'); + if (!initialFolding && options.animation) dragEl$1.thisAnimationDuration = null; + toSortable.captureAnimationState(); + if (!initialFolding) { + if (options.animation) { + dragEl$1.fromRect = dragRect; + multiDragElements.forEach(function (multiDragElement) { + multiDragElement.thisAnimationDuration = null; + if (multiDragElement !== dragEl$1) { + var rect = folding ? getRect(multiDragElement) : dragRect; + multiDragElement.fromRect = rect; + + // Prepare unfold animation + toSortable.addAnimationState({ + target: multiDragElement, + rect: rect + }); + } + }); + } + + // Multi drag elements are not necessarily removed from the DOM on drop, so to reinsert + // properly they must all be removed + removeMultiDragElements(); + multiDragElements.forEach(function (multiDragElement) { + if (children[multiDragIndex]) { + parentEl.insertBefore(multiDragElement, children[multiDragIndex]); + } else { + parentEl.appendChild(multiDragElement); + } + multiDragIndex++; + }); + + // If initial folding is done, the elements may have changed position because they are now + // unfolding around dragEl, even though dragEl may not have his index changed, so update event + // must be fired here as Sortable will not. + if (oldIndex === index(dragEl$1)) { + var update = false; + multiDragElements.forEach(function (multiDragElement) { + if (multiDragElement.sortableIndex !== index(multiDragElement)) { + update = true; + return; + } + }); + if (update) { + dispatchSortableEvent('update'); + dispatchSortableEvent('sort'); + } + } + } + + // Must be done after capturing individual rects (scroll bar) + multiDragElements.forEach(function (multiDragElement) { + unsetRect(multiDragElement); + }); + toSortable.animateAll(); + } + multiDragSortable = toSortable; + } + + // Remove clones if necessary + if (rootEl === parentEl || putSortable && putSortable.lastPutMode !== 'clone') { + multiDragClones.forEach(function (clone) { + clone.parentNode && clone.parentNode.removeChild(clone); + }); + } + }, + nullingGlobal: function nullingGlobal() { + this.isMultiDrag = dragStarted = false; + multiDragClones.length = 0; + }, + destroyGlobal: function destroyGlobal() { + this._deselectMultiDrag(); + off(document, 'pointerup', this._deselectMultiDrag); + off(document, 'mouseup', this._deselectMultiDrag); + off(document, 'touchend', this._deselectMultiDrag); + off(document, 'keydown', this._checkKeyDown); + off(document, 'keyup', this._checkKeyUp); + }, + _deselectMultiDrag: function _deselectMultiDrag(evt) { + if (typeof dragStarted !== "undefined" && dragStarted) return; + + // Only deselect if selection is in this sortable + if (multiDragSortable !== this.sortable) return; + + // Only deselect if target is not item in this sortable + if (evt && closest(evt.target, this.options.draggable, this.sortable.el, false)) return; + + // Only deselect if left click + if (evt && evt.button !== 0) return; + while (multiDragElements.length) { + var el = multiDragElements[0]; + toggleClass(el, this.options.selectedClass, false); + multiDragElements.shift(); + dispatchEvent({ + sortable: this.sortable, + rootEl: this.sortable.el, + name: 'deselect', + targetEl: el, + originalEvent: evt + }); + } + }, + _checkKeyDown: function _checkKeyDown(evt) { + if (evt.key === this.options.multiDragKey) { + this.multiDragKeyDown = true; + } + }, + _checkKeyUp: function _checkKeyUp(evt) { + if (evt.key === this.options.multiDragKey) { + this.multiDragKeyDown = false; + } + } + }; + return _extends(MultiDrag, { + // Static methods & properties + pluginName: 'multiDrag', + utils: { + /** + * Selects the provided multi-drag item + * @param {HTMLElement} el The element to be selected + */ + select: function select(el) { + var sortable = el.parentNode[expando]; + if (!sortable || !sortable.options.multiDrag || ~multiDragElements.indexOf(el)) return; + if (multiDragSortable && multiDragSortable !== sortable) { + multiDragSortable.multiDrag._deselectMultiDrag(); + multiDragSortable = sortable; + } + toggleClass(el, sortable.options.selectedClass, true); + multiDragElements.push(el); + }, + /** + * Deselects the provided multi-drag item + * @param {HTMLElement} el The element to be deselected + */ + deselect: function deselect(el) { + var sortable = el.parentNode[expando], + index = multiDragElements.indexOf(el); + if (!sortable || !sortable.options.multiDrag || !~index) return; + toggleClass(el, sortable.options.selectedClass, false); + multiDragElements.splice(index, 1); + } + }, + eventProperties: function eventProperties() { + var _this3 = this; + var oldIndicies = [], + newIndicies = []; + multiDragElements.forEach(function (multiDragElement) { + oldIndicies.push({ + multiDragElement: multiDragElement, + index: multiDragElement.sortableIndex + }); + + // multiDragElements will already be sorted if folding + var newIndex; + if (folding && multiDragElement !== dragEl$1) { + newIndex = -1; + } else if (folding) { + newIndex = index(multiDragElement, ':not(.' + _this3.options.selectedClass + ')'); + } else { + newIndex = index(multiDragElement); + } + newIndicies.push({ + multiDragElement: multiDragElement, + index: newIndex + }); + }); + return { + items: _toConsumableArray(multiDragElements), + clones: [].concat(multiDragClones), + oldIndicies: oldIndicies, + newIndicies: newIndicies + }; + }, + optionListeners: { + multiDragKey: function multiDragKey(key) { + key = key.toLowerCase(); + if (key === 'ctrl') { + key = 'Control'; + } else if (key.length > 1) { + key = key.charAt(0).toUpperCase() + key.substr(1); + } + return key; + } + } + }); +} +function insertMultiDragElements(clonesInserted, rootEl) { + multiDragElements.forEach(function (multiDragElement, i) { + var target = rootEl.children[multiDragElement.sortableIndex + (clonesInserted ? Number(i) : 0)]; + if (target) { + rootEl.insertBefore(multiDragElement, target); + } else { + rootEl.appendChild(multiDragElement); + } + }); +} + +/** + * Insert multi-drag clones + * @param {[Boolean]} elementsInserted Whether the multi-drag elements are inserted + * @param {HTMLElement} rootEl + */ +function insertMultiDragClones(elementsInserted, rootEl) { + multiDragClones.forEach(function (clone, i) { + var target = rootEl.children[clone.sortableIndex + (elementsInserted ? Number(i) : 0)]; + if (target) { + rootEl.insertBefore(clone, target); + } else { + rootEl.appendChild(clone); + } + }); +} +function removeMultiDragElements() { + multiDragElements.forEach(function (multiDragElement) { + if (multiDragElement === dragEl$1) return; + multiDragElement.parentNode && multiDragElement.parentNode.removeChild(multiDragElement); + }); +} + +export default Sortable; +export { AutoScrollPlugin as AutoScroll, MultiDragPlugin as MultiDrag, OnSpill, Sortable, SwapPlugin as Swap }; diff --git a/public/assets/scripts/dash/app/vendor/sortable.js b/public/assets/scripts/dash/app/vendor/sortable.js deleted file mode 100644 index 98c6fb8..0000000 --- a/public/assets/scripts/dash/app/vendor/sortable.js +++ /dev/null @@ -1,1513 +0,0 @@ -var t; -export default ((function (t) { - var e; - (e = function () { - if ('undefined' == typeof window || !window.document) - return function () { - throw new Error('Sortable.js requires a window with a document'); - }; - var t, - e, - n, - o, - i, - r, - a, - l, - s, - c, - d, - h, - u, - f, - p, - g, - v, - m, - b, - w, - _, - y, - D, - S, - C, - T = [], - E = !1, - x = !1, - N = !1, - X = [], - Y = !1, - M = !1, - k = /\s+/g, - P = 'Sortable' + new Date().getTime(), - I = window, - A = I.document, - O = I.parseInt, - B = I.setTimeout, - H = I.jQuery || I.Zepto, - R = I.Polymer, - L = { capture: !1, passive: !1 }, - W = !!navigator.userAgent.match(/(?:Trident.*rv[ :]?11\.|msie|iemobile)/i), - F = !!navigator.userAgent.match(/Edge/i), - z = F || W ? 'cssFloat' : 'float', - j = 'draggable' in A.createElement('div'), - U = (function () { - if (W) return !1; - var t = A.createElement('x'); - return ( - (t.style.cssText = 'pointer-events:auto'), - 'auto' === t.style.pointerEvents - ); - })(), - V = !1, - q = !1, - G = Math.abs, - K = Math.min, - Z = [], - Q = function (t, e) { - var n = gt(t), - o = O(n.width), - i = Dt(t, 0, e), - r = Dt(t, 1, e), - a = i && gt(i), - l = r && gt(r), - s = a && O(a.marginLeft) + O(a.marginRight) + kt(i).width, - c = l && O(l.marginLeft) + O(l.marginRight) + kt(r).width; - if ('flex' === n.display) - return 'column' === n.flexDirection || - 'column-reverse' === n.flexDirection - ? 'vertical' - : 'horizontal'; - if (i && 'none' !== a.float) { - var d = 'left' === a.float ? 'left' : 'right'; - return !r || ('both' !== l.clear && l.clear !== d) - ? 'horizontal' - : 'vertical'; - } - return i && - ('block' === a.display || - 'flex' === a.display || - 'table' === a.display || - 'grid' === a.display || - (s >= o && 'none' === n[z]) || - (r && 'none' === n[z] && s + c > o)) - ? 'vertical' - : 'horizontal'; - }, - J = function (t, e) { - if (!t || !t.getBoundingClientRect) return I; - var n = t, - o = !1; - do { - if ( - n.clientWidth < n.scrollWidth || - n.clientHeight < n.scrollHeight - ) { - var i = gt(n); - if ( - (n.clientWidth < n.scrollWidth && - ('auto' == i.overflowX || 'scroll' == i.overflowX)) || - (n.clientHeight < n.scrollHeight && - ('auto' == i.overflowY || 'scroll' == i.overflowY)) - ) { - if (!n || !n.getBoundingClientRect || n === A.body) return I; - if (o || e) return n; - o = !0; - } - } - } while ((n = n.parentNode)); - return I; - }, - $ = xt(function (t, e, n, o) { - if (e.scroll) { - var i = n ? n[P] : window, - r = e.scrollSensitivity, - a = e.scrollSpeed, - d = t.clientX, - h = t.clientY, - u = (window.innerWidth, window.innerHeight, !1); - s !== n && - (tt(), - (l = e.scroll), - (c = e.scrollFn), - !0 === l && ((l = J(n, !0)), (s = l))); - var f = 0, - p = l; - do { - var g, - v, - m, - w, - _, - y, - D, - S, - C, - x = p, - N = kt(x), - X = N.top, - Y = N.bottom, - M = N.left, - k = N.right, - O = N.width, - B = N.height; - if ( - (x !== I - ? ((g = x.scrollWidth), - (v = x.scrollHeight), - (m = gt(x)), - (y = - O < g && - ('auto' === m.overflowX || - 'scroll' === m.overflowX)), - (D = - B < v && - ('auto' === m.overflowY || - 'scroll' === m.overflowY)), - (S = x.scrollLeft), - (C = x.scrollTop)) - : ((g = A.documentElement.scrollWidth), - (v = A.documentElement.scrollHeight), - (m = gt(A.documentElement)), - (y = - O < g && - ('auto' === m.overflowX || - 'scroll' === m.overflowX || - 'visible' === m.overflowX)), - (D = - B < v && - ('auto' === m.overflowY || - 'scroll' === m.overflowY || - 'visible' === m.overflowY)), - (S = A.documentElement.scrollLeft), - (C = A.documentElement.scrollTop)), - (w = - y && - (G(k - d) <= r && S + O < g) - (G(M - d) <= r && !!S)), - (_ = - D && - (G(Y - h) <= r && C + B < v) - (G(X - h) <= r && !!C)), - !T[f]) - ) - for (var H = 0; H <= f; H++) T[H] || (T[H] = {}); - (T[f].vx == w && T[f].vy == _ && T[f].el === x) || - ((T[f].el = x), - (T[f].vx = w), - (T[f].vy = _), - clearInterval(T[f].pid), - !x || - (0 == w && 0 == _) || - ((u = !0), - (T[f].pid = setInterval( - function () { - o && - 0 === this.layer && - ct.active._emulateDragOver(!0); - var e = T[this.layer].vy - ? T[this.layer].vy * a - : 0, - n = T[this.layer].vx - ? T[this.layer].vx * a - : 0; - ('function' == typeof c && - 'continue' !== - c.call( - i, - n, - e, - t, - b, - T[this.layer].el - )) || - (T[this.layer].el === I - ? I.scrollTo( - I.pageXOffset + n, - I.pageYOffset + e - ) - : ((T[this.layer].el.scrollTop += e), - (T[this.layer].el.scrollLeft += n))); - }.bind({ layer: f }), - 24 - )))), - f++; - } while (e.bubbleScroll && p !== I && (p = J(p, !1))); - E = u; - } - }, 30), - tt = function () { - T.forEach(function (t) { - clearInterval(t.pid); - }), - (T = []); - }, - et = function (t) { - function e(t, n) { - return function (o, i, r, a) { - var l = - o.options.group.name && - i.options.group.name && - o.options.group.name === i.options.group.name; - if (null == t && (n || l)) return !0; - if (null == t || !1 === t) return !1; - if (n && 'clone' === t) return t; - if ('function' == typeof t) - return e(t(o, i, r, a), n)(o, i, r, a); - var s = (n ? o : i).options.group.name; - return ( - !0 === t || - ('string' == typeof t && t === s) || - (t.join && t.indexOf(s) > -1) - ); - }; - } - var n = {}, - o = t.group; - (o && 'object' == typeof o) || (o = { name: o }), - (n.name = o.name), - (n.checkPull = e(o.pull, !0)), - (n.checkPut = e(o.put)), - (n.revertClone = o.revertClone), - (t.group = n); - }, - nt = function (e) { - t && - t.parentNode && - t.parentNode[P] && - t.parentNode[P]._computeIsAligned(e); - }, - ot = function (t, e) { - for (var n = e; !n[P]; ) n = n.parentNode; - return t === n; - }, - it = function (t, e, n) { - for (var o = t.parentNode; o && !o[P]; ) o = o.parentNode; - o && o[P][n](Nt(e, { artificialBubble: !0 })); - }, - rt = function () { - !U && n && gt(n, 'display', 'none'); - }, - at = function () { - !U && n && gt(n, 'display', ''); - }; - A.addEventListener( - 'click', - function (t) { - if (N) - return ( - t.preventDefault(), - t.stopPropagation && t.stopPropagation(), - t.stopImmediatePropagation && t.stopImmediatePropagation(), - (N = !1), - !1 - ); - }, - !0 - ); - var lt, - st = function (e) { - if (((e = e.touches ? e.touches[0] : e), t)) { - var n = (function (t, e) { - for (var n = 0; n < X.length; n++) - if (!X[n].children.length) { - var o = kt(X[n]), - i = X[n][P].options.emptyInsertThreshold, - r = t >= o.left - i && t <= o.right + i, - a = e >= o.top - i && e <= o.bottom + i; - if (r && a) return X[n]; - } - })(e.clientX, e.clientY); - n && - n[P]._onDragOver({ - clientX: e.clientX, - clientY: e.clientY, - target: n, - rootEl: n - }); - } - }; - function ct(t, e) { - if (!t || !t.nodeType || 1 !== t.nodeType) - throw 'Sortable: `el` must be HTMLElement, not ' + {}.toString.call(t); - (this.el = t), (this.options = e = Nt({}, e)), (t[P] = this); - var n = { - group: null, - sort: !0, - disabled: !1, - store: null, - handle: null, - scroll: !0, - scrollSensitivity: 30, - scrollSpeed: 10, - bubbleScroll: !0, - draggable: /[uo]l/i.test(t.nodeName) ? '>li' : '>*', - swapThreshold: 1, - invertSwap: !1, - invertedSwapThreshold: null, - removeCloneOnHide: !0, - direction: function () { - return Q(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, - touchStartThreshold: O(window.devicePixelRatio, 10) || 1, - forceFallback: !1, - fallbackClass: 'sortable-fallback', - fallbackOnBody: !1, - fallbackTolerance: 0, - fallbackOffset: { x: 0, y: 0 }, - supportPointer: - !1 !== ct.supportPointer && - ('PointerEvent' in window || - (window.navigator && 'msPointerEnabled' in window.navigator)), - emptyInsertThreshold: 5 - }; - for (var o in n) !(o in e) && (e[o] = n[o]); - for (var i in (et(e), this)) - '_' === i.charAt(0) && - 'function' == typeof this[i] && - (this[i] = this[i].bind(this)); - (this.nativeDraggable = !e.forceFallback && j), - e.supportPointer - ? ut(t, 'pointerdown', this._onTapStart) - : (ut(t, 'mousedown', this._onTapStart), - ut(t, 'touchstart', this._onTapStart)), - this.nativeDraggable && - (ut(t, 'dragover', this), ut(t, 'dragenter', this)), - X.push(this.el), - e.store && e.store.get && this.sort(e.store.get(this) || []); - } - function dt(t, e, n, o) { - if (t) { - n = n || A; - do { - if ( - (null != e && - (('>' === e[0] && - t.parentNode === n && - Et(t, e.substring(1))) || - Et(t, e))) || - (o && t === n) - ) - return t; - if (t === n) break; - } while ((t = ht(t))); - } - return null; - } - function ht(t) { - return t.host && t !== A && t.host.nodeType ? t.host : t.parentNode; - } - function ut(t, e, n) { - t.addEventListener(e, n, L); - } - function ft(t, e, n) { - t.removeEventListener(e, n, L); - } - function pt(t, e, n) { - if (t && e) - if (t.classList) t.classList[n ? 'add' : 'remove'](e); - else { - var o = (' ' + t.className + ' ') - .replace(k, ' ') - .replace(' ' + e + ' ', ' '); - t.className = (o + (n ? ' ' + e : '')).replace(k, ' '); - } - } - function gt(t, e, n) { - var o = t && t.style; - if (o) { - if (void 0 === n) - return ( - A.defaultView && A.defaultView.getComputedStyle - ? (n = A.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 vt(t) { - var e = ''; - do { - var n = gt(t, 'transform'); - n && 'none' !== n && (e = n + ' ' + e); - } while ((t = t.parentNode)); - return window.DOMMatrix - ? new DOMMatrix(e) - : window.WebKitCSSMatrix - ? new WebKitCSSMatrix(e) - : window.CSSMatrix - ? new CSSMatrix(e) - : void 0; - } - function mt(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 bt(t, e, n, i, r, a, l, s, c) { - var d, - h = (t = t || e[P]).options, - u = 'on' + n.charAt(0).toUpperCase() + n.substr(1); - !window.CustomEvent || W || F - ? (d = A.createEvent('Event')).initEvent(n, !0, !0) - : (d = new CustomEvent(n, { bubbles: !0, cancelable: !0 })), - (d.to = r || e), - (d.from = a || e), - (d.item = i || e), - (d.clone = o), - (d.oldIndex = l), - (d.newIndex = s), - (d.originalEvent = c), - e && e.dispatchEvent(d), - h[u] && h[u].call(t, d); - } - function wt(t, e, n, o, i, r, a, l) { - var s, - c, - d = t[P], - h = d.options.onMove; - return ( - !window.CustomEvent || W || F - ? (s = A.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 || kt(e)), - (s.willInsertAfter = l), - (s.originalEvent = a), - t.dispatchEvent(s), - h && (c = h.call(d, s, a)), - c - ); - } - function _t(t) { - t.draggable = !1; - } - function yt() { - V = !1; - } - function Dt(e, o, i) { - for (var r = 0, a = 0, l = e.children; a < l.length; ) { - if ( - 'none' !== l[a].style.display && - l[a] !== n && - l[a] !== t && - dt(l[a], i.draggable, e, !1) - ) { - if (r === o) return l[a]; - r++; - } - a++; - } - return null; - } - function St(t) { - for ( - var e = t.lastElementChild; - (e === n || 'none' === e.style.display) && (e = e.previousElementSibling); - - ); - return e || null; - } - function Ct(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 Tt(t, e) { - var n = 0; - if (!t || !t.parentNode) return -1; - for (; t && (t = t.previousElementSibling); ) - 'TEMPLATE' !== t.nodeName.toUpperCase() && t !== o && n++; - return n; - } - function Et(t, e) { - if (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 xt(t, e) { - return function () { - if (!lt) { - var n = arguments, - o = this; - lt = B(function () { - 1 === n.length ? t.call(o, n[0]) : t.apply(o, n), (lt = void 0); - }, e); - } - }; - } - function Nt(t, e) { - if (t && e) for (var n in e) e.hasOwnProperty(n) && (t[n] = e[n]); - return t; - } - function Xt(t) { - return R && R.dom - ? R.dom(t).cloneNode(!0) - : H - ? H(t).clone(!0)[0] - : t.cloneNode(!0); - } - function Yt(t) { - return B(t, 0); - } - function Mt(t) { - return clearTimeout(t); - } - function kt(t, e, n) { - if (t.getBoundingClientRect || t === I) { - var o, i, r, a, l, s, c; - if ( - (t !== I - ? ((i = (o = t.getBoundingClientRect()).top), - (r = o.left), - (a = o.bottom), - (l = o.right), - (s = o.height), - (c = o.width)) - : ((i = 0), - (r = 0), - (a = window.innerHeight), - (l = window.innerWidth), - (s = window.innerHeight), - (c = window.innerWidth)), - n && t !== I) - ) { - if (((e = e || t.parentNode), !W)) - do { - if ( - e && - e.getBoundingClientRect && - 'none' !== gt(e, 'transform') - ) { - var d = e.getBoundingClientRect(); - (i -= d.top + O(gt(e, 'border-top-width'))), - (r -= d.left + O(gt(e, 'border-left-width'))), - (a = i + o.height), - (l = r + o.width); - break; - } - } while ((e = e.parentNode)); - var h = vt(t), - u = h && h.a, - f = h && h.d; - h && ((a = (i /= f) + (s /= f)), (l = (r /= u) + (c /= u))); - } - return { top: i, left: r, bottom: a, right: l, width: c, height: s }; - } - } - return ( - ut(A, 'dragover', st), - ut(A, 'mousemove', st), - ut(A, 'touchmove', st), - (ct.prototype = { - constructor: ct, - _computeIsAligned: function (e) { - var o; - if ( - (n && !U - ? (rt(), (o = A.elementFromPoint(e.clientX, e.clientY)), at()) - : (o = e.target), - (o = dt(o, this.options.draggable, this.el, !1)), - !q && t && t.parentNode === this.el) - ) { - for ( - var i, r, a, l, s, c, d, h, u = this.el.children, f = 0; - f < u.length; - f++ - ) - dt(u[f], this.options.draggable, this.el, !1) && - u[f] !== o && - (u[f].sortableMouseAligned = - ((i = e.clientX), - (r = e.clientY), - (a = u[f]), - (l = this._getDirection(e, null)), - this.options, - (s = void 0), - (c = void 0), - (d = void 0), - (h = void 0), - (s = kt(a)), - (c = 'vertical' === l ? s.left : s.top), - (d = 'vertical' === l ? s.right : s.bottom), - c < (h = 'vertical' === l ? i : r) && h < d)); - dt(o, this.options.draggable, this.el, !0) || (_ = null), - (q = !0), - B(function () { - q = !1; - }, 30); - } - }, - _getDirection: function (e, n) { - return 'function' == typeof this.options.direction - ? this.options.direction.call(this, e, n, t) - : this.options.direction; - }, - _onTapStart: function (e) { - if (e.cancelable) { - var n, - o = this, - i = this.el, - r = this.options, - l = r.preventOnFilter, - s = e.type, - c = e.touches && e.touches[0], - d = (c || e).target, - h = - (e.target.shadowRoot && - ((e.path && e.path[0]) || - (e.composedPath && e.composedPath()[0]))) || - d, - u = r.filter; - if ( - ((function (t) { - Z.length = 0; - var e = t.getElementsByTagName('input'), - n = e.length; - for (; n--; ) { - var o = e[n]; - o.checked && Z.push(o); - } - })(i), - (!W || e.artificialBubble || ot(i, d)) && - !t && - !( - (/mousedown|pointerdown/.test(s) && 0 !== e.button) || - r.disabled || - h.isContentEditable - )) - ) - if ((d = dt(d, r.draggable, i, !1))) { - if (a !== d) { - if ( - ((n = Tt(d, r.draggable)), 'function' == typeof u) - ) { - if (u.call(this, e, d, this)) - return ( - bt(o, h, 'filter', d, i, i, n), - void ( - l && - e.cancelable && - e.preventDefault() - ) - ); - } else if ( - u && - (u = u.split(',').some(function (t) { - if ((t = dt(h, t.trim(), i, !1))) - return bt(o, t, 'filter', d, i, i, n), !0; - })) - ) - return void ( - l && - e.cancelable && - e.preventDefault() - ); - (r.handle && !dt(h, r.handle, i, !1)) || - this._prepareDragStart(e, c, d, n); - } - } else W && it(i, e, '_onTapStart'); - } - }, - _handleAutoScroll: function (e, n) { - if (t && this.options.scroll) { - var o = e.clientX, - i = e.clientY, - r = A.elementFromPoint(o, i), - a = this; - if (n || F || W) { - $(e, a.options, r, n); - var l = J(r, !0); - !E || - (p && o === g && i === v) || - (p && clearInterval(p), - (p = setInterval(function () { - if (t) { - var r = J(A.elementFromPoint(o, i), !0); - r !== l && ((l = r), tt(), $(e, a.options, l, n)); - } - }, 10)), - (g = o), - (v = i)); - } else { - if (!a.options.bubbleScroll || J(r, !0) === window) - return void tt(); - $(e, a.options, J(r, !1), !1); - } - } - }, - _prepareDragStart: function (n, o, l, s) { - var c, - h = this, - f = h.el, - p = h.options, - g = f.ownerDocument; - l && - !t && - l.parentNode === f && - ((i = f), - (e = (t = l).parentNode), - (r = t.nextSibling), - (a = l), - (u = p.group), - (d = s), - (m = { - target: t, - clientX: (o || n).clientX, - clientY: (o || n).clientY - }), - (this._lastX = (o || n).clientX), - (this._lastY = (o || n).clientY), - (t.style['will-change'] = 'all'), - (t.style.transition = ''), - (t.style.transform = ''), - (c = function () { - h._disableDelayedDrag(), - (t.draggable = h.nativeDraggable), - h._triggerDragStart(n, o), - bt(h, i, 'choose', t, i, i, d), - pt(t, p.chosenClass, !0); - }), - p.ignore.split(',').forEach(function (e) { - mt(t, e.trim(), _t); - }), - p.supportPointer - ? ut(g, 'pointerup', h._onDrop) - : (ut(g, 'mouseup', h._onDrop), - ut(g, 'touchend', h._onDrop), - ut(g, 'touchcancel', h._onDrop)), - p.delay - ? (ut(g, 'mouseup', h._disableDelayedDrag), - ut(g, 'touchend', h._disableDelayedDrag), - ut(g, 'touchcancel', h._disableDelayedDrag), - ut(g, 'mousemove', h._delayedDragTouchMoveHandler), - ut(g, 'touchmove', h._delayedDragTouchMoveHandler), - p.supportPointer && - ut(g, 'pointermove', h._delayedDragTouchMoveHandler), - (h._dragStartTimer = B(c, p.delay))) - : c()); - }, - _delayedDragTouchMoveHandler: function (t) { - var e = t.touches ? t.touches[0] : t; - K(G(e.clientX - this._lastX), G(e.clientY - this._lastY)) >= - this.options.touchStartThreshold && this._disableDelayedDrag(); - }, - _disableDelayedDrag: function () { - var t = this.el.ownerDocument; - clearTimeout(this._dragStartTimer), - ft(t, 'mouseup', this._disableDelayedDrag), - ft(t, 'touchend', this._disableDelayedDrag), - ft(t, 'touchcancel', this._disableDelayedDrag), - ft(t, 'mousemove', this._delayedDragTouchMoveHandler), - ft(t, 'touchmove', this._delayedDragTouchMoveHandler), - ft(t, 'pointermove', this._delayedDragTouchMoveHandler); - }, - _triggerDragStart: function (e, n) { - (n = n || ('touch' == e.pointerType ? e : null)), - !this.nativeDraggable || n - ? this.options.supportPointer - ? ut(A, 'pointermove', this._onTouchMove) - : ut(A, n ? 'touchmove' : 'mousemove', this._onTouchMove) - : (ut(t, 'dragend', this), - ut(i, 'dragstart', this._onDragStart)); - try { - A.selection - ? Yt(function () { - A.selection.empty(); - }) - : window.getSelection().removeAllRanges(); - } catch (t) {} - }, - _dragStarted: function (e) { - if (((x = !1), i && t)) { - this.nativeDraggable && - (ut(A, 'dragover', this._handleAutoScroll), - ut(A, 'dragover', nt)); - var n = this.options; - !e && pt(t, n.dragClass, !1), - pt(t, n.ghostClass, !0), - gt(t, 'transform', ''), - (ct.active = this), - e && this._appendGhost(), - bt(this, i, 'start', t, i, i, d); - } else this._nulling(); - }, - _emulateDragOver: function (e) { - if (b) { - if (this._lastX === b.clientX && this._lastY === b.clientY && !e) - return; - (this._lastX = b.clientX), (this._lastY = b.clientY), rt(); - for ( - var n = A.elementFromPoint(b.clientX, b.clientY), o = n; - n && n.shadowRoot; - - ) - o = n = n.shadowRoot.elementFromPoint(b.clientX, b.clientY); - if (o) - do { - if (o[P]) - if ( - o[P]._onDragOver({ - clientX: b.clientX, - clientY: b.clientY, - target: n, - rootEl: o - }) && - !this.options.dragoverBubble - ) - break; - n = o; - } while ((o = o.parentNode)); - t.parentNode[P]._computeIsAligned(b), at(); - } - }, - _onTouchMove: function (t) { - if (m) { - var e = this.options, - o = e.fallbackTolerance, - i = e.fallbackOffset, - r = t.touches ? t.touches[0] : t, - a = n && vt(n), - l = n && a && a.a, - s = n && a && a.d, - c = (r.clientX - m.clientX + i.x) / (l || 1), - d = (r.clientY - m.clientY + i.y) / (s || 1), - h = t.touches - ? 'translate3d(' + c + 'px,' + d + 'px,0)' - : 'translate(' + c + 'px,' + d + 'px)'; - if (!ct.active && !x) { - if ( - o && - K( - G(r.clientX - this._lastX), - G(r.clientY - this._lastY) - ) < o - ) - return; - this._onDragStart(t, !0); - } - this._handleAutoScroll(r, !0), - (w = !0), - (b = r), - gt(n, 'webkitTransform', h), - gt(n, 'mozTransform', h), - gt(n, 'msTransform', h), - gt(n, 'transform', h), - t.cancelable && t.preventDefault(); - } - }, - _appendGhost: function () { - if (!n) { - var e = kt(t, this.options.fallbackOnBody ? A.body : i, !0), - o = (gt(t), this.options); - pt((n = t.cloneNode(!0)), o.ghostClass, !1), - pt(n, o.fallbackClass, !0), - pt(n, o.dragClass, !0), - gt(n, 'box-sizing', 'border-box'), - gt(n, 'margin', 0), - gt(n, 'top', e.top), - gt(n, 'left', e.left), - gt(n, 'width', e.width), - gt(n, 'height', e.height), - gt(n, 'opacity', '0.8'), - gt(n, 'position', 'fixed'), - gt(n, 'zIndex', '100000'), - gt(n, 'pointerEvents', 'none'), - (o.fallbackOnBody && A.body.appendChild(n)) || - i.appendChild(n); - } - }, - _onDragStart: function (e, n) { - var r = this, - a = e.dataTransfer, - l = r.options; - ((o = Xt(t)).draggable = !1), - (o.style['will-change'] = ''), - this._hideClone(), - pt(o, r.options.chosenClass, !1), - (r._cloneId = Yt(function () { - r.options.removeCloneOnHide || i.insertBefore(o, t), - bt(r, i, 'clone', t); - })), - !n && pt(t, l.dragClass, !0), - n - ? ((N = !0), - (r._loopId = setInterval(r._emulateDragOver, 50))) - : (ft(A, 'mouseup', r._onDrop), - ft(A, 'touchend', r._onDrop), - ft(A, 'touchcancel', r._onDrop), - a && - ((a.effectAllowed = 'move'), - l.setData && l.setData.call(r, a, t)), - ut(A, 'drop', r), - gt(t, 'transform', 'translateZ(0)')), - (x = !0), - (r._dragStartId = Yt(r._dragStarted.bind(r, n))), - ut(A, 'selectstart', r); - }, - _onDragOver: function (o) { - var a, - l, - s, - c = this.el, - h = o.target, - p = this.options, - g = p.group, - v = ct.active, - m = u === g, - b = p.sort, - T = this; - if (!V && (!W || o.rootEl || o.artificialBubble || ot(c, h))) { - if ( - (void 0 !== o.preventDefault && - o.cancelable && - o.preventDefault(), - (w = !0), - (h = dt(h, p.draggable, c, !0)), - dt(o.target, null, t, !0) || h.animated) - ) - return j(); - if ( - (h !== t && (N = !1), - v && - !p.disabled && - (m - ? b || (s = !i.contains(t)) - : f === this || - ((this.lastPutMode = u.checkPull(this, v, t, o)) && - g.checkPut(this, v, t, o)))) - ) { - var x = this._getDirection(o, h); - if (((a = kt(t)), s)) - return ( - this._hideClone(), - (e = i), - r ? i.insertBefore(t, r) : i.appendChild(t), - j() - ); - if ( - 0 === c.children.length || - c.children[0] === n || - ((function (t, e, n) { - var o = kt(St(n)), - i = 'vertical' === e ? t.clientY : t.clientX, - r = 'vertical' === e ? t.clientX : t.clientY, - a = 'vertical' === e ? o.bottom : o.right, - l = 'vertical' === e ? o.left : o.top, - s = 'vertical' === e ? o.right : o.bottom; - return 'vertical' === e - ? r > s + 10 || (r <= s && i > a && r >= l) - : (i > a && r > l) || (i <= a && r > s + 10); - })(o, x, c) && - !t.animated) - ) { - if ( - (0 !== c.children.length && - c.children[0] !== n && - c === o.target && - (h = St(c)), - h && (l = kt(h)), - m ? v._hideClone() : v._showClone(this), - !1 !== wt(i, c, t, a, h, l, o, !!h)) - ) - return ( - c.appendChild(t), - (e = c), - (C = null), - U(), - this._animate(a, t), - h && this._animate(l, h), - j() - ); - } else if (h && h !== t && h.parentNode === c) { - var X, - k = 0, - O = h.sortableMouseAligned, - H = t.parentNode !== c, - R = (function (t, e) { - var n = J(n, !0), - o = kt(t)[e]; - for (; n; ) { - var i = kt(n)[e]; - if ( - !('top' === e || 'left' === e - ? o >= i - : o <= i) - ) - return !0; - if (n === I) break; - n = J(n, !1); - } - return !1; - })(h, 'vertical' === x ? 'top' : 'left'); - if ( - (_ !== h && - ((D = null), - (X = kt(h)['vertical' === x ? 'top' : 'left']), - (Y = !1)), - ((function (e, n, o) { - var i = (e === t && C) || kt(e), - r = (n === t && C) || kt(n), - a = 'vertical' === o ? i.left : i.top, - l = 'vertical' === o ? i.right : i.bottom, - s = 'vertical' === o ? i.width : i.height, - c = 'vertical' === o ? r.left : r.top, - d = 'vertical' === o ? r.right : r.bottom, - h = 'vertical' === o ? r.width : r.height; - return ( - a === c || l === d || a + s / 2 === c + h / 2 - ); - })(t, h, x) && - O) || - H || - R || - p.invertSwap || - 'insert' === D || - 'swap' === D - ? ('swap' !== D && - (M = p.invertSwap || H || E || R), - (k = (function (e, n, o, i, r, a, l) { - var s = kt(n), - c = - 'vertical' === o - ? e.clientY - : e.clientX, - d = - 'vertical' === o - ? s.height - : s.width, - h = 'vertical' === o ? s.top : s.left, - u = - 'vertical' === o - ? s.bottom - : s.right, - f = kt(t), - p = !1; - if (!a) - if (l && S < d * i) - if ( - (!Y && - (1 === y - ? c > h + (d * r) / 2 - : c < - u - (d * r) / 2) && - (Y = !0), - Y) - ) - p = !0; - else { - 'vertical' === o - ? f.top - : f.left, - 'vertical' === o - ? f.bottom - : f.right; - if ( - 1 === y - ? c < h + S - : c > u - S - ) - return -1 * y; - } - else if ( - c > h + (d * (1 - i)) / 2 && - c < u - (d * (1 - i)) / 2 - ) - return c > h + d / 2 ? -1 : 1; - if ( - (p = p || a) && - (c < h + (d * r) / 2 || - c > u - (d * r) / 2) - ) - return c > h + d / 2 ? 1 : -1; - return 0; - })( - o, - h, - x, - p.swapThreshold, - null == p.invertedSwapThreshold - ? p.swapThreshold - : p.invertedSwapThreshold, - M, - _ === h - )), - (D = 'swap')) - : ((k = (function (e, n) { - var o = Tt(t, n.draggable), - i = Tt(e, n.draggable); - return o < i ? 1 : -1; - })(h, p)), - (D = 'insert')), - 0 === k) - ) - return j(); - (C = null), (_ = h), (y = k), (l = kt(h)); - var L = h.nextElementSibling, - F = !1, - z = wt(i, c, t, a, h, l, o, (F = 1 === k)); - if (!1 !== z) - return ( - (1 !== z && -1 !== z) || (F = 1 === z), - (V = !0), - B(yt, 30), - m ? v._hideClone() : v._showClone(this), - F && !L - ? c.appendChild(t) - : h.parentNode.insertBefore(t, F ? L : h), - (e = t.parentNode), - void 0 === X || - M || - (S = G( - X - - kt(h)[ - 'vertical' === x ? 'top' : 'left' - ] - )), - U(), - !H && this._animate(l, h), - this._animate(a, t), - j() - ); - } - if (c.contains(t)) return j(); - } - return W && !o.rootEl && it(c, o, '_onDragOver'), !1; - } - function j() { - return ( - v && - (pt( - t, - f ? f.options.ghostClass : v.options.ghostClass, - !1 - ), - pt(t, p.ghostClass, !0)), - f !== T && T !== ct.active - ? (f = T) - : T === ct.active && (f = null), - ((h === t && !t.animated) || (h === c && !h.animated)) && - (_ = null), - p.dragoverBubble || - o.rootEl || - h === A || - (T._handleAutoScroll(o), - t.parentNode[P]._computeIsAligned(o)), - !p.dragoverBubble && o.stopPropagation && o.stopPropagation(), - !0 - ); - } - function U() { - bt(T, i, 'change', h, c, i, d, Tt(t, p.draggable), o); - } - }, - _animate: function (e, n) { - var o = this.options.animation; - if (o) { - var i = kt(n); - if ( - (n === t && (C = i), - 1 === e.nodeType && (e = kt(e)), - e.left + e.width / 2 !== i.left + i.width / 2 || - e.top + e.height / 2 !== i.top + i.height / 2) - ) { - var r = vt(this.el), - a = r && r.a, - l = r && r.d; - gt(n, 'transition', 'none'), - gt( - n, - 'transform', - 'translate3d(' + - (e.left - i.left) / (a || 1) + - 'px,' + - (e.top - i.top) / (l || 1) + - 'px,0)' - ), - n.offsetWidth, - gt( - n, - 'transition', - 'transform ' + - o + - 'ms' + - (this.options.easing - ? ' ' + this.options.easing - : '') - ), - gt(n, 'transform', 'translate3d(0,0,0)'); - } - 'number' == typeof n.animated && clearTimeout(n.animated), - (n.animated = B(function () { - gt(n, 'transition', ''), - gt(n, 'transform', ''), - (n.animated = !1); - }, o)); - } - }, - _offUpEvents: function () { - var t = this.el.ownerDocument; - ft(A, 'touchmove', this._onTouchMove), - ft(A, 'pointermove', this._onTouchMove), - ft(t, 'mouseup', this._onDrop), - ft(t, 'touchend', this._onDrop), - ft(t, 'pointerup', this._onDrop), - ft(t, 'touchcancel', this._onDrop), - ft(A, 'selectstart', this); - }, - _onDrop: function (a) { - var l = this.el, - s = this.options; - (x = !1), - (E = !1), - (M = !1), - (Y = !1), - clearInterval(this._loopId), - clearInterval(p), - tt(), - clearTimeout(lt), - (lt = void 0), - clearTimeout(this._dragStartTimer), - Mt(this._cloneId), - Mt(this._dragStartId), - ft(A, 'mousemove', this._onTouchMove), - this.nativeDraggable && - (ft(A, 'drop', this), - ft(l, 'dragstart', this._onDragStart), - ft(A, 'dragover', this._handleAutoScroll), - ft(A, 'dragover', nt)), - this._offUpEvents(), - a && - (w && - (a.cancelable && a.preventDefault(), - !s.dropBubble && a.stopPropagation()), - n && n.parentNode && n.parentNode.removeChild(n), - (i === e || (f && 'clone' !== f.lastPutMode)) && - o && - o.parentNode && - o.parentNode.removeChild(o), - t && - (this.nativeDraggable && ft(t, 'dragend', this), - _t(t), - (t.style['will-change'] = ''), - pt( - t, - f ? f.options.ghostClass : this.options.ghostClass, - !1 - ), - pt(t, this.options.chosenClass, !1), - bt(this, i, 'unchoose', t, e, i, d, null, a), - i !== e - ? ((h = Tt(t, s.draggable)) >= 0 && - (bt(null, e, 'add', t, e, i, d, h, a), - bt(this, i, 'remove', t, e, i, d, h, a), - bt(null, e, 'sort', t, e, i, d, h, a), - bt(this, i, 'sort', t, e, i, d, h, a)), - f && f.save()) - : t.nextSibling !== r && - (h = Tt(t, s.draggable)) >= 0 && - (bt(this, i, 'update', t, e, i, d, h, a), - bt(this, i, 'sort', t, e, i, d, h, a)), - ct.active && - ((null != h && -1 !== h) || (h = d), - bt(this, i, 'end', t, e, i, d, h, a), - this.save()))), - this._nulling(); - }, - _nulling: function () { - (i = - t = - e = - n = - r = - o = - a = - l = - s = - T.length = - p = - g = - v = - m = - b = - w = - h = - d = - _ = - y = - C = - f = - u = - ct.active = - null), - Z.forEach(function (t) { - t.checked = !0; - }), - (Z.length = 0); - }, - handleEvent: function (e) { - switch (e.type) { - case 'drop': - case 'dragend': - this._onDrop(e); - break; - case 'dragenter': - case 'dragover': - t && - (this._onDragOver(e), - (function (t) { - t.dataTransfer && - (t.dataTransfer.dropEffect = 'move'); - t.cancelable && t.preventDefault(); - })(e)); - break; - case 'selectstart': - e.preventDefault(); - } - }, - toArray: function () { - for ( - var t, - e = [], - n = this.el.children, - o = 0, - i = n.length, - r = this.options; - o < i; - o++ - ) - dt((t = n[o]), r.draggable, this.el, !1) && - e.push(t.getAttribute(r.dataIdAttr) || Ct(t)); - return e; - }, - sort: function (t) { - var e = {}, - n = this.el; - this.toArray().forEach(function (t, o) { - var i = n.children[o]; - dt(i, this.options.draggable, n, !1) && (e[t] = i); - }, this), - t.forEach(function (t) { - e[t] && (n.removeChild(e[t]), n.appendChild(e[t])); - }); - }, - save: function () { - var t = this.options.store; - t && t.set && t.set(this); - }, - closest: function (t, e) { - return dt(t, e || this.options.draggable, this.el, !1); - }, - option: function (t, e) { - var n = this.options; - if (void 0 === e) return n[t]; - (n[t] = e), 'group' === t && et(n); - }, - destroy: function () { - var t = this.el; - (t[P] = null), - ft(t, 'mousedown', this._onTapStart), - ft(t, 'touchstart', this._onTapStart), - ft(t, 'pointerdown', this._onTapStart), - this.nativeDraggable && - (ft(t, 'dragover', this), ft(t, 'dragenter', this)), - Array.prototype.forEach.call( - t.querySelectorAll('[draggable]'), - function (t) { - t.removeAttribute('draggable'); - } - ), - this._onDrop(), - X.splice(X.indexOf(this.el), 1), - (this.el = t = null); - }, - _hideClone: function () { - o.cloneHidden || - (gt(o, 'display', 'none'), - (o.cloneHidden = !0), - o.parentNode && - this.options.removeCloneOnHide && - o.parentNode.removeChild(o)); - }, - _showClone: function (e) { - 'clone' === e.lastPutMode - ? o.cloneHidden && - (i.contains(t) && !this.options.group.revertClone - ? i.insertBefore(o, t) - : r - ? i.insertBefore(o, r) - : i.appendChild(o), - this.options.group.revertClone && this._animate(t, o), - gt(o, 'display', ''), - (o.cloneHidden = !1)) - : this._hideClone(); - } - }), - ut(A, 'touchmove', function (t) { - (ct.active || x) && t.cancelable && t.preventDefault(); - }), - (ct.utils = { - on: ut, - off: ft, - css: gt, - find: mt, - is: function (t, e) { - return !!dt(t, e, t, !1); - }, - extend: Nt, - throttle: xt, - closest: dt, - toggleClass: pt, - clone: Xt, - index: Tt, - nextTick: Yt, - cancelNextTick: Mt, - detectDirection: Q, - getChild: Dt - }), - (ct.create = function (t, e) { - return new ct(t, e); - }), - (ct.version = '1.8.3'), - ct - ); - }), - (t.exports = e()); -})((t = { exports: {} }), t.exports), -t.exports); diff --git a/public/assets/scripts/dash/libraries/FipamoAdminAPI.js b/public/assets/scripts/dash/libraries/FipamoAdminAPI.js index bace695..d27d7fc 100644 --- a/public/assets/scripts/dash/libraries/FipamoAdminAPI.js +++ b/public/assets/scripts/dash/libraries/FipamoAdminAPI.js @@ -234,23 +234,26 @@ class FipamoAdminAPI { ``` */ pageActions(task, data) { - let url, event, content; + let url, event, content, type; switch (task) { case TASK_PAGE_CREATE: url = API_NEW_PAGE; event = TASK_PAGE_CREATE; content = CONTENT_TYPE_JSON; + type = REQUEST_TYPE_POST; break; case TASK_PAGE_EDIT: url = API_EDIT_PAGE; event = TASK_PAGE_EDIT; content = CONTENT_TYPE_JSON; + type = REQUEST_TYPE_PUT; break; case TASK_PAGE_DELETE: url = API_DELETE_PAGE; event = TASK_PAGE_DELETE; content = CONTENT_TYPE_JSON; + type = REQUEST_TYPE_DELETE; break; default: @@ -268,7 +271,7 @@ class FipamoAdminAPI { this._request( this.baseURL ? this.baseURL + url : url, event, - REQUEST_TYPE_POST, + type, content, data ) diff --git a/resources/views/back/page.blade.php b/resources/views/back/page.blade.php index 646feb6..8268da5 100644 --- a/resources/views/back/page.blade.php +++ b/resources/views/back/page.blade.php @@ -46,11 +46,10 @@ -
+
@if(count($media)>1) @foreach($media as $item) @if($item['type'] == "mp4") -