@alauda-fe/common 1.0.0-next.0

package/esm2022/grid-layout/utils/react-grid-layout.utils.mjs

@@ -0,0 +1,471 @@
+/* eslint-disable sonar/no-redundant-optional */
+/* eslint-disable sonarjs/no-duplicate-string */
+const DEBUG = false;
+/**
+ * Return the bottom coordinate of the layout.
+ *
+ * @param  {Array} layout Layout array.
+ * @return {Number}       Bottom coordinate.
+ */
+export function bottom(layout) {
+    let max = 0;
+    let bottomY;
+    for (let i = 0, len = layout.length; i < len; i++) {
+        bottomY = layout[i].y + layout[i].h;
+        if (bottomY > max) {
+            max = bottomY;
+        }
+    }
+    return max;
+}
+export function cloneLayout(layout) {
+    const newLayout = Array.from({ length: layout.length });
+    for (let i = 0, len = layout.length; i < len; i++) {
+        newLayout[i] = cloneLayoutItem(layout[i]);
+    }
+    return newLayout;
+}
+// Fast path to cloning, since this is monomorphic
+/** NOTE: This code has been modified from the original source */
+export function cloneLayoutItem(layoutItem) {
+    const clonedLayoutItem = {
+        w: layoutItem.w,
+        h: layoutItem.h,
+        x: layoutItem.x,
+        y: layoutItem.y,
+        id: layoutItem.id,
+        moved: !!layoutItem.moved,
+        static: !!layoutItem.static,
+    };
+    if (layoutItem.minW !== undefined) {
+        clonedLayoutItem.minW = layoutItem.minW;
+    }
+    if (layoutItem.maxW !== undefined) {
+        clonedLayoutItem.maxW = layoutItem.maxW;
+    }
+    if (layoutItem.minH !== undefined) {
+        clonedLayoutItem.minH = layoutItem.minH;
+    }
+    if (layoutItem.maxH !== undefined) {
+        clonedLayoutItem.maxH = layoutItem.maxH;
+    }
+    // These can be null
+    if (layoutItem.isDraggable !== undefined) {
+        clonedLayoutItem.isDraggable = layoutItem.isDraggable;
+    }
+    if (layoutItem.isResizable !== undefined) {
+        clonedLayoutItem.isResizable = layoutItem.isResizable;
+    }
+    return clonedLayoutItem;
+}
+/**
+ * Given two layout items, check if they collide.
+ */
+export function collides(l1, l2) {
+    if (l1.id === l2.id) {
+        return false;
+    } // same element
+    if (l1.x + l1.w <= l2.x) {
+        return false;
+    } // l1 is left of l2
+    if (l1.x >= l2.x + l2.w) {
+        return false;
+    } // l1 is right of l2
+    if (l1.y + l1.h <= l2.y) {
+        return false;
+    } // l1 is above l2
+    if (l1.y >= l2.y + l2.h) {
+        return false;
+    } // l1 is below l2
+    return true; // boxes overlap
+}
+/**
+ * Given a layout, compact it. This involves going down each y coordinate and removing gaps
+ * between items.
+ *
+ * @param  {Array} layout Layout.
+ * @param  {Boolean} verticalCompact Whether or not to compact the layout
+ *   vertically.
+ * @return {Array}       Compacted Layout.
+ */
+export function compact(layout, compactType, cols) {
+    // Statics go in the compareWith array right away so items flow around them.
+    const compareWith = getStatics(layout);
+    // We go through the items by row and column.
+    const sorted = sortLayoutItems(layout, compactType);
+    // Holding for new items.
+    const out = Array.from({ length: layout.length });
+    for (let i = 0, len = sorted.length; i < len; i++) {
+        let l = cloneLayoutItem(sorted[i]);
+        // Don't move static elements
+        if (!l.static) {
+            l = compactItem(compareWith, l, compactType, cols, sorted);
+            // Add to comparison array. We only collide with items before this one.
+            // Statics are already in this array.
+            compareWith.push(l);
+        }
+        // Add to output array to make sure they still come out in the right order.
+        out[layout.indexOf(sorted[i])] = l;
+        // Clear moved flag, if it exists.
+        l.moved = false;
+    }
+    return out;
+}
+const heightWidth = { x: 'w', y: 'h' };
+/**
+ * Before moving item down, it will check if the movement will cause collisions and move those items down before.
+ */
+function resolveCompactionCollision(layout, item, moveToCoord, axis) {
+    const sizeProp = heightWidth[axis];
+    item[axis] += 1;
+    const itemIndex = layout.map(layoutItem => layoutItem.id).indexOf(item.id);
+    // Go through each item we collide with.
+    for (let i = itemIndex + 1; i < layout.length; i++) {
+        const otherItem = layout[i];
+        // Ignore static items
+        if (otherItem.static) {
+            continue;
+        }
+        // Optimization: we can break early if we know we're past this el
+        // We can do this b/c it's a sorted layout
+        if (otherItem.y > item.y + item.h) {
+            break;
+        }
+        if (collides(item, otherItem)) {
+            resolveCompactionCollision(layout, otherItem, 
+            // @ts-ignore
+            moveToCoord + item[sizeProp], axis);
+        }
+    }
+    item[axis] = moveToCoord;
+}
+/**
+ * Compact an item in the layout.
+ */
+export function compactItem(compareWith, l, compactType, cols, fullLayout) {
+    const compactV = compactType === 'vertical';
+    const compactH = compactType === 'horizontal';
+    if (compactV) {
+        // Bottom 'y' possible is the bottom of the layout.
+        // This allows you to do nice stuff like specify {y: Infinity}
+        // This is here because the layout must be sorted in order to get the correct bottom `y`.
+        l.y = Math.min(bottom(compareWith), l.y);
+        // Move the element up as far as it can go without colliding.
+        while (l.y > 0 && !getFirstCollision(compareWith, l)) {
+            l.y--;
+        }
+    }
+    else if (compactH) {
+        l.y = Math.min(bottom(compareWith), l.y);
+        // Move the element left as far as it can go without colliding.
+        while (l.x > 0 && !getFirstCollision(compareWith, l)) {
+            l.x--;
+        }
+    }
+    // Move it down, and keep moving it down if it's colliding.
+    let collides;
+    while ((collides = getFirstCollision(compareWith, l))) {
+        if (compactH) {
+            resolveCompactionCollision(fullLayout, l, collides.x + collides.w, 'x');
+        }
+        else {
+            resolveCompactionCollision(fullLayout, l, collides.y + collides.h, 'y');
+        }
+        // Since we can't grow without bounds horizontally, if we've overflown, let's move it down and try again.
+        if (compactH && l.x + l.w > cols) {
+            l.x = cols - l.w;
+            l.y++;
+        }
+    }
+    return l;
+}
+/**
+ * Given a layout, make sure all elements fit within its bounds.
+ *
+ * @param  {Array} layout Layout array.
+ * @param  {Number} bounds Number of columns.
+ */
+export function correctBounds(layout, bounds) {
+    const collidesWith = getStatics(layout);
+    for (let i = 0, len = layout.length; i < len; i++) {
+        const l = layout[i];
+        // Overflows right
+        if (l.x + l.w > bounds.cols) {
+            l.x = bounds.cols - l.w;
+        }
+        // Overflows left
+        if (l.x < 0) {
+            l.x = 0;
+            l.w = bounds.cols;
+        }
+        if (l.static) {
+            // If this is static and collides with other statics, we must move it down.
+            // We have to do something nicer than just letting them overlap.
+            while (getFirstCollision(collidesWith, l)) {
+                l.y++;
+            }
+        }
+        else {
+            collidesWith.push(l);
+        }
+    }
+    return layout;
+}
+/**
+ * Get a layout item by ID. Used so we can override later on if necessary.
+ *
+ * @param  {Array}  layout Layout array.
+ * @param  {String} id     ID
+ * @return {LayoutItem}    Item at ID.
+ */
+export function getLayoutItem(layout, id) {
+    for (let i = 0, len = layout.length; i < len; i++) {
+        if (layout[i].id === id) {
+            return layout[i];
+        }
+    }
+    return null;
+}
+/**
+ * Returns the first item this layout collides with.
+ * It doesn't appear to matter which order we approach this from, although
+ * perhaps that is the wrong thing to do.
+ *
+ * @param  {Object} layoutItem Layout item.
+ * @return {Object|undefined}  A colliding layout item, or undefined.
+ */
+export function getFirstCollision(layout, layoutItem) {
+    for (let i = 0, len = layout.length; i < len; i++) {
+        if (collides(layout[i], layoutItem)) {
+            return layout[i];
+        }
+    }
+    return null;
+}
+export function getAllCollisions(layout, layoutItem) {
+    return layout.filter(l => collides(l, layoutItem));
+}
+/**
+ * Get all static elements.
+ * @param  {Array} layout Array of layout objects.
+ * @return {Array}        Array of static layout items..
+ */
+export function getStatics(layout) {
+    return layout.filter(l => l.static);
+}
+/**
+ * Move an element. Responsible for doing cascading movements of other elements.
+ *
+ * @param  {Array}      layout            Full layout to modify.
+ * @param  {LayoutItem} l                 element to move.
+ * @param  {Number}     [x]               X position in grid units.
+ * @param  {Number}     [y]               Y position in grid units.
+ */
+export function moveElement(layout, l, x, y, isUserAction, preventCollision, compactType, cols) {
+    // If this is static and not explicitly enabled as draggable,
+    // no move is possible, so we can short-circuit this immediately.
+    if (l.static && l.isDraggable !== true) {
+        return layout;
+    }
+    // Short-circuit if nothing to do.
+    if (l.y === y && l.x === x) {
+        return layout;
+    }
+    log(`Moving element ${l.id} to [${String(x)},${String(y)}] from [${l.x},${l.y}]`);
+    const oldX = l.x;
+    const oldY = l.y;
+    // This is quite a bit faster than extending the object
+    if (typeof x === 'number') {
+        l.x = x;
+    }
+    if (typeof y === 'number') {
+        l.y = y;
+    }
+    l.moved = true;
+    // If this collides with anything, move it.
+    // When doing this comparison, we have to sort the items we compare with
+    // to ensure, in the case of multiple collisions, that we're getting the
+    // nearest collision.
+    let sorted = sortLayoutItems(layout, compactType);
+    const movingUp = compactType === 'vertical' && typeof y === 'number'
+        ? oldY >= y
+        : compactType === 'horizontal' && typeof x === 'number'
+            ? oldX >= x
+            : false;
+    if (movingUp) {
+        sorted = sorted.reverse();
+    }
+    const collisions = getAllCollisions(sorted, l);
+    // There was a collision; abort
+    if (preventCollision && collisions.length) {
+        log(`Collision prevented on ${l.id}, reverting.`);
+        l.x = oldX;
+        l.y = oldY;
+        l.moved = false;
+        return layout;
+    }
+    // Move each item that collides away from this element.
+    for (let i = 0, len = collisions.length; i < len; i++) {
+        const collision = collisions[i];
+        log(`Resolving collision between ${l.id} at [${l.x},${l.y}] and ${collision.id} at [${collision.x},${collision.y}]`);
+        // Short circuit so we can't infinite loop
+        if (collision.moved) {
+            continue;
+        }
+        // Don't move static items - we have to move *this* element away
+        layout = collision.static
+            ? moveElementAwayFromCollision(layout, collision, l, isUserAction, compactType, cols)
+            : moveElementAwayFromCollision(layout, l, collision, isUserAction, compactType, cols);
+    }
+    return layout;
+}
+/**
+ * This is where the magic needs to happen - given a collision, move an element away from the collision.
+ * We attempt to move it up if there's room, otherwise it goes below.
+ *
+ * @param  {Array} layout            Full layout to modify.
+ * @param  {LayoutItem} collidesWith Layout item we're colliding with.
+ * @param  {LayoutItem} itemToMove   Layout item we're moving.
+ */
+export function moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction, compactType, cols) {
+    const compactH = compactType === 'horizontal';
+    // Compact vertically if not set to horizontal
+    const compactV = compactType !== 'horizontal';
+    const preventCollision = collidesWith.static; // we're already colliding (not for static items)
+    // If there is enough space above the collision to put this element, move it there.
+    // We only do this on the main collision as this can get funky in cascades and cause
+    // unwanted swapping behavior.
+    if (isUserAction) {
+        // Reset isUserAction flag because we're not in the main collision anymore.
+        isUserAction = false;
+        // Make a mock item so we don't modify the item here, only modify in moveElement.
+        const fakeItem = {
+            x: compactH ? Math.max(collidesWith.x - itemToMove.w, 0) : itemToMove.x,
+            y: compactV ? Math.max(collidesWith.y - itemToMove.h, 0) : itemToMove.y,
+            w: itemToMove.w,
+            h: itemToMove.h,
+            id: '-1',
+        };
+        // No collision? If so, we can go up there; otherwise, we'll end up moving down as normal
+        if (!getFirstCollision(layout, fakeItem)) {
+            log(`Doing reverse collision on ${itemToMove.id} up to [${fakeItem.x},${fakeItem.y}].`);
+            return moveElement(layout, itemToMove, compactH ? fakeItem.x : undefined, compactV ? fakeItem.y : undefined, isUserAction, preventCollision, compactType, cols);
+        }
+    }
+    return moveElement(layout, itemToMove, compactH ? itemToMove.x + 1 : undefined, compactV ? itemToMove.y + 1 : undefined, isUserAction, preventCollision, compactType, cols);
+}
+/**
+ * Helper to convert a number to a percentage string.
+ *
+ * @param  {Number} num Any number
+ * @return {String}     That number as a percentage.
+ */
+export function percent(num) {
+    return num * 100 + '%';
+}
+export function setTransform({ top, left, width, height }) {
+    // Replace unit-less items with px
+    const translate = `translate(${left}px,${top}px)`;
+    return {
+        transform: translate,
+        WebkitTransform: translate,
+        MozTransform: translate,
+        msTransform: translate,
+        OTransform: translate,
+        width: `${width}px`,
+        height: `${height}px`,
+        position: 'absolute',
+    };
+}
+export function setTopLeft({ top, left, width, height }) {
+    return {
+        top: `${top}px`,
+        left: `${left}px`,
+        width: `${width}px`,
+        height: `${height}px`,
+        position: 'absolute',
+    };
+}
+/**
+ * Get layout items sorted from top left to right and down.
+ *
+ * @return {Array} Array of layout objects.
+ * @return {Array}        Layout, sorted static items first.
+ */
+export function sortLayoutItems(layout, compactType) {
+    if (compactType === 'horizontal') {
+        return sortLayoutItemsByColRow(layout);
+    }
+    return sortLayoutItemsByRowCol(layout);
+}
+export function sortLayoutItemsByRowCol(layout) {
+    return [].concat(layout).sort(function (a, b) {
+        if (a.y > b.y || (a.y === b.y && a.x > b.x)) {
+            return 1;
+        }
+        if (a.y === b.y && a.x === b.x) {
+            // Without this, we can get different sort results in IE vs. Chrome/FF
+            return 0;
+        }
+        return -1;
+    });
+}
+export function sortLayoutItemsByColRow(layout) {
+    return [].concat(layout).sort(function (a, b) {
+        if (a.x > b.x || (a.x === b.x && a.y > b.y)) {
+            return 1;
+        }
+        return -1;
+    });
+}
+/**
+ * Validate a layout. Throws errors.
+ *
+ * @param  {Array}  layout        Array of layout items.
+ * @param  {String} [contextName] Context name for errors.
+ * @throw  {Error}                Validation error.
+ */
+export function validateLayout(layout, contextName = 'Layout') {
+    const subProps = ['x', 'y', 'w', 'h'];
+    if (!Array.isArray(layout)) {
+        throw new TypeError(contextName + ' must be an array!');
+    }
+    for (let i = 0, len = layout.length; i < len; i++) {
+        const item = layout[i];
+        for (const subProp of subProps) {
+            // @ts-ignore
+            if (typeof item[subProp] !== 'number') {
+                throw new TypeError('ReactGridLayout: ' +
+                    contextName +
+                    '[' +
+                    i +
+                    '].' +
+                    subProp +
+                    ' must be a number!');
+            }
+        }
+        if (item.id && typeof item.id !== 'string') {
+            throw new Error('ReactGridLayout: ' + contextName + '[' + i + '].i must be a string!');
+        }
+        if (item.static !== undefined && typeof item.static !== 'boolean') {
+            throw new Error('ReactGridLayout: ' +
+                contextName +
+                '[' +
+                i +
+                '].static must be a boolean!');
+        }
+    }
+}
+// Flow can't really figure this out, so we just use Object
+export function autoBindHandlers(el, fns) {
+    // @ts-ignore
+    fns.forEach(key => (el[key] = el[key].bind(el)));
+}
+function log(...args) {
+    if (!DEBUG) {
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(...args);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"react-grid-layout.utils.js","sourceRoot":"","sources":["../../../../../../libs/common/src/grid-layout/utils/react-grid-layout.utils.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,gDAAgD;AA0FhD,MAAM,KAAK,GAAG,KAAK,CAAC;AAEpB;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAC,MAAc;IACnC,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,IAAI,OAAO,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;QACjD,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpC,IAAI,OAAO,GAAG,GAAG,EAAE;YACjB,GAAG,GAAG,OAAO,CAAC;SACf;KACF;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAc;IACxC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAW,CAAC;IAClE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;QACjD,SAAS,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;KAC3C;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,kDAAkD;AAClD,iEAAiE;AACjE,MAAM,UAAU,eAAe,CAAC,UAAsB;IACpD,MAAM,gBAAgB,GAAe;QACnC,CAAC,EAAE,UAAU,CAAC,CAAC;QACf,CAAC,EAAE,UAAU,CAAC,CAAC;QACf,CAAC,EAAE,UAAU,CAAC,CAAC;QACf,CAAC,EAAE,UAAU,CAAC,CAAC;QACf,EAAE,EAAE,UAAU,CAAC,EAAE;QACjB,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC,KAAK;QACzB,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,MAAM;KAC5B,CAAC;IAEF,IAAI,UAAU,CAAC,IAAI,KAAK,SAAS,EAAE;QACjC,gBAAgB,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;KACzC;IACD,IAAI,UAAU,CAAC,IAAI,KAAK,SAAS,EAAE;QACjC,gBAAgB,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;KACzC;IACD,IAAI,UAAU,CAAC,IAAI,KAAK,SAAS,EAAE;QACjC,gBAAgB,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;KACzC;IACD,IAAI,UAAU,CAAC,IAAI,KAAK,SAAS,EAAE;QACjC,gBAAgB,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;KACzC;IACD,oBAAoB;IACpB,IAAI,UAAU,CAAC,WAAW,KAAK,SAAS,EAAE;QACxC,gBAAgB,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;KACvD;IACD,IAAI,UAAU,CAAC,WAAW,KAAK,SAAS,EAAE;QACxC,gBAAgB,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;KACvD;IAED,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAc,EAAE,EAAc;IACrD,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;QACnB,OAAO,KAAK,CAAC;KACd,CAAC,eAAe;IACjB,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE;QACvB,OAAO,KAAK,CAAC;KACd,CAAC,mBAAmB;IACrB,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE;QACvB,OAAO,KAAK,CAAC;KACd,CAAC,oBAAoB;IACtB,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE;QACvB,OAAO,KAAK,CAAC;KACd,CAAC,iBAAiB;IACnB,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE;QACvB,OAAO,KAAK,CAAC;KACd,CAAC,iBAAiB;IACnB,OAAO,IAAI,CAAC,CAAC,gBAAgB;AAC/B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,OAAO,CACrB,MAAc,EACd,WAAwB,EACxB,IAAY;IAEZ,4EAA4E;IAC5E,MAAM,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IACvC,6CAA6C;IAC7C,MAAM,MAAM,GAAG,eAAe,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACpD,yBAAyB;IACzB,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAElD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;QACjD,IAAI,CAAC,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAEnC,6BAA6B;QAC7B,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;YACb,CAAC,GAAG,WAAW,CAAC,WAAW,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;YAE3D,uEAAuE;YACvE,qCAAqC;YACrC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SACrB;QAED,2EAA2E;QAC3E,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAEnC,kCAAkC;QAClC,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC;KACjB;IAED,OAAO,GAAa,CAAC;AACvB,CAAC;AAED,MAAM,WAAW,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC;AAEvC;;GAEG;AACH,SAAS,0BAA0B,CACjC,MAAc,EACd,IAAgB,EAChB,WAAmB,EACnB,IAAe;IAEf,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChB,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAE3E,wCAAwC;IACxC,KAAK,IAAI,CAAC,GAAG,SAAS,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAClD,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC5B,sBAAsB;QACtB,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,SAAS;SACV;QAED,iEAAiE;QACjE,0CAA0C;QAC1C,IAAI,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE;YACjC,MAAM;SACP;QAED,IAAI,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE;YAC7B,0BAA0B,CACxB,MAAM,EACN,SAAS;YACT,aAAa;YACb,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,EAC5B,IAAI,CACL,CAAC;SACH;KACF;IAED,IAAI,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC;AAC3B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CACzB,WAAmB,EACnB,CAAa,EACb,WAAwB,EACxB,IAAY,EACZ,UAAkB;IAElB,MAAM,QAAQ,GAAG,WAAW,KAAK,UAAU,CAAC;IAC5C,MAAM,QAAQ,GAAG,WAAW,KAAK,YAAY,CAAC;IAC9C,IAAI,QAAQ,EAAE;QACZ,mDAAmD;QACnD,8DAA8D;QAC9D,yFAAyF;QACzF,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACzC,6DAA6D;QAC7D,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE;YACpD,CAAC,CAAC,CAAC,EAAE,CAAC;SACP;KACF;SAAM,IAAI,QAAQ,EAAE;QACnB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACzC,+DAA+D;QAC/D,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE;YACpD,CAAC,CAAC,CAAC,EAAE,CAAC;SACP;KACF;IAED,2DAA2D;IAC3D,IAAI,QAAQ,CAAC;IACb,OAAO,CAAC,QAAQ,GAAG,iBAAiB,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE;QACrD,IAAI,QAAQ,EAAE;YACZ,0BAA0B,CAAC,UAAU,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;SACzE;aAAM;YACL,0BAA0B,CAAC,UAAU,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;SACzE;QACD,yGAAyG;QACzG,IAAI,QAAQ,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE;YAChC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;YACjB,CAAC,CAAC,CAAC,EAAE,CAAC;SACP;KACF;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAC3B,MAAc,EACd,MAAwB;IAExB,MAAM,YAAY,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;QACjD,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACpB,kBAAkB;QAClB,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE;YAC3B,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;SACzB;QACD,iBAAiB;QACjB,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;YACX,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YACR,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC;SACnB;QACD,IAAI,CAAC,CAAC,MAAM,EAAE;YACZ,2EAA2E;YAC3E,gEAAgE;YAChE,OAAO,iBAAiB,CAAC,YAAY,EAAE,CAAC,CAAC,EAAE;gBACzC,CAAC,CAAC,CAAC,EAAE,CAAC;aACP;SACF;aAAM;YACL,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SACtB;KACF;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAC3B,MAAc,EACd,EAAU;IAEV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;QACjD,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;YACvB,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;SAClB;KACF;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAc,EACd,UAAsB;IAEtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;QACjD,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE;YACnC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;SAClB;KACF;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC9B,MAAc,EACd,UAAsB;IAEtB,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;AACrD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,MAAc;IACvC,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CACzB,MAAc,EACd,CAAa,EACb,CAA4B,EAC5B,CAA4B,EAC5B,YAAwC,EACxC,gBAA4C,EAC5C,WAAwB,EACxB,IAAY;IAEZ,6DAA6D;IAC7D,iEAAiE;IACjE,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,WAAW,KAAK,IAAI,EAAE;QACtC,OAAO,MAAM,CAAC;KACf;IAED,kCAAkC;IAClC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE;QAC1B,OAAO,MAAM,CAAC;KACf;IAED,GAAG,CACD,kBAAkB,CAAC,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,IAChE,CAAC,CAAC,CACJ,GAAG,CACJ,CAAC;IACF,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;IACjB,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;IAEjB,uDAAuD;IACvD,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;QACzB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;KACT;IACD,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;QACzB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;KACT;IACD,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC;IAEf,2CAA2C;IAC3C,wEAAwE;IACxE,wEAAwE;IACxE,qBAAqB;IACrB,IAAI,MAAM,GAAG,eAAe,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAClD,MAAM,QAAQ,GACZ,WAAW,KAAK,UAAU,IAAI,OAAO,CAAC,KAAK,QAAQ;QACjD,CAAC,CAAC,IAAI,IAAI,CAAC;QACX,CAAC,CAAC,WAAW,KAAK,YAAY,IAAI,OAAO,CAAC,KAAK,QAAQ;YACvD,CAAC,CAAC,IAAI,IAAI,CAAC;YACX,CAAC,CAAC,KAAK,CAAC;IACZ,IAAI,QAAQ,EAAE;QACZ,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;KAC3B;IACD,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAE/C,+BAA+B;IAC/B,IAAI,gBAAgB,IAAI,UAAU,CAAC,MAAM,EAAE;QACzC,GAAG,CAAC,0BAA0B,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACX,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QACX,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC;QAChB,OAAO,MAAM,CAAC;KACf;IAED,uDAAuD;IACvD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;QACrD,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAChC,GAAG,CACD,+BAA+B,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,SAAS,CAAC,EAAE,QAAQ,SAAS,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,GAAG,CAChH,CAAC;QAEF,0CAA0C;QAC1C,IAAI,SAAS,CAAC,KAAK,EAAE;YACnB,SAAS;SACV;QAED,gEAAgE;QAChE,MAAM,GAAG,SAAS,CAAC,MAAM;YACvB,CAAC,CAAC,4BAA4B,CAC1B,MAAM,EACN,SAAS,EACT,CAAC,EACD,YAAY,EACZ,WAAW,EACX,IAAI,CACL;YACH,CAAC,CAAC,4BAA4B,CAC1B,MAAM,EACN,CAAC,EACD,SAAS,EACT,YAAY,EACZ,WAAW,EACX,IAAI,CACL,CAAC;KACP;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,4BAA4B,CAC1C,MAAc,EACd,YAAwB,EACxB,UAAsB,EACtB,YAAwC,EACxC,WAAwB,EACxB,IAAY;IAEZ,MAAM,QAAQ,GAAG,WAAW,KAAK,YAAY,CAAC;IAC9C,8CAA8C;IAC9C,MAAM,QAAQ,GAAG,WAAW,KAAK,YAAY,CAAC;IAC9C,MAAM,gBAAgB,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,iDAAiD;IAE/F,mFAAmF;IACnF,oFAAoF;IACpF,8BAA8B;IAC9B,IAAI,YAAY,EAAE;QAChB,2EAA2E;QAC3E,YAAY,GAAG,KAAK,CAAC;QAErB,iFAAiF;QACjF,MAAM,QAAQ,GAAe;YAC3B,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;YACvE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;YACvE,CAAC,EAAE,UAAU,CAAC,CAAC;YACf,CAAC,EAAE,UAAU,CAAC,CAAC;YACf,EAAE,EAAE,IAAI;SACT,CAAC;QAEF,yFAAyF;QACzF,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE;YACxC,GAAG,CACD,8BAA8B,UAAU,CAAC,EAAE,WAAW,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,IAAI,CACnF,CAAC;YACF,OAAO,WAAW,CAChB,MAAM,EACN,UAAU,EACV,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EACjC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EACjC,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,IAAI,CACL,CAAC;SACH;KACF;IAED,OAAO,WAAW,CAChB,MAAM,EACN,UAAU,EACV,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,EACvC,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,EACvC,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,IAAI,CACL,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,GAAW;IACjC,OAAO,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AACzB,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAY;IACjE,kCAAkC;IAClC,MAAM,SAAS,GAAG,aAAa,IAAI,MAAM,GAAG,KAAK,CAAC;IAClD,OAAO;QACL,SAAS,EAAE,SAAS;QACpB,eAAe,EAAE,SAAS;QAC1B,YAAY,EAAE,SAAS;QACvB,WAAW,EAAE,SAAS;QACtB,UAAU,EAAE,SAAS;QACrB,KAAK,EAAE,GAAG,KAAK,IAAI;QACnB,MAAM,EAAE,GAAG,MAAM,IAAI;QACrB,QAAQ,EAAE,UAAU;KACrB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAY;IAC/D,OAAO;QACL,GAAG,EAAE,GAAG,GAAG,IAAI;QACf,IAAI,EAAE,GAAG,IAAI,IAAI;QACjB,KAAK,EAAE,GAAG,KAAK,IAAI;QACnB,MAAM,EAAE,GAAG,MAAM,IAAI;QACrB,QAAQ,EAAE,UAAU;KACrB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAc,EACd,WAAwB;IAExB,IAAI,WAAW,KAAK,YAAY,EAAE;QAChC,OAAO,uBAAuB,CAAC,MAAM,CAAC,CAAC;KACxC;IACD,OAAO,uBAAuB,CAAC,MAAM,CAAC,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,MAAc;IACpD,OAAQ,EAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QACrD,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;YAC3C,OAAO,CAAC,CAAC;SACV;QACD,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YAC9B,sEAAsE;YACtE,OAAO,CAAC,CAAC;SACV;QACD,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,MAAc;IACpD,OAAQ,EAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QACrD,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;YAC3C,OAAO,CAAC,CAAC;SACV;QACD,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc,EAAE,WAAW,GAAG,QAAQ;IACnE,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IACtC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QAC1B,MAAM,IAAI,SAAS,CAAC,WAAW,GAAG,oBAAoB,CAAC,CAAC;KACzD;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;QACjD,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACvB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;YAC9B,aAAa;YACb,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,QAAQ,EAAE;gBACrC,MAAM,IAAI,SAAS,CACjB,mBAAmB;oBACjB,WAAW;oBACX,GAAG;oBACH,CAAC;oBACD,IAAI;oBACJ,OAAO;oBACP,oBAAoB,CACvB,CAAC;aACH;SACF;QACD,IAAI,IAAI,CAAC,EAAE,IAAI,OAAO,IAAI,CAAC,EAAE,KAAK,QAAQ,EAAE;YAC1C,MAAM,IAAI,KAAK,CACb,mBAAmB,GAAG,WAAW,GAAG,GAAG,GAAG,CAAC,GAAG,uBAAuB,CACtE,CAAC;SACH;QACD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE;YACjE,MAAM,IAAI,KAAK,CACb,mBAAmB;gBACjB,WAAW;gBACX,GAAG;gBACH,CAAC;gBACD,6BAA6B,CAChC,CAAC;SACH;KACF;AACH,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,gBAAgB,CAAC,EAAU,EAAE,GAAa;IACxD,aAAa;IACb,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC;AAED,SAAS,GAAG,CAAC,GAAG,IAAe;IAC7B,IAAI,CAAC,KAAK,EAAE;QACV,OAAO;KACR;IACD,sCAAsC;IACtC,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;AACvB,CAAC","sourcesContent":["/* eslint-disable sonar/no-redundant-optional */\n/* eslint-disable sonarjs/no-duplicate-string */\n\n/* eslint-disable sonarjs/cognitive-complexity */\n/* eslint-disable sonarjs/prefer-single-boolean-return */\n/* eslint-disable @typescript-eslint/ban-types */\n/* eslint-disable @typescript-eslint/no-unsafe-call */\n\n// These utils fork from : https://github.com/STRML/react-grid-layout.\n// NOTE: -------> Do not modify this file for easy maintenance !!! <-------\n// We only add eslint-disable/ts-ignore to ignore unnecessary changes\n\nexport interface LayoutItem {\n  w: number;\n  h: number;\n  x: number;\n  y: number;\n  id: string;\n  minW?: number;\n  minH?: number;\n  maxW?: number;\n  maxH?: number;\n  moved?: boolean;\n  static?: boolean;\n  isDraggable?: boolean | null | undefined;\n  isResizable?: boolean | null | undefined;\n}\nexport type Layout = LayoutItem[];\nexport interface Position {\n  left: number;\n  top: number;\n  width: number;\n  height: number;\n}\nexport interface ReactDraggableCallbackData {\n  node: HTMLElement;\n  x?: number;\n  y?: number;\n  deltaX: number;\n  deltaY: number;\n  lastX?: number;\n  lastY?: number;\n}\n\nexport interface PartialPosition {\n  left: number;\n  top: number;\n}\nexport interface DroppingPosition {\n  x: number;\n  y: number;\n  e: Event;\n}\nexport interface Size {\n  width: number;\n  height: number;\n}\nexport interface GridDragEvent {\n  e: Event;\n  node: HTMLElement;\n  newPosition: PartialPosition;\n}\nexport interface GridResizeEvent {\n  e: Event;\n  node: HTMLElement;\n  size: Size;\n}\nexport type DragOverEvent = MouseEvent & {\n  nativeEvent: {\n    layerX: number;\n    layerY: number;\n    target: {\n      className: String;\n    };\n  };\n};\n\n// type REl = ReactElement<any>;\n// export type ReactChildren = ReactChildrenArray<REl>;\n\n// All callbacks are of the signature (layout, oldItem, newItem, placeholder, e).\nexport type EventCallback = (\n  arg0: Layout,\n  oldItem: LayoutItem | null | undefined,\n  newItem: LayoutItem | null | undefined,\n  placeholder: LayoutItem | null | undefined,\n  arg4: Event,\n  arg5: HTMLElement | null | undefined,\n) => void;\nexport type CompactType = ('horizontal' | 'vertical') | null | undefined;\n\nconst DEBUG = false;\n\n/**\n * Return the bottom coordinate of the layout.\n *\n * @param  {Array} layout Layout array.\n * @return {Number}       Bottom coordinate.\n */\nexport function bottom(layout: Layout): number {\n  let max = 0;\n  let bottomY;\n  for (let i = 0, len = layout.length; i < len; i++) {\n    bottomY = layout[i].y + layout[i].h;\n    if (bottomY > max) {\n      max = bottomY;\n    }\n  }\n  return max;\n}\n\nexport function cloneLayout(layout: Layout): Layout {\n  const newLayout = Array.from({ length: layout.length }) as Layout;\n  for (let i = 0, len = layout.length; i < len; i++) {\n    newLayout[i] = cloneLayoutItem(layout[i]);\n  }\n  return newLayout;\n}\n\n// Fast path to cloning, since this is monomorphic\n/** NOTE: This code has been modified from the original source */\nexport function cloneLayoutItem(layoutItem: LayoutItem): LayoutItem {\n  const clonedLayoutItem: LayoutItem = {\n    w: layoutItem.w,\n    h: layoutItem.h,\n    x: layoutItem.x,\n    y: layoutItem.y,\n    id: layoutItem.id,\n    moved: !!layoutItem.moved,\n    static: !!layoutItem.static,\n  };\n\n  if (layoutItem.minW !== undefined) {\n    clonedLayoutItem.minW = layoutItem.minW;\n  }\n  if (layoutItem.maxW !== undefined) {\n    clonedLayoutItem.maxW = layoutItem.maxW;\n  }\n  if (layoutItem.minH !== undefined) {\n    clonedLayoutItem.minH = layoutItem.minH;\n  }\n  if (layoutItem.maxH !== undefined) {\n    clonedLayoutItem.maxH = layoutItem.maxH;\n  }\n  // These can be null\n  if (layoutItem.isDraggable !== undefined) {\n    clonedLayoutItem.isDraggable = layoutItem.isDraggable;\n  }\n  if (layoutItem.isResizable !== undefined) {\n    clonedLayoutItem.isResizable = layoutItem.isResizable;\n  }\n\n  return clonedLayoutItem;\n}\n\n/**\n * Given two layout items, check if they collide.\n */\nexport function collides(l1: LayoutItem, l2: LayoutItem): boolean {\n  if (l1.id === l2.id) {\n    return false;\n  } // same element\n  if (l1.x + l1.w <= l2.x) {\n    return false;\n  } // l1 is left of l2\n  if (l1.x >= l2.x + l2.w) {\n    return false;\n  } // l1 is right of l2\n  if (l1.y + l1.h <= l2.y) {\n    return false;\n  } // l1 is above l2\n  if (l1.y >= l2.y + l2.h) {\n    return false;\n  } // l1 is below l2\n  return true; // boxes overlap\n}\n\n/**\n * Given a layout, compact it. This involves going down each y coordinate and removing gaps\n * between items.\n *\n * @param  {Array} layout Layout.\n * @param  {Boolean} verticalCompact Whether or not to compact the layout\n *   vertically.\n * @return {Array}       Compacted Layout.\n */\nexport function compact(\n  layout: Layout,\n  compactType: CompactType,\n  cols: number,\n): Layout {\n  // Statics go in the compareWith array right away so items flow around them.\n  const compareWith = getStatics(layout);\n  // We go through the items by row and column.\n  const sorted = sortLayoutItems(layout, compactType);\n  // Holding for new items.\n  const out = Array.from({ length: layout.length });\n\n  for (let i = 0, len = sorted.length; i < len; i++) {\n    let l = cloneLayoutItem(sorted[i]);\n\n    // Don't move static elements\n    if (!l.static) {\n      l = compactItem(compareWith, l, compactType, cols, sorted);\n\n      // Add to comparison array. We only collide with items before this one.\n      // Statics are already in this array.\n      compareWith.push(l);\n    }\n\n    // Add to output array to make sure they still come out in the right order.\n    out[layout.indexOf(sorted[i])] = l;\n\n    // Clear moved flag, if it exists.\n    l.moved = false;\n  }\n\n  return out as Layout;\n}\n\nconst heightWidth = { x: 'w', y: 'h' };\n\n/**\n * Before moving item down, it will check if the movement will cause collisions and move those items down before.\n */\nfunction resolveCompactionCollision(\n  layout: Layout,\n  item: LayoutItem,\n  moveToCoord: number,\n  axis: 'x' | 'y',\n) {\n  const sizeProp = heightWidth[axis];\n  item[axis] += 1;\n  const itemIndex = layout.map(layoutItem => layoutItem.id).indexOf(item.id);\n\n  // Go through each item we collide with.\n  for (let i = itemIndex + 1; i < layout.length; i++) {\n    const otherItem = layout[i];\n    // Ignore static items\n    if (otherItem.static) {\n      continue;\n    }\n\n    // Optimization: we can break early if we know we're past this el\n    // We can do this b/c it's a sorted layout\n    if (otherItem.y > item.y + item.h) {\n      break;\n    }\n\n    if (collides(item, otherItem)) {\n      resolveCompactionCollision(\n        layout,\n        otherItem,\n        // @ts-ignore\n        moveToCoord + item[sizeProp],\n        axis,\n      );\n    }\n  }\n\n  item[axis] = moveToCoord;\n}\n\n/**\n * Compact an item in the layout.\n */\nexport function compactItem(\n  compareWith: Layout,\n  l: LayoutItem,\n  compactType: CompactType,\n  cols: number,\n  fullLayout: Layout,\n): LayoutItem {\n  const compactV = compactType === 'vertical';\n  const compactH = compactType === 'horizontal';\n  if (compactV) {\n    // Bottom 'y' possible is the bottom of the layout.\n    // This allows you to do nice stuff like specify {y: Infinity}\n    // This is here because the layout must be sorted in order to get the correct bottom `y`.\n    l.y = Math.min(bottom(compareWith), l.y);\n    // Move the element up as far as it can go without colliding.\n    while (l.y > 0 && !getFirstCollision(compareWith, l)) {\n      l.y--;\n    }\n  } else if (compactH) {\n    l.y = Math.min(bottom(compareWith), l.y);\n    // Move the element left as far as it can go without colliding.\n    while (l.x > 0 && !getFirstCollision(compareWith, l)) {\n      l.x--;\n    }\n  }\n\n  // Move it down, and keep moving it down if it's colliding.\n  let collides;\n  while ((collides = getFirstCollision(compareWith, l))) {\n    if (compactH) {\n      resolveCompactionCollision(fullLayout, l, collides.x + collides.w, 'x');\n    } else {\n      resolveCompactionCollision(fullLayout, l, collides.y + collides.h, 'y');\n    }\n    // Since we can't grow without bounds horizontally, if we've overflown, let's move it down and try again.\n    if (compactH && l.x + l.w > cols) {\n      l.x = cols - l.w;\n      l.y++;\n    }\n  }\n  return l;\n}\n\n/**\n * Given a layout, make sure all elements fit within its bounds.\n *\n * @param  {Array} layout Layout array.\n * @param  {Number} bounds Number of columns.\n */\nexport function correctBounds(\n  layout: Layout,\n  bounds: { cols: number },\n): Layout {\n  const collidesWith = getStatics(layout);\n  for (let i = 0, len = layout.length; i < len; i++) {\n    const l = layout[i];\n    // Overflows right\n    if (l.x + l.w > bounds.cols) {\n      l.x = bounds.cols - l.w;\n    }\n    // Overflows left\n    if (l.x < 0) {\n      l.x = 0;\n      l.w = bounds.cols;\n    }\n    if (l.static) {\n      // If this is static and collides with other statics, we must move it down.\n      // We have to do something nicer than just letting them overlap.\n      while (getFirstCollision(collidesWith, l)) {\n        l.y++;\n      }\n    } else {\n      collidesWith.push(l);\n    }\n  }\n  return layout;\n}\n\n/**\n * Get a layout item by ID. Used so we can override later on if necessary.\n *\n * @param  {Array}  layout Layout array.\n * @param  {String} id     ID\n * @return {LayoutItem}    Item at ID.\n */\nexport function getLayoutItem(\n  layout: Layout,\n  id: string,\n): LayoutItem | null | undefined {\n  for (let i = 0, len = layout.length; i < len; i++) {\n    if (layout[i].id === id) {\n      return layout[i];\n    }\n  }\n  return null;\n}\n\n/**\n * Returns the first item this layout collides with.\n * It doesn't appear to matter which order we approach this from, although\n * perhaps that is the wrong thing to do.\n *\n * @param  {Object} layoutItem Layout item.\n * @return {Object|undefined}  A colliding layout item, or undefined.\n */\nexport function getFirstCollision(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem | null | undefined {\n  for (let i = 0, len = layout.length; i < len; i++) {\n    if (collides(layout[i], layoutItem)) {\n      return layout[i];\n    }\n  }\n  return null;\n}\n\nexport function getAllCollisions(\n  layout: Layout,\n  layoutItem: LayoutItem,\n): LayoutItem[] {\n  return layout.filter(l => collides(l, layoutItem));\n}\n\n/**\n * Get all static elements.\n * @param  {Array} layout Array of layout objects.\n * @return {Array}        Array of static layout items..\n */\nexport function getStatics(layout: Layout): LayoutItem[] {\n  return layout.filter(l => l.static);\n}\n\n/**\n * Move an element. Responsible for doing cascading movements of other elements.\n *\n * @param  {Array}      layout            Full layout to modify.\n * @param  {LayoutItem} l                 element to move.\n * @param  {Number}     [x]               X position in grid units.\n * @param  {Number}     [y]               Y position in grid units.\n */\nexport function moveElement(\n  layout: Layout,\n  l: LayoutItem,\n  x: number | null | undefined,\n  y: number | null | undefined,\n  isUserAction: boolean | null | undefined,\n  preventCollision: boolean | null | undefined,\n  compactType: CompactType,\n  cols: number,\n): Layout {\n  // If this is static and not explicitly enabled as draggable,\n  // no move is possible, so we can short-circuit this immediately.\n  if (l.static && l.isDraggable !== true) {\n    return layout;\n  }\n\n  // Short-circuit if nothing to do.\n  if (l.y === y && l.x === x) {\n    return layout;\n  }\n\n  log(\n    `Moving element ${l.id} to [${String(x)},${String(y)}] from [${l.x},${\n      l.y\n    }]`,\n  );\n  const oldX = l.x;\n  const oldY = l.y;\n\n  // This is quite a bit faster than extending the object\n  if (typeof x === 'number') {\n    l.x = x;\n  }\n  if (typeof y === 'number') {\n    l.y = y;\n  }\n  l.moved = true;\n\n  // If this collides with anything, move it.\n  // When doing this comparison, we have to sort the items we compare with\n  // to ensure, in the case of multiple collisions, that we're getting the\n  // nearest collision.\n  let sorted = sortLayoutItems(layout, compactType);\n  const movingUp =\n    compactType === 'vertical' && typeof y === 'number'\n      ? oldY >= y\n      : compactType === 'horizontal' && typeof x === 'number'\n      ? oldX >= x\n      : false;\n  if (movingUp) {\n    sorted = sorted.reverse();\n  }\n  const collisions = getAllCollisions(sorted, l);\n\n  // There was a collision; abort\n  if (preventCollision && collisions.length) {\n    log(`Collision prevented on ${l.id}, reverting.`);\n    l.x = oldX;\n    l.y = oldY;\n    l.moved = false;\n    return layout;\n  }\n\n  // Move each item that collides away from this element.\n  for (let i = 0, len = collisions.length; i < len; i++) {\n    const collision = collisions[i];\n    log(\n      `Resolving collision between ${l.id} at [${l.x},${l.y}] and ${collision.id} at [${collision.x},${collision.y}]`,\n    );\n\n    // Short circuit so we can't infinite loop\n    if (collision.moved) {\n      continue;\n    }\n\n    // Don't move static items - we have to move *this* element away\n    layout = collision.static\n      ? moveElementAwayFromCollision(\n          layout,\n          collision,\n          l,\n          isUserAction,\n          compactType,\n          cols,\n        )\n      : moveElementAwayFromCollision(\n          layout,\n          l,\n          collision,\n          isUserAction,\n          compactType,\n          cols,\n        );\n  }\n\n  return layout;\n}\n\n/**\n * This is where the magic needs to happen - given a collision, move an element away from the collision.\n * We attempt to move it up if there's room, otherwise it goes below.\n *\n * @param  {Array} layout            Full layout to modify.\n * @param  {LayoutItem} collidesWith Layout item we're colliding with.\n * @param  {LayoutItem} itemToMove   Layout item we're moving.\n */\nexport function moveElementAwayFromCollision(\n  layout: Layout,\n  collidesWith: LayoutItem,\n  itemToMove: LayoutItem,\n  isUserAction: boolean | null | undefined,\n  compactType: CompactType,\n  cols: number,\n): Layout {\n  const compactH = compactType === 'horizontal';\n  // Compact vertically if not set to horizontal\n  const compactV = compactType !== 'horizontal';\n  const preventCollision = collidesWith.static; // we're already colliding (not for static items)\n\n  // If there is enough space above the collision to put this element, move it there.\n  // We only do this on the main collision as this can get funky in cascades and cause\n  // unwanted swapping behavior.\n  if (isUserAction) {\n    // Reset isUserAction flag because we're not in the main collision anymore.\n    isUserAction = false;\n\n    // Make a mock item so we don't modify the item here, only modify in moveElement.\n    const fakeItem: LayoutItem = {\n      x: compactH ? Math.max(collidesWith.x - itemToMove.w, 0) : itemToMove.x,\n      y: compactV ? Math.max(collidesWith.y - itemToMove.h, 0) : itemToMove.y,\n      w: itemToMove.w,\n      h: itemToMove.h,\n      id: '-1',\n    };\n\n    // No collision? If so, we can go up there; otherwise, we'll end up moving down as normal\n    if (!getFirstCollision(layout, fakeItem)) {\n      log(\n        `Doing reverse collision on ${itemToMove.id} up to [${fakeItem.x},${fakeItem.y}].`,\n      );\n      return moveElement(\n        layout,\n        itemToMove,\n        compactH ? fakeItem.x : undefined,\n        compactV ? fakeItem.y : undefined,\n        isUserAction,\n        preventCollision,\n        compactType,\n        cols,\n      );\n    }\n  }\n\n  return moveElement(\n    layout,\n    itemToMove,\n    compactH ? itemToMove.x + 1 : undefined,\n    compactV ? itemToMove.y + 1 : undefined,\n    isUserAction,\n    preventCollision,\n    compactType,\n    cols,\n  );\n}\n\n/**\n * Helper to convert a number to a percentage string.\n *\n * @param  {Number} num Any number\n * @return {String}     That number as a percentage.\n */\nexport function percent(num: number): string {\n  return num * 100 + '%';\n}\n\nexport function setTransform({ top, left, width, height }: Position): Object {\n  // Replace unit-less items with px\n  const translate = `translate(${left}px,${top}px)`;\n  return {\n    transform: translate,\n    WebkitTransform: translate,\n    MozTransform: translate,\n    msTransform: translate,\n    OTransform: translate,\n    width: `${width}px`,\n    height: `${height}px`,\n    position: 'absolute',\n  };\n}\n\nexport function setTopLeft({ top, left, width, height }: Position): Object {\n  return {\n    top: `${top}px`,\n    left: `${left}px`,\n    width: `${width}px`,\n    height: `${height}px`,\n    position: 'absolute',\n  };\n}\n\n/**\n * Get layout items sorted from top left to right and down.\n *\n * @return {Array} Array of layout objects.\n * @return {Array}        Layout, sorted static items first.\n */\nexport function sortLayoutItems(\n  layout: Layout,\n  compactType: CompactType,\n): Layout {\n  if (compactType === 'horizontal') {\n    return sortLayoutItemsByColRow(layout);\n  }\n  return sortLayoutItemsByRowCol(layout);\n}\n\nexport function sortLayoutItemsByRowCol(layout: Layout): Layout {\n  return ([] as any[]).concat(layout).sort(function (a, b) {\n    if (a.y > b.y || (a.y === b.y && a.x > b.x)) {\n      return 1;\n    }\n    if (a.y === b.y && a.x === b.x) {\n      // Without this, we can get different sort results in IE vs. Chrome/FF\n      return 0;\n    }\n    return -1;\n  });\n}\n\nexport function sortLayoutItemsByColRow(layout: Layout): Layout {\n  return ([] as any[]).concat(layout).sort(function (a, b) {\n    if (a.x > b.x || (a.x === b.x && a.y > b.y)) {\n      return 1;\n    }\n    return -1;\n  });\n}\n\n/**\n * Validate a layout. Throws errors.\n *\n * @param  {Array}  layout        Array of layout items.\n * @param  {String} [contextName] Context name for errors.\n * @throw  {Error}                Validation error.\n */\nexport function validateLayout(layout: Layout, contextName = 'Layout'): void {\n  const subProps = ['x', 'y', 'w', 'h'];\n  if (!Array.isArray(layout)) {\n    throw new TypeError(contextName + ' must be an array!');\n  }\n  for (let i = 0, len = layout.length; i < len; i++) {\n    const item = layout[i];\n    for (const subProp of subProps) {\n      // @ts-ignore\n      if (typeof item[subProp] !== 'number') {\n        throw new TypeError(\n          'ReactGridLayout: ' +\n            contextName +\n            '[' +\n            i +\n            '].' +\n            subProp +\n            ' must be a number!',\n        );\n      }\n    }\n    if (item.id && typeof item.id !== 'string') {\n      throw new Error(\n        'ReactGridLayout: ' + contextName + '[' + i + '].i must be a string!',\n      );\n    }\n    if (item.static !== undefined && typeof item.static !== 'boolean') {\n      throw new Error(\n        'ReactGridLayout: ' +\n          contextName +\n          '[' +\n          i +\n          '].static must be a boolean!',\n      );\n    }\n  }\n}\n\n// Flow can't really figure this out, so we just use Object\nexport function autoBindHandlers(el: Object, fns: string[]): void {\n  // @ts-ignore\n  fns.forEach(key => (el[key] = el[key].bind(el)));\n}\n\nfunction log(...args: unknown[]) {\n  if (!DEBUG) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.log(...args);\n}\n"]}