uikit 3.11.2-dev.57792c7e7 → 3.11.2-dev.78e397546

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.11.2-dev.57792c7e7",
+  "version": "3.11.2-dev.78e397546",
   "main": "dist/js/uikit.js",
   "style": "dist/css/uikit.css",
   "sideEffects": [

package/src/js/components/parallax.js

@@ -28,13 +28,15 @@ export default {
         },
 
         start({start}) {
-            return parseCalc(start, this.target);
+            return toPx(start, 'height', this.target, true);
         },
 
         end({end, viewport}) {
-            return parseCalc(
+            return toPx(
                 end || (viewport = (1 - viewport) * 100) && `${viewport}vh+${viewport}%`,
-                this.target
+                'height',
+                this.target,
+                true
             );
         }
 
@@ -77,19 +79,6 @@ export default {
 
 };
 
-const calcRe = /-?\d+(?:\.\d+)?(?:v[wh]|%|px)?/g;
-function parseCalc(calc, el) {
-    let match;
-    let result = 0;
-    calc = calc.toString().replace(/\s/g, '');
-    calcRe.lastIndex = 0;
-    while ((match = calcRe.exec(calc)) !== null) {
-        result += toPx(match[0], 'height', el, true);
-    }
-
-    return result;
-}
-
 function ease(percent, easing) {
     return easing >= 0
         ? Math.pow(percent, easing + 1)

package/src/js/components/sortable.js

@@ -218,7 +218,6 @@ export default {
 
             off(document, pointerMove, this.move);
             off(document, pointerUp, this.end);
-            off(window, 'scroll', this.scroll);
 
             if (!this.drag) {
                 return;
@@ -295,7 +294,7 @@ function trackScroll(pos) {
     trackTimer = setInterval(() => {
 
         let {x, y} = pos;
-        y += window.pageYOffset;
+        y += scrollTop(window);
 
         const dist = (Date.now() - last) * .3;
         last = Date.now();

package/src/js/core/core.js

@@ -13,7 +13,7 @@ export default function (UIkit) {
             return;
         }
         pendingResize = true;
-        fastdom.write(() => pendingResize = false);
+        fastdom.read(() => pendingResize = false);
         UIkit.update(null, 'resize');
     };
 
@@ -32,7 +32,7 @@ export default function (UIkit) {
             return;
         }
         pending = true;
-        fastdom.write(() => pending = false);
+        fastdom.read(() => pending = false);
 
         UIkit.update(null, e.type);
 

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

@@ -1,5 +1,5 @@
 import FlexBug from '../mixin/flex-bug';
-import {boxModelAdjust, css, dimensions, endsWith, height, isNumeric, isString, isVisible, offset, query, toFloat} from 'uikit-util';
+import {boxModelAdjust, css, dimensions, endsWith, height, isNumeric, isString, isVisible, offset, query, toFloat, trigger} from 'uikit-util';
 
 export default {
 
@@ -76,7 +76,7 @@ export default {
             css(this.$el, {minHeight});
 
             if (minHeight !== prev) {
-                this.$update(this.$el, 'resize');
+                trigger(this.$el, 'resize');
             }
 
             if (this.minHeight && toFloat(css(this.$el, 'minHeight')) < this.minHeight) {

package/src/js/core/sticky.js

@@ -1,12 +1,13 @@
 import Class from '../mixin/class';
 import Media from '../mixin/media';
-import {$, addClass, after, Animation, assign, css, dimensions, fastdom, height as getHeight, hasClass, isNumeric, isString, isVisible, noop, offset, offsetPosition, parent, query, remove, removeClass, replaceClass, scrollTop, toFloat, toggleClass, toPx, trigger, within} from 'uikit-util';
+import {$, addClass, after, Animation, assign, clamp, css, dimensions, fastdom, height as getHeight, getScrollingElement, hasClass, isNumeric, isString, isVisible, noop, offset, offsetPosition, parent, query, remove, removeClass, replaceClass, scrollTop, toggleClass, toPx, trigger, within} from 'uikit-util';
 
 export default {
 
     mixins: [Class, Media],
 
     props: {
+        position: String,
         top: null,
         bottom: Boolean,
         offset: String,
@@ -22,6 +23,7 @@ export default {
     },
 
     data: {
+        position: 'top',
         top: 0,
         bottom: false,
         offset: 0,
@@ -38,8 +40,19 @@ export default {
 
     computed: {
 
-        offset({offset}) {
-            return toPx(offset);
+        position({position}, $el) {
+            return position === 'auto'
+                ? (this.isFixed ? this.placeholder : $el).offsetHeight > getHeight(window)
+                    ? 'bottom'
+                    : 'top'
+                : position;
+        },
+
+        offset({offset}, $el) {
+            if (this.position === 'bottom') {
+                offset += '+100vh-100%';
+            }
+            return toPx(offset, 'height', $el);
         },
 
         selTarget({selTarget}, $el) {
@@ -100,7 +113,7 @@ export default {
 
             handler() {
 
-                if (!(this.targetOffset !== false && location.hash && window.pageYOffset > 0)) {
+                if (!(this.targetOffset !== false && location.hash && scrollTop(window) > 0)) {
                     return;
                 }
 
@@ -146,24 +159,28 @@ export default {
 
                 height = this.isActive ? height : this.$el.offsetHeight;
 
-                if (height + this.offset > getHeight(window)) {
-                    this.inactive = true;
-                    return false;
-                }
+                const overflow = Math.max(0, height + this.offset - getHeight(window));
 
                 const referenceElement = this.isFixed ? this.placeholder : this.$el;
-                this.topOffset = offset(referenceElement).top;
-                this.bottomOffset = this.topOffset + height;
-                this.offsetParentTop = offset(referenceElement.offsetParent).top;
+                const topOffset = offset(referenceElement).top;
+                const offsetParentTop = offset(referenceElement.offsetParent).top;
 
-                const bottom = parseProp('bottom', this);
+                const top = parseProp(this.top, this.$el, topOffset);
+                const bottom = parseProp(this.bottom, this.$el, topOffset + height);
 
-                this.top = Math.max(toFloat(parseProp('top', this)), this.topOffset) - this.offset;
-                this.bottom = bottom && bottom - this.$el.offsetHeight;
-                this.width = dimensions(isVisible(this.widthElement) ? this.widthElement : this.$el).width;
+                const start = Math.max(top, topOffset) - this.offset;
+                const end = bottom
+                    ? bottom - this.$el.offsetHeight + overflow - this.offset
+                    : getScrollingElement(this.$el).scrollHeight - getHeight(window);
 
                 return {
+                    start,
+                    end,
+                    overflow,
+                    topOffset,
+                    offsetParentTop,
                     height,
+                    width: dimensions(isVisible(this.widthElement) ? this.widthElement : this.$el).width,
                     top: offsetPosition(this.placeholder)[0],
                     margins: css(this.$el, ['marginTop', 'marginBottom', 'marginLeft', 'marginRight'])
                 };
@@ -190,42 +207,48 @@ export default {
 
         {
 
-            read({scroll = 0}) {
+            read({scroll: prevScroll = 0, dir: prevDir = 'down', overflow, overflowScroll = 0, start, end}) {
 
-                this.scroll = window.pageYOffset;
+                const scroll = scrollTop(window);
+                const dir = prevScroll <= scroll ? 'down' : 'up';
 
                 return {
-                    dir: scroll <= this.scroll ? 'down' : 'up',
-                    scroll: this.scroll
+                    dir,
+                    prevDir,
+                    scroll,
+                    prevScroll,
+                    overflowScroll: clamp(
+                        overflowScroll
+                        + clamp(scroll, start, end)
+                        - clamp(prevScroll, start, end),
+                        0,
+                        overflow
+                    )
                 };
             },
 
             write(data, types) {
 
-                const now = Date.now();
                 const isScrollUpdate = types.has('scroll');
-                const {initTimestamp = 0, dir, lastDir, lastScroll, scroll, top} = data;
+                const {initTimestamp = 0, dir, prevDir, scroll, prevScroll = 0, top, start, topOffset, height} = data;
 
-                data.lastScroll = scroll;
-
-                if (scroll < 0 || scroll === lastScroll && isScrollUpdate || this.showOnUp && !isScrollUpdate && !this.isFixed) {
+                if (scroll < 0 || scroll === prevScroll && isScrollUpdate || this.showOnUp && !isScrollUpdate && !this.isFixed) {
                     return;
                 }
 
-                if (now - initTimestamp > 300 || dir !== lastDir) {
+                const now = Date.now();
+                if (now - initTimestamp > 300 || dir !== prevDir) {
                     data.initScroll = scroll;
                     data.initTimestamp = now;
                 }
 
-                data.lastDir = dir;
-
-                if (this.showOnUp && !this.isFixed && Math.abs(data.initScroll - scroll) <= 30 && Math.abs(lastScroll - scroll) <= 10) {
+                if (this.showOnUp && !this.isFixed && Math.abs(data.initScroll - scroll) <= 30 && Math.abs(prevScroll - scroll) <= 10) {
                     return;
                 }
 
                 if (this.inactive
-                    || scroll < this.top
-                    || this.showOnUp && (scroll <= this.top || dir === 'down' && isScrollUpdate || dir === 'up' && !this.isFixed && scroll <= this.bottomOffset)
+                    || scroll < start
+                    || this.showOnUp && (scroll <= start || dir === 'down' && isScrollUpdate || dir === 'up' && !this.isFixed && scroll <= topOffset + height)
                 ) {
 
                     if (!this.isFixed) {
@@ -240,7 +263,7 @@ export default {
 
                     this.isFixed = false;
 
-                    if (this.animation && scroll > this.topOffset) {
+                    if (this.animation && scroll > topOffset) {
                         Animation.cancel(this.$el);
                         Animation.out(this.$el, this.animation).then(() => this.hide(), noop);
                     } else {
@@ -290,23 +313,28 @@ export default {
 
         update() {
 
-            const active = this.top !== 0 || this.scroll > this.top;
-            let top = Math.max(0, this.offset);
+            const {width, scroll = 0, overflow, overflowScroll = 0, start, end, topOffset, height, offsetParentTop} = this._data;
+            const active = start !== 0 || scroll > start;
+            let top = this.offset;
             let position = 'fixed';
 
-            if (isNumeric(this.bottom) && this.scroll > this.bottom - this.offset) {
-                top = this.bottom - this.offsetParentTop;
+            if (scroll > end) {
+                top = end + this.offset - offsetParentTop;
                 position = 'absolute';
             }
 
+            if (overflow) {
+                top -= overflowScroll;
+            }
+
             css(this.$el, {
                 position,
                 top: `${top}px`,
-                width: this.width
+                width
             });
 
             this.isActive = active;
-            toggleClass(this.$el, this.clsBelow, this.scroll > this.bottomOffset);
+            toggleClass(this.$el, this.clsBelow, scroll > topOffset + height);
             addClass(this.$el, this.clsFixed);
 
         }
@@ -315,12 +343,10 @@ export default {
 
 };
 
-function parseProp(prop, {$props, $el, [`${prop}Offset`]: propOffset}) {
-
-    const value = $props[prop];
+function parseProp(value, el, propOffset) {
 
     if (!value) {
-        return;
+        return 0;
     }
 
     if (isString(value) && value.match(/^-?\d/)) {
@@ -329,7 +355,7 @@ function parseProp(prop, {$props, $el, [`${prop}Offset`]: propOffset}) {
 
     } else {
 
-        return offset(value === true ? parent($el) : query(value, $el)).bottom;
+        return offset(value === true ? parent(el) : query(value, el)).bottom;
 
     }
 }

package/src/js/mixin/parallax.js

@@ -1,6 +1,6 @@
 import Media from '../mixin/media';
 import {getMaxPathLength} from '../core/svg';
-import {css, Dimensions, each, isNumber, isString, isUndefined, noop, startsWith, toFloat, toPx, ucfirst} from 'uikit-util';
+import {css, Dimensions, each, isNumber, isString, isUndefined, noop, startsWith, toFloat, toPx, trigger, ucfirst} from 'uikit-util';
 
 const props = {
     x: transformFn,
@@ -38,7 +38,7 @@ export default {
         props(properties, $el) {
             return keys(props).reduce((result, prop) => {
                 if (!isUndefined(properties[prop])) {
-                    result[prop] = props[prop].call(this, prop, $el, properties[prop].slice());
+                    result[prop] = props[prop](prop, $el, properties[prop].slice());
                 }
                 return result;
             }, {});
@@ -46,6 +46,12 @@ export default {
 
     },
 
+    events: {
+        bgimageload() {
+            this.$emit();
+        }
+    },
+
     methods: {
 
         reset() {
@@ -186,15 +192,15 @@ function backgroundFn(prop, el, steps) {
     const bgPos = css(el, 'backgroundPosition').split(' ')[prop === 'x' ? 0 : 1]; // IE 11 can't read background-position-[x|y]
 
     return getCssValue(el, 'backgroundSize', '') === 'cover'
-        ? backgroundCoverFn.call(this, prop, el, steps, bgPos, attr)
+        ? backgroundCoverFn(prop, el, steps, bgPos, attr)
         : setBackgroundPosFn(prop, steps, bgPos);
 }
 
 function backgroundCoverFn(prop, el, steps, bgPos, attr) {
 
-    const image = getBackgroundImage.call(this, el);
+    const dimImage = getBackgroundImageDimensions(el);
 
-    if (!image.naturalWidth) {
+    if (!dimImage.width) {
         return noop;
     }
 
@@ -210,11 +216,6 @@ function backgroundCoverFn(prop, el, steps, bgPos, attr) {
         height: el.offsetHeight
     };
 
-    const dimImage = {
-        width: image.naturalWidth,
-        height: image.naturalHeight
-    };
-
     const baseDim = Dimensions.cover(dimImage, dimEl);
     const span = baseDim[attr] - dimEl[attr];
 
@@ -245,24 +246,34 @@ function setBackgroundPosFn(prop, steps, pos) {
     };
 }
 
-function getBackgroundImage(el) {
+const dimensions = {};
+function getBackgroundImageDimensions(el) {
     const src = css(el, 'backgroundImage').replace(/^none|url\(["']?(.+?)["']?\)$/, '$1');
 
-    const data = this._data;
-
-    if (data[src]) {
-        return data[src];
+    if (dimensions[src]) {
+        return dimensions[src];
     }
 
+    const image = new Image();
     if (src) {
-        const img = new Image();
-        img.src = src;
-        if (!img.naturalWidth) {
-            img.onload = () => this.$update();
-        }
+        image.src = src;
 
-        return data[src] = img;
+        if (!image.naturalWidth) {
+            image.onload = () => {
+                dimensions[src] = toDimensions(image);
+                trigger(el, 'bgimageload');
+            };
+        }
     }
+
+    return dimensions[src] = toDimensions(image);
+}
+
+function toDimensions(image) {
+    return {
+        width: image.naturalWidth,
+        height: image.naturalHeight
+    };
 }
 
 function getStep(steps, percent) {

package/src/js/util/dimensions.js

@@ -1,5 +1,5 @@
 import {css} from './style';
-import {each, endsWith, isDocument, isElement, isNumeric, isUndefined, isWindow, toFloat, toNode, toWindow, ucfirst} from './lang';
+import {each, isDocument, isElement, isString, isUndefined, isWindow, memoize, toFloat, toNode, toWindow, ucfirst} from './lang';
 
 const dirs = {
     width: ['left', 'right'],
@@ -157,19 +157,35 @@ export function flipPosition(pos) {
 }
 
 export function toPx(value, property = 'width', element = window, offsetDim = false) {
-    return isNumeric(value)
-        ? +value
-        : endsWith(value, 'vh')
-            ? percent(height(toWindow(element)), value)
-            : endsWith(value, 'vw')
-                ? percent(width(toWindow(element)), value)
-                : endsWith(value, '%')
-                    ? percent(offsetDim
-                        ? element[`offset${ucfirst(property)}`]
-                        : dimensions(element)[property], value)
-                    : toFloat(value);
+
+    if (!isString(value)) {
+        return toFloat(value);
+    }
+
+    return parseCalc(value).reduce((result, value) => {
+        const unit = parseUnit(value);
+        if (unit) {
+            value = percent(
+                unit === 'vh'
+                    ? height(toWindow(element))
+                    : unit === 'vw'
+                        ? width(toWindow(element))
+                        : offsetDim
+                            ? element[`offset${ucfirst(property)}`]
+                            : dimensions(element)[property],
+                value
+            );
+        }
+
+        return result + toFloat(value);
+    }, 0);
 }
 
+const calcRe = /-?\d+(?:\.\d+)?(?:v[wh]|%|px)?/g;
+const parseCalc = memoize(calc => calc.toString().replace(/\s/g, '').match(calcRe) || []);
+const unitRe = /(?:v[hw]|%)$/;
+const parseUnit = memoize(str => (str.match(unitRe) || [])[0]);
+
 function percent(base, value) {
     return base * toFloat(value) / 100;
 }

package/src/js/util/fastdom.js

@@ -31,7 +31,7 @@ export const fastdom = {
 
 };
 
-function flush(recursion = 1) {
+function flush(recursion) {
     runTasks(fastdom.reads);
     runTasks(fastdom.writes.splice(0));
 
@@ -53,7 +53,7 @@ function scheduleFlush(recursion) {
     if (recursion && recursion < RECURSION_LIMIT) {
         Promise.resolve().then(() => flush(recursion));
     } else {
-        requestAnimationFrame(() => flush());
+        requestAnimationFrame(() => flush(1));
     }
 
 }

package/src/js/util/viewport.js

@@ -2,7 +2,7 @@ import {css} from './style';
 import {Promise} from './promise';
 import {isVisible, parents} from './filter';
 import {offset, offsetPosition} from './dimensions';
-import {clamp, findIndex, intersectRect, isDocument, isWindow, toNode, toWindow} from './lang';
+import {clamp, findIndex, intersectRect, isDocument, isUndefined, isWindow, toNode, toWindow} from './lang';
 
 export function isInView(element, offsetTop = 0, offsetLeft = 0) {
 
@@ -31,7 +31,11 @@ export function scrollTop(element, top) {
         element = toNode(element);
     }
 
-    element.scrollTop = top;
+    if (isUndefined(top)) {
+        return element.scrollTop;
+    } else {
+        element.scrollTop = top;
+    }
 }
 
 export function scrollIntoView(element, {offset: offsetBy = 0} = {}) {
@@ -145,7 +149,7 @@ export function getViewportClientHeight(scrollElement) {
     return (scrollElement === getScrollingElement(scrollElement) ? document.documentElement : scrollElement).clientHeight;
 }
 
-function getScrollingElement(element) {
+export function getScrollingElement(element) {
     const {document} = toWindow(element);
     return document.scrollingElement || document.documentElement;
 }