uikit 3.13.2-dev.13a8eb3ff → 3.13.2-dev.696f00752

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.13.2-dev.13a8eb3ff",
+    "version": "3.13.2-dev.696f00752",
     "main": "dist/js/uikit.js",
     "style": "dist/css/uikit.css",
     "sideEffects": [

package/src/js/components/tooltip.js

@@ -35,7 +35,6 @@ export default {
         animation: ['uk-animation-scale-up'],
         duration: 100,
         cls: 'uk-active',
-        clsPos: 'uk-tooltip',
     },
 
     beforeConnect() {
@@ -91,8 +90,8 @@ export default {
         _show() {
             this.tooltip = append(
                 this.container,
-                `<div class="${this.clsPos}">
-                    <div class="${this.clsPos}-inner">${this.title}</div>
+                `<div class="uk-${this.$options.name}">
+                    <div class="uk-${this.$options.name}-inner">${this.title}</div>
                  </div>`
             );
 

package/src/js/core/drop.js

@@ -63,7 +63,7 @@ export default {
     },
 
     connected() {
-        this.clsPos = this.clsDrop = this.$props.clsDrop || `uk-${this.$options.name}`;
+        this.clsDrop = this.$props.clsDrop || `uk-${this.$options.name}`;
         addClass(this.$el, this.clsDrop);
 
         if (this.toggle && !this.target) {
@@ -129,7 +129,7 @@ export default {
                 if (this.isToggled()) {
                     this.hide(false);
                 } else {
-                    this.show(toggle.$el, false);
+                    this.show(toggle?.$el, false);
                 }
             },
         },
@@ -141,7 +141,7 @@ export default {
 
             handler(e, toggle) {
                 e.preventDefault();
-                this.show(toggle.$el);
+                this.show(toggle?.$el);
             },
         },
 
@@ -352,23 +352,20 @@ export default {
         },
 
         position() {
-            const boundary = this.boundary === true ? window : query(this.boundary, this.$el);
+            const boundary = query(this.boundary, this.$el) || window;
             removeClass(this.$el, `${this.clsDrop}-stack`);
             toggleClass(this.$el, `${this.clsDrop}-boundary`, this.boundaryAlign);
 
             const boundaryOffset = offset(boundary);
-            const alignTo = this.boundaryAlign ? boundaryOffset : offset(this.target);
+            const targetOffset = offset(this.target);
+            const alignTo = this.boundaryAlign ? boundaryOffset : targetOffset;
 
             if (this.align === 'justify') {
                 const prop = this.getAxis() === 'y' ? 'width' : 'height';
                 css(this.$el, prop, alignTo[prop]);
             } else if (
-                boundary &&
                 this.$el.offsetWidth >
-                    Math.max(
-                        boundaryOffset.right - alignTo.left,
-                        alignTo.right - boundaryOffset.left
-                    )
+                Math.max(boundaryOffset.right - alignTo.left, alignTo.right - boundaryOffset.left)
             ) {
                 addClass(this.$el, `${this.clsDrop}-stack`);
             }

package/src/js/core/navbar.js

@@ -16,6 +16,7 @@ import {
     isVisible,
     matches,
     noop,
+    offset,
     once,
     parent,
     query,
@@ -274,10 +275,16 @@ export default {
                 return this.dropbar;
             },
 
-            handler() {
+            handler(_, { $el }) {
+                if (!hasClass($el, this.clsDrop)) {
+                    return;
+                }
+
                 if (!parent(this.dropbar)) {
                     after(this.dropbarAnchor || this.$el, this.dropbar);
                 }
+
+                addClass($el, `${this.clsDrop}-dropbar`);
             },
         },
 
@@ -297,12 +304,10 @@ export default {
                     return;
                 }
 
-                this.clsDrop && addClass($el, `${this.clsDrop}-dropbar`);
-
                 if (dir === 'bottom') {
                     this.transitionTo(
-                        $el.offsetHeight +
-                            toFloat(css($el, 'marginTop')) +
+                        offset($el).bottom -
+                            offset(this.dropbar).top +
                             toFloat(css($el, 'marginBottom')),
                         $el
                     );

package/src/js/core/sticky.js

@@ -14,6 +14,7 @@ import {
     height as getHeight,
     offset as getOffset,
     getScrollingElement,
+    intersectRect,
     isString,
     isVisible,
     noop,
@@ -29,7 +30,6 @@ import {
     toPx,
     trigger,
     within,
-    intersectRect,
 } from 'uikit-util';
 
 export default {

package/src/js/mixin/media.js

@@ -1,12 +1,12 @@
 import {
+    createEvent,
     getCssVar,
+    isNumeric,
     isString,
     on,
-    trigger,
-    toFloat,
     startsWith,
-    isNumeric,
-    createEvent,
+    toFloat,
+    trigger,
 } from 'uikit-util';
 
 export default {

package/src/js/mixin/position.js

@@ -1,12 +1,13 @@
 import {
     $,
     flipPosition,
+    getCssVar,
     offset as getOffset,
+    includes,
     isNumeric,
     isRtl,
     positionAt,
-    removeClasses,
-    toggleClass,
+    toPx,
 } from 'uikit-util';
 
 export default {
@@ -14,14 +15,12 @@ export default {
         pos: String,
         offset: null,
         flip: Boolean,
-        clsPos: String,
     },
 
     data: {
         pos: `bottom-${isRtl ? 'right' : 'left'}`,
         flip: true,
         offset: false,
-        clsPos: '',
     },
 
     connected() {
@@ -32,13 +31,11 @@ export default {
 
     methods: {
         positionAt(element, target, boundary) {
-            removeClasses(element, `${this.clsPos}-(top|bottom|left|right)(-[a-z]+)?`);
-
-            let { offset } = this;
             const axis = this.getAxis();
             const dir = this.pos[0];
             const align = this.pos[1];
 
+            let { offset } = this;
             if (!isNumeric(offset)) {
                 const node = $(offset);
                 offset = node
@@ -46,28 +43,60 @@ export default {
                       getOffset(target)[axis === 'x' ? 'right' : 'bottom']
                     : 0;
             }
+            offset += toPx(getCssVar('position-margin-offset', element));
 
-            const { x, y } = positionAt(
-                element,
-                target,
-                axis === 'x' ? `${flipPosition(dir)} ${align}` : `${align} ${flipPosition(dir)}`,
-                axis === 'x' ? `${dir} ${align}` : `${align} ${dir}`,
-                axis === 'x'
-                    ? `${dir === 'left' ? -offset : offset}`
-                    : ` ${dir === 'top' ? -offset : offset}`,
-                null,
-                this.flip,
-                boundary
-            ).target;
-
-            this.dir = axis === 'x' ? x : y;
-            this.align = axis === 'x' ? y : x;
+            positionAt(element, target, {
+                boundary,
+                flip: this.flip,
+                attach: {
+                    element: axis === 'x' ? [flipPosition(dir), align] : [align, flipPosition(dir)],
+                    target: axis === 'x' ? [dir, align] : [align, dir],
+                },
+                offset:
+                    axis === 'x'
+                        ? [dir === 'left' ? -offset : +offset, 0]
+                        : [0, dir === 'top' ? -offset : +offset],
+            });
 
-            toggleClass(element, `${this.clsPos}-${this.dir}-${this.align}`, this.offset === false);
+            [this.dir, this.align] = getAlignment(element, target);
+            console.log(this.dir, this.align);
         },
 
         getAxis() {
-            return this.dir === 'top' || this.dir === 'bottom' ? 'y' : 'x';
+            return includes(['top', 'bottom'], this.dir) ? 'y' : 'x';
         },
     },
 };
+
+function getAlignment(el, target) {
+    const elOffset = getOffset(el);
+    const targetOffset = getOffset(target);
+    const properties = [
+        ['left', 'right'],
+        ['top', 'bottom'],
+    ];
+
+    let dir;
+    for (const props of properties) {
+        if (elOffset[props[0]] > targetOffset[props[1]]) {
+            dir = props[1];
+            break;
+        }
+        if (elOffset[props[1]] < targetOffset[props[0]]) {
+            dir = props[0];
+            break;
+        }
+    }
+
+    let align;
+    const props = includes(properties[0], dir) ? properties[1] : properties[0];
+    if (elOffset[props[0]] === targetOffset[props[0]]) {
+        align = props[0];
+    } else if (elOffset[props[1]] === targetOffset[props[1]]) {
+        align = props[1];
+    } else {
+        align = 'center';
+    }
+
+    return [dir, align];
+}

package/src/js/util/dimensions.js

@@ -41,8 +41,8 @@ export function offset(element, coordinates) {
         const offsetBy = { height: scrollY, width: scrollX };
 
         for (const dir in dirs) {
-            for (const i in dirs[dir]) {
-                currentOffset[dirs[dir][i]] += offsetBy[dir];
+            for (const prop of dirs[dir]) {
+                currentOffset[prop] += offsetBy[dir];
             }
         }
     }

package/src/js/util/position.js

@@ -1,156 +1,152 @@
 import { offset } from './dimensions';
-import { each, endsWith, includes, toFloat } from './lang';
+import { clamp, includes } from './lang';
 import { getViewport, scrollParents } from './viewport';
 
-const dirs = {
-    width: ['x', 'left', 'right'],
-    height: ['y', 'top', 'bottom'],
-};
-
-export function positionAt(
-    element,
-    target,
-    elAttach,
-    targetAttach,
-    elOffset,
-    targetOffset,
-    flip,
-    boundary
-) {
-    elAttach = getPos(elAttach);
-    targetAttach = getPos(targetAttach);
-
-    const flipped = { element: elAttach, target: targetAttach };
-
-    if (!element || !target) {
-        return flipped;
+const dirs = [
+    ['width', 'x', 'left', 'right'],
+    ['height', 'y', 'top', 'bottom'],
+];
+
+export function positionAt(element, target, options) {
+    options = {
+        attach: {
+            element: ['left', 'top'],
+            target: ['left', 'top'],
+            ...options.attach,
+        },
+        offset: [0, 0],
+        ...options,
+    };
+
+    const dim = options.flip
+        ? attachToWithFlip(element, target, options)
+        : attachTo(element, target, options);
+
+    offset(element, dim);
+}
+
+function attachTo(element, target, options) {
+    let { attach, offset: offsetBy } = {
+        attach: {
+            element: ['left', 'top'],
+            target: ['left', 'top'],
+            ...options.attach,
+        },
+        offset: [0, 0],
+        ...options,
+    };
+
+    const position = offset(element);
+    const targetOffset = offset(target);
+    for (const i in dirs) {
+        const [prop, dir, start, end] = dirs[i];
+        position[start] = position[dir] =
+            targetOffset[start] +
+            moveBy(attach.target[i], end, targetOffset[prop]) -
+            moveBy(attach.element[i], end, position[prop]) +
+            +offsetBy[i];
+        position[end] = position[start] + position[prop];
     }
+    return position;
+}
 
-    const dim = offset(element);
+function attachToWithFlip(element, target, options) {
+    const position = attachTo(element, target, options);
     const targetDim = offset(target);
-    const position = targetDim;
+    const viewports = scrollParents(element).map(getViewport);
+
+    let {
+        flip,
+        attach: { element: elAttach, target: targetAttach },
+        offset: elOffset,
+        boundary,
+        viewport,
+    } = options;
 
-    moveTo(position, elAttach, dim, -1);
-    moveTo(position, targetAttach, targetDim, 1);
+    viewports.push(viewport);
 
-    elOffset = getOffsets(elOffset, dim.width, dim.height);
-    targetOffset = getOffsets(targetOffset, targetDim.width, targetDim.height);
+    for (const i in dirs) {
+        const [prop, dir, start, end] = dirs[i];
 
-    elOffset['x'] += targetOffset['x'];
-    elOffset['y'] += targetOffset['y'];
+        if (flip !== true && !includes(flip, dir)) {
+            continue;
+        }
 
-    position.left += elOffset['x'];
-    position.top += elOffset['y'];
+        const willFlip =
+            !intersectLine(position, targetDim, i) && intersectLine(position, targetDim, 1 - i);
 
-    if (flip) {
-        let boundaries = scrollParents(element).map(getViewport);
+        viewport = getIntersectionArea(...viewports, willFlip ? null : boundary);
+        const isInStartBoundary = position[start] >= viewport[start];
+        const isInEndBoundary = position[end] <= viewport[end];
 
-        if (boundary && !includes(boundaries, boundary)) {
-            boundaries.unshift(boundary);
+        if (isInStartBoundary && isInEndBoundary) {
+            continue;
         }
 
-        boundaries = boundaries.map((el) => offset(el));
+        let offsetBy;
 
-        each(dirs, ([dir, align, alignFlip], prop) => {
-            if (!(flip === true || includes(flip, dir))) {
-                return;
+        // Flip
+        if (willFlip) {
+            if (
+                (elAttach[i] === end && isInStartBoundary) ||
+                (elAttach[i] === start && isInEndBoundary)
+            ) {
+                continue;
             }
 
-            boundaries.some((boundary) => {
-                const elemOffset =
-                    elAttach[dir] === align
-                        ? -dim[prop]
-                        : elAttach[dir] === alignFlip
-                        ? dim[prop]
-                        : 0;
-
-                const targetOffset =
-                    targetAttach[dir] === align
-                        ? targetDim[prop]
-                        : targetAttach[dir] === alignFlip
-                        ? -targetDim[prop]
-                        : 0;
-
-                if (
-                    position[align] < boundary[align] ||
-                    position[align] + dim[prop] > boundary[alignFlip]
-                ) {
-                    const centerOffset = dim[prop] / 2;
-                    const centerTargetOffset =
-                        targetAttach[dir] === 'center' ? -targetDim[prop] / 2 : 0;
-
-                    return (
-                        (elAttach[dir] === 'center' &&
-                            (apply(centerOffset, centerTargetOffset) ||
-                                apply(-centerOffset, -centerTargetOffset))) ||
-                        apply(elemOffset, targetOffset)
-                    );
-                }
-
-                function apply(elemOffset, targetOffset) {
-                    const newVal = toFloat(
-                        (position[align] + elemOffset + targetOffset - elOffset[dir] * 2).toFixed(4)
-                    );
-
-                    if (newVal >= boundary[align] && newVal + dim[prop] <= boundary[alignFlip]) {
-                        position[align] = newVal;
-
-                        for (const el of ['element', 'target']) {
-                            if (elemOffset) {
-                                flipped[el][dir] =
-                                    flipped[el][dir] === dirs[prop][1]
-                                        ? dirs[prop][2]
-                                        : dirs[prop][1];
-                            }
-                        }
-
-                        return true;
-                    }
-                }
-            });
-        });
-    }
+            offsetBy =
+                (elAttach[i] === start
+                    ? -position[prop]
+                    : elAttach[i] === end
+                    ? position[prop]
+                    : 0) +
+                (targetAttach[i] === start
+                    ? targetDim[prop]
+                    : targetAttach[i] === end
+                    ? -targetDim[prop]
+                    : 0) -
+                elOffset[i] * 2;
+
+            // Move
+        } else {
+            offsetBy =
+                clamp(
+                    clamp(position[start], viewport[start], viewport[end] - position[prop]),
+                    targetDim[start] - position[prop] + elOffset[i],
+                    targetDim[end] - elOffset[i]
+                ) - position[start];
+        }
 
-    offset(element, position);
+        position[start] = position[dir] = position[start] + offsetBy;
+        position[end] += offsetBy;
+    }
 
-    return flipped;
+    return position;
 }
 
-function moveTo(position, attach, dim, factor) {
-    each(dirs, ([dir, align, alignFlip], prop) => {
-        if (attach[dir] === alignFlip) {
-            position[align] += dim[prop] * factor;
-        } else if (attach[dir] === 'center') {
-            position[align] += (dim[prop] * factor) / 2;
-        }
-    });
+function moveBy(start, end, dim) {
+    return start === 'center' ? dim / 2 : start === end ? dim : 0;
 }
 
-function getPos(pos) {
-    const x = /left|center|right/;
-    const y = /top|center|bottom/;
-
-    pos = (pos || '').split(' ');
-
-    if (pos.length === 1) {
-        pos = x.test(pos[0])
-            ? pos.concat('center')
-            : y.test(pos[0])
-            ? ['center'].concat(pos)
-            : ['center', 'center'];
+function getIntersectionArea(...elements) {
+    let intersection;
+    for (const el of elements.filter(Boolean)) {
+        const rect = offset(el);
+        if (!intersection) {
+            intersection = rect;
+            continue;
+        }
+        for (const prop of ['left', 'top']) {
+            intersection[prop] = Math.max(rect[prop], intersection[prop]);
+        }
+        for (const prop of ['right', 'bottom']) {
+            intersection[prop] = Math.min(rect[prop], intersection[prop]);
+        }
     }
-
-    return {
-        x: x.test(pos[0]) ? pos[0] : 'center',
-        y: y.test(pos[1]) ? pos[1] : 'center',
-    };
+    return intersection;
 }
 
-function getOffsets(offsets, width, height) {
-    const [x, y] = (offsets || '').split(' ');
-
-    return {
-        x: x ? toFloat(x) * (endsWith(x, '%') ? width / 100 : 1) : 0,
-        y: y ? toFloat(y) * (endsWith(y, '%') ? height / 100 : 1) : 0,
-    };
+function intersectLine(dimA, dimB, dir) {
+    const [, , start, end] = dirs[dir];
+    return dimA[end] > dimB[start] && dimB[end] > dimA[start];
 }

package/src/js/util/style.js

@@ -9,7 +9,6 @@ import {
     isUndefined,
     memoize,
     toNodes,
-    toWindow,
 } from './lang';
 
 const cssNumber = {
@@ -37,21 +36,22 @@ export function css(element, property, value, priority = '') {
             property = propName(property);
 
             if (isUndefined(value)) {
-                return getStyle(element, property);
-            } else if (!value && !isNumber(value)) {
-                element.style.removeProperty(property);
+                return getComputedStyle(element).getPropertyValue(property);
             } else {
                 element.style.setProperty(
                     property,
-                    isNumeric(value) && !cssNumber[property] ? `${value}px` : value,
+                    isNumeric(value) && !cssNumber[property]
+                        ? `${value}px`
+                        : value || isNumber(value)
+                        ? value
+                        : '',
                     priority
                 );
             }
         } else if (isArray(property)) {
-            const styles = getStyles(element);
             const props = {};
             for (const prop of property) {
-                props[prop] = styles[propName(prop)];
+                props[prop] = css(element, prop);
             }
             return props;
         } else if (isObject(property)) {
@@ -62,19 +62,9 @@ export function css(element, property, value, priority = '') {
     return elements[0];
 }
 
-function getStyles(element, pseudoElt) {
-    return toWindow(element).getComputedStyle(element, pseudoElt);
-}
-
-function getStyle(element, property, pseudoElt) {
-    return getStyles(element, pseudoElt)[property];
-}
-
 const propertyRe = /^\s*(["'])?(.*?)\1\s*$/;
-export function getCssVar(name) {
-    return getStyles(document.documentElement)
-        .getPropertyValue(`--uk-${name}`)
-        .replace(propertyRe, '$2');
+export function getCssVar(name, element = document.documentElement) {
+    return css(element, `--uk-${name}`).replace(propertyRe, '$2');
 }
 
 // https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-setproperty
@@ -83,6 +73,10 @@ export const propName = memoize((name) => vendorPropName(name));
 const cssPrefixes = ['webkit', 'moz'];
 
 function vendorPropName(name) {
+    if (name[0] === '-') {
+        return name;
+    }
+
     name = hyphenate(name);
 
     const { style } = document.documentElement;