uikit 3.11.2-dev.21a5b7139 → 3.11.2-dev.29f2881ed

package/src/js/core/svg.js

@@ -5,10 +5,12 @@ import {
     append,
     attr,
     includes,
+    isTag,
     isVisible,
     isVoidElement,
     memoize,
     noop,
+    once,
     remove,
     removeAttr,
     startsWith,
@@ -94,6 +96,12 @@ export default {
 
     methods: {
         async getSvg() {
+            if (isTag(this.$el, 'img') && !this.$el.complete && this.$el.loading === 'lazy') {
+                return new Promise((resolve) =>
+                    once(this.$el, 'load', () => resolve(this.getSvg()))
+                );
+            }
+
             return parseSVG(await loadSVG(this.src), this.icon) || Promise.reject('SVG not found.');
         },
 
@@ -193,7 +201,7 @@ export function getMaxPathLength(el) {
 }
 
 function insertSVG(el, root) {
-    if (isVoidElement(root) || root.tagName === 'CANVAS') {
+    if (isVoidElement(root) || isTag(root, 'canvas')) {
         root.hidden = true;
 
         const next = root.nextElementSibling;
@@ -205,11 +213,7 @@ function insertSVG(el, root) {
 }
 
 function equals(el, other) {
-    return isSVG(el) && isSVG(other) && innerHTML(el) === innerHTML(other);
-}
-
-function isSVG(el) {
-    return el?.tagName === 'svg';
+    return isTag(el, 'svg') && isTag(other, 'svg') && innerHTML(el) === innerHTML(other);
 }
 
 function innerHTML(el) {

package/src/js/core/toggle.js

@@ -7,6 +7,7 @@ import {
     includes,
     isBoolean,
     isFocusable,
+    isTag,
     isTouch,
     matches,
     once,
@@ -134,7 +135,7 @@ export default {
             name: 'keydown',
 
             filter() {
-                return includes(this.mode, 'click') && this.$el.tagName !== 'INPUT';
+                return includes(this.mode, 'click') && !isTag(this.$el, 'input');
             },
 
             handler(e) {
@@ -216,10 +217,10 @@ export default {
             const leaving = this.target.filter((el) => hasClass(el, this.clsLeave));
 
             if (leaving.length) {
-                this.target.forEach((el) => {
+                for (const el of this.target) {
                     const isLeaving = includes(leaving, el);
                     this.toggleElement(el, isLeaving, isLeaving);
-                });
+                }
                 return;
             }
 

package/src/js/mixin/internal/animate-slide.js

@@ -1,5 +1,4 @@
 import {
-    assign,
     children,
     css,
     fastdom,
@@ -44,7 +43,7 @@ export default function (action, target, duration) {
 
                 // Reset to previous state
                 nodes.forEach((el, i) => propsFrom[i] && css(el, propsFrom[i]));
-                css(target, assign({ display: 'block' }, targetProps));
+                css(target, { display: 'block', ...targetProps });
 
                 // Start transitions on next frame
                 requestAnimationFrame(() => {
@@ -76,16 +75,14 @@ function getProps(el, opacity) {
     const zIndex = css(el, 'zIndex');
 
     return isVisible(el)
-        ? assign(
-              {
-                  display: '',
-                  opacity: opacity ? css(el, 'opacity') : '0',
-                  pointerEvents: 'none',
-                  position: 'absolute',
-                  zIndex: zIndex === 'auto' ? index(el) : zIndex,
-              },
-              getPositionWithMargin(el)
-          )
+        ? {
+              display: '',
+              opacity: opacity ? css(el, 'opacity') : '0',
+              pointerEvents: 'none',
+              position: 'absolute',
+              zIndex: zIndex === 'auto' ? index(el) : zIndex,
+              ...getPositionWithMargin(el),
+          }
         : false;
 }
 

package/src/js/mixin/parallax.js

@@ -4,11 +4,11 @@ import {
     css,
     Dimensions,
     each,
+    findIndex,
     isNumber,
     isString,
     isUndefined,
     noop,
-    startsWith,
     toFloat,
     toPx,
     trigger,
@@ -79,39 +79,35 @@ export default {
     },
 };
 
-function transformFn(prop, el, steps) {
-    const unit = getUnit(steps) || { x: 'px', y: 'px', rotate: 'deg' }[prop] || '';
+function transformFn(prop, el, stops) {
+    const unit = getUnit(stops) || { x: 'px', y: 'px', rotate: 'deg' }[prop] || '';
+    let transformFn;
 
     if (prop === 'x' || prop === 'y') {
         prop = `translate${ucfirst(prop)}`;
+        transformFn = (stop) => toFloat(toFloat(stop).toFixed(unit === 'px' ? 0 : 6));
     }
 
-    steps = steps.map(toFloat);
-
-    if (steps.length === 1) {
-        steps.unshift(prop === 'scale' ? 1 : 0);
+    if (stops.length === 1) {
+        stops.unshift(prop === 'scale' ? 1 : 0);
     }
 
-    return (css, percent) => {
-        let value = getValue(steps, percent);
+    stops = parseStops(stops, transformFn);
 
-        if (startsWith(prop, 'translate')) {
-            value = toFloat(value).toFixed(unit === 'px' ? 0 : 6);
-        }
-
-        css.transform += ` ${prop}(${value}${unit})`;
+    return (css, percent) => {
+        css.transform += ` ${prop}(${getValue(stops, percent)}${unit})`;
     };
 }
 
-function colorFn(prop, el, steps) {
-    if (steps.length === 1) {
-        steps.unshift(getCssValue(el, prop, ''));
+function colorFn(prop, el, stops) {
+    if (stops.length === 1) {
+        stops.unshift(getCssValue(el, prop, ''));
     }
 
-    steps = steps.map((step) => parseColor(el, step));
+    stops = parseStops(stops, (stop) => parseColor(el, stop));
 
     return (css, percent) => {
-        const [start, end, p] = getStep(steps, percent);
+        const [start, end, p] = getStop(stops, percent);
         const value = start
             .map((value, i) => {
                 value += p * (end[i] - value);
@@ -131,85 +127,83 @@ function parseColor(el, color) {
         .map(toFloat);
 }
 
-function filterFn(prop, el, steps) {
-    if (steps.length === 1) {
-        steps.unshift(0);
+function filterFn(prop, el, stops) {
+    if (stops.length === 1) {
+        stops.unshift(0);
     }
 
-    const unit = getUnit(steps) || { blur: 'px', hue: 'deg' }[prop] || '%';
+    const unit = getUnit(stops) || { blur: 'px', hue: 'deg' }[prop] || '%';
     prop = { fopacity: 'opacity', hue: 'hue-rotate' }[prop] || prop;
-    steps = steps.map(toFloat);
+    stops = parseStops(stops);
 
     return (css, percent) => {
-        const value = getValue(steps, percent);
+        const value = getValue(stops, percent);
         css.filter += ` ${prop}(${value + unit})`;
     };
 }
 
-function cssPropFn(prop, el, steps) {
-    if (steps.length === 1) {
-        steps.unshift(getCssValue(el, prop, ''));
+function cssPropFn(prop, el, stops) {
+    if (stops.length === 1) {
+        stops.unshift(getCssValue(el, prop, ''));
     }
 
-    steps = steps.map(toFloat);
+    stops = parseStops(stops);
 
     return (css, percent) => {
-        css[prop] = getValue(steps, percent);
+        css[prop] = getValue(stops, percent);
     };
 }
 
-function strokeFn(prop, el, steps) {
-    if (steps.length === 1) {
-        steps.unshift(0);
+function strokeFn(prop, el, stops) {
+    if (stops.length === 1) {
+        stops.unshift(0);
     }
 
-    const unit = getUnit(steps);
-    steps = steps.map(toFloat);
+    const unit = getUnit(stops);
+    const length = getMaxPathLength(el);
+    stops = parseStops(stops.reverse(), (stop) => {
+        stop = toFloat(stop);
+        return unit === '%' ? (stop * length) / 100 : stop;
+    });
 
-    if (!steps.some((step) => step)) {
+    if (!stops.some(([value]) => value)) {
         return noop;
     }
 
-    const length = getMaxPathLength(el);
     css(el, 'strokeDasharray', length);
 
-    if (unit === '%') {
-        steps = steps.map((step) => (step * length) / 100);
-    }
-
-    steps = steps.reverse();
-
     return (css, percent) => {
-        css.strokeDashoffset = getValue(steps, percent);
+        css.strokeDashoffset = getValue(stops, percent);
     };
 }
 
-function backgroundFn(prop, el, steps) {
-    if (steps.length === 1) {
-        steps.unshift(0);
+function backgroundFn(prop, el, stops) {
+    if (stops.length === 1) {
+        stops.unshift(0);
     }
 
     prop = prop.substr(-1);
     const attr = prop === 'y' ? 'height' : 'width';
-    steps = steps.map((step) => toPx(step, attr, el));
+    stops = parseStops(stops, (stop) => toPx(stop, attr, el));
 
     const bgPos = getCssValue(el, `background-position-${prop}`, '');
 
     return getCssValue(el, 'backgroundSize', '') === 'cover'
-        ? backgroundCoverFn(prop, el, steps, bgPos, attr)
-        : setBackgroundPosFn(prop, steps, bgPos);
+        ? backgroundCoverFn(prop, el, stops, bgPos, attr)
+        : setBackgroundPosFn(prop, stops, bgPos);
 }
 
-function backgroundCoverFn(prop, el, steps, bgPos, attr) {
+function backgroundCoverFn(prop, el, stops, bgPos, attr) {
     const dimImage = getBackgroundImageDimensions(el);
 
     if (!dimImage.width) {
         return noop;
     }
 
-    const min = Math.min(...steps);
-    const max = Math.max(...steps);
-    const down = steps.indexOf(min) < steps.indexOf(max);
+    const values = stops.map(([value]) => value);
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    const down = values.indexOf(min) < values.indexOf(max);
 
     const diff = max - min;
     let pos = (down ? -diff : 0) - (down ? min : max);
@@ -234,7 +228,7 @@ function backgroundCoverFn(prop, el, steps, bgPos, attr) {
 
     const dim = Dimensions.cover(dimImage, dimEl);
 
-    const fn = setBackgroundPosFn(prop, steps, `${pos}px`);
+    const fn = setBackgroundPosFn(prop, stops, `${pos}px`);
     return (css, percent) => {
         fn(css, percent);
         css.backgroundSize = `${dim.width}px ${dim.height}px`;
@@ -242,9 +236,9 @@ function backgroundCoverFn(prop, el, steps, bgPos, attr) {
     };
 }
 
-function setBackgroundPosFn(prop, steps, pos) {
+function setBackgroundPosFn(prop, stops, pos) {
     return function (css, percent) {
-        css[`background-position-${prop}`] = `calc(${pos} + ${getValue(steps, percent)}px)`;
+        css[`background-position-${prop}`] = `calc(${pos} + ${getValue(stops, percent)}px)`;
     };
 }
 
@@ -278,27 +272,71 @@ function toDimensions(image) {
     };
 }
 
-function getStep(steps, percent) {
-    const count = steps.length - 1;
-    const index = Math.min(Math.floor(count * percent), count - 1);
+function parseStops(stops, fn = toFloat) {
+    const result = [];
+    const { length } = stops;
+    let nullIndex = 0;
+    for (let i = 0; i < length; i++) {
+        let [value, percent] = isString(stops[i]) ? stops[i].trim().split(' ') : [stops[i]];
+        value = fn(value);
+        percent = percent ? toFloat(percent) / 100 : null;
+
+        if (i === 0) {
+            if (percent === null) {
+                percent = 0;
+            } else if (percent) {
+                result.push([value, 0]);
+            }
+        } else if (i === length - 1) {
+            if (percent === null) {
+                percent = 1;
+            } else if (percent !== 1) {
+                result.push([value, percent]);
+                percent = 1;
+            }
+        }
+
+        result.push([value, percent]);
+
+        if (percent === null) {
+            nullIndex++;
+        } else if (nullIndex) {
+            const leftPercent = result[i - nullIndex - 1][1];
+            const p = (percent - leftPercent) / (nullIndex + 1);
+            for (let j = nullIndex; j > 0; j--) {
+                result[i - j][1] = leftPercent + p * (nullIndex - j + 1);
+            }
+
+            nullIndex = 0;
+        }
+    }
+
+    return result;
+}
 
-    return steps
-        .slice(index, index + 2)
-        .concat(percent === 1 ? 1 : (percent % (1 / count)) * count);
+function getStop(stops, percent) {
+    const index = findIndex(stops.slice(1), ([, targetPercent]) => percent <= targetPercent) + 1;
+    return [
+        stops[index - 1][0],
+        stops[index][0],
+        (percent - stops[index - 1][1]) / (stops[index][1] - stops[index - 1][1]),
+    ];
 }
 
-function getValue(steps, percent) {
-    const [start, end, p] = getStep(steps, percent);
+function getValue(stops, percent) {
+    const [start, end, p] = getStop(stops, percent);
     return isNumber(start) ? start + Math.abs(start - end) * p * (start < end ? 1 : -1) : +end;
 }
 
-function getUnit(steps, defaultUnit) {
-    return (
-        steps.reduce(
-            (unit, step) => unit || (isString(step) && step.replace(/[\d-]/g, '').trim()),
-            ''
-        ) || defaultUnit
-    );
+const unitRe = /^-?\d+([^\s]*)/;
+function getUnit(stops, defaultUnit) {
+    for (const stop of stops) {
+        const match = stop.match?.(unitRe);
+        if (match) {
+            return match[1];
+        }
+    }
+    return defaultUnit;
 }
 
 function getCssValue(el, prop, value) {

package/src/js/mixin/slider-drag.js

@@ -26,17 +26,17 @@ export default {
     },
 
     created() {
-        ['start', 'move', 'end'].forEach((key) => {
+        for (const key of ['start', 'move', 'end']) {
             const fn = this[key];
             this[key] = (e) => {
                 const pos = getEventPos(e).x * (isRtl ? -1 : 1);
 
-                this.prevPos = pos !== this.pos ? this.pos : this.prevPos;
+                this.prevPos = pos === this.pos ? this.prevPos : this.pos;
                 this.pos = pos;
 
                 fn(e);
             };
-        });
+        }
     },
 
     events: [

package/src/js/mixin/slider-nav.js

@@ -61,7 +61,7 @@ export default {
     methods: {
         updateNav() {
             const i = this.getValidIndex();
-            this.navItems.forEach((el) => {
+            for (const el of this.navItems) {
                 const cmd = data(el, this.attrItem);
 
                 toggleClass(el, this.clsActive, toNumber(cmd) === i);
@@ -71,7 +71,7 @@ export default {
                     this.finite &&
                         ((cmd === 'previous' && i === 0) || (cmd === 'next' && i >= this.maxIndex))
                 );
-            });
+            }
         },
     },
 };

package/src/js/mixin/slider.js

@@ -4,7 +4,6 @@ import SliderNav from './slider-nav';
 import {
     $,
     $$,
-    assign,
     clamp,
     fastdom,
     getIndex,
@@ -170,21 +169,14 @@ export default {
         },
 
         _show(prev, next, force) {
-            this._transitioner = this._getTransitioner(
-                prev,
-                next,
-                this.dir,
-                assign(
-                    {
-                        easing: force
-                            ? next.offsetWidth < 600
-                                ? 'cubic-bezier(0.25, 0.46, 0.45, 0.94)' /* easeOutQuad */
-                                : 'cubic-bezier(0.165, 0.84, 0.44, 1)' /* easeOutQuart */
-                            : this.easing,
-                    },
-                    this.transitionOptions
-                )
-            );
+            this._transitioner = this._getTransitioner(prev, next, this.dir, {
+                easing: force
+                    ? next.offsetWidth < 600
+                        ? 'cubic-bezier(0.25, 0.46, 0.45, 0.94)' /* easeOutQuad */
+                        : 'cubic-bezier(0.165, 0.84, 0.44, 1)' /* easeOutQuart */
+                    : this.easing,
+                ...this.transitionOptions,
+            });
 
             if (!force && !prev) {
                 this._translate(1);

package/src/js/mixin/slideshow.js

@@ -1,7 +1,7 @@
 import Animations from './internal/slideshow-animations';
 import Transitioner from './internal/slideshow-transitioner';
 import Slider from './slider.js';
-import { addClass, assign, removeClass } from 'uikit-util';
+import { addClass, removeClass } from 'uikit-util';
 
 export default {
     mixins: [Slider],
@@ -19,7 +19,7 @@ export default {
 
     computed: {
         animation({ animation, Animations }) {
-            return assign(Animations[animation] || Animations.slide, { name: animation });
+            return { ...(Animations[animation] || Animations.slide), name: animation };
         },
 
         transitionOptions() {

package/src/js/mixin/togglable.js

@@ -2,7 +2,6 @@ import {
     $$,
     addClass,
     Animation,
-    assign,
     css,
     fastdom,
     hasClass,
@@ -175,7 +174,7 @@ export function toggleHeight({ isToggled, duration, initProps, hideProps, transi
             show
                 ? Transition.start(
                       el,
-                      assign({}, initProps, { overflow: 'hidden', height: endHeight }),
+                      { ...initProps, overflow: 'hidden', height: endHeight },
                       Math.round(duration * (1 - currentHeight / endHeight)),
                       transition
                   )

package/src/js/util/ajax.js

@@ -2,18 +2,15 @@ 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 = {
+        data: null,
+        method: 'GET',
+        headers: {},
+        xhr: new XMLHttpRequest(),
+        beforeSend: noop,
+        responseType: '',
+        ...options,
+    };
     return Promise.resolve()
         .then(() => env.beforeSend(env))
         .then(() => send(url, env));
@@ -63,8 +60,12 @@ export function getImage(src, srcset, sizes) {
     return new Promise((resolve, reject) => {
         const img = new Image();
 
-        img.onerror = (e) => reject(e);
-        img.onload = () => resolve(img);
+        img.onerror = (e) => {
+            reject(e);
+        };
+        img.onload = () => {
+            resolve(img);
+        };
 
         sizes && (img.sizes = sizes);
         srcset && (img.srcset = srcset);

package/src/js/util/animation.js

@@ -1,7 +1,7 @@
 import { attr } from './attr';
 import { once, trigger } from './event';
 import { css, propName } from './style';
-import { assign, startsWith, toNodes } from './lang';
+import { startsWith, toNodes } from './lang';
 import { addClass, hasClass, removeClass, removeClasses } from './class';
 
 export function transition(element, props, duration = 400, timing = 'linear') {
@@ -35,17 +35,12 @@ export function transition(element, props, duration = 400, timing = 'linear') {
                     );
 
                     addClass(element, 'uk-transition');
-                    css(
-                        element,
-                        assign(
-                            {
-                                transitionProperty: Object.keys(props).map(propName).join(','),
-                                transitionDuration: `${duration}ms`,
-                                transitionTimingFunction: timing,
-                            },
-                            props
-                        )
-                    );
+                    css(element, {
+                        transitionProperty: Object.keys(props).map(propName).join(','),
+                        transitionDuration: `${duration}ms`,
+                        transitionTimingFunction: timing,
+                        ...props,
+                    });
                 })
         )
     );

package/src/js/util/attr.js

@@ -11,17 +11,17 @@ export function attr(element, name, value) {
     if (isUndefined(value)) {
         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);
             }
-        });
+        }
     }
 }
 
@@ -30,16 +30,18 @@ export function hasAttr(element, 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/dimensions.js

@@ -37,8 +37,8 @@ export function offset(element, coordinates) {
     const currentOffset = dimensions(element);
 
     if (element) {
-        const { pageYOffset, pageXOffset } = toWindow(element);
-        const offsetBy = { height: pageYOffset, width: pageXOffset };
+        const { scrollY, scrollX } = toWindow(element);
+        const offsetBy = { height: scrollY, width: scrollX };
 
         for (const dir in dirs) {
             for (const i in dirs[dir]) {
@@ -104,8 +104,8 @@ export function offsetPosition(element) {
 
         if (css(element, 'position') === 'fixed') {
             const win = toWindow(element);
-            offset[0] += win.pageYOffset;
-            offset[1] += win.pageXOffset;
+            offset[0] += win.scrollY;
+            offset[1] += win.scrollX;
             return offset;
         }
     } while ((element = element.offsetParent));