uikit 3.13.6-dev.d986a0728 → 3.13.7-dev.04818b8b8

package/dist/js/uikit-core.js

@@ -1,4 +1,4 @@
-/*! UIkit 3.13.6-dev.d986a0728 | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
+/*! UIkit 3.13.7-dev.04818b8b8 | https://www.getuikit.com | (c) 2014 - 2022 YOOtheme | MIT License */
 
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -1933,153 +1933,157 @@
       return document.scrollingElement || document.documentElement;
     }
 
-    const dirs = [
-    ['width', 'x', 'left', 'right'],
-    ['height', 'y', 'top', 'bottom']];
+    const dirs = {
+      width: ['x', 'left', 'right'],
+      height: ['y', 'top', 'bottom'] };
 
 
-    function positionAt(element, target, options) {
-      options = {
-        attach: {
-          element: ['left', 'top'],
-          target: ['left', 'top'],
-          ...options.attach },
+    function positionAt(
+    element,
+    target,
+    elAttach,
+    targetAttach,
+    elOffset,
+    targetOffset,
+    flip,
+    boundary)
+    {
+      elAttach = getPos(elAttach);
+      targetAttach = getPos(targetAttach);
 
-        offset: [0, 0],
-        ...options };
+      const flipped = { element: elAttach, target: targetAttach };
 
+      if (!element || !target) {
+        return flipped;
+      }
 
-      const dim = options.flip ?
-      attachToWithFlip(element, target, options) :
-      attachTo(element, target, options);
+      const dim = offset(element);
+      const targetDim = offset(target);
+      const position = targetDim;
 
-      offset(element, dim);
-    }
+      moveTo(position, elAttach, dim, -1);
+      moveTo(position, targetAttach, targetDim, 1);
 
-    function attachTo(element, target, options) {
-      let { attach, offset: offsetBy } = {
-        attach: {
-          element: ['left', 'top'],
-          target: ['left', 'top'],
-          ...options.attach },
+      elOffset = getOffsets(elOffset, dim.width, dim.height);
+      targetOffset = getOffsets(targetOffset, targetDim.width, targetDim.height);
 
-        offset: [0, 0],
-        ...options };
+      elOffset['x'] += targetOffset['x'];
+      elOffset['y'] += targetOffset['y'];
 
+      position.left += elOffset['x'];
+      position.top += elOffset['y'];
 
-      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;
-    }
+      if (flip) {
+        let boundaries = scrollParents(element).map(getViewport$1);
 
-    function attachToWithFlip(element, target, options) {
-      const position = attachTo(element, target, options);
-      const targetDim = offset(target);
-      const viewports = scrollParents(element).map(getViewport$1);
+        if (boundary && !includes(boundaries, boundary)) {
+          boundaries.unshift(boundary);
+        }
 
-      let {
-        flip,
-        attach: { element: elAttach, target: targetAttach },
-        offset: elOffset,
-        boundary,
-        viewport } =
-      options;
+        boundaries = boundaries.map((el) => offset(el));
 
-      viewports.push(viewport);
+        each(dirs, (_ref, prop) => {let [dir, align, alignFlip] = _ref;
+          if (!(flip === true || includes(flip, dir))) {
+            return;
+          }
 
-      for (const i in dirs) {
-        const [prop, dir, start, end] = dirs[i];
+          boundaries.some((boundary) => {
+            const elemOffset =
+            elAttach[dir] === align ?
+            -dim[prop] :
+            elAttach[dir] === alignFlip ?
+            dim[prop] :
+            0;
 
-        if (flip !== true && !includes(flip, dir)) {
-          continue;
-        }
+            const targetOffset =
+            targetAttach[dir] === align ?
+            targetDim[prop] :
+            targetAttach[dir] === alignFlip ?
+            -targetDim[prop] :
+            0;
 
-        const willFlip =
-        !intersectLine(position, targetDim, i) && intersectLine(position, targetDim, 1 - i);
+            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;
 
-        viewport = getIntersectionArea(...viewports, willFlip ? null : boundary);
-        const isInStartBoundary = position[start] >= viewport[start];
-        const isInEndBoundary = position[end] <= viewport[end];
+              return (
+                elAttach[dir] === 'center' && (
+                apply(centerOffset, centerTargetOffset) ||
+                apply(-centerOffset, -centerTargetOffset)) ||
+                apply(elemOffset, targetOffset));
 
-        if (isInStartBoundary && isInEndBoundary) {
-          continue;
-        }
+            }
 
-        let offsetBy;
+            function apply(elemOffset, targetOffset) {
+              const newVal = toFloat(
+              (position[align] + elemOffset + targetOffset - elOffset[dir] * 2).toFixed(4));
 
-        // Flip
-        if (willFlip) {
-          if (
-          elAttach[i] === end && isInStartBoundary ||
-          elAttach[i] === start && isInEndBoundary)
-          {
-            continue;
-          }
 
-          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];
-        }
+              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];
+                  }
+                }
 
-        position[start] = position[dir] = position[start] + offsetBy;
-        position[end] += offsetBy;
+                return true;
+              }
+            }
+          });
+        });
       }
 
-      return position;
-    }
+      offset(element, position);
 
-    function moveBy(start, end, dim) {
-      return start === 'center' ? dim / 2 : start === end ? dim : 0;
+      return flipped;
     }
 
-    function getIntersectionArea() {
-      let intersection;for (var _len = arguments.length, elements = new Array(_len), _key = 0; _key < _len; _key++) {elements[_key] = arguments[_key];}
-      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]);
+    function moveTo(position, attach, dim, factor) {
+      each(dirs, (_ref2, prop) => {let [dir, align, alignFlip] = _ref2;
+        if (attach[dir] === alignFlip) {
+          position[align] += dim[prop] * factor;
+        } else if (attach[dir] === 'center') {
+          position[align] += dim[prop] * factor / 2;
         }
+      });
+    }
+
+    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'];
       }
-      return intersection;
+
+      return {
+        x: x.test(pos[0]) ? pos[0] : 'center',
+        y: y.test(pos[1]) ? pos[1] : 'center' };
+
     }
 
-    function intersectLine(dimA, dimB, dir) {
-      const [,, start, end] = dirs[dir];
-      return dimA[end] > dimB[start] && dimB[end] > dimA[start];
+    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 };
+
     }
 
     var util = /*#__PURE__*/Object.freeze({
@@ -2888,7 +2892,7 @@
     UIkit.data = '__uikit__';
     UIkit.prefix = 'uk-';
     UIkit.options = {};
-    UIkit.version = '3.13.6-dev.d986a0728';
+    UIkit.version = '3.13.7-dev.04818b8b8';
 
     globalAPI(UIkit);
     hooksAPI(UIkit);
@@ -3522,61 +3526,27 @@
           }
           offset$1 = toPx(offset$1) + toPx(getCssVar('position-offset', element));
 
-          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$1 : +offset$1, 0] :
-            [0, dir === 'top' ? -offset$1 : +offset$1] });
-
-
-          [this.dir, this.align] = getAlignment(element, target);
+          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$1 : offset$1) : " " + (
+          dir === 'top' ? -offset$1 : offset$1),
+          null,
+          this.flip,
+          boundary).
+          target;
+
+          this.dir = axis === 'x' ? x : y;
+          this.align = axis === 'x' ? y : x;
         },
 
         getAxis() {
-          return includes(['top', 'bottom'], this.dir) ? 'y' : 'x';
+          return this.dir === 'top' || this.dir === 'bottom' ? 'y' : 'x';
         } } };
 
-
-
-    function getAlignment(el, target) {
-      const elOffset = offset(el);
-      const targetOffset = offset(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];
-    }
-
     let active$1;
 
     var drop = {
@@ -3909,7 +3879,7 @@
           const targetOffset = offset(this.target);
           const alignTo = this.boundaryAlign ? boundaryOffset : targetOffset;
 
-          if (this.align === 'justify') {
+          if (this.pos[1] === 'justify') {
             const prop = this.getAxis() === 'y' ? 'width' : 'height';
             css(this.$el, prop, alignTo[prop]);
           } else if (
@@ -4916,25 +4886,6 @@
         }
       },
 
-      update: {
-        write(store) {
-          if (!this.observer || isImg(this.$el)) {
-            return false;
-          }
-
-          const srcset = data(this.$el, 'data-srcset');
-          if (srcset && window.devicePixelRatio !== 1) {
-            const bgSize = css(this.$el, 'backgroundSize');
-            if (bgSize.match(/^(auto\s?)+$/) || toFloat(bgSize) === store.bgSize) {
-              store.bgSize = getSourceSize(srcset, data(this.$el, 'sizes'));
-              css(this.$el, 'backgroundSize', store.bgSize + "px");
-            }
-          }
-        },
-
-        events: ['resize'] },
-
-
       methods: {
         load() {
           if (this._data.image) {
@@ -5024,43 +4975,6 @@
       return sources.filter((source) => !isEmpty(source));
     }
 
-    const sizesRe = /\s*(.*?)\s*(\w+|calc\(.*?\))\s*(?:,|$)/g;
-    function sizesToPixel(sizes) {
-      let matches;
-
-      sizesRe.lastIndex = 0;
-
-      while (matches = sizesRe.exec(sizes)) {
-        if (!matches[1] || window.matchMedia(matches[1]).matches) {
-          matches = evaluateSize(matches[2]);
-          break;
-        }
-      }
-
-      return matches || '100vw';
-    }
-
-    const sizeRe = /\d+(?:\w+|%)/g;
-    const additionRe = /[+-]?(\d+)/g;
-    function evaluateSize(size) {
-      return startsWith(size, 'calc') ?
-      size.
-      slice(5, -1).
-      replace(sizeRe, (size) => toPx(size)).
-      replace(/ /g, '').
-      match(additionRe).
-      reduce((a, b) => a + +b, 0) :
-      size;
-    }
-
-    const srcSetRe = /\s+\d+w\s*(?:,|$)/g;
-    function getSourceSize(srcset, sizes) {
-      const srcSize = toPx(sizesToPixel(sizes));
-      const descriptors = (srcset.match(srcSetRe) || []).map(toFloat).sort((a, b) => a - b);
-
-      return descriptors.filter((size) => size >= srcSize)[0] || descriptors.pop() || '';
-    }
-
     function ensureSrcAttribute(el) {
       if (isImg(el) && !hasAttr(el, 'src')) {
         attr(el, 'src', 'data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"></svg>');