uikit 3.14.3 → 3.14.4-dev.10a07fe5a

package/package.json

@@ -2,7 +2,7 @@
     "name": "uikit",
     "title": "UIkit",
     "description": "UIkit is a lightweight and modular front-end framework for developing fast and powerful web interfaces.",
-    "version": "3.14.3",
+    "version": "3.14.4-dev.10a07fe5a",
     "main": "dist/js/uikit.js",
     "style": "dist/css/uikit.css",
     "sideEffects": [

package/src/js/core/accordion.js

@@ -1,6 +1,6 @@
 import Class from '../mixin/class';
 import Lazyload from '../mixin/lazyload';
-import { default as Togglable, toggleHeight } from '../mixin/togglable';
+import { slide, default as Togglable } from '../mixin/togglable';
 import {
     $,
     $$,
@@ -34,7 +34,7 @@ export default {
     data: {
         targets: '> *',
         active: false,
-        animation: [true],
+        animation: ['slide'],
         collapsible: true,
         multiple: false,
         clsOpen: 'uk-open',
@@ -144,7 +144,7 @@ export default {
                     }
 
                     hide(content, false);
-                    await toggleHeight(this)(el._wrapper, show);
+                    await slide(this)(el._wrapper, show);
                     hide(content, !show);
 
                     delete el._wrapper;

package/src/js/core/alert.js

@@ -11,7 +11,7 @@ export default {
     },
 
     data: {
-        animation: [true],
+        animation: ['slide'],
         selClose: '.uk-alert-close',
         duration: 150,
         hideProps: { opacity: 0, ...Togglable.data.hideProps },

package/src/js/core/drop.js

@@ -8,7 +8,6 @@ import {
     apply,
     attr,
     css,
-    getCssVar,
     hasClass,
     includes,
     isTouch,
@@ -16,6 +15,7 @@ import {
     MouseTracker,
     observeResize,
     offset,
+    offsetViewport,
     on,
     once,
     parent,
@@ -28,9 +28,9 @@ import {
     removeClass,
     scrollParents,
     toggleClass,
-    toPx,
     within,
 } from 'uikit-util';
+import { preventBackgroundScroll, preventOverscroll } from '../mixin/modal';
 
 export let active;
 
@@ -48,6 +48,8 @@ export default {
         delayHide: Number,
         display: String,
         clsDrop: String,
+        animateOut: Boolean,
+        bgScroll: Boolean,
     },
 
     data: {
@@ -62,6 +64,8 @@ export default {
         animation: ['uk-animation-fade'],
         cls: 'uk-open',
         container: false,
+        animateOut: false,
+        bgScroll: true,
     },
 
     created() {
@@ -249,7 +253,11 @@ export default {
                         }
                     }),
 
-                    ...(this.display === 'static'
+                    ...(this.bgScroll
+                        ? []
+                        : [preventOverscroll(this.$el), preventBackgroundScroll()]),
+
+                    ...(this.display === 'static' && this.align !== 'stretch'
                         ? []
                         : (() => {
                               const handler = () => this.$emit();
@@ -310,7 +318,7 @@ export default {
     methods: {
         show(target = this.target, delay = true) {
             if (this.isToggled() && target && this.target && target !== this.target) {
-                this.hide(false);
+                this.hide(false, false);
             }
 
             this.target = target;
@@ -330,7 +338,7 @@ export default {
                 let prev;
                 while (active && prev !== active && !within(this.$el, active.$el)) {
                     prev = active;
-                    active.hide(false);
+                    active.hide(false, false);
                 }
             }
 
@@ -344,8 +352,8 @@ export default {
             );
         },
 
-        hide(delay = true) {
-            const hide = () => this.toggleElement(this.$el, false, false);
+        hide(delay = true, animate = true) {
+            const hide = () => this.toggleElement(this.$el, false, this.animateOut && animate);
 
             this.clearTimers();
 
@@ -377,40 +385,59 @@ export default {
         position() {
             removeClass(this.$el, `${this.clsDrop}-stack`);
             toggleClass(this.$el, `${this.clsDrop}-boundary`, this.boundaryAlign);
+            toggleClass(this.$el, `${this.clsDrop}-stretch`, this.align === 'stretch');
 
             const boundary = query(this.boundary, this.$el);
-            const scrollParentOffset = offset(
-                scrollParents(boundary && this.boundaryAlign ? boundary : this.$el)[0]
+            const target = boundary && this.boundaryAlign ? boundary : this.target;
+            const [scrollParent] = scrollParents(
+                boundary && this.boundaryAlign ? boundary : this.$el
             );
+            const scrollParentOffset = offset(scrollParent);
             const boundaryOffset = boundary ? offset(boundary) : scrollParentOffset;
+            const viewportOffset = this.getViewportOffset(this.$el);
 
             css(this.$el, 'maxWidth', '');
-            const maxWidth =
-                scrollParentOffset.width -
-                2 * toPx(getCssVar('position-viewport-offset', this.$el));
+            const maxWidth = scrollParentOffset.width - 2 * viewportOffset;
 
-            if (this.pos[1] === 'justify') {
+            if (this.align === 'justify') {
                 const prop = this.axis === 'y' ? 'width' : 'height';
                 css(
                     this.$el,
                     prop,
                     Math.min(
                         (boundary ? boundaryOffset : offset(this.target))[prop],
-                        scrollParentOffset[prop] -
-                            2 * toPx(getCssVar('position-viewport-offset', this.$el))
+                        scrollParentOffset[prop] - 2 * viewportOffset
                     )
                 );
+            } else if (this.align === 'stretch') {
+                this.flip = this.axis === 'y' ? 'x' : 'y';
+                this.display = 'static';
+
+                const viewport = offsetViewport(scrollParent);
+                const targetDim = offset(target);
+                const elOffset = Math.abs(this.getPositionOffset(this.$el)) + viewportOffset;
+
+                css(this.$el, {
+                    width:
+                        this.axis === 'y'
+                            ? viewport.width
+                            : (this.dir === 'left'
+                                  ? targetDim.left - viewport.left
+                                  : viewport.right - targetDim.right) - elOffset,
+                    height:
+                        this.axis === 'x'
+                            ? viewport.height
+                            : (this.dir === 'top'
+                                  ? targetDim.top - viewport.top
+                                  : viewport.bottom - targetDim.bottom) - elOffset,
+                });
             } else if (this.$el.offsetWidth > maxWidth) {
                 addClass(this.$el, `${this.clsDrop}-stack`);
             }
 
             css(this.$el, 'maxWidth', maxWidth);
 
-            this.positionAt(
-                this.$el,
-                boundary && this.boundaryAlign ? boundary : this.target,
-                boundary
-            );
+            this.positionAt(this.$el, target, boundary);
         },
     },
 };

package/src/js/core/height-viewport.js

@@ -4,12 +4,13 @@ import {
     css,
     dimensions,
     endsWith,
-    height,
     isNumeric,
     isString,
     isVisible,
-    offset,
+    offsetPosition,
+    offsetViewport,
     query,
+    scrollParents,
     toFloat,
 } from 'uikit-util';
 
@@ -32,7 +33,7 @@ export default {
 
     resizeTargets() {
         // check for offsetTop change
-        return [this.$el, document.documentElement];
+        return [this.$el, ...scrollParents(this.$el, /auto|scroll/)];
     },
 
     update: {
@@ -44,21 +45,25 @@ export default {
             let minHeight = '';
             const box = boxModelAdjust(this.$el, 'height', 'content-box');
 
+            const [scrollElement] = scrollParents(this.$el, /auto|scroll/);
+            const { height: viewportHeight } = offsetViewport(scrollElement);
+
             if (this.expand) {
                 minHeight = Math.max(
-                    height(window) -
-                        (dimensions(document.documentElement).height -
-                            dimensions(this.$el).height) -
+                    viewportHeight -
+                        (dimensions(scrollElement).height - dimensions(this.$el).height) -
                         box,
                     0
                 );
             } else {
                 // on mobile devices (iOS and Android) window.innerHeight !== 100vh
-                minHeight = 'calc(100vh';
+                minHeight = `calc(${
+                    document.scrollingElement === scrollElement ? '100vh' : `${viewportHeight}px`
+                }`;
 
                 if (this.offsetTop) {
-                    const { top } = offset(this.$el);
-                    minHeight += top > 0 && top < height(window) / 2 ? ` - ${top}px` : '';
+                    const top = offsetPosition(this.$el)[0] - offsetPosition(scrollElement)[0];
+                    minHeight += top > 0 && top < viewportHeight / 2 ? ` - ${top}px` : '';
                 }
 
                 if (this.offsetBottom === true) {

package/src/js/core/navbar.js

@@ -285,8 +285,8 @@ export default {
                 return this.dropbar;
             },
 
-            handler(_, { $el }) {
-                if (!hasClass($el, this.clsDrop)) {
+            handler(_, { $el, align }) {
+                if (!hasClass($el, this.clsDrop) || align === 'stretch') {
                     return;
                 }
 
@@ -309,8 +309,8 @@ export default {
                 return this.dropbar;
             },
 
-            handler(_, { $el }) {
-                if (!hasClass($el, this.clsDrop)) {
+            handler(_, { $el, align }) {
+                if (!hasClass($el, this.clsDrop) || align === 'stretch') {
                     return;
                 }
 
@@ -360,8 +360,8 @@ export default {
                 return this.dropbar;
             },
 
-            handler(_, { $el }) {
-                if (!hasClass($el, this.clsDrop)) {
+            handler(_, { $el, align }) {
+                if (!hasClass($el, this.clsDrop) || align === 'stretch') {
                     return;
                 }
 
@@ -387,7 +387,7 @@ export default {
 
             el = oldHeight < newHeight && el;
 
-            css(el, 'clip', `rect(0,${el.offsetWidth}px,${oldHeight}px,0)`);
+            css(el, 'clipPath', `polygon(0 0,100% 0,100% ${oldHeight}px,0 ${oldHeight}px)`);
 
             height(dropbar, oldHeight);
 
@@ -396,12 +396,14 @@ export default {
                 Transition.start(dropbar, { height: newHeight }, this.duration),
                 Transition.start(
                     el,
-                    { clip: `rect(0,${el.offsetWidth}px,${newHeight}px,0)` },
+                    {
+                        clipPath: `polygon(0 0,100% 0,100% ${newHeight}px,0 ${newHeight}px)`,
+                    },
                     this.duration
                 ),
             ])
                 .catch(noop)
-                .then(() => css(el, { clip: '' }));
+                .then(() => css(el, { clipPath: '' }));
         },
 
         getDropdown(el) {

package/src/js/core/offcanvas.js

@@ -93,22 +93,6 @@ export default {
             },
         },
 
-        {
-            name: 'touchstart',
-
-            passive: true,
-
-            el() {
-                return this.panel;
-            },
-
-            handler({ targetTouches }) {
-                if (targetTouches.length === 1) {
-                    this.clientY = targetTouches[0].clientY;
-                }
-            },
-        },
-
         {
             name: 'touchmove',
 
@@ -124,33 +108,6 @@ export default {
             },
         },
 
-        {
-            name: 'touchmove',
-
-            passive: false,
-
-            el() {
-                return this.panel;
-            },
-
-            handler(e) {
-                if (e.targetTouches.length !== 1) {
-                    return;
-                }
-
-                const clientY = e.targetTouches[0].clientY - this.clientY;
-                const { scrollTop, scrollHeight, clientHeight } = this.panel;
-
-                if (
-                    clientHeight >= scrollHeight ||
-                    (scrollTop === 0 && clientY > 0) ||
-                    (scrollHeight - scrollTop <= clientHeight && clientY < 0)
-                ) {
-                    e.cancelable && e.preventDefault();
-                }
-            },
-        },
-
         {
             name: 'show',
 
@@ -162,7 +119,6 @@ export default {
                     addClass(parent(this.panel), this.clsMode);
                 }
 
-                css(document.documentElement, 'overflowY', this.overlay ? 'hidden' : '');
                 addClass(document.body, this.clsContainer, this.clsFlip);
                 css(document.body, 'touch-action', 'pan-y pinch-zoom');
                 css(this.$el, 'display', 'block');
@@ -170,7 +126,7 @@ export default {
                 addClass(
                     this.panel,
                     this.clsSidebarAnimation,
-                    this.mode !== 'reveal' ? this.clsMode : ''
+                    this.mode === 'reveal' ? '' : this.clsMode
                 );
 
                 height(document.body); // force reflow
@@ -207,8 +163,6 @@ export default {
                 removeClass(this.$el, this.clsOverlay);
                 css(this.$el, 'display', '');
                 removeClass(document.body, this.clsContainer, this.clsFlip);
-
-                css(document.documentElement, 'overflowY', '');
             },
         },
 

package/src/js/core/switcher.js

@@ -48,7 +48,7 @@ export default {
 
             watch(connects) {
                 if (this.swiping) {
-                    css(connects, 'touch-action', 'pan-y pinch-zoom');
+                    css(connects, 'touchAction', 'pan-y pinch-zoom');
                 }
 
                 const index = this.index();

package/src/js/mixin/modal.js

@@ -2,6 +2,7 @@ import {
     $,
     addClass,
     append,
+    apply,
     attr,
     css,
     endsWith,
@@ -15,6 +16,7 @@ import {
     pointerDown,
     pointerUp,
     removeClass,
+    scrollParents,
     toFloat,
     width,
     within,
@@ -121,17 +123,26 @@ export default {
             self: true,
 
             handler() {
-                const docEl = document.documentElement;
+                once(
+                    this.$el,
+                    'hide',
+                    on(document, 'focusin', (e) => {
+                        if (!within(e.target, this.panel)) {
+                            this.$el.focus();
+                        }
+                    })
+                );
 
-                if (width(window) > docEl.clientWidth && this.overlay) {
-                    css(document.body, 'overflowY', 'scroll');
+                if (this.overlay) {
+                    once(this.$el, 'hide', preventOverscroll(this.$el));
+                    once(this.$el, 'hide', preventBackgroundScroll());
                 }
 
                 if (this.stack) {
                     css(this.$el, 'zIndex', toFloat(css(this.$el, 'zIndex')) + active.length);
                 }
 
-                addClass(docEl, this.clsPage);
+                addClass(document.documentElement, this.clsPage);
 
                 if (this.bgClose) {
                     once(
@@ -273,3 +284,78 @@ function animate({ transitionElement, _toggle }) {
 function toMs(time) {
     return time ? (endsWith(time, 'ms') ? toFloat(time) : toFloat(time) * 1000) : 0;
 }
+
+export function preventOverscroll(el) {
+    if (CSS.supports('overscroll-behavior', 'contain')) {
+        const elements = filterChildren(el, (child) => /auto|scroll/.test(css(child, 'overflow')));
+        css(elements, 'overscrollBehavior', 'contain');
+        return () => css(elements, 'overscrollBehavior', '');
+    }
+
+    let startClientY;
+
+    const events = [
+        on(
+            el,
+            'touchstart',
+            ({ targetTouches }) => {
+                if (targetTouches.length === 1) {
+                    startClientY = targetTouches[0].clientY;
+                }
+            },
+            { passive: true }
+        ),
+
+        on(
+            el,
+            'touchmove',
+            (e) => {
+                if (e.targetTouches.length !== 1) {
+                    return;
+                }
+
+                let [scrollParent] = scrollParents(e.target, /auto|scroll/);
+                if (!within(scrollParent, el)) {
+                    scrollParent = el;
+                }
+
+                const clientY = e.targetTouches[0].clientY - startClientY;
+                const { scrollTop, scrollHeight, clientHeight } = scrollParent;
+
+                if (
+                    clientHeight >= scrollHeight ||
+                    (scrollTop === 0 && clientY > 0) ||
+                    (scrollHeight - scrollTop <= clientHeight && clientY < 0)
+                ) {
+                    e.cancelable && e.preventDefault();
+                }
+            },
+            { passive: false }
+        ),
+    ];
+
+    return () => events.forEach((fn) => fn());
+}
+
+export function preventBackgroundScroll() {
+    const { body, documentElement } = document;
+    css(body, {
+        overflowY: width(window) > documentElement.clientWidth ? 'scroll' : '',
+        touchAction: 'none',
+    });
+    css(documentElement, 'overflowY', 'hidden');
+    return () => {
+        css(documentElement, 'overflowY', '');
+        css(body, { overflowY: '', touchAction: '' });
+    };
+}
+
+function filterChildren(el, fn) {
+    const children = [];
+    apply(el, (node) => {
+        if (fn(node)) {
+            children.push(node);
+        }
+    });
+    return children;
+}

package/src/js/mixin/position.js

@@ -1,4 +1,13 @@
-import { flipPosition, getCssVar, includes, isRtl, positionAt, toPx } from 'uikit-util';
+import {
+    css,
+    dimensions,
+    flipPosition,
+    getCssVar,
+    includes,
+    isRtl,
+    positionAt,
+    toPx,
+} from 'uikit-util';
 
 export default {
     props: {
@@ -15,23 +24,17 @@ export default {
 
     connected() {
         this.pos = this.$props.pos.split('-').concat('center').slice(0, 2);
-        this.axis = includes(['top', 'bottom'], this.pos[0]) ? 'y' : 'x';
+        [this.dir, this.align] = this.pos;
+        this.axis = includes(['top', 'bottom'], this.dir) ? 'y' : 'x';
     },
 
     methods: {
         positionAt(element, target, boundary) {
-            const [dir, align] = this.pos;
-
-            let offset = toPx(
-                this.offset === false ? getCssVar('position-offset', element) : this.offset,
-                this.axis === 'x' ? 'width' : 'height',
-                element
-            );
-            offset = [includes(['left', 'top'], dir) ? -offset : +offset, 0];
+            let offset = [this.getPositionOffset(element), this.getShiftOffset(element)];
 
             const attach = {
-                element: [flipPosition(dir), align],
-                target: [dir, align],
+                element: [flipPosition(this.dir), this.align],
+                target: [this.dir, this.align],
             };
 
             if (this.axis === 'y') {
@@ -41,13 +44,41 @@ export default {
                 offset = offset.reverse();
             }
 
+            // Ensure none positioned element does not generate scrollbars
+            const elDim = dimensions(element);
+            css(element, { top: -elDim.height, left: -elDim.width });
+
             positionAt(element, target, {
                 attach,
                 offset,
                 boundary,
                 flip: this.flip,
-                viewportOffset: toPx(getCssVar('position-viewport-offset', element)),
+                viewportOffset: this.getViewportOffset(element),
             });
         },
+
+        getPositionOffset(element) {
+            return (
+                toPx(
+                    this.offset === false ? getCssVar('position-offset', element) : this.offset,
+                    this.axis === 'x' ? 'width' : 'height',
+                    element
+                ) * (includes(['left', 'top'], this.dir) ? -1 : 1)
+            );
+        },
+
+        getShiftOffset(element) {
+            return includes(['center', 'justify', 'stretch'], this.align)
+                ? 0
+                : toPx(
+                      getCssVar('position-shift-offset', element),
+                      this.axis === 'y' ? 'width' : 'height',
+                      element
+                  ) * (includes(['left', 'top'], this.align) ? 1 : -1);
+        },
+
+        getViewportOffset(element) {
+            return toPx(getCssVar('position-viewport-offset', element));
+        },
     },
 };