jekyll-uikit 0.1.5 → 0.1.7

data/assets/node_modules/uikit/src/js/util/mouse.js

@@ -0,0 +1,88 @@
+import { doc, offset, on } from './index';
+
+export function MouseTracker() {}
+
+MouseTracker.prototype = {
+
+    positions: [],
+    position: null,
+
+    init() {
+
+        this.positions = [];
+        this.position = null;
+
+        var ticking = false;
+        this.unbind = on(doc, 'mousemove', e => {
+
+            if (ticking) {
+                return;
+            }
+
+            setTimeout(() => {
+
+                var time = Date.now(), length = this.positions.length;
+                if (length && (time - this.positions[length - 1].time > 100)) {
+                    this.positions.splice(0, length);
+                }
+
+                this.positions.push({time, x: e.pageX, y: e.pageY});
+
+                if (this.positions.length > 5) {
+                    this.positions.shift();
+                }
+
+                ticking = false;
+            }, 5);
+
+            ticking = true;
+        });
+
+    },
+
+    cancel() {
+        if (this.unbind) {
+            this.unbind();
+        }
+    },
+
+    movesTo(target) {
+
+        if (this.positions.length < 2) {
+            return false;
+        }
+
+        var p = offset(target),
+            position = this.positions[this.positions.length - 1],
+            prevPos = this.positions[0];
+
+        if (p.left <= position.x && position.x <= p.right && p.top <= position.y && position.y <= p.bottom) {
+            return false;
+        }
+
+        var points = [
+            [{x: p.left, y: p.top}, {x: p.right, y: p.bottom}],
+            [{x: p.right, y: p.top}, {x: p.left, y: p.bottom}]
+        ];
+
+        if (p.right <= position.x) {
+
+        } else if (p.left >= position.x) {
+            points[0].reverse();
+            points[1].reverse();
+        } else if (p.bottom <= position.y) {
+            points[0].reverse();
+        } else if (p.top >= position.y) {
+            points[1].reverse();
+        }
+
+        return !!points.reduce((result, point) => {
+            return result + (slope(prevPos, point[0]) < slope(position, point[0]) && slope(prevPos, point[1]) > slope(position, point[1]));
+        }, 0);
+    }
+
+};
+
+function slope(a, b) {
+    return (b.y - a.y) / (b.x - a.x);
+}

data/assets/node_modules/uikit/src/js/util/options.js

@@ -0,0 +1,85 @@
+import { assign, hasOwn, isArray, isFunction, isUndefined } from './index';
+
+var strats = {};
+
+// concat strategy
+strats.args =
+strats.created =
+strats.events =
+strats.init =
+strats.ready =
+strats.connected =
+strats.disconnected =
+strats.destroy = function (parentVal, childVal) {
+
+    parentVal = parentVal && !isArray(parentVal) ? [parentVal] : parentVal;
+
+    return childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+};
+
+// update strategy
+strats.update = function (parentVal, childVal) {
+    return strats.args(parentVal, isFunction(childVal) ? {read: childVal} : childVal);
+};
+
+// property strategy
+strats.props = function (parentVal, childVal) {
+
+    if (isArray(childVal)) {
+        childVal = childVal.reduce((value, key) => {
+            value[key] = String;
+            return value;
+        }, {});
+    }
+
+    return strats.methods(parentVal, childVal);
+};
+
+// extend strategy
+strats.computed =
+strats.defaults =
+strats.methods = function (parentVal, childVal) {
+    return childVal
+        ? parentVal
+            ? assign({}, parentVal, childVal)
+            : childVal
+        : parentVal;
+};
+
+// default strategy
+var defaultStrat = function (parentVal, childVal) {
+    return isUndefined(childVal) ? parentVal : childVal;
+};
+
+export function mergeOptions(parent, child) {
+
+    var options = {}, key;
+
+    if (child.mixins) {
+        for (var i = 0, l = child.mixins.length; i < l; i++) {
+            parent = mergeOptions(parent, child.mixins[i]);
+        }
+    }
+
+    for (key in parent) {
+        mergeKey(key);
+    }
+
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeKey(key);
+        }
+    }
+
+    function mergeKey(key) {
+        options[key] = (strats[key] || defaultStrat)(parent[key], child[key]);
+    }
+
+    return options;
+}

data/assets/node_modules/uikit/src/js/util/player.js

@@ -0,0 +1,139 @@
+import { assign, attr, includes, isString, once, Promise, toNode, win } from './index';
+
+var id = 0;
+
+export class Player {
+
+    constructor(el) {
+        this.id = ++id;
+        this.el = toNode(el);
+    }
+
+    isVideo() {
+        return this.isYoutube() || this.isVimeo() || this.isHTML5();
+    }
+
+    isHTML5() {
+        return this.el.tagName === 'VIDEO';
+    }
+
+    isIFrame() {
+        return this.el.tagName === 'IFRAME';
+    }
+
+    isYoutube() {
+        return this.isIFrame() && !!this.el.src.match(/\/\/.*?youtube\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/);
+    }
+
+    isVimeo() {
+        return this.isIFrame() && !!this.el.src.match(/vimeo\.com\/video\/.*/);
+    }
+
+    enableApi() {
+
+        if (this.ready) {
+            return this.ready;
+        }
+
+        var youtube = this.isYoutube(), vimeo = this.isVimeo(), poller;
+
+        if (youtube || vimeo) {
+
+            return this.ready = new Promise(resolve => {
+
+                once(this.el, 'load', () => {
+                    if (youtube) {
+                        var listener = () => post(this.el, {event: 'listening', id: this.id});
+                        poller = setInterval(listener, 100);
+                        listener();
+                    }
+                });
+
+                listen(data => youtube && data.id === this.id && data.event === 'onReady' || vimeo && Number(data.player_id) === this.id)
+                    .then(() => {
+                        resolve();
+                        poller && clearInterval(poller);
+                    });
+
+                attr(this.el, 'src', `${this.el.src}${includes(this.el.src, '?') ? '&' : '?'}${youtube ? 'enablejsapi=1' : `api=1&player_id=${id}`}`);
+
+            });
+
+        }
+
+        return Promise.resolve();
+
+    }
+
+    play() {
+
+        if (!this.isVideo()) {
+            return;
+        }
+
+        if (this.isIFrame()) {
+            this.enableApi().then(() => post(this.el, {func: 'playVideo', method: 'play'}))
+        } else if (this.isHTML5()) {
+            this.el.play();
+        }
+    }
+
+    pause() {
+
+        if (!this.isVideo()) {
+            return;
+        }
+
+        if (this.isIFrame()) {
+            this.enableApi().then(() => post(this.el, {func: 'pauseVideo', method: 'pause'}))
+        } else if (this.isHTML5()) {
+            this.el.pause();
+        }
+    }
+
+    mute() {
+
+        if (!this.isVideo()) {
+            return;
+        }
+
+        if (this.isIFrame()) {
+            this.enableApi().then(() => post(this.el, {func: 'mute', method: 'setVolume', value: 0}))
+        } else if (this.isHTML5()) {
+            this.el.muted = true;
+            attr(this.el, 'muted', '');
+        }
+
+    }
+
+}
+
+function post(el, cmd) {
+    try {
+        el.contentWindow.postMessage(JSON.stringify(assign({event: 'command'}, cmd)), '*');
+    } catch (e) {}
+}
+
+function listen(cb) {
+
+    return new Promise(resolve => {
+
+        once(win, 'message', (_, data) => resolve(data), false, ({data}) => {
+
+            if (!data || !isString(data)) {
+                return;
+            }
+
+            try {
+                data = JSON.parse(data);
+            } catch (e) {
+                return;
+            }
+
+            return data && cb(data);
+
+        });
+
+    });
+
+}

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

@@ -0,0 +1,298 @@
+import { css, each, endsWith, includes, isDocument, isUndefined, isVisible, isWindow, toFloat, toNode, ucfirst } from './index';
+
+var dirs = {
+        width: ['x', 'left', 'right'],
+        height: ['y', 'top', 'bottom']
+    };
+
+export function positionAt(element, target, elAttach, targetAttach, elOffset, targetOffset, flip, boundary) {
+
+    elAttach = getPos(elAttach);
+    targetAttach = getPos(targetAttach);
+
+    var flipped = {element: elAttach, target: targetAttach};
+
+    if (!element || !target) {
+        return flipped;
+    }
+
+    var dim = getDimensions(element),
+        targetDim = getDimensions(target),
+        position = targetDim;
+
+    moveTo(position, elAttach, dim, -1);
+    moveTo(position, targetAttach, targetDim, 1);
+
+    elOffset = getOffsets(elOffset, dim.width, dim.height);
+    targetOffset = getOffsets(targetOffset, targetDim.width, targetDim.height);
+
+    elOffset['x'] += targetOffset['x'];
+    elOffset['y'] += targetOffset['y'];
+
+    position.left += elOffset['x'];
+    position.top += elOffset['y'];
+
+    boundary = getDimensions(boundary || getWindow(element));
+
+    if (flip) {
+        each(dirs, ([dir, align, alignFlip], prop) => {
+
+            if (!(flip === true || includes(flip, dir))) {
+                return;
+            }
+
+            var elemOffset = elAttach[dir] === align
+                    ? -dim[prop]
+                    : elAttach[dir] === alignFlip
+                        ? dim[prop]
+                        : 0,
+                targetOffset = targetAttach[dir] === align
+                    ? targetDim[prop]
+                    : targetAttach[dir] === alignFlip
+                        ? -targetDim[prop]
+                        : 0;
+
+            if (position[align] < boundary[align] || position[align] + dim[prop] > boundary[alignFlip]) {
+
+                var centerOffset = dim[prop] / 2,
+                    centerTargetOffset = targetAttach[dir] === 'center' ? -targetDim[prop] / 2 : 0;
+
+                elAttach[dir] === 'center' && (
+                    apply(centerOffset, centerTargetOffset)
+                    || apply(-centerOffset, -centerTargetOffset)
+                ) || apply(elemOffset, targetOffset);
+
+            }
+
+            function apply(elemOffset, targetOffset) {
+
+                var newVal = position[align] + elemOffset + targetOffset - elOffset[dir] * 2;
+
+                if (newVal >= boundary[align] && newVal + dim[prop] <= boundary[alignFlip]) {
+                    position[align] = newVal;
+
+                    ['element', 'target'].forEach((el) => {
+                        flipped[el][dir] = !elemOffset
+                            ? flipped[el][dir]
+                            : flipped[el][dir] === dirs[prop][1]
+                                ? dirs[prop][2]
+                                : dirs[prop][1];
+                    });
+
+                    return true;
+                }
+
+            }
+
+        });
+    }
+
+    offset(element, position);
+
+    return flipped;
+}
+
+export function offset(element, coordinates) {
+
+    element = toNode(element);
+
+    if (coordinates) {
+
+        var currentOffset = offset(element),
+            pos = css(element, 'position');
+
+        ['left', 'top'].forEach(prop => {
+            if (prop in coordinates) {
+                var value = css(element, prop);
+                element.style[prop] = `${(coordinates[prop] - currentOffset[prop]) 
+                    + toFloat(pos === 'absolute' && value === 'auto' ? position(element)[prop] : value)
+                }px`;
+            }
+        });
+
+        return;
+    }
+
+    return getDimensions(element);
+}
+
+function getDimensions(element) {
+
+    element = toNode(element);
+
+    var {pageYOffset: top, pageXOffset: left} = getWindow(element);
+
+    if (isWindow(element)) {
+
+        var height = element.innerHeight,
+            width = element.innerWidth;
+
+        return {
+            top,
+            left,
+            height,
+            width,
+            bottom: top + height,
+            right: left + width,
+        }
+    }
+
+    var display = false;
+    if (!isVisible(element)) {
+        display = element.style.display;
+        element.style.display = 'block';
+    }
+
+    var rect = element.getBoundingClientRect();
+
+    if (display !== false) {
+        element.style.display = display;
+    }
+
+    return {
+        height: rect.height,
+        width: rect.width,
+        top: rect.top + top,
+        left: rect.left + left,
+        bottom: rect.bottom + top,
+        right: rect.right + left,
+    }
+}
+
+export function position(element) {
+    element = toNode(element);
+
+    var parent = offsetParent(element),
+        parentOffset = parent === docEl(element) ? {top: 0, left: 0} : offset(parent);
+
+    return ['top', 'left'].reduce((props, prop) => {
+        var propName = ucfirst(prop);
+        props[prop] -= parentOffset[prop]
+            + (toFloat(css(element, `margin${propName}`)) || 0)
+            + (toFloat(css(parent, `border${propName}Width`)) || 0);
+        return props;
+    }, offset(element));
+}
+
+function offsetParent(element) {
+
+    var parent = toNode(element).offsetParent;
+
+    while (parent && css(parent, 'position') === 'static') {
+        parent = parent.offsetParent;
+    }
+
+    return parent || docEl(element);
+}
+
+export const height = dimension('height');
+export const width = dimension('width');
+
+function dimension(prop) {
+    var propName = ucfirst(prop);
+    return (element, value) => {
+
+        element = toNode(element);
+
+        if (isUndefined(value)) {
+
+            if (isWindow(element)) {
+                return element[`inner${propName}`];
+            }
+
+            if (isDocument(element)) {
+                var doc = element.documentElement;
+                return Math.max(doc.offsetHeight, doc.scrollHeight);
+            }
+
+            value = css(element, prop);
+            value = value === 'auto' ? element[`offset${propName}`] : toFloat(value) || 0;
+
+            return getContentSize(prop, element, value);
+
+        } else {
+
+            css(element, prop, !value && value !== 0
+                ? ''
+                : getContentSize(prop, element, value) + 'px'
+            );
+
+        }
+
+    }
+}
+
+function getContentSize(prop, element, value) {
+    return css(element, 'boxSizing') === 'border-box' ? dirs[prop].slice(1).map(ucfirst).reduce((value, prop) =>
+        value
+            - toFloat(css(element, `padding${prop}`))
+            - toFloat(css(element, `border${prop}Width`))
+    , value) : value;
+}
+
+function getWindow(element) {
+    return isWindow(element) ? element : document(element).defaultView;
+}
+
+function moveTo(position, attach, dim, factor) {
+    each(dirs, function ([dir, align, alignFlip], prop) {
+        if (attach[dir] === alignFlip) {
+            position[align] += dim[prop] * factor;
+        } else if (attach[dir] === 'center') {
+            position[align] += dim[prop] * factor / 2;
+        }
+    });
+}
+
+function getPos(pos) {
+
+    var x = /left|center|right/, y = /top|center|bottom/;
+
+    pos = (pos || '').split(' ');
+
+    if (pos.length === 1) {
+        pos = x.test(pos[0])
+            ? pos.concat(['center'])
+            : y.test(pos[0])
+                ? ['center'].concat(pos)
+                : ['center', 'center'];
+    }
+
+    return {
+        x: x.test(pos[0]) ? pos[0] : 'center',
+        y: y.test(pos[1]) ? pos[1] : 'center'
+    };
+}
+
+function getOffsets(offsets, width, height) {
+
+    var [x, y] = (offsets || '').split(' ');
+
+    return {
+        x: x ? toFloat(x) * (endsWith(x, '%') ? width / 100 : 1) : 0,
+        y: y ? toFloat(y) * (endsWith(y, '%') ? height / 100 : 1) : 0
+    };
+}
+
+export function flipPosition(pos) {
+    switch (pos) {
+        case 'left':
+            return 'right';
+        case 'right':
+            return 'left';
+        case 'top':
+            return 'bottom';
+        case 'bottom':
+            return 'top';
+        default:
+            return pos;
+    }
+}
+
+function document(element) {
+    return toNode(element).ownerDocument;
+}
+
+function docEl(element) {
+    return document(element).documentElement;
+}