RubyGems - jekyll-uikit - Versions diffs - 0.1.7 → 0.2.0 - Mend

jekyll-uikit 0.1.7 → 0.2.0

Files changed (640) hide show

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

@@ -1,179 +0,0 @@
-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 DELETED

@@ -1,333 +0,0 @@
-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;