jekyll-uikit 0.1.5 → 0.1.7

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

@@ -0,0 +1,46 @@
+import { css, isVisible, Player } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.component('video', {
+
+        props: {
+            automute: Boolean,
+            autoplay: Boolean,
+        },
+
+        defaults: {automute: false, autoplay: true},
+
+        ready() {
+
+            this.player = new Player(this.$el);
+
+            if (this.automute) {
+                this.player.mute();
+            }
+
+        },
+
+        update: {
+
+            write() {
+
+                if (!this.player) {
+                    return;
+                }
+
+                if (!isVisible(this.$el) || css(this.$el, 'visibility') === 'hidden') {
+                    this.player.pause();
+                } else if (this.autoplay) {
+                    this.player.play();
+                }
+
+            },
+
+            events: ['load']
+
+        },
+
+    });
+
+}

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

@@ -0,0 +1,17 @@
+import Icons from 'icons';
+
+function plugin(UIkit) {
+
+    if (plugin.installed) {
+        return;
+    }
+
+    UIkit.icon.add(Icons);
+
+}
+
+if (typeof window !== 'undefined' && window.UIkit) {
+    window.UIkit.use(plugin);
+}
+
+export default plugin;

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

@@ -0,0 +1,9 @@
+import { addClass } from '../util/index';
+
+export default {
+
+    init() {
+        addClass(this.$el, this.$name);
+    }
+
+}

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

@@ -0,0 +1,21 @@
+import UIkit from '../api/index';
+
+export default {
+
+    props: {
+        container: Boolean
+    },
+
+    defaults: {
+        container: true
+    },
+
+    computed: {
+
+        container({container}) {
+            return container === true && UIkit.container || container && $(container) || UIkit.container;
+        }
+
+    }
+
+}

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

@@ -0,0 +1,17 @@
+import Class from './class';
+import Container from './container';
+import Modal from './modal';
+import Position from './position';
+import Togglable from './togglable';
+
+export { Class, Container, Modal, Position, Togglable }
+
+export default function (UIkit) {
+
+    UIkit.mixin.class = Class;
+    UIkit.mixin.container = Container;
+    UIkit.mixin.modal = Modal;
+    UIkit.mixin.position = Position;
+    UIkit.mixin.togglable = Togglable;
+
+}

data/assets/node_modules/uikit/src/js/mixin/internal/slideshow-animations.js

@@ -0,0 +1,45 @@
+export default function (UIkit) {
+
+    var {css} = UIkit.util;
+
+    var Animations = {
+
+        slide: {
+
+            show(dir) {
+                return [
+                    {transform: translate(dir * -100)},
+                    {transform: translate()}
+                ];
+            },
+
+            percent(current) {
+                return Animations.translated(current);
+            },
+
+            translate(percent, dir) {
+                return [
+                    {transform: translate(dir * -100 * percent)},
+                    {transform: translate(dir * 100 * (1 - percent))}
+                ];
+            }
+
+        },
+
+        translated(el) {
+            return Math.abs(css(el, 'transform').split(',')[4] / el.offsetWidth)
+        }
+
+    };
+
+    return Animations;
+
+};
+
+export function translate(value = 0) {
+    return `translate(${value}${value ? '%' : ''}, 0)`; // currently not translate3d to support IE, translate3d within translate3d does not work while transitioning
+}
+
+export function scale3d(value) {
+    return `scale3d(${value}, ${value}, 1)`;
+}

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

@@ -0,0 +1,229 @@
+import { $, addClass, append, css, doc, docEl, hasClass, on, once, Promise, removeClass, requestAnimationFrame, toMs, transitionend, width, win, within } from '../util/index';
+import Class from './class';
+import Container from './container';
+import Togglable from './togglable';
+
+var active;
+
+export default {
+
+    mixins: [Class, Container, Togglable],
+
+    props: {
+        clsPanel: String,
+        selClose: String,
+        escClose: Boolean,
+        bgClose: Boolean,
+        stack: Boolean
+    },
+
+    defaults: {
+        cls: 'uk-open',
+        escClose: true,
+        bgClose: true,
+        overlay: true,
+        stack: false
+    },
+
+    computed: {
+
+        panel({clsPanel}, $el) {
+            return $(`.${clsPanel}`, $el);
+        },
+
+        transitionElement() {
+            return this.panel;
+        },
+
+        transitionDuration() {
+            return toMs(css(this.transitionElement, 'transitionDuration'));
+        }
+
+    },
+
+    events: [
+
+        {
+
+            name: 'click',
+
+            delegate() {
+                return this.selClose;
+            },
+
+            handler(e) {
+                e.preventDefault();
+                this.hide();
+            }
+
+        },
+
+        {
+
+            name: 'toggle',
+
+            self: true,
+
+            handler(e) {
+
+                if (e.defaultPrevented) {
+                    return;
+                }
+
+                e.preventDefault();
+                this.toggle();
+            }
+
+        },
+
+        {
+
+            name: 'show',
+
+            self: true,
+
+            handler() {
+
+                if (!hasClass(docEl, this.clsPage)) {
+                    this.scrollbarWidth = width(win) - docEl.offsetWidth;
+                    css(doc.body, 'overflowY', this.scrollbarWidth && this.overlay ? 'scroll' : '');
+                }
+
+                addClass(docEl, this.clsPage);
+
+            }
+
+        },
+
+        {
+
+            name: 'hidden',
+
+            self: true,
+
+            handler() {
+
+                var found, prev = this.prev;
+
+                while (prev) {
+
+                    if (prev.clsPage === this.clsPage) {
+                        found = true;
+                        break;
+                    }
+
+                    prev = prev.prev;
+
+                }
+
+                if (!found) {
+                    removeClass(docEl, this.clsPage);
+
+                }
+
+                !this.prev && css(doc.body, 'overflowY', '');
+            }
+
+        }
+
+    ],
+
+    methods: {
+
+        toggle() {
+            return this.isToggled() ? this.hide() : this.show();
+        },
+
+        show() {
+
+            if (this.isToggled()) {
+                return;
+            }
+
+            if (this.container && this.$el.parentNode !== this.container) {
+                append(this.container, this.$el);
+                this._callConnected()
+            }
+
+            var prev = active && active !== this && active;
+
+            active = this;
+
+            if (prev) {
+                if (this.stack) {
+                    this.prev = prev;
+                } else {
+                    prev.hide().then(this.show);
+                    return;
+                }
+            }
+
+            registerEvents();
+
+            return this.toggleNow(this.$el, true);
+        },
+
+        hide() {
+
+            if (!this.isToggled()) {
+                return;
+            }
+
+            active = active && active !== this && active || this.prev;
+
+            if (!active) {
+                deregisterEvents();
+            }
+
+            return this.toggleNow(this.$el, false);
+        },
+
+        getActive() {
+            return active;
+        },
+
+        _toggleImmediate(el, show) {
+            return new Promise(resolve =>
+                requestAnimationFrame(() => {
+                    this._toggle(el, show);
+
+                    if (this.transitionDuration) {
+                        once(this.transitionElement, transitionend, resolve, false, e => e.target === this.transitionElement);
+                    } else {
+                        resolve();
+                    }
+                })
+            );
+        }
+
+    }
+
+}
+
+var events;
+
+function registerEvents() {
+
+    if (events) {
+        return;
+    }
+
+    events = [
+        on(docEl, 'click', ({target, defaultPrevented}) => {
+            if (active && active.bgClose && !defaultPrevented && !within(target, active.panel)) {
+                active.hide();
+            }
+        }),
+        on(doc, 'keydown', e => {
+            if (e.keyCode === 27 && active && active.escClose) {
+                e.preventDefault();
+                active.hide();
+            }
+        })
+    ];
+}
+
+function deregisterEvents() {
+    events && events.forEach(unbind => unbind());
+    events = null;
+}

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

@@ -0,0 +1,68 @@
+import { css, flipPosition, includes, isRtl, positionAt, removeClasses, toggleClass, toNumber } from '../util/index';
+
+export default {
+
+    props: {
+        pos: String,
+        offset: null,
+        flip: Boolean,
+        clsPos: String
+    },
+
+    defaults: {
+        pos: `bottom-${!isRtl ? 'left' : 'right'}`,
+        flip: true,
+        offset: false,
+        clsPos: ''
+    },
+
+    computed: {
+
+        pos({pos}) {
+            return (pos + (!includes(pos, '-') ? '-center' : '')).split('-');
+        },
+
+        dir() {
+            return this.pos[0];
+        },
+
+        align() {
+            return this.pos[1];
+        }
+
+    },
+
+    methods: {
+
+        positionAt(element, target, boundary) {
+
+            removeClasses(element, `${this.clsPos}-(top|bottom|left|right)(-[a-z]+)?`);
+            css(element, {top: '', left: ''});
+
+            var offset = toNumber(this.offset) || 0,
+                axis = this.getAxis(),
+                {x, y} = positionAt(
+                    element,
+                    target,
+                    axis === 'x' ? `${flipPosition(this.dir)} ${this.align}` : `${this.align} ${flipPosition(this.dir)}`,
+                    axis === 'x' ? `${this.dir} ${this.align}` : `${this.align} ${this.dir}`,
+                    axis === 'x' ? `${this.dir === 'left' ? -1 * offset : offset}` : ` ${this.dir === 'top' ? -1 * offset : offset}`,
+                    null,
+                    this.flip,
+                    boundary
+                ).target;
+
+            this.dir = axis === 'x' ? x : y;
+            this.align = axis === 'x' ? y : x;
+
+            toggleClass(element, `${this.clsPos}-${this.dir}-${this.align}`, this.offset === false);
+
+        },
+
+        getAxis() {
+            return this.dir === 'top' || this.dir === 'bottom' ? 'y' : 'x';
+        }
+
+    }
+
+}