uikit 3.14.4-dev.fea9fd466 → 3.15.1-dev.f849bb0c8

package/src/js/mixin/togglable.js

@@ -3,7 +3,7 @@ import {
     addClass,
     Animation,
     css,
-    fastdom,
+    dimensions,
     hasClass,
     includes,
     isBoolean,
@@ -11,13 +11,14 @@ import {
     isVisible,
     noop,
     removeClass,
-    scrollParents,
     startsWith,
     toFloat,
     toggleClass,
     toNodes,
     Transition,
     trigger,
+    unwrap,
+    wrapInner,
 } from 'uikit-util';
 
 export default {
@@ -39,26 +40,6 @@ export default {
         transition: 'ease',
         clsEnter: 'uk-togglabe-enter',
         clsLeave: 'uk-togglabe-leave',
-
-        initProps: {
-            overflow: '',
-            maxHeight: '',
-            paddingTop: '',
-            paddingBottom: '',
-            marginTop: '',
-            marginBottom: '',
-            boxShadow: '',
-        },
-
-        hideProps: {
-            overflow: 'hidden',
-            maxHeight: 0,
-            paddingTop: 0,
-            paddingBottom: 0,
-            marginTop: 0,
-            marginBottom: 0,
-            boxShadow: 'none',
-        },
     },
 
     computed: {
@@ -67,7 +48,7 @@ export default {
         },
 
         hasTransition({ animation }) {
-            return startsWith(animation[0], 'slide');
+            return ['slide', 'reveal'].some((transition) => startsWith(animation[0], transition));
         },
     },
 
@@ -160,122 +141,107 @@ function toggleInstant({ _toggle }) {
     };
 }
 
-function toggleTransition(cmp) {
-    switch (cmp.animation[0]) {
-        case 'slide-left':
-            return slideHorizontal(cmp);
-        case 'slide-right':
-            return slideHorizontal(cmp, true);
-    }
-    return slide(cmp);
-}
+export function toggleTransition(cmp) {
+    const [mode = 'reveal', startProp = 'top'] = cmp.animation[0]?.split('-') || [];
 
-export function slide({
-    isToggled,
-    duration,
-    velocity,
-    initProps,
-    hideProps,
-    transition,
-    _toggle,
-}) {
-    return (el, show) => {
-        const inProgress = Transition.inProgress(el);
-        const inner =
-            !inProgress && el.hasChildNodes()
-                ? toFloat(css(el.firstElementChild, 'marginTop')) +
-                  toFloat(css(el.lastElementChild, 'marginBottom'))
-                : 0;
-        const currentHeight = isVisible(el) ? toFloat(css(el, 'height')) + inner : 0;
+    const dirs = [
+        ['left', 'right'],
+        ['top', 'bottom'],
+    ];
+    const dir = dirs[includes(dirs[0], startProp) ? 0 : 1];
+    const end = dir[1] === startProp;
+    const props = ['width', 'height'];
+    const dimProp = props[dirs.indexOf(dir)];
+    const marginProp = `margin-${dir[0]}`;
+    const marginStartProp = `margin-${startProp}`;
 
-        const props = inProgress ? css(el, Object.keys(initProps)) : show ? hideProps : initProps;
+    return async (el, show) => {
+        let { duration, velocity, transition, _toggle } = cmp;
 
-        Transition.cancel(el);
+        let currentDim = dimensions(el)[dimProp];
+
+        const inProgress = Transition.inProgress(el);
+        await Transition.cancel(el);
 
-        if (!isToggled(el)) {
+        if (show) {
             _toggle(el, true);
         }
 
-        css(el, 'maxHeight', '');
-
-        // Update child components first
-        fastdom.flush();
-
-        const endHeight = toFloat(css(el, 'height')) + inner;
-        duration = velocity * endHeight + duration;
-
-        css(el, { ...props, maxHeight: currentHeight });
-
-        return (
-            show
-                ? Transition.start(
-                      el,
-                      { ...initProps, overflow: 'hidden', maxHeight: endHeight },
-                      duration * (1 - currentHeight / endHeight),
-                      transition
-                  )
-                : Transition.start(
-                      el,
-                      hideProps,
-                      duration * (currentHeight / endHeight),
-                      transition
-                  ).then(() => _toggle(el, false))
-        ).then(() => css(el, initProps));
-    };
-}
-
-function slideHorizontal({ isToggled, duration, velocity, transition, _toggle }, right) {
-    return (el, show) => {
-        const visible = isVisible(el);
-        const marginLeft = toFloat(css(el, 'marginLeft'));
-
-        Transition.cancel(el);
+        const prevProps = Object.fromEntries(
+            [
+                'padding',
+                'border',
+                'width',
+                'height',
+                'overflowY',
+                'overflowX',
+                marginProp,
+                marginStartProp,
+            ].map((key) => [key, el.style[key]])
+        );
 
-        const [scrollElement] = scrollParents(el.offsetParent);
-        css(scrollElement, 'overflowX', 'hidden');
+        const dim = dimensions(el);
+        const currentMargin = toFloat(css(el, marginProp));
+        const marginStart = toFloat(css(el, marginStartProp));
+        const endDim = dim[dimProp] + marginStart;
 
-        if (!isToggled(el)) {
-            _toggle(el, true);
+        if (!inProgress && !show) {
+            currentDim += marginStart;
         }
 
-        const width = toFloat(css(el, 'width'));
-        duration = velocity * width + duration;
-
-        const percent = visible ? ((width + marginLeft * (right ? -1 : 1)) / width) * 100 : 0;
+        const [wrapper] = wrapInner(el, '<div>');
+        css(wrapper, {
+            boxSizing: 'border-box',
+            height: dim.height,
+            width: dim.width,
+            ...css(el, [
+                'overflow',
+                'padding',
+                'borderTop',
+                'borderRight',
+                'borderBottom',
+                'borderLeft',
+                'borderImage',
+                marginStartProp,
+            ]),
+        });
 
         css(el, {
-            clipPath: right
-                ? `polygon(0 0,${percent}% 0,${percent}% 100%,0 100%)`
-                : `polygon(${100 - percent}% 0,100% 0,100% 100%,${100 - percent}% 100%)`,
-            marginLeft: (((100 - percent) * (right ? 1 : -1)) / 100) * width,
+            padding: 0,
+            border: 0,
+            minWidth: 0,
+            minHeight: 0,
+            [marginStartProp]: 0,
+            width: dim.width,
+            height: dim.height,
+            overflow: 'hidden',
+            [dimProp]: currentDim,
         });
 
-        return (
-            show
-                ? Transition.start(
-                      el,
-                      {
-                          clipPath: `polygon(0 0,100% 0,100% 100%,0 100%)`,
-                          marginLeft: 0,
-                      },
-                      duration * (1 - percent / 100),
-                      transition
-                  )
-                : Transition.start(
-                      el,
-                      {
-                          clipPath: right
-                              ? `polygon(0 0,0 0,0 100%,0 100%)`
-                              : `polygon(100% 0,100% 0,100% 100%,100% 100%)`,
-                          marginLeft: (right ? 1 : -1) * width,
-                      },
-                      duration * (percent / 100),
-                      transition
-                  ).then(() => _toggle(el, false))
-        ).then(() => {
-            css(scrollElement, 'overflowX', '');
-            css(el, { clipPath: '', marginLeft: '' });
-        });
+        const percent = currentDim / endDim;
+        duration = (velocity * endDim + duration) * (show ? 1 - percent : percent);
+        const endProps = { [dimProp]: show ? endDim : 0 };
+
+        if (end) {
+            css(el, marginProp, endDim - currentDim + currentMargin);
+            endProps[marginProp] = show ? currentMargin : endDim + currentMargin;
+        }
+
+        if (!end ^ (mode === 'reveal')) {
+            css(wrapper, marginProp, -endDim + currentDim);
+            Transition.start(wrapper, { [marginProp]: show ? 0 : -endDim }, duration, transition);
+        }
+
+        try {
+            await Transition.start(el, endProps, duration, transition);
+        } finally {
+            css(el, prevProps);
+            unwrap(wrapper.firstChild);
+
+            if (!show) {
+                _toggle(el, false);
+            }
+        }
     };
 }
 

package/src/js/util/animation.js

@@ -4,7 +4,7 @@ import { css, propName } from './style';
 import { startsWith, toNodes } from './lang';
 import { addClass, hasClass, removeClass, removeClasses } from './class';
 
-export function transition(element, props, duration = 400, timing = 'linear') {
+function transition(element, props, duration = 400, timing = 'linear') {
     duration = Math.round(duration);
     return Promise.all(
         toNodes(element).map(
@@ -50,13 +50,14 @@ export function transition(element, props, duration = 400, timing = 'linear') {
 export const Transition = {
     start: transition,
 
-    stop(element) {
+    async stop(element) {
         trigger(element, 'transitionend');
-        return Promise.resolve();
+        await Promise.resolve();
     },
 
-    cancel(element) {
+    async cancel(element) {
         trigger(element, 'transitioncanceled');
+        await Promise.resolve();
     },
 
     inProgress(element) {
@@ -66,7 +67,7 @@ export const Transition = {
 
 const animationPrefix = 'uk-animation-';
 
-export function animate(element, animation, duration = 200, origin, out) {
+function animate(element, animation, duration = 200, origin, out) {
     return Promise.all(
         toNodes(element).map(
             (element) =>
@@ -100,7 +101,8 @@ export function animate(element, animation, duration = 200, origin, out) {
     );
 }
 
-const inProgress = new RegExp(`${animationPrefix}(enter|leave)`);
+const inProgressRe = new RegExp(`${animationPrefix}(enter|leave)`);
+
 export const Animation = {
     in: animate,
 
@@ -109,7 +111,7 @@ export const Animation = {
     },
 
     inProgress(element) {
-        return inProgress.test(attr(element, 'class'));
+        return inProgressRe.test(attr(element, 'class'));
     },
 
     cancel(element) {

package/src/js/util/class.js

@@ -10,7 +10,9 @@ 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\\s?`, 'g'), '')
+    );
 }
 
 export function replaceClass(element, ...args) {

package/src/js/util/filter.js

@@ -51,12 +51,8 @@ export function matches(element, selector) {
 }
 
 export function closest(element, selector) {
-    if (startsWith(selector, '>')) {
-        selector = selector.slice(1);
-    }
-
     return isElement(element)
-        ? element.closest(selector)
+        ? element.closest(startsWith(selector, '>') ? selector.slice(1) : selector)
         : toNodes(element)
               .map((element) => closest(element, selector))
               .filter(Boolean);
@@ -64,8 +60,8 @@ export function closest(element, selector) {
 
 export function within(element, selector) {
     return isString(selector)
-        ? matches(element, selector) || !!closest(element, selector)
-        : element === selector || toNode(selector).contains(toNode(element));
+        ? !!closest(element, selector)
+        : toNode(selector).contains(toNode(element));
 }
 
 export function parents(element, selector) {