function rebuildLayout()

in client/src/components/special/grid-layout/layout.js [46:179]
134 lines of code
29 McCabe index (conditional complexity)

function rebuildLayout (layout, gridStyles, rebuildHeights = true, composing = false, move = true) {
  const moveItem = (item, index, array) => {
    const buildBreakPoints = () => {
      const breakPointsX = [];
      const breakPointsY = [];
      for (let i = 0; i < array.length; i++) {
        const layoutItem = array[i];
        if (breakPointsX.indexOf(layoutItem.x) === -1) {
          breakPointsX.push(layoutItem.x);
        }
        if (breakPointsX.indexOf(layoutItem.x + layoutItem.w) === -1) {
          breakPointsX.push(layoutItem.x + layoutItem.w);
        }
        if (breakPointsY.indexOf(layoutItem.y) === -1) {
          breakPointsY.push(layoutItem.y);
        }
        if (breakPointsY.indexOf(layoutItem.y + layoutItem.h) === -1) {
          breakPointsY.push(layoutItem.y + layoutItem.h);
        }
      }
      breakPointsX.sort((a, b) => a - b);
      breakPointsY.sort((a, b) => a - b);
      return {
        breakPointsX,
        breakPointsY
      };
    };
    const zoneIsEmpty = (x1, y1, x2, y2) => {
      for (let i = 0; i < array.length; i++) {
        const layoutItem = array[i];
        if (layoutItem.x <= x1 && layoutItem.x + layoutItem.w >= x1 &&
          layoutItem.x <= x2 && layoutItem.x + layoutItem.w >= x2 &&
          layoutItem.y <= y1 && layoutItem.y + layoutItem.h >= y1 &&
          layoutItem.y <= y2 && layoutItem.y + layoutItem.h >= y2) {
          return false;
        }
      }
      return true;
    };
    const moveY = () => {
      const {breakPointsX, breakPointsY} = buildBreakPoints();
      const yIndex = breakPointsY.indexOf(item.y);
      const x1Index = breakPointsX.indexOf(item.x);
      const x2Index = breakPointsX.indexOf(item.x + item.w);
      let moveTo = item.y;
      for (let i = yIndex - 1; i >= 0; i--) {
        const y1 = breakPointsY[i];
        const y2 = breakPointsY[i + 1];
        let empty = true;
        for (let j = x1Index; j <= x2Index - 1; j++) {
          if (!zoneIsEmpty(breakPointsX[j], y1, breakPointsX[j + 1], y2)) {
            empty = false;
            break;
          }
        }
        if (empty) {
          moveTo = y1;
        } else {
          break;
        }
      }
      if (moveTo !== item.y) {
        item.y = moveTo;
        return true;
      }
      return false;
    };
    const moveX = () => {
      const {breakPointsX, breakPointsY} = buildBreakPoints();
      const xIndex = breakPointsX.indexOf(item.x);
      const y1Index = breakPointsY.indexOf(item.y);
      const y2Index = breakPointsY.indexOf(item.y + item.h);
      let moveTo = item.x;
      for (let i = xIndex - 1; i >= 0; i--) {
        const x1 = breakPointsX[i];
        const x2 = breakPointsX[i + 1];
        let empty = true;
        for (let j = y1Index; j <= y2Index - 1; j++) {
          if (!zoneIsEmpty(x1, breakPointsY[j], x2, breakPointsY[j + 1])) {
            empty = false;
            break;
          }
        }
        if (empty) {
          moveTo = x1;
        } else {
          break;
        }
      }
      if (moveTo !== item.x) {
        item.x = moveTo;
        return true;
      }
      return false;
    };
    const movedByX = moveX();
    const movedByY = moveY();
    return movedByX || movedByY;
  };
  const moveAll = () => {
    let moved = false;
    for (let i = 0; i < layout.length; i++) {
      moved = moved || moveItem(layout[i], i, layout);
    }
    return moved;
  };
  if (move) {
    while (moveAll()) {
    }
  }
  if (rebuildHeights) {
    const dimensions = getTotalDimensions(layout);
    if (composing) {
      dimensions.height = Math.min(3, dimensions.height);
    }
    const widthItem = gridStyles.gridCols / dimensions.width;
    const heightItem = gridStyles.gridRows / dimensions.height;
    return layout.map(item => ({
      i: item.i,
      x: Math.floor((item.x - dimensions.x) * widthItem),
      y: Math.floor((item.y - dimensions.y) * heightItem),
      w: Math.floor(item.w * widthItem),
      h: Math.floor(item.h * heightItem)
    }));
  } else {
    return (layout || []).map(item => ({
      i: item.i,
      x: item.x,
      y: item.y,
      w: item.w,
      h: item.h
    }));
  }
}