jekyll-uikit 0.1.5 → 0.1.7

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

@@ -0,0 +1,54 @@
+import { classify, doc, docEl, Promise, win } from './index';
+
+export const Observer = win.MutationObserver || win.WebKitMutationObserver;
+export const requestAnimationFrame = win.requestAnimationFrame || (fn => setTimeout(fn, 1000 / 60));
+
+var hasTouchEvents = 'ontouchstart' in win;
+var hasPointerEvents = win.PointerEvent;
+export const hasTouch = 'ontouchstart' in win
+    || win.DocumentTouch && doc instanceof DocumentTouch
+    || navigator.msPointerEnabled && navigator.msMaxTouchPoints // IE 10
+    || navigator.pointerEnabled && navigator.maxTouchPoints; // IE >=11
+
+export const pointerDown = !hasTouch ? 'mousedown' : `mousedown ${hasTouchEvents ? 'touchstart' : 'pointerdown'}`;
+export const pointerMove = !hasTouch ? 'mousemove' : `mousemove ${hasTouchEvents ? 'touchmove' : 'pointermove'}`;
+export const pointerUp = !hasTouch ? 'mouseup' : `mouseup ${hasTouchEvents ? 'touchend' : 'pointerup'}`;
+export const pointerEnter = hasTouch && hasPointerEvents ? 'pointerenter' : 'mouseenter';
+export const pointerLeave = hasTouch && hasPointerEvents ? 'pointerleave' : 'mouseleave';
+
+export const transitionend = prefix('transition', 'transition-end');
+export const animationstart = prefix('animation', 'animation-start');
+export const animationend = prefix('animation', 'animation-end');
+
+export function getImage(src) {
+
+    return new Promise((resolve, reject) => {
+        var img = new Image();
+
+        img.onerror = reject;
+        img.onload = () => resolve(img);
+
+        img.src = src;
+    });
+
+}
+
+function prefix(name, event) {
+
+    var ucase = classify(name),
+        lowered = classify(event).toLowerCase(),
+        classified = classify(event),
+        element = doc.body || docEl,
+        names = {
+            [name]: lowered,
+            [`Webkit${ucase}`]: `webkit${classified}`,
+            [`Moz${ucase}`]: lowered,
+            [`o${ucase}`]: `o${classified} o${lowered}`
+        };
+
+    for (name in names) {
+        if (element.style[name] !== undefined) {
+            return names[name];
+        }
+    }
+}

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

@@ -0,0 +1,104 @@
+import { $, $$, closest, doc, isArray, isFunction, isString, toNode, toNodes, win, within } from './index';
+
+export function on(...args) {
+
+    var [target, type, selector, listener, useCapture] = getArgs(args);
+
+    target = toEventTarget(target);
+
+    if (selector) {
+        listener = delegate(target, selector, listener);
+    }
+
+    if (listener.length > 1) {
+        listener = detail(listener);
+    }
+
+    type.split(' ').forEach(type => target.addEventListener(type, listener, useCapture));
+    return () => off(target, type, listener, useCapture);
+}
+
+export function off(target, type, listener, useCapture = false) {
+    type.split(' ').forEach(type => toEventTarget(target).removeEventListener(type, listener, useCapture));
+}
+
+export function once(...args) {
+
+    var [element, type, selector, listener, useCapture, condition] = getArgs(args),
+        off = on(element, type, selector, e => {
+            var result = !condition || condition(e);
+            if (result) {
+                off();
+                listener(e, result);
+            }
+        }, useCapture);
+
+    return off;
+}
+
+export function trigger(target, event, detail) {
+    return toEventTargets(target).reduce((notCanceled, target) =>
+        notCanceled && target.dispatchEvent(createEvent(event, true, true, detail))
+    , true);
+}
+
+export function createEvent(e, bubbles = true, cancelable = false, detail) {
+    if (isString(e)) {
+        var event = doc.createEvent('CustomEvent');
+        event.initCustomEvent(e, bubbles, cancelable, detail);
+        e = event;
+    }
+
+    return e;
+}
+
+function getArgs(args) {
+
+    if (isString(args[0])) {
+        args[0] = $(args[0]);
+    }
+
+    if (isFunction(args[2])) {
+        args.splice(2, 0, false);
+    }
+    return args;
+}
+
+function delegate(element, selector, listener) {
+    return e => {
+
+        var target = e.target,
+            current = selector[0] === '>'
+                ? $$(selector, element).filter(element => within(target, element))[0]
+                : closest(target, selector);
+
+        if (current) {
+            e.delegate = element;
+            e.current = current;
+
+            listener.call(this, e);
+        }
+    }
+}
+
+function detail(listener) {
+    return e => isArray(e.detail) ? listener.apply(listener, [e].concat(e.detail)) : listener(e);
+}
+
+function isEventTarget(target) {
+    return 'EventTarget' in win
+        ? target instanceof EventTarget
+        : 'addEventListener' in target;
+}
+
+function toEventTarget(target) {
+    return isEventTarget(target) ? target : toNode(target);
+}
+
+export function toEventTargets(target) {
+    return isEventTarget(target)
+        ? [target]
+        : isArray(target)
+            ? target.map(toEventTarget).filter(Boolean)
+            : toNodes(target);
+}

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

@@ -0,0 +1,62 @@
+/*
+    Based on:
+    Copyright (c) 2016 Wilson Page wilsonpage@me.com
+    https://github.com/wilsonpage/fastdom
+*/
+
+import { requestAnimationFrame } from './index';
+
+export const fastdom = {
+
+    reads: [],
+    writes: [],
+
+    read(task) {
+        this.reads.push(task);
+        scheduleFlush();
+        return task;
+    },
+
+    write(task) {
+        this.writes.push(task);
+        scheduleFlush();
+        return task;
+    },
+
+    clear(task) {
+        return remove(this.reads, task) || remove(this.writes, task);
+    },
+
+    flush() {
+
+        runTasks(this.reads);
+        runTasks(this.writes.splice(0, this.writes.length));
+
+        this.scheduled = false;
+
+        if (this.reads.length || this.writes.length) {
+            scheduleFlush();
+        }
+
+    }
+
+};
+
+function scheduleFlush() {
+    if (!fastdom.scheduled) {
+        fastdom.scheduled = true;
+        requestAnimationFrame(fastdom.flush.bind(fastdom));
+    }
+}
+
+function runTasks(tasks) {
+    var task;
+    while (task = tasks.shift()) {
+        task();
+    }
+}
+
+function remove(array, item) {
+    var index = array.indexOf(item);
+    return !!~index && !!array.splice(index, 1);
+}

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

@@ -0,0 +1,14 @@
+export * from './lang';
+export * from './selector';
+export * from './attr';
+export * from './dom';
+export * from './style';
+export * from './class';
+export * from './env';
+export * from './event';
+export * from './fastdom';
+export * from './mouse';
+export * from './options';
+export * from './player';
+export * from './position';
+export * from './touch';

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

@@ -0,0 +1,276 @@
+import { getCssVar, on, query } from './index';
+import promiseFn from './promise';
+
+export function bind(fn, context) {
+    return function (a) {
+        var l = arguments.length;
+        return l ? l > 1 ? fn.apply(context, arguments) : fn.call(context, a) : fn.call(context);
+    };
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+export function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+
+export const Promise = 'Promise' in window ? window.Promise : promiseFn;
+
+const classifyRe = /(?:^|[-_\/])(\w)/g;
+
+export function classify(str) {
+    return str.replace(classifyRe, (_, c) => c ? c.toUpperCase() : '');
+}
+
+const hyphenateRe = /([a-z\d])([A-Z])/g;
+
+export function hyphenate(str) {
+    return str
+        .replace(hyphenateRe, '$1-$2')
+        .toLowerCase()
+}
+
+const camelizeRE = /-(\w)/g;
+
+export function camelize(str) {
+    return str.replace(camelizeRE, toUpper)
+}
+
+function toUpper(_, c) {
+    return c ? c.toUpperCase() : ''
+}
+
+export function ucfirst(str) {
+    return str.length ? toUpper(null, str.charAt(0)) + str.slice(1) : '';
+}
+
+var strPrototype = String.prototype;
+var startsWithFn = strPrototype.startsWith || function (search) { return this.lastIndexOf(search, 0) === 0; };
+
+export function startsWith(str, search) {
+    return startsWithFn.call(str, search);
+}
+
+var endsWithFn = strPrototype.endsWith || function (search) { return this.substr(-1 * search.length) === search; };
+
+export function endsWith(str, search) {
+    return endsWithFn.call(str, search);
+}
+
+var includesFn = function (search) { return ~this.indexOf(search); };
+var includesStr = strPrototype.includes || includesFn;
+var includesArray = Array.prototype.includes || includesFn;
+
+export function includes(obj, search) {
+    return obj && (isString(obj) ? includesStr : includesArray).call(obj, search);
+}
+
+export const isArray = Array.isArray;
+
+export function isFunction(obj) {
+    return typeof obj === 'function';
+}
+
+export function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+
+export function isPlainObject(obj) {
+    return isObject(obj) && Object.getPrototypeOf(obj) === Object.prototype;
+}
+
+export function isWindow(obj) {
+    return isObject(obj) && obj === obj.window;
+}
+
+export function isDocument(obj) {
+    return isObject(obj) && obj.nodeType === 9;
+}
+
+export function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+
+export function isString(value) {
+    return typeof value === 'string';
+}
+
+export function isNumber(value) {
+    return typeof value === 'number';
+}
+
+export function isNumeric(value) {
+    return isNumber(value) || isString(value) && !isNaN(value - parseFloat(value));
+}
+
+export function isUndefined(value) {
+    return value === void 0;
+}
+
+export function toBoolean(value) {
+    return isBoolean(value)
+        ? value
+        : value === 'true' || value === '1' || value === ''
+            ? true
+            : value === 'false' || value === '0'
+                ? false
+                : value;
+}
+
+export function toNumber(value) {
+    var number = Number(value);
+    return !isNaN(number) ? number : false;
+}
+
+export function toFloat(value) {
+    return parseFloat(value) || 0;
+}
+
+export function toList(value) {
+    return isArray(value)
+        ? value
+        : isString(value)
+            ? value.split(/,(?![^(]*\))/).map(value => isNumeric(value)
+                ? toNumber(value)
+                : toBoolean(value.trim()))
+            : [value];
+}
+
+var vars = {};
+
+export function toMedia(value) {
+
+    if (isString(value)) {
+        if (value[0] === '@') {
+            var name = `media-${value.substr(1)}`;
+            value = vars[name] || (vars[name] = toFloat(getCssVar(name)));
+        } else if (isNaN(value)) {
+            return value;
+        }
+    }
+
+    return value && !isNaN(value) ? `(min-width: ${value}px)` : false;
+}
+
+export function coerce(type, value, context) {
+
+    if (type === Boolean) {
+        return toBoolean(value);
+    } else if (type === Number) {
+        return toNumber(value);
+    } else if (type === 'query') {
+        return query(value, context);
+    } else if (type === 'list') {
+        return toList(value);
+    } else if (type === 'media') {
+        return toMedia(value);
+    }
+
+    return type ? type(value) : value;
+}
+
+export function toMs(time) {
+    return !time
+        ? 0
+        : endsWith(time, 'ms')
+            ? toFloat(time)
+            : toFloat(time) * 1000;
+}
+
+export function swap(value, a, b) {
+    return value.replace(new RegExp(`${a}|${b}`, 'mg'), function (match) {
+        return match === a ? b : a
+    });
+}
+
+export const assign = Object.assign || function (target, ...args) {
+    target = Object(target);
+    for (var i = 0; i < args.length; i++) {
+        var source = args[i];
+        if (source !== null) {
+            for (var key in source) {
+                if (hasOwn(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+    }
+    return target;
+};
+
+export function each(obj, cb) {
+    for (var key in obj) {
+        if (cb.call(obj[key], obj[key], key) === false) {
+            break;
+        }
+    }
+}
+
+export function clamp(number, min = 0, max = 1) {
+    return Math.min(Math.max(number, min), max);
+}
+
+export function noop() {}
+
+export function intersectRect(r1, r2) {
+    return r1.left <= r2.right &&
+        r2.left <= r1.right &&
+        r1.top <= r2.bottom &&
+        r2.top <= r1.bottom;
+}
+
+export function pointInRect(point, rect) {
+    return intersectRect({top: point.y, bottom: point.y, left: point.x, right: point.x}, rect)
+}
+
+export function ajax(url, options) {
+    return new Promise((resolve, reject) => {
+
+        var env = assign({
+            data: null,
+            method: 'GET',
+            headers: {},
+            xhr: new XMLHttpRequest(),
+            beforeSend: noop,
+            responseType: ''
+        }, options);
+
+        var xhr = env.xhr;
+
+        env.beforeSend(env);
+
+        for (var prop in env) {
+            if (prop in xhr) {
+                try {
+
+                    xhr[prop] = env[prop];
+
+                } catch (e) {}
+            }
+        }
+
+        xhr.open(env.method.toUpperCase(), url);
+
+        for (var header in env.headers) {
+            xhr.setRequestHeader(header, env.headers[header]);
+        }
+
+        on(xhr, 'load', () => {
+
+            if (xhr.status === 0 || xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) {
+                resolve(xhr);
+            } else {
+                reject(assign(Error(xhr.statusText), {
+                    xhr,
+                    status: xhr.status
+                }));
+            }
+
+        });
+
+        on(xhr, 'error', () => reject(assign(Error('Network Error'), {xhr})));
+        on(xhr, 'timeout', () => reject(assign(Error('Network Timeout'), {xhr})));
+
+        xhr.send(env.data);
+    });
+}