barsa-user-workspace 0.0.0-watch

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

@@ -0,0 +1,493 @@
+/**
+ * IMPORTANT:
+ * This utils are taken from the project: https://github.com/STRML/react-grid-layout.
+ * The code should be as less modified as possible for easy maintenance.
+ */
+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, 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(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 layoutitems, 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(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 => {
+        return 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, 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) {
+        // 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++;
+            // ALso move element as left as much as we can (buw-custom-change)
+            while (l.x > 0 && !getFirstCollision(compareWith, l)) {
+                l.x--;
+            }
+        }
+    }
+    // Ensure that there are no negative positions
+    l.y = Math.max(l.y, 0);
+    l.x = Math.max(l.x, 0);
+    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) {
+            collidesWith.push(l);
+        }
+        else {
+            // 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++;
+            }
+        }
+    }
+    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
+        if (collision.static) {
+            layout = moveElementAwayFromCollision(layout, collision, l, isUserAction, compactType, cols);
+        }
+        else {
+            layout = 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 perc(num) {
+    return num * 100 + '%';
+}
+export function setTransform({ top, left, width, height }) {
+    // Replace unitless 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);
+    }
+    else {
+        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;
+        }
+        else 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 Error(contextName + ' must be an array!');
+    }
+    for (let i = 0, len = layout.length; i < len; i++) {
+        const item = layout[i];
+        for (let j = 0; j < subProps.length; j++) {
+            if (typeof item[subProps[j]] !== 'number') {
+                throw new Error('ReactGridLayout: ' +
+                    contextName +
+                    '[' +
+                    i +
+                    '].' +
+                    subProps[j] +
+                    ' 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) {
+    fns.forEach(key => (el[key] = el[key].bind(el)));
+}
+function log(...args) {
+    if (!DEBUG) {
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(...args);
+}
+export const noop = () => { };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"react-grid-layout.utils.js","sourceRoot":"","sources":["../../../../../projects/barsa-user-workspace/src/lib/utils/react-grid-layout.utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * IMPORTANT:\n * This utils are taken from the project: https://github.com/STRML/react-grid-layout.\n * The code should be as less modified as possible for easy maintenance.\n */\n\n// Disable lint since we don't want to modify this code\n/* eslint-disable */\nexport type 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 = Array<LayoutItem>;\nexport type Position = {\n    left: number;\n    top: number;\n    width: number;\n    height: number;\n};\nexport type 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 type PartialPosition = { left: number; top: number };\nexport type DroppingPosition = { x: number; y: number; e: Event };\nexport type Size = { width: number; height: number };\nexport type GridDragEvent = {\n    e: Event;\n    node: HTMLElement;\n    newPosition: PartialPosition;\n};\nexport type GridResizeEvent = { e: Event; node: HTMLElement; size: Size };\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        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(layout.length);\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) { clonedLayoutItem.minW = layoutItem.minW;}\n    if (layoutItem.maxW !== undefined) { clonedLayoutItem.maxW = layoutItem.maxW;}\n    if (layoutItem.minH !== undefined) { clonedLayoutItem.minH = layoutItem.minH;}\n    if (layoutItem.maxH !== undefined) { clonedLayoutItem.maxH = layoutItem.maxH;}\n    // These can be null\n    if (layoutItem.isDraggable !== undefined) { clonedLayoutItem.isDraggable = layoutItem.isDraggable;}\n    if (layoutItem.isResizable !== undefined) { clonedLayoutItem.isResizable = layoutItem.isResizable;}\n\n    return clonedLayoutItem;\n}\n\n/**\n * Given two layoutitems, 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(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;\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\n        .map(layoutItem => {\n            return layoutItem.id;\n        })\n        .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                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        // 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            // ALso move element as left as much as we can (buw-custom-change)\n            while (l.x > 0 && !getFirstCollision(compareWith, l)) {\n                l.x--;\n            }\n        }\n    }\n\n    // Ensure that there are no negative positions\n    l.y = Math.max(l.y, 0);\n    l.x = Math.max(l.x, 0);\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(layout: Layout, bounds: { cols: number }): 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            collidesWith.push(l);\n        } else {\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        }\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): Array<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): Array<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 ${\n                collision.id\n            } 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        if (collision.static) {\n            layout = moveElementAwayFromCollision(\n                layout,\n                collision,\n                l,\n                isUserAction,\n                compactType,\n                cols,\n            );\n        } else {\n            layout = moveElementAwayFromCollision(\n                layout,\n                l,\n                collision,\n                isUserAction,\n                compactType,\n                cols,\n            );\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\n                ? Math.max(collidesWith.x - itemToMove.w, 0)\n                : itemToMove.x,\n            y: compactV\n                ? Math.max(collidesWith.y - itemToMove.h, 0)\n                : 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 [${\n                    fakeItem.x\n                },${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 perc(num: number): string {\n    return num * 100 + '%';\n}\n\nexport function setTransform({top, left, width, height}: Position): Object {\n    // Replace unitless 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    } else {\n        return sortLayoutItemsByRowCol(layout);\n    }\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        } else 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(\n    layout: Layout,\n    contextName: string = 'Layout',\n): void {\n    const subProps = ['x', 'y', 'w', 'h'];\n    if (!Array.isArray(layout)) {\n        throw new Error(contextName + ' must be an array!');\n    }\n    for (let i = 0, len = layout.length; i < len; i++) {\n        const item = layout[i];\n        for (let j = 0; j < subProps.length; j++) {\n            if (typeof item[subProps[j]] !== 'number') {\n                throw new Error(\n                    'ReactGridLayout: ' +\n                    contextName +\n                    '[' +\n                    i +\n                    '].' +\n                    subProps[j] +\n                    ' must be a number!',\n                );\n            }\n        }\n        if (item.id && typeof item.id !== 'string') {\n            throw new Error(\n                'ReactGridLayout: ' +\n                contextName +\n                '[' +\n                i +\n                '].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: Array<string>): void {\n    fns.forEach(key => (el[key] = el[key].bind(el)));\n}\n\nfunction log(...args) {\n    if (!DEBUG) {\n        return;\n    }\n    // eslint-disable-next-line no-console\n    console.log(...args);\n}\n\nexport const noop = () => {};\n"]}