@flozy/editor 9.3.6 → 9.3.7

package/dist/Editor/common/RnD/Theme/MainThemeProvider.js

@@ -1,17 +0,0 @@
-import { Experimental_CssVarsProvider as CssVarsProvider, experimental_extendTheme as extendTheme } from "@mui/material/styles";
-import { jsx as _jsx } from "react/jsx-runtime";
-function MainThemeProvider({
-  children,
-  userSelectedTheme,
-  theme = {}
-}) {
-  const themeVars = extendTheme(userSelectedTheme?.theme?.cssVars || {});
-  return /*#__PURE__*/_jsx(CssVarsProvider, {
-    theme: {
-      ...themeVars,
-      ...theme
-    },
-    children: children
-  });
-}
-export default MainThemeProvider;

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

@@ -1,110 +0,0 @@
-import { Box } from "@mui/material";
-import { useAutoAlignStyles } from "./styles";
-import { useEffect, useRef } from "react";
-import { ROW_HEIGHT, calculateGridArea, reRenderChildNodes } from "../Utils/gridDropItem";
-import updateAutoProps from "./updateAutoProps";
-import { jsx as _jsx } from "react/jsx-runtime";
-const ROOT_ITEM_CLASS = ".freegrid-item.path-3";
-const getMarginTop = y => {
-  const calcMargin = y % ROW_HEIGHT;
-  return calcMargin <= 0 ? 0 : calcMargin;
-};
-function ForceAutoAlignment(props) {
-  const {
-    editor,
-    sectionCls,
-    path,
-    autoAlign,
-    setAutoAlign
-  } = props;
-  const classes = useAutoAlignStyles();
-  const virtualRef = useRef();
-  useEffect(() => {
-    let timeoutId;
-    if (virtualRef?.current && autoAlign) {
-      timeoutId = setTimeout(() => {
-        const allData = calculateProps(path, virtualRef?.current, ROOT_ITEM_CLASS, []);
-        updateAutoProps(editor, allData, "xs", true);
-        const currentSectionPath = path.split("|").map(m => parseInt(m));
-        reRenderChildNodes(editor, currentSectionPath);
-        setAutoAlign(false);
-      }, 100);
-    }
-    return () => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-    };
-  }, [autoAlign, virtualRef?.current]);
-  const calculateProps = (curPath, dom, domClass, allData, parentDom) => {
-    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);
-        itemsData.push({
-          path: items[i]?.dataset.path,
-          props: {
-            top: y,
-            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 y = Math.abs(parentDomRect.top - rect?.top);
-      sectionProps.props.gridArea = calculateGridArea(y);
-      sectionProps.props.left = 24;
-      sectionProps.props.marginTop = getMarginTop(y);
-      sectionProps.props.width = rect?.width;
-    }
-    allData = [sectionProps, [...allData, ...itemsData]]?.flat();
-    return allData;
-  };
-  const getItems = () => {
-    const cloneNode = document.querySelector(sectionCls)?.cloneNode(true);
-    const items = cloneNode?.querySelectorAll(ROOT_ITEM_CLASS) || [];
-    if (!cloneNode || !items?.length) {
-      return;
-    }
-    let itemsHTML = "";
-    for (let i = 0; i < items?.length; i++) {
-      items[i].classList.add("exclude-virtual");
-      itemsHTML += items[i].outerHTML;
-    }
-    return itemsHTML;
-  };
-  return /*#__PURE__*/_jsx(Box, {
-    className: "force-mobile-virtual-mode",
-    ref: virtualRef,
-    sx: {
-      visibility: "hidden",
-      ...classes.root
-    },
-    "aria-hidden": "true",
-    dangerouslySetInnerHTML: {
-      __html: getItems()
-    }
-  });
-}
-export default ForceAutoAlignment;

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

@@ -1,112 +0,0 @@
-import { useEffect, useRef } from "react";
-import { Path, Transforms } from "slate";
-import { getNode } from "../../../utils/helper";
-import { ROW_HEIGHT } from "../Utils/gridDropItem";
-import { findFirstRowOverlap, getGridArea, handleContainers, moveOverlappedItems } from "./helper";
-import { jsx as _jsx } from "react/jsx-runtime";
-const updateTextHeight = (editor, path, height) => {
-  if (!height) {
-    return;
-  }
-  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 {
-    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) {
-  const {
-    dataSets,
-    getCurrentEle,
-    path,
-    editor
-  } = props;
-  const textRef = useRef(null);
-  const currElement = getCurrentEle();
-  useEffect(() => {
-    const observer = new ResizeObserver(([entry]) => {
-      if (entry) {
-        const {
-          height
-        } = entry.contentRect;
-        updateTextHeight(editor, path, height);
-      }
-    });
-    const elementRef = textRef?.current;
-    if (elementRef) {
-      observer.observe(elementRef);
-    }
-    return () => {
-      const elementRef = textRef?.current;
-      if (elementRef) {
-        observer.unobserve(elementRef);
-      }
-      observer.disconnect();
-    };
-  }, []);
-  return /*#__PURE__*/_jsx("div", {
-    style: {
-      position: "fixed",
-      width: dataSets["data-width-xs"],
-      minHeight: "fit-content",
-      visibility: "hidden",
-      pointerEvents: "none",
-      right: 0,
-      top: 0
-    },
-    ref: textRef,
-    children: currElement?.innerText
-  });
-}
-export default VirtualTextElement;

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

@@ -1,267 +0,0 @@
-import { ROW_HEIGHT } from "../Utils/gridDropItem";
-import { Transforms, Editor } from "slate";
-export const findFirstRowOverlap = (gridItems, startRow, endRow, textItemIndex) => {
-  let firstOverlapRow;
-  gridItems.forEach((gridItem, index) => {
-    const {
-      gridArea_xs: gridArea
-    } = gridItem;
-    if (!gridArea) {
-      return;
-    }
-    const [itemStartRow] = getGridArea(gridArea);
-    const isItemOverlap = itemStartRow >= startRow && itemStartRow <= endRow;
-    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
-    } = gridItem;
-    const [itemStartRow] = getGridArea(gridArea);
-    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
-  });
-  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
-      });
-    });
-  }
-};

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

@@ -1,43 +0,0 @@
-import Snackbar from "@mui/material/Snackbar";
-import Alert from "@mui/material/Alert";
-import { useState } from "react";
-import { useEditorContext } from "../../hooks/useMouseMove";
-import { jsx as _jsx } from "react/jsx-runtime";
-const SnackbarAlert = ({
-  message,
-  setShowSnackBar,
-  severity = "info"
-}) => {
-  const [open, setOpen] = useState(!!message);
-  const {
-    theme
-  } = useEditorContext();
-  return /*#__PURE__*/_jsx(Snackbar, {
-    open: open,
-    autoHideDuration: 3000,
-    onClose: () => {
-      setOpen(false);
-      setShowSnackBar(false);
-    },
-    anchorOrigin: {
-      vertical: "top",
-      horizontal: "right"
-    },
-    children: /*#__PURE__*/_jsx(Alert, {
-      severity: severity,
-      onClose: () => {
-        setOpen(false);
-        setShowSnackBar(false);
-      },
-      sx: {
-        background: theme?.palette?.primary?.gradientBtn,
-        color: "#FFFFFF",
-        "& .MuiAlert-icon": {
-          color: "#FFFFFF"
-        }
-      },
-      children: message
-    })
-  });
-};
-export default SnackbarAlert;

package/dist/Editor/helper/textIndeces.js

@@ -1,58 +0,0 @@
-export function extractTextWithPath(data, path = []) {
-  let result = [];
-  data.forEach((item, index) => {
-    const currentPath = [...path, index];
-    if (item.text) {
-      result.push({
-        path_id: currentPath.join(","),
-        text: item.text
-      });
-    }
-    if (item.children) {
-      result = result.concat(extractTextWithPath(item.children, currentPath));
-    }
-  });
-  return result;
-}
-export function replaceTextPath(nestedJson, pathIdJson) {
-  // Create a map from path_id JSON for quick lookup
-  const pathIdMap = new Map(pathIdJson.map(item => [item.path_id, item.text]));
-  console.log(pathIdMap);
-  function extractTextWithPath(data, path = []) {
-    data.forEach((item, index) => {
-      const currentPath = [...path, index];
-      if (item.text) {
-        if (pathIdMap.has(currentPath?.join(","))) {
-          item.text = pathIdMap.get(currentPath?.join(","));
-        }
-      }
-      if (item.children) {
-        extractTextWithPath(item.children, currentPath);
-      }
-    });
-  }
-  extractTextWithPath(nestedJson, []);
-  return nestedJson;
-}
-
-// export function replaceTextPath(nestedJson, pathIdJson) {
-//   // Create a map from path_id JSON for quick lookup
-//   const pathIdMap = new Map(
-//     pathIdJson.map((item) => [item.path_id, item.text])
-//   );
-
-//   function traverseAndReplace(node) {
-//     if (Array.isArray(node)) {
-//       node.forEach(traverseAndReplace);
-//     } else if (typeof node === "object" && node !== null) {
-//       console.log(node);
-//       if (node.text && pathIdMap.has(node.text)) {
-//         node.text = pathIdMap.get(node.path_id);
-//       }
-//       Object.values(node).forEach(traverseAndReplace);
-//     }
-//   }
-
-//   traverseAndReplace(nestedJson);
-//   return nestedJson;
-// }

package/dist/Editor/hooks/useAutoScroll.js

@@ -1,38 +0,0 @@
-import { useEffect, useRef } from "react";
-function useAutoScroll(speed = 10, scrollElementId = "slate-wrapper-scroll-container") {
-  const scrollInterval = useRef(null);
-  function getScrollElement() {
-    return document.getElementById(scrollElementId) || window;
-  }
-  function startAutoScroll(direction) {
-    if (scrollInterval.current) return; // Prevent multiple intervals
-
-    const scrollContainer = getScrollElement();
-    scrollInterval.current = setInterval(() => {
-      scrollContainer.style.scrollBehavior = "auto";
-      if (direction === "up") {
-        scrollContainer.scrollBy(0, -speed);
-      } else if (direction === "down") {
-        scrollContainer.scrollBy(0, speed);
-        scrollContainer.style.scrollBehavior = "smooth";
-      }
-    }, 16); // Approx 60fps
-  }
-
-  function stopAutoScroll() {
-    if (scrollInterval.current) {
-      clearInterval(scrollInterval.current);
-      scrollInterval.current = null;
-      const scrollContainer = getScrollElement();
-      scrollContainer.style.scrollBehavior = "smooth";
-    }
-  }
-  useEffect(() => {
-    return () => stopAutoScroll(); // Cleanup on unmount
-  }, []);
-  return {
-    startAutoScroll,
-    stopAutoScroll
-  };
-}
-export default useAutoScroll;