jekyll-uikit 0.1.5 → 0.1.7

data/assets/node_modules/uikit/src/js/api/hooks.js

@@ -0,0 +1,121 @@
+import { createEvent, fastdom, includes, ready } from '../util/index';
+
+export default function (UIkit) {
+
+    UIkit.prototype._callHook = function (hook) {
+
+        var handlers = this.$options[hook];
+
+        if (handlers) {
+            handlers.forEach(handler => handler.call(this));
+        }
+    };
+
+    UIkit.prototype._callReady = function () {
+
+        if (this._isReady) {
+            return;
+        }
+
+        this._isReady = true;
+        this._callHook('ready');
+        this._resetComputeds();
+        this._callUpdate();
+    };
+
+    UIkit.prototype._callConnected = function () {
+
+        if (this._connected) {
+            return;
+        }
+
+        if (!includes(UIkit.elements, this.$options.el)) {
+            UIkit.elements.push(this.$options.el);
+        }
+
+        UIkit.instances[this._uid] = this;
+
+        this._initEvents();
+
+        this._callHook('connected');
+        this._connected = true;
+
+        this._initObserver();
+
+        if (!this._isReady) {
+            ready(() => this._callReady());
+        }
+
+        this._callUpdate();
+    };
+
+    UIkit.prototype._callDisconnected = function () {
+
+        if (!this._connected) {
+            return;
+        }
+
+        if (this._observer) {
+            this._observer.disconnect();
+            this._observer = null;
+        }
+
+        var index = UIkit.elements.indexOf(this.$options.el);
+
+        if (~index) {
+            UIkit.elements.splice(index, 1);
+        }
+
+        delete UIkit.instances[this._uid];
+
+        this._unbindEvents();
+        this._callHook('disconnected');
+
+        this._connected = false;
+
+    };
+
+    UIkit.prototype._callUpdate = function (e) {
+
+        e = createEvent(e || 'update');
+
+        var {type, detail} = e;
+
+        if (type === 'update' && detail && detail.mutation) {
+            this._resetComputeds();
+        }
+
+        var updates = this.$options.update, {reads, writes} = this._frames;
+
+        if (!updates) {
+            return;
+        }
+
+        updates.forEach(({read, write, events}, i) => {
+
+            if (type !== 'update' && !includes(events, type)) {
+                return;
+            }
+
+            if (read && !includes(fastdom.reads, reads[i])) {
+                reads[i] = fastdom.read(() => {
+                    if (read.call(this, e) === false && write) {
+                        fastdom.clear(writes[i]);
+                        delete writes[i];
+                    }
+                    delete reads[i];
+                });
+            }
+
+            if (write && !includes(fastdom.writes, writes[i])) {
+                writes[i] = fastdom.write(() => {
+                    write.call(this, e);
+                    delete writes[i];
+                });
+            }
+
+        });
+
+    };
+
+}

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

@@ -0,0 +1,25 @@
+import globalAPI from './global';
+import hooksAPI from './hooks';
+import stateAPI from './state';
+import instanceAPI from './instance';
+import componentAPI from './component';
+import * as util from '../util/index';
+
+var UIkit = function (options) {
+    this._init(options);
+};
+
+UIkit.util = util;
+UIkit.data = '__uikit__';
+UIkit.prefix = 'uk-';
+UIkit.options = {};
+UIkit.instances = {};
+UIkit.elements = [];
+
+globalAPI(UIkit);
+hooksAPI(UIkit);
+stateAPI(UIkit);
+instanceAPI(UIkit);
+componentAPI(UIkit);
+
+export default UIkit;

data/assets/node_modules/uikit/src/js/api/instance.js

@@ -0,0 +1,71 @@
+import { docEl, remove, within } from '../util/index';
+
+export default function (UIkit) {
+
+    const DATA = UIkit.data;
+
+    UIkit.prototype.$mount = function (el) {
+
+        var name = this.$options.name;
+
+        if (!el[DATA]) {
+            el[DATA] = {};
+        }
+
+        if (el[DATA][name]) {
+            return;
+        }
+
+        el[DATA][name] = this;
+
+        this.$el = this.$options.el = this.$options.el || el;
+
+        this._initProps();
+
+        this._callHook('init');
+
+        if (within(el, docEl)) {
+            this._callConnected();
+        }
+    };
+
+    UIkit.prototype.$emit = function (e) {
+        this._callUpdate(e);
+    };
+
+    UIkit.prototype.$update = function (e, parents) {
+        UIkit.update(e, this.$options.el, parents);
+    };
+
+    UIkit.prototype.$reset = function (data) {
+        this._callDisconnected();
+        this._initProps(data);
+        this._callConnected();
+    };
+
+    UIkit.prototype.$destroy = function (removeEl = false) {
+
+        var {el, name} = this.$options;
+
+        if (el) {
+            this._callDisconnected();
+        }
+
+        this._callHook('destroy');
+
+        if (!el || !el[DATA]) {
+            return;
+        }
+
+        delete el[DATA][name];
+
+        if (!Object.keys(el[DATA]).length) {
+            delete el[DATA];
+        }
+
+        if (removeEl) {
+            remove(this.$el);
+        }
+    };
+
+}

data/assets/node_modules/uikit/src/js/api/state.js

@@ -0,0 +1,283 @@
+import { assign, attr, bind, camelize, coerce, data as getData, hasAttr, hasOwn, hyphenate, includes, isArray, isFunction, isPlainObject, isString, isUndefined, mergeOptions, Observer, on, startsWith } from '../util/index';
+
+export default function (UIkit) {
+
+    var uid = 0;
+
+    UIkit.prototype.props = {};
+
+    UIkit.prototype._init = function (options) {
+
+        options = options || {};
+        options = this.$options = mergeOptions(this.constructor.options, options, this);
+
+        this.$el = null;
+        this.$name = UIkit.prefix + hyphenate(this.$options.name);
+        this.$props = {};
+
+        this._frames = {reads: {}, writes: {}};
+        this._events = [];
+
+        this._uid = uid++;
+        this._initData();
+        this._initMethods();
+        this._initComputeds();
+        this._callHook('created');
+
+        if (options.el) {
+            this.$mount(options.el);
+        }
+    };
+
+    UIkit.prototype._initData = function () {
+
+        var {defaults, data = {}, args = [], props = {}, el} = this.$options;
+
+        if (args.length && isArray(data)) {
+            data = data.slice(0, args.length).reduce((data, value, index) => {
+                if (isPlainObject(value)) {
+                    assign(data, value);
+                } else {
+                    data[args[index]] = value;
+                }
+                return data;
+            }, {});
+        }
+
+        for (var key in defaults) {
+            this.$props[key] = this[key] = hasOwn(data, key) && !isUndefined(data[key])
+                ? coerce(props[key], data[key], el)
+                : isArray(defaults[key])
+                    ? defaults[key].concat()
+                    : defaults[key];
+        }
+    };
+
+    UIkit.prototype._initMethods = function () {
+
+        var methods = this.$options.methods;
+
+        if (methods) {
+            for (var key in methods) {
+                this[key] = bind(methods[key], this);
+            }
+        }
+    };
+
+    UIkit.prototype._initComputeds = function () {
+
+        var computed = this.$options.computed;
+
+        this._resetComputeds();
+
+        if (computed) {
+            for (var key in computed) {
+                registerComputed(this, key, computed[key]);
+            }
+        }
+    };
+
+    UIkit.prototype._resetComputeds = function () {
+        this._computeds = {};
+    };
+
+    UIkit.prototype._initProps = function (props) {
+
+        this._resetComputeds();
+        assign(this.$props, props || getProps(this.$options, this.$name));
+
+        var exclude = [this.$options.computed, this.$options.methods];
+        for (var key in this.$props) {
+            if (notIn(exclude, key)) {
+                this[key] = this.$props[key];
+            }
+        }
+    };
+
+    UIkit.prototype._initEvents = function () {
+
+        var events = this.$options.events;
+
+        if (events) {
+
+            events.forEach(event => {
+
+                if (!hasOwn(event, 'handler')) {
+                    for (var key in event) {
+                        registerEvent(this, event[key], key);
+                    }
+                } else {
+                    registerEvent(this, event);
+                }
+
+            });
+        }
+    };
+
+    UIkit.prototype._unbindEvents = function () {
+        this._events.forEach(unbind => unbind());
+        this._events = [];
+    };
+
+    UIkit.prototype._initObserver = function () {
+
+        var {attrs, props, el} = this.$options;
+        if (this._observer || !props || !attrs || !Observer) {
+            return;
+        }
+
+        attrs = isArray(attrs) ? attrs : Object.keys(props).map(key => hyphenate(key));
+
+        this._observer = new Observer(() => {
+
+            var data = getProps(this.$options, this.$name);
+            if (attrs.some(key => !isUndefined(data[key]) && data[key] !== this.$props[key])) {
+                this.$reset(data);
+            }
+
+        });
+
+        this._observer.observe(el, {attributes: true, attributeFilter: attrs.concat([this.$name, `data-${this.$name}`])});
+    };
+
+    function getProps(opts, name) {
+
+        var data = {},
+            {args = [], props = {}, el} = opts,
+            key, prop;
+
+        if (!props) {
+            return data;
+        }
+
+        for (key in props) {
+            prop = hyphenate(key);
+            if (hasAttr(el, prop)) {
+
+                var value = coerce(props[key], attr(el, prop), el);
+
+                if (prop === 'target' && (!value || startsWith(value, '_'))) {
+                    continue;
+                }
+
+                data[key] = value;
+            }
+        }
+
+        var options = parseOptions(getData(el, name), args);
+
+        for (key in options) {
+            prop = camelize(key);
+            if (props[prop] !== undefined) {
+                data[prop] = coerce(props[prop], options[key], el);
+            }
+        }
+
+        return data;
+    }
+
+    function parseOptions(options, args = []) {
+
+        try {
+
+            return !options
+                ? {}
+                : startsWith(options, '{')
+                    ? JSON.parse(options)
+                    : args.length && !includes(options, ':')
+                        ? ({[args[0]]: options})
+                        : options.split(';').reduce((options, option) => {
+                            var [key, value] = option.split(/:(.+)/);
+                            if (key && value) {
+                                options[key.trim()] = value.trim();
+                            }
+                            return options;
+                        }, {});
+
+        } catch (e) {
+            return {};
+        }
+
+    }
+
+    function registerComputed(component, key, cb) {
+        Object.defineProperty(component, key, {
+
+            enumerable: true,
+
+            get() {
+
+                var {_computeds, $props, $el} = component;
+
+                if (!hasOwn(_computeds, key)) {
+                    _computeds[key] = cb.call(component, $props, $el);
+                }
+
+                return _computeds[key];
+            },
+
+            set(value) {
+                component._computeds[key] = value;
+            }
+
+        });
+    }
+
+    function registerEvent(component, event, key) {
+
+        if (!isPlainObject(event)) {
+            event = ({name: key, handler: event});
+        }
+
+        var {name, el, delegate, self, filter, handler} = event;
+        el = isFunction(el)
+            ? el.call(component)
+            : el || component.$el;
+
+        if (isArray(el)) {
+            el.forEach(el => registerEvent(component, assign({}, event, {el}), key));
+            return;
+        }
+
+        if (!el || filter && !filter.call(component)) {
+            return;
+        }
+
+        handler = detail(isString(handler) ? component[handler] : bind(handler, component));
+
+        if (self) {
+            handler = selfFilter(handler);
+        }
+
+        component._events.push(
+            on(
+                el,
+                name,
+                !delegate
+                    ? null
+                    : isString(delegate)
+                        ? delegate
+                        : delegate.call(component),
+                handler
+            )
+        );
+
+    }
+
+    function selfFilter(handler) {
+        return function selfHandler(e) {
+            if (e.target === e.currentTarget || e.target === e.current) {
+                return handler.call(null, e);
+            }
+        }
+    }
+
+    function notIn(options, key) {
+        return options.every(arr => !arr || !hasOwn(arr, key));
+    }
+
+    function detail(listener) {
+        return e => isArray(e.detail) ? listener.apply(listener, [e].concat(e.detail)) : listener(e);
+    }
+
+}