uikit 3.11.2-dev.bbaa4362f → 3.11.2-dev.c7ed3c19b

package/src/js/uikit.js

@@ -1,9 +1,7 @@
 import UIkit from './uikit-core';
 import * as components from './components/index';
-import {each} from 'uikit-util';
+import { each } from 'uikit-util';
 
-each(components, (component, name) =>
-    UIkit.component(name, component)
-);
+each(components, (component, name) => UIkit.component(name, component));
 
 export default UIkit;

package/src/js/util/ajax.js

@@ -1,17 +1,18 @@
-import {on} from './event';
-import {Promise} from './promise';
-import {assign, isString, noop} from './lang';
+import { on } from './event';
+import { assign, noop } from './lang';
 
 export function ajax(url, options) {
-
-    const env = assign({
-        data: null,
-        method: 'GET',
-        headers: {},
-        xhr: new XMLHttpRequest(),
-        beforeSend: noop,
-        responseType: ''
-    }, options);
+    const env = assign(
+        {
+            data: null,
+            method: 'GET',
+            headers: {},
+            xhr: new XMLHttpRequest(),
+            beforeSend: noop,
+            responseType: '',
+        },
+        options
+    );
 
     return Promise.resolve()
         .then(() => env.beforeSend(env))
@@ -20,15 +21,15 @@ export function ajax(url, options) {
 
 function send(url, env) {
     return new Promise((resolve, reject) => {
-        let {xhr} = env;
+        const { xhr } = env;
 
         for (const prop in env) {
             if (prop in xhr) {
                 try {
-
                     xhr[prop] = env[prop];
-
-                } catch (e) {}
+                } catch (e) {
+                    // noop
+                }
             }
         }
 
@@ -39,51 +40,34 @@ function send(url, env) {
         }
 
         on(xhr, 'load', () => {
-
-            if (xhr.status === 0 || xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) {
-
-                // IE 11 does not support responseType 'json'
-                if (env.responseType === 'json' && isString(xhr.response)) {
-                    xhr = assign(copyXhr(xhr), {response: JSON.parse(xhr.response)});
-                }
-
+            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
-                }));
+                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})));
+        on(xhr, 'error', () => reject(assign(Error('Network Error'), { xhr })));
+        on(xhr, 'timeout', () => reject(assign(Error('Network Timeout'), { xhr })));
 
         xhr.send(env.data);
     });
 }
 
 export function getImage(src, srcset, sizes) {
-
     return new Promise((resolve, reject) => {
         const img = new Image();
 
-        img.onerror = e => reject(e);
+        img.onerror = (e) => reject(e);
         img.onload = () => resolve(img);
 
         sizes && (img.sizes = sizes);
         srcset && (img.srcset = srcset);
         img.src = src;
     });
-
-}
-
-function copyXhr(source) {
-    const target = {};
-    for (const key in source) {
-        target[key] = source[key];
-    }
-    return target;
 }

package/src/js/util/animation.js

@@ -1,49 +1,57 @@
-import {attr} from './attr';
-import {Promise} from './promise';
-import {once, trigger} from './event';
-import {css, propName} from './style';
-import {assign, startsWith, toNodes} from './lang';
-import {addClass, hasClass, removeClass, removeClasses} from './class';
+import { attr } from './attr';
+import { once, trigger } from './event';
+import { css, propName } from './style';
+import { assign, startsWith, toNodes } from './lang';
+import { addClass, hasClass, removeClass, removeClasses } from './class';
 
 export function transition(element, props, duration = 400, timing = 'linear') {
-
-    return Promise.all(toNodes(element).map(element =>
-        new Promise((resolve, reject) => {
-
-            for (const name in props) {
-                const value = css(element, name);
-                if (value === '') {
-                    css(element, name, value);
-                }
-            }
-
-            const timer = setTimeout(() => trigger(element, 'transitionend'), duration);
-
-            once(element, 'transitionend transitioncanceled', ({type}) => {
-                clearTimeout(timer);
-                removeClass(element, 'uk-transition');
-                css(element, {
-                    transitionProperty: '',
-                    transitionDuration: '',
-                    transitionTimingFunction: ''
-                });
-                type === 'transitioncanceled' ? reject() : resolve(element);
-            }, {self: true});
-
-            addClass(element, 'uk-transition');
-            css(element, assign({
-                transitionProperty: Object.keys(props).map(propName).join(','),
-                transitionDuration: `${duration}ms`,
-                transitionTimingFunction: timing
-            }, props));
-
-        })
-    ));
-
+    return Promise.all(
+        toNodes(element).map(
+            (element) =>
+                new Promise((resolve, reject) => {
+                    for (const name in props) {
+                        const value = css(element, name);
+                        if (value === '') {
+                            css(element, name, value);
+                        }
+                    }
+
+                    const timer = setTimeout(() => trigger(element, 'transitionend'), duration);
+
+                    once(
+                        element,
+                        'transitionend transitioncanceled',
+                        ({ type }) => {
+                            clearTimeout(timer);
+                            removeClass(element, 'uk-transition');
+                            css(element, {
+                                transitionProperty: '',
+                                transitionDuration: '',
+                                transitionTimingFunction: '',
+                            });
+                            type === 'transitioncanceled' ? reject() : resolve(element);
+                        },
+                        { self: true }
+                    );
+
+                    addClass(element, 'uk-transition');
+                    css(
+                        element,
+                        assign(
+                            {
+                                transitionProperty: Object.keys(props).map(propName).join(','),
+                                transitionDuration: `${duration}ms`,
+                                transitionTimingFunction: timing,
+                            },
+                            props
+                        )
+                    );
+                })
+        )
+    );
 }
 
 export const Transition = {
-
     start: transition,
 
     stop(element) {
@@ -57,47 +65,47 @@ export const Transition = {
 
     inProgress(element) {
         return hasClass(element, 'uk-transition');
-    }
-
+    },
 };
 
 const animationPrefix = 'uk-animation-';
 
 export function animate(element, animation, duration = 200, origin, out) {
-
-    return Promise.all(toNodes(element).map(element =>
-        new Promise((resolve, reject) => {
-
-            trigger(element, 'animationcanceled');
-            const timer = setTimeout(() => trigger(element, 'animationend'), duration);
-
-            once(element, 'animationend animationcanceled', ({type}) => {
-
-                clearTimeout(timer);
-
-                type === 'animationcanceled' ? reject() : resolve(element);
-
-                css(element, 'animationDuration', '');
-                removeClasses(element, `${animationPrefix}\\S*`);
-
-            }, {self: true});
-
-            css(element, 'animationDuration', `${duration}ms`);
-            addClass(element, animation, animationPrefix + (out ? 'leave' : 'enter'));
-
-            if (startsWith(animation, animationPrefix)) {
-                origin && addClass(element, `uk-transform-origin-${origin}`);
-                out && addClass(element, `${animationPrefix}reverse`);
-            }
-
-        })
-    ));
-
+    return Promise.all(
+        toNodes(element).map(
+            (element) =>
+                new Promise((resolve, reject) => {
+                    trigger(element, 'animationcanceled');
+                    const timer = setTimeout(() => trigger(element, 'animationend'), duration);
+
+                    once(
+                        element,
+                        'animationend animationcanceled',
+                        ({ type }) => {
+                            clearTimeout(timer);
+
+                            type === 'animationcanceled' ? reject() : resolve(element);
+
+                            css(element, 'animationDuration', '');
+                            removeClasses(element, `${animationPrefix}\\S*`);
+                        },
+                        { self: true }
+                    );
+
+                    css(element, 'animationDuration', `${duration}ms`);
+                    addClass(element, animation, animationPrefix + (out ? 'leave' : 'enter'));
+
+                    if (startsWith(animation, animationPrefix)) {
+                        origin && addClass(element, `uk-transform-origin-${origin}`);
+                        out && addClass(element, `${animationPrefix}reverse`);
+                    }
+                })
+        )
+    );
 }
 
 const inProgress = new RegExp(`${animationPrefix}(enter|leave)`);
 export const Animation = {
-
     in: animate,
 
     out(element, animation, duration, origin) {
@@ -110,6 +118,5 @@ export const Animation = {
 
     cancel(element) {
         trigger(element, 'animationcanceled');
-    }
-
+    },
 };

package/src/js/util/attr.js

@@ -1,7 +1,6 @@
-import {isFunction, isObject, isUndefined, toNode, toNodes} from './lang';
+import { isFunction, isObject, isUndefined, toNode, toNodes } from './lang';
 
 export function attr(element, name, value) {
-
     if (isObject(name)) {
         for (const key in name) {
             attr(element, key, name[key]);
@@ -10,42 +9,39 @@ export function attr(element, name, value) {
     }
 
     if (isUndefined(value)) {
-        element = toNode(element);
-        return element && element.getAttribute(name);
+        return toNode(element)?.getAttribute(name);
     } else {
-        toNodes(element).forEach(element => {
-
+        for (const el of toNodes(element)) {
             if (isFunction(value)) {
-                value = value.call(element, attr(element, name));
+                value = value.call(el, attr(el, name));
             }
 
             if (value === null) {
-                removeAttr(element, name);
+                removeAttr(el, name);
             } else {
-                element.setAttribute(name, value);
+                el.setAttribute(name, value);
             }
-        });
+        }
     }
-
 }
 
 export function hasAttr(element, name) {
-    return toNodes(element).some(element => element.hasAttribute(name));
+    return toNodes(element).some((element) => element.hasAttribute(name));
 }
 
 export function removeAttr(element, name) {
-    element = toNodes(element);
-    name.split(' ').forEach(name =>
-        element.forEach(element =>
-            element.hasAttribute(name) && element.removeAttribute(name)
-        )
-    );
+    const elements = toNodes(element);
+    for (const attribute of name.split(' ')) {
+        for (const element of elements) {
+            element.removeAttribute(attribute);
+        }
+    }
 }
 
 export function data(element, attribute) {
-    for (let i = 0, attrs = [attribute, `data-${attribute}`]; i < attrs.length; i++) {
-        if (hasAttr(element, attrs[i])) {
-            return attr(element, attrs[i]);
+    for (const name of [attribute, `data-${attribute}`]) {
+        if (hasAttr(element, name)) {
+            return attr(element, name);
         }
     }
 }

package/src/js/util/class.js

@@ -1,5 +1,5 @@
-import {attr} from './attr';
-import {isUndefined, toNodes} from './lang';
+import { attr } from './attr';
+import { isUndefined, toNodes } from './lang';
 
 export function addClass(element, ...args) {
     apply(element, args, 'add');
@@ -10,7 +10,7 @@ export function removeClass(element, ...args) {
 }
 
 export function removeClasses(element, cls) {
-    attr(element, 'class', value => (value || '').replace(new RegExp(`\\b${cls}\\b`, 'g'), ''));
+    attr(element, 'class', (value) => (value || '').replace(new RegExp(`\\b${cls}\\b`, 'g'), ''));
 }
 
 export function replaceClass(element, ...args) {
@@ -20,9 +20,8 @@ export function replaceClass(element, ...args) {
 
 export function hasClass(element, cls) {
     [cls] = getClasses(cls);
-    const nodes = toNodes(element);
-    for (let n = 0; n < nodes.length; n++) {
-        if (cls && nodes[n].classList.contains(cls)) {
+    for (const node of toNodes(element)) {
+        if (cls && node.classList.contains(cls)) {
             return true;
         }
     }
@@ -30,64 +29,27 @@ export function hasClass(element, cls) {
 }
 
 export function toggleClass(element, cls, force) {
+    const classes = getClasses(cls);
 
-    cls = getClasses(cls);
+    if (!isUndefined(force)) {
+        force = !!force;
+    }
 
-    const nodes = toNodes(element);
-    for (let n = 0; n < nodes.length; n++) {
-        const list = nodes[n].classList;
-        for (let i = 0; i < cls.length; i++) {
-            if (isUndefined(force)) {
-                list.toggle(cls[i]);
-            } else if (supports.Force) {
-                list.toggle(cls[i], !!force);
-            } else {
-                list[force ? 'add' : 'remove'](cls[i]);
-            }
+    for (const node of toNodes(element)) {
+        for (const cls of classes) {
+            node.classList.toggle(cls, force);
         }
     }
 }
 
 function apply(element, args, fn) {
-
     args = args.reduce((args, arg) => args.concat(getClasses(arg)), []);
 
-    const nodes = toNodes(element);
-    for (let n = 0; n < nodes.length; n++) {
-        if (supports.Multiple) {
-            nodes[n].classList[fn](...args);
-        } else {
-            args.forEach(cls => nodes[n].classList[fn](cls));
-        }
+    for (const node of toNodes(element)) {
+        node.classList[fn](...args);
     }
 }
 
 function getClasses(str) {
     return String(str).split(/\s|,/).filter(Boolean);
 }
-
-// IE 11
-let supports = {
-
-    get Multiple() {
-        return this.get('Multiple');
-    },
-
-    get Force() {
-        return this.get('Force');
-    },
-
-    get(key) {
-
-        const {classList} = document.createElement('_');
-        classList.add('a', 'b');
-        classList.toggle('c', false);
-        supports = {
-            Multiple: classList.contains('b'),
-            Force: !classList.contains('c')
-        };
-
-        return supports[key];
-    }
-
-};