@flozy/editor 9.8.3 → 9.8.4

package/dist/Editor/common/RnD/VirtualElement/helper.js

@@ -0,0 +1,382 @@
+import { ROW_HEIGHT, calculateGridArea } from "../Utils/gridDropItem";
+import { Transforms, Editor } from "slate";
+const isBulletOrTickIcon = (width, itemStartRow, startRow) => {
+  return width <= 40 && itemStartRow === startRow;
+};
+export const findFirstRowOverlap = (gridItems, startRow, endRow, textItemIndex) => {
+  let firstOverlapRow;
+  gridItems.forEach((gridItem, index) => {
+    const {
+      gridArea_xs: gridArea,
+      width_xs
+    } = gridItem;
+    if (!gridArea) {
+      return;
+    }
+    const [itemStartRow] = getGridArea(gridArea);
+    const isItemOverlap = itemStartRow >= startRow && itemStartRow <= endRow;
+    if (isBulletOrTickIcon(width_xs, itemStartRow, startRow)) {
+      return;
+    }
+    const isCurrentEle = textItemIndex === index;
+    if (isItemOverlap && !isCurrentEle && gridArea) {
+      firstOverlapRow = firstOverlapRow ? Math.min(firstOverlapRow, itemStartRow) : itemStartRow;
+    }
+  });
+  return firstOverlapRow;
+};
+export const getHeight = (oldHeight, newHeight) => {
+  const changeHeight = oldHeight && oldHeight < newHeight;
+  const height = changeHeight ? newHeight : oldHeight;
+  return {
+    height,
+    changeHeight
+  };
+};
+export const getGridArea = gridArea => {
+  return gridArea.split("/").map(num => parseInt(num));
+};
+const getBoxToAutoAlign = (editor, sectionPath) => {
+  const [boxData] = Editor.nodes(editor, {
+    at: sectionPath,
+    match: node => node.type === "freegridBox" && node.autoAlign
+  });
+  return boxData || [];
+};
+const handleGridItems = (gridItems, lastRow) => {
+  // to find the previously occupied rows
+  gridItems.forEach(item => {
+    const {
+      gridArea_xs: gridArea,
+      marginTop_xs,
+      height_xs,
+      type
+    } = item;
+    if (type === "paragraph") {
+      // non-freegridItem,
+      // some "paragraph" node is defaulty coming inside in box's children
+      return;
+    }
+    const [startRow] = getGridArea(gridArea);
+    const marginTop = marginTop_xs ? Number(marginTop_xs) : 0;
+    const fullHeight = Number(height_xs) + marginTop;
+    const endRow = startRow + Math.floor(fullHeight / ROW_HEIGHT) + 1;
+    lastRow = Math.max(endRow, lastRow);
+  });
+  return {
+    lastRow
+  };
+};
+const handleNonGridItems = (nonGridItems, lastRow, editor, boxPath) => {
+  let containerHeight = (lastRow - 1) * ROW_HEIGHT;
+  let newlyAddedHeight = 0;
+
+  //place it on the next rows that are available
+  nonGridItems.forEach((item, index) => {
+    const {
+      height_xs,
+      type,
+      itemIndex
+    } = item;
+    if (type === "paragraph") {
+      // non-freegridItem
+      return;
+    }
+    const startRow = lastRow || 1;
+    const DEFAULT_NEW_ELEMENT_MARGIN_TOP = 12;
+    let fullHeight = height_xs + DEFAULT_NEW_ELEMENT_MARGIN_TOP;
+    const endRow = startRow + Math.floor(fullHeight / ROW_HEIGHT) + 1;
+    const newGridArea = `${startRow} / 1 / ${startRow + 1} / 2`;
+    const currentElementPath = [...boxPath, itemIndex];
+    Transforms.setNodes(editor, {
+      gridArea_xs: newGridArea,
+      marginTop_xs: 12,
+      left_xs: 12,
+      xs_updatedOn: new Date().getTime()
+    }, {
+      at: currentElementPath
+    });
+    lastRow = Math.max(endRow, lastRow);
+    containerHeight += fullHeight;
+    newlyAddedHeight += fullHeight;
+  });
+  return {
+    lastRow,
+    containerHeight,
+    newlyAddedHeight
+  };
+};
+const alignNewElementInContainer = (editor, boxPath, containerItems) => {
+  let lastRow = 1;
+  const gridItems = [];
+  const nonGridItems = [];
+  containerItems.forEach((item, index) => {
+    if (item?.gridArea_xs) {
+      gridItems.push({
+        ...item,
+        itemIndex: index
+      });
+    } else {
+      nonGridItems.push({
+        ...item,
+        itemIndex: index
+      });
+    }
+  });
+  const {
+    lastRow: lastRowOccupied
+  } = handleGridItems(gridItems, lastRow);
+  lastRow = lastRowOccupied;
+  const {
+    lastRow: lastRowTaken,
+    containerHeight,
+    newlyAddedHeight
+  } = handleNonGridItems(nonGridItems, lastRow, editor, boxPath);
+  lastRow = lastRowTaken;
+  return {
+    lastRow,
+    containerHeight,
+    newlyAddedHeight
+  };
+};
+const getAncestorFreeGridContainers = (editor, path) => {
+  const containers = [...Editor.nodes(editor, {
+    at: path,
+    // Start from the current path
+    match: (node, nodePath) => {
+      const container = ["freegridBox", "freegrid"].includes(node.type);
+      return container;
+    },
+    reverse: true // Go upwards in the document tree
+  })].filter(([node, nodePath]) => nodePath.length <= path.length);
+  return containers;
+};
+export const handleContainers = (editor, boxPath, extraHeight) => {
+  const containers = getAncestorFreeGridContainers(editor, boxPath);
+  let lastChildStartRow;
+  let lastChildEndRow;
+  let lastChildPath;
+  const containerData = [];
+  for (let i = containers.length - 1; i >= 0; i--) {
+    const container = containers[i];
+    const childContainer = containers[i + 1];
+    const [containerNode, containerPath] = container;
+    const {
+      gridArea_xs,
+      height_xs,
+      marginTop_xs
+    } = containerNode;
+    const [startRow] = gridArea_xs ? getGridArea(gridArea_xs) : [0]; // there is no grid area for section nodes
+
+    let newHeight = Number(height_xs) + extraHeight;
+    let fullHeight = newHeight + Number(marginTop_xs); // to find end row
+
+    if (!childContainer) {
+      const endRow = startRow + Math.floor(fullHeight / ROW_HEIGHT) + 1;
+      containerData.push({
+        moveRows: 0,
+        extraHeight,
+        containerPath,
+        newHeight,
+        containerNode,
+        lastChildStartRow
+      });
+      lastChildStartRow = startRow;
+      lastChildEndRow = endRow;
+    } else {
+      const lastChildIndex = lastChildPath[containerPath.length];
+      const firstOverlappedRow = findFirstRowOverlap(containerNode?.children, lastChildStartRow, lastChildEndRow, lastChildIndex);
+      const moveRows = firstOverlappedRow ? lastChildEndRow - firstOverlappedRow : 0;
+      newHeight = newHeight + moveRows * ROW_HEIGHT;
+      fullHeight = newHeight + Number(marginTop_xs);
+      const newEndRow = startRow + Math.floor(fullHeight / ROW_HEIGHT) + 1;
+      containerData.push({
+        moveRows,
+        extraHeight,
+        childIndex: lastChildIndex,
+        newHeight,
+        containerPath,
+        containerNode,
+        lastChildStartRow
+      });
+      lastChildStartRow = startRow;
+      lastChildEndRow = newEndRow;
+    }
+    lastChildPath = containerPath;
+  }
+  return containerData;
+};
+export const moveOverlappedItems = (editor, moveRows, containerItems, containerPath, childIndex, lastChildStartRow) => {
+  containerItems?.forEach((gridItem, index) => {
+    const isChildEle = childIndex === index;
+    if (isChildEle) {
+      return;
+    }
+    if (gridItem.type === "paragraph") {
+      return;
+    }
+    const {
+      gridArea_xs: gridArea,
+      width_xs
+    } = gridItem;
+    const [itemStartRow] = getGridArea(gridArea);
+    if (isBulletOrTickIcon(width_xs, itemStartRow, lastChildStartRow)) {
+      return;
+    }
+    if (itemStartRow >= lastChildStartRow) {
+      const row = itemStartRow + moveRows;
+      const newGridArea = `${row} / 1 / ${row + 1} / 2`;
+      const currentElementPath = [...containerPath, index];
+      Transforms.setNodes(editor, {
+        gridArea_xs: newGridArea
+      }, {
+        at: currentElementPath
+      });
+    }
+  });
+};
+export const handleBoxAlignment = (editor, sectionNode, sectionPath) => {
+  const [boxNode, boxPath] = getBoxToAutoAlign(editor, sectionPath);
+  Transforms.setNodes(editor, {
+    autoAlign: false
+  }, {
+    at: boxPath
+  });
+  if (!boxNode) {
+    return;
+  }
+  const containerItems = boxNode?.children || [];
+  const {
+    containerHeight
+  } = alignNewElementInContainer(editor, boxPath, containerItems);
+  const bufferHeight = 12;
+  const newHeight = containerHeight + bufferHeight;
+  const {
+    height_xs
+  } = boxNode;
+  const oldHeight = Number(height_xs);
+  const extraHeight = newHeight - oldHeight;
+  if (extraHeight > 0) {
+    const containerData = handleContainers(editor, boxPath, extraHeight);
+    containerData.forEach(container => {
+      const {
+        moveRows,
+        containerNode,
+        containerPath,
+        newHeight,
+        childIndex,
+        lastChildStartRow
+      } = container;
+      if (moveRows) {
+        moveOverlappedItems(editor, moveRows, containerNode?.children, containerPath, childIndex, lastChildStartRow);
+      }
+      Transforms.setNodes(editor, {
+        height_xs: newHeight,
+        xs_updatedOn: new Date().getTime()
+      }, {
+        at: containerPath
+      });
+    });
+  }
+};
+export const getMarginTop = y => {
+  const calcMargin = y % ROW_HEIGHT;
+  return calcMargin <= 0 ? 0 : calcMargin;
+};
+export const calculateProps = (curPath, dom, domClass, allData, parentDom, isBoxHeader) => {
+  const rect = dom?.getBoundingClientRect();
+  const bufferHeight = parentDom ? 0 : 12;
+  const sectionProps = {
+    path: curPath,
+    props: {
+      height: rect?.height + bufferHeight
+    }
+  };
+  const itemsData = [];
+  const items = dom.querySelectorAll(domClass);
+  const nextItemPathLength = curPath?.split("|").length + 2;
+  let sectionHeight = 12;
+  for (let i = 0; i < items.length; i++) {
+    const itemRect = items[i]?.getBoundingClientRect();
+    if (items[i]?.classList.contains("type_box")) {
+      allData = calculateProps(items[i]?.dataset.path, items[i], `.freegrid-item.path-${nextItemPathLength}`, allData, dom);
+    } else {
+      const y = Math.abs(rect.top - itemRect?.top);
+      const left = Math.abs(rect.left - itemRect?.left);
+      const isAppHeader = isBoxHeader || dom?.classList?.contains("appHeaderBox");
+      itemsData.push({
+        path: items[i]?.dataset.path,
+        props: {
+          top: y,
+          left: isAppHeader ? left : 24,
+          marginTop: getMarginTop(y),
+          width: itemRect?.width,
+          height: itemRect?.height,
+          gridArea: calculateGridArea(y)
+        }
+      });
+      sectionHeight += itemRect?.height;
+    }
+  }
+  if (dom?.classList.contains("type_box") && parentDom) {
+    const parentDomRect = parentDom?.getBoundingClientRect();
+    const isAppHeader = isBoxHeader || dom?.classList.contains("appHeaderBox");
+    const y = Math.abs(parentDomRect.top - rect?.top);
+    sectionProps.props.gridArea = calculateGridArea(y);
+    sectionProps.props.left = isAppHeader ? 6 : 24;
+    sectionProps.props.marginTop = getMarginTop(y);
+    sectionProps.props.width = rect?.width;
+  }
+  allData = [sectionProps, [...allData, ...itemsData]]?.flat();
+  return allData;
+};
+export const sortElements = (items, container) => {
+  const elementsArray = Array.from(items);
+  elementsArray.sort((a, b) => {
+    const aGridArea = a.dataset.gridAreaXs;
+    const bGridArea = b.dataset.gridAreaXs;
+
+    // If either element has no gridArea, push it to the end
+    if (!aGridArea) return 1;
+    if (!bGridArea) return -1;
+    const [aRow] = aGridArea.split("/").map(Number);
+    const [bRow] = bGridArea.split("/").map(Number);
+    if (aRow !== bRow) {
+      return aRow - bRow; // Sort by start row first
+    }
+
+    // Compare marginTopXs
+    const aMarginTop = parseFloat(a.dataset.marginTopXs) || 0;
+    const bMarginTop = parseFloat(b.dataset.marginTopXs) || 0;
+    const BUFFER_DIFF = 5;
+    if (Math.abs(aMarginTop - bMarginTop) > BUFFER_DIFF) {
+      return aMarginTop - bMarginTop;
+    }
+    const aLeft = parseFloat(a.dataset.leftXs) || 0;
+    const bLeft = parseFloat(b.dataset.leftXs) || 0;
+    return aLeft - bLeft;
+  });
+
+  // Append sorted elements to container
+  elementsArray.forEach(item => {
+    container.appendChild(item);
+
+    // If item is a box, recursively sort its children
+    if (item.classList.contains("type_box")) {
+      const nestedContainer = item.querySelector(":scope > .fgi_type_box");
+      const isAppHeader = item.querySelector(".type_appHeader");
+      if (isAppHeader) {
+        item.classList.add("appHeaderBox");
+      }
+      if (nestedContainer) {
+        const childToRemove = nestedContainer.querySelector(":scope > .simple-text");
+        if (childToRemove) {
+          nestedContainer.removeChild(childToRemove);
+        }
+        const children = nestedContainer.children;
+        sortElements(children, nestedContainer);
+        item.appendChild(nestedContainer);
+      }
+    }
+  });
+};