jekyll-uikit 0.1.5 → 0.1.7

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

@@ -0,0 +1,5 @@
+export default function (UIkit) {
+
+    UIkit.component('dropdown', UIkit.components.drop.extend({name: 'dropdown'}));
+
+}

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

@@ -0,0 +1,88 @@
+import { Class } from '../mixin/index';
+import { $, $$, includes, isInput, matches, query, selInput, toggleClass, trigger } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('form-custom', {
+
+        mixins: [Class],
+
+        args: 'target',
+
+        props: {
+            target: Boolean
+        },
+
+        defaults: {
+            target: false
+        },
+
+        computed: {
+
+            input(_, $el) {
+                return $(selInput, $el);
+            },
+
+            state() {
+                return this.input.nextElementSibling;
+            },
+
+            target({target}, $el) {
+                return target && (target === true
+                    && this.input.parentNode === $el
+                    && this.input.nextElementSibling
+                    || query(target, $el));
+            }
+
+        },
+
+        connected() {
+            trigger(this.input, 'change');
+        },
+
+        events: [
+
+            {
+
+                name: 'focusin focusout mouseenter mouseleave',
+
+                delegate: selInput,
+
+                handler({type, current}) {
+                    if (current === this.input) {
+                        toggleClass(
+                            this.state,
+                            `uk-${includes(type, 'focus') ? 'focus' : 'hover'}`,
+                            includes(['focusin', 'mouseenter'], type)
+                        );
+                    }
+                }
+
+            },
+
+            {
+
+                name: 'change',
+
+                handler() {
+
+                    var target = this.target, input = this.input, option;
+
+                    if (!target) {
+                        return;
+                    }
+
+                    target[isInput(target) ? 'value' : 'textContent'] = input.files && input.files[0]
+                        ? input.files[0].name
+                        : matches(input, 'select') && (option = $$('option', input).filter(el => el.selected)[0])
+                            ? option.textContent
+                            : input.value;
+                }
+
+            }
+
+        ]
+
+    });
+
+}

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

@@ -0,0 +1,25 @@
+import { isInView } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('gif', {
+
+        update: {
+
+            read() {
+
+                var inview = isInView(this.$el);
+
+                if (!this.isInView && inview) {
+                    this.$el.src = this.$el.src;
+                }
+
+                this.isInView = inview;
+            },
+
+            events: ['scroll', 'load', 'resize']
+        }
+
+    });
+
+}

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

@@ -0,0 +1,31 @@
+import { Class } from '../mixin/index';
+import { toggleClass } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('grid', UIkit.components.margin.extend({
+
+        mixins: [Class],
+
+        name: 'grid',
+
+        defaults: {
+            margin: 'uk-grid-margin',
+            clsStack: 'uk-grid-stack'
+        },
+
+        update: {
+
+            write() {
+
+                toggleClass(this.$el, this.clsStack, this.stacks);
+
+            },
+
+            events: ['load', 'resize']
+
+        }
+
+    }));
+
+}

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

@@ -0,0 +1,104 @@
+import { $$, attr, css, isUndefined, isVisible } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('height-match', {
+
+        args: 'target',
+
+        props: {
+            target: String,
+            row: Boolean
+        },
+
+        defaults: {
+            target: '> *',
+            row: true
+        },
+
+        computed: {
+
+            elements({target}, $el) {
+                return $$(target, $el);
+            }
+
+        },
+
+        update: {
+
+            read() {
+
+                var lastOffset = false;
+
+                css(this.elements, 'minHeight', '');
+
+                this.rows = !this.row
+                    ? [this.match(this.elements)]
+                    : this.elements.reduce((rows, el) => {
+
+                        if (lastOffset !== el.offsetTop) {
+                            rows.push([el]);
+                        } else {
+                            rows[rows.length - 1].push(el);
+                        }
+
+                        lastOffset = el.offsetTop;
+
+                        return rows;
+
+                    }, []).map(elements => this.match(elements));
+            },
+
+            write() {
+
+                this.rows.forEach(({height, elements}) => css(elements, 'minHeight', height));
+
+            },
+
+            events: ['load', 'resize']
+
+        },
+
+        methods: {
+
+            match(elements) {
+
+                if (elements.length < 2) {
+                    return {};
+                }
+
+                var max = 0, heights = [];
+
+                elements
+                    .forEach(el => {
+
+                        var style, hidden;
+
+                        if (!isVisible(el)) {
+                            style = attr(el, 'style');
+                            hidden = attr(el, 'hidden');
+
+                            attr(el, {
+                                style: `${style || ''};display:block !important;`,
+                                hidden: null
+                            });
+                        }
+
+                        max = Math.max(max, el.offsetHeight);
+                        heights.push(el.offsetHeight);
+
+                        if (!isUndefined(style)) {
+                            attr(el, {style, hidden});
+                        }
+
+                    });
+
+                elements = elements.filter((el, i) => heights[i] < max);
+
+                return {height: max, elements};
+            }
+        }
+
+    });
+
+}

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

@@ -0,0 +1,98 @@
+import { css, docEl, endsWith, height, isNumeric, isString, offset, query, toFloat, win } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('height-viewport', {
+
+        props: {
+            expand: Boolean,
+            offsetTop: Boolean,
+            offsetBottom: Boolean,
+            minHeight: Number
+        },
+
+        defaults: {
+            expand: false,
+            offsetTop: false,
+            offsetBottom: false,
+            minHeight: 0
+        },
+
+        update: {
+
+            write() {
+
+                css(this.$el, 'boxSizing', 'border-box');
+
+                var viewport = height(win), minHeight, offsetTop = 0;
+
+                if (this.expand) {
+
+                    css(this.$el, {height: '', minHeight: ''});
+
+                    var diff = viewport - offsetHeight(docEl);
+
+                    if (diff > 0) {
+                        minHeight = offsetHeight(this.$el) + diff;
+                    }
+
+                } else {
+
+                    var top = offset(this.$el).top;
+
+                    if (top < viewport / 2 && this.offsetTop) {
+                        offsetTop += top;
+                    }
+
+                    if (this.offsetBottom === true) {
+
+                        offsetTop += offsetHeight(this.$el.nextElementSibling);
+
+                    } else if (isNumeric(this.offsetBottom)) {
+
+                        offsetTop += (viewport / 100) * this.offsetBottom;
+
+                    } else if (this.offsetBottom && endsWith(this.offsetBottom, 'px')) {
+
+                        offsetTop += toFloat(this.offsetBottom);
+
+                    } else if (isString(this.offsetBottom)) {
+
+                        offsetTop += offsetHeight(query(this.offsetBottom, this.$el));
+
+                    }
+
+                    // on mobile devices (iOS and Android) window.innerHeight !== 100vh
+                    minHeight = offsetTop ? `calc(100vh - ${offsetTop}px)` : '100vh';
+
+                }
+
+                if (!minHeight) {
+                    return;
+                }
+
+                css(this.$el, {height: '', minHeight});
+
+                var elHeight = this.$el.offsetHeight;
+                if (this.minHeight && this.minHeight > elHeight) {
+                    css(this.$el, 'minHeight', this.minHeight);
+                }
+
+                // IE 10-11 fix (min-height on a flex container won't apply to its flex items)
+                if (viewport - offsetTop >= elHeight) {
+                    css(this.$el, 'height', minHeight);
+                }
+
+            },
+
+            events: ['load', 'resize']
+
+        }
+
+    });
+
+    function offsetHeight(el) {
+        return el && el.offsetHeight || 0;
+    }
+
+}

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

@@ -0,0 +1,31 @@
+import { $$, addClass, doc, hasTouch, on, ready, removeClass, within } from '../util/index';
+
+export default function (UIkit) {
+
+    ready(() => {
+
+        if (!hasTouch) {
+            return;
+        }
+
+        var cls = 'uk-hover';
+
+        on(doc, 'tap', ({target}) =>
+            $$(`.${cls}`).forEach((_, el) =>
+                !within(target, el) && removeClass(el, cls)
+            )
+        );
+
+        Object.defineProperty(UIkit, 'hoverSelector', {
+
+            set(selector) {
+                on(doc, 'tap', selector, ({current}) => addClass(current, cls));
+            }
+
+        });
+
+        UIkit.hoverSelector = '.uk-animation-toggle, .uk-transition-toggle, [uk-hover]';
+
+    });
+
+}

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

@@ -0,0 +1,180 @@
+import { Class } from '../mixin/index';
+import { $, addClass, css, each, hasClass, isRtl, noop, parents, Promise, swap } from '../util/index';
+import closeIcon from '../../images/components/close-icon.svg';
+import closeLarge from '../../images/components/close-large.svg';
+import marker from '../../images/components/marker.svg';
+import navbarToggleIcon from '../../images/components/navbar-toggle-icon.svg';
+import overlayIcon from '../../images/components/overlay-icon.svg';
+import paginationNext from '../../images/components/pagination-next.svg';
+import paginationPrevious from '../../images/components/pagination-previous.svg';
+import searchIcon from '../../images/components/search-icon.svg';
+import searchLarge from '../../images/components/search-large.svg';
+import searchNavbar from '../../images/components/search-navbar.svg';
+import slidenavNext from '../../images/components/slidenav-next.svg';
+import slidenavNextLarge from '../../images/components/slidenav-next-large.svg';
+import slidenavPrevious from '../../images/components/slidenav-previous.svg';
+import slidenavPreviousLarge from '../../images/components/slidenav-previous-large.svg';
+import spinner from '../../images/components/spinner.svg';
+import totop from '../../images/components/totop.svg';
+
+export default function (UIkit) {
+
+    var parsed = {},
+        icons = {
+            spinner,
+            totop,
+            marker,
+            'close-icon': closeIcon,
+            'close-large': closeLarge,
+            'navbar-toggle-icon': navbarToggleIcon,
+            'overlay-icon': overlayIcon,
+            'pagination-next': paginationNext,
+            'pagination-previous': paginationPrevious,
+            'search-icon': searchIcon,
+            'search-large': searchLarge,
+            'search-navbar': searchNavbar,
+            'slidenav-next': slidenavNext,
+            'slidenav-next-large': slidenavNextLarge,
+            'slidenav-previous': slidenavPrevious,
+            'slidenav-previous-large': slidenavPreviousLarge
+        };
+
+    UIkit.component('icon', UIkit.components.svg.extend({
+
+        attrs: ['icon', 'ratio'],
+
+        mixins: [Class],
+
+        name: 'icon',
+
+        args: 'icon',
+
+        props: ['icon'],
+
+        defaults: {exclude: ['id', 'style', 'class', 'src', 'icon']},
+
+        init() {
+            addClass(this.$el, 'uk-icon');
+
+            if (isRtl) {
+                this.icon = swap(swap(this.icon, 'left', 'right'), 'previous', 'next');
+            }
+        },
+
+        disconnected() {
+            delete this.delay;
+        },
+
+        methods: {
+
+            getSvg() {
+
+                var icon = getIcon(this.icon);
+
+                if (!icon) {
+                    return Promise.reject('Icon not found.');
+                }
+
+                return Promise.resolve(icon);
+            }
+
+        }
+
+    }));
+
+    [
+        'marker',
+        'navbar-toggle-icon',
+        'overlay-icon',
+        'pagination-previous',
+        'pagination-next',
+        'totop'
+    ].forEach(name => registerComponent(name));
+
+    [
+        'slidenav-previous',
+        'slidenav-next'
+    ].forEach(name => registerComponent(name, {
+
+        init() {
+            addClass(this.$el, 'uk-slidenav');
+
+            if (hasClass(this.$el, 'uk-slidenav-large')) {
+                this.icon += '-large';
+            }
+        }
+
+    }));
+
+    registerComponent('search-icon', {
+
+        init() {
+            if (hasClass(this.$el, 'uk-search-icon') && parents(this.$el, '.uk-search-large').length) {
+                this.icon = 'search-large';
+            } else if (parents(this.$el, '.uk-search-navbar').length) {
+                this.icon = 'search-navbar';
+            }
+        }
+
+    });
+
+    registerComponent('close', {
+
+        init() {
+            this.icon = `close-${hasClass(this.$el, 'uk-close-large') ? 'large' : 'icon'}`;
+        }
+
+    });
+
+    registerComponent('spinner', {
+
+        connected() {
+            this.svg.then(svg => this.ratio !== 1 && css($('circle', svg), 'stroke-width', 1 / this.ratio), noop);
+        }
+
+    });
+
+    UIkit.icon.add = added => {
+        Object.keys(added).forEach(name => {
+            icons[name] = added[name];
+            delete parsed[name];
+        });
+
+        if (UIkit._initialized) {
+            each(UIkit.instances, component => {
+                if (component.$options.name === 'icon') {
+                    component.$reset();
+                }
+            });
+        }
+    };
+
+    function registerComponent(name, mixin) {
+
+        UIkit.component(name, UIkit.components.icon.extend({
+
+            name,
+
+            mixins: mixin ? [mixin] : [],
+
+            defaults: {
+                icon: name
+            }
+
+        }));
+    }
+
+    function getIcon(icon) {
+
+        if (!icons[icon]) {
+            return null;
+        }
+
+        if (!parsed[icon]) {
+            parsed[icon] = $(icons[icon].trim());
+        }
+
+        return parsed[icon];
+    }
+
+}