@get-set/gs-sortable 0.0.20 → 0.0.21

package/dist/actions/calculateOnSort.js

@@ -1,278 +1,247 @@
-import types from "../constants/types";
-import { getOffsetFromWindow, getTranslateCoord } from "./general";
-
-const calculateOnSort = (ref) => {
-  const params = ref.currentParams;
-  if (!params.takeClone) {
-    const $items = [...ref.grid.children];
-    const itemsCount = $items.filter(
-      (x) => !x.classList.contains("gs-sortable-item-inmove")
-    ).length;
-    const info = window.GSSortableConfigue.draggableInfo;
-    let {
-      containerPT,
-      containerPL,
-      currentHeight,
-      currentWidth,
-      itemWidth,
-      gapX,
-      gapY,
-    } = ref.uiData;
-
-    let currentLeft = containerPL;
-    let currentTop = containerPT;
-    let maxHeight = 0;
-
-    let placeholderSeted = info === undefined;
-    let inProcessEl = undefined;
-    const containerCoord = getOffsetFromWindow(info.ref.grid);
-    if (info !== undefined) {
-      const $el = info.$el;
-      const elCoord = getOffsetFromWindow($el);
-      inProcessEl = {
-        height: $el.offsetHeight,
-        width: $el.offsetWidth,
-        top: elCoord.top - containerCoord.top,
-        left: elCoord.left - containerCoord.left,
-      };
-    }
-    let plIndex = info.index;
-    let colHeight = 0;
-
-    let itIndex = 0;
-
-    $items.map((el) => {
-      if (!el.classList.contains("gs-sortable-item-inmove")) {
-        const height = el.offsetHeight;
-        const width = el.offsetWidth;
-        if (params.type == types.column) {
-          if (!placeholderSeted) {
-            let placeholderTop =
-              currentTop == containerPT ? containerPT : currentTop + gapY;
-            let placeholderLeft = containerPL;
-
-            if (
-              Math.abs(placeholderTop - inProcessEl.top) <
-                inProcessEl.height / 2 &&
-              Math.abs(placeholderLeft - inProcessEl.left) <
-                inProcessEl.width / 2
-            ) {
-              info.newTop = placeholderTop;
-              info.newLeft = placeholderLeft;
-              placeholderSeted = true;
-              plIndex = itIndex;
-            }
-          }
-          if (!el.classList.contains("gs-sortable-placeholder")) {
-            if (currentTop == containerPT) {
-              currentTop = containerPT + height;
-              currentHeight = currentHeight + height;
-            } else {
-              currentTop = currentTop + gapY + height;
-              currentHeight = currentHeight + height + gapY;
-            }
-          }
-        } else if (params.type == types.row) {
-          if (!placeholderSeted) {
-            let placeholderLeft =
-              currentLeft == containerPL ? containerPL : currentLeft + gapX;
-            let placeholderTop = containerPT;
-            if (
-              Math.abs(placeholderTop - inProcessEl.top) <
-                inProcessEl.height / 2 &&
-              Math.abs(placeholderLeft - inProcessEl.left) <
-                inProcessEl.width / 2
-            ) {
-              info.newTop = placeholderTop;
-              info.newLeft = placeholderLeft;
-              placeholderSeted = true;
-              plIndex = itIndex;
-            }
-          }
-          if (!el.classList.contains("gs-sortable-placeholder")) {
-            if (currentLeft == containerPL) {
-              currentLeft = containerPL + width;
-              currentWidth = currentWidth + width;
-            } else {
-              currentLeft = currentLeft + gapX + width;
-              currentWidth = currentWidth + width + gapX;
-            }
-            if (height > maxHeight) {
-              maxHeight = height;
-            }
-          }
-        } else if (params.type == types.grid) {
-          const placeholderLeft =
-            itIndex % params.count == 0
-              ? containerPL
-              : containerPL + (itIndex % params.count) * (itemWidth + gapX);
-          const placeholderTop = currentTop;
-          if (
-            Math.abs(placeholderTop - inProcessEl.top) <
-              inProcessEl.height / 2 &&
-            Math.abs(placeholderLeft - inProcessEl.left) < inProcessEl.width / 2
-          ) {
-            info.newTop = placeholderTop;
-            info.newLeft = placeholderLeft;
-            placeholderSeted = true;
-            plIndex = itIndex;
-          }
-          if (!el.classList.contains("gs-sortable-placeholder")) {
-            const top = currentTop;
-            if (height > colHeight) {
-              colHeight = height;
-            }
-            if (
-              itIndex % params.count === params.count - 1 ||
-              itIndex === itemsCount - 1
-            ) {
-              if (top === containerPT) {
-                currentHeight = currentHeight + colHeight;
-              } else {
-                currentHeight = currentHeight + colHeight + gapY;
-              }
-              currentTop = currentTop + colHeight + gapY;
-              colHeight = 0;
-            }
-          }
-        }
-        itIndex += 1;
-      }
-    });
-    {
-      info.index = plIndex;
-      let {
-        containerPT,
-        containerPL,
-        currentHeight,
-        currentWidth,
-        itemWidth,
-        gapX,
-        gapY,
-      } = ref.uiData;
-
-      currentLeft = containerPL;
-      currentTop = containerPT;
-      itIndex = 0;
-      $items.map((el) => {
-        if (!el.classList.contains("gs-sortable-item-inmove")) {
-          const height = el.offsetHeight;
-          const width = el.offsetWidth;
-          if (params.type == types.column) {
-            if (itIndex == plIndex) {
-              info.placeholder.style.left = `${containerPL}px`;
-              info.newLeft = containerPL;
-              if (currentTop == containerPT) {
-                info.newTop = containerPT;
-                info.placeholder.style.top = `${containerPT}px`;
-                currentTop = containerPT + inProcessEl.height;
-              } else {
-                info.newTop = currentTop + gapY;
-                info.placeholder.style.top = `${currentTop + gapY}px`;
-                currentTop = currentTop + gapY + inProcessEl.height;
-              }
-            }
-            if (!el.classList.contains("gs-sortable-placeholder")) {
-              el.style.left = `${containerPL}px`;
-              if (currentTop == containerPT) {
-                el.style.top = `${containerPT}px`;
-                currentTop = containerPT + height;
-                currentHeight = currentHeight + height;
-              } else {
-                el.style.top = `${currentTop + gapY}px`;
-                currentTop = currentTop + gapY + height;
-                currentHeight = currentHeight + height + gapY;
-              }
-            }
-          } else if (params.type == types.row) {
-            if (itIndex == plIndex) {
-              info.placeholder.style.top = `${containerPT}px`;
-              info.newTop = containerPT;
-              if (currentLeft == containerPL) {
-                info.newLeft = containerPL;
-                info.placeholder.style.left = `${containerPL}px`;
-                currentLeft = containerPL + inProcessEl.width;
-              } else {
-                info.newLeft = currentLeft + gapX;
-                info.placeholder.style.left = `${currentLeft + gapX}px`;
-                currentLeft = currentLeft + gapX + inProcessEl.width;
-              }
-            }
-            if (!el.classList.contains("gs-sortable-placeholder")) {
-              el.style.top = `${containerPT}px`;
-              if (currentLeft == containerPL) {
-                el.style.left = `${containerPL}px`;
-                currentLeft = containerPL + width;
-                currentWidth = currentWidth + width;
-              } else {
-                el.style.left = `${currentLeft + gapX}px`;
-                currentLeft = currentLeft + gapX + width;
-                currentWidth = currentWidth + width + gapX;
-              }
-            }
-            if (height > maxHeight) {
-              maxHeight = height;
-            }
-          } else if (params.type == types.grid) {
-            if (itIndex == plIndex) {
-              const left =
-                itIndex % params.count == 0
-                  ? containerPL
-                  : containerPL + (itIndex % params.count) * (itemWidth + gapX);
-              const top = currentTop;
-              if (inProcessEl.height > colHeight) {
-                colHeight = inProcessEl.height;
-              }
-              if (
-                itIndex % params.count === params.count - 1 ||
-                itIndex === itemsCount - 1
-              ) {
-                if (top === containerPT) {
-                  currentHeight = currentHeight + colHeight;
-                } else {
-                  currentHeight = currentHeight + colHeight + gapY;
-                }
-                currentTop = currentTop + colHeight + gapY;
-                colHeight = 0;
-                ref.grid.style.height = `${currentHeight}px`;
-              }
-              itIndex += 1;
-              info.newTop = top;
-              info.newLeft = left;
-              info.placeholder.style.left = `${left}px`;
-              info.placeholder.style.top = `${top}px`;
-            }
-            if (!el.classList.contains("gs-sortable-placeholder")) {
-              const left =
-                itIndex % params.count == 0
-                  ? containerPL
-                  : containerPL + (itIndex % params.count) * (itemWidth + gapX);
-              const top = currentTop;
-              if (height > colHeight) {
-                colHeight = height;
-              }
-              if (
-                itIndex % params.count === params.count - 1 ||
-                itIndex === itemsCount - 1
-              ) {
-                if (top === containerPT) {
-                  currentHeight = currentHeight + colHeight;
-                } else {
-                  currentHeight = currentHeight + colHeight + gapY;
-                }
-                currentTop = currentTop + colHeight + gapY;
-                colHeight = 0;
-                ref.grid.style.height = `${currentHeight}px`;
-              }
-              el.style.left = `${left}px`;
-              el.style.top = `${top}px`;
-            }
-          }
-          itIndex += 1;
-        }
-      });
-    }
-  }
-};
-
-export default calculateOnSort;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _types = _interopRequireDefault(require("../constants/types"));
+var _general = require("./general");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var calculateOnSort = function calculateOnSort(ref) {
+  var params = ref.currentParams;
+  if (!params.takeClone) {
+    var $items = _toConsumableArray(ref.grid.children);
+    var itemsCount = $items.filter(function (x) {
+      return !x.classList.contains("gs-sortable-item-inmove");
+    }).length;
+    var info = window.GSSortableConfigue.draggableInfo;
+    var _ref$uiData = ref.uiData,
+      containerPT = _ref$uiData.containerPT,
+      containerPL = _ref$uiData.containerPL,
+      currentHeight = _ref$uiData.currentHeight,
+      currentWidth = _ref$uiData.currentWidth,
+      itemWidth = _ref$uiData.itemWidth,
+      gapX = _ref$uiData.gapX,
+      gapY = _ref$uiData.gapY;
+    var currentLeft = containerPL;
+    var currentTop = containerPT;
+    var maxHeight = 0;
+    var placeholderSeted = info === undefined;
+    var inProcessEl = undefined;
+    var containerCoord = (0, _general.getOffsetFromWindow)(info.ref.grid);
+    if (info !== undefined) {
+      var $el = info.$el;
+      var elCoord = (0, _general.getOffsetFromWindow)($el);
+      inProcessEl = {
+        height: $el.offsetHeight,
+        width: $el.offsetWidth,
+        top: elCoord.top - containerCoord.top,
+        left: elCoord.left - containerCoord.left
+      };
+    }
+    var plIndex = info.index;
+    var colHeight = 0;
+    var itIndex = 0;
+    $items.map(function (el) {
+      if (!el.classList.contains("gs-sortable-item-inmove")) {
+        var height = el.offsetHeight;
+        var width = el.offsetWidth;
+        if (params.type == _types["default"].column) {
+          if (!placeholderSeted) {
+            var placeholderTop = currentTop == containerPT ? containerPT : currentTop + gapY;
+            var placeholderLeft = containerPL;
+            if (Math.abs(placeholderTop - inProcessEl.top) < inProcessEl.height / 2 && Math.abs(placeholderLeft - inProcessEl.left) < inProcessEl.width / 2) {
+              info.newTop = placeholderTop;
+              info.newLeft = placeholderLeft;
+              placeholderSeted = true;
+              plIndex = itIndex;
+            }
+          }
+          if (!el.classList.contains("gs-sortable-placeholder")) {
+            if (currentTop == containerPT) {
+              currentTop = containerPT + height;
+              currentHeight = currentHeight + height;
+            } else {
+              currentTop = currentTop + gapY + height;
+              currentHeight = currentHeight + height + gapY;
+            }
+          }
+        } else if (params.type == _types["default"].row) {
+          if (!placeholderSeted) {
+            var _placeholderLeft = currentLeft == containerPL ? containerPL : currentLeft + gapX;
+            var _placeholderTop = containerPT;
+            if (Math.abs(_placeholderTop - inProcessEl.top) < inProcessEl.height / 2 && Math.abs(_placeholderLeft - inProcessEl.left) < inProcessEl.width / 2) {
+              info.newTop = _placeholderTop;
+              info.newLeft = _placeholderLeft;
+              placeholderSeted = true;
+              plIndex = itIndex;
+            }
+          }
+          if (!el.classList.contains("gs-sortable-placeholder")) {
+            if (currentLeft == containerPL) {
+              currentLeft = containerPL + width;
+              currentWidth = currentWidth + width;
+            } else {
+              currentLeft = currentLeft + gapX + width;
+              currentWidth = currentWidth + width + gapX;
+            }
+            if (height > maxHeight) {
+              maxHeight = height;
+            }
+          }
+        } else if (params.type == _types["default"].grid) {
+          var _placeholderLeft2 = itIndex % params.count == 0 ? containerPL : containerPL + itIndex % params.count * (itemWidth + gapX);
+          var _placeholderTop2 = currentTop;
+          if (Math.abs(_placeholderTop2 - inProcessEl.top) < inProcessEl.height / 2 && Math.abs(_placeholderLeft2 - inProcessEl.left) < inProcessEl.width / 2) {
+            info.newTop = _placeholderTop2;
+            info.newLeft = _placeholderLeft2;
+            placeholderSeted = true;
+            plIndex = itIndex;
+          }
+          if (!el.classList.contains("gs-sortable-placeholder")) {
+            var top = currentTop;
+            if (height > colHeight) {
+              colHeight = height;
+            }
+            if (itIndex % params.count === params.count - 1 || itIndex === itemsCount - 1) {
+              if (top === containerPT) {
+                currentHeight = currentHeight + colHeight;
+              } else {
+                currentHeight = currentHeight + colHeight + gapY;
+              }
+              currentTop = currentTop + colHeight + gapY;
+              colHeight = 0;
+            }
+          }
+        }
+        itIndex += 1;
+      }
+    });
+    {
+      info.index = plIndex;
+      var _ref$uiData2 = ref.uiData,
+        _containerPT = _ref$uiData2.containerPT,
+        _containerPL = _ref$uiData2.containerPL,
+        _currentHeight = _ref$uiData2.currentHeight,
+        _currentWidth = _ref$uiData2.currentWidth,
+        _itemWidth = _ref$uiData2.itemWidth,
+        _gapX = _ref$uiData2.gapX,
+        _gapY = _ref$uiData2.gapY;
+      currentLeft = _containerPL;
+      currentTop = _containerPT;
+      itIndex = 0;
+      $items.map(function (el) {
+        if (!el.classList.contains("gs-sortable-item-inmove")) {
+          var height = el.offsetHeight;
+          var width = el.offsetWidth;
+          if (params.type == _types["default"].column) {
+            if (itIndex == plIndex) {
+              info.placeholder.style.left = "".concat(_containerPL, "px");
+              info.newLeft = _containerPL;
+              if (currentTop == _containerPT) {
+                info.newTop = _containerPT;
+                info.placeholder.style.top = "".concat(_containerPT, "px");
+                currentTop = _containerPT + inProcessEl.height;
+              } else {
+                info.newTop = currentTop + _gapY;
+                info.placeholder.style.top = "".concat(currentTop + _gapY, "px");
+                currentTop = currentTop + _gapY + inProcessEl.height;
+              }
+            }
+            if (!el.classList.contains("gs-sortable-placeholder")) {
+              el.style.left = "".concat(_containerPL, "px");
+              if (currentTop == _containerPT) {
+                el.style.top = "".concat(_containerPT, "px");
+                currentTop = _containerPT + height;
+                _currentHeight = _currentHeight + height;
+              } else {
+                el.style.top = "".concat(currentTop + _gapY, "px");
+                currentTop = currentTop + _gapY + height;
+                _currentHeight = _currentHeight + height + _gapY;
+              }
+            }
+          } else if (params.type == _types["default"].row) {
+            if (itIndex == plIndex) {
+              info.placeholder.style.top = "".concat(_containerPT, "px");
+              info.newTop = _containerPT;
+              if (currentLeft == _containerPL) {
+                info.newLeft = _containerPL;
+                info.placeholder.style.left = "".concat(_containerPL, "px");
+                currentLeft = _containerPL + inProcessEl.width;
+              } else {
+                info.newLeft = currentLeft + _gapX;
+                info.placeholder.style.left = "".concat(currentLeft + _gapX, "px");
+                currentLeft = currentLeft + _gapX + inProcessEl.width;
+              }
+            }
+            if (!el.classList.contains("gs-sortable-placeholder")) {
+              el.style.top = "".concat(_containerPT, "px");
+              if (currentLeft == _containerPL) {
+                el.style.left = "".concat(_containerPL, "px");
+                currentLeft = _containerPL + width;
+                _currentWidth = _currentWidth + width;
+              } else {
+                el.style.left = "".concat(currentLeft + _gapX, "px");
+                currentLeft = currentLeft + _gapX + width;
+                _currentWidth = _currentWidth + width + _gapX;
+              }
+            }
+            if (height > maxHeight) {
+              maxHeight = height;
+            }
+          } else if (params.type == _types["default"].grid) {
+            if (itIndex == plIndex) {
+              var left = itIndex % params.count == 0 ? _containerPL : _containerPL + itIndex % params.count * (_itemWidth + _gapX);
+              var top = currentTop;
+              if (inProcessEl.height > colHeight) {
+                colHeight = inProcessEl.height;
+              }
+              if (itIndex % params.count === params.count - 1 || itIndex === itemsCount - 1) {
+                if (top === _containerPT) {
+                  _currentHeight = _currentHeight + colHeight;
+                } else {
+                  _currentHeight = _currentHeight + colHeight + _gapY;
+                }
+                currentTop = currentTop + colHeight + _gapY;
+                colHeight = 0;
+                ref.grid.style.height = "".concat(_currentHeight, "px");
+              }
+              itIndex += 1;
+              info.newTop = top;
+              info.newLeft = left;
+              info.placeholder.style.left = "".concat(left, "px");
+              info.placeholder.style.top = "".concat(top, "px");
+            }
+            if (!el.classList.contains("gs-sortable-placeholder")) {
+              var _left = itIndex % params.count == 0 ? _containerPL : _containerPL + itIndex % params.count * (_itemWidth + _gapX);
+              var _top = currentTop;
+              if (height > colHeight) {
+                colHeight = height;
+              }
+              if (itIndex % params.count === params.count - 1 || itIndex === itemsCount - 1) {
+                if (_top === _containerPT) {
+                  _currentHeight = _currentHeight + colHeight;
+                } else {
+                  _currentHeight = _currentHeight + colHeight + _gapY;
+                }
+                currentTop = currentTop + colHeight + _gapY;
+                colHeight = 0;
+                ref.grid.style.height = "".concat(_currentHeight, "px");
+              }
+              el.style.left = "".concat(_left, "px");
+              el.style.top = "".concat(_top, "px");
+            }
+          }
+          itIndex += 1;
+        }
+      });
+    }
+  }
+};
+var _default = exports["default"] = calculateOnSort;

package/dist/actions/checkItemInContainer.js

@@ -1,28 +1,26 @@
-import { getOffsetFromWindow } from './general';
-
-const checkItemInContainer = (grid, el) => {
-  const gridOffset = getOffsetFromWindow(grid);
-  const elOffset = getOffsetFromWindow(el);
-  const gridTop = gridOffset.top;
-  const gridLeft = gridOffset.left;
-  const elTop = elOffset.top;
-  const elLeft = elOffset.left;
-
-  const offsetTopFromGrid = elTop - gridTop;
-  const offsetLeftFromGrid = elLeft - gridLeft;
-  const elHeight = el.offsetHeight;
-  const elWidth = el.offsetWidth;
-  const gridHeight = grid.offsetHeight;
-  const gridWidth = grid.offsetWidth;
-  if (
-    offsetTopFromGrid >= (-1 * elHeight) / 2 &&
-    offsetLeftFromGrid >= (-1 * elWidth) / 2 &&
-    offsetTopFromGrid <= gridHeight - elHeight / 2 &&
-    offsetLeftFromGrid <= gridWidth - elWidth / 2
-  ) {
-    return true;
-  }
-  return false;
-};
-
-export default checkItemInContainer;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _general = require("./general");
+var checkItemInContainer = function checkItemInContainer(grid, el) {
+  var gridOffset = (0, _general.getOffsetFromWindow)(grid);
+  var elOffset = (0, _general.getOffsetFromWindow)(el);
+  var gridTop = gridOffset.top;
+  var gridLeft = gridOffset.left;
+  var elTop = elOffset.top;
+  var elLeft = elOffset.left;
+  var offsetTopFromGrid = elTop - gridTop;
+  var offsetLeftFromGrid = elLeft - gridLeft;
+  var elHeight = el.offsetHeight;
+  var elWidth = el.offsetWidth;
+  var gridHeight = grid.offsetHeight;
+  var gridWidth = grid.offsetWidth;
+  if (offsetTopFromGrid >= -1 * elHeight / 2 && offsetLeftFromGrid >= -1 * elWidth / 2 && offsetTopFromGrid <= gridHeight - elHeight / 2 && offsetLeftFromGrid <= gridWidth - elWidth / 2) {
+    return true;
+  }
+  return false;
+};
+var _default = exports["default"] = checkItemInContainer;