asp-smart-ui-plus-test/lib/components/pc/advanced/grid-layout/src/helpers/utils.js

A Component Library for Vue 3

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function bottom(layout) {
  let max = 0, bottomY;
  for (let i = 0, len = layout.length; i < len; i++) {
    bottomY = layout[i].gridStyle.y + layout[i].gridStyle.h;
    if (bottomY > max)
      max = bottomY;
  }
  return max;
}
function calcContainerHeight(layout, opt) {
  const { rowHeight, margin, padding } = opt;
  const list = (layout == null ? void 0 : layout.length) > 0 ? layout : [
    {
      gridStyle: {
        i: "-1",
        w: 6,
        h: 6,
        x: 0,
        y: 0
      }
    }
  ];
  return bottom(list) * (rowHeight + margin) + padding * 2 - margin;
}
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;
}
function cloneLayoutItem(layoutItem) {
  return JSON.parse(JSON.stringify(layoutItem));
}
function collides(l1, l2) {
  if (l1 === l2)
    return false;
  if (l1.gridStyle.x + l1.gridStyle.w <= l2.gridStyle.x)
    return false;
  if (l1.gridStyle.x >= l2.gridStyle.x + l2.gridStyle.w)
    return false;
  if (l1.gridStyle.y + l1.gridStyle.h <= l2.gridStyle.y)
    return false;
  if (l1.gridStyle.y >= l2.gridStyle.y + l2.gridStyle.h)
    return false;
  return true;
}
function compact(layout, verticalCompact, minPositions) {
  const compareWith = getStatics(layout);
  const sorted = sortLayoutItemsByRowCol(layout);
  const out = Array.from({ length: layout.length });
  for (let i = 0, len = sorted.length; i < len; i++) {
    let l = sorted[i];
    if (!l.gridStyle.static) {
      l = compactItem(compareWith, l, verticalCompact, minPositions);
      compareWith.push(l);
    }
    out[layout.indexOf(l)] = l;
    l.gridStyle.moved = false;
  }
  return out;
}
function compactItem(compareWith, l, verticalCompact, minPositions) {
  if (verticalCompact) {
    while (l.gridStyle.y > 0 && !getFirstCollision(compareWith, l)) {
      l.gridStyle.y--;
    }
  } else if (minPositions) {
    const minY = minPositions[l.gridStyle.i].gridStyle.y;
    while (l.gridStyle.y > minY && !getFirstCollision(compareWith, l)) {
      l.gridStyle.y--;
    }
  }
  let collides2;
  while (collides2 = getFirstCollision(compareWith, l)) {
    l.gridStyle.y = collides2.gridStyle.y + collides2.gridStyle.h;
  }
  return l;
}
function getLayoutItem(layout, id) {
  for (let i = 0, len = layout.length; i < len; i++) {
    if (layout[i].gridStyle.i === id)
      return layout[i];
  }
}
function getFirstCollision(layout, layoutItem) {
  for (let i = 0, len = layout.length; i < len; i++) {
    if (collides(layout[i], layoutItem))
      return layout[i];
  }
}
function getAllCollisions(layout, layoutItem) {
  return layout.filter((l) => collides(l, layoutItem));
}
function getStatics(layout) {
  return layout.filter((l) => l.gridStyle.static);
}
function moveElement(layout, l, x, y, isUserAction, preventCollision) {
  if (l.gridStyle.static)
    return layout;
  const oldX = l.gridStyle.x;
  const oldY = l.gridStyle.y;
  const movingUp = y && l.gridStyle.y > y;
  if (typeof x === "number")
    l.gridStyle.x = x;
  if (typeof y === "number")
    l.gridStyle.y = y;
  l.gridStyle.moved = true;
  let sorted = sortLayoutItemsByRowCol(layout);
  if (movingUp)
    sorted = sorted.reverse();
  const collisions = getAllCollisions(sorted, l);
  if (preventCollision && collisions.length) {
    l.gridStyle.x = oldX;
    l.gridStyle.y = oldY;
    l.gridStyle.moved = false;
    return layout;
  }
  for (let i = 0, len = collisions.length; i < len; i++) {
    const collision = collisions[i];
    if (collision.gridStyle.moved)
      continue;
    if (l.gridStyle.y > collision.gridStyle.y && l.gridStyle.y - collision.gridStyle.y > collision.gridStyle.h / 4)
      continue;
    if (collision.gridStyle.static) {
      layout = moveElementAwayFromCollision(layout, collision, l, isUserAction);
    } else {
      layout = moveElementAwayFromCollision(layout, l, collision, isUserAction);
    }
  }
  return layout;
}
function moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction) {
  const preventCollision = false;
  if (isUserAction) {
    const fakeItem = {
      gridStyle: {
        x: itemToMove.gridStyle.x,
        y: itemToMove.gridStyle.y,
        w: itemToMove.gridStyle.w,
        h: itemToMove.gridStyle.h,
        i: "-1"
      }
    };
    fakeItem.gridStyle.y = Math.max(
      collidesWith.gridStyle.y - itemToMove.gridStyle.h,
      0
    );
    if (!getFirstCollision(layout, fakeItem)) {
      return moveElement(
        layout,
        itemToMove,
        void 0,
        fakeItem.gridStyle.y,
        preventCollision
      );
    }
  }
  return moveElement(
    layout,
    itemToMove,
    void 0,
    itemToMove.gridStyle.y + 1,
    preventCollision
  );
}
function setTransform(top, left, width, height) {
  const translate = `translate3d(${left}px,${top}px, 0)`;
  return {
    transform: translate,
    WebkitTransform: translate,
    MozTransform: translate,
    msTransform: translate,
    OTransform: translate,
    width: `${width}px`,
    height: `${height}px`,
    position: "absolute"
  };
}
function setTopLeft(top, left, width, height) {
  return {
    top: `${top}px`,
    left: `${left}px`,
    width: `${width}px`,
    height: `${height}px`,
    position: "absolute"
  };
}
function sortLayoutItemsByRowCol(layout) {
  const a = [];
  return a.concat(layout).sort((a2, b) => {
    if (a2.gridStyle.y === b.gridStyle.y && a2.gridStyle.x === b.gridStyle.x) {
      return 0;
    }
    if (a2.gridStyle.y > b.gridStyle.y || a2.gridStyle.y === b.gridStyle.y && a2.gridStyle.x > b.gridStyle.x) {
      return 1;
    }
    return -1;
  });
}
function validateLayout(layout, contextName) {
  contextName = contextName || "Layout";
  const subProps = ["x", "y", "w", "h"];
  const keyArr = [];
  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 (const subProp of subProps) {
      const field = subProp;
      if (typeof item.gridStyle[field] !== "number") {
        throw new TypeError(
          `VueGridLayout: ${contextName}[${i}].${subProp} must be a number!`
        );
      }
    }
    if (item.gridStyle.i === void 0 || item.gridStyle.i === null) {
      throw new Error(`VueGridLayout: ${contextName}[${i}].i cannot be null!`);
    }
    if (typeof item.gridStyle.i !== "number" && typeof item.gridStyle.i !== "string") {
      throw new TypeError(
        `VueGridLayout: ${contextName}[${i}].i must be a string or number!`
      );
    }
    if (keyArr.includes(item.gridStyle.i)) {
      throw new Error(`VueGridLayout: ${contextName}[${i}].i must be unique!`);
    }
    keyArr.push(item.gridStyle.i);
    if (item.static !== void 0 && typeof item.static !== "boolean") {
      throw new Error(
        `VueGridLayout: ${contextName}[${i}].static must be a boolean!`
      );
    }
  }
}

exports.bottom = bottom;
exports.calcContainerHeight = calcContainerHeight;
exports.cloneLayout = cloneLayout;
exports.cloneLayoutItem = cloneLayoutItem;
exports.collides = collides;
exports.compact = compact;
exports.compactItem = compactItem;
exports.getAllCollisions = getAllCollisions;
exports.getFirstCollision = getFirstCollision;
exports.getLayoutItem = getLayoutItem;
exports.getStatics = getStatics;
exports.moveElement = moveElement;
exports.moveElementAwayFromCollision = moveElementAwayFromCollision;
exports.setTopLeft = setTopLeft;
exports.setTransform = setTransform;
exports.sortLayoutItemsByRowCol = sortLayoutItemsByRowCol;
exports.validateLayout = validateLayout;