jekyll-uikit 0.1.5 → 0.1.7

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

@@ -0,0 +1,127 @@
+function plugin(UIkit) {
+
+    if (plugin.installed) {
+        return;
+    }
+
+    var {util, mixin} = UIkit;
+    var {append, attr, doc, fastdom, flipPosition, includes, isTouch, isVisible, matches, on, pointerDown, pointerEnter, pointerLeave, remove, within} = util;
+
+    var actives = [];
+
+    UIkit.component('tooltip', {
+
+        attrs: true,
+
+        mixins: [mixin.container, mixin.togglable, mixin.position],
+
+        props: {
+            delay: Number,
+            title: String
+        },
+
+        defaults: {
+            pos: 'top',
+            title: '',
+            delay: 0,
+            animation: ['uk-animation-scale-up'],
+            duration: 100,
+            cls: 'uk-active',
+            clsPos: 'uk-tooltip'
+        },
+
+        connected() {
+            fastdom.write(() => attr(this.$el, {title: null, 'aria-expanded': false}));
+        },
+
+        disconnected() {
+            this.hide();
+        },
+
+        methods: {
+
+            show() {
+
+                if (includes(actives, this)) {
+                    return;
+                }
+
+                actives.forEach(active => active.hide());
+                actives.push(this);
+
+                this._unbind = on(doc, 'click', e => !within(e.target, this.$el) && this.hide());
+
+                clearTimeout(this.showTimer);
+
+                this.tooltip = append(this.container, `<div class="${this.clsPos}" aria-hidden><div class="${this.clsPos}-inner">${this.title}</div></div>`);
+
+                attr(this.$el, 'aria-expanded', true);
+
+                this.positionAt(this.tooltip, this.$el);
+
+                this.origin = this.getAxis() === 'y' ? `${flipPosition(this.dir)}-${this.align}` : `${this.align}-${flipPosition(this.dir)}`;
+
+                this.showTimer = setTimeout(() => {
+
+                    this.toggleElement(this.tooltip, true);
+
+                    this.hideTimer = setInterval(() => {
+
+                        if (!isVisible(this.$el)) {
+                            this.hide();
+                        }
+
+                    }, 150);
+
+                }, this.delay);
+            },
+
+            hide() {
+
+                var index = actives.indexOf(this);
+
+                if (!~index || matches(this.$el, 'input') && this.$el === doc.activeElement) {
+                    return;
+                }
+
+                actives.splice(index, 1);
+
+                clearTimeout(this.showTimer);
+                clearInterval(this.hideTimer);
+                attr(this.$el, 'aria-expanded', false);
+                this.toggleElement(this.tooltip, false);
+                this.tooltip && remove(this.tooltip);
+                this.tooltip = false;
+                this._unbind();
+
+            }
+
+        },
+
+        events: {
+
+            [`focus ${pointerEnter} ${pointerDown}`](e) {
+                if (e.type !== pointerDown || !isTouch(e)) {
+                    this.show();
+                }
+            },
+
+            'blur': 'hide',
+
+            [pointerLeave](e) {
+                if (!isTouch(e)) {
+                    this.hide()
+                }
+            }
+
+        }
+
+    });
+
+}
+
+if (!BUNDLED && typeof window !== 'undefined' && window.UIkit) {
+    window.UIkit.use(plugin);
+}
+
+export default plugin;

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

@@ -0,0 +1,208 @@
+function plugin(UIkit) {
+
+    if (plugin.installed) {
+        return;
+    }
+
+    var {addClass, ajax, matches, noop, on, removeClass, trigger} = UIkit.util;
+
+    UIkit.component('upload', {
+
+        props: {
+            allow: String,
+            clsDragover: String,
+            concurrent: Number,
+            mime: String,
+            msgInvalidMime: String,
+            msgInvalidName: String,
+            multiple: Boolean,
+            name: String,
+            params: Object,
+            type: String,
+            url: String
+        },
+
+        defaults: {
+            allow: false,
+            clsDragover: 'uk-dragover',
+            concurrent: 1,
+            mime: false,
+            msgInvalidMime: 'Invalid File Type: %s',
+            msgInvalidName: 'Invalid File Name: %s',
+            multiple: false,
+            name: 'files[]',
+            params: {},
+            type: 'POST',
+            url: '',
+            abort: noop,
+            beforeAll: noop,
+            beforeSend: noop,
+            complete: noop,
+            completeAll: noop,
+            error: noop,
+            fail: noop,
+            load: noop,
+            loadEnd: noop,
+            loadStart: noop,
+            progress: noop
+        },
+
+        events: {
+
+            change(e) {
+
+                if (!matches(e.target, 'input[type="file"]')) {
+                    return;
+                }
+
+                e.preventDefault();
+
+                if (e.target.files) {
+                    this.upload(e.target.files);
+                }
+
+                e.target.value = '';
+            },
+
+            drop(e) {
+                stop(e);
+
+                var transfer = e.dataTransfer;
+
+                if (!transfer || !transfer.files) {
+                    return;
+                }
+
+                removeClass(this.$el, this.clsDragover);
+
+                this.upload(transfer.files);
+            },
+
+            dragenter(e) {
+                stop(e);
+            },
+
+            dragover(e) {
+                stop(e);
+                addClass(this.$el, this.clsDragover);
+            },
+
+            dragleave(e) {
+                stop(e);
+                removeClass(this.$el, this.clsDragover);
+            }
+
+        },
+
+        methods: {
+
+            upload(files) {
+
+                if (!files.length) {
+                    return;
+                }
+
+                trigger(this.$el, 'upload', [files]);
+
+                for (var i = 0; i < files.length; i++) {
+
+                    if (this.allow) {
+                        if (!match(this.allow, files[i].name)) {
+                            this.fail(this.msgInvalidName.replace(/%s/, this.allow));
+                            return;
+                        }
+                    }
+
+                    if (this.mime) {
+                        if (!match(this.mime, files[i].type)) {
+                            this.fail(this.msgInvalidMime.replace(/%s/, this.mime));
+                            return;
+                        }
+                    }
+
+                }
+
+                if (!this.multiple) {
+                    files = [files[0]];
+                }
+
+                this.beforeAll(this, files);
+
+                var chunks = chunk(files, this.concurrent),
+                    upload = files => {
+
+                        var data = new FormData();
+
+                        files.forEach(file => data.append(this.name, file));
+
+                        for (var key in this.params) {
+                            data.append(key, this.params[key]);
+                        }
+
+                        ajax(this.url, {
+                            data,
+                            method: this.type,
+                            beforeSend: env => {
+
+                                var xhr = env.xhr;
+                                xhr.upload && on(xhr.upload, 'progress', this.progress);
+                                ['loadStart', 'load', 'loadEnd', 'abort'].forEach(type =>
+                                    on(xhr, type.toLowerCase(), this[type])
+                                );
+
+                                this.beforeSend(env);
+
+                            }
+                        }).then(
+                            xhr => {
+
+                                this.complete(xhr);
+
+                                if (chunks.length) {
+                                    upload(chunks.shift());
+                                } else {
+                                    this.completeAll(xhr);
+                                }
+
+                            },
+                            e => this.error(e.message)
+                        );
+
+                    };
+
+                upload(chunks.shift());
+
+            }
+
+        }
+
+    });
+
+    function match(pattern, path) {
+        return path.match(new RegExp(`^${pattern.replace(/\//g, '\\/').replace(/\*\*/g, '(\\/[^\\/]+)*').replace(/\*/g, '[^\\/]+').replace(/((?!\\))\?/g, '$1.')}$`, 'i'));
+    }
+
+    function chunk(files, size) {
+        var chunks = [];
+        for (var i = 0; i < files.length; i += size) {
+            var chunk = [];
+            for (var j = 0; j < size; j++) {
+                chunk.push(files[i + j]);
+            }
+            chunks.push(chunk);
+        }
+        return chunks;
+    }
+
+    function stop(e) {
+        e.preventDefault();
+        e.stopPropagation();
+    }
+
+}
+
+if (!BUNDLED && typeof window !== 'undefined' && window.UIkit) {
+    window.UIkit.use(plugin);
+}
+
+export default plugin;

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

@@ -0,0 +1,124 @@
+import { Class, Togglable } from '../mixin/index';
+import { $, $$, attr, filter, getIndex, hasClass, includes, index, toggleClass, unwrap, wrapAll } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('accordion', {
+
+        mixins: [Class, Togglable],
+
+        props: {
+            targets: String,
+            active: null,
+            collapsible: Boolean,
+            multiple: Boolean,
+            toggle: String,
+            content: String,
+            transition: String
+        },
+
+        defaults: {
+            targets: '> *',
+            active: false,
+            animation: [true],
+            collapsible: true,
+            multiple: false,
+            clsOpen: 'uk-open',
+            toggle: '> .uk-accordion-title',
+            content: '> .uk-accordion-content',
+            transition: 'ease'
+        },
+
+        computed: {
+
+            items({targets}, $el) {
+                return $$(targets, $el);
+            }
+
+        },
+
+        events: [
+
+            {
+
+                name: 'click',
+
+                delegate() {
+                    return `${this.targets} ${this.$props.toggle}`;
+                },
+
+                handler(e) {
+                    e.preventDefault();
+                    this.toggle(index($$(`${this.targets} ${this.$props.toggle}`, this.$el), e.current));
+                }
+
+            }
+
+        ],
+
+        ready() {
+            var active = this.active !== false && this.items[Number(this.active)] && !hasClass(active, this.clsOpen);
+            if (active) {
+                this.toggle(active, false);
+            }
+        },
+
+        update() {
+
+            this.items.forEach(el => this._toggleImmediate($(this.content, el), hasClass(el, this.clsOpen)));
+
+            var active = !this.collapsible && !hasClass(this.items, this.clsOpen) && this.items[0];
+            if (active) {
+                this.toggle(active, false);
+            }
+        },
+
+        methods: {
+
+            toggle(item, animate) {
+
+                var index = getIndex(item, this.items),
+                    active = filter(this.items, `.${this.clsOpen}`);
+
+                item = this.items[index];
+
+                item && [item]
+                    .concat(!this.multiple && !includes(active, item) && active || [])
+                    .forEach(el => {
+
+                        var isItem = el === item, state = isItem && !hasClass(el, this.clsOpen);
+
+                        if (!state && isItem && !this.collapsible && active.length < 2) {
+                            return;
+                        }
+
+                        toggleClass(el, this.clsOpen, state);
+
+                        var content = el._wrapper ? el._wrapper.firstElementChild : $(this.content, el);
+
+                        if (!el._wrapper) {
+                            el._wrapper = wrapAll(content, '<div>');
+                            attr(el._wrapper, 'hidden', state ? '' : null);
+                        }
+
+                        this._toggleImmediate(content, true);
+                        this.toggleElement(el._wrapper, state, animate).then(() => {
+                            if (hasClass(el, this.clsOpen) === state) {
+
+                                if (!state) {
+                                    this._toggleImmediate(content, false);
+                                }
+
+                                el._wrapper = null;
+                                unwrap(content);
+                            }
+                        });
+
+                    })
+            }
+
+        }
+
+    });
+
+}