@flozy/editor 10.3.8 → 10.4.0

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

@@ -1,45 +1,69 @@
 import { useEffect, useRef } from "react";
+import { Path, Transforms } from "slate";
 import { getNode } from "../../../utils/helper";
 import { ROW_HEIGHT } from "../Utils/gridDropItem";
-import { getGridArea, getNodeValues, handleTextAlignment } from "./helper";
+import { findFirstRowOverlap, getGridArea, handleContainers, moveOverlappedItems } from "./helper";
 import { Box } from "@mui/material";
 import { jsx as _jsx } from "react/jsx-runtime";
-export const getElementOffset = (element, breakpoint) => {
-  const {
-    height,
-    gridArea,
-    marginTop
-  } = getNodeValues(element, breakpoint);
-  const [startRow] = getGridArea(gridArea);
-  const top = (startRow - 1) * ROW_HEIGHT + marginTop;
-  const bottom = top + height;
-  return {
-    top,
-    bottom
-  };
-};
-export const updateTextHeight = (editor, path, currHeight, updateBreakpoint) => {
-  if (!currHeight) {
+const updateTextHeight = (editor, path, height) => {
+  if (!height) {
     return;
   }
-  const textItem = getNode(editor, path);
-  if (!textItem) {
+  const parentPath = Path.parent(path);
+  const currentNode = getNode(editor, parentPath);
+  const gridItems = currentNode?.children || [];
+  const isNewlyAddedElement = gridItems.some(gridItem => !gridItem.gridArea_xs && gridItem.type !== "paragraph");
+  if (isNewlyAddedElement) {
     return;
   }
+  const textItemIndex = path[parentPath.length];
+  const textItem = gridItems.find((_, index) => textItemIndex === index);
   const {
-    height,
-    gridArea,
-    type
-  } = getNodeValues(textItem, updateBreakpoint);
-  if (!gridArea && type !== "paragraph") {
-    return;
-  }
-  const oldHeight = height;
-  const newHeight = currHeight;
-  const heightDiff = newHeight - oldHeight;
-  if (heightDiff !== 0) {
-    const textNode = [textItem, path];
-    handleTextAlignment(editor, textNode, heightDiff, updateBreakpoint);
+    marginTop_xs: marginTop,
+    gridArea_xs: gridArea,
+    height_xs
+  } = textItem;
+  const oldHeight = height_xs + marginTop;
+  const newHeight = height + marginTop;
+  const extraHeight = newHeight - oldHeight;
+  let containerExtraHeight = extraHeight;
+  if (extraHeight > 0) {
+    const [startRow] = getGridArea(gridArea);
+    const newRows = Math.floor(newHeight / ROW_HEIGHT) + 1;
+    const endRow = startRow + newRows;
+    const firstOverlappedRow = findFirstRowOverlap(gridItems, startRow, endRow, textItemIndex);
+    if (firstOverlappedRow) {
+      const moveRows = endRow - firstOverlappedRow;
+      moveOverlappedItems(editor, moveRows, gridItems, parentPath, textItemIndex, startRow);
+      containerExtraHeight += moveRows * ROW_HEIGHT;
+    }
+
+    // handle containers (box and section)
+    const containerData = handleContainers(editor, parentPath, containerExtraHeight);
+    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
+      });
+    });
+    Transforms.setNodes(editor, {
+      height_xs: height
+    }, {
+      at: path
+    });
   }
 };
 function VirtualTextElement(props) {
@@ -59,9 +83,9 @@ function VirtualTextElement(props) {
           height
         } = entry.contentRect;
         const currentText = currElement?.innerText;
-        const prevText = prevTextRef?.current;
+        const prevText = prevTextRef.current;
         if (currentText && currentText !== prevText) {
-          updateTextHeight(editor, path, height, "xs");
+          updateTextHeight(editor, path, height);
         }
         prevTextRef.current = currentText;
       }
@@ -98,14 +122,6 @@ function VirtualTextElement(props) {
       },
       "& .editor-blocker": {
         display: "none"
-      },
-      "& .fgi_type_text": {
-        "& .edt-headings": {
-          margin: "0px"
-        },
-        "& .edt-paragraphs": {
-          margin: "0px"
-        }
       }
     },
     dangerouslySetInnerHTML: {

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

@@ -1,9 +1,5 @@
 import { ROW_HEIGHT, calculateGridArea } from "../Utils/gridDropItem";
 import { Transforms, Editor } from "slate";
-import { getElementOffset } from "./VirtualTextElement";
-import { getNode } from "../../../utils/helper";
-import { findMaxYValue } from "../../../Elements/FreeGrid/helper";
-import { RND_ITEMS } from "../../../helper";
 const isBulletOrTickIcon = (width, itemStartRow, startRow) => {
   return width <= 40 && itemStartRow === startRow;
 };
@@ -43,83 +39,106 @@ export const getGridArea = gridArea => {
 const getBoxToAutoAlign = (editor, sectionPath) => {
   const [boxData] = Editor.nodes(editor, {
     at: sectionPath,
-    match: node => ["freegridBox", "freegrid"].includes(node.type) && node.autoAlign
+    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;
 
-// 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,
-//   };
-// };
-
+  //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,
@@ -132,37 +151,6 @@ const getAncestorFreeGridContainers = (editor, path) => {
   })].filter(([node, nodePath]) => nodePath.length <= path.length);
   return containers;
 };
-export const handleTextAlignment = (editor, textNode, heightDiff, updateBreakpoint) => {
-  const [textEle, textPath] = textNode;
-  let containers = getAncestorFreeGridContainers(editor, textPath);
-  for (let i = containers.length - 1; i >= 0; i--) {
-    const container = containers[i];
-    const childContainer = containers[i + 1];
-    if (!heightDiff) {
-      break;
-    }
-
-    // get the data of elements to align inside container
-    const alignElements = alignElementsInsideContainer(container, childContainer || textNode, heightDiff, updateBreakpoint);
-    if (!childContainer) {
-      const {
-        height
-      } = getNodeValues(textEle, updateBreakpoint);
-      const appendBp = updateBreakpoint === "lg" ? "" : "_xs";
-
-      // update the height of the current text element, before updating the container
-      Transforms.setNodes(editor, {
-        [`height${appendBp}`]: height + heightDiff
-      }, {
-        at: textPath
-      });
-    }
-    const containerHeightDiff = updateContainer(editor, alignElements, container, updateBreakpoint, heightDiff);
-
-    // if container height incresed/decresed, need to auto align the parent container based on height differed
-    heightDiff = containerHeightDiff;
-  }
-};
 export const handleContainers = (editor, boxPath, extraHeight) => {
   const containers = getAncestorFreeGridContainers(editor, boxPath);
   let lastChildStartRow;
@@ -224,7 +212,7 @@ export const moveOverlappedItems = (editor, moveRows, containerItems, containerP
     if (isChildEle) {
       return;
     }
-    if (!RND_ITEMS.includes(gridItem.type)) {
+    if (gridItem.type === "paragraph") {
       return;
     }
     const {
@@ -247,196 +235,7 @@ export const moveOverlappedItems = (editor, moveRows, containerItems, containerP
     }
   });
 };
-export const causeOverlap = (container, currElementPath, updateBreakpoint, newTopPosition, firstNextElement) => {
-  const [containerNode, containerPath] = container;
-  let isOverlapped = false;
-  containerNode.children.forEach((item, index) => {
-    if (!RND_ITEMS.includes(item.type)) {
-      return;
-    }
-    const currPath = [...containerPath, index];
-    if (currPath.toString() === currElementPath.toString()) {
-      return;
-    }
-    const {
-      top,
-      bottom
-    } = getElementOffset(item, updateBreakpoint);
-    if (firstNextElement === top) {
-      return;
-    }
-    if (newTopPosition > top && newTopPosition <= bottom) {
-      isOverlapped = true;
-    }
-  });
-  return isOverlapped;
-};
-export const alignElementsInsideContainer = (container, currentElement, heightDiff, updateBreakpoint) => {
-  const [containerNode, containerPath] = container;
-  const [currentElementNode, currElementPath] = currentElement || [];
-  const {
-    bottom: currElementBottom
-  } = getElementOffset(currentElementNode, updateBreakpoint);
-  const newCurrElementBottom = currElementBottom + heightDiff;
-  const bufferSpace = 12;
-  const nextElements = []; // Elements after the current element
-  let firstNextElement = 0; // first element position which is after the current element
-
-  const alignElements = {};
-
-  // find the elements present after the current element
-  containerNode.children.forEach((item, index) => {
-    if (!RND_ITEMS.includes(item.type)) {
-      return;
-    }
-    const currPath = [...containerPath, index];
-    const {
-      top: itemTop
-    } = getElementOffset(item, updateBreakpoint);
-    if (currPath.toString() === currElementPath.toString()) {
-      return;
-    }
-    const bufferPosition = 15;
-    if (itemTop + bufferPosition >= currElementBottom) {
-      const element = {
-        path: currPath,
-        node: item
-      };
-      nextElements.push(element);
-      firstNextElement = firstNextElement > 0 ? Math.min(firstNextElement, itemTop) : itemTop;
-    }
-  });
-
-  // check whether the new height is overlapping the next element
-  const isOverlapped = firstNextElement && newCurrElementBottom >= firstNextElement;
-  let moveElements = isOverlapped || heightDiff < 0; // if heightDiff is negative, move elements up
-
-  if (heightDiff < 0) {
-    // does flex elements cause overlap
-    const isCausingOverlap = causeOverlap(container, currElementPath, updateBreakpoint, firstNextElement + heightDiff, firstNextElement);
-    moveElements = !isCausingOverlap;
-  }
-  if (moveElements) {
-    const topPos = newCurrElementBottom - firstNextElement + bufferSpace; // position the element after the current element
-    alignElements.topPos = heightDiff < 0 ? heightDiff : topPos;
-    alignElements.nextElements = nextElements;
-    alignElements.moveElements = moveElements;
-  }
-  return alignElements;
-};
-export const updateContainer = (editor, alignElements, container, updateBreakpoint, heightDiff) => {
-  const [containerNode, containerPath] = container;
-  const {
-    moveElements,
-    topPos,
-    nextElements
-  } = alignElements || {};
-  const appendBp = updateBreakpoint === "lg" ? "" : "_xs";
-
-  // update the aligned data inside container
-  if (moveElements && topPos !== 0) {
-    nextElements.forEach(ele => {
-      const {
-        path,
-        node
-      } = ele;
-      const {
-        top
-      } = getElementOffset(node, updateBreakpoint);
-      const y = top + topPos;
-
-      // Calculate grid position
-      const row = Math.floor(y / ROW_HEIGHT) + 1;
-
-      // to calculate difference inside the grid
-      const marginTop = Math.abs((row - 1) * ROW_HEIGHT - y);
-
-      // Update grid area
-      const gridArea = `${row} / 1 / ${row + 1} / 2`;
-      Transforms.setNodes(editor, {
-        [`gridArea${appendBp}`]: gridArea,
-        [`marginTop${appendBp}`]: marginTop
-      }, {
-        at: path
-      });
-    });
-  }
-
-  // update the new height of the container
-  const newContainerNode = getNode(editor, containerPath);
-  const newHeight = findMaxYValue(newContainerNode?.children, updateBreakpoint) + 12;
-  const {
-    height: containerOldHeight
-  } = getNodeValues(containerNode, updateBreakpoint);
-  let currHeightDiff = newHeight - containerOldHeight;
-  const noUpdate = currHeightDiff < 0 && heightDiff > 0; // if current text height is increased, but container height is getting reduced, we don't want to reduce the height of the container
-  if (noUpdate) {
-    currHeightDiff = 0;
-  } else {
-    Transforms.setNodes(editor, {
-      [`height${appendBp}`]: newHeight + 12
-    }, {
-      at: containerPath
-    });
-    currHeightDiff += 12;
-  }
-  return currHeightDiff;
-};
-export const handleContainersAlignment = (editor, containers, heightDiff, bufferSpace = 0) => {
-  for (let i = containers.length - 1; i >= 0; i--) {
-    const container = containers[i];
-    const childContainer = containers[i + 1];
-    const [containerNode, containerPath] = container;
-    const [childContainerNode, childContainerPath] = childContainer || [];
-    if (childContainer) {
-      const {
-        bottom
-      } = getElementOffset(childContainerNode);
-      containerNode.children.forEach((item, index) => {
-        const currPath = [...containerPath, index];
-        if (currPath.toString() === childContainerPath.toString()) {
-          return;
-        }
-        if (!RND_ITEMS.includes(item.type)) {
-          return;
-        }
-        const {
-          top: itemTop
-        } = getElementOffset(item);
-        if (itemTop >= bottom) {
-          const {
-            gridArea_xs,
-            marginTop_xs
-          } = item;
-          const [startRow] = getGridArea(gridArea_xs);
-          const y = (startRow - 1) * ROW_HEIGHT + marginTop_xs + heightDiff;
-
-          // Calculate grid position
-          const row = Math.floor(y / ROW_HEIGHT) + 1;
-
-          // to calculate difference inside the grid
-          const marginTop = Math.abs((row - 1) * ROW_HEIGHT - y);
-
-          // Update grid area
-          const gridArea = `${row} / 1 / ${row + 1} / 2`;
-          Transforms.setNodes(editor, {
-            gridArea_xs: gridArea,
-            marginTop_xs: marginTop + bufferSpace
-          }, {
-            at: currPath
-          });
-        }
-      });
-    }
-    Transforms.setNodes(editor, {
-      height_xs: containerNode?.height_xs + heightDiff + bufferSpace,
-      xs_updatedOn: new Date().getTime()
-    }, {
-      at: containerPath
-    });
-  }
-};
-export const handleBoxAlignment = (editor, sectionPath, heightDiff) => {
+export const handleBoxAlignment = (editor, sectionNode, sectionPath) => {
   const [boxNode, boxPath] = getBoxToAutoAlign(editor, sectionPath);
   Transforms.setNodes(editor, {
     autoAlign: false
@@ -446,11 +245,39 @@ export const handleBoxAlignment = (editor, sectionPath, heightDiff) => {
   if (!boxNode) {
     return;
   }
-  if (heightDiff <= 0) {
-    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
+      });
+    });
   }
-  let containers = getAncestorFreeGridContainers(editor, boxPath);
-  handleContainersAlignment(editor, containers, heightDiff, 12);
 };
 export const getMarginTop = y => {
   const calcMargin = y % ROW_HEIGHT;
@@ -468,7 +295,7 @@ export const calculateProps = (curPath, dom, domClass, allData, parentDom, isBox
   const itemsData = [];
   const items = dom.querySelectorAll(domClass);
   const nextItemPathLength = curPath?.split("|").length + 2;
-  // let sectionHeight = 12;
+  let sectionHeight = 12;
   for (let i = 0; i < items.length; i++) {
     const itemRect = items[i]?.getBoundingClientRect();
     if (items[i]?.classList.contains("type_box")) {
@@ -488,10 +315,9 @@ export const calculateProps = (curPath, dom, domClass, allData, parentDom, isBox
           gridArea: calculateGridArea(y)
         }
       });
-      // sectionHeight += itemRect?.height;
+      sectionHeight += itemRect?.height;
     }
   }
-
   if (dom?.classList.contains("type_box") && parentDom) {
     const parentDomRect = parentDom?.getBoundingClientRect();
     const isAppHeader = isBoxHeader || dom?.classList.contains("appHeaderBox");
@@ -553,21 +379,4 @@ export const sortElements = (items, container) => {
       }
     }
   });
-};
-const nodeKeys = ["height", "width", "gridArea", "marginTop", "left"];
-export const getNodeValues = (node, breakpoint = "xs") => {
-  // defaulty return xs breakpoint values, if breakpoint is not given
-  const appendBp = breakpoint === "lg" ? "" : "_xs";
-  const nodeVals = nodeKeys.reduce((a, b) => {
-    const key = b + appendBp;
-    a[b] = node[key];
-    if (b === "height" && !a[b]) {
-      a[b] = node.height;
-    }
-    return a;
-  }, {});
-  return {
-    ...node,
-    ...nodeVals
-  };
 };

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

@@ -18,14 +18,6 @@ const useVirtualElementStyles = () => ({
     "& .editor-blocker": {
       display: "none"
     },
-    "& .fgi_type_text": {
-      "& .edt-headings": {
-        margin: "0px"
-      },
-      "& .edt-paragraphs": {
-        margin: "0px"
-      }
-    },
     "& .freegrid-item": {
       position: "relative !important",
       top: "0 !important",
@@ -105,14 +97,6 @@ export const useAutoAlignStyles = () => ({
       "&.type_text": {
         height: "auto !important"
       },
-      "& .fgi_type_text": {
-        "& .edt-headings": {
-          margin: "0px"
-        },
-        "& .edt-paragraphs": {
-          margin: "0px"
-        }
-      },
       // start - default signature classes on free-grid
       "& .fgi_type_signature": {
         height: "100%",