jekyll-uikit 0.1.5 → 0.1.7

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

@@ -0,0 +1,193 @@
+import { $, after, ajax, append, attr, includes, isString, isVoidElement, noop, Promise, remove, removeAttr, startsWith } from '../util/index';
+
+var svgs = {};
+
+export default function (UIkit) {
+
+    UIkit.component('svg', {
+
+        attrs: true,
+
+        props: {
+            id: String,
+            icon: String,
+            src: String,
+            style: String,
+            width: Number,
+            height: Number,
+            ratio: Number,
+            'class': String
+        },
+
+        defaults: {
+            ratio: 1,
+            id: false,
+            exclude: ['src'],
+            'class': ''
+        },
+
+        init() {
+            this.class += ' uk-svg';
+        },
+
+        connected() {
+
+            if (!this.icon && includes(this.src, '#')) {
+
+                var parts = this.src.split('#');
+
+                if (parts.length > 1) {
+                    this.src = parts[0];
+                    this.icon = parts[1];
+                }
+            }
+
+            this.svg = this.getSvg().then(svg => {
+
+                var el;
+
+                if (isString(svg)) {
+
+                    if (this.icon && includes(svg, '<symbol')) {
+                        svg = parseSymbols(svg, this.icon) || svg;
+                    }
+
+                    el = $(svg.substr(svg.indexOf('<svg')));
+
+                } else {
+                    el = svg.cloneNode(true);
+                }
+
+                if (!el) {
+                    return Promise.reject('SVG not found.');
+                }
+
+                var dimensions = attr(el, 'viewBox');
+
+                if (dimensions) {
+                    dimensions = dimensions.split(' ');
+                    this.width = this.$props.width || dimensions[2];
+                    this.height = this.$props.height || dimensions[3];
+                }
+
+                this.width *= this.ratio;
+                this.height *= this.ratio;
+
+                for (var prop in this.$options.props) {
+                    if (this[prop] && !includes(this.exclude, prop)) {
+                        attr(el, prop, this[prop]);
+                    }
+                }
+
+                if (!this.id) {
+                    removeAttr(el, 'id');
+                }
+
+                if (this.width && !this.height) {
+                    removeAttr(el, 'height');
+                }
+
+                if (this.height && !this.width) {
+                    removeAttr(el, 'width');
+                }
+
+                var root = this.$el;
+                if (isVoidElement(root) || root.tagName === 'CANVAS') {
+
+                    attr(root, {hidden: true, id: null});
+
+                    var next = root.nextElementSibling;
+                    if (next && el.isEqualNode(next)) {
+                        el = next;
+                    } else {
+                        after(root, el);
+                    }
+
+                } else {
+
+                    var last = root.lastElementChild;
+                    if (last && el.isEqualNode(last)) {
+                        el = last;
+                    } else {
+                        append(root, el);
+                    }
+
+                }
+
+                this.svgEl = el;
+
+                return el;
+
+            }, noop);
+
+        },
+
+        disconnected() {
+
+            if (isVoidElement(this.$el)) {
+                attr(this.$el, {hidden: null, id: this.id || null});
+            }
+
+            if (this.svg) {
+                this.svg.then(svg => (!this._connected || svg !== this.svgEl) && remove(svg), noop);
+            }
+
+            this.svg = this.svgEl = null;
+
+        },
+
+        methods: {
+
+            getSvg() {
+
+                if (!this.src) {
+                    return Promise.reject();
+                }
+
+                if (svgs[this.src]) {
+                    return svgs[this.src];
+                }
+
+                svgs[this.src] = new Promise((resolve, reject) => {
+
+                    if (startsWith(this.src, 'data:')) {
+                        resolve(decodeURIComponent(this.src.split(',')[1]));
+                    } else {
+
+                        ajax(this.src).then(
+                            xhr => resolve(xhr.response),
+                            () => reject('SVG not found.')
+                        );
+
+                    }
+
+                });
+
+                return svgs[this.src];
+
+            }
+
+        }
+
+    });
+
+    var symbolRe = /<symbol(.*?id=(['"])(.*?)\2[^]*?<\/)symbol>/g,
+        symbols = {};
+
+    function parseSymbols(svg, icon) {
+
+        if (!symbols[svg]) {
+
+            symbols[svg] = {};
+
+            var match;
+            while (match = symbolRe.exec(svg)) {
+                symbols[svg][match[3]] = `<svg xmlns="http://www.w3.org/2000/svg"${match[1]}svg>`;
+            }
+
+        }
+
+        return symbols[svg][icon];
+    }
+
+}

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

@@ -0,0 +1,149 @@
+import { Togglable } from '../mixin/index';
+import { $$, addClass, attr, data, filter, getIndex, hasClass, index, isTouch, matches, queryAll, removeClass, win } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('switcher', {
+
+        mixins: [Togglable],
+
+        args: 'connect',
+
+        props: {
+            connect: String,
+            toggle: String,
+            active: Number,
+            swiping: Boolean
+        },
+
+        defaults: {
+            connect: '~.uk-switcher',
+            toggle: '> *',
+            active: 0,
+            swiping: true,
+            cls: 'uk-active',
+            clsContainer: 'uk-switcher',
+            attrItem: 'uk-switcher-item',
+            queued: true
+        },
+
+        computed: {
+
+            connects({connect}, $el) {
+                return queryAll(connect, $el);
+            },
+
+            toggles({toggle}, $el) {
+                return $$(toggle, $el);
+            }
+
+        },
+
+        events: [
+
+            {
+
+                name: 'click',
+
+                delegate() {
+                    return `${this.toggle}:not(.uk-disabled)`;
+                },
+
+                handler(e) {
+                    e.preventDefault();
+                    this.show(e.current);
+                }
+
+            },
+
+            {
+                name: 'click',
+
+                el() {
+                    return this.connects;
+                },
+
+                delegate() {
+                    return `[${this.attrItem}],[data-${this.attrItem}]`;
+                },
+
+                handler(e) {
+                    e.preventDefault();
+                    this.show(data(e.current, this.attrItem));
+                }
+            },
+
+            {
+                name: 'swipeRight swipeLeft',
+
+                filter() {
+                    return this.swiping;
+                },
+
+                el() {
+                    return this.connects;
+                },
+
+                handler(e) {
+                    if (!isTouch(e)) {
+                        return;
+                    }
+
+                    e.preventDefault();
+                    if (!win.getSelection().toString()) {
+                        this.show(e.type === 'swipeLeft' ? 'next' : 'previous');
+                    }
+                }
+            }
+
+        ],
+
+        update() {
+
+            this.connects.forEach(list => this.updateAria(list.children));
+            this.show(filter(this.toggles, `.${this.cls}`)[0] || this.toggles[this.active] || this.toggles[0]);
+
+        },
+
+        methods: {
+
+            show(item) {
+
+                var length = this.toggles.length,
+                    prev = !!this.connects.length && index(filter(this.connects[0].children, `.${this.cls}`)[0]),
+                    hasPrev = prev >= 0,
+                    next = getIndex(item, this.toggles, prev),
+                    dir = item === 'previous' ? -1 : 1,
+                    toggle;
+
+                for (var i = 0; i < length; i++, next = (next + dir + length) % length) {
+                    if (!matches(this.toggles[next], '.uk-disabled, [disabled]')) {
+                        toggle = this.toggles[next];
+                        break;
+                    }
+                }
+
+                if (!toggle || prev >= 0 && hasClass(toggle, this.cls) || prev === next) {
+                    return;
+                }
+
+                removeClass(this.toggles, this.cls);
+                attr(this.toggles, 'aria-expanded', false);
+                addClass(toggle, this.cls);
+                attr(toggle, 'aria-expanded', true);
+
+                this.connects.forEach(list => {
+                    if (!hasPrev) {
+                        this.toggleNow(list.children[next]);
+                    } else {
+                        this.toggleElement([list.children[prev], list.children[next]]);
+                    }
+                })
+
+            }
+
+        }
+
+    });
+
+}

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

@@ -0,0 +1,36 @@
+import { Class } from '../mixin/index';
+import { hasClass } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('tab', UIkit.components.switcher.extend({
+
+        mixins: [Class],
+
+        name: 'tab',
+
+        props: {
+            media: 'media'
+        },
+
+        defaults: {
+            media: 960,
+            attrItem: 'uk-tab-item'
+        },
+
+        init() {
+
+            var cls = hasClass(this.$el, 'uk-tab-left')
+                ? 'uk-tab-left'
+                : hasClass(this.$el, 'uk-tab-right')
+                    ? 'uk-tab-right'
+                    : false;
+
+            if (cls) {
+                UIkit.toggle(this.$el, {cls, mode: 'media', media: this.media});
+            }
+        }
+
+    }));
+
+}

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

@@ -0,0 +1,116 @@
+import { closest, hasTouch, includes, isTouch, isVisible, matches, pointerEnter, pointerLeave, queryAll, trigger, win } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('toggle', {
+
+        mixins: [UIkit.mixin.togglable],
+
+        args: 'target',
+
+        props: {
+            href: String,
+            target: null,
+            mode: 'list',
+            media: 'media'
+        },
+
+        defaults: {
+            href: false,
+            target: false,
+            mode: 'click',
+            queued: true,
+            media: false
+        },
+
+        computed: {
+
+            target({href, target}, $el) {
+                target = queryAll(target || href, $el);
+                return target.length && target || [$el];
+            }
+
+        },
+
+        events: [
+
+            {
+
+                name: `${pointerEnter} ${pointerLeave}`,
+
+                filter() {
+                    return includes(this.mode, 'hover');
+                },
+
+                handler(e) {
+                    if (!isTouch(e)) {
+                        this.toggle(`toggle${e.type === pointerEnter ? 'show' : 'hide'}`);
+                    }
+                }
+
+            },
+
+            {
+
+                name: 'click',
+
+                filter() {
+                    return includes(this.mode, 'click') || hasTouch;
+                },
+
+                handler(e) {
+
+                    if (!isTouch(e) && !includes(this.mode, 'click')) {
+                        return;
+                    }
+
+                    // TODO better isToggled handling
+                    var link;
+                    if (closest(e.target, 'a[href="#"], button')
+                        || (link = closest(e.target, 'a[href]')) && (
+                            this.cls
+                            || !isVisible(this.target)
+                            || link.hash && matches(this.target, link.hash)
+                        )
+                    ) {
+                        e.preventDefault();
+                    }
+
+                    this.toggle();
+                }
+
+            }
+        ],
+
+        update: {
+
+            write() {
+
+                if (!includes(this.mode, 'media') || !this.media) {
+                    return;
+                }
+
+                var toggled = this.isToggled(this.target);
+                if (win.matchMedia(this.media).matches ? !toggled : toggled) {
+                    this.toggle();
+                }
+
+            },
+
+            events: ['load', 'resize']
+
+        },
+
+        methods: {
+
+            toggle(type) {
+                if (trigger(this.target, type || 'toggle', [this])) {
+                    this.toggleElement(this.target);
+                }
+            }
+
+        }
+
+    });
+
+}