jekyll-uikit 0.1.5 → 0.1.7

data/assets/node_modules/uikit/src/js/mixin/togglable.js

@@ -0,0 +1,207 @@
+import UIkit from '../api/index';
+import { $$, Animation, assign, attr, css, doc, fastdom, hasAttr, hasClass, height, includes, isBoolean, isUndefined, isVisible, noop, Promise, toFloat, toggleClass, toNodes, Transition, trigger } from '../util/index';
+
+export default {
+
+    props: {
+        cls: Boolean,
+        animation: 'list',
+        duration: Number,
+        origin: String,
+        transition: String,
+        queued: Boolean
+    },
+
+    defaults: {
+        cls: false,
+        animation: [false],
+        duration: 200,
+        origin: false,
+        transition: 'linear',
+        queued: false,
+
+        initProps: {
+            overflow: '',
+            height: '',
+            paddingTop: '',
+            paddingBottom: '',
+            marginTop: '',
+            marginBottom: ''
+        },
+
+        hideProps: {
+            overflow: 'hidden',
+            height: 0,
+            paddingTop: 0,
+            paddingBottom: 0,
+            marginTop: 0,
+            marginBottom: 0
+        }
+
+    },
+
+    computed: {
+
+        hasAnimation({animation}) {
+            return !!animation[0];
+        },
+
+        hasTransition({animation}) {
+            return this.hasAnimation && animation[0] === true;
+        }
+
+    },
+
+    methods: {
+
+        toggleElement(targets, show, animate) {
+            return new Promise(resolve => {
+
+                targets = toNodes(targets);
+
+                var all = targets => Promise.all(targets.map(el => this._toggleElement(el, show, animate))),
+                    toggled = targets.filter(el => this.isToggled(el)),
+                    untoggled = targets.filter(el => !includes(toggled, el)),
+                    p;
+
+                if (!this.queued || !isUndefined(animate) || !isUndefined(show) || !this.hasAnimation || targets.length < 2) {
+
+                    p = all(untoggled.concat(toggled));
+
+                } else {
+
+                    var body = doc.body,
+                        scroll = body.scrollTop,
+                        el = toggled[0],
+                        inProgress = Animation.inProgress(el) && hasClass(el, 'uk-animation-leave')
+                            || Transition.inProgress(el) && el.style.height === '0px';
+
+                    p = all(toggled);
+
+                    if (!inProgress) {
+                        p = p.then(() => {
+                            var p = all(untoggled);
+                            body.scrollTop = scroll;
+                            return p;
+                        });
+                    }
+
+                }
+
+                p.then(resolve, noop);
+
+            });
+        },
+
+        toggleNow(targets, show) {
+            return new Promise(resolve => Promise.all(toNodes(targets).map(el => this._toggleElement(el, show, false))).then(resolve, noop));
+        },
+
+        isToggled(el) {
+            var nodes = toNodes(el || this.$el);
+            return this.cls
+                ? hasClass(nodes, this.cls.split(' ')[0])
+                : !hasAttr(nodes, 'hidden');
+        },
+
+        updateAria(el) {
+            if (this.cls === false) {
+                attr(el, 'aria-hidden', !this.isToggled(el));
+            }
+        },
+
+        _toggleElement(el, show, animate) {
+
+            show = isBoolean(show)
+                ? show
+                : Animation.inProgress(el)
+                    ? hasClass(el, 'uk-animation-leave')
+                    : Transition.inProgress(el)
+                        ? el.style.height === '0px'
+                        : !this.isToggled(el);
+
+            if (!trigger(el, `before${show ? 'show' : 'hide'}`, [this])) {
+                return Promise.reject();
+            }
+
+            var promise = (animate === false || !this.hasAnimation
+                    ? this._toggleImmediate
+                    : this.hasTransition
+                        ? this._toggleHeight
+                        : this._toggleAnimation
+            )(el, show);
+
+            trigger(el, show ? 'show' : 'hide', [this]);
+
+            return promise.then(() => {
+                trigger(el, show ? 'shown' : 'hidden', [this]);
+                UIkit.update(null, el);
+            });
+        },
+
+        _toggle(el, toggled) {
+
+            if (!el) {
+                return;
+            }
+
+            if (this.cls) {
+                toggleClass(el, this.cls, includes(this.cls, ' ') ? undefined : toggled);
+            } else {
+                attr(el, 'hidden', !toggled ? '' : null);
+            }
+
+            $$('[autofocus]', el).some(el => isVisible(el) && (el.focus() || true));
+
+            this.updateAria(el);
+            UIkit.update(null, el);
+        },
+
+        _toggleImmediate(el, show) {
+            this._toggle(el, show);
+            return Promise.resolve();
+        },
+
+        _toggleHeight(el, show) {
+
+            var inProgress = Transition.inProgress(el),
+                inner = el.hasChildNodes ? toFloat(css(el.firstElementChild, 'marginTop')) + toFloat(css(el.lastElementChild, 'marginBottom')) : 0,
+                currentHeight = isVisible(el) ? height(el) + (inProgress ? 0 : inner) : 0,
+                endHeight;
+
+            Transition.cancel(el);
+
+            if (!this.isToggled(el)) {
+                this._toggle(el, true);
+            }
+
+            height(el, '');
+
+            // Update child components first
+            fastdom.flush();
+
+            endHeight = height(el) + (inProgress ? 0 : inner);
+            height(el, currentHeight);
+
+            return (show
+                ? Transition.start(el, assign({}, this.initProps, {overflow: 'hidden', height: endHeight}), Math.round(this.duration * (1 - currentHeight / endHeight)), this.transition)
+                : Transition.start(el, this.hideProps, Math.round(this.duration * (currentHeight / endHeight)), this.transition).then(() => this._toggle(el, false))
+            ).then(() => css(el, this.initProps));
+
+        },
+
+        _toggleAnimation(el, show) {
+
+            Animation.cancel(el);
+
+            if (show) {
+                this._toggle(el, true);
+                return Animation.in(el, this.animation[0], this.duration, this.origin);
+            }
+
+            return Animation.out(el, this.animation[1] || this.animation[0], this.duration, this.origin).then(() => this._toggle(el, false));
+        }
+
+    }
+
+};

data/assets/node_modules/uikit/src/js/uikit-core.js

@@ -0,0 +1,15 @@
+import UIkit from './api/index';
+import mixin from './mixin/index';
+import core from './core/index';
+import boot from './api/boot';
+
+UIkit.version = VERSION;
+
+mixin(UIkit);
+core(UIkit);
+
+if (!BUNDLED) {
+    boot(UIkit);
+}
+
+export default UIkit;

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

@@ -0,0 +1,27 @@
+import boot from './api/boot';
+import UIkit from './uikit-core';
+import Countdown from './components/countdown';
+import GridParallax from './components/grid-parallax';
+import Lightbox from './components/lightbox';
+import Notification from './components/notification';
+import Parallax from './components/parallax';
+import Slideshow from './components/slideshow';
+import Sortable from './components/sortable';
+import Tooltip from './components/tooltip';
+import Upload from './components/upload';
+
+UIkit.use(Countdown);
+UIkit.use(GridParallax);
+UIkit.use(Lightbox);
+UIkit.use(Notification);
+UIkit.use(Parallax);
+UIkit.use(Slideshow);
+UIkit.use(Sortable);
+UIkit.use(Tooltip);
+UIkit.use(Upload);
+
+if (BUNDLED) {
+    boot(UIkit);
+}
+
+export default UIkit;

data/assets/node_modules/uikit/src/js/util/attr.js

@@ -0,0 +1,55 @@
+import { isFunction, isObject, isUndefined, toNode, toNodes } from './index';
+
+export function attr(element, name, value) {
+
+    if (isObject(name)) {
+        for (var key in name) {
+            attr(element, key, name[key]);
+        }
+        return;
+    }
+
+    if (isUndefined(value)) {
+        element = toNode(element);
+        return element && element.getAttribute(name);
+    } else {
+        toNodes(element).forEach(element => {
+
+            if (isFunction(value)) {
+                value = value.call(element, attr(element, name));
+            }
+
+            if (value === null) {
+                removeAttr(element, name);
+            } else {
+                element.setAttribute(name, value);
+            }
+        });
+    }
+
+}
+
+export function hasAttr(element, name) {
+    return toNodes(element).some(element => element.hasAttribute(name));
+}
+
+export function removeAttr(element, name) {
+    element = toNodes(element);
+    name.split(' ').forEach(name =>
+        element.forEach(element =>
+            element.removeAttribute(name)
+        )
+    );
+}
+
+export function filterAttr(element, attribute, pattern, replacement) {
+    attr(element, attribute, value => value ? value.replace(pattern, replacement) : value);
+}
+
+export function data(element, attribute) {
+    for (var i = 0, attrs = [attribute, `data-${attribute}`]; i < attrs.length; i++) {
+        if (hasAttr(element, attrs[i])) {
+            return attr(element, attrs[i]);
+        }
+    }
+}

data/assets/node_modules/uikit/src/js/util/class.js

@@ -0,0 +1,75 @@
+import { doc, filterAttr, includes, isString, isUndefined, toNodes } from './index';
+
+var supportsClassList, supportsMultiple, supportsForce;
+
+export function addClass(element, ...args) {
+    apply(element, args, 'add');
+}
+
+export function removeClass(element, ...args) {
+    apply(element, args, 'remove');
+}
+
+export function removeClasses(element, cls) {
+    filterAttr(element, 'class', new RegExp(`(^|\\s)${cls}(?!\\S)`, 'g'), '');
+}
+
+export function replaceClass(element, ...args) {
+    args[0] && removeClass(element, args[0]);
+    args[1] && addClass(element, args[1]);
+}
+
+export function hasClass(element, cls) {
+    return supportsClassList && toNodes(element).some(element => element.classList.contains(cls));
+}
+
+export function toggleClass(element, ...args) {
+
+    if (!supportsClassList || !args.length) {
+        return;
+    }
+
+    args = getArgs(args);
+
+    var force = !isString(args[args.length - 1]) ? args.pop()  : undefined;
+
+    toNodes(element).forEach(({classList}) => {
+        for (var i = 0; i < args.length; i++) {
+            supportsForce
+                ? classList.toggle(args[i], force)
+                : (classList[(!isUndefined(force) ? force : !classList.contains(args[i])) ? 'add' : 'remove'](args[i]));
+        }
+    });
+
+}
+
+function apply(element, args, fn) {
+    args = getArgs(args).filter(arg => arg);
+
+    supportsClassList && args.length && toNodes(element).forEach(({classList}) => {
+        supportsMultiple
+            ? classList[fn].apply(classList, args)
+            : args.forEach(cls => classList[fn](cls));
+    });
+}
+
+function getArgs(args) {
+    return args.reduce((args, arg) => {
+        args.push.apply(args, isString(arg) && includes(arg, ' ') ? arg.trim().split(' ') : [arg]);
+        return args;
+    }, []);
+}
+
+(function () {
+
+    var list = doc.createElement('_').classList;
+    if (list) {
+        list.add('a', 'b');
+        list.toggle('c', false);
+        supportsMultiple = list.contains('b');
+        supportsForce = !list.contains('c');
+        supportsClassList = true;
+    }
+    list = null;
+
+})();

data/assets/node_modules/uikit/src/js/util/dom.js

@@ -0,0 +1,414 @@
+import { addClass, animationend, assign, attr, clamp, css, each, hasClass, height, intersectRect, isNumeric, isString, isUndefined, matches, on, once, Promise, removeClass, removeClasses, requestAnimationFrame, startsWith, toNode, toNodes, toNumber, transitionend, trigger, width } from './index';
+
+export const win = window;
+export const doc = document;
+export const docEl = doc.documentElement;
+
+export const isRtl = attr(docEl, 'dir') === 'rtl';
+
+export function isReady() {
+    return doc.readyState === 'complete' || doc.readyState !== 'loading' && !docEl.doScroll;
+}
+
+export function ready(fn) {
+
+    if (isReady()) {
+        fn();
+        return;
+    }
+
+    var handle = function () {
+            unbind1();
+            unbind2();
+            fn();
+        },
+        unbind1 = on(doc, 'DOMContentLoaded', handle),
+        unbind2 = on(win, 'load', handle);
+}
+
+var transitioncancel = 'transitioncanceled';
+
+export function transition(element, props, duration = 400, transition = 'linear') {
+
+    return Promise.all(toNodes(element).map(element =>
+        new Promise((resolve, reject) => {
+
+            for (var name in props) {
+                var value = css(element, name);
+                if (value === '') {
+                    css(element, name, value);
+                }
+            }
+
+            var timer = setTimeout(() => trigger(element, transitionend), duration);
+
+            once(element, `${transitionend} ${transitioncancel}`, ({type}) => {
+                clearTimeout(timer);
+                removeClass(element, 'uk-transition');
+                css(element, 'transition', '');
+                type === transitioncancel ? reject() : resolve();
+            }, false, ({target}) => element === target);
+
+            addClass(element, 'uk-transition');
+            css(element, assign({transition: `all ${duration}ms ${transition}`}, props));
+
+        })
+    ));
+
+}
+
+export const Transition = {
+
+    start: transition,
+
+    stop(element) {
+        trigger(element, transitionend);
+        return Promise.resolve();
+    },
+
+    cancel(element) {
+        trigger(element, transitioncancel);
+    },
+
+    inProgress(element) {
+        return hasClass(element, 'uk-transition');
+    }
+
+};
+
+var animationcancel = 'animationcancel',
+    animationPrefix = 'uk-animation-',
+    clsCancelAnimation = 'uk-cancel-animation';
+
+export function animate(element, animation, duration = 200, origin, out) {
+
+    return Promise.all(toNodes(element).map(element =>
+        new Promise((resolve, reject) => {
+
+            if (hasClass(element, clsCancelAnimation)) {
+                requestAnimationFrame(() =>
+                    Promise.resolve().then(() =>
+                        animate.apply(null, arguments).then(resolve, reject)
+                    )
+                );
+                return;
+            }
+
+            var cls = `${animation} ${animationPrefix}${out ? 'leave' : 'enter'}`;
+
+            if (startsWith(animation, animationPrefix)) {
+
+                if (origin) {
+                    cls += ` ${animationPrefix}${origin}`;
+                }
+
+                if (out) {
+                    cls += ` ${animationPrefix}reverse`;
+                }
+
+            }
+
+            reset();
+
+            once(element, `${animationend || 'animationend'} ${animationcancel}`, ({type}) => {
+
+                var hasReset = false;
+
+                if (type === animationcancel) {
+                    reject();
+                    reset();
+                } else {
+                    resolve();
+                    Promise.resolve().then(() => {
+                        hasReset = true;
+                        reset();
+                    });
+                }
+
+                requestAnimationFrame(() => {
+                    if (!hasReset) {
+                        addClass(element, clsCancelAnimation);
+
+                        requestAnimationFrame(() => removeClass(element, clsCancelAnimation));
+                    }
+                });
+
+            }, false, ({target}) => element === target);
+
+            css(element, 'animationDuration', `${duration}ms`);
+            addClass(element, cls);
+
+            if (!animationend) {
+                requestAnimationFrame(() => Animation.cancel(element));
+            }
+
+            function reset() {
+                css(element, 'animationDuration', '');
+                removeClasses(element, `${animationPrefix}\\S*`);
+            }
+
+        })
+    ));
+
+}
+
+var inProgress = new RegExp(`${animationPrefix}(enter|leave)`);
+export const Animation = {
+
+    in(element, animation, duration, origin) {
+        return animate(element, animation, duration, origin, false);
+    },
+
+    out(element, animation, duration, origin) {
+        return animate(element, animation, duration, origin, true);
+    },
+
+    inProgress(element) {
+        return inProgress.test(attr(element, 'class'));
+    },
+
+    cancel(element) {
+        trigger(element, animationcancel);
+    }
+
+};
+
+export function isInView(element, top = 0, left = 0) {
+    return intersectRect(toNode(element).getBoundingClientRect(), {
+        top,
+        left,
+        bottom: top + height(win),
+        right: left + width(win)
+    });
+}
+
+export function scrolledOver(element) {
+
+    element = toNode(element);
+
+    var elHeight = element.offsetHeight,
+        top = positionTop(element),
+        vp = height(win),
+        vh = vp + Math.min(0, top - vp),
+        diff = Math.max(0, vp - (height(doc) - (top + elHeight)));
+
+    return clamp(((vh + win.pageYOffset - top) / ((vh + (elHeight - (diff < vp ? diff : 0)) ) / 100)) / 100);
+}
+
+function positionTop(element) {
+    var top = 0;
+
+    do {
+
+        top += element.offsetTop;
+
+    } while (element = element.offsetParent);
+
+    return top;
+}
+
+export function getIndex(i, elements, current = 0) {
+
+    elements = toNodes(elements);
+
+    var length = elements.length;
+
+    i = (isNumeric(i)
+            ? toNumber(i)
+            : i === 'next'
+                ? current + 1
+                : i === 'previous'
+                    ? current - 1
+                    : index(elements, i)
+    ) % length;
+
+    return i < 0 ? i + length : i;
+}
+
+var voidElements = {
+    area: true,
+    base: true,
+    br: true,
+    col: true,
+    embed: true,
+    hr: true,
+    img: true,
+    input: true,
+    keygen: true,
+    link: true,
+    menuitem: true,
+    meta: true,
+    param: true,
+    source: true,
+    track: true,
+    wbr: true
+};
+export function isVoidElement(element) {
+    return voidElements[toNode(element).tagName.toLowerCase()];
+}
+
+export const Dimensions = {
+
+    ratio(dimensions, prop, value) {
+
+        var aProp = prop === 'width' ? 'height' : 'width';
+
+        return {
+            [aProp]: Math.round(value * dimensions[aProp] / dimensions[prop]),
+            [prop]: value
+        };
+    },
+
+    contain(dimensions, maxDimensions) {
+        dimensions = assign({}, dimensions);
+
+        each(dimensions, (_, prop) => dimensions = dimensions[prop] > maxDimensions[prop]
+            ? this.ratio(dimensions, prop, maxDimensions[prop])
+            : dimensions
+        );
+
+        return dimensions;
+    },
+
+    cover(dimensions, maxDimensions) {
+        dimensions = this.contain(dimensions, maxDimensions);
+
+        each(dimensions, (_, prop) => dimensions = dimensions[prop] < maxDimensions[prop]
+            ? this.ratio(dimensions, prop, maxDimensions[prop])
+            : dimensions
+        );
+
+        return dimensions;
+    }
+
+};
+
+export function preventClick() {
+
+    var timer = setTimeout(() => trigger(doc, 'click'), 0);
+
+    once(doc, 'click', e => {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+
+        clearTimeout(timer);
+    }, true);
+
+}
+
+export function isVisible(element) {
+    return toNodes(element).some(element => element.offsetHeight);
+}
+
+export const selInput = 'input,select,textarea,button';
+export function isInput(element) {
+    return toNodes(element).some(element => matches(element, selInput));
+}
+
+export function empty(element) {
+    element = toNode(element);
+    element.innerHTML = '';
+    return element;
+}
+
+export function html(parent, html) {
+    parent = toNode(parent);
+    return isUndefined(html)
+        ? parent.innerHTML
+        : append(parent.hasChildNodes() ? empty(parent) : parent, html);
+}
+
+export function prepend(parent, element) {
+
+    parent = toNode(parent);
+
+    if (!parent.hasChildNodes()) {
+        return append(parent, element);
+    } else {
+        return insertNodes(element, element => parent.insertBefore(element, parent.firstChild));
+    }
+}
+
+export function append(parent, element) {
+    parent = toNode(parent);
+    return insertNodes(element, element => parent.appendChild(element));
+}
+
+export function before(ref, element) {
+    ref = toNode(ref);
+    return insertNodes(element, element => ref.parentNode.insertBefore(element, ref));
+}
+
+export function after(ref, element) {
+    ref = toNode(ref);
+    return insertNodes(element, element => ref.nextSibling
+        ? before(ref.nextSibling, element)
+        : append(ref.parentNode,element)
+    );
+}
+
+function insertNodes(element, fn) {
+    element = isString(element) ? fragment(element) : element;
+    return 'length' in element ? toNodes(element).map(fn) : fn(element);
+}
+
+export function remove(element) {
+    toNodes(element).map(element => element.parentNode && element.parentNode.removeChild(element));
+}
+
+export function wrapAll(element, structure) {
+
+    structure = toNode(before(element, structure));
+
+    while (structure.firstChild) {
+        structure = structure.firstChild;
+    }
+
+    append(structure, element);
+
+    return structure;
+}
+
+export function wrapInner(element, structure) {
+    return toNodes(toNodes(element).map(element =>
+        element.hasChildNodes ? wrapAll(toNodes(element.childNodes), structure) : append(element, structure)
+    ));
+}
+
+export function unwrap(element) {
+    toNodes(element)
+        .map(element => element.parentNode)
+        .filter((value, index, self) => self.indexOf(value) === index)
+        .forEach(parent => {
+            before(parent, parent.childNodes);
+            remove(parent);
+        });
+}
+
+var fragmentRE = /^\s*<(\w+|!)[^>]*>/,
+    singleTagRE = /^<(\w+)\s*\/?>(?:<\/\1>)?$/;
+
+export function fragment(html) {
+
+    var matches;
+
+    if (matches = singleTagRE.exec(html)) {
+        return doc.createElement(matches[1]);
+    }
+
+    var container = doc.createElement('div');
+    if (fragmentRE.test(html)) {
+        container.insertAdjacentHTML('beforeend', html.trim());
+    } else {
+        container.textContent = html;
+    }
+
+    return container.childNodes.length > 1 ? toNodes(container.childNodes) : container.firstChild;
+
+}
+
+export function index(element, ref) {
+    return ref
+        ? toNodes(element).indexOf(toNode(ref))
+        : toNodes((element = toNode(element)) && element.parentNode.children).indexOf(element);
+}