@flozy/editor 9.5.6 → 9.5.8

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

@@ -1,152 +1,235 @@
-import React, { useEffect, useRef } from "react";
+import React, { useEffect, useMemo, useRef, useState } from "react";
 import { Box } from "@mui/material";
 import useVirtualElementStyles from "./styles";
 import updateAutoProps from "./updateAutoProps";
-import { calculateGridArea } from "../Utils/gridDropItem";
+import { ROW_HEIGHT, calculateGridArea } from "../Utils/gridDropItem";
 import { jsx as _jsx } from "react/jsx-runtime";
 const ROOT_ITEM_CLASS = ".freegrid-item.path-3";
+export function getStartRow(el) {
+  const gridArea = el.dataset.gridAreaXs;
+  if (gridArea) {
+    const [startRow] = gridArea.split("/").map(num => parseInt(num));
+    return startRow;
+  }
+}
+function appendGridOccupied(domItem, startRow, fullHeight, lastRow) {
+  const endRow = startRow + Math.floor(fullHeight / ROW_HEIGHT) + 1;
+  lastRow = Math.max(endRow, lastRow);
+  const gridArea = `${startRow}/1/${endRow}/2`;
+  domItem.style.setProperty("--gridArea_xs", gridArea);
+  domItem.dataset.gridAreaXs = gridArea;
+  domItem.classList.add("exclude-virtual");
+  return {
+    domItem,
+    updatedLastRow: lastRow,
+    gridArea
+  };
+}
 
 // Function to group items by path and calculate heights
-function groupByPathAndCalculateHeight(data) {
-  const root = {};
-  const heightData = {};
-
-  // Step 1: Group items based on their path
-  data.forEach(item => {
-    const segments = item.path.split("|");
-    let current = root;
-    segments.forEach((segment, index) => {
-      if (!current[segment]) {
-        current[segment] = {
-          children: {},
-          props: {
-            height: 0
-          }
-        };
-      }
-      if (index === segments.length - 1) {
-        // Assign the properties of the item including height
-        current[segment] = {
-          ...item,
-          children: current[segment].children
-        };
-      }
-      current = current[segment].children;
-    });
-  });
+// function groupByPathAndCalculateHeight(allData) {
+//   const data = JSON.parse(JSON.stringify([...allData]));
+//   const root = {};
+//   const heightData = {};
 
-  // Step 2: Recursively calculate the height of each parent based on children
-  const calculateHeight = node => {
-    if (!node.children || Object.keys(node.children).length === 0) {
-      // Base case: If there are no children, return the node's height
-      return node.props.height;
-    }
+//   // Step 1: Group items based on their path
+//   data.forEach((item) => {
+//     const segments = item.path.split("|");
+//     let current = root;
 
-    // Calculate the height by summing the heights of all children
-    let totalHeight = 0;
-    Object.values(node.children).forEach(child => {
-      totalHeight += calculateHeight(child);
-    });
+//     segments.forEach((segment, index) => {
+//       if (!current[segment]) {
+//         current[segment] = { children: {}, props: { height: 0 } };
+//       }
 
-    // Update the parent's height to be the total height of its children
-    node.props.height = totalHeight;
-    if (node?.path) {
-      heightData[node.path] = totalHeight;
-    }
-    return totalHeight;
-  };
+//       if (index === segments.length - 1) {
+//         // Assign the properties of the item including height
+//         current[segment] = { ...item, children: current[segment].children };
+//       }
 
-  // Start calculation from the root
-  Object.values(root).forEach(node => calculateHeight(node));
+//       current = current[segment].children;
+//     });
+//   });
+
+//   // Step 2: Recursively calculate the height of each parent based on children
+//   const calculateHeight = (node) => {
+//     if (!node.children || Object.keys(node.children).length === 0) {
+//       // Base case: If there are no children, return the node's height
+//       return node.props.height;
+//     }
+
+//     // Calculate the height by summing the heights of all children
+//     let totalHeight = 0;
+//     Object.values(node.children).forEach((child) => {
+//       totalHeight += calculateHeight(child);
+//     });
+
+//     // Update the parent's height to be the total height of its children
+//     node.props.height = totalHeight;
+//     if (node?.path) {
+//       heightData[node.path] = totalHeight;
+//     }
+//     return totalHeight;
+//   };
+
+//   // Start calculation from the root
+//   Object.values(root).forEach((node) => calculateHeight(node));
+
+//   return { root, heightData };
+// }
+
+const handleGridItem = (dom, lastRow) => {
+  const startRow = getStartRow(dom);
+  const {
+    marginTopXs,
+    heightXs
+  } = dom.dataset;
+  const marginTop = marginTopXs ? Number(marginTopXs) : 0;
+  const fullHeight = Number(heightXs) + marginTop;
+  return appendGridOccupied(dom, startRow, fullHeight, lastRow);
+};
+const handleNonGridItem = (dom, lastRow) => {
+  const rect = dom.getBoundingClientRect();
+  dom.style.setProperty("--height_xs", rect.height + "px"); // assign the auto height that taken
+  const startRow = lastRow || 1;
+  const DEFAULT_NEW_ELEMENT_MARGIN_TOP = 12;
+  let fullHeight = rect.height + DEFAULT_NEW_ELEMENT_MARGIN_TOP;
+  const gridOccupiedData = appendGridOccupied(dom, startRow, fullHeight, lastRow);
   return {
-    root,
-    heightData
+    ...gridOccupiedData,
+    fullHeight
   };
-}
+};
+const appendContainerItems = async (sectionCls, virtualRef, dataSets) => {
+  const cloneNode = document.querySelector(sectionCls)?.cloneNode(true);
+  const items = cloneNode?.querySelectorAll(ROOT_ITEM_CLASS) || [];
+  if (!cloneNode || !items?.length || !virtualRef.current) {
+    return;
+  }
+
+  // Remove all existing elements inside virtualRef.current
+  virtualRef.current.innerHTML = "";
+  virtualRef.current.style.height = `auto`;
+  virtualRef.current.style.gridTemplateRows = `unset`;
+
+  // temporary append section items to get the dom styles
+  virtualRef.current.append(...items);
+  let itemsHTML = "";
+  let lastRow = 0;
+  const gridItems = [];
+  const nonGridItems = [];
+  items.forEach(item => {
+    if (getStartRow(item)) {
+      gridItems.push(item);
+    } else {
+      nonGridItems.push(item);
+    }
+  });
+
+  // to find the previously occupied rows
+  gridItems.forEach(item => {
+    const {
+      updatedLastRow,
+      domItem
+    } = handleGridItem(item, lastRow);
+    lastRow = updatedLastRow;
+    itemsHTML += domItem.outerHTML;
+  });
+  let containerHeight = lastRow ? (lastRow - 1) * ROW_HEIGHT : 0;
+
+  //place it on the next rows that are available
+  nonGridItems.forEach(item => {
+    const {
+      domItem,
+      updatedLastRow,
+      fullHeight
+    } = handleNonGridItem(item, lastRow);
+    lastRow = updatedLastRow;
+    itemsHTML += domItem.outerHTML;
+    containerHeight += fullHeight;
+  });
+  const oldSectionHeight = dataSets["data-height-xs"];
+  const newHeight = oldSectionHeight && oldSectionHeight > containerHeight ? oldSectionHeight : containerHeight;
+  virtualRef.current.style.height = `${newHeight}px`;
+  virtualRef.current.style.gridTemplateRows = `repeat(${lastRow - 1}, ${ROW_HEIGHT}px)`;
+  virtualRef.current.innerHTML = itemsHTML;
+};
 const VirtualElement = props => {
   const classes = useVirtualElementStyles();
   const {
     editor,
     path,
-    parentEle,
-    updated_at
+    updated_at,
+    sectionCls,
+    dataSets
   } = props;
-  const cloneNode = parentEle?.cloneNode(true);
   const virtualRef = useRef();
+  const [toggleUpdate, setToggleUpdate] = useState(false);
   useEffect(() => {
     if (virtualRef?.current) {
-      const timeoutId = setTimeout(() => {
+      setTimeout(() => {
         const allData = calculateProps(path, virtualRef?.current, ROOT_ITEM_CLASS, []);
-        const groupData = groupByPathAndCalculateHeight(allData);
+        // const groupData = groupByPathAndCalculateHeight(allData);
+        // console.log("allData", allData);
         // it should trigger by auto alignment or on clicking mobile view change
-        updateAutoProps(editor, allData, "xs", groupData);
+        updateAutoProps(editor, allData, "xs");
       }, 100);
-      return () => clearTimeout(timeoutId);
+      setToggleUpdate(prev => !prev);
     }
   }, [updated_at, virtualRef?.current]);
   const calculateProps = (curPath, dom, domClass, allData) => {
     const rect = dom?.getBoundingClientRect();
-    const sectionRect = virtualRef?.current?.getBoundingClientRect();
+
+    // const sectionRect = virtualRef?.current?.getBoundingClientRect();
+
+    const bufferHeight = 12; // for spacing
+
     const sectionProps = {
       path: curPath,
       props: {
-        height: rect?.height
+        height: rect?.height + bufferHeight
       }
     };
     const itemsData = [];
-    const items = dom.querySelectorAll(domClass);
-    const nextItemPathLength = curPath?.split("|").length + 2;
-    let sectionHeight = 12;
+    const items = dom ? dom.querySelectorAll(domClass) : [];
     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);
-      } else {
-        const y = Math.abs(rect.top - itemRect?.top);
-        itemsData.push({
-          path: items[i]?.dataset.path,
-          props: {
-            top: y,
-            left: 24,
-            marginTop: 12,
-            width: itemRect?.width,
-            height: itemRect?.height,
-            gridArea: calculateGridArea(y)
-          }
-        });
-        sectionHeight += itemRect?.height;
-      }
-    }
-    if (dom?.classList.contains("type_box")) {
-      const y = Math.abs(sectionRect.top - rect?.top);
-      sectionProps.props.gridArea = calculateGridArea(y);
-    }
-    if (sectionHeight > sectionProps?.props?.height) {
-      sectionProps.props.height = sectionHeight;
+      const item = items[i];
+      const itemRect = item?.getBoundingClientRect();
+      const {
+        path
+      } = item?.dataset;
+      const y = Math.abs(rect.top - itemRect?.top);
+      itemsData.push({
+        path,
+        props: {
+          top: y,
+          left: 24,
+          marginTop: 12,
+          width: itemRect?.width,
+          height: itemRect?.height,
+          gridArea: calculateGridArea(y)
+        }
+      });
     }
     allData = [sectionProps, [...allData, ...itemsData]]?.flat();
     return allData;
   };
-  const getItems = () => {
-    const items = cloneNode?.querySelectorAll(ROOT_ITEM_CLASS) || [];
-    let itemsHTML = "";
-    for (let i = 0; i < items?.length; i++) {
-      items[i].classList.add("exclude-virtual");
-      itemsHTML += items[i].outerHTML;
-    }
-    return itemsHTML;
-  };
+  useMemo(() => {
+    return appendContainerItems(sectionCls, virtualRef, dataSets);
+  }, [toggleUpdate]);
   return /*#__PURE__*/_jsx(Box, {
     className: "mobile-virtual-mode",
     ref: virtualRef,
-    sx: classes.root,
-    dangerouslySetInnerHTML: {
-      __html: getItems()
-    },
-    style: {
-      visibility: "hidden"
+    sx: {
+      display: "grid",
+      gridTemplateColumns: "100%",
+      visibility: "hidden",
+      // height: `${containerHeight}px !important`,
+      // gridTemplateRows: `repeat(${lastRow - 1}, ${ROW_HEIGHT}px)`,
+      ...classes.root
     },
-    "aria-hidden": "true"
+    "aria-hidden": "true",
+    contentEditable: false
   });
 };
 export default VirtualElement;

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

@@ -2,20 +2,40 @@ const useVirtualElementStyles = () => ({
   root: {
     width: "320px",
     position: "fixed",
-    backgroundColor: "red",
-    height: "auto",
+    // backgroundColor: "red",
+    // height: "fit-content",
     overflow: "visible",
     pointerEvents: "none",
-    opacity: 0,
+    opacity: 1,
     right: 0,
     top: 0,
+    "& .leaf-item": {
+      fontSize: "var(--fontSize_xs) !important",
+      "& span": {
+        fontSize: "var(--fontSize_xs) !important"
+      }
+    },
+    "& .editor-blocker": {
+      display: "none"
+    },
     "& .freegrid-item": {
       position: "relative !important",
-      gridArea: "none !important",
+      top: "0 !important",
+      gridArea: "var(--gridArea_xs) !important",
       width: "calc(100% - 48px) !important",
-      height: "auto !important",
+      height: "var(--height_xs) !important",
       left: "24px !important",
-      marginTop: "24px !important",
+      marginTop: "var(--marginTop_xs) !important",
+      outline: "1px solid gray !important",
+      "&.type_text": {
+        height: "auto !important"
+      },
+      // "&.type_box": {
+      //   // display: "grid !important",
+      //   // gridTemplateRows: "repeat(auto-fill, 50px) !important",
+      //   // height: "min-content !important",
+      // },
+
       "& .debug-info, & .editor-blocker": {
         display: "none"
       },
@@ -25,4 +45,100 @@ const useVirtualElementStyles = () => ({
     }
   }
 });
-export default useVirtualElementStyles;
+export default useVirtualElementStyles;
+export const useAutoAlignStyles = () => ({
+  root: {
+    width: "320px",
+    position: "fixed",
+    overflow: "visible",
+    opacity: 1,
+    right: 0,
+    top: 0,
+    height: "auto !important",
+    pointerEvents: "none",
+    "& .leaf-item": {
+      fontSize: "var(--fontSize_xs) !important",
+      "& span": {
+        fontSize: "var(--fontSize_xs) !important"
+      }
+    },
+    "& .editor-blocker": {
+      display: "none"
+    },
+    "& .freegrid-item": {
+      position: "relative !important",
+      top: "0 !important",
+      gridArea: "none !important",
+      width: "calc(100% - 48px) !important",
+      height: "var(--height_xs) !important",
+      left: "24px !important",
+      marginTop: "12px !important",
+      minHeight: "auto",
+      display: "inherit !important",
+      "&.type_box": {
+        height: "auto !important"
+      },
+      "&.type_image": {
+        width: "var(--width_xs) !important",
+        height: "var(--height_xs) !important"
+      },
+      "&.type_text": {
+        height: "auto !important"
+      },
+      // start - default signature classes on free-grid
+      "& .fgi_type_signature": {
+        height: "100%",
+        "& .signature-container": {
+          height: "100%",
+          LineHeight: 1.43,
+          "& .signature-btn-container": {
+            height: "100%",
+            display: "flex",
+            flexDirection: "column",
+            "& .sign-placeholder": {
+              display: "flex",
+              // remove hidden sign placeholder
+              width: "100%",
+              flexGrow: 1
+            },
+            "& button": {
+              margin: "6px 0px"
+            }
+          }
+        }
+      },
+      "& .fgi_type_sign": {
+        width: "100%",
+        height: "100%",
+        "& .signature-signed-wrapper": {
+          width: "100%",
+          height: "100%",
+          "& .signature-signed-span": {
+            width: "100%",
+            height: "100%",
+            "& .signed-btn": {
+              width: "100%",
+              height: "100%",
+              display: "flex",
+              flexDirection: "column",
+              "& img": {
+                width: "100% !important",
+                maxWidth: "none !important",
+                height: "70% !important",
+                flexGrow: 1
+              }
+            }
+          }
+        }
+      },
+      // end - default signature classes on free-grid
+
+      "& .debug-info, & .editor-blocker": {
+        display: "none"
+      },
+      "& .embed": {
+        minHeight: "300px"
+      }
+    }
+  }
+});

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

@@ -1,5 +1,5 @@
 import { Node, Transforms } from "slate";
-const updateAutoProps = (editor, datas = [], breakpoint = "", groupData) => {
+const updateAutoProps = (editor, datas = [], breakpoint = "", updateAll) => {
   try {
     // const { heightData } = groupData;
     for (let i = 0; i < datas.length; i++) {
@@ -14,9 +14,11 @@ const updateAutoProps = (editor, datas = [], breakpoint = "", groupData) => {
         return a;
       }, {});
       const oldProps = Node.get(editor, int_path);
-      if (!oldProps?.xs_updatedOn) {
+      const updateNode = !oldProps?.xs_updatedOn || updateAll;
+      if (updateNode) {
         Transforms.setNodes(editor, {
-          ...updatedProps
+          ...updatedProps,
+          xs_updatedOn: new Date().getTime()
         }, {
           at: int_path
         });

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

@@ -19,6 +19,10 @@ import { removeSign } from "./ElementSettings/OtherSettings";
 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 useAutoScroll from "../../hooks/useAutoScroll";
+import ForceAutoAlignment from "./VirtualElement/ForceAutoAlignment";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment as _Fragment } from "react/jsx-runtime";
@@ -64,7 +68,12 @@ const RnD = props => {
     editor,
     breakpoint = "",
     handleContextMenuClick = () => {},
-    itemData = {}
+    itemData = {},
+    customProps,
+    sectionElement,
+    dataSets,
+    autoAlign,
+    setAutoAlign
   } = props;
   const {
     isSelectedElement,
@@ -106,6 +115,13 @@ const RnD = props => {
     y: 0
   });
   const parentSectionPath = str_path?.split("|").slice(0, 2).join("_");
+  const {
+    translation
+  } = customProps;
+  const {
+    startAutoScroll,
+    stopAutoScroll
+  } = useAutoScroll(10, "slate-wrapper-scroll-container");
   useEffect(() => {
     if (ITEM_TYPES.includes(type)) {
       if (enable === 1) {
@@ -347,6 +363,16 @@ const RnD = props => {
   };
   const onDrag = e => {
     e.preventDefault();
+    const {
+      clientY
+    } = e;
+    if (clientY < 50) {
+      startAutoScroll("up");
+    } else if (window.innerHeight - clientY < 50) {
+      startAutoScroll("down");
+    } else {
+      stopAutoScroll();
+    }
     const lines = getClosestDraggable(e.clientX, e.clientY, `.freegrid-section_${parentSectionPath} .freegrid-container .freegrid-item.inactive-drag`.replace(/\|/g, "\\|"), ".freegrid-item.active-drag:not(.exclude-virtual)");
     setAbsPosition({
       ...absPosition,
@@ -389,6 +415,7 @@ const RnD = props => {
   const onDragStop = (e, d) => {
     e.preventDefault();
     e.stopPropagation();
+    stopAutoScroll();
     if (dragging?.isDragging === 2 && dragging?.position?.strXY && dragging?.dragOver) {
       d.x = e.x;
       d.y = e.y;
@@ -449,13 +476,18 @@ const RnD = props => {
     }
     const updatedSize = {
       width: delta?.width + d.width,
-      height: delta?.height + d.height,
+      height: ref.offsetHeight,
       ...updatedPosition
     };
     onChange({
       ...updatedSize
     });
     handleResizeEvent("stop");
+    const parentPath = getParentSectionPath({
+      ref
+    }, ".freegrid-container-parent");
+    const formatParentPath = parentPath?.split("|")?.map(m => parseInt(m));
+    reRenderChildNodes(editor, formatParentPath);
   };
   const onCloseSettings = () => {
     setSelectedElement({
@@ -523,7 +555,7 @@ const RnD = props => {
   return /*#__PURE__*/_jsxs(_Fragment, {
     children: [/*#__PURE__*/_jsxs(Box, {
       component: Rnd,
-      placeholder: ItemTypes[childType] || "Item",
+      placeholder: translation(ItemTypes[childType]) || translation("Item"),
       id: eId || "",
       ref: c => {
         positionRef.current = c;
@@ -557,6 +589,7 @@ const RnD = props => {
         ...DISABLE_RESIZING
       },
       ...getEventProps(),
+      ...(dataSets || {}),
       children: [/*#__PURE__*/_jsx("div", {
         id: `opt_ref_${str_path}`,
         style: {
@@ -590,7 +623,9 @@ const RnD = props => {
       optionsProps: optionsProps,
       selectedAction: currentAction,
       path: str_path,
-      theme: theme
+      theme: theme,
+      translation: translation,
+      customProps: customProps
     }) : null, /*#__PURE__*/_jsx(ElementSettings, {
       open: Boolean(currentAction),
       currentAction: currentAction,
@@ -624,12 +659,29 @@ const RnD = props => {
       open: openContextMenu,
       contextMenu: contextMenu,
       handleClose: handleClose,
-      theme: theme
+      theme: theme,
+      translation: translation
     }), type === "parent" && breakpoint === "lg" && !readOnly ? /*#__PURE__*/_jsx(VirtualElement, {
-      parentEle: positionRef?.current?.resizableElement?.current,
       updated_at: updated_at,
       path: str_path,
-      editor: editor
+      editor: editor,
+      sectionElement: sectionElement,
+      sectionCls: `.freegrid-section_${path.join("_")}`,
+      dataSets: dataSets
+    }) : null, childType === "text" && breakpoint === "lg" && !readOnly && enable ? /*#__PURE__*/_jsx(VirtualTextElement, {
+      editor: editor,
+      dataSets: dataSets,
+      getCurrentEle: getCurrentEle,
+      path: path
+    }) : null, type === "parent" && breakpoint === "xs" && !readOnly && autoAlign ? /*#__PURE__*/_jsx(ForceAutoAlignment, {
+      updated_at: updated_at,
+      path: str_path,
+      editor: editor,
+      sectionElement: sectionElement,
+      sectionCls: `.freegrid-section_${path.join("_")}`,
+      dataSets: dataSets,
+      autoAlign: autoAlign,
+      setAutoAlign: setAutoAlign
     }) : null]
   });
 };

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

@@ -19,7 +19,8 @@ const Toolbar = ({
   readOnly,
   showTool,
   onSettings,
-  isSectionFullWidth
+  isSectionFullWidth,
+  translation
 }) => {
   return !readOnly && !showTool ? /*#__PURE__*/_jsx(Box, {
     component: "div",
@@ -33,7 +34,7 @@ const Toolbar = ({
       }
     },
     children: /*#__PURE__*/_jsx(Tooltip, {
-      title: "Section Settings",
+      title: translation("Section Settings"),
       children: /*#__PURE__*/_jsx(IconButton, {
         onClick: onSettings,
         children: /*#__PURE__*/_jsx(SectionSettingIcon, {})
@@ -51,7 +52,8 @@ const Section = props => {
     customProps
   } = props;
   const {
-    readOnly
+    readOnly,
+    translation
   } = customProps;
   const editor = useSlateStatic();
   // const [isHovering, setIsHovering] = useState(false);
@@ -176,7 +178,8 @@ const Section = props => {
         isSectionFullWidth: isSectionFullWidth,
         readOnly: readOnly,
         showTool: false,
-        onSettings: onSettings
+        onSettings: onSettings,
+        translation: translation
       }), children]
     }), openSetttings ? /*#__PURE__*/_jsx(SectionPopup, {
       element: {