@get-set/gs-sortable 0.0.35 → 0.0.37

package/dist-js/bundle.js

@@ -0,0 +1,1181 @@
+
+        (() => {
+          if (window.jQuery) {
+            $.fn.GSSortable = function (params) {
+              this.each(function(){
+                new window.GSSortable(this, params);
+              })
+            };
+          }
+          HTMLElement.prototype.GSSortable = function(params) {
+            new window.GSSortable(this, params);
+          };
+        })();
+      
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 571
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+/// <reference path="./types/global.d.ts" />
+const getCurrentParams_1 = __importDefault(__webpack_require__(238));
+const afterAllImagesLoad_1 = __importDefault(__webpack_require__(502));
+const init_1 = __importDefault(__webpack_require__(43));
+const destroy_1 = __importDefault(__webpack_require__(403));
+const initMouseMove_1 = __importDefault(__webpack_require__(705));
+const initSortEnd_1 = __importDefault(__webpack_require__(518));
+const initScroll_1 = __importDefault(__webpack_require__(618));
+const calculate_1 = __importDefault(__webpack_require__(605));
+const uihelpers_1 = __webpack_require__(432);
+window.GSSortable = function (grid, params = {}) {
+    const _params = { ...params };
+    const _key = _params.reference != undefined && _params.reference !== ''
+        ? _params.reference
+        : (0, uihelpers_1.NewGuid)();
+    _params.reference = _key;
+    if (typeof window.GSSortableConfigue === 'undefined') {
+        window.GSSortableConfigue = {
+            references: [],
+            instance: (ref) => {
+                if (ref != undefined && ref !== '') {
+                    const instance = window.GSSortableConfigue.references.find((x) => x.key === ref);
+                    if (instance != undefined) {
+                        return instance.ref;
+                    }
+                }
+            },
+        };
+        window.addEventListener('mousemove', (e) => (0, initMouseMove_1.default)(e));
+        window.addEventListener('mouseup', (e) => (0, initSortEnd_1.default)(e));
+        window.addEventListener('scroll', () => (0, initScroll_1.default)());
+    }
+    if (window.GSSortableConfigue.references.find((x) => x.key === _key) === undefined) {
+        const currentParams = (0, getCurrentParams_1.default)(_params);
+        window.GSSortableConfigue.references.push({
+            key: _key,
+            ref: {
+                isAdjusting: false,
+                grid,
+                currentParams: { ...currentParams, reference: _key },
+                itemResizeObservers: [],
+                calculate: () => {
+                    (0, calculate_1.default)(window.GSSortableConfigue.instance(_key));
+                },
+                destroy: () => {
+                    (0, destroy_1.default)(window.GSSortableConfigue.instance(_key));
+                },
+                refresh: () => {
+                    const ref = window.GSSortableConfigue.instance(_key);
+                    (0, destroy_1.default)(ref);
+                    (0, init_1.default)(ref);
+                },
+            },
+        });
+        const currentRef = window.GSSortableConfigue.references.find((x) => x.key === _key).ref;
+        (0, init_1.default)(currentRef);
+        (0, afterAllImagesLoad_1.default)(currentRef);
+    }
+    else {
+        console.error(`GSSortable with '${_key}' reference already exists`);
+    }
+};
+exports["default"] = window.GSSortable;
+
+
+/***/ },
+
+/***/ 502
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const calculate_1 = __importDefault(__webpack_require__(605));
+const afterAllImagesLoad = (ref) => {
+    const $images = [...ref.grid.querySelectorAll('img')];
+    const count = $images.length;
+    if (count > 0) {
+        let alreadyLoaded = 0;
+        $images.forEach((img) => {
+            if (img.complete) {
+                alreadyLoaded++;
+                if (alreadyLoaded === count) {
+                    setTimeout(() => (0, calculate_1.default)(ref), 500);
+                }
+            }
+            else {
+                img.onload = () => {
+                    alreadyLoaded++;
+                    if (alreadyLoaded === count) {
+                        setTimeout(() => (0, calculate_1.default)(ref), 500);
+                    }
+                };
+                img.onerror = () => {
+                    alreadyLoaded++;
+                    if (alreadyLoaded === count) {
+                        setTimeout(() => (0, calculate_1.default)(ref), 500);
+                    }
+                };
+            }
+        });
+    }
+    else {
+        setTimeout(() => (0, calculate_1.default)(ref), 500);
+    }
+};
+exports["default"] = afterAllImagesLoad;
+
+
+/***/ },
+
+/***/ 605
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const types_1 = __importDefault(__webpack_require__(178));
+const calculate = (ref) => {
+    const params = ref.currentParams;
+    if (typeof params.beforeInit === 'function') {
+        params.beforeInit();
+    }
+    const $items = Array.from(ref.grid.children).filter((x) => !x.classList.contains('gs-sortable-item-inmove'));
+    const itemsCount = $items.length;
+    ref.grid.style.position = 'relative';
+    if (params.gap !== '') {
+        ref.grid.style.gap = params.gap;
+    }
+    const gridStyles = getComputedStyle(ref.grid);
+    const cssGap = gridStyles.gap;
+    let gapX = 0;
+    let gapY = 0;
+    if (cssGap) {
+        const [cssGapYValue, cssGapXValue] = cssGap.includes(' ')
+            ? cssGap.split(' ')
+            : [cssGap, cssGap];
+        const gapYSize = parseInt(cssGapYValue);
+        const gapXSize = parseInt(cssGapXValue);
+        if (!Number.isNaN(gapYSize))
+            gapY = gapYSize;
+        if (!Number.isNaN(gapXSize))
+            gapX = gapXSize;
+    }
+    const borderBottomWidth = parseFloat(gridStyles.borderBottomWidth);
+    const borderTopWidth = parseFloat(gridStyles.borderTopWidth);
+    const borderLeftWidth = parseFloat(gridStyles.borderLeftWidth);
+    const borderRightWidth = parseFloat(gridStyles.borderRightWidth);
+    const containerPT = parseFloat(gridStyles.paddingTop);
+    const containerPR = parseFloat(gridStyles.paddingRight);
+    const containerPB = parseFloat(gridStyles.paddingBottom);
+    const containerPL = parseFloat(gridStyles.paddingLeft);
+    const containerWidth = ref.grid.clientWidth - containerPR - containerPL;
+    let itemWidth = 0;
+    let strItemWidth = 'max-content';
+    if (params.type === types_1.default.grid) {
+        itemWidth = (containerWidth - (params.count - 1) * gapX) / params.count;
+        strItemWidth = `${itemWidth}px`;
+    }
+    else if (params.type === types_1.default.column) {
+        itemWidth = containerWidth;
+        strItemWidth = `${itemWidth}px`;
+    }
+    ref.itemWidth = strItemWidth;
+    let currentLeft = containerPL;
+    let currentTop = containerPT;
+    let currentHeight = containerPT + containerPB + borderBottomWidth + borderTopWidth;
+    let currentWidth = containerPL + containerPR + borderLeftWidth + borderRightWidth;
+    let maxHeight = 0;
+    $items.forEach((el) => {
+        if (params.type !== types_1.default.row ||
+            !el.classList.contains('gs-sortable-placeholder')) {
+            el.style.width = strItemWidth;
+        }
+    });
+    ref.uiData = {
+        containerPT,
+        containerPR,
+        containerPB,
+        containerPL,
+        containerWidth,
+        currentHeight,
+        currentWidth,
+        itemWidth,
+        gapX,
+        gapY,
+    };
+    let colHeight = 0;
+    $items.forEach((el, index) => {
+        const height = el.offsetHeight;
+        const width = el.offsetWidth;
+        if (params.type === types_1.default.column) {
+            el.style.left = `${containerPL}px`;
+            if (currentTop === containerPT) {
+                el.style.top = `${containerPT}px`;
+                currentTop += height;
+                currentHeight += height;
+            }
+            else {
+                el.style.top = `${currentTop + gapY}px`;
+                currentTop += gapY + height;
+                currentHeight += height + gapY;
+            }
+        }
+        else if (params.type === types_1.default.row) {
+            el.style.top = `${containerPT}px`;
+            if (currentLeft === containerPL) {
+                el.style.left = `${containerPL}px`;
+                currentLeft += width;
+                currentWidth += width;
+            }
+            else {
+                el.style.left = `${currentLeft + gapX}px`;
+                currentLeft += gapX + width;
+                currentWidth += width + gapX;
+            }
+            if (height > maxHeight) {
+                maxHeight = height;
+            }
+        }
+        else if (params.type === types_1.default.grid) {
+            const left = index % params.count === 0
+                ? containerPL
+                : containerPL + (index % params.count) * (itemWidth + gapX);
+            const top = currentTop;
+            if (height > colHeight) {
+                colHeight = height;
+            }
+            if (index % params.count === params.count - 1 ||
+                index === itemsCount - 1) {
+                if (top === containerPT) {
+                    currentHeight += colHeight;
+                }
+                else {
+                    currentHeight += colHeight + gapY;
+                }
+                currentTop += colHeight + gapY;
+                colHeight = 0;
+            }
+            el.style.left = `${left}px`;
+            el.style.top = `${top}px`;
+        }
+    });
+    ref.grid.style.height = `${currentHeight}px`;
+    if (params.type === types_1.default.row) {
+        ref.grid.style.height = `${currentHeight + maxHeight}px`;
+        ref.grid.style.width = `${currentWidth}px`;
+    }
+};
+exports["default"] = calculate;
+
+
+/***/ },
+
+/***/ 960
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const types_1 = __importDefault(__webpack_require__(178));
+const general_1 = __webpack_require__(577);
+const calculateOnSort = (ref) => {
+    const params = ref.currentParams;
+    if (!params.takeClone) {
+        const $items = Array.from(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;
+        const containerCoord = (0, general_1.getOffsetFromWindow)(info?.ref.grid);
+        if (info !== undefined) {
+            const $el = info.$el;
+            const elCoord = (0, general_1.getOffsetFromWindow)($el);
+            inProcessEl = {
+                height: $el.offsetHeight,
+                width: $el.offsetWidth,
+                top: elCoord.top - containerCoord.top,
+                left: elCoord.left - containerCoord.left,
+            };
+        }
+        let plIndex = info?.index ?? 0;
+        let colHeight = 0;
+        let itIndex = 0;
+        // Pass 1 — find where the placeholder should land
+        $items.forEach((el) => {
+            if (!el.classList.contains('gs-sortable-item-inmove')) {
+                const height = el.offsetHeight;
+                const width = el.offsetWidth;
+                if (params.type === types_1.default.column) {
+                    if (!placeholderSeted) {
+                        const placeholderTop = currentTop === containerPT ? containerPT : currentTop + gapY;
+                        const 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 += height;
+                        }
+                        else {
+                            currentTop = currentTop + gapY + height;
+                            currentHeight += height + gapY;
+                        }
+                    }
+                }
+                else if (params.type === types_1.default.row) {
+                    if (!placeholderSeted) {
+                        const placeholderLeft = currentLeft === containerPL ? containerPL : currentLeft + gapX;
+                        const 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 += width;
+                        }
+                        else {
+                            currentLeft = currentLeft + gapX + width;
+                            currentWidth += width + gapX;
+                        }
+                        if (height > maxHeight)
+                            maxHeight = height;
+                    }
+                }
+                else if (params.type === types_1.default.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 += colHeight;
+                            }
+                            else {
+                                currentHeight += colHeight + gapY;
+                            }
+                            currentTop += colHeight + gapY;
+                            colHeight = 0;
+                        }
+                    }
+                }
+                itIndex += 1;
+            }
+        });
+        // Pass 2 — reposition everything including the placeholder
+        {
+            info.index = plIndex;
+            ({
+                containerPT,
+                containerPL,
+                currentHeight,
+                currentWidth,
+                itemWidth,
+                gapX,
+                gapY,
+            } = ref.uiData);
+            currentLeft = containerPL;
+            currentTop = containerPT;
+            itIndex = 0;
+            $items.forEach((el) => {
+                if (!el.classList.contains('gs-sortable-item-inmove')) {
+                    const height = el.offsetHeight;
+                    const width = el.offsetWidth;
+                    if (params.type === types_1.default.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 += height;
+                            }
+                            else {
+                                el.style.top = `${currentTop + gapY}px`;
+                                currentTop = currentTop + gapY + height;
+                                currentHeight += height + gapY;
+                            }
+                        }
+                    }
+                    else if (params.type === types_1.default.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 += width;
+                            }
+                            else {
+                                el.style.left = `${currentLeft + gapX}px`;
+                                currentLeft = currentLeft + gapX + width;
+                                currentWidth += width + gapX;
+                            }
+                        }
+                    }
+                    else if (params.type === types_1.default.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 += colHeight;
+                                }
+                                else {
+                                    currentHeight += colHeight + gapY;
+                                }
+                                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 += colHeight;
+                                }
+                                else {
+                                    currentHeight += colHeight + gapY;
+                                }
+                                currentTop += colHeight + gapY;
+                                colHeight = 0;
+                                ref.grid.style.height = `${currentHeight}px`;
+                            }
+                            el.style.left = `${left}px`;
+                            el.style.top = `${top}px`;
+                        }
+                    }
+                    itIndex += 1;
+                }
+            });
+        }
+    }
+};
+exports["default"] = calculateOnSort;
+
+
+/***/ },
+
+/***/ 490
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const general_1 = __webpack_require__(577);
+const checkItemInContainer = (grid, el) => {
+    const gridOffset = (0, general_1.getOffsetFromWindow)(grid);
+    const elOffset = (0, general_1.getOffsetFromWindow)(el);
+    const offsetTopFromGrid = elOffset.top - gridOffset.top;
+    const offsetLeftFromGrid = elOffset.left - gridOffset.left;
+    const elHeight = el.offsetHeight;
+    const elWidth = el.offsetWidth;
+    const gridHeight = grid.offsetHeight;
+    const gridWidth = grid.offsetWidth;
+    return (offsetTopFromGrid >= (-1 * elHeight) / 2 &&
+        offsetLeftFromGrid >= (-1 * elWidth) / 2 &&
+        offsetTopFromGrid <= gridHeight - elHeight / 2 &&
+        offsetLeftFromGrid <= gridWidth - elWidth / 2);
+};
+exports["default"] = checkItemInContainer;
+
+
+/***/ },
+
+/***/ 403
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const types_1 = __importDefault(__webpack_require__(178));
+const destroy = (ref) => {
+    // Disconnect per-item resize observers to prevent leaks
+    ref.itemResizeObservers?.forEach((obs) => obs.disconnect());
+    ref.itemResizeObservers = [];
+    ref.grid.classList.remove('gs-sortable-instance');
+    ref.grid.classList.remove(`gs-sortable-${ref.currentParams.type}`);
+    ref.grid.style.removeProperty('position');
+    ref.grid.style.removeProperty('gap');
+    ref.grid.style.removeProperty('height');
+    if (ref.currentParams.type === types_1.default.row) {
+        ref.grid.style.removeProperty('width');
+    }
+    Array.from(ref.grid.children).forEach((el) => {
+        const element = el;
+        element.classList.remove('gs-sortable-item');
+        element.style.removeProperty('position');
+        element.style.removeProperty('width');
+        element.style.removeProperty('left');
+        element.style.removeProperty('top');
+        element.style.removeProperty('transition');
+    });
+};
+exports["default"] = destroy;
+
+
+/***/ },
+
+/***/ 577
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.moveChildToIndex = exports.getOffsetFromWindow = exports.getOffsetFromBody = exports.getTranslateCoord = void 0;
+const getTranslateCoord = (element) => {
+    const style = window.getComputedStyle(element);
+    const matrix = new DOMMatrix(style.transform);
+    return {
+        x: matrix.e,
+        y: matrix.f,
+    };
+};
+exports.getTranslateCoord = getTranslateCoord;
+const getOffsetFromBody = (el) => {
+    let top = 0, left = 0;
+    while (el && el !== document.body) {
+        top += el.offsetTop || 0;
+        left += el.offsetLeft || 0;
+        const transform = window.getComputedStyle(el).transform;
+        if (transform !== 'none') {
+            const matrix = new DOMMatrix(transform);
+            top += matrix.m42 || 0;
+            left += matrix.m41 || 0;
+        }
+        el = el.offsetParent;
+    }
+    top += document.body.scrollTop || document.documentElement.scrollTop || 0;
+    left += document.body.scrollLeft || document.documentElement.scrollLeft || 0;
+    return { top, left };
+};
+exports.getOffsetFromBody = getOffsetFromBody;
+const getOffsetFromWindow = (el) => {
+    let top = 0, left = 0;
+    while (el) {
+        top += el.offsetTop || 0;
+        left += el.offsetLeft || 0;
+        const transform = window.getComputedStyle(el).transform;
+        if (transform !== 'none') {
+            const matrix = new DOMMatrix(transform);
+            top += matrix.m42 || 0;
+            left += matrix.m41 || 0;
+        }
+        el = el.offsetParent;
+    }
+    top -= window.scrollY || 0;
+    left -= window.scrollX || 0;
+    return { top, left };
+};
+exports.getOffsetFromWindow = getOffsetFromWindow;
+const moveChildToIndex = (parent, child, newIndex) => {
+    const children = Array.from(parent.children);
+    const oldIndex = children.indexOf(child);
+    if (oldIndex !== newIndex) {
+        newIndex = Math.max(0, Math.min(newIndex, children.length - 1));
+        if (newIndex > oldIndex && oldIndex !== -1) {
+            parent.insertBefore(child, children[newIndex].nextSibling);
+        }
+        else {
+            parent.insertBefore(child, children[newIndex]);
+        }
+    }
+};
+exports.moveChildToIndex = moveChildToIndex;
+
+
+/***/ },
+
+/***/ 238
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const defaultParams_1 = __importDefault(__webpack_require__(636));
+const getCurrentParams = (params) => {
+    const defaultParams = { ...defaultParams_1.default };
+    let finalParams = {
+        ...defaultParams,
+        ...params,
+    };
+    if (finalParams.responsive && finalParams.responsive.length > 0) {
+        finalParams.responsive.sort((a, b) => b.windowSize - a.windowSize);
+    }
+    if (finalParams.responsive && finalParams.responsive.length > 0) {
+        const windowSize = window.innerWidth;
+        const availableResponsives = finalParams.responsive.filter((resp) => resp.windowSize >= windowSize);
+        availableResponsives.forEach((resp) => {
+            finalParams = {
+                ...finalParams,
+                ...resp.params,
+            };
+        });
+    }
+    return finalParams;
+};
+exports["default"] = getCurrentParams;
+
+
+/***/ },
+
+/***/ 43
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const constParams_1 = __importDefault(__webpack_require__(742));
+const calculate_1 = __importDefault(__webpack_require__(605));
+const initDraggable_1 = __importDefault(__webpack_require__(304));
+const init = (ref) => {
+    const transition = `left ${constParams_1.default.animationSpeed}ms, top ${constParams_1.default.animationSpeed}ms, transform ${constParams_1.default.animationSpeed}ms`;
+    ref.grid.classList.add('gs-sortable-instance');
+    ref.grid.classList.add(`gs-sortable-${ref.currentParams.type}`);
+    // Disconnect any observers from a previous init/refresh cycle
+    ref.itemResizeObservers?.forEach((obs) => obs.disconnect());
+    ref.itemResizeObservers = [];
+    Array.from(ref.grid.children).forEach((el) => {
+        const element = el;
+        element.classList.add('gs-sortable-item');
+        element.style.transition = transition;
+        element.style.position = 'absolute';
+        const obs = new ResizeObserver(() => (0, calculate_1.default)(ref));
+        obs.observe(element);
+        ref.itemResizeObservers.push(obs);
+    });
+    ref.count = ref.grid.children.length;
+    (0, initDraggable_1.default)(ref);
+};
+exports["default"] = init;
+
+
+/***/ },
+
+/***/ 304
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const constParams_1 = __importDefault(__webpack_require__(742));
+const general_1 = __webpack_require__(577);
+const initDraggable = (ref) => {
+    const params = ref.currentParams;
+    const $items = Array.from(ref.grid.children);
+    $items.forEach(($el, index) => {
+        $el.onmousedown = null;
+        const handler = params.handler
+            ? $el.querySelector(params.handler)
+            : $el;
+        if (handler instanceof HTMLElement) {
+            handler.style.cursor = 'move';
+            handler.onmousedown = (e) => {
+                if (!ref.isAdjusting) {
+                    window.GSSortableConfigue.overInItemRef = ref;
+                    window.GSSortableConfigue.takeFrom = ref;
+                    const container = ref.grid;
+                    const elStyles = getComputedStyle($el);
+                    const containerStyles = getComputedStyle(container);
+                    const paddingTop = parseFloat(containerStyles.paddingTop);
+                    const paddingLeft = parseFloat(containerStyles.paddingLeft);
+                    const top = parseFloat(elStyles.top);
+                    const left = parseFloat(elStyles.left);
+                    let $draggableEl = $el;
+                    let placeholder;
+                    if (!params.takeClone) {
+                        placeholder = document.createElement('div');
+                        placeholder.classList.add('gs-sortable-placeholder');
+                        placeholder.style.position = elStyles.position;
+                        placeholder.style.transition = `left ${constParams_1.default.animationSpeed}ms, top ${constParams_1.default.animationSpeed}ms, transform ${constParams_1.default.animationSpeed}ms, opacity ${constParams_1.default.animationSpeed}ms`;
+                        placeholder.style.width = `${$el.offsetWidth}px`;
+                        placeholder.style.height = `${$el.offsetHeight}px`;
+                        placeholder.style.top = `${top}px`;
+                        placeholder.style.left = `${left}px`;
+                        placeholder.style.border = elStyles.border;
+                        placeholder.style.borderRadius = elStyles.borderRadius;
+                        ref.grid.append(placeholder);
+                    }
+                    else {
+                        const $cloneEl = $el.cloneNode(true);
+                        ref.grid.append($cloneEl);
+                        $draggableEl = $cloneEl;
+                    }
+                    const elOffsetWindow = (0, general_1.getOffsetFromWindow)($el);
+                    let translateX = !isNaN(left) ? left : 0;
+                    let translateY = !isNaN(top) ? top : 0;
+                    $draggableEl.style.transform = `translate(${translateX - paddingLeft}px, ${translateY - paddingTop}px)`;
+                    $draggableEl.style.top = `${paddingTop}px`;
+                    $draggableEl.style.left = `${paddingLeft}px`;
+                    window.GSSortableConfigue.draggableInfo = {
+                        moved: false,
+                        ref,
+                        index,
+                        $el: $draggableEl,
+                        clientX: e.clientX,
+                        clientY: e.clientY,
+                        placeholder,
+                        newLeft: left,
+                        newTop: top,
+                        fromLeft: (e.clientX - elOffsetWindow.left) / $el.offsetWidth,
+                        fromTop: (e.clientY - elOffsetWindow.top) / $el.offsetHeight,
+                    };
+                    $draggableEl.classList.add('gs-sortable-item-inmove');
+                    ref.grid.classList.add('gs-sortable-active');
+                    const closestItem = ref.grid.closest('.gs-sortable-item');
+                    if (closestItem) {
+                        closestItem.classList.add('gs-sortable-item-active-parent');
+                    }
+                }
+            };
+        }
+    });
+};
+exports["default"] = initDraggable;
+
+
+/***/ },
+
+/***/ 705
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const general_1 = __webpack_require__(577);
+const checkItemInContainer_1 = __importDefault(__webpack_require__(490));
+const calculate_1 = __importDefault(__webpack_require__(605));
+const constParams_1 = __importDefault(__webpack_require__(742));
+const calculateOnSort_1 = __importDefault(__webpack_require__(960));
+const initMouseMove = (event) => {
+    const info = window.GSSortableConfigue?.draggableInfo;
+    if (info !== undefined) {
+        info.moved = true;
+        const allRefs = [];
+        if (window.GSSortableConfigue.takeFrom !== undefined) {
+            allRefs.push(window.GSSortableConfigue.takeFrom);
+        }
+        window.GSSortableConfigue.references.forEach((item) => {
+            if (item.ref.currentParams.acceptFrom.includes(window.GSSortableConfigue.takeFrom.currentParams.reference)) {
+                allRefs.push(item.ref);
+            }
+        });
+        let findedRef = '';
+        allRefs.forEach((item) => {
+            if ((0, checkItemInContainer_1.default)(item.grid, info.$el)) {
+                findedRef = item.currentParams.reference;
+            }
+        });
+        if (findedRef !== '') {
+            const newRef = window.GSSortableConfigue.instance(findedRef);
+            if (newRef !== undefined &&
+                info.ref.currentParams.reference !== newRef.currentParams.reference) {
+                const placeholder = document.querySelector('.gs-sortable-placeholder');
+                if (placeholder != null) {
+                    placeholder.remove();
+                    (0, calculate_1.default)(window.GSSortableConfigue.overInItemRef);
+                }
+                window.GSSortableConfigue.overInItemRef = newRef;
+                info.$el.style.width = window.GSSortableConfigue.overInItemRef.itemWidth;
+                const newWidth = info.$el.clientWidth;
+                const newHeight = info.$el.clientHeight;
+                const newContainerOffset = (0, general_1.getOffsetFromWindow)(window.GSSortableConfigue.takeFrom.grid);
+                const translateY = event.clientY - newContainerOffset.top - newHeight * info.fromTop;
+                const translateX = event.clientX - newContainerOffset.left - newWidth * info.fromLeft;
+                const elStyles = getComputedStyle(info.$el);
+                const top = parseFloat(elStyles.top);
+                const left = parseFloat(elStyles.left);
+                if (!window.GSSortableConfigue.overInItemRef.currentParams.takeClone) {
+                    const newPlaceholder = document.createElement('div');
+                    newPlaceholder.classList.add('gs-sortable-placeholder');
+                    newPlaceholder.style.position = elStyles.position;
+                    info.$el.style.transform = `translate(${translateX}px, ${translateY}px)`;
+                    newPlaceholder.style.transition = `left ${constParams_1.default.animationSpeed}ms, top ${constParams_1.default.animationSpeed}ms, transform ${constParams_1.default.animationSpeed}ms, opacity ${constParams_1.default.animationSpeed}ms`;
+                    newPlaceholder.style.top = `${top}px`;
+                    newPlaceholder.style.left = `${left}px`;
+                    newPlaceholder.style.border = elStyles.border;
+                    newPlaceholder.style.borderRadius = elStyles.borderRadius;
+                    info.placeholder = newPlaceholder;
+                    info.ref = newRef;
+                    newPlaceholder.style.width = `${info.$el.offsetWidth}px`;
+                    newPlaceholder.style.height = `${info.$el.offsetHeight}px`;
+                    newRef.grid.append(newPlaceholder);
+                    (0, calculate_1.default)(newRef);
+                    return;
+                }
+                else {
+                    info.ref = newRef;
+                }
+            }
+        }
+        const params = info.ref.currentParams;
+        const $el = info.$el;
+        const containerStyles = getComputedStyle(info.ref.grid);
+        const paddingLeft = parseFloat(containerStyles.paddingLeft);
+        const paddingTop = parseFloat(containerStyles.paddingTop);
+        const paddingRight = parseFloat(containerStyles.paddingRight);
+        const paddingBottom = parseFloat(containerStyles.paddingBottom);
+        const containerInnerHeight = info.ref.grid.clientHeight - paddingTop - paddingBottom;
+        const containerInnerWidth = info.ref.grid.clientWidth - paddingLeft - paddingRight;
+        const moveX = event.clientX - info.clientX;
+        const moveY = event.clientY - info.clientY;
+        const coord = (0, general_1.getTranslateCoord)($el);
+        info.clientX = event.clientX;
+        info.clientY = event.clientY;
+        let translateX = moveX + coord.x;
+        let translateY = moveY + coord.y;
+        if (!params.allowOutOfBox) {
+            translateX = Math.min(Math.max(translateX, 0), containerInnerWidth - $el.offsetWidth);
+            translateY = Math.min(Math.max(translateY, 0), containerInnerHeight - $el.offsetHeight);
+        }
+        $el.style.transform = `translate(${translateX}px, ${translateY}px)`;
+        if (findedRef !== '') {
+            (0, calculateOnSort_1.default)(window.GSSortableConfigue.overInItemRef);
+        }
+    }
+    window.scrollY = document.documentElement.scrollTop;
+    window.scrollX = document.documentElement.scrollLeft;
+};
+exports["default"] = initMouseMove;
+
+
+/***/ },
+
+/***/ 618
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const general_1 = __webpack_require__(577);
+const initScroll = () => {
+    const info = window.GSSortableConfigue?.draggableInfo;
+    if (info !== undefined) {
+        const coord = (0, general_1.getTranslateCoord)(info.$el);
+        const scrollY = document.documentElement.scrollTop;
+        const scrollX = document.documentElement.scrollLeft;
+        const translateX = coord.x + (scrollX - (window.scrollX || 0));
+        const translateY = coord.y + (scrollY - (window.scrollY || 0));
+        window.scrollY = scrollY;
+        window.scrollX = scrollX;
+        info.$el.style.transform = `translate(${translateX}px, ${translateY}px)`;
+    }
+};
+exports["default"] = initScroll;
+
+
+/***/ },
+
+/***/ 518
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const constParams_1 = __importDefault(__webpack_require__(742));
+const calculate_1 = __importDefault(__webpack_require__(605));
+const general_1 = __webpack_require__(577);
+const initSortEnd = (_event) => {
+    if (window.GSSortableConfigue?.draggableInfo === undefined)
+        return;
+    // Capture all needed values before clearing the global — prevents a second
+    // mousedown during the animation from reading stale isAdjusting state.
+    const draggableInfo = window.GSSortableConfigue.draggableInfo;
+    const { $el, ref, placeholder, moved, newTop, newLeft, index } = draggableInfo;
+    const takeFrom = window.GSSortableConfigue.takeFrom;
+    // Clear global immediately so new drags are not blocked
+    window.GSSortableConfigue.draggableInfo = undefined;
+    if (moved) {
+        let containerDifX = 0;
+        let containerDifY = 0;
+        if (ref.currentParams.reference !== takeFrom.currentParams.reference) {
+            const fromCoord = (0, general_1.getOffsetFromBody)(takeFrom.grid);
+            const toCoord = (0, general_1.getOffsetFromBody)(ref.grid);
+            containerDifY = toCoord.top - fromCoord.top;
+            containerDifX = toCoord.left - fromCoord.left;
+        }
+        ref.isAdjusting = true;
+        $el.classList.remove('gs-sortable-item-inmove');
+        ref.grid.classList.remove('gs-sortable-active');
+        const activeParent = ref.grid.closest('.gs-sortable-item-active-parent');
+        if (activeParent) {
+            activeParent.classList.remove('gs-sortable-item-active-parent');
+        }
+        $el.classList.add('gs-sortable-item-adjusting');
+        $el.style.top = `${newTop + containerDifY}px`;
+        $el.style.left = `${newLeft + containerDifX}px`;
+        $el.style.removeProperty('transform');
+        setTimeout(() => {
+            $el.classList.remove('gs-sortable-item-adjusting');
+            if (ref.currentParams.reference === takeFrom.currentParams.reference &&
+                takeFrom.currentParams.takeClone) {
+                $el.remove();
+            }
+            else {
+                if (index !== undefined) {
+                    (0, general_1.moveChildToIndex)(ref.grid, $el, index);
+                }
+            }
+            placeholder?.remove();
+            if (ref.currentParams.reference !== takeFrom.currentParams.reference) {
+                takeFrom.currentParams.afterSort?.(takeFrom.grid.querySelectorAll('.gs-sortable-item'));
+                ref.currentParams.afterSort?.(ref.grid.querySelectorAll('.gs-sortable-item'));
+                takeFrom.refresh();
+                ref.refresh();
+            }
+            else {
+                (0, calculate_1.default)(ref);
+                ref.currentParams.afterSort?.(ref.grid.querySelectorAll('.gs-sortable-item'));
+            }
+            ref.isAdjusting = false;
+        }, constParams_1.default.animationSpeed);
+    }
+    else {
+        $el.style.top = `${newTop}px`;
+        $el.style.left = `${newLeft}px`;
+        $el.style.removeProperty('transform');
+        placeholder?.remove();
+    }
+};
+exports["default"] = initSortEnd;
+
+
+/***/ },
+
+/***/ 742
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const constParams = {
+    animationSpeed: 400,
+};
+exports["default"] = Object.freeze(constParams);
+
+
+/***/ },
+
+/***/ 636
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const types_1 = __importDefault(__webpack_require__(178));
+const defaultParams = {
+    acceptFrom: [],
+    className: '',
+    takeClone: false,
+    reference: '',
+    count: 3,
+    gap: '',
+    gsx: undefined,
+    handler: '',
+    width: 'auto',
+    type: types_1.default.column,
+    allowOutOfBox: true,
+    responsive: [],
+    afterSort: () => { },
+};
+exports["default"] = Object.freeze(defaultParams);
+
+
+/***/ },
+
+/***/ 178
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const types = {
+    row: 'row',
+    column: 'column',
+    grid: 'grid',
+};
+exports["default"] = Object.freeze(types);
+
+
+/***/ },
+
+/***/ 432
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.convertScssToCss = exports.injectCssToHead = exports.removeCssFromHead = exports.NewGuid = void 0;
+const NewGuid = () => {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+};
+exports.NewGuid = NewGuid;
+const removeCssFromHead = (key) => {
+    const style = document.querySelector(`head style[data-key='${key}']`);
+    if (style != null) {
+        style.remove();
+    }
+};
+exports.removeCssFromHead = removeCssFromHead;
+const injectCssToHead = (css, key) => {
+    const style = document.createElement('style');
+    style.dataset.key = key;
+    style.innerHTML = css;
+    document.head.appendChild(style);
+};
+exports.injectCssToHead = injectCssToHead;
+const camelToKebab = (str) => str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+const convertScssToCss = (scssObj) => {
+    const convertObjectToCss = (obj, parent = '') => {
+        let css = '';
+        for (const key in obj) {
+            const value = obj[key];
+            if (typeof value === 'object') {
+                const newParent = parent ? `${parent} ${key}` : key;
+                css += convertObjectToCss(value, newParent);
+            }
+            else {
+                css += `${parent} { ${camelToKebab(key)}: ${value}; }\n`;
+            }
+        }
+        return css;
+    };
+    return convertObjectToCss(scssObj, '');
+};
+exports.convertScssToCss = convertScssToCss;
+
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(571);
+/******/ 	window.GSSortable = __webpack_exports__["default"];
+/******/ 	
+/******/ })()
+;