uikit 3.14.1-dev.dadc910c0 → 3.14.1-dev.e15dd286c

package/dist/js/uikit.js

@@ -1,4 +1,4 @@
-/*! UIkit 3.14.1-dev.dadc910c0 | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
+/*! UIkit 3.14.1-dev.e15dd286c | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
 
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -2954,7 +2954,7 @@
     UIkit.data = '__uikit__';
     UIkit.prefix = 'uk-';
     UIkit.options = {};
-    UIkit.version = '3.14.1-dev.dadc910c0';
+    UIkit.version = '3.14.1-dev.e15dd286c';
 
     globalAPI(UIkit);
     hooksAPI(UIkit);
@@ -3622,7 +3622,7 @@
             attach,
             offset: offset$1,
             boundary,
-            viewportPadding: this.viewportPadding,
+            viewportPadding: this.boundaryAlign ? 0 : this.viewportPadding,
             flip: this.flip });
 
         } } };
@@ -4120,7 +4120,7 @@
           for (const row of rows) {
             for (const column of row) {
               toggleClass(column, this.margin, rows[0] !== row);
-              toggleClass(column, this.firstColumn, !!~columns[0].indexOf(column));
+              toggleClass(column, this.firstColumn, columns[0].includes(column));
             }
           }
         },
@@ -6443,13 +6443,13 @@
             return target ? $$(target, $el) : [$el];
           },
 
-          watch(elements, prev) {
+          watch(elements) {
             if (this.hidden) {
               css(filter$1(elements, ":not(." + this.inViewClass + ")"), 'visibility', 'hidden');
             }
 
-            if (prev) {
-              this.$reset();
+            for (const element of elements) {
+              this._observer.observe(element);
             }
           },
 
@@ -6459,9 +6459,10 @@
 
       connected() {
         this._data.elements = new Map();
+
         this.registerObserver(
-        observeIntersection(
-        this.elements,
+        this._observer = observeIntersection(
+        [],
         (records) => {
           const elements = this._data.elements;
           for (const { target: el, isIntersecting } of records) {
@@ -6495,6 +6496,8 @@
         for (const [el, state] of this._data.elements.entries()) {
           removeClass(el, this.inViewClass, (state == null ? void 0 : state.cls) || '');
         }
+
+        this._observer = null;
       },
 
       update: [
@@ -8053,7 +8056,7 @@
     }
 
     function isEqualList(listA, listB) {
-      return listA.length === listB.length && listA.every((el) => ~listB.indexOf(el));
+      return listA.length === listB.length && listA.every((el) => listB.includes(el));
     }
 
     function getSelector(_ref4) {let { filter } = _ref4;
@@ -9378,39 +9381,39 @@
 
 
 
-    function transformFn(prop, el, steps) {
-      let unit = getUnit(steps) || { x: 'px', y: 'px', rotate: 'deg' }[prop] || '';
+    function transformFn(prop, el, stops) {
+      let unit = getUnit(stops) || { x: 'px', y: 'px', rotate: 'deg' }[prop] || '';
       let transformFn;
 
       if (prop === 'x' || prop === 'y') {
         prop = "translate" + ucfirst(prop);
-        transformFn = (step) => toFloat(toFloat(step).toFixed(unit === 'px' ? 0 : 6));
+        transformFn = (stop) => toFloat(toFloat(stop).toFixed(unit === 'px' ? 0 : 6));
       } else if (prop === 'scale') {
         unit = '';
-        transformFn = (step) =>
-        getUnit([step]) ? toPx(step, 'width', el, true) / el.offsetWidth : step;
+        transformFn = (stop) =>
+        getUnit([stop]) ? toPx(stop, 'width', el, true) / el.offsetWidth : stop;
       }
 
-      if (steps.length === 1) {
-        steps.unshift(prop === 'scale' ? 1 : 0);
+      if (stops.length === 1) {
+        stops.unshift(prop === 'scale' ? 1 : 0);
       }
 
-      steps = parseSteps(steps, transformFn);
+      stops = parseStops(stops, transformFn);
 
       return (css, percent) => {
-        css.transform += " " + prop + "(" + getValue(steps, percent) + unit + ")";
+        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 = parseSteps(steps, (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);
@@ -9430,80 +9433,80 @@
       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 = parseSteps(steps);
+      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 = parseSteps(steps);
+      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);
+      const unit = getUnit(stops);
       const length = getMaxPathLength(el);
-      steps = parseSteps(steps.reverse(), (step) => {
-        step = toFloat(step);
-        return unit === '%' ? step * length / 100 : step;
+      stops = parseStops(stops.reverse(), (stop) => {
+        stop = toFloat(stop);
+        return unit === '%' ? stop * length / 100 : stop;
       });
 
-      if (!steps.some((_ref) => {let [value] = _ref;return value;})) {
+      if (!stops.some((_ref) => {let [value] = _ref;return value;})) {
         return noop;
       }
 
       css(el, 'strokeDasharray', length);
 
       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 = parseSteps(steps, (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 values = steps.map((_ref2) => {let [value] = _ref2;return value;});
+      const values = stops.map((_ref2) => {let [value] = _ref2;return value;});
       const min = Math.min(...values);
       const max = Math.max(...values);
       const down = values.indexOf(min) < values.indexOf(max);
@@ -9531,7 +9534,7 @@
 
       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";
@@ -9539,9 +9542,9 @@
       };
     }
 
-    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)";
       };
     }
 
@@ -9576,12 +9579,12 @@
 
     }
 
-    function parseSteps(steps, fn) {if (fn === void 0) {fn = toFloat;}
+    function parseStops(stops, fn) {if (fn === void 0) {fn = toFloat;}
       const result = [];
-      const { length } = steps;
+      const { length } = stops;
       let nullIndex = 0;
       for (let i = 0; i < length; i++) {
-        let [value, percent] = isString(steps[i]) ? steps[i].trim().split(' ') : [steps[i]];
+        let [value, percent] = isString(stops[i]) ? stops[i].trim().split(' ') : [stops[i]];
         value = fn(value);
         percent = percent ? toFloat(percent) / 100 : null;
 
@@ -9618,24 +9621,24 @@
       return result;
     }
 
-    function getStep(steps, percent) {
-      const index = findIndex(steps.slice(1), (_ref3) => {let [, targetPercent] = _ref3;return percent <= targetPercent;}) + 1;
+    function getStop(stops, percent) {
+      const index = findIndex(stops.slice(1), (_ref3) => {let [, targetPercent] = _ref3;return percent <= targetPercent;}) + 1;
       return [
-      steps[index - 1][0],
-      steps[index][0],
-      (percent - steps[index - 1][1]) / (steps[index][1] - steps[index - 1][1])];
+      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;
     }
 
-    const unitRe = /^-?\d+([^\s]*)/;
-    function getUnit(steps, defaultUnit) {
-      for (const step of steps) {
-        const match = step.match == null ? void 0 : step.match(unitRe);
+    const unitRe = /^-?\d+(\S*)/;
+    function getUnit(stops, defaultUnit) {
+      for (const stop of stops) {
+        const match = stop.match == null ? void 0 : stop.match(unitRe);
         if (match) {
           return match[1];
         }