/*!
 * awe-dnd v0.3.2
 * (c) 2018 awe <hilongjw@gmail.com>
 * released under the mit license.
 */
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global.vuedragging = factory());
}(this, (function () { 'use strict';

var _createclass = function () { function defineproperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; object.defineproperty(target, descriptor.key, descriptor); } } return function (constructor, protoprops, staticprops) { if (protoprops) defineproperties(constructor.prototype, protoprops); if (staticprops) defineproperties(constructor, staticprops); return constructor; }; }();

function _toconsumablearray(arr) { if (array.isarray(arr)) { for (var i = 0, arr2 = array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return array.from(arr); } }

function _classcallcheck(instance, constructor) { if (!(instance instanceof constructor)) { throw new typeerror("cannot call a class as a function"); } }

var dragdata = function () {
    function dragdata() {
        _classcallcheck(this, dragdata);

        this.data = {};
    }

    _createclass(dragdata, [{
        key: 'new',
        value: function _new(key) {
            if (!this.data[key]) {
                this.data[key] = {
                    classname: '',
                    list: [],
                    key_map: {}
                };
            }
            return this.data[key];
        }
    }, {
        key: 'get',
        value: function get(key) {
            return this.data[key];
        }
    }]);

    return dragdata;
}();

var $dragging = {
    listeners: {},
    $on: function $on(event, func) {
        var events = this.listeners[event];
        if (!events) {
            this.listeners[event] = [];
        }
        this.listeners[event].push(func);
    },
    $once: function $once(event, func) {
        var vm = this;
        function on() {
            vm.$off(event, on);

            for (var _len = arguments.length, args = array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = arguments[_key];
            }

            func.apply(vm, args);
        }
        this.$on(event, on);
    },
    $off: function $off(event, func) {
        var events = this.listeners[event];
        if (!func || !events) {
            this.listeners[event] = [];
            return;
        }
        this.listeners[event] = this.listeners[event].filter(function (i) {
            return i !== func;
        });
    },
    $emit: function $emit(event, context) {
        var events = this.listeners[event];
        if (events && events.length > 0) {
            events.foreach(function (func) {
                func(context);
            });
        }
    }
};
var _ = {
    on: function on(el, type, fn) {
        el.addeventlistener(type, fn);
    },
    off: function off(el, type, fn) {
        el.removeeventlistener(type, fn);
    },
    addclass: function addclass(el, cls) {
        if (arguments.length < 2) {
            el.classlist.add(cls);
        } else {
            for (var i = 1, len = arguments.length; i < len; i++) {
                el.classlist.add(arguments[i]);
            }
        }
    },
    removeclass: function removeclass(el, cls) {
        if (arguments.length < 2) {
            el.classlist.remove(cls);
        } else {
            for (var i = 1, len = arguments.length; i < len; i++) {
                el.classlist.remove(arguments[i]);
            }
        }
    }
};

var vuedragging = function (vue, options) {
    var isprevue = vue.version.split('.')[0] === '1';
    var dragdata = new dragdata();
    var isswap = false;
    var current = null;

    function handledragstart(e) {
        var el = getblockel(e.target);
        var key = el.getattribute('drag_group');
        var drag_key = el.getattribute('drag_key');
        var comb = el.getattribute('comb');
        var ddd = dragdata.new(key);
        var item = ddd.key_map[drag_key];
        var index = ddd.list.indexof(item);
        var grouparr = ddd.list.filter(function (item) {
            return item[comb];
        });
        _.addclass(el, 'dragging');

        if (e.datatransfer) {
            e.datatransfer.effectallowed = 'move';
            e.datatransfer.setdata('text', json.stringify(item));
        }

        current = {
            index: index,
            item: item,
            el: el,
            group: key,
            grouparr: grouparr
        };
    }

    function handledragover(e) {
        if (e.preventdefault) {
            e.preventdefault();
        }
        return false;
    }

    function handledragenter(e) {
        var el = void 0;
        if (e.type === 'touchmove') {
            e.stoppropagation();
            e.preventdefault();
            el = getoverelementfromtouch(e);
            el = getblockel(el);
        } else {
            el = getblockel(e.target);
        }

        if (!el || !current) return;

        var key = el.getattribute('drag_group');
        if (key !== current.group || !current.el || !current.item || el === current.el) return;
        var drag_key = el.getattribute('drag_key');
        var ddd = dragdata.new(key);
        var item = ddd.key_map[drag_key];

        if (item === current.item) return;

        var indexto = ddd.list.indexof(item);
        var indexfrom = ddd.list.indexof(current.item);

        swaparrayelements(ddd.list, indexfrom, indexto);

        current.grouparr.foreach(function (item) {
            if (item != current.item) {
                ddd.list.splice(ddd.list.indexof(item), 1);
            }
        });

        var targetindex = ddd.list.indexof(current.item);
        if (current.grouparr.length) {
            var _ddd$list;

            (_ddd$list = ddd.list).splice.apply(_ddd$list, [targetindex, 1].concat(_toconsumablearray(current.grouparr)));
        }

        current.index = indexto;
        isswap = true;
        $dragging.$emit('dragged', {
            draged: current.item,
            to: item,
            value: ddd.value,
            group: key
        });
    }

    function handledragleave(e) {
        _.removeclass(getblockel(e.target), 'drag-over', 'drag-enter');
    }

    function handledrag(e) {}

    function handledragend(e) {
        var el = getblockel(e.target);
        _.removeclass(el, 'dragging', 'drag-over', 'drag-enter');
        current = null;
        // if (isswap) {
        isswap = false;
        var group = el.getattribute('drag_group');
        $dragging.$emit('dragend', { group: group });
        // }
    }

    function handledrop(e) {
        e.preventdefault();
        if (e.stoppropagation) {
            e.stoppropagation();
        }
        return false;
    }

    function getblockel(el) {
        if (!el) return;
        while (el.parentnode) {
            if (el.getattribute && el.getattribute('drag_block')) {
                return el;
                break;
            } else {
                el = el.parentnode;
            }
        }
    }

    function swaparrayelements(items, indexfrom, indexto) {
        var item = items[indexto];
        if (isprevue) {
            items.$set(indexto, items[indexfrom]);
            items.$set(indexfrom, item);
        } else {
            vue.set(items, indexto, items[indexfrom]);
            vue.set(items, indexfrom, item);
        }
        return items;
    }

    function getoverelementfromtouch(e) {
        var touch = e.touches[0];
        var el = document.elementfrompoint(touch.clientx, touch.clienty);
        return el;
    }

    function adddragitem(el, binding, vnode) {
        var item = binding.value.item;
        var list = binding.value.list;
        var ddd = dragdata.new(binding.value.group);

        var drag_key = isprevue ? binding.value.key : vnode.key;
        ddd.value = binding.value;
        ddd.classname = binding.value.classname;
        ddd.key_map[drag_key] = item;
        if (list && ddd.list !== list) {
            ddd.list = list;
        }
        el.setattribute('draggable', 'true');
        el.setattribute('drag_group', binding.value.group);
        el.setattribute('drag_block', binding.value.group);
        el.setattribute('drag_key', drag_key);
        el.setattribute('comb', binding.value.comb);

        _.on(el, 'dragstart', handledragstart);
        _.on(el, 'dragenter', handledragenter);
        _.on(el, 'dragover', handledragover);
        _.on(el, 'drag', handledrag);
        _.on(el, 'dragleave', handledragleave);
        _.on(el, 'dragend', handledragend);
        _.on(el, 'drop', handledrop);

        _.on(el, 'touchstart', handledragstart);
        _.on(el, 'touchmove', handledragenter);
        _.on(el, 'touchend', handledragend);
    }

    function removedragitem(el, binding, vnode) {
        var ddd = dragdata.new(binding.value.group);
        var drag_key = isprevue ? binding.value.key : vnode.key;
        ddd.key_map[drag_key] = undefined;
        _.off(el, 'dragstart', handledragstart);
        _.off(el, 'dragenter', handledragenter);
        _.off(el, 'dragover', handledragover);
        _.off(el, 'drag', handledrag);
        _.off(el, 'dragleave', handledragleave);
        _.off(el, 'dragend', handledragend);
        _.off(el, 'drop', handledrop);

        _.off(el, 'touchstart', handledragstart);
        _.off(el, 'touchmove', handledragenter);
        _.off(el, 'touchend', handledragend);
    }

    vue.prototype.$dragging = $dragging;
    if (!isprevue) {
        vue.directive('dragging', {
            bind: adddragitem,
            update: function update(el, binding, vnode) {
                var ddd = dragdata.new(binding.value.group);
                var item = binding.value.item;
                var list = binding.value.list;

                var drag_key = vnode.key;
                var old_item = ddd.key_map[drag_key];
                if (item && old_item !== item) {
                    ddd.key_map[drag_key] = item;
                }
                if (list && ddd.list !== list) {
                    ddd.list = list;
                }
            },

            unbind: removedragitem
        });
    } else {
        vue.directive('dragging', {
            update: function update(newvalue, oldvalue) {
                adddragitem(this.el, {
                    modifiers: this.modifiers,
                    arg: this.arg,
                    value: newvalue,
                    oldvalue: oldvalue
                });
            },
            unbind: function unbind(newvalue, oldvalue) {
                removedragitem(this.el, {
                    modifiers: this.modifiers,
                    arg: this.arg,
                    value: newvalue ? newvalue : { group: this.el.getattribute('drag_group') },
                    oldvalue: oldvalue
                });
            }
        });
    }
};
return vuedragging;

    })
));
document.ready(function () {
    document.body.ondrop = function (event) { event.preventdefault(); event.stoppropagation(); }
});

this.vuedragging(vue,this);//注册方法