jekyll-uikit 0.1.5 → 0.1.7

data/assets/node_modules/uikit/src/js/components/slideshow.js

@@ -0,0 +1,179 @@
+import Parallax from './parallax';
+import Slideshow from '../mixin/slideshow';
+import Animations from './internal/slideshow-animations';
+
+function plugin(UIkit) {
+
+    if (plugin.installed) {
+        return;
+    }
+
+    UIkit.use(Parallax);
+    UIkit.use(Slideshow);
+
+    var {mixin} = UIkit;
+    var {closest, css, fastdom, endsWith, height, noop, Transition} = UIkit.util;
+
+    UIkit.component('slideshow', {
+
+        mixins: [mixin.class, mixin.slideshow],
+
+        props: {
+            ratio: String,
+            minHeight: Boolean,
+            maxHeight: Boolean,
+        },
+
+        defaults: {
+            ratio: '16:9',
+            minHeight: false,
+            maxHeight: false,
+            selList: '.uk-slideshow-items',
+            attrItem: 'uk-slideshow-item',
+            Animations: Animations(UIkit)
+        },
+
+        ready() {
+            fastdom.write(() => this.show(this.index));
+        },
+
+        update: {
+
+            read() {
+
+                var [width, height] = this.ratio.split(':').map(Number);
+                this.height = height * this.$el.offsetWidth / width;
+
+                if (this.minHeight) {
+                    this.height = Math.max(this.minHeight, this.height);
+                }
+
+                if (this.maxHeight) {
+                    this.height = Math.min(this.maxHeight, this.height);
+                }
+
+            },
+
+            write() {
+                height(this.list, Math.floor(this.height));
+            },
+
+            events: ['load', 'resize']
+
+        }
+
+    });
+
+    UIkit.component('slideshow-parallax', {
+
+        mixins: [mixin.parallax],
+
+        computed: {
+
+            item() {
+                var slideshow = UIkit.getComponent(closest(this.$el, '.uk-slideshow'), 'slideshow');
+                return slideshow && closest(this.$el, `${slideshow.selList} > *`);
+            }
+
+        },
+
+        events: [
+
+            {
+
+                name: 'itemshown',
+
+                self: true,
+
+                el() {
+                    return this.item;
+                },
+
+                handler() {
+                    css(this.$el, this.getCss(.5));
+                }
+
+            },
+
+            {
+                name: 'itemin itemout',
+
+                self: true,
+
+                el() {
+                    return this.item;
+                },
+
+                handler({type, detail: {percent, duration, ease, dir}}) {
+
+                    Transition.cancel(this.$el);
+                    css(this.$el, this.getCss(getCurrent(type, dir, percent)));
+
+                    Transition.start(this.$el, this.getCss(isIn(type)
+                        ? .5
+                        : dir > 0
+                            ? 1
+                            : 0
+                    ), duration, ease).catch(noop);
+
+                }
+            },
+
+            {
+                name: 'transitioncanceled transitionend',
+
+                self: true,
+
+                el() {
+                    return this.item;
+                },
+
+                handler() {
+                    Transition.cancel(this.$el);
+                }
+
+            },
+
+            {
+                name: 'itemtranslatein itemtranslateout',
+
+                self: true,
+
+                el() {
+                    return this.item;
+                },
+
+                handler({type, detail: {percent, dir}}) {
+                    Transition.cancel(this.$el);
+                    css(this.$el, this.getCss(getCurrent(type, dir, percent)));
+                }
+            }
+
+        ]
+
+    });
+
+    function isIn(type) {
+        return endsWith(type, 'in');
+    }
+
+    function getCurrent(type, dir, percent) {
+
+        percent /= 2;
+
+        return !isIn(type)
+            ? dir < 0
+                ? percent
+                : 1 - percent
+            : dir < 0
+                ? 1 - percent
+                : percent;
+    }
+
+}
+
+if (!BUNDLED && typeof window !== 'undefined' && window.UIkit) {
+    window.UIkit.use(plugin);
+}
+
+export default plugin;

data/assets/node_modules/uikit/src/js/components/sortable.js

@@ -0,0 +1,333 @@
+function plugin(UIkit) {
+
+    if (plugin.installed) {
+        return;
+    }
+
+    var {mixin, util} = UIkit;
+    var {addClass, after, assign, append, attr, before, closest, css, doc, docEl, height, fastdom, getPos, includes, index, isInput, noop, offset, off, on, pointerDown, pointerMove, pointerUp, position, preventClick, Promise, remove, removeClass, toggleClass, toNodes, Transition, trigger, win, within} = util;
+
+    UIkit.component('sortable', {
+
+        mixins: [mixin.class],
+
+        props: {
+            group: String,
+            animation: Number,
+            threshold: Number,
+            clsItem: String,
+            clsPlaceholder: String,
+            clsDrag: String,
+            clsDragState: String,
+            clsBase: String,
+            clsNoDrag: String,
+            clsEmpty: String,
+            clsCustom: String,
+            handle: String
+        },
+
+        defaults: {
+            group: false,
+            animation: 150,
+            threshold: 5,
+            clsItem: 'uk-sortable-item',
+            clsPlaceholder: 'uk-sortable-placeholder',
+            clsDrag: 'uk-sortable-drag',
+            clsDragState: 'uk-drag',
+            clsBase: 'uk-sortable',
+            clsNoDrag: 'uk-sortable-nodrag',
+            clsEmpty: 'uk-sortable-empty',
+            clsCustom: '',
+            handle: false
+        },
+
+        init() {
+            ['init', 'start', 'move', 'end'].forEach(key => {
+                var fn = this[key];
+                this[key] = e => {
+                    this.scrollY = win.scrollY;
+                    var {x, y} = getPos(e);
+                    this.pos = {x, y};
+
+                    fn(e);
+                }
+            });
+        },
+
+        events: {
+
+            [pointerDown]: 'init'
+
+        },
+
+        update: {
+
+            write() {
+
+                if (this.clsEmpty) {
+                    toggleClass(this.$el, this.clsEmpty, !this.$el.children.length);
+                }
+
+                if (!this.drag) {
+                    return;
+                }
+
+                offset(this.drag, {top: this.pos.y + this.origin.top, left: this.pos.x + this.origin.left});
+
+                var top = offset(this.drag).top,
+                    bottom = top + this.drag.offsetHeight,
+                    scroll;
+
+                if (top > 0 && top < this.scrollY) {
+                    scroll = this.scrollY - 5;
+                } else if (bottom < height(doc) && bottom > height(win) + this.scrollY) {
+                    scroll = this.scrollY + 5;
+                }
+
+                scroll && setTimeout(() => win.scrollTo(win.scrollX, scroll), 5);
+            }
+
+        },
+
+        methods: {
+
+            init(e) {
+
+                var {target, button, defaultPrevented} = e,
+                    placeholder = toNodes(this.$el.children).filter(el => within(target, el))[0];
+
+                if (!placeholder
+                    || isInput(e.target)
+                    || this.handle && !within(target, this.handle)
+                    || button > 0
+                    || within(target, `.${this.clsNoDrag}`)
+                    || defaultPrevented
+                ) {
+                    return;
+                }
+
+                e.preventDefault();
+
+                this.touched = [this];
+                this.placeholder = placeholder;
+                this.origin = assign({target, index: index(placeholder)}, this.pos);
+
+                on(docEl, pointerMove, this.move);
+                on(docEl, pointerUp, this.end);
+                on(win, 'scroll', this.scroll);
+
+                if (!this.threshold) {
+                    this.start(e);
+                }
+
+            },
+
+            start(e) {
+
+                this.drag = append(UIkit.container, this.placeholder.outerHTML.replace(/^<li/i, '<div').replace(/li>$/i, 'div>'));
+
+                css(this.drag, assign({
+                    boxSizing: 'border-box',
+                    width: this.placeholder.offsetWidth,
+                    height: this.placeholder.offsetHeight
+                }, css(this.placeholder, ['paddingLeft', 'paddingRight', 'paddingTop', 'paddingBottom'])));
+                attr(this.drag, 'uk-no-boot', '');
+                addClass(this.drag, `${this.clsDrag} ${this.clsCustom}`);
+
+                height(this.drag.firstElementChild, height(this.placeholder.firstElementChild));
+
+                var {left, top} = offset(this.placeholder);
+                assign(this.origin, {left: left - this.pos.x, top: top - this.pos.y});
+
+                addClass(this.placeholder, this.clsPlaceholder);
+                addClass(this.$el.children, this.clsItem);
+                addClass(docEl, this.clsDragState);
+
+                trigger(this.$el, 'start', [this, this.placeholder, this.drag]);
+
+                this.move(e);
+            },
+
+            move(e) {
+
+                if (!this.drag) {
+
+                    if (Math.abs(this.pos.x - this.origin.x) > this.threshold || Math.abs(this.pos.y - this.origin.y) > this.threshold) {
+                        this.start(e);
+                    }
+
+                    return;
+                }
+
+                this.$emit();
+
+                var target = e.type === 'mousemove' ? e.target : doc.elementFromPoint(this.pos.x - doc.body.scrollLeft, this.pos.y - doc.body.scrollTop),
+                    sortable = getSortable(target),
+                    previous = getSortable(this.placeholder),
+                    move = sortable !== previous;
+
+                if (!sortable || within(target, this.placeholder) || move && (!sortable.group || sortable.group !== previous.group)) {
+                    return;
+                }
+
+                target = sortable.$el === target.parentNode && target || toNodes(sortable.$el.children).filter(element => within(target, element))[0];
+
+                if (move) {
+                    previous.remove(this.placeholder);
+                } else if (!target) {
+                    return;
+                }
+
+                sortable.insert(this.placeholder, target);
+
+                if (!includes(this.touched, sortable)) {
+                    this.touched.push(sortable);
+                }
+
+            },
+
+            scroll() {
+                var scroll = win.scrollY;
+                if (scroll !== this.scrollY) {
+                    this.pos.y += scroll - this.scrollY;
+                    this.scrollY = scroll;
+                    this.$emit();
+                }
+            },
+
+            end(e) {
+
+                off(docEl, pointerMove, this.move);
+                off(docEl, pointerUp, this.end);
+                off(win, 'scroll', this.scroll);
+
+                if (!this.drag) {
+
+                    if (e.type !== 'mouseup' && within(e.target, 'a[href]')) {
+                        location.href = closest(e.target, 'a[href]').href;
+                    }
+
+                    return;
+                }
+
+                preventClick();
+
+                var sortable = getSortable(this.placeholder);
+
+                if (this === sortable) {
+                    if (this.origin.index !== index(this.placeholder)) {
+                        trigger(this.$el, 'moved', [this, this.placeholder]);
+                    }
+                } else {
+                    trigger(sortable.$el, 'added', [sortable, this.placeholder]);
+                    trigger(this.$el, 'removed', [this, this.placeholder]);
+                }
+
+                trigger(this.$el, 'stop', [this]);
+
+                remove(this.drag);
+                this.drag = null;
+
+                var classes = this.touched.map(sortable => `${sortable.clsPlaceholder} ${sortable.clsItem}`).join(' ');
+                this.touched.forEach(sortable => removeClass(sortable.$el.children, classes));
+
+                removeClass(docEl, this.clsDragState);
+
+            },
+
+            insert(element, target) {
+
+                addClass(this.$el.children, this.clsItem);
+
+                var insert = () => {
+
+                    if (target) {
+
+                        if (!within(element, this.$el) || isPredecessor(element, target)) {
+                            before(target, element);
+                        } else {
+                            after(target, element);
+                        }
+
+                    } else {
+                        append(this.$el, element);
+                    }
+
+                };
+
+                if (this.animation) {
+                    this.animate(insert);
+                } else {
+                    insert();
+                }
+
+            },
+
+            remove(element) {
+
+                if (!within(element, this.$el)) {
+                    return;
+                }
+
+                if (this.animation) {
+                    this.animate(() => remove(element));
+                } else {
+                    remove(element);
+                }
+
+            },
+
+            animate(action) {
+
+                var props = [],
+                    children = toNodes(this.$el.children),
+                    reset = {position: '', width: '', height: '', pointerEvents: '', top: '', left: '', bottom: '', right: ''};
+
+                children.forEach(el => {
+                    props.push(assign({
+                        position: 'absolute',
+                        pointerEvents: 'none',
+                        width: el.offsetWidth,
+                        height: el.offsetHeight
+                    }, position(el)));
+                });
+
+                action();
+
+                children.forEach(Transition.cancel);
+                css(this.$el.children, reset);
+                this.$update('update', true);
+                fastdom.flush();
+
+                css(this.$el, 'minHeight', height(this.$el));
+
+                var positions = children.map(el => position(el));
+                Promise.all(children.map((el, i) => Transition.start(css(el, props[i]), positions[i], this.animation)))
+                    .then(() => {
+                        css(this.$el, 'minHeight', '');
+                        css(children, reset);
+                        this.$update('update', true);
+                        fastdom.flush();
+                    }, noop);
+
+            }
+
+        }
+
+    });
+
+    function getSortable(element) {
+        return element && (UIkit.getComponent(element, 'sortable') || getSortable(element.parentNode));
+    }
+
+    function isPredecessor(element, target) {
+        return element.parentNode === target.parentNode && index(element) > index(target);
+    }
+
+}
+
+if (!BUNDLED && typeof window !== 'undefined' && window.UIkit) {
+    window.UIkit.use(plugin);
+}
+
+export default plugin;