jekyll-uikit 0.1.5 → 0.1.7

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

@@ -0,0 +1,85 @@
+import { animationstart, css, doc, fastdom, on, toMs, win } from '../util/index';
+
+import Accordion from './accordion';
+import Alert from './alert';
+import Cover from './cover';
+import Drop from './drop';
+import Dropdown from './dropdown';
+import FormCustom from './form-custom';
+import Gif from './gif';
+import Grid from './grid';
+import HeightMatch from './height-match';
+import HeightViewport from './height-viewport';
+import Hover from './hover';
+import Icon from './icon';
+import Leader from './leader';
+import Margin from './margin';
+import Modal from './modal';
+import Nav from './nav';
+import Navbar from './navbar';
+import Offcanvas from './offcanvas';
+import Responsive from './responsive';
+import Scroll from './scroll';
+import Scrollspy from './scrollspy';
+import ScrollspyNav from './scrollspy-nav';
+import Sticky from './sticky';
+import Svg from './svg';
+import Switcher from './switcher';
+import Tab from './tab';
+import Toggle from './toggle';
+import Video from './video';
+
+export default function (UIkit) {
+
+    var scroll = 0, started = 0;
+
+    on(win, 'load resize', UIkit.update);
+    on(win, 'scroll', e => {
+        e.dir = scroll <= win.pageYOffset ? 'down' : 'up';
+        e.scrollY = scroll = win.pageYOffset;
+        UIkit.update(e);
+    });
+
+    animationstart && on(doc, animationstart, ({target}) => {
+        if ((css(target, 'animationName') || '').match(/^uk-.*(left|right)/)) {
+            started++;
+            doc.body.style.overflowX = 'hidden';
+            setTimeout(() => {
+                if (!--started) {
+                    doc.body.style.overflowX = '';
+                }
+            }, toMs(css(target, 'animationDuration')) + 100);
+        }
+    }, true);
+
+    // core components
+    UIkit.use(Toggle);
+    UIkit.use(Accordion);
+    UIkit.use(Alert);
+    UIkit.use(Video);
+    UIkit.use(Cover);
+    UIkit.use(Drop);
+    UIkit.use(Dropdown);
+    UIkit.use(FormCustom);
+    UIkit.use(HeightMatch);
+    UIkit.use(HeightViewport);
+    UIkit.use(Hover);
+    UIkit.use(Margin);
+    UIkit.use(Gif);
+    UIkit.use(Grid);
+    UIkit.use(Leader);
+    UIkit.use(Modal);
+    UIkit.use(Nav);
+    UIkit.use(Navbar);
+    UIkit.use(Offcanvas);
+    UIkit.use(Responsive);
+    UIkit.use(Scroll);
+    UIkit.use(Scrollspy);
+    UIkit.use(ScrollspyNav);
+    UIkit.use(Sticky);
+    UIkit.use(Svg);
+    UIkit.use(Icon);
+    UIkit.use(Switcher);
+    UIkit.use(Tab);
+
+}

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

@@ -0,0 +1,68 @@
+import { Class } from '../mixin/index';
+import { attr, getCssVar, toggleClass, unwrap, win, wrapInner } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('leader', {
+
+        mixins: [Class],
+
+        props: {
+            fill: String,
+            media: 'media'
+        },
+
+        defaults: {
+            fill: '',
+            media: false,
+            clsWrapper: 'uk-leader-fill',
+            clsHide: 'uk-leader-hide',
+            attrFill: 'data-fill'
+        },
+
+        computed: {
+
+            fill({fill}) {
+                return fill || getCssVar('leader-fill');
+            }
+
+        },
+
+        connected() {
+            this.wrapper = wrapInner(this.$el, `<span class="${this.clsWrapper}">`)[0];
+        },
+
+        disconnected() {
+            unwrap(this.wrapper.childNodes);
+            delete this._width;
+        },
+
+        update: [
+
+            {
+
+                read() {
+                    var prev = this._width;
+                    this._width = Math.floor(this.$el.offsetWidth / 2);
+                    this._changed = this._changed || prev !== this._width;
+                    this._hide = this.media && !win.matchMedia(this.media).matches;
+                },
+
+                write() {
+
+                    toggleClass(this.wrapper, this.clsHide, this._hide);
+
+                    if (this._changed) {
+                        this._changed = false;
+                        attr(this.wrapper, this.attrFill, new Array(this._width).join(this.fill));
+                    }
+
+                },
+
+                events: ['load', 'resize']
+
+            }
+        ]
+    });
+
+}

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

@@ -0,0 +1,100 @@
+import { isRtl, isVisible, toggleClass } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('margin', {
+
+        props: {
+            margin: String,
+            firstColumn: Boolean
+        },
+
+        defaults: {
+            margin: 'uk-margin-small-top',
+            firstColumn: 'uk-first-column'
+        },
+
+        update: {
+
+            read() {
+
+                var items = this.$el.children;
+
+                if (!items.length || !isVisible(this.$el)) {
+                    this.rows = false;
+                    return;
+                }
+
+                this.stacks = true;
+
+                var rows = [[]];
+
+                for (var i = 0; i < items.length; i++) {
+
+                    var el = items[i],
+                        dim = el.getBoundingClientRect();
+
+                    if (!dim.height) {
+                        continue;
+                    }
+
+                    for (var j = rows.length - 1; j >= 0; j--) {
+
+                        var row = rows[j];
+
+                        if (!row[0]) {
+                            row.push(el);
+                            break;
+                        }
+
+                        var leftDim = row[0].getBoundingClientRect();
+
+                        if (dim.top >= Math.floor(leftDim.bottom)) {
+                            rows.push([el]);
+                            break;
+                        }
+
+                        if (Math.floor(dim.bottom) > leftDim.top) {
+
+                            this.stacks = false;
+
+                            if (dim.left < leftDim.left && !isRtl) {
+                                row.unshift(el);
+                                break;
+                            }
+
+                            row.push(el);
+                            break;
+                        }
+
+                        if (j === 0) {
+                            rows.unshift([el]);
+                            break;
+                        }
+
+                    }
+
+                }
+
+                this.rows = rows;
+
+            },
+
+            write() {
+
+                this.rows && this.rows.forEach((row, i) =>
+                    row.forEach((el, j) => {
+                        toggleClass(el, this.margin, i !== 0);
+                        toggleClass(el, this.firstColumn, j === 0);
+                    })
+                )
+
+            },
+
+            events: ['load', 'resize']
+
+        }
+
+    });
+
+}

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

@@ -0,0 +1,184 @@
+import { Class, Modal } from '../mixin/index';
+import { $, addClass, assign, closest, css, hasClass, height, html, index, isString, on, Promise, removeClass, trigger } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('modal', {
+
+        mixins: [Modal],
+
+        defaults: {
+            clsPage: 'uk-modal-page',
+            clsPanel: 'uk-modal-dialog',
+            selClose: '.uk-modal-close, .uk-modal-close-default, .uk-modal-close-outside, .uk-modal-close-full'
+        },
+
+        events: [
+
+            {
+                name: 'show',
+
+                self: true,
+
+                handler() {
+
+                    if (hasClass(this.panel, 'uk-margin-auto-vertical')) {
+                        addClass(this.$el, 'uk-flex');
+                    } else {
+                        css(this.$el, 'display', 'block');
+                    }
+
+                    height(this.$el); // force reflow
+                }
+            },
+
+            {
+                name: 'hidden',
+
+                self: true,
+
+                handler() {
+
+                    css(this.$el, 'display', '');
+                    removeClass(this.$el, 'uk-flex');
+
+                }
+            }
+
+        ]
+
+    });
+
+    UIkit.component('overflow-auto', {
+
+        mixins: [Class],
+
+        computed: {
+
+            modal(_, $el) {
+                return closest($el, '.uk-modal');
+            },
+
+            panel(_, $el) {
+                return closest($el, '.uk-modal-dialog');
+            }
+
+        },
+
+        connected() {
+            css(this.$el, 'minHeight', 150);
+        },
+
+        update: {
+
+            write() {
+
+                if (!this.panel || !this.modal) {
+                    return;
+                }
+
+                var current = css(this.$el, 'maxHeight');
+
+                css(css(this.$el, 'maxHeight', 150), 'maxHeight', Math.max(150, 150 + height(this.modal) - this.panel.offsetHeight));
+                if (current !== css(this.$el, 'maxHeight')) {
+                    trigger(this.$el, 'resize');
+                }
+            },
+
+            events: ['load', 'resize']
+
+        }
+
+    });
+
+    UIkit.modal.dialog = function (content, options) {
+
+        var dialog = UIkit.modal(`
+            <div class="uk-modal">
+                <div class="uk-modal-dialog">${content}</div>
+             </div>
+        `, options);
+
+        on(dialog.$el, 'hidden', ({target, current}) => {
+            if (target === current) {
+                dialog.$destroy(true);
+            }
+        });
+        dialog.show();
+
+        return dialog;
+    };
+
+    UIkit.modal.alert = function (message, options) {
+
+        options = assign({bgClose: false, escClose: false, labels: UIkit.modal.labels}, options);
+
+        return new Promise(
+            resolve => on(UIkit.modal.dialog(`
+                <div class="uk-modal-body">${isString(message) ? message : html(message)}</div>
+                <div class="uk-modal-footer uk-text-right">
+                    <button class="uk-button uk-button-primary uk-modal-close" autofocus>${options.labels.ok}</button>
+                </div>
+            `, options).$el, 'hide', resolve)
+        );
+    };
+
+    UIkit.modal.confirm = function (message, options) {
+
+        options = assign({bgClose: false, escClose: false, labels: UIkit.modal.labels}, options);
+
+        return new Promise(
+            (resolve, reject) => on(UIkit.modal.dialog(`
+                <div class="uk-modal-body">${isString(message) ? message : html(message)}</div>
+                <div class="uk-modal-footer uk-text-right">
+                    <button class="uk-button uk-button-default uk-modal-close">${options.labels.cancel}</button>
+                    <button class="uk-button uk-button-primary uk-modal-close" autofocus>${options.labels.ok}</button>
+                </div>
+            `, options).$el, 'click', '.uk-modal-footer button', ({target}) => index(target) === 0 ? reject() : resolve())
+        );
+    };
+
+    UIkit.modal.prompt = function (message, value, options) {
+
+        options = assign({bgClose: false, escClose: false, labels: UIkit.modal.labels}, options);
+
+        return new Promise(resolve => {
+
+            var resolved = false,
+                prompt = UIkit.modal.dialog(`
+                    <form class="uk-form-stacked">
+                        <div class="uk-modal-body">
+                            <label>${isString(message) ? message : html(message)}</label>
+                            <input class="uk-input" autofocus>
+                        </div>
+                        <div class="uk-modal-footer uk-text-right">
+                            <button class="uk-button uk-button-default uk-modal-close" type="button">${options.labels.cancel}</button>
+                            <button class="uk-button uk-button-primary">${options.labels.ok}</button>
+                        </div>
+                    </form>
+                `, options),
+                input = $('input', prompt.$el);
+
+            input.value = value;
+
+            on(prompt.$el, 'submit', 'form', e => {
+                e.preventDefault();
+                resolve(input.value);
+                resolved = true;
+                prompt.hide()
+            });
+            on(prompt.$el, 'hide', () => {
+                if (!resolved) {
+                    resolve(null);
+                }
+            });
+
+        });
+    };
+
+    UIkit.modal.labels = {
+        ok: 'Ok',
+        cancel: 'Cancel'
+    }
+
+}

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

@@ -0,0 +1,15 @@
+export default function (UIkit) {
+
+    UIkit.component('nav', UIkit.components.accordion.extend({
+
+        name: 'nav',
+
+        defaults: {
+            targets: '> .uk-parent',
+            toggle: '> a',
+            content: '> ul'
+        }
+
+    }));
+
+}