diff --git a/plugin_files/dom-autoscroller.js b/plugin_files/dom-autoscroller.js new file mode 100644 index 0000000..38b7ac0 --- /dev/null +++ b/plugin_files/dom-autoscroller.js @@ -0,0 +1,1036 @@ +var autoScroll = (function () { +'use strict'; + +function getDef(f, d) { + if (typeof f === 'undefined') { + return typeof d === 'undefined' ? f : d; + } + + return f; +} +function boolean(func, def) { + + func = getDef(func, def); + + if (typeof func === 'function') { + return function f() { + var arguments$1 = arguments; + + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments$1[_key]; + } + + return !!func.apply(this, args); + }; + } + + return !!func ? function () { + return true; + } : function () { + return false; + }; +} + +var prefix = ['webkit', 'moz', 'ms', 'o']; + +var requestAnimationFrame = function () { + + for (var i = 0, limit = prefix.length; i < limit && !window.requestAnimationFrame; ++i) { + window.requestAnimationFrame = window[prefix[i] + 'RequestAnimationFrame']; + } + + if (!window.requestAnimationFrame) { + (function () { + var lastTime = 0; + + window.requestAnimationFrame = function (callback) { + var now = new Date().getTime(); + var ttc = Math.max(0, 16 - now - lastTime); + var timer = window.setTimeout(function () { + return callback(now + ttc); + }, ttc); + + lastTime = now + ttc; + + return timer; + }; + })(); + } + + return window.requestAnimationFrame.bind(window); +}(); + +var cancelAnimationFrame = function () { + + for (var i = 0, limit = prefix.length; i < limit && !window.cancelAnimationFrame; ++i) { + window.cancelAnimationFrame = window[prefix[i] + 'CancelAnimationFrame'] || window[prefix[i] + 'CancelRequestAnimationFrame']; + } + + if (!window.cancelAnimationFrame) { + window.cancelAnimationFrame = function (timer) { + window.clearTimeout(timer); + }; + } + + return window.cancelAnimationFrame.bind(window); +}(); + +// Production steps of ECMA-262, Edition 6, 22.1.2.1 +// Reference: http://www.ecma-international.org/ecma-262/6.0/#sec-array.from +var polyfill = (function() { + var isCallable = function(fn) { + return typeof fn === 'function'; + }; + var toInteger = function (value) { + var number = Number(value); + if (isNaN(number)) { return 0; } + if (number === 0 || !isFinite(number)) { return number; } + return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); + }; + var maxSafeInteger = Math.pow(2, 53) - 1; + var toLength = function (value) { + var len = toInteger(value); + return Math.min(Math.max(len, 0), maxSafeInteger); + }; + var iteratorProp = function(value) { + if(value != null) { + if(['string','number','boolean','symbol'].indexOf(typeof value) > -1){ + return Symbol.iterator; + } else if ( + (typeof Symbol !== 'undefined') && + ('iterator' in Symbol) && + (Symbol.iterator in value) + ) { + return Symbol.iterator; + } + // Support "@@iterator" placeholder, Gecko 27 to Gecko 35 + else if ('@@iterator' in value) { + return '@@iterator'; + } + } + }; + var getMethod = function(O, P) { + // Assert: IsPropertyKey(P) is true. + if (O != null && P != null) { + // Let func be GetV(O, P). + var func = O[P]; + // ReturnIfAbrupt(func). + // If func is either undefined or null, return undefined. + if(func == null) { + return void 0; + } + // If IsCallable(func) is false, throw a TypeError exception. + if (!isCallable(func)) { + throw new TypeError(func + ' is not a function'); + } + return func; + } + }; + var iteratorStep = function(iterator) { + // Let result be IteratorNext(iterator). + // ReturnIfAbrupt(result). + var result = iterator.next(); + // Let done be IteratorComplete(result). + // ReturnIfAbrupt(done). + var done = Boolean(result.done); + // If done is true, return false. + if(done) { + return false; + } + // Return result. + return result; + }; + + // The length property of the from method is 1. + return function from(items /*, mapFn, thisArg */ ) { + 'use strict'; + + // 1. Let C be the this value. + var C = this; + + // 2. If mapfn is undefined, let mapping be false. + var mapFn = arguments.length > 1 ? arguments[1] : void 0; + + var T; + if (typeof mapFn !== 'undefined') { + // 3. else + // a. If IsCallable(mapfn) is false, throw a TypeError exception. + if (!isCallable(mapFn)) { + throw new TypeError( + 'Array.from: when provided, the second argument must be a function' + ); + } + + // b. If thisArg was supplied, let T be thisArg; else let T + // be undefined. + if (arguments.length > 2) { + T = arguments[2]; + } + // c. Let mapping be true (implied by mapFn) + } + + var A, k; + + // 4. Let usingIterator be GetMethod(items, @@iterator). + // 5. ReturnIfAbrupt(usingIterator). + var usingIterator = getMethod(items, iteratorProp(items)); + + // 6. If usingIterator is not undefined, then + if (usingIterator !== void 0) { + // a. If IsConstructor(C) is true, then + // i. Let A be the result of calling the [[Construct]] + // internal method of C with an empty argument list. + // b. Else, + // i. Let A be the result of the abstract operation ArrayCreate + // with argument 0. + // c. ReturnIfAbrupt(A). + A = isCallable(C) ? Object(new C()) : []; + + // d. Let iterator be GetIterator(items, usingIterator). + var iterator = usingIterator.call(items); + + // e. ReturnIfAbrupt(iterator). + if (iterator == null) { + throw new TypeError( + 'Array.from requires an array-like or iterable object' + ); + } + + // f. Let k be 0. + k = 0; + + // g. Repeat + var next, nextValue; + while (true) { + // i. Let Pk be ToString(k). + // ii. Let next be IteratorStep(iterator). + // iii. ReturnIfAbrupt(next). + next = iteratorStep(iterator); + + // iv. If next is false, then + if (!next) { + + // 1. Let setStatus be Set(A, "length", k, true). + // 2. ReturnIfAbrupt(setStatus). + A.length = k; + + // 3. Return A. + return A; + } + // v. Let nextValue be IteratorValue(next). + // vi. ReturnIfAbrupt(nextValue) + nextValue = next.value; + + // vii. If mapping is true, then + // 1. Let mappedValue be Call(mapfn, T, «nextValue, k»). + // 2. If mappedValue is an abrupt completion, return + // IteratorClose(iterator, mappedValue). + // 3. Let mappedValue be mappedValue.[[value]]. + // viii. Else, let mappedValue be nextValue. + // ix. Let defineStatus be the result of + // CreateDataPropertyOrThrow(A, Pk, mappedValue). + // x. [TODO] If defineStatus is an abrupt completion, return + // IteratorClose(iterator, defineStatus). + if (mapFn) { + A[k] = mapFn.call(T, nextValue, k); + } + else { + A[k] = nextValue; + } + // xi. Increase k by 1. + k++; + } + // 7. Assert: items is not an Iterable so assume it is + // an array-like object. + } else { + + // 8. Let arrayLike be ToObject(items). + var arrayLike = Object(items); + + // 9. ReturnIfAbrupt(items). + if (items == null) { + throw new TypeError( + 'Array.from requires an array-like object - not null or undefined' + ); + } + + // 10. Let len be ToLength(Get(arrayLike, "length")). + // 11. ReturnIfAbrupt(len). + var len = toLength(arrayLike.length); + + // 12. If IsConstructor(C) is true, then + // a. Let A be Construct(C, «len»). + // 13. Else + // a. Let A be ArrayCreate(len). + // 14. ReturnIfAbrupt(A). + A = isCallable(C) ? Object(new C(len)) : new Array(len); + + // 15. Let k be 0. + k = 0; + // 16. Repeat, while k < len… (also steps a - h) + var kValue; + while (k < len) { + kValue = arrayLike[k]; + if (mapFn) { + A[k] = mapFn.call(T, kValue, k); + } + else { + A[k] = kValue; + } + k++; + } + // 17. Let setStatus be Set(A, "length", len, true). + // 18. ReturnIfAbrupt(setStatus). + A.length = len; + // 19. Return A. + } + return A; + }; +})(); + +var index = (typeof Array.from === 'function' ? + Array.from : + polyfill +); + +/** + * isArray + */ + +var isArray = Array.isArray; + +/** + * toString + */ + +var str = Object.prototype.toString; + +/** + * Whether or not the given `val` + * is an array. + * + * example: + * + * isArray([]); + * // > true + * isArray(arguments); + * // > false + * isArray(''); + * // > false + * + * @param {mixed} val + * @return {bool} + */ + +var index$1 = isArray || function (val) { + return !! val && '[object Array]' == str.call(val); +}; + +/** + * Returns `true` if provided input is Element. + * @name isElement + * @param {*} [input] + * @returns {boolean} + */ + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; + +/** + * Returns `true` if provided input is Element. + * @name isElement + * @param {*} [input] + * @returns {boolean} + */ +var isElement$1 = function (input) { + return input != null && (typeof input === 'undefined' ? 'undefined' : _typeof(input)) === 'object' && input.nodeType === 1 && _typeof(input.style) === 'object' && _typeof(input.ownerDocument) === 'object'; +}; + +function indexOfElement(elements, element){ + element = resolveElement(element, true); + if(!isElement$1(element)) { return -1; } + for(var i=0; i 0 ) { toAdd[ len ] = arguments$1[ len + 1 ]; } + + toAdd = toAdd.map(resolveElement); + return pushElements(elements, toAdd); +} + +function removeElements(elements){ + var arguments$1 = arguments; + + var toRemove = [], len = arguments.length - 1; + while ( len-- > 0 ) { toRemove[ len ] = arguments$1[ len + 1 ]; } + + return toRemove.map(resolveElement).reduce(function (last, e){ + + var index$$1 = indexOfElement(elements, e); + + if(index$$1 !== -1) + { return last.concat(elements.splice(index$$1, 1)); } + return last; + }, []); +} + +function resolveElement(element, noThrow){ + if(typeof element === 'string'){ + try{ + return document.querySelector(element); + }catch(e){ + throw e; + } + + } + + if(!isElement$1(element) && !noThrow){ + throw new TypeError((element + " is not a DOM element.")); + } + return element; +} + +function createPointCB(object, options) { + + // A persistent object (as opposed to returned object) is used to save memory + // This is good to prevent layout thrashing, or for games, and such + + // NOTE + // This uses IE fixes which should be OK to remove some day. :) + // Some speed will be gained by removal of these. + + // pointCB should be saved in a variable on return + // This allows the usage of element.removeEventListener + + options = options || {}; + + var allowUpdate = boolean(options.allowUpdate, true); + + /*if(typeof options.allowUpdate === 'function'){ + allowUpdate = options.allowUpdate; + }else{ + allowUpdate = function(){return true;}; + }*/ + + return function pointCB(event) { + + event = event || window.event; // IE-ism + object.target = event.target || event.srcElement || event.originalTarget; + object.element = this; + object.type = event.type; + + if (!allowUpdate(event)) { + return; + } + + // Support touch + // http://www.creativebloq.com/javascript/make-your-site-work-touch-devices-51411644 + + if (event.targetTouches) { + object.x = event.targetTouches[0].clientX; + object.y = event.targetTouches[0].clientY; + object.pageX = event.targetTouches[0].pageX; + object.pageY = event.targetTouches[0].pageY; + object.screenX = event.targetTouches[0].screenX; + object.screenY = event.targetTouches[0].screenY; + } else { + + // If pageX/Y aren't available and clientX/Y are, + // calculate pageX/Y - logic taken from jQuery. + // (This is to support old IE) + // NOTE Hopefully this can be removed soon. + + if (event.pageX === null && event.clientX !== null) { + var eventDoc = event.target && event.target.ownerDocument || document; + var doc = eventDoc.documentElement; + var body = eventDoc.body; + + object.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0); + object.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0); + } else { + object.pageX = event.pageX; + object.pageY = event.pageY; + } + + // pageX, and pageY change with page scroll + // so we're not going to use those for x, and y. + // NOTE Most browsers also alias clientX/Y with x/y + // so that's something to consider down the road. + + object.x = event.clientX; + object.y = event.clientY; + + object.screenX = event.screenX; + object.screenY = event.screenY; + } + + object.clientX = object.x; + object.clientY = object.y; + }; + + //NOTE Remember accessibility, Aria roles, and labels. +} + +function createWindowRect() { + var props = { + top: { value: 0, enumerable: true }, + left: { value: 0, enumerable: true }, + right: { value: window.innerWidth, enumerable: true }, + bottom: { value: window.innerHeight, enumerable: true }, + width: { value: window.innerWidth, enumerable: true }, + height: { value: window.innerHeight, enumerable: true }, + x: { value: 0, enumerable: true }, + y: { value: 0, enumerable: true } + }; + + if (Object.create) { + return Object.create({}, props); + } else { + var rect = {}; + Object.defineProperties(rect, props); + return rect; + } +} + +function getClientRect(el) { + if (el === window) { + return createWindowRect(); + } else { + try { + var rect = el.getBoundingClientRect(); + if (rect.x === undefined) { + rect.x = rect.left; + rect.y = rect.top; + } + return rect; + } catch (e) { + throw new TypeError("Can't call getBoundingClientRect on " + el); + } + } +} + +function pointInside(point, el) { + var rect = getClientRect(el); + return point.y > rect.top && point.y < rect.bottom && point.x > rect.left && point.x < rect.right; +} + +var objectCreate = void 0; +if (typeof Object.create != 'function') { + objectCreate = function (undefined) { + var Temp = function Temp() {}; + return function (prototype, propertiesObject) { + if (prototype !== Object(prototype) && prototype !== null) { + throw TypeError('Argument must be an object, or null'); + } + Temp.prototype = prototype || {}; + var result = new Temp(); + Temp.prototype = null; + if (propertiesObject !== undefined) { + Object.defineProperties(result, propertiesObject); + } + + // to imitate the case of Object.create(null) + if (prototype === null) { + result.__proto__ = null; + } + return result; + }; + }(); +} else { + objectCreate = Object.create; +} + +var objectCreate$1 = objectCreate; + +var mouseEventProps = ['altKey', 'button', 'buttons', 'clientX', 'clientY', 'ctrlKey', 'metaKey', 'movementX', 'movementY', 'offsetX', 'offsetY', 'pageX', 'pageY', 'region', 'relatedTarget', 'screenX', 'screenY', 'shiftKey', 'which', 'x', 'y']; + +function createDispatcher(element) { + + var defaultSettings = { + screenX: 0, + screenY: 0, + clientX: 0, + clientY: 0, + ctrlKey: false, + shiftKey: false, + altKey: false, + metaKey: false, + button: 0, + buttons: 1, + relatedTarget: null, + region: null + }; + + if (element !== undefined) { + element.addEventListener('mousemove', onMove); + } + + function onMove(e) { + for (var i = 0; i < mouseEventProps.length; i++) { + defaultSettings[mouseEventProps[i]] = e[mouseEventProps[i]]; + } + } + + var dispatch = function () { + if (MouseEvent) { + return function m1(element, initMove, data) { + var evt = new MouseEvent('mousemove', createMoveInit(defaultSettings, initMove)); + + //evt.dispatched = 'mousemove'; + setSpecial(evt, data); + + return element.dispatchEvent(evt); + }; + } else if (typeof document.createEvent === 'function') { + return function m2(element, initMove, data) { + var settings = createMoveInit(defaultSettings, initMove); + var evt = document.createEvent('MouseEvents'); + + evt.initMouseEvent("mousemove", true, //can bubble + true, //cancelable + window, //view + 0, //detail + settings.screenX, //0, //screenX + settings.screenY, //0, //screenY + settings.clientX, //80, //clientX + settings.clientY, //20, //clientY + settings.ctrlKey, //false, //ctrlKey + settings.altKey, //false, //altKey + settings.shiftKey, //false, //shiftKey + settings.metaKey, //false, //metaKey + settings.button, //0, //button + settings.relatedTarget //null //relatedTarget + ); + + //evt.dispatched = 'mousemove'; + setSpecial(evt, data); + + return element.dispatchEvent(evt); + }; + } else if (typeof document.createEventObject === 'function') { + return function m3(element, initMove, data) { + var evt = document.createEventObject(); + var settings = createMoveInit(defaultSettings, initMove); + for (var name in settings) { + evt[name] = settings[name]; + } + + //evt.dispatched = 'mousemove'; + setSpecial(evt, data); + + return element.dispatchEvent(evt); + }; + } + }(); + + function destroy() { + if (element) { element.removeEventListener('mousemove', onMove, false); } + defaultSettings = null; + } + + return { + destroy: destroy, + dispatch: dispatch + }; +} + +function createMoveInit(defaultSettings, initMove) { + initMove = initMove || {}; + var settings = objectCreate$1(defaultSettings); + for (var i = 0; i < mouseEventProps.length; i++) { + if (initMove[mouseEventProps[i]] !== undefined) { settings[mouseEventProps[i]] = initMove[mouseEventProps[i]]; } + } + + return settings; +} + +function setSpecial(e, data) { + console.log('data ', data); + e.data = data || {}; + e.dispatched = 'mousemove'; +} + +function AutoScroller(elements, options){ + if ( options === void 0 ) options = {}; + + var self = this; + var maxSpeed = 4, scrolling = false; + + this.margin = options.margin || -1; + //this.scrolling = false; + this.scrollWhenOutside = options.scrollWhenOutside || false; + + var point = {}, + pointCB = createPointCB(point), + dispatcher = createDispatcher(), + down = false; + + window.addEventListener('mousemove', pointCB, false); + window.addEventListener('touchmove', pointCB, false); + + if(!isNaN(options.maxSpeed)){ + maxSpeed = options.maxSpeed; + } + + this.autoScroll = boolean(options.autoScroll); + this.syncMove = boolean(options.syncMove, false); + + this.destroy = function(forceCleanAnimation) { + window.removeEventListener('mousemove', pointCB, false); + window.removeEventListener('touchmove', pointCB, false); + window.removeEventListener('mousedown', onDown, false); + window.removeEventListener('touchstart', onDown, false); + window.removeEventListener('mouseup', onUp, false); + window.removeEventListener('touchend', onUp, false); + window.removeEventListener('pointerup', onUp, false); + window.removeEventListener('mouseleave', onMouseOut, false); + + window.removeEventListener('mousemove', onMove, false); + window.removeEventListener('touchmove', onMove, false); + + window.removeEventListener('scroll', setScroll, true); + elements = []; + if(forceCleanAnimation){ + cleanAnimation(); + } + }; + + this.add = function(){ + var element = [], len = arguments.length; + while ( len-- ) element[ len ] = arguments[ len ]; + + addElements.apply(void 0, [ elements ].concat( element )); + return this; + }; + + this.remove = function(){ + var element = [], len = arguments.length; + while ( len-- ) element[ len ] = arguments[ len ]; + + return removeElements.apply(void 0, [ elements ].concat( element )); + }; + + var hasWindow = null, windowAnimationFrame; + + if(Object.prototype.toString.call(elements) !== '[object Array]'){ + elements = [elements]; + } + + (function(temp){ + elements = []; + temp.forEach(function(element){ + if(element === window){ + hasWindow = window; + }else{ + self.add(element); + } + }); + }(elements)); + + Object.defineProperties(this, { + down: { + get: function(){ return down; } + }, + maxSpeed: { + get: function(){ return maxSpeed; } + }, + point: { + get: function(){ return point; } + }, + scrolling: { + get: function(){ return scrolling; } + } + }); + + var n = 0, current = null, animationFrame; + + window.addEventListener('mousedown', onDown, false); + window.addEventListener('touchstart', onDown, false); + window.addEventListener('mouseup', onUp, false); + window.addEventListener('touchend', onUp, false); + + /* + IE does not trigger mouseup event when scrolling. + It is a known issue that Microsoft won't fix. + https://connect.microsoft.com/IE/feedback/details/783058/scrollbar-trigger-mousedown-but-not-mouseup + IE supports pointer events instead + */ + window.addEventListener('pointerup', onUp, false); + + window.addEventListener('mousemove', onMove, false); + window.addEventListener('touchmove', onMove, false); + + window.addEventListener('mouseleave', onMouseOut, false); + + window.addEventListener('scroll', setScroll, true); + + function setScroll(e){ + + for(var i=0; i rect.right - self.margin){ + scrollx = Math.ceil( + Math.min(1, (point.x - rect.right) / self.margin + 1) * self.maxSpeed + ); + }else{ + scrollx = 0; + } + + if(point.y < rect.top + self.margin){ + scrolly = Math.floor( + Math.max(-1, (point.y - rect.top) / self.margin - 1) * self.maxSpeed + ); + }else if(point.y > rect.bottom - self.margin){ + scrolly = Math.ceil( + Math.min(1, (point.y - rect.bottom) / self.margin + 1) * self.maxSpeed + ); + }else{ + scrolly = 0; + } + + if(self.syncMove()){ + /* + Notes about mousemove event dispatch. + screen(X/Y) should need to be updated. + Some other properties might need to be set. + Keep the syncMove option default false until all inconsistencies are taken care of. + */ + dispatcher.dispatch(el, { + pageX: point.pageX + scrollx, + pageY: point.pageY + scrolly, + clientX: point.x + scrollx, + clientY: point.y + scrolly + }); + } + + setTimeout(function (){ + + if(scrolly){ + scrollY(el, scrolly); + } + + if(scrollx){ + scrollX(el, scrollx); + } + + }); + } + + function scrollY(el, amount){ + if(el === window){ + window.scrollTo(el.pageXOffset, el.pageYOffset + amount); + }else{ + el.scrollTop += amount; + } + } + + function scrollX(el, amount){ + if(el === window){ + window.scrollTo(el.pageXOffset + amount, el.pageYOffset); + }else{ + el.scrollLeft += amount; + } + } + +} + +function AutoScrollerFactory(element, options){ + return new AutoScroller(element, options); +} + +function inside(point, el, rect){ + if(!rect){ + return pointInside(point, el); + }else{ + return (point.y > rect.top && point.y < rect.bottom && + point.x > rect.left && point.x < rect.right); + } +} + +/* +git remote add origin https://github.com/hollowdoor/dom_autoscroller.git +git push -u origin master +*/ + +return AutoScrollerFactory; + +}()); +//# sourceMappingURL=dom-autoscroller.js.map \ No newline at end of file diff --git a/plugin_files/dom-autoscroller.min.js b/plugin_files/dom-autoscroller.min.js new file mode 100644 index 0000000..0fecee6 --- /dev/null +++ b/plugin_files/dom-autoscroller.min.js @@ -0,0 +1 @@ +var autoScroll=function(){"use strict";function e(e,n){var t,r;return r=n,"function"==typeof(e=void 0===(t=e)?void 0===r?t:r:t)?function(){for(var n=arguments,t=arguments.length,r=Array(t),o=0;o0?1:-1)*Math.floor(Math.abs(n)):n}(e);return Math.min(Math.max(n,0),t)},o=function(e){var n=e.next();return!Boolean(n.done)&&n},function(e){var t,i,a,u=this,c=arguments.length>1?arguments[1]:void 0;if(void 0!==c){if(!n(c))throw new TypeError("Array.from: when provided, the second argument must be a function");arguments.length>2&&(t=arguments[2])}var l=function(e,t){if(null!=e&&null!=t){var r=e[t];if(null==r)return;if(!n(r))throw new TypeError(r+" is not a function");return r}}(e,function(e){if(null!=e){if(["string","number","boolean","symbol"].indexOf(typeof e)>-1)return Symbol.iterator;if("undefined"!=typeof Symbol&&"iterator"in Symbol&&Symbol.iterator in e)return Symbol.iterator;if("@@iterator"in e)return"@@iterator"}}(e));if(void 0!==l){i=n(u)?Object(new u):[];var f,d,s=l.call(e);if(null==s)throw new TypeError("Array.from requires an array-like or iterable object");for(a=0;;){if(!(f=o(s)))return i.length=a,i;d=f.value,i[a]=c?c.call(t,d,a):d,a++}}else{var m=Object(e);if(null==e)throw new TypeError("Array.from requires an array-like object - not null or undefined");var v,w=r(m.length);for(i=n(u)?Object(new u(w)):new Array(w),a=0;a0;)t[r]=n[r+1];return function(e,n){for(var t=0;t0;)t[r]=n[r+1];return t.map(w).reduce((function(n,t){var r=d(e,t);return-1!==r?n.concat(e.splice(r,1)):n}),[])}function w(e,n){if("string"==typeof e)try{return document.querySelector(e)}catch(e){throw e}if(!f(e)&&!n)throw new TypeError(e+" is not a DOM element.");return e}function p(e){if(e===window)return function(){var e={top:{value:0,enumerable:!0},left:{value:0,enumerable:!0},right:{value:window.innerWidth,enumerable:!0},bottom:{value:window.innerHeight,enumerable:!0},width:{value:window.innerWidth,enumerable:!0},height:{value:window.innerHeight,enumerable:!0},x:{value:0,enumerable:!0},y:{value:0,enumerable:!0}};if(Object.create)return Object.create({},e);var n={};return Object.defineProperties(n,e),n}();try{var n=e.getBoundingClientRect();return void 0===n.x&&(n.x=n.left,n.y=n.top),n}catch(n){throw new TypeError("Can't call getBoundingClientRect on "+e)}}var h,g=void 0;"function"!=typeof Object.create?(h=function(){},g=function(e,n){if(e!==Object(e)&&null!==e)throw TypeError("Argument must be an object, or null");h.prototype=e||{};var t=new h;return h.prototype=null,void 0!==n&&Object.defineProperties(t,n),null===e&&(t.__proto__=null),t}):g=Object.create;var y=g,b=["altKey","button","buttons","clientX","clientY","ctrlKey","metaKey","movementX","movementY","offsetX","offsetY","pageX","pageY","region","relatedTarget","screenX","screenY","shiftKey","which","x","y"];function E(e,n){n=n||{};for(var t=y(e),r=0;ro.right-r.margin?Math.ceil(Math.min(1,(c.x-o.right)/r.margin+1)*r.maxSpeed):0,t=c.yo.bottom-r.margin?Math.ceil(Math.min(1,(c.y-o.bottom)/r.margin+1)*r.maxSpeed):0,r.syncMove()&&f.dispatch(e,{pageX:c.pageX+n,pageY:c.pageY+t,clientX:c.x+n,clientY:c.y+t}),setTimeout((function(){t&&function(e,n){e===window?window.scrollTo(e.pageXOffset,e.pageYOffset+n):e.scrollTop+=n}(e,t),n&&function(e,n){e===window?window.scrollTo(e.pageXOffset+n,e.pageYOffset):e.scrollLeft+=n}(e,n)}))}window.addEventListener("mousedown",Y,!1),window.addEventListener("touchstart",Y,!1),window.addEventListener("mouseup",A,!1),window.addEventListener("touchend",A,!1),window.addEventListener("pointerup",A,!1),window.addEventListener("mousemove",M,!1),window.addEventListener("touchmove",M,!1),window.addEventListener("mouseleave",S,!1),window.addEventListener("scroll",X,!0)}function L(e,n,t){return t?e.y>t.top&&e.yt.left&&e.xt.top&&e.yt.left&&e.x 0 ? revert : o.revertOnSpill; + var item = _copy || _item; + var parent = getParent(item); + var initial = isInitialPlacement(parent); + if (initial === false && reverts) { + if (_copy) { + if (parent) { + parent.removeChild(_copy); + } + } else { + _source.insertBefore(item, _initialSibling); + } + } + if (initial || reverts) { + drake.emit('cancel', item, _source, _source); + } else { + drake.emit('drop', item, parent, _source, _currentSibling); + } + cleanup(); + } + + function cleanup () { + var item = _copy || _item; + ungrab(); + removeMirrorImage(); + if (item) { + classes.rm(item, 'gu-transit'); + } + if (_renderTimer) { + clearTimeout(_renderTimer); + } + drake.dragging = false; + if (_lastDropTarget) { + drake.emit('out', item, _lastDropTarget, _source); + } + drake.emit('dragend', item); + _source = _item = _copy = _initialSibling = _currentSibling = _renderTimer = _lastDropTarget = null; + } + + function isInitialPlacement (target, s) { + var sibling; + if (s !== void 0) { + sibling = s; + } else if (_mirror) { + sibling = _currentSibling; + } else { + sibling = nextEl(_copy || _item); + } + return target === _source && sibling === _initialSibling; + } + + function findDropTarget (elementBehindCursor, clientX, clientY) { + var target = elementBehindCursor; + while (target && !accepted()) { + target = getParent(target); + } + return target; + + function accepted () { + var droppable = isContainer(target); + if (droppable === false) { + return false; + } + + var immediate = getImmediateChild(target, elementBehindCursor); + var reference = getReference(target, immediate, clientX, clientY); + var initial = isInitialPlacement(target, reference); + if (initial) { + return true; // should always be able to drop it right back where it was + } + return o.accepts(_item, target, _source, reference); + } + } + + function drag (e) { + if (!_mirror) { + return; + } + e.preventDefault(); + + var clientX = getCoord('clientX', e) || 0; + var clientY = getCoord('clientY', e) || 0; + var x = clientX - _offsetX; + var y = clientY - _offsetY; + + _mirror.style.left = x + 'px'; + _mirror.style.top = y + 'px'; + + var item = _copy || _item; + var elementBehindCursor = getElementBehindPoint(_mirror, clientX, clientY); + var dropTarget = findDropTarget(elementBehindCursor, clientX, clientY); + var changed = dropTarget !== null && dropTarget !== _lastDropTarget; + if (changed || dropTarget === null) { + out(); + _lastDropTarget = dropTarget; + over(); + } + var parent = getParent(item); + if (dropTarget === _source && _copy && !o.copySortSource) { + if (parent) { + parent.removeChild(item); + } + return; + } + var reference; + var immediate = getImmediateChild(dropTarget, elementBehindCursor); + if (immediate !== null) { + reference = getReference(dropTarget, immediate, clientX, clientY); + } else if (o.revertOnSpill === true && !_copy) { + reference = _initialSibling; + dropTarget = _source; + } else { + if (_copy && parent) { + parent.removeChild(item); + } + return; + } + if ( + (reference === null && changed) || + reference !== item && + reference !== nextEl(item) + ) { + _currentSibling = reference; + dropTarget.insertBefore(item, reference); + drake.emit('shadow', item, dropTarget, _source); + } + function moved (type) { drake.emit(type, item, _lastDropTarget, _source); } + function over () { if (changed) { moved('over'); } } + function out () { if (_lastDropTarget) { moved('out'); } } + } + + function spillOver (el) { + classes.rm(el, 'gu-hide'); + } + + function spillOut (el) { + if (drake.dragging) { classes.add(el, 'gu-hide'); } + } + + function renderMirrorImage () { + if (_mirror) { + return; + } + var rect = _item.getBoundingClientRect(); + _mirror = _item.cloneNode(true); + _mirror.style.width = getRectWidth(rect) + 'px'; + _mirror.style.height = getRectHeight(rect) + 'px'; + classes.rm(_mirror, 'gu-transit'); + classes.add(_mirror, 'gu-mirror'); + o.mirrorContainer.appendChild(_mirror); + touchy(documentElement, 'add', 'mousemove', drag); + classes.add(o.mirrorContainer, 'gu-unselectable'); + drake.emit('cloned', _mirror, _item, 'mirror'); + } + + function removeMirrorImage () { + if (_mirror) { + classes.rm(o.mirrorContainer, 'gu-unselectable'); + touchy(documentElement, 'remove', 'mousemove', drag); + getParent(_mirror).removeChild(_mirror); + _mirror = null; + } + } + + function getImmediateChild (dropTarget, target) { + var immediate = target; + while (immediate !== dropTarget && getParent(immediate) !== dropTarget) { + immediate = getParent(immediate); + } + if (immediate === documentElement) { + return null; + } + return immediate; + } + + function getReference (dropTarget, target, x, y) { + var horizontal = o.direction === 'horizontal'; + var reference = target !== dropTarget ? inside() : outside(); + return reference; + + function outside () { // slower, but able to figure out any position + var len = dropTarget.children.length; + var i; + var el; + var rect; + for (i = 0; i < len; i++) { + el = dropTarget.children[i]; + rect = el.getBoundingClientRect(); + if (horizontal && (rect.left + rect.width / 2) > x) { return el; } + if (!horizontal && (rect.top + rect.height / 2) > y) { return el; } + } + return null; + } + + function inside () { // faster, but only available if dropped inside a child element + var rect = target.getBoundingClientRect(); + if (horizontal) { + return resolve(x > rect.left + getRectWidth(rect) / 2); + } + return resolve(y > rect.top + getRectHeight(rect) / 2); + } + + function resolve (after) { + return after ? nextEl(target) : target; + } + } + + function isCopy (item, container) { + return typeof o.copy === 'boolean' ? o.copy : o.copy(item, container); + } +} + +function touchy (el, op, type, fn) { + var touch = { + mouseup: 'touchend', + mousedown: 'touchstart', + mousemove: 'touchmove' + }; + var pointers = { + mouseup: 'pointerup', + mousedown: 'pointerdown', + mousemove: 'pointermove' + }; + var microsoft = { + mouseup: 'MSPointerUp', + mousedown: 'MSPointerDown', + mousemove: 'MSPointerMove' + }; + if (global.navigator.pointerEnabled) { + crossvent[op](el, pointers[type], fn); + } else if (global.navigator.msPointerEnabled) { + crossvent[op](el, microsoft[type], fn); + } else { + crossvent[op](el, touch[type], fn); + crossvent[op](el, type, fn); + } +} + +function whichMouseButton (e) { + if (e.touches !== void 0) { return e.touches.length; } + if (e.which !== void 0 && e.which !== 0) { return e.which; } // see https://github.com/bevacqua/dragula/issues/261 + if (e.buttons !== void 0) { return e.buttons; } + var button = e.button; + if (button !== void 0) { // see https://github.com/jquery/jquery/blob/99e8ff1baa7ae341e94bb89c3e84570c7c3ad9ea/src/event.js#L573-L575 + return button & 1 ? 1 : button & 2 ? 3 : (button & 4 ? 2 : 0); + } +} + +function getOffset (el) { + var rect = el.getBoundingClientRect(); + return { + left: rect.left + getScroll('scrollLeft', 'pageXOffset'), + top: rect.top + getScroll('scrollTop', 'pageYOffset') + }; +} + +function getScroll (scrollProp, offsetProp) { + if (typeof global[offsetProp] !== 'undefined') { + return global[offsetProp]; + } + if (documentElement.clientHeight) { + return documentElement[scrollProp]; + } + return doc.body[scrollProp]; +} + +function getElementBehindPoint (point, x, y) { + point = point || {}; + var state = point.className || ''; + var el; + point.className += ' gu-hide'; + el = doc.elementFromPoint(x, y); + point.className = state; + return el; +} + +function never () { return false; } +function always () { return true; } +function getRectWidth (rect) { return rect.width || (rect.right - rect.left); } +function getRectHeight (rect) { return rect.height || (rect.bottom - rect.top); } +function getParent (el) { return el.parentNode === doc ? null : el.parentNode; } +function isInput (el) { return el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.tagName === 'SELECT' || isEditable(el); } +function isEditable (el) { + if (!el) { return false; } // no parents were editable + if (el.contentEditable === 'false') { return false; } // stop the lookup + if (el.contentEditable === 'true') { return true; } // found a contentEditable element in the chain + return isEditable(getParent(el)); // contentEditable is set to 'inherit' +} + +function nextEl (el) { + return el.nextElementSibling || manually(); + function manually () { + var sibling = el; + do { + sibling = sibling.nextSibling; + } while (sibling && sibling.nodeType !== 1); + return sibling; + } +} + +function getEventHost (e) { + // on touchend event, we have to use `e.changedTouches` + // see http://stackoverflow.com/questions/7192563/touchend-event-properties + // see https://github.com/bevacqua/dragula/issues/34 + if (e.targetTouches && e.targetTouches.length) { + return e.targetTouches[0]; + } + if (e.changedTouches && e.changedTouches.length) { + return e.changedTouches[0]; + } + return e; +} + +function getCoord (coord, e) { + var host = getEventHost(e); + var missMap = { + pageX: 'clientX', // IE8 + pageY: 'clientY' // IE8 + }; + if (coord in missMap && !(coord in host) && missMap[coord] in host) { + coord = missMap[coord]; + } + return host[coord]; +} + +module.exports = dragula; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"./classes":1,"contra/emitter":5,"crossvent":6}],3:[function(require,module,exports){ +module.exports = function atoa (a, n) { return Array.prototype.slice.call(a, n); } + +},{}],4:[function(require,module,exports){ +'use strict'; + +var ticky = require('ticky'); + +module.exports = function debounce (fn, args, ctx) { + if (!fn) { return; } + ticky(function run () { + fn.apply(ctx || null, args || []); + }); +}; + +},{"ticky":10}],5:[function(require,module,exports){ +'use strict'; + +var atoa = require('atoa'); +var debounce = require('./debounce'); + +module.exports = function emitter (thing, options) { + var opts = options || {}; + var evt = {}; + if (thing === undefined) { thing = {}; } + thing.on = function (type, fn) { + if (!evt[type]) { + evt[type] = [fn]; + } else { + evt[type].push(fn); + } + return thing; + }; + thing.once = function (type, fn) { + fn._once = true; // thing.off(fn) still works! + thing.on(type, fn); + return thing; + }; + thing.off = function (type, fn) { + var c = arguments.length; + if (c === 1) { + delete evt[type]; + } else if (c === 0) { + evt = {}; + } else { + var et = evt[type]; + if (!et) { return thing; } + et.splice(et.indexOf(fn), 1); + } + return thing; + }; + thing.emit = function () { + var args = atoa(arguments); + return thing.emitterSnapshot(args.shift()).apply(this, args); + }; + thing.emitterSnapshot = function (type) { + var et = (evt[type] || []).slice(0); + return function () { + var args = atoa(arguments); + var ctx = this || thing; + if (type === 'error' && opts.throws !== false && !et.length) { throw args.length === 1 ? args[0] : args; } + et.forEach(function emitter (listen) { + if (opts.async) { debounce(listen, args, ctx); } else { listen.apply(ctx, args); } + if (listen._once) { thing.off(type, listen); } + }); + return thing; + }; + }; + return thing; +}; + +},{"./debounce":4,"atoa":3}],6:[function(require,module,exports){ +(function (global){ +'use strict'; + +var customEvent = require('custom-event'); +var eventmap = require('./eventmap'); +var doc = global.document; +var addEvent = addEventEasy; +var removeEvent = removeEventEasy; +var hardCache = []; + +if (!global.addEventListener) { + addEvent = addEventHard; + removeEvent = removeEventHard; +} + +module.exports = { + add: addEvent, + remove: removeEvent, + fabricate: fabricateEvent +}; + +function addEventEasy (el, type, fn, capturing) { + return el.addEventListener(type, fn, capturing); +} + +function addEventHard (el, type, fn) { + return el.attachEvent('on' + type, wrap(el, type, fn)); +} + +function removeEventEasy (el, type, fn, capturing) { + return el.removeEventListener(type, fn, capturing); +} + +function removeEventHard (el, type, fn) { + var listener = unwrap(el, type, fn); + if (listener) { + return el.detachEvent('on' + type, listener); + } +} + +function fabricateEvent (el, type, model) { + var e = eventmap.indexOf(type) === -1 ? makeCustomEvent() : makeClassicEvent(); + if (el.dispatchEvent) { + el.dispatchEvent(e); + } else { + el.fireEvent('on' + type, e); + } + function makeClassicEvent () { + var e; + if (doc.createEvent) { + e = doc.createEvent('Event'); + e.initEvent(type, true, true); + } else if (doc.createEventObject) { + e = doc.createEventObject(); + } + return e; + } + function makeCustomEvent () { + return new customEvent(type, { detail: model }); + } +} + +function wrapperFactory (el, type, fn) { + return function wrapper (originalEvent) { + var e = originalEvent || global.event; + e.target = e.target || e.srcElement; + e.preventDefault = e.preventDefault || function preventDefault () { e.returnValue = false; }; + e.stopPropagation = e.stopPropagation || function stopPropagation () { e.cancelBubble = true; }; + e.which = e.which || e.keyCode; + fn.call(el, e); + }; +} + +function wrap (el, type, fn) { + var wrapper = unwrap(el, type, fn) || wrapperFactory(el, type, fn); + hardCache.push({ + wrapper: wrapper, + element: el, + type: type, + fn: fn + }); + return wrapper; +} + +function unwrap (el, type, fn) { + var i = find(el, type, fn); + if (i) { + var wrapper = hardCache[i].wrapper; + hardCache.splice(i, 1); // free up a tad of memory + return wrapper; + } +} + +function find (el, type, fn) { + var i, item; + for (i = 0; i < hardCache.length; i++) { + item = hardCache[i]; + if (item.element === el && item.type === type && item.fn === fn) { + return i; + } + } +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"./eventmap":7,"custom-event":8}],7:[function(require,module,exports){ +(function (global){ +'use strict'; + +var eventmap = []; +var eventname = ''; +var ron = /^on/; + +for (eventname in global) { + if (ron.test(eventname)) { + eventmap.push(eventname.slice(2)); + } +} + +module.exports = eventmap; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{}],8:[function(require,module,exports){ +(function (global){ + +var NativeCustomEvent = global.CustomEvent; + +function useNative () { + try { + var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } }); + return 'cat' === p.type && 'bar' === p.detail.foo; + } catch (e) { + } + return false; +} + +/** + * Cross-browser `CustomEvent` constructor. + * + * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent + * + * @public + */ + +module.exports = useNative() ? NativeCustomEvent : + +// IE >= 9 +'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) { + var e = document.createEvent('CustomEvent'); + if (params) { + e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail); + } else { + e.initCustomEvent(type, false, false, void 0); + } + return e; +} : + +// IE <= 8 +function CustomEvent (type, params) { + var e = document.createEventObject(); + e.type = type; + if (params) { + e.bubbles = Boolean(params.bubbles); + e.cancelable = Boolean(params.cancelable); + e.detail = params.detail; + } else { + e.bubbles = false; + e.cancelable = false; + e.detail = void 0; + } + return e; +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{}],9:[function(require,module,exports){ +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + +},{}],10:[function(require,module,exports){ +(function (setImmediate){ +var si = typeof setImmediate === 'function', tick; +if (si) { + tick = function (fn) { setImmediate(fn); }; +} else { + tick = function (fn) { setTimeout(fn, 0); }; +} + +module.exports = tick; +}).call(this,require("timers").setImmediate) + +},{"timers":11}],11:[function(require,module,exports){ +(function (setImmediate,clearImmediate){ +var nextTick = require('process/browser.js').nextTick; +var apply = Function.prototype.apply; +var slice = Array.prototype.slice; +var immediateIds = {}; +var nextImmediateId = 0; + +// DOM APIs, for completeness + +exports.setTimeout = function() { + return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout); +}; +exports.setInterval = function() { + return new Timeout(apply.call(setInterval, window, arguments), clearInterval); +}; +exports.clearTimeout = +exports.clearInterval = function(timeout) { timeout.close(); }; + +function Timeout(id, clearFn) { + this._id = id; + this._clearFn = clearFn; +} +Timeout.prototype.unref = Timeout.prototype.ref = function() {}; +Timeout.prototype.close = function() { + this._clearFn.call(window, this._id); +}; + +// Does not start the time, just sets up the members needed. +exports.enroll = function(item, msecs) { + clearTimeout(item._idleTimeoutId); + item._idleTimeout = msecs; +}; + +exports.unenroll = function(item) { + clearTimeout(item._idleTimeoutId); + item._idleTimeout = -1; +}; + +exports._unrefActive = exports.active = function(item) { + clearTimeout(item._idleTimeoutId); + + var msecs = item._idleTimeout; + if (msecs >= 0) { + item._idleTimeoutId = setTimeout(function onTimeout() { + if (item._onTimeout) + item._onTimeout(); + }, msecs); + } +}; + +// That's not how node.js implements it but the exposed api is the same. +exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) { + var id = nextImmediateId++; + var args = arguments.length < 2 ? false : slice.call(arguments, 1); + + immediateIds[id] = true; + + nextTick(function onNextTick() { + if (immediateIds[id]) { + // fn.call() is faster so we optimize for the common use-case + // @see http://jsperf.com/call-apply-segu + if (args) { + fn.apply(null, args); + } else { + fn.call(null); + } + // Prevent ids from leaking + exports.clearImmediate(id); + } + }); + + return id; +}; + +exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) { + delete immediateIds[id]; +}; +}).call(this,require("timers").setImmediate,require("timers").clearImmediate) + +},{"process/browser.js":9,"timers":11}]},{},[2])(2) +}); + +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","classes.js","dragula.js","node_modules/atoa/atoa.js","node_modules/contra/debounce.js","node_modules/contra/emitter.js","node_modules/crossvent/src/crossvent.js","node_modules/crossvent/src/eventmap.js","node_modules/custom-event/index.js","node_modules/process/browser.js","node_modules/ticky/ticky-browser.js","node_modules/timers-browserify/main.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnmBA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACrGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACxLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","'use strict';\n\nvar cache = {};\nvar start = '(?:^|\\\\s)';\nvar end = '(?:\\\\s|$)';\n\nfunction lookupClass (className) {\n  var cached = cache[className];\n  if (cached) {\n    cached.lastIndex = 0;\n  } else {\n    cache[className] = cached = new RegExp(start + className + end, 'g');\n  }\n  return cached;\n}\n\nfunction addClass (el, className) {\n  var current = el.className;\n  if (!current.length) {\n    el.className = className;\n  } else if (!lookupClass(className).test(current)) {\n    el.className += ' ' + className;\n  }\n}\n\nfunction rmClass (el, className) {\n  el.className = el.className.replace(lookupClass(className), ' ').trim();\n}\n\nmodule.exports = {\n  add: addClass,\n  rm: rmClass\n};\n","'use strict';\n\nvar emitter = require('contra/emitter');\nvar crossvent = require('crossvent');\nvar classes = require('./classes');\nvar doc = document;\nvar documentElement = doc.documentElement;\n\nfunction dragula (initialContainers, options) {\n  var len = arguments.length;\n  if (len === 1 && Array.isArray(initialContainers) === false) {\n    options = initialContainers;\n    initialContainers = [];\n  }\n  var _mirror; // mirror image\n  var _source; // source container\n  var _item; // item being dragged\n  var _offsetX; // reference x\n  var _offsetY; // reference y\n  var _moveX; // reference move x\n  var _moveY; // reference move y\n  var _initialSibling; // reference sibling when grabbed\n  var _currentSibling; // reference sibling now\n  var _copy; // item used for copying\n  var _renderTimer; // timer for setTimeout renderMirrorImage\n  var _lastDropTarget = null; // last container item was over\n  var _grabbed; // holds mousedown context until first mousemove\n\n  var o = options || {};\n  if (o.moves === void 0) { o.moves = always; }\n  if (o.accepts === void 0) { o.accepts = always; }\n  if (o.invalid === void 0) { o.invalid = invalidTarget; }\n  if (o.containers === void 0) { o.containers = initialContainers || []; }\n  if (o.isContainer === void 0) { o.isContainer = never; }\n  if (o.copy === void 0) { o.copy = false; }\n  if (o.copySortSource === void 0) { o.copySortSource = false; }\n  if (o.revertOnSpill === void 0) { o.revertOnSpill = false; }\n  if (o.removeOnSpill === void 0) { o.removeOnSpill = false; }\n  if (o.direction === void 0) { o.direction = 'vertical'; }\n  if (o.ignoreInputTextSelection === void 0) { o.ignoreInputTextSelection = true; }\n  if (o.mirrorContainer === void 0) { o.mirrorContainer = doc.body; }\n\n  var drake = emitter({\n    containers: o.containers,\n    start: manualStart,\n    end: end,\n    cancel: cancel,\n    remove: remove,\n    destroy: destroy,\n    canMove: canMove,\n    dragging: false\n  });\n\n  if (o.removeOnSpill === true) {\n    drake.on('over', spillOver).on('out', spillOut);\n  }\n\n  events();\n\n  return drake;\n\n  function isContainer (el) {\n    return drake.containers.indexOf(el) !== -1 || o.isContainer(el);\n  }\n\n  function events (remove) {\n    var op = remove ? 'remove' : 'add';\n    touchy(documentElement, op, 'mousedown', grab);\n    touchy(documentElement, op, 'mouseup', release);\n  }\n\n  function eventualMovements (remove) {\n    var op = remove ? 'remove' : 'add';\n    touchy(documentElement, op, 'mousemove', startBecauseMouseMoved);\n  }\n\n  function movements (remove) {\n    var op = remove ? 'remove' : 'add';\n    crossvent[op](documentElement, 'selectstart', preventGrabbed); // IE8\n    crossvent[op](documentElement, 'click', preventGrabbed);\n  }\n\n  function destroy () {\n    events(true);\n    release({});\n  }\n\n  function preventGrabbed (e) {\n    if (_grabbed) {\n      e.preventDefault();\n    }\n  }\n\n  function grab (e) {\n    _moveX = e.clientX;\n    _moveY = e.clientY;\n\n    var ignore = whichMouseButton(e) !== 1 || e.metaKey || e.ctrlKey;\n    if (ignore) {\n      return; // we only care about honest-to-god left clicks and touch events\n    }\n    var item = e.target;\n    var context = canStart(item);\n    if (!context) {\n      return;\n    }\n    _grabbed = context;\n    eventualMovements();\n    if (e.type === 'mousedown') {\n      if (isInput(item)) { // see also: https://github.com/bevacqua/dragula/issues/208\n        item.focus(); // fixes https://github.com/bevacqua/dragula/issues/176\n      } else {\n        e.preventDefault(); // fixes https://github.com/bevacqua/dragula/issues/155\n      }\n    }\n  }\n\n  function startBecauseMouseMoved (e) {\n    if (!_grabbed) {\n      return;\n    }\n    if (whichMouseButton(e) === 0) {\n      release({});\n      return; // when text is selected on an input and then dragged, mouseup doesn't fire. this is our only hope\n    }\n\n    // truthy check fixes #239, equality fixes #207, fixes #501\n    if ((e.clientX !== void 0 && Math.abs(e.clientX - _moveX) <= (o.slideFactorX || 0)) &&\n      (e.clientY !== void 0 && Math.abs(e.clientY - _moveY) <= (o.slideFactorY || 0))) {\n      return;\n    }\n\n    if (o.ignoreInputTextSelection) {\n      var clientX = getCoord('clientX', e) || 0;\n      var clientY = getCoord('clientY', e) || 0;\n      var elementBehindCursor = doc.elementFromPoint(clientX, clientY);\n      if (isInput(elementBehindCursor)) {\n        return;\n      }\n    }\n\n    var grabbed = _grabbed; // call to end() unsets _grabbed\n    eventualMovements(true);\n    movements();\n    end();\n    start(grabbed);\n\n    var offset = getOffset(_item);\n    _offsetX = getCoord('pageX', e) - offset.left;\n    _offsetY = getCoord('pageY', e) - offset.top;\n\n    classes.add(_copy || _item, 'gu-transit');\n    renderMirrorImage();\n    drag(e);\n  }\n\n  function canStart (item) {\n    if (drake.dragging && _mirror) {\n      return;\n    }\n    if (isContainer(item)) {\n      return; // don't drag container itself\n    }\n    var handle = item;\n    while (getParent(item) && isContainer(getParent(item)) === false) {\n      if (o.invalid(item, handle)) {\n        return;\n      }\n      item = getParent(item); // drag target should be a top element\n      if (!item) {\n        return;\n      }\n    }\n    var source = getParent(item);\n    if (!source) {\n      return;\n    }\n    if (o.invalid(item, handle)) {\n      return;\n    }\n\n    var movable = o.moves(item, source, handle, nextEl(item));\n    if (!movable) {\n      return;\n    }\n\n    return {\n      item: item,\n      source: source\n    };\n  }\n\n  function canMove (item) {\n    return !!canStart(item);\n  }\n\n  function manualStart (item) {\n    var context = canStart(item);\n    if (context) {\n      start(context);\n    }\n  }\n\n  function start (context) {\n    if (isCopy(context.item, context.source)) {\n      _copy = context.item.cloneNode(true);\n      drake.emit('cloned', _copy, context.item, 'copy');\n    }\n\n    _source = context.source;\n    _item = context.item;\n    _initialSibling = _currentSibling = nextEl(context.item);\n\n    drake.dragging = true;\n    drake.emit('drag', _item, _source);\n  }\n\n  function invalidTarget () {\n    return false;\n  }\n\n  function end () {\n    if (!drake.dragging) {\n      return;\n    }\n    var item = _copy || _item;\n    drop(item, getParent(item));\n  }\n\n  function ungrab () {\n    _grabbed = false;\n    eventualMovements(true);\n    movements(true);\n  }\n\n  function release (e) {\n    ungrab();\n\n    if (!drake.dragging) {\n      return;\n    }\n    var item = _copy || _item;\n    var clientX = getCoord('clientX', e) || 0;\n    var clientY = getCoord('clientY', e) || 0;\n    var elementBehindCursor = getElementBehindPoint(_mirror, clientX, clientY);\n    var dropTarget = findDropTarget(elementBehindCursor, clientX, clientY);\n    if (dropTarget && ((_copy && o.copySortSource) || (!_copy || dropTarget !== _source))) {\n      drop(item, dropTarget);\n    } else if (o.removeOnSpill) {\n      remove();\n    } else {\n      cancel();\n    }\n  }\n\n  function drop (item, target) {\n    var parent = getParent(item);\n    if (_copy && o.copySortSource && target === _source) {\n      parent.removeChild(_item);\n    }\n    if (isInitialPlacement(target)) {\n      drake.emit('cancel', item, _source, _source);\n    } else {\n      drake.emit('drop', item, target, _source, _currentSibling);\n    }\n    cleanup();\n  }\n\n  function remove () {\n    if (!drake.dragging) {\n      return;\n    }\n    var item = _copy || _item;\n    var parent = getParent(item);\n    if (parent) {\n      parent.removeChild(item);\n    }\n    drake.emit(_copy ? 'cancel' : 'remove', item, parent, _source);\n    cleanup();\n  }\n\n  function cancel (revert) {\n    if (!drake.dragging) {\n      return;\n    }\n    var reverts = arguments.length > 0 ? revert : o.revertOnSpill;\n    var item = _copy || _item;\n    var parent = getParent(item);\n    var initial = isInitialPlacement(parent);\n    if (initial === false && reverts) {\n      if (_copy) {\n        if (parent) {\n          parent.removeChild(_copy);\n        }\n      } else {\n        _source.insertBefore(item, _initialSibling);\n      }\n    }\n    if (initial || reverts) {\n      drake.emit('cancel', item, _source, _source);\n    } else {\n      drake.emit('drop', item, parent, _source, _currentSibling);\n    }\n    cleanup();\n  }\n\n  function cleanup () {\n    var item = _copy || _item;\n    ungrab();\n    removeMirrorImage();\n    if (item) {\n      classes.rm(item, 'gu-transit');\n    }\n    if (_renderTimer) {\n      clearTimeout(_renderTimer);\n    }\n    drake.dragging = false;\n    if (_lastDropTarget) {\n      drake.emit('out', item, _lastDropTarget, _source);\n    }\n    drake.emit('dragend', item);\n    _source = _item = _copy = _initialSibling = _currentSibling = _renderTimer = _lastDropTarget = null;\n  }\n\n  function isInitialPlacement (target, s) {\n    var sibling;\n    if (s !== void 0) {\n      sibling = s;\n    } else if (_mirror) {\n      sibling = _currentSibling;\n    } else {\n      sibling = nextEl(_copy || _item);\n    }\n    return target === _source && sibling === _initialSibling;\n  }\n\n  function findDropTarget (elementBehindCursor, clientX, clientY) {\n    var target = elementBehindCursor;\n    while (target && !accepted()) {\n      target = getParent(target);\n    }\n    return target;\n\n    function accepted () {\n      var droppable = isContainer(target);\n      if (droppable === false) {\n        return false;\n      }\n\n      var immediate = getImmediateChild(target, elementBehindCursor);\n      var reference = getReference(target, immediate, clientX, clientY);\n      var initial = isInitialPlacement(target, reference);\n      if (initial) {\n        return true; // should always be able to drop it right back where it was\n      }\n      return o.accepts(_item, target, _source, reference);\n    }\n  }\n\n  function drag (e) {\n    if (!_mirror) {\n      return;\n    }\n    e.preventDefault();\n\n    var clientX = getCoord('clientX', e) || 0;\n    var clientY = getCoord('clientY', e) || 0;\n    var x = clientX - _offsetX;\n    var y = clientY - _offsetY;\n\n    _mirror.style.left = x + 'px';\n    _mirror.style.top = y + 'px';\n\n    var item = _copy || _item;\n    var elementBehindCursor = getElementBehindPoint(_mirror, clientX, clientY);\n    var dropTarget = findDropTarget(elementBehindCursor, clientX, clientY);\n    var changed = dropTarget !== null && dropTarget !== _lastDropTarget;\n    if (changed || dropTarget === null) {\n      out();\n      _lastDropTarget = dropTarget;\n      over();\n    }\n    var parent = getParent(item);\n    if (dropTarget === _source && _copy && !o.copySortSource) {\n      if (parent) {\n        parent.removeChild(item);\n      }\n      return;\n    }\n    var reference;\n    var immediate = getImmediateChild(dropTarget, elementBehindCursor);\n    if (immediate !== null) {\n      reference = getReference(dropTarget, immediate, clientX, clientY);\n    } else if (o.revertOnSpill === true && !_copy) {\n      reference = _initialSibling;\n      dropTarget = _source;\n    } else {\n      if (_copy && parent) {\n        parent.removeChild(item);\n      }\n      return;\n    }\n    if (\n      (reference === null && changed) ||\n      reference !== item &&\n      reference !== nextEl(item)\n    ) {\n      _currentSibling = reference;\n      dropTarget.insertBefore(item, reference);\n      drake.emit('shadow', item, dropTarget, _source);\n    }\n    function moved (type) { drake.emit(type, item, _lastDropTarget, _source); }\n    function over () { if (changed) { moved('over'); } }\n    function out () { if (_lastDropTarget) { moved('out'); } }\n  }\n\n  function spillOver (el) {\n    classes.rm(el, 'gu-hide');\n  }\n\n  function spillOut (el) {\n    if (drake.dragging) { classes.add(el, 'gu-hide'); }\n  }\n\n  function renderMirrorImage () {\n    if (_mirror) {\n      return;\n    }\n    var rect = _item.getBoundingClientRect();\n    _mirror = _item.cloneNode(true);\n    _mirror.style.width = getRectWidth(rect) + 'px';\n    _mirror.style.height = getRectHeight(rect) + 'px';\n    classes.rm(_mirror, 'gu-transit');\n    classes.add(_mirror, 'gu-mirror');\n    o.mirrorContainer.appendChild(_mirror);\n    touchy(documentElement, 'add', 'mousemove', drag);\n    classes.add(o.mirrorContainer, 'gu-unselectable');\n    drake.emit('cloned', _mirror, _item, 'mirror');\n  }\n\n  function removeMirrorImage () {\n    if (_mirror) {\n      classes.rm(o.mirrorContainer, 'gu-unselectable');\n      touchy(documentElement, 'remove', 'mousemove', drag);\n      getParent(_mirror).removeChild(_mirror);\n      _mirror = null;\n    }\n  }\n\n  function getImmediateChild (dropTarget, target) {\n    var immediate = target;\n    while (immediate !== dropTarget && getParent(immediate) !== dropTarget) {\n      immediate = getParent(immediate);\n    }\n    if (immediate === documentElement) {\n      return null;\n    }\n    return immediate;\n  }\n\n  function getReference (dropTarget, target, x, y) {\n    var horizontal = o.direction === 'horizontal';\n    var reference = target !== dropTarget ? inside() : outside();\n    return reference;\n\n    function outside () { // slower, but able to figure out any position\n      var len = dropTarget.children.length;\n      var i;\n      var el;\n      var rect;\n      for (i = 0; i < len; i++) {\n        el = dropTarget.children[i];\n        rect = el.getBoundingClientRect();\n        if (horizontal && (rect.left + rect.width / 2) > x) { return el; }\n        if (!horizontal && (rect.top + rect.height / 2) > y) { return el; }\n      }\n      return null;\n    }\n\n    function inside () { // faster, but only available if dropped inside a child element\n      var rect = target.getBoundingClientRect();\n      if (horizontal) {\n        return resolve(x > rect.left + getRectWidth(rect) / 2);\n      }\n      return resolve(y > rect.top + getRectHeight(rect) / 2);\n    }\n\n    function resolve (after) {\n      return after ? nextEl(target) : target;\n    }\n  }\n\n  function isCopy (item, container) {\n    return typeof o.copy === 'boolean' ? o.copy : o.copy(item, container);\n  }\n}\n\nfunction touchy (el, op, type, fn) {\n  var touch = {\n    mouseup: 'touchend',\n    mousedown: 'touchstart',\n    mousemove: 'touchmove'\n  };\n  var pointers = {\n    mouseup: 'pointerup',\n    mousedown: 'pointerdown',\n    mousemove: 'pointermove'\n  };\n  var microsoft = {\n    mouseup: 'MSPointerUp',\n    mousedown: 'MSPointerDown',\n    mousemove: 'MSPointerMove'\n  };\n  if (global.navigator.pointerEnabled) {\n    crossvent[op](el, pointers[type], fn);\n  } else if (global.navigator.msPointerEnabled) {\n    crossvent[op](el, microsoft[type], fn);\n  } else {\n    crossvent[op](el, touch[type], fn);\n    crossvent[op](el, type, fn);\n  }\n}\n\nfunction whichMouseButton (e) {\n  if (e.touches !== void 0) { return e.touches.length; }\n  if (e.which !== void 0 && e.which !== 0) { return e.which; } // see https://github.com/bevacqua/dragula/issues/261\n  if (e.buttons !== void 0) { return e.buttons; }\n  var button = e.button;\n  if (button !== void 0) { // see https://github.com/jquery/jquery/blob/99e8ff1baa7ae341e94bb89c3e84570c7c3ad9ea/src/event.js#L573-L575\n    return button & 1 ? 1 : button & 2 ? 3 : (button & 4 ? 2 : 0);\n  }\n}\n\nfunction getOffset (el) {\n  var rect = el.getBoundingClientRect();\n  return {\n    left: rect.left + getScroll('scrollLeft', 'pageXOffset'),\n    top: rect.top + getScroll('scrollTop', 'pageYOffset')\n  };\n}\n\nfunction getScroll (scrollProp, offsetProp) {\n  if (typeof global[offsetProp] !== 'undefined') {\n    return global[offsetProp];\n  }\n  if (documentElement.clientHeight) {\n    return documentElement[scrollProp];\n  }\n  return doc.body[scrollProp];\n}\n\nfunction getElementBehindPoint (point, x, y) {\n  point = point || {};\n  var state = point.className || '';\n  var el;\n  point.className += ' gu-hide';\n  el = doc.elementFromPoint(x, y);\n  point.className = state;\n  return el;\n}\n\nfunction never () { return false; }\nfunction always () { return true; }\nfunction getRectWidth (rect) { return rect.width || (rect.right - rect.left); }\nfunction getRectHeight (rect) { return rect.height || (rect.bottom - rect.top); }\nfunction getParent (el) { return el.parentNode === doc ? null : el.parentNode; }\nfunction isInput (el) { return el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.tagName === 'SELECT' || isEditable(el); }\nfunction isEditable (el) {\n  if (!el) { return false; } // no parents were editable\n  if (el.contentEditable === 'false') { return false; } // stop the lookup\n  if (el.contentEditable === 'true') { return true; } // found a contentEditable element in the chain\n  return isEditable(getParent(el)); // contentEditable is set to 'inherit'\n}\n\nfunction nextEl (el) {\n  return el.nextElementSibling || manually();\n  function manually () {\n    var sibling = el;\n    do {\n      sibling = sibling.nextSibling;\n    } while (sibling && sibling.nodeType !== 1);\n    return sibling;\n  }\n}\n\nfunction getEventHost (e) {\n  // on touchend event, we have to use `e.changedTouches`\n  // see http://stackoverflow.com/questions/7192563/touchend-event-properties\n  // see https://github.com/bevacqua/dragula/issues/34\n  if (e.targetTouches && e.targetTouches.length) {\n    return e.targetTouches[0];\n  }\n  if (e.changedTouches && e.changedTouches.length) {\n    return e.changedTouches[0];\n  }\n  return e;\n}\n\nfunction getCoord (coord, e) {\n  var host = getEventHost(e);\n  var missMap = {\n    pageX: 'clientX', // IE8\n    pageY: 'clientY' // IE8\n  };\n  if (coord in missMap && !(coord in host) && missMap[coord] in host) {\n    coord = missMap[coord];\n  }\n  return host[coord];\n}\n\nmodule.exports = dragula;\n","module.exports = function atoa (a, n) { return Array.prototype.slice.call(a, n); }\n","'use strict';\n\nvar ticky = require('ticky');\n\nmodule.exports = function debounce (fn, args, ctx) {\n  if (!fn) { return; }\n  ticky(function run () {\n    fn.apply(ctx || null, args || []);\n  });\n};\n","'use strict';\n\nvar atoa = require('atoa');\nvar debounce = require('./debounce');\n\nmodule.exports = function emitter (thing, options) {\n  var opts = options || {};\n  var evt = {};\n  if (thing === undefined) { thing = {}; }\n  thing.on = function (type, fn) {\n    if (!evt[type]) {\n      evt[type] = [fn];\n    } else {\n      evt[type].push(fn);\n    }\n    return thing;\n  };\n  thing.once = function (type, fn) {\n    fn._once = true; // thing.off(fn) still works!\n    thing.on(type, fn);\n    return thing;\n  };\n  thing.off = function (type, fn) {\n    var c = arguments.length;\n    if (c === 1) {\n      delete evt[type];\n    } else if (c === 0) {\n      evt = {};\n    } else {\n      var et = evt[type];\n      if (!et) { return thing; }\n      et.splice(et.indexOf(fn), 1);\n    }\n    return thing;\n  };\n  thing.emit = function () {\n    var args = atoa(arguments);\n    return thing.emitterSnapshot(args.shift()).apply(this, args);\n  };\n  thing.emitterSnapshot = function (type) {\n    var et = (evt[type] || []).slice(0);\n    return function () {\n      var args = atoa(arguments);\n      var ctx = this || thing;\n      if (type === 'error' && opts.throws !== false && !et.length) { throw args.length === 1 ? args[0] : args; }\n      et.forEach(function emitter (listen) {\n        if (opts.async) { debounce(listen, args, ctx); } else { listen.apply(ctx, args); }\n        if (listen._once) { thing.off(type, listen); }\n      });\n      return thing;\n    };\n  };\n  return thing;\n};\n","'use strict';\n\nvar customEvent = require('custom-event');\nvar eventmap = require('./eventmap');\nvar doc = global.document;\nvar addEvent = addEventEasy;\nvar removeEvent = removeEventEasy;\nvar hardCache = [];\n\nif (!global.addEventListener) {\n  addEvent = addEventHard;\n  removeEvent = removeEventHard;\n}\n\nmodule.exports = {\n  add: addEvent,\n  remove: removeEvent,\n  fabricate: fabricateEvent\n};\n\nfunction addEventEasy (el, type, fn, capturing) {\n  return el.addEventListener(type, fn, capturing);\n}\n\nfunction addEventHard (el, type, fn) {\n  return el.attachEvent('on' + type, wrap(el, type, fn));\n}\n\nfunction removeEventEasy (el, type, fn, capturing) {\n  return el.removeEventListener(type, fn, capturing);\n}\n\nfunction removeEventHard (el, type, fn) {\n  var listener = unwrap(el, type, fn);\n  if (listener) {\n    return el.detachEvent('on' + type, listener);\n  }\n}\n\nfunction fabricateEvent (el, type, model) {\n  var e = eventmap.indexOf(type) === -1 ? makeCustomEvent() : makeClassicEvent();\n  if (el.dispatchEvent) {\n    el.dispatchEvent(e);\n  } else {\n    el.fireEvent('on' + type, e);\n  }\n  function makeClassicEvent () {\n    var e;\n    if (doc.createEvent) {\n      e = doc.createEvent('Event');\n      e.initEvent(type, true, true);\n    } else if (doc.createEventObject) {\n      e = doc.createEventObject();\n    }\n    return e;\n  }\n  function makeCustomEvent () {\n    return new customEvent(type, { detail: model });\n  }\n}\n\nfunction wrapperFactory (el, type, fn) {\n  return function wrapper (originalEvent) {\n    var e = originalEvent || global.event;\n    e.target = e.target || e.srcElement;\n    e.preventDefault = e.preventDefault || function preventDefault () { e.returnValue = false; };\n    e.stopPropagation = e.stopPropagation || function stopPropagation () { e.cancelBubble = true; };\n    e.which = e.which || e.keyCode;\n    fn.call(el, e);\n  };\n}\n\nfunction wrap (el, type, fn) {\n  var wrapper = unwrap(el, type, fn) || wrapperFactory(el, type, fn);\n  hardCache.push({\n    wrapper: wrapper,\n    element: el,\n    type: type,\n    fn: fn\n  });\n  return wrapper;\n}\n\nfunction unwrap (el, type, fn) {\n  var i = find(el, type, fn);\n  if (i) {\n    var wrapper = hardCache[i].wrapper;\n    hardCache.splice(i, 1); // free up a tad of memory\n    return wrapper;\n  }\n}\n\nfunction find (el, type, fn) {\n  var i, item;\n  for (i = 0; i < hardCache.length; i++) {\n    item = hardCache[i];\n    if (item.element === el && item.type === type && item.fn === fn) {\n      return i;\n    }\n  }\n}\n","'use strict';\n\nvar eventmap = [];\nvar eventname = '';\nvar ron = /^on/;\n\nfor (eventname in global) {\n  if (ron.test(eventname)) {\n    eventmap.push(eventname.slice(2));\n  }\n}\n\nmodule.exports = eventmap;\n","\nvar NativeCustomEvent = global.CustomEvent;\n\nfunction useNative () {\n  try {\n    var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } });\n    return  'cat' === p.type && 'bar' === p.detail.foo;\n  } catch (e) {\n  }\n  return false;\n}\n\n/**\n * Cross-browser `CustomEvent` constructor.\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent\n *\n * @public\n */\n\nmodule.exports = useNative() ? NativeCustomEvent :\n\n// IE >= 9\n'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) {\n  var e = document.createEvent('CustomEvent');\n  if (params) {\n    e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail);\n  } else {\n    e.initCustomEvent(type, false, false, void 0);\n  }\n  return e;\n} :\n\n// IE <= 8\nfunction CustomEvent (type, params) {\n  var e = document.createEventObject();\n  e.type = type;\n  if (params) {\n    e.bubbles = Boolean(params.bubbles);\n    e.cancelable = Boolean(params.cancelable);\n    e.detail = params.detail;\n  } else {\n    e.bubbles = false;\n    e.cancelable = false;\n    e.detail = void 0;\n  }\n  return e;\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","var si = typeof setImmediate === 'function', tick;\nif (si) {\n  tick = function (fn) { setImmediate(fn); };\n} else {\n  tick = function (fn) { setTimeout(fn, 0); };\n}\n\nmodule.exports = tick;","var nextTick = require('process/browser.js').nextTick;\nvar apply = Function.prototype.apply;\nvar slice = Array.prototype.slice;\nvar immediateIds = {};\nvar nextImmediateId = 0;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) { timeout.close(); };\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// That's not how node.js implements it but the exposed api is the same.\nexports.setImmediate = typeof setImmediate === \"function\" ? setImmediate : function(fn) {\n  var id = nextImmediateId++;\n  var args = arguments.length < 2 ? false : slice.call(arguments, 1);\n\n  immediateIds[id] = true;\n\n  nextTick(function onNextTick() {\n    if (immediateIds[id]) {\n      // fn.call() is faster so we optimize for the common use-case\n      // @see http://jsperf.com/call-apply-segu\n      if (args) {\n        fn.apply(null, args);\n      } else {\n        fn.call(null);\n      }\n      // Prevent ids from leaking\n      exports.clearImmediate(id);\n    }\n  });\n\n  return id;\n};\n\nexports.clearImmediate = typeof clearImmediate === \"function\" ? clearImmediate : function(id) {\n  delete immediateIds[id];\n};"]} \ No newline at end of file diff --git a/plugin_files/dragula.min.css b/plugin_files/dragula.min.css new file mode 100644 index 0000000..8079a35 --- /dev/null +++ b/plugin_files/dragula.min.css @@ -0,0 +1 @@ +.gu-mirror {position: fixed !important;margin: 0 !important;z-index: 9999 !important;opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.gu-hide {display: none !important;}.gu-unselectable {-webkit-user-select: none !important;-moz-user-select: none !important;-ms-user-select: none !important;user-select: none !important;}.gu-transit {opacity: 0.2;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=20)";filter: alpha(opacity=20);} \ No newline at end of file diff --git a/plugin_files/dragula.min.js b/plugin_files/dragula.min.js new file mode 100644 index 0000000..cabba93 --- /dev/null +++ b/plugin_files/dragula.min.js @@ -0,0 +1 @@ +!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).dragula=e()}}((function(){return function e(t,n,r){function o(u,c){if(!n[u]){if(!t[u]){var a="function"==typeof require&&require;if(!c&&a)return a(u,!0);if(i)return i(u,!0);var l=new Error("Cannot find module '"+u+"'");throw l.code="MODULE_NOT_FOUND",l}var f=n[u]={exports:{}};t[u][0].call(f.exports,(function(e){return o(t[u][1][e]||e)}),f,f.exports,e,t,n,r)}return n[u].exports}for(var i="function"==typeof require&&require,u=0;u0?e:Y.revertOnSpill,n=N||T,r=h(n),o=J(r);!1===o&&t&&(N?r&&r.removeChild(N):y.insertBefore(n,O)),o||t?A.emit("cancel",n,y,y):A.emit("drop",n,r,y,I),G()}}function G(){var e=N||T;K(),n&&(i.rm(Y.mirrorContainer,"gu-unselectable"),a(c,"remove","mousemove",W),h(n).removeChild(n),n=null),e&&i.rm(e,"gu-transit"),_&&clearTimeout(_),A.dragging=!1,L&&A.emit("out",e,L,y),A.emit("dragend",e),y=T=N=O=I=_=L=null}function J(e,t){var r;return r=void 0!==t?t:n?I:w(N||T),e===y&&r===O}function Q(e,t,n){for(var r=e;r&&!o();)r=h(r);return r;function o(){if(!1===B(r))return!1;var o=Z(r,e),i=ee(r,o,t,n);return!!J(r,i)||Y.accepts(T,r,y,i)}}function W(e){if(n){e.preventDefault();var t=b("clientX",e)||0,r=b("clientY",e)||0,o=t-E,i=r-x;n.style.left=o+"px",n.style.top=i+"px";var u=N||T,c=s(n,t,r),a=Q(c,t,r),l=null!==a&&a!==L;(l||null===a)&&(L&&m("out"),L=a,l&&m("over"));var f=h(u);if(a!==y||!N||Y.copySortSource){var d,v=Z(a,c);if(null!==v)d=ee(a,v,t,r);else{if(!0!==Y.revertOnSpill||N)return void(N&&f&&f.removeChild(u));d=O,a=y}(null===d&&l||d!==u&&d!==w(u))&&(I=d,a.insertBefore(u,d),A.emit("shadow",u,a,y))}else f&&f.removeChild(u)}function m(e){A.emit(e,u,L,y)}}function Z(e,t){for(var n=t;n!==e&&h(n)!==e;)n=h(n);return n===c?null:n}function ee(e,t,n,r){var o="horizontal"===Y.direction,i=t!==e?function(){var e=t.getBoundingClientRect();if(o)return u(n>e.left+m(e)/2);return u(r>e.top+p(e)/2)}():function(){var t,i,u,c=e.children.length;for(t=0;tn)return i;if(!o&&u.top+u.height/2>r)return i}return null}();return i;function u(e){return e?w(t):t}}}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./classes":1,"contra/emitter":5,crossvent:6}],3:[function(e,t,n){t.exports=function(e,t){return Array.prototype.slice.call(e,t)}},{}],4:[function(e,t,n){"use strict";var r=e("ticky");t.exports=function(e,t,n){e&&r((function(){e.apply(n||null,t||[])}))}},{ticky:10}],5:[function(e,t,n){"use strict";var r=e("atoa"),o=e("./debounce");t.exports=function(e,t){var n=t||{},i={};return void 0===e&&(e={}),e.on=function(t,n){return i[t]?i[t].push(n):i[t]=[n],e},e.once=function(t,n){return n._once=!0,e.on(t,n),e},e.off=function(t,n){var r=arguments.length;if(1===r)delete i[t];else if(0===r)i={};else{var o=i[t];if(!o)return e;o.splice(o.indexOf(n),1)}return e},e.emit=function(){var t=r(arguments);return e.emitterSnapshot(t.shift()).apply(this,t)},e.emitterSnapshot=function(t){var u=(i[t]||[]).slice(0);return function(){var i=r(arguments),c=this||e;if("error"===t&&!1!==n.throws&&!u.length)throw 1===i.length?i[0]:i;return u.forEach((function(r){n.async?o(r,i,c):r.apply(c,i),r._once&&e.off(t,r)})),e}},e}},{"./debounce":4,atoa:3}],6:[function(e,t,n){(function(n){"use strict";var r=e("custom-event"),o=e("./eventmap"),i=n.document,u=function(e,t,n,r){return e.addEventListener(t,n,r)},c=function(e,t,n,r){return e.removeEventListener(t,n,r)},a=[];function l(e,t,n){var r=function(e,t,n){var r,o;for(r=0;r1)for(var n=1;n=0&&(e._idleTimeoutId=setTimeout((function(){e._onTimeout&&e._onTimeout()}),t))},n.setImmediate="function"==typeof t?t:function(e){var t=a++,r=!(arguments.length<2)&&u.call(arguments,1);return c[t]=!0,o((function(){c[t]&&(r?e.apply(null,r):e.call(null),n.clearImmediate(t))})),t},n.clearImmediate="function"==typeof r?r:function(e){delete c[e]}}).call(this,e("timers").setImmediate,e("timers").clearImmediate)},{"process/browser.js":9,timers:11}]},{},[2])(2)})); \ No newline at end of file diff --git a/plugin_files/responsive-grid.css b/plugin_files/responsive-grid.css new file mode 100644 index 0000000..b88c640 --- /dev/null +++ b/plugin_files/responsive-grid.css @@ -0,0 +1,147 @@ +.s-g-container { + width: 98%; + margin-left: auto; + margin-right: auto; +} +.s-g-row { + position: relative; + width: 100%; +} +.s-g-row [class^="s-g-col"] { + float: left; + margin: 0.5rem 2%; + min-height: 0.125rem; +} +.s-g-col-1, +.s-g-col-2, +.s-g-col-3, +.s-g-col-4, +.s-g-col-5, +.s-g-col-6, +.s-g-col-7, +.s-g-col-8, +.s-g-col-9, +.s-g-col-10, +.s-g-col-11, +.s-g-col-12 { + width: 96%; +} +.s-g-col-1-sm { + width: 4.33%; +} +.s-g-col-2-sm { + width: 12.66%; +} +.s-g-col-3-sm { + width: 21%; +} +.s-g-col-4-sm { + width: 29.33%; +} +.s-g-col-5-sm { + width: 37.66%; +} +.s-g-col-6-sm { + width: 46%; +} +.s-g-col-7-sm { + width: 54.33%; +} +.s-g-col-8-sm { + width: 62.66%; +} +.s-g-col-9-sm { + width: 71%; +} +.s-g-col-10-sm { + width: 79.33%; +} +.s-g-col-11-sm { + width: 87.66%; +} +.s-g-col-12-sm { + width: 96%; +} +.s-g-row::after { + content: ""; + display: table; + clear: both; +} +.hidden-sm { + display: none; +} +@media only screen and (min-width: 33.75em) { + /* 540px */ + .s-g-container { + width: 98%; + } +} +@media only screen and (min-width: 60em) { + /* was 45em */ + /* 720px */ + .s-g-col-1, + .s-g-col-2, + .s-g-col-3, + .s-g-col-4, + .s-g-col-5, + .s-g-col-6 { + width: 46%; + } + .s-g-col-7, + .s-g-col-8, + .s-g-col-9, + .s-g-col-10, + .s-g-col-11, + .s-g-col-12 { + width: 96%; + } + .hidden-sm { + display: block; + } +} +@media only screen and (min-width: 66em) { + /* was 60em */ + /* 960px */ + .s-g-container { + width: 98%; + } + .s-g-col-1 { + width: 4.33%; + } + .s-g-col-2 { + width: 12.66%; + } + .s-g-col-3 { + width: 21%; + } + .s-g-col-4 { + width: 29.33%; + } + .s-g-col-5 { + width: 37.66%; + } + .s-g-col-6 { + width: 46%; + } + .s-g-col-7 { + width: 54.33%; + } + .s-g-col-8 { + width: 62.66%; + } + .s-g-col-9 { + width: 71%; + } + .s-g-col-10 { + width: 79.33%; + } + .s-g-col-11 { + width: 87.66%; + } + .s-g-col-12 { + width: 96%; + } + .hidden-sm { + display: block; + } +} diff --git a/plugin_files/responsive-grid.min.css b/plugin_files/responsive-grid.min.css new file mode 100644 index 0000000..6695809 --- /dev/null +++ b/plugin_files/responsive-grid.min.css @@ -0,0 +1,22 @@ +.s-g-container {width: 98%;margin-left: auto;margin-right: auto;}.s-g-row {position: relative;width: 100%;}.s-g-row [class^="s-g-col"] {float: left;margin: 0.5rem 2%;min-height: 0.125rem;}.s-g-col-1, +.s-g-col-2, +.s-g-col-3, +.s-g-col-4, +.s-g-col-5, +.s-g-col-6, +.s-g-col-7, +.s-g-col-8, +.s-g-col-9, +.s-g-col-10, +.s-g-col-11, +.s-g-col-12 {width: 96%;}.s-g-col-1-sm {width: 4.33%;}.s-g-col-2-sm {width: 12.66%;}.s-g-col-3-sm {width: 21%;}.s-g-col-4-sm {width: 29.33%;}.s-g-col-5-sm {width: 37.66%;}.s-g-col-6-sm {width: 46%;}.s-g-col-7-sm {width: 54.33%;}.s-g-col-8-sm {width: 62.66%;}.s-g-col-9-sm {width: 71%;}.s-g-col-10-sm {width: 79.33%;}.s-g-col-11-sm {width: 87.66%;}.s-g-col-12-sm {width: 96%;}.s-g-row::after {content: "";display: table;clear: both;}.hidden-sm {display: none;}@media only screen and (min-width: 33.75em) { .s-g-container {width: 98%;}}@media only screen and (min-width: 60em) {.s-g-col-1, +.s-g-col-2, +.s-g-col-3, +.s-g-col-4, +.s-g-col-5, +.s-g-col-6 {width: 46%;}.s-g-col-7, +.s-g-col-8, +.s-g-col-9, +.s-g-col-10, +.s-g-col-11, +.s-g-col-12 {width: 96%;}.hidden-sm {display: block;}}@media only screen and (min-width: 66em) {.s-g-container {width: 98%;}.s-g-col-1 {width: 4.33%;}.s-g-col-2 {width: 12.66%;}.s-g-col-3 {width: 21%;}.s-g-col-4 {width: 29.33%;}.s-g-col-5 {width: 37.66%;}.s-g-col-6 {width: 46%;}.s-g-col-7 {width: 54.33%;}.s-g-col-8 {width: 62.66%;}.s-g-col-9 {width: 71%;}.s-g-col-10 {width: 79.33%;}.s-g-col-11 {width: 87.66%;}.s-g-col-12 {width: 96%;}.hidden-sm {display: block;}} \ No newline at end of file diff --git a/plugin_files/script.js b/plugin_files/script.js new file mode 100644 index 0000000..83ee100 --- /dev/null +++ b/plugin_files/script.js @@ -0,0 +1,517 @@ +apex.jQuery( apex.gPageContext$ ).on( "apexreadyend", function( e ) { + $('.s-g-container').each(function(){ + kanban.initialize('#'+this.id,this.getAttribute('dropitemajax'),this.getAttribute('dropgroupajax')) + }); +} ); + + +var kanban = (function ($) { + var kanbancount = $('.s-g-container').length + var initialized = false; + /* get model */ + + return { + initialize: function ( parentID,dropitemajax,dropgroupajax) { + + var drakeItems = null; + var drakeGroups = null; + var lastItemsData = []; + kanbancount -= 1; + + if (initialized){ + return; + } + initialized = kanbancount == 0 ? true:false; + var parent = $( parentID); + let tc$ = parent.find('.kb-group-container').parent(); + let viewInstance = tc$.tableModelView('instance'); + let model = tc$.tableModelView('getModel'); + + //model.setOption('editable',true) + + function relocate(itemsToFind,sourceItemIndex){ + parent = $( parentID); + $(parentID).find(itemsToFind?itemsToFind:'[relocationneed]').each(function(){ + var $itemContainer = $(this); + + var colId = $itemContainer.attr('datastatus'); + var dataid = $itemContainer.attr('data-id'); + + var groupid = null; + + + if(colId){ + var $group; + /* Not needed because model.setRecord using instead of overwrite behaviour */ + /*var cardData = lastItemsData.filter(function(e) { + return e.id == dataid + }); + if(cardData?.length > 0 ){ + colId = cardData[0].status; + groupid = cardData[0].groupid; + $group = parent.find('[data-group-id="'+groupid+'"]'); + } + else{ + $group = $itemContainer.closest('.reportgroup'); + } */ + + var dataGroupId = model.getRecordValue(dataid,'APEX$CONTROL_BREAK_VALUE') + $group = parent.find('[data-group-id='+dataGroupId+']') + var $targetRegion = ($group && $group.length) + ? $group.find('.kb-item-container[datastatus="' + colId + '"]') + : parent.find('.kb-item-container[datastatus="' + colId + '"]'); + + if($targetRegion.length){ + + var $children = $targetRegion.children(); + if ($children.length > sourceItemIndex) { + $itemContainer.insertBefore($children.eq(sourceItemIndex)); + } else { + $targetRegion.append($itemContainer); + } + + + + var cardicon = $(parentID).find('[parentheaderid="'+colId+'"]').attr('card-icon'); + var cardcolor = $(parentID).find('[parentheaderid="'+colId+'"]').attr('card-icon-color'); + + var $icon = $(this).find('.card-header > i'); + + if (!$icon.hasClass('specific_icon')) { + $icon.addClass(cardicon); + } + + var $cardHeader = $(this).find('.card-header'); + + if (!$cardHeader.hasClass('specific_color')) { + $cardHeader.css('background', cardcolor); + } + + $itemContainer.removeAttr('relocationneed') + $itemContainer.css('display', ''); + } + } + + }); + + } + + /* model.subscribe( { + onChange: function( changeType, change ) { + console.log(changeType,change) + relocate() + }, + } ); */ + + relocate(); + + addDragulaToItems(); + addDragulaToGroups(); + $(parentID).on( "tablemodelviewpagechange", function( event, data ) { + relocate(); + if (drakeItems) { + drakeItems.destroy(); + } + if (drakeGroups) { + drakeGroups.destroy(); + } + addDragulaToItems(); + addDragulaToGroups(); + + } ); + + function addDragulaToItems() { + + var sourceItemIndex = 0; + var sourceItemSibling = null; + drakeItems = dragula($(parent.find('.kb-item-container')).toArray(), { + direction: 'vertical', + revertOnSpill: true, + accepts: function (el, target, source, sibling) { + //if (configJSON.allowDragItemsBetweenGroups) { + return true; + //} + return $(source).closest('.kb-row').attr("data-group-id") == $(target).closest('.kb-row').attr("data-group-id"); + } + }); + $(parent).find('.kb-items').each(function() { + var dataId = $(this).attr('data-id'); + var status = $(this).attr('datastatus'); + var groupid = $(this).closest('.reportgroup').attr('data-group-id'); + // If id not exist in lastItemsData then add + if (dataId && !lastItemsData?.some(item => item.id === dataId)) { + lastItemsData.push({ + "id": dataId, + "status": status, + "groupid":groupid + }); + } + }); + + + var containers = Array.from(document.querySelectorAll('.kb-item-container')); + var scroll = autoScroll( + [window].concat(containers), + { + maxSpeed: 15, + margin: 150, + pixels: 7, + scrollWhenOutside: true, + autoScroll: function(){ + return this.down && drakeItems.dragging; + } + } + ); + + /* + On mobile this prevents the default page scrolling while dragging an item. + https://github.com/bevacqua/dragula/issues/487 + */ + parent.find(".kb-group-container").on('click', '.kb-collapsable', function(event) { + console.log($(this).parent().find(".card-footer")) + toggleGroup($(this).parent(), true); + }); + parent.find('.kb-item-container').on('touchmove', '.kb-items', function(event) { + event.preventDefault(); + }); + + drakeItems.on("drag", function (el, source) { + var _el = $(el); + var _source = $(source); + + sourceItemIndex = _el.index(); + var next = _el.next(); + sourceItemSibling = next.length > 0 ? $(next[0]) : null; + + var cardData = lastItemsData.filter(function(e) { + + return e.id == _el.attr("data-id") + }); + + if(cardData.length == 0){ + apex.message.clearErrors(); + apex.message.showErrors( [ + { + type: "error", + location: [ "page"], + message: apex.lang.getMessage('SYSTEM_MANIPULATION_DETECTED'), + unsafe: false + } + ] ); + $(parent[0]).remove(); + return; + } + + var dragData = { + "itemId": _el.attr("data-id"), + "sourceGroupId": _source.closest('.kb-row').attr("data-group-id"), + "sourceColumnId": _source.attr("datastatus"), + "sourceItemIndex": sourceItemIndex + }; + parent.trigger('kanbandrag', [dragData]); + }); + drakeItems.on("drop", function (el, target, source, sibling) { + var _el = $(el); + var _target = $(target); + var _source = $(source); + + var dropData = { + "itemId": _el.attr("data-id"), + "sourceGroupId": _source.closest('.kb-row').attr("data-group-id"), + "sourceColumnId": _source.attr("datastatus"), + "sourceItemIndex": sourceItemIndex, + "targetGroupId": _target.closest('.kb-row').attr("data-group-id"), + "targetColumnId": _target.attr("datastatus"), + "targetItemIndex": _el.index() + }; + + var cardData = lastItemsData.filter(function(e) { + return e.id == _el.attr("data-id") + }); + + if(cardData.length == 0){ + apex.message.clearErrors(); + apex.message.showErrors( [ + { + type: "error", + location: [ "page"], + message: apex.lang.getMessage('SYSTEM_MANIPULATION_DETECTED'), + unsafe: false + } + ] ); + $(parent[0]).remove(); + return; + } + + /* console.log("moved item " + + dropData.itemId + " from " + + dropData.sourceGroupId + "/" + + dropData.sourceColumnId + "/" + + dropData.sourceItemIndex + " to " + + dropData.targetGroupId + "/" + + dropData.targetColumnId + "/" + + dropData.targetItemIndex + ); */ + if(dropitemajax){ + try { + apex.server.process(dropitemajax, + { + x01: dropData.itemId, + x02: dropData.sourceGroupId, + x03: dropData.sourceColumnId, + x04: dropData.sourceItemIndex, + x05: dropData.targetGroupId, + x06: dropData.targetColumnId, + x07: dropData.targetItemIndex + }, { + success: function (d) { + if(d.success){ + parent.trigger('kanbanafterdrop', [dropData]); + } + else{ + /* if (sourceItemSibling) { + _el.insertBefore(sourceItemSibling); + } else { + _source.append(_el); + } */ + + updateCardHeader(_el, dropData,true); + relocate('[data-id='+dropData.itemId+']',sourceItemIndex); + dropData.sqlcode = d.sqlcode; + parent.trigger('kanbandroperror', [dropData]); + } + /* model.addChangesToSaveRequest(model.getChanges()); + model.save(); */ + }, + error: function (d) { + /* if (sourceItemSibling) { + _el.insertBefore(sourceItemSibling); + } else { + _source.append(_el); + } */ + updateCardHeader(_source, dropData,true); + relocate('[data-id='+dropData.itemId+']',sourceItemIndex); + parent.trigger('kanbandroperror', [dropData]); + }, + dataType: "json" + }); + } catch (e) { + } + } + + updateCardHeader(_el, dropData); + + parent.trigger('kanbandrop', [dropData]); + + }); + } + + function updateCardHeader(_card,dropData,err) { + + var new_groupid = dropData.targetGroupId; + var sourceGroupId = dropData.sourceGroupId; + var cardid = dropData.itemId; + + var groupid + var new_status; + + if (err){ + new_status = dropData.sourceColumnId; + groupid = dropData.sourceGroupId; + } else{ + groupid = dropData.targetGroupId; + new_status = dropData.targetColumnId; + } + + var cardicon = $(parentID).find('[parentheaderid="'+new_status+'"]').attr('card-icon'); + var cardcolor = $(parentID).find('[parentheaderid="'+new_status+'"]').attr('card-icon-color'); + var $cardHeader = _card.find('.card-header'); + var $iconElement = $cardHeader.find('i'); + + _card.attr('datastatus', new_status); + + if (!$iconElement.hasClass('specific_icon')) { + $iconElement.attr('class', ''); + $iconElement.addClass('fa ' + cardicon); + } + + if (!$cardHeader.hasClass('specific_color')) { + $cardHeader.css('background', cardcolor); + } + + _card.removeClass('gu-transit'); + _card.attr('relocationneed','') + var cardid = dropData.itemId; + var modelnewvalue = _card[0].outerHTML; + + /* Update model in order to keep changes for pagination changes. + Also, if ajax defined and user trying to refresh the page before saving finished, + then user gets page unsaved browser warning as default apex behaviour. + */ + + model.setOption('editable',true) + model.setRecordValue(cardid,'APEX$ROW_CONTENT',modelnewvalue); + sourceGroupId != new_groupid? + model.setRecordValue(cardid,'APEX$CONTROL_BREAK_VALUE',groupid):null; + model.setOption('editable',false) + model.clearChanges() + + //console.log(model.getChanges()) + //console.log(model.getRecord(cardid)) + + + lastItemsData.forEach(function(e) { + if (e.id == cardid) { + e.status = new_status; // example "IN_PROGRESS" + e.groupid = new_groupid; + } + }); + + + } + + + function addDragulaToGroups() { + + var sourceItemIndex = 0; + var sourceItemSibling = null; + + drakeGroups = dragula($(parent.find('.kb-group-container')).toArray(), { + direction: 'vertical', + revertOnSpill: true, + moves: function (el, container, handle) { + var groupcard = $(handle).closest('.kb-group-card'); + return groupcard.length > 0; + } + }); + + var containers = Array.from(document.querySelectorAll('.kb-group-container')); + var scroll = autoScroll( + [window].concat(containers), + { + maxSpeed: 15, + margin: 150, + pixels: 7, + scrollWhenOutside: true, + autoScroll: function(){ + return this.down && drakeGroups.dragging; + } + } + ); + /* + On mobile this prevents the default page scrolling while dragging an item. + https://github.com/bevacqua/dragula/issues/487 + */ + $('.kb-group-region > .kb-card').each(function (index, card) { + /* $(card).addClass("kb-card-draggable"); */ + card.addEventListener('touchmove', function (event) { + event.preventDefault(); + }); + }); + + + drakeGroups.on("drag", function (el, source) { + var _el = $(el); + sourceItemIndex = _el.index(); + var next = _el.next(); + sourceItemSibling = next.length > 0 ? $(next[0]) : null; + + var dragData = { + "groupId": _el.attr("data-group-id"), + "sourceGroupIndex": sourceItemIndex + }; + + /* + console.log("drag group " + + dragData.groupId + " from " + + dragData.sourceGroupIndex + ); + */ + + parent.trigger('kanbandraggroup', [dragData]); + }); + drakeGroups.on("drop", function (el, target, source, sibling) { + var _el = $(el); + var _target = $(target); + var _source = $(source); + + var dropData = { + "groupId": _el.attr("data-group-id"), + "sourceGroupIndex": sourceItemIndex, + "targetGroupIndex": _el.index() + }; + + /* + console.log("moved group " + + dropData.groupId + " from " + + dropData.sourceGroupIndex + " to " + + dropData.targetGroupIndex + ); + */ + if(dropgroupajax){ + try { + apex.server.process(dropgroupajax, + { + x01: dropData.groupId, + x02: dropData.sourceGroupIndex, + x03: dropData.targetGroupIndex + }, { + success: function (d) { + /*console.log(d);*/ + if(!d.success){ + if (sourceItemSibling) { + _el.insertBefore(sourceItemSibling); + } else { + _source.append(_el); + } + //console.error(d.responseText); + dropData.sqlcode = d.sqlcode; + parent.trigger('kanbandropgrouperror', [dropData]); + } + else{ + parent.trigger('kanbanafterdropgroup', [dropData]); + } + }, + error: function (d) { + /* move item back to last known position */ + if (sourceItemSibling) { + _el.insertBefore(sourceItemSibling); + } else { + _source.append(_el); + } + parent.trigger('kanbandropgrouperror', [dropData]); + }, + dataType: "json" + }); + } catch (e) { + } + } + parent.trigger('kanbandropgroup', [dropData]); + }); + } + + + + /* parent.find(".kb-group-card > .kb-collapsable").click(function () { + console.log(this) + toggleGroup(this, true); + }); */ + + function toggleGroup(groupRow, triggerEvent) { + groupRow.find(".kb-collapsable").toggle(); + groupRow.find(".card-footer").toggle(); + groupRow.parent().parent().find(".kb-item-region").toggle(); + var group = groupRow.parent(); + group.toggleClass("kb-collapsed"); + + if (triggerEvent) { + var collapsedData = { + "groupId": groupRow.attr("data-group-id"), + "collapsed": group.hasClass("kb-collapsed") + }; + parent.trigger('kanbangroupcollapsed', [collapsedData]); + } + } + } + } +})(apex.jQuery); \ No newline at end of file diff --git a/plugin_files/script.min.js b/plugin_files/script.min.js new file mode 100644 index 0000000..8c0c4f1 --- /dev/null +++ b/plugin_files/script.min.js @@ -0,0 +1 @@ +apex.jQuery(apex.gPageContext$).on("apexreadyend",(function(r){$(".s-g-container").each((function(){kanban.initialize("#"+this.id,this.getAttribute("dropitemajax"),this.getAttribute("dropgroupajax"))}))}));var kanban=function(r){var e=r(".s-g-container").length,t=!1;return{initialize:function(a,n,o){var i=null,d=null,s=[];if(e-=1,t)return;t=0==e;var c=r(a);let u=c.find(".kb-group-container").parent(),l=(u.tableModelView("instance"),u.tableModelView("getModel"));function g(e,t){c=r(a),r(a).find(e||"[relocationneed]").each((function(){var e=r(this),n=e.attr("datastatus"),o=e.attr("data-id");if(n){var i,d=l.getRecordValue(o,"APEX$CONTROL_BREAK_VALUE"),s=(i=c.find("[data-group-id="+d+"]"))&&i.length?i.find('.kb-item-container[datastatus="'+n+'"]'):c.find('.kb-item-container[datastatus="'+n+'"]');if(s.length){var u=s.children();u.length>t?e.insertBefore(u.eq(t)):s.append(e);var g=r(a).find('[parentheaderid="'+n+'"]').attr("card-icon"),p=r(a).find('[parentheaderid="'+n+'"]').attr("card-icon-color"),f=r(this).find(".card-header > i");f.hasClass("specific_icon")||f.addClass(g);var h=r(this).find(".card-header");h.hasClass("specific_color")||h.css("background",p),e.removeAttr("relocationneed"),e.css("display","")}}}))}function p(){var e=0;i=dragula(r(c.find(".kb-item-container")).toArray(),{direction:"vertical",revertOnSpill:!0,accepts:function(r,e,t,a){return!0}}),r(c).find(".kb-items").each((function(){var e=r(this).attr("data-id"),t=r(this).attr("datastatus"),a=r(this).closest(".reportgroup").attr("data-group-id");e&&!s?.some((r=>r.id===e))&&s.push({id:e,status:t,groupid:a})}));var t=Array.from(document.querySelectorAll(".kb-item-container"));autoScroll([window].concat(t),{maxSpeed:15,margin:150,pixels:7,scrollWhenOutside:!0,autoScroll:function(){return this.down&&i.dragging}});c.find(".kb-group-container").on("click",".kb-collapsable",(function(e){console.log(r(this).parent().find(".card-footer")),function(r,e){r.find(".kb-collapsable").toggle(),r.find(".card-footer").toggle(),r.parent().parent().find(".kb-item-region").toggle();var t=r.parent();if(t.toggleClass("kb-collapsed"),e){var a={groupId:r.attr("data-group-id"),collapsed:t.hasClass("kb-collapsed")};c.trigger("kanbangroupcollapsed",[a])}}(r(this).parent(),!0)})),c.find(".kb-item-container").on("touchmove",".kb-items",(function(r){r.preventDefault()})),i.on("drag",(function(t,a){var n=r(t),o=r(a);e=n.index();var i=n.next();if(i.length>0?r(i[0]):null,0==s.filter((function(r){return r.id==n.attr("data-id")})).length)return apex.message.clearErrors(),apex.message.showErrors([{type:"error",location:["page"],message:apex.lang.getMessage("SYSTEM_MANIPULATION_DETECTED"),unsafe:!1}]),void r(c[0]).remove();var d={itemId:n.attr("data-id"),sourceGroupId:o.closest(".kb-row").attr("data-group-id"),sourceColumnId:o.attr("datastatus"),sourceItemIndex:e};c.trigger("kanbandrag",[d])})),i.on("drop",(function(t,a,o,i){var d=r(t),u=r(a),l=r(o),p={itemId:d.attr("data-id"),sourceGroupId:l.closest(".kb-row").attr("data-group-id"),sourceColumnId:l.attr("datastatus"),sourceItemIndex:e,targetGroupId:u.closest(".kb-row").attr("data-group-id"),targetColumnId:u.attr("datastatus"),targetItemIndex:d.index()};if(0==s.filter((function(r){return r.id==d.attr("data-id")})).length)return apex.message.clearErrors(),apex.message.showErrors([{type:"error",location:["page"],message:apex.lang.getMessage("SYSTEM_MANIPULATION_DETECTED"),unsafe:!1}]),void r(c[0]).remove();if(n)try{apex.server.process(n,{x01:p.itemId,x02:p.sourceGroupId,x03:p.sourceColumnId,x04:p.sourceItemIndex,x05:p.targetGroupId,x06:p.targetColumnId,x07:p.targetItemIndex},{success:function(r){r.success?c.trigger("kanbanafterdrop",[p]):(f(d,p,!0),g("[data-id="+p.itemId+"]",e),p.sqlcode=r.sqlcode,c.trigger("kanbandroperror",[p]))},error:function(r){f(l,p,!0),g("[data-id="+p.itemId+"]",e),c.trigger("kanbandroperror",[p])},dataType:"json"})}catch(r){}f(d,p),c.trigger("kanbandrop",[p])}))}function f(e,t,n){var o,i,d=t.targetGroupId,c=t.sourceGroupId,u=t.itemId;n?(i=t.sourceColumnId,o=t.sourceGroupId):(o=t.targetGroupId,i=t.targetColumnId);var g=r(a).find('[parentheaderid="'+i+'"]').attr("card-icon"),p=r(a).find('[parentheaderid="'+i+'"]').attr("card-icon-color"),f=e.find(".card-header"),h=f.find("i");e.attr("datastatus",i),h.hasClass("specific_icon")||(h.attr("class",""),h.addClass("fa "+g)),f.hasClass("specific_color")||f.css("background",p),e.removeClass("gu-transit"),e.attr("relocationneed","");u=t.itemId;var m=e[0].outerHTML;l.setOption("editable",!0),l.setRecordValue(u,"APEX$ROW_CONTENT",m),c!=d&&l.setRecordValue(u,"APEX$CONTROL_BREAK_VALUE",o),l.setOption("editable",!1),l.clearChanges(),s.forEach((function(r){r.id==u&&(r.status=i,r.groupid=d)}))}function h(){var e=0,t=null;d=dragula(r(c.find(".kb-group-container")).toArray(),{direction:"vertical",revertOnSpill:!0,moves:function(e,t,a){return r(a).closest(".kb-group-card").length>0}});var a=Array.from(document.querySelectorAll(".kb-group-container"));autoScroll([window].concat(a),{maxSpeed:15,margin:150,pixels:7,scrollWhenOutside:!0,autoScroll:function(){return this.down&&d.dragging}});r(".kb-group-region > .kb-card").each((function(r,e){e.addEventListener("touchmove",(function(r){r.preventDefault()}))})),d.on("drag",(function(a,n){var o=r(a);e=o.index();var i=o.next();t=i.length>0?r(i[0]):null;var d={groupId:o.attr("data-group-id"),sourceGroupIndex:e};c.trigger("kanbandraggroup",[d])})),d.on("drop",(function(a,n,i,d){var s=r(a),u=(r(n),r(i)),l={groupId:s.attr("data-group-id"),sourceGroupIndex:e,targetGroupIndex:s.index()};if(o)try{apex.server.process(o,{x01:l.groupId,x02:l.sourceGroupIndex,x03:l.targetGroupIndex},{success:function(r){r.success?c.trigger("kanbanafterdropgroup",[l]):(t?s.insertBefore(t):u.append(s),l.sqlcode=r.sqlcode,c.trigger("kanbandropgrouperror",[l]))},error:function(r){t?s.insertBefore(t):u.append(s),c.trigger("kanbandropgrouperror",[l])},dataType:"json"})}catch(r){}c.trigger("kanbandropgroup",[l])}))}g(),p(),h(),r(a).on("tablemodelviewpagechange",(function(r,e){g(),i&&i.destroy(),d&&d.destroy(),p(),h()}))}}}(apex.jQuery); \ No newline at end of file diff --git a/plugin_files/style.css b/plugin_files/style.css new file mode 100644 index 0000000..55aa4b3 --- /dev/null +++ b/plugin_files/style.css @@ -0,0 +1,331 @@ +.ct-loader { + position: absolute; + top: 70px; + width: 100%; + z-index: 1; + text-align: center; +} + +.kb-col { + display: inline-block; + position: relative; + width: 100%; + vertical-align: top; + border-radius: 5px; + border: 3px solid var(--ut-component-highlight-background-color); +} + +.kb-col-content { + height: 100%; + width: 100%; +} + +.kb-col-header {} + +.kb-col-header-content { + border-radius: 5px; + border-top: 5px solid #AAA; + height: 30px; + margin: 5px 5px 0px 5px; +} + +.kb-col-header-content .title { + position: relative; + left: 15px; + font-size: 1.3em; +} + +.card-title{ + /* text-overflow: ellipsis; + white-space: nowrap; + overflow: hidden; + max-width: 75px; */ +} + +.kb-col-inner-header { + display: none; +} + +.kb-col-inner-header .title { + position: relative; + font-size: 1.3em; + margin: 5px 10px 0px 10px; +} + +.kb-row { + display: -ms-flex; + display: -webkit-flex; + display: flex; +} + +.kb-item-region { + background: var(--ut-component-background-color); + min-height: 160px; +} + +.kb-group-region {} + +.kb-card { + + display: inline-block; + width: 100%; + + /* box-shadow: 0 1px 4px 0 rgba(0, 0, 0, 0.44); */ + border-radius: 1px; + /* color: rgba(0, 0, 0, 0.87); */ + transition: all 0.4s ease; + + /* background: var(--ut-component-badge-background-color); */ + background-color:var(--ut-component-inner-border-color); + box-shadow:var(--ut-shadow-sm); + margin: 0; + position: relative; + overflow: hidden; +} + +.kb-card-draggable { + cursor: grab; +} + +.kb-card:hover { + background: var(--ut-component-highlight-background-color); + box-shadow: 0 10px 20px rgba(0, 0, 0, 0.19), 0 6px 6px rgba(0, 0, 0, 0.23); +} + +.kb-card .card-header { + float: left; + text-align: center; + margin: 6px 0px 6px 6px; + box-shadow: 0 12px 20px -10px rgba(230, 230, 230, 0.28), 0 4px 20px 0px rgba(0, 0, 0, 0.12), 0 7px 8px -5px rgba(230, 230, 230, 0.2); + transition: all 1.0s ease; +} + +.kb-card .card-header i { + font-size: 18px; + line-height: 28px; + width: 28px; + height: 28px; + color: white; + transition: all 1.0s ease; +} + +.kb-card .card-content { + text-align: left; + padding: 0 6px; + overflow: hidden; + min-height: 40px; + /* display: table; */ + display: flex; + align-items: center; + /* overflow-wrap: anywhere; */ +} + +.kb-card .title { + font-size: 1em; + /* display: table-cell; */ + vertical-align: middle; + display: flex; + align-items: center; + overflow-wrap: anywhere; + +} + +.kb-card .card-footer { + margin: 0 20px 6px; + padding-top: 3px; + border-top: 1px solid #eeeeee; + color: var(--ut-component-text-muted-color); + overflow-wrap: anywhere; +} + +.kb-card .card-footer > div { + display: inline-block; + width: 100%; +} + +.kb-new-item-region { + clear: both; +} + +.kb-item-container { + height: 100%; + min-height: 10px; + padding: 5px; + max-height: 520px; + overflow: auto; + +} + +.kb-item-container .kb-card { + float: left; + margin: 5px 5px; + min-height: 0.125rem; + width: calc(100% - 10px); + max-width: 200px; +} + +.kb-item-container-with-new-card { + height: calc(100% - 40px); + +} + +.kb-new-card { + float: left; + text-align: center; + margin: 3px 10px 10px 10px; + transition: all 0.3s cubic-bezier(.25, .8, .25, 1); + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.12), 0 1px 2px rgba(0, 0, 0, 0.24); + background: #55c555; +} + +.kb-new-card:hover { + box-shadow: 0 10px 20px rgba(0, 0, 0, 0.19), 0 6px 6px rgba(0, 0, 0, 0.23); +} + +.kb-new-card i { + font-size: 18px; + line-height: 28px; + width: 28px; + height: 28px; + color: white; +} + +.kb-group-region .card-header { + background: #39a6da; +} + +.kb-collapsable { + float: left; + text-align: center; + margin: 6px 1px 6px 7px; + cursor: pointer; +} + +.kb-collapsable i { + font-size: 15px; + line-height: 28px; + width: 18px; + /*height: 28px;*/ + color: #000; +} + +.kb-collapsable:hover { + margin: 5px 0px 5px 6px; + border: 1px solid #eee; +} + +.kb-collapsed { + width: 100% !important; +} + +/* +@media only screen and (max-width: 1279px) { + + .kb-item-region, + .kb-group-region, + .kb-col-header { + width: 100% !important; + } + + .kb-card { + max-width: none !important; + } +} +*/ + +@media only screen and (max-width: 1200px) { + .kb-row { + display: -ms-inline-box; + display: -webkit-inline-box; + display: inline-block; + } + + .kb-col-header { + display: none; + } + + .kb-item-region, + .kb-group-region, + .kb-col-header { + width: 100% !important; + } + + /* .kb-card { + max-width: 200px !important; + } */ + + .kb-item-container { + height: 100%; + min-height: 10px; + padding: 5px; + max-height: 320px; + overflow: auto; + + } + + .kb-item-region { + display: -ms-flex; + display: -webkit-flex; + display: flex; + } + + .kb-col-content { + border-radius: 5px; + border-left: 5px solid #AAA; + } + + .kb-col-inner-header { + display: inline-block; + } + + .kb-group-region { + border: none; + } + + .kb-group-region > div { + margin: 3px !important; + width: calc(100% - 6px); + border-radius: 5px; + /* border-top: 5px solid #aaa; + border-left: 5px solid #aaa; */ + } + + .kb-new-group-region > div { + border-top: none; + } + + .kb-group-region .kb-card { + display: inherit; + } + + .kb-row::after { + margin-bottom: 20px; + } +} + +/* Dragula CSS */ +.gu-mirror { + position: fixed !important; + margin: 0 !important; + z-index: 9999 !important; + opacity: 0.8; + -ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)"; + filter: alpha(opacity=80); +} + +.gu-hide { + display: none !important; +} + +.gu-unselectable { + -webkit-user-select: none !important; + -moz-user-select: none !important; + -ms-user-select: none !important; + user-select: none !important; +} + +.gu-transit { + opacity: 0.2; + -ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=20)"; + filter: alpha(opacity=20); +} diff --git a/plugin_files/style.min.css b/plugin_files/style.min.css new file mode 100644 index 0000000..df44c0a --- /dev/null +++ b/plugin_files/style.min.css @@ -0,0 +1,10 @@ +.ct-loader {position: absolute;top: 70px;width: 100%;z-index: 1;text-align: center;}.kb-col {display: inline-block;position: relative;width: 100%;vertical-align: top;border-radius: 5px;border: 3px solid var(--ut-component-highlight-background-color);}.kb-col-content {height: 100%;width: 100%;}.kb-col-header {}.kb-col-header-content {border-radius: 5px;border-top: 5px solid #AAA;height: 30px;margin: 5px 5px 0px 5px;}.kb-col-header-content .title {position: relative;left: 15px;font-size: 1.3em;}.card-title{}.kb-col-inner-header {display: none;}.kb-col-inner-header .title {position: relative;font-size: 1.3em;margin: 5px 10px 0px 10px;}.kb-row {display: -ms-flex;display: -webkit-flex;display: flex;}.kb-item-region {background: var(--ut-component-background-color);min-height: 160px;}.kb-group-region {}.kb-card {display: inline-block;width: 100%; border-radius: 1px; transition: all 0.4s ease; background-color:var(--ut-component-inner-border-color);box-shadow:var(--ut-shadow-sm);margin: 0;position: relative;overflow: hidden;}.kb-card-draggable {cursor: grab;}.kb-card:hover {background: var(--ut-component-highlight-background-color);box-shadow: 0 10px 20px rgba(0, 0, 0, 0.19), 0 6px 6px rgba(0, 0, 0, 0.23);}.kb-card .card-header {float: left;text-align: center;margin: 6px 0px 6px 6px;box-shadow: 0 12px 20px -10px rgba(230, 230, 230, 0.28), 0 4px 20px 0px rgba(0, 0, 0, 0.12), 0 7px 8px -5px rgba(230, 230, 230, 0.2);transition: all 1.0s ease;}.kb-card .card-header i {font-size: 18px;line-height: 28px;width: 28px;height: 28px;color: white;transition: all 1.0s ease;}.kb-card .card-content {text-align: left;padding: 0 6px;overflow: hidden;min-height: 40px; display: flex;align-items: center;}.kb-card .title {font-size: 1em; vertical-align: middle;display: flex;align-items: center;overflow-wrap: anywhere;}.kb-card .card-footer {margin: 0 20px 6px;padding-top: 3px;border-top: 1px solid #eeeeee;color: var(--ut-component-text-muted-color);overflow-wrap: anywhere;}.kb-card .card-footer > div {display: inline-block;width: 100%;}.kb-new-item-region {clear: both;}.kb-item-container {height: 100%;min-height: 10px;padding: 5px;max-height: 520px;overflow: auto;}.kb-item-container .kb-card {float: left;margin: 5px 5px;min-height: 0.125rem;width: calc(100% - 10px);max-width: 200px;}.kb-item-container-with-new-card {height: calc(100% - 40px);}.kb-new-card {float: left;text-align: center;margin: 3px 10px 10px 10px;transition: all 0.3s cubic-bezier(.25, .8, .25, 1);box-shadow: 0 1px 3px rgba(0, 0, 0, 0.12), 0 1px 2px rgba(0, 0, 0, 0.24);background: #55c555;}.kb-new-card:hover {box-shadow: 0 10px 20px rgba(0, 0, 0, 0.19), 0 6px 6px rgba(0, 0, 0, 0.23);}.kb-new-card i {font-size: 18px;line-height: 28px;width: 28px;height: 28px;color: white;}.kb-group-region .card-header {background: #39a6da;}.kb-collapsable {float: left;text-align: center;margin: 6px 1px 6px 7px;cursor: pointer;}.kb-collapsable i {font-size: 15px;line-height: 28px;width: 18px; color: #000;}.kb-collapsable:hover {margin: 5px 0px 5px 6px;border: 1px solid #eee;}.kb-collapsed {width: 100% !important;}/* +@media only screen and (max-width: 1279px) {.kb-item-region, +.kb-group-region, +.kb-col-header {width: 100% !important;}.kb-card {max-width: none !important;}}*/ + +@media only screen and (max-width: 1200px) {.kb-row {display: -ms-inline-box;display: -webkit-inline-box;display: inline-block;}.kb-col-header {display: none;}.kb-item-region, +.kb-group-region, +.kb-col-header {width: 100% !important;}/* .kb-card {max-width: 200px !important;} */ + +.kb-item-container {height: 100%;min-height: 10px;padding: 5px;max-height: 320px;overflow: auto; }.kb-item-region {display: -ms-flex;display: -webkit-flex;display: flex;}.kb-col-content {border-radius: 5px;border-left: 5px solid #AAA;}.kb-col-inner-header {display: inline-block;}.kb-group-region {border: none;}.kb-group-region > div {margin: 3px !important;width: calc(100% - 6px);border-radius: 5px; }.kb-new-group-region > div {border-top: none;}.kb-group-region .kb-card {display: inherit;}.kb-row::after {margin-bottom: 20px;}}.gu-mirror {position: fixed !important;margin: 0 !important;z-index: 9999 !important;opacity: 0.8;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=80)";filter: alpha(opacity=80);}.gu-hide {display: none !important;}.gu-unselectable {-webkit-user-select: none !important;-moz-user-select: none !important;-ms-user-select: none !important;user-select: none !important;}.gu-transit {opacity: 0.2;-ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=20)";filter: alpha(opacity=20);} \ No newline at end of file