@flozy/editor 11.0.7 → 11.0.9

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

@@ -1,5 +1,9 @@
 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;
 };
@@ -39,106 +43,83 @@ export const getGridArea = gridArea => {
 const getBoxToAutoAlign = (editor, sectionPath) => {
   const [boxData] = Editor.nodes(editor, {
     at: sectionPath,
-    match: node => node.type === "freegridBox" && node.autoAlign
+    match: node => ["freegridBox", "freegrid"].includes(node.type) && 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 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 getAncestorFreeGridContainers = (editor, path) => {
   const containers = [...Editor.nodes(editor, {
     at: path,
@@ -151,6 +132,37 @@ 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;
@@ -212,7 +224,7 @@ export const moveOverlappedItems = (editor, moveRows, containerItems, containerP
     if (isChildEle) {
       return;
     }
-    if (gridItem.type === "paragraph") {
+    if (!RND_ITEMS.includes(gridItem.type)) {
       return;
     }
     const {
@@ -235,7 +247,196 @@ export const moveOverlappedItems = (editor, moveRows, containerItems, containerP
     }
   });
 };
-export const handleBoxAlignment = (editor, sectionNode, sectionPath) => {
+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) => {
   const [boxNode, boxPath] = getBoxToAutoAlign(editor, sectionPath);
   Transforms.setNodes(editor, {
     autoAlign: false
@@ -245,39 +446,11 @@ export const handleBoxAlignment = (editor, sectionNode, sectionPath) => {
   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
-      });
-    });
+  if (heightDiff <= 0) {
+    return;
   }
+  let containers = getAncestorFreeGridContainers(editor, boxPath);
+  handleContainersAlignment(editor, containers, heightDiff, 12);
 };
 export const getMarginTop = y => {
   const calcMargin = y % ROW_HEIGHT;
@@ -380,4 +553,21 @@ 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,6 +18,17 @@ const useVirtualElementStyles = () => ({
     "& .editor-blocker": {
       display: "none"
     },
+    "& .fgi_type_text": {
+      "& .edt-headings": {
+        margin: "0px"
+      },
+      "& .edt-paragraphs": {
+        margin: "0px"
+      },
+      "& blockquote": {
+        margin: "0px !important"
+      }
+    },
     "& .freegrid-item": {
       position: "relative !important",
       top: "0 !important",
@@ -97,6 +108,17 @@ export const useAutoAlignStyles = () => ({
       "&.type_text": {
         height: "auto !important"
       },
+      "& .fgi_type_text": {
+        "& .edt-headings": {
+          margin: "0px"
+        },
+        "& .edt-paragraphs": {
+          margin: "0px"
+        },
+        "& blockquote": {
+          margin: "0px !important"
+        }
+      },
       // start - default signature classes on free-grid
       "& .fgi_type_signature": {
         height: "100%",

package/dist/Editor/common/RnD/index.js

@@ -12,7 +12,7 @@ import GuideLines from "./GuideLines";
 import ShadowElement from "./ShadowElement";
 import BoundaryLine from "./GuideLines/BoundaryLine";
 import ContextMenu from "./ContextMenu";
-import VirtualElement from "./VirtualElement";
+// import VirtualElement from "./VirtualElement";
 import { ItemTypes } from "./ElementSettings/settingsConstants";
 import { selectText } from "../../utils/helper";
 import { removeSign } from "./ElementSettings/OtherSettings";
@@ -20,7 +20,7 @@ import useDragging from "../../hooks/useDragging";
 import { dragOverOn } from "../../helper/RnD/focusNode";
 import { focusSelection, clearSelection, clearSelectionOnly } from "../../helper";
 // import { reRenderChildNodes } from "./Utils/gridDropItem";
-import VirtualTextElement from "./VirtualElement/VirtualTextElement";
+import VirtualTextElement, { updateTextHeight } from "./VirtualElement/VirtualTextElement";
 import useAutoScroll from "../../hooks/useAutoScroll";
 import ForceAutoAlignment from "./VirtualElement/ForceAutoAlignment";
 import BoxHeaderAutoAlignment from "./VirtualElement/BoxHeaderAutoAlignment";
@@ -29,6 +29,38 @@ import { useFreeGrid } from "../../Elements/FreeGrid/FreeGrid";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment as _Fragment } from "react/jsx-runtime";
+function getTextElementHeight(textElement) {
+  let totalHeight = 0;
+  if (textElement) {
+    const {
+      childNodes
+    } = textElement || {};
+    for (let i = childNodes.length - 1; i >= 0; i--) {
+      const el = childNodes[i];
+      const text = el.textContent?.replace(/\n/g, "")?.trim();
+      if (text || totalHeight) {
+        // remove last empty spaces
+        totalHeight += el.offsetHeight || el.getBoundingClientRect().height;
+      }
+    }
+  }
+  return totalHeight;
+}
+function textAutoAlign(editor, path, getCurrentEle, delta, breakpoint, onLoad) {
+  const currElement = getCurrentEle();
+  const textElement = currElement?.querySelector(".fgi_type_text");
+  const clientHeight = getTextElementHeight(textElement);
+  const {
+    height
+  } = delta || {};
+  const heightDiff = Math.abs(clientHeight - height);
+  const autoAlign = onLoad ? clientHeight > height : heightDiff >= 5;
+  if (clientHeight && height && autoAlign) {
+    updateTextHeight(editor, path, clientHeight, breakpoint);
+    const parentSectionPath = path.slice(0, 2);
+    reRenderChildNodes(editor, parentSectionPath);
+  }
+}
 const ITEM_TYPES = ["child", "parent-container"];
 const EDIT_MODES = ["text", "form", "table"];
 const DISABLE_RESIZING = {
@@ -78,7 +110,8 @@ const RnD = props => {
     setAutoAlign,
     isBoxHeader,
     customProps,
-    xsHidden
+    xsHidden,
+    disableClick = false
   } = props;
   const {
     isSelectedElement,
@@ -132,6 +165,8 @@ const RnD = props => {
   const {
     translation
   } = customProps;
+  const timerId = useRef(0);
+  const isFirstRender = useRef(true);
   useEffect(() => {
     if (ITEM_TYPES.includes(type)) {
       if (enable === 1) {
@@ -141,6 +176,19 @@ const RnD = props => {
         setAbsPosition({});
       }
     }
+    if (childType === "text" && !enable && !readOnly) {
+      if (isFirstRender.current) {
+        isFirstRender.current = false;
+        timerId.current = setTimeout(() => {
+          // auto align on load
+          textAutoAlign(editor, path, getCurrentEle, delta, breakpoint, true);
+        }, 200);
+      } else {
+        // auto align when the text is changed
+        textAutoAlign(editor, path, getCurrentEle, delta, breakpoint);
+      }
+    }
+    return () => clearTimeout(timerId?.current);
   }, [enable]);
   const getCurrentEle = () => {
     return positionRef.current?.resizableElement?.current;
@@ -500,7 +548,9 @@ const RnD = props => {
       ref
     }, ".freegrid-container-parent");
     const formatParentPath = parentPath?.split("|")?.map(m => parseInt(m));
-    reRenderChildNodes(editor, formatParentPath);
+    if (formatParentPath) {
+      reRenderChildNodes(editor, formatParentPath);
+    }
   };
   const onCloseSettings = () => {
     setSelectedElement({
@@ -631,7 +681,10 @@ const RnD = props => {
         "data-path": path,
         contentEditable: false,
         "data-dragoverid": str_path,
-        "data-dragovertype": type
+        "data-dragovertype": type,
+        style: {
+          pointerEvents: disableClick && "none"
+        }
       }) : null]
     }, eId), xsHidden && breakpoint === "xs" ? null : /*#__PURE__*/_jsxs(_Fragment, {
       children: [/*#__PURE__*/_jsx(ElementSettings, {
@@ -684,18 +737,12 @@ const RnD = props => {
       handleClose: handleClose,
       theme: theme,
       translation: translation
-    }), type === "parent" && breakpoint === "lg" && !readOnly ? /*#__PURE__*/_jsx(VirtualElement, {
-      updated_at: updated_at,
-      path: str_path,
-      editor: editor,
-      sectionElement: sectionElement,
-      sectionCls: `.freegrid-section_${path.join("_")}`,
-      dataSets: dataSets
-    }) : null, childType === "text" && breakpoint === "lg" && !readOnly && enable ? /*#__PURE__*/_jsx(VirtualTextElement, {
+    }), childType === "text" && !readOnly && enable ? /*#__PURE__*/_jsx(VirtualTextElement, {
       editor: editor,
       dataSets: dataSets,
       getCurrentEle: getCurrentEle,
-      path: path
+      path: path,
+      breakpoint: breakpoint === "xs" ? "lg" : "xs" // auto-align for this passed breakpoint
     }) : null, type === "parent" && breakpoint === "xs" && !readOnly && autoAlign ? /*#__PURE__*/_jsx(ForceAutoAlignment, {
       updated_at: updated_at,
       path: str_path,