@flozy/editor 5.5.8 → 5.6.0

package/dist/Editor/helper/deserialize/index.js

@@ -1,4 +1,26 @@
 import { jsx } from "slate-hyperscript";
+const inlineStyles = [{
+  key: "bold",
+  getStyle: styles => styles.fontWeight === "bold" || parseInt(styles.fontWeight, 10) >= 700
+}, {
+  key: "italic",
+  getStyle: styles => styles.fontStyle === "italic"
+}, {
+  key: "underline",
+  getStyle: styles => styles.textDecoration.includes("underline")
+}];
+function getInlineTextStyles(element) {
+  if (!element || !element.style) return {};
+  const styles = element.style;
+  const elementStyles = inlineStyles.reduce((total, currVal) => {
+    const style = currVal.getStyle(styles);
+    if (style) {
+      total[currVal.key] = style;
+    }
+    return total;
+  }, {});
+  return elementStyles;
+}
 const handleTableCell = (el, children) => {
   const wrapChild = children?.map(c => {
     if (typeof c === "string") {
@@ -14,7 +36,10 @@ const handleTableCell = (el, children) => {
   });
   return {
     type: "table-cell",
-    overwriteChild: wrapChild
+    overwriteChild: wrapChild,
+    size: {
+      width: 120
+    }
   };
 };
 const INLINE_TAGS = ["A", "ABBR", "B", "BDO", "CITE", "CODE", "DATA", "DEL", "DFN", "IMG", "INS", "KBD", "LABEL", "MARK", "Q", "SAMP", "SMALL", "SPAN", "SUB", "SUP", "TIME", "VAR"];
@@ -135,9 +160,13 @@ const TEXT_TAGS = {
 
 const deserialize = el => {
   if (el.nodeType === 3) {
+    // if there is any line-breaks
     const match = /\r|\n/.exec(el.textContent);
     const text = el.textContent.replace(/\r|\n/g, "").trim();
-    return match && !text ? null : el.textContent;
+    return match && !text ? null : {
+      text,
+      ...getInlineTextStyles(el.parentNode)
+    };
   } else if (el.nodeType !== 1) {
     return null;
   } else if (el.nodeName === "BR") {

package/dist/Editor/helper/enforceDateFormat.js

@@ -0,0 +1,41 @@
+function enforceDateFormat(inputElement) {
+  inputElement.addEventListener("input", event => {
+    const input = event.target;
+    let value = input.value;
+
+    // Allow only numbers and forward slashes
+    value = value.replace(/[^\d/]/g, "");
+
+    // Enforce MM/DD/YYYY structure
+    if (value.length > 10) {
+      value = value.slice(0, 10);
+    }
+    const parts = value.split("/");
+    if (parts.length > 1) {
+      parts[0] = parts[0].slice(0, 2); // Limit MM to 2 digits
+      if (parts[0] > 12) parts[0] = "12"; // Max month value
+    }
+
+    if (parts.length > 2) {
+      parts[1] = parts[1].slice(0, 2); // Limit DD to 2 digits
+      if (parts[1] > 31) parts[1] = "31"; // Max day value
+    }
+
+    if (parts.length > 3) {
+      parts[2] = parts[2].slice(0, 4); // Limit YYYY to 4 digits
+    }
+
+    input.value = parts.join("/");
+
+    // Optionally, validate the full date
+    if (input.value.length === 10) {
+      const [month, day, year] = input.value.split("/").map(Number);
+      const isValidDate = !isNaN(Date.parse(`${year}-${month}-${day}`));
+      if (!isValidDate) {
+        input.value = ""; // Clear input if invalid
+        alert("Invalid date format. Please enter a valid MM/DD/YYYY date.");
+      }
+    }
+  });
+}
+export default enforceDateFormat;

package/dist/Editor/helper/index.js

@@ -308,7 +308,13 @@ export const getTextColor = (color = "") => {
     color: "transparent !important",
     caretColor: "black",
     "& span": {
-      color: "transparent !important"
+      color: "transparent !important",
+      "& ::selection": {
+        color: "#000 !important"
+      }
+    },
+    "& ::selection": {
+      color: "#000 !important"
     }
   } : {
     color
@@ -352,7 +358,7 @@ export const clearBrainText = editor => {
     } = editor;
     if (selection) {
       const [currentNode, currentPath] = Editor.node(editor, selection);
-      const cleanedText = Node.string(currentNode).replace(/\/b(?:rain|rai|ra|r)?/g, "").trim();
+      const cleanedText = Node.string(currentNode).replace(/\/(?:b(?:rain|rai|ra|r)?)?/g, "").trim();
       Transforms.insertText(editor, cleanedText, {
         at: currentPath
       });
@@ -360,4 +366,11 @@ export const clearBrainText = editor => {
   } catch (err) {
     console.log(err);
   }
+};
+export const clearSelectionOnly = editor => {
+  try {
+    Transforms.deselect(editor);
+  } catch (err) {
+    console.log(err);
+  }
 };

package/dist/Editor/helper/theme.js

@@ -54,6 +54,20 @@ const overrides = {
     return `${val?.topLeft}px ${val?.topRight}px ${val?.bottomLeft}px ${val?.bottomRight}px`;
   }
 };
+export const checkXS = (val = {}) => {
+  try {
+    if (typeof val === "object") {
+      if (val?.xs === undefined && val?.lg !== undefined) {
+        val.xs = val.lg;
+      }
+      return val;
+    }
+    return val;
+  } catch (err) {
+    console.log(err);
+    return val;
+  }
+};
 export const getBreakPointsValue = (value, breakpoint, ot = null, ov = false) => {
   try {
     if (breakpoint) {
@@ -67,7 +81,7 @@ export const getBreakPointsValue = (value, breakpoint, ot = null, ov = false) =>
         return value ? value[breakpoint] || value["lg"] : value;
       }
     } else if (typeof value === "object") {
-      return !breakpoint && value["lg"] ? !ov ? value : overrideValues(value, ot) : value[breakpoint] || copyAllLg(value, ot);
+      return !breakpoint && value["lg"] ? !ov ? value : checkXS(overrideValues(value, ot)) : value[breakpoint] || copyAllLg(value, ot);
     } else {
       // consider without breakpoints
       return copyAllLg(value, ot);

package/dist/Editor/hooks/useBreakpoints.js

@@ -1,6 +1,6 @@
 import { useMediaQuery } from "@mui/material";
 export const STIMULATOR_MOCK = {
-  xs: "@media (min-width: 1200px) and (max-width: 1980px)"
+  xs: "@media (min-width: 1200px) and (max-width: 10000px)"
 };
 export const isStimulator = () => {
   try {

package/dist/Editor/hooks/useTable.js

@@ -0,0 +1,210 @@
+import { ClickAwayListener } from "@mui/material";
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
+import { clearCellText } from "../utils/table";
+import { Editor, Element, Transforms } from "slate";
+import { DndContext, DragOverlay, PointerSensor, useSensor, useSensors } from "@dnd-kit/core";
+import { encodeToBase64, isHavingSelection } from "../utils/helper";
+import { serializeToText } from "../utils/serializeToText";
+import { createCopiedTableStructure, getRectangleBounds, tableNodeToDom } from "../Elements/Table/tableHelper";
+
+// const selectFirstCell = (tablePath, editor, updateTableSelection) => {
+//   const firstCell = [...tablePath, 0, 0];
+
+//   const end = Editor.end(editor, firstCell);
+
+//   Transforms.select(editor, {
+//     anchor: end,
+//     focus: end,
+//   });
+
+//   updateTableSelection({
+//     startCellPath: firstCell,
+//     endCellPath: [],
+//     isDragging: false,
+//   });
+// };
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+const handleDragEnd = (dragData, editor, resetAll) => {
+  const {
+    active,
+    over
+  } = dragData;
+  if (over) {
+    const {
+      dragType,
+      path: startCellPath
+    } = active?.data?.current || {};
+    const {
+      path: overCellPath
+    } = over?.data?.current || {};
+    if (startCellPath?.length) {
+      if (dragType === "row") {
+        const startRowPath = startCellPath.slice(0, -1);
+        const overRowPath = overCellPath.slice(0, -1);
+        Transforms.moveNodes(editor, {
+          at: startRowPath,
+          to: overRowPath
+        });
+      } else {
+        const [startCol] = startCellPath.slice(-1);
+        const [overCol] = overCellPath.slice(-1);
+        const [tableData] = Editor.nodes(editor, {
+          at: startCellPath,
+          match: n => !Editor.isEditor(n) && Element.isElement(n) && n.type === "table"
+        });
+        const [tableNode, tablePath] = tableData;
+        const rows = tableNode?.rows || 0;
+        for (let row = 0; row < rows; row++) {
+          const startColPath = [...tablePath, row, startCol];
+          const overColPath = [...tablePath, row, overCol];
+          Transforms.moveNodes(editor, {
+            at: startColPath,
+            to: overColPath
+          });
+        }
+      }
+      resetAll();
+    }
+  }
+};
+const TableContext = /*#__PURE__*/createContext();
+export function getDefaultTableSelection() {
+  return {
+    startCellPath: [],
+    endCellPath: [],
+    isDragging: false
+  };
+}
+export const TableProvider = ({
+  editor,
+  children,
+  otherProps = {}
+}) => {
+  const [hoverPath, setHoverPath] = useState(null);
+  const [tableSelection, setTableSelection] = useState(getDefaultTableSelection());
+  const [tableResizing, setTableResizing] = useState(null);
+
+  // for the button events (like onclick,...etc) inside draggable component to work correctly
+  const sensors = useSensors(useSensor(PointerSensor, {
+    activationConstraint: {
+      delay: 250,
+      distance: 0 // throws exceeded distance error
+    }
+  }));
+
+  const getSelectedCells = () => {
+    return getRectangleBounds(tableSelection);
+  };
+  const updateTableSelection = update => {
+    setTableSelection(prev => ({
+      ...prev,
+      ...update
+    }));
+  };
+  const resetAll = () => {
+    setTableSelection(getDefaultTableSelection());
+    Transforms.deselect(editor);
+
+    // hide drag icons after drag completion
+    setTimeout(() => setHoverPath(null), 200);
+  };
+  const values = useMemo(() => {
+    return {
+      hoverPath,
+      setHoverPath,
+      editor,
+      getSelectedCells,
+      updateTableSelection,
+      tableSelection,
+      tableResizing,
+      setTableResizing,
+      otherProps,
+      resetAll
+    };
+  }, [hoverPath, editor?.selection, tableSelection, tableResizing]);
+  useEffect(() => {
+    let isTextSelected;
+    const handleKeyDown = event => {
+      const isCutKey = (event.ctrlKey || event.metaKey) && event.key === "x";
+      if (isCutKey) {
+        isTextSelected = isHavingSelection(editor);
+      } else if (event.key === "Backspace") {
+        const selectedCells = getSelectedCells();
+        if (selectedCells?.length > 1) {
+          selectedCells.forEach(currentCellPath => {
+            clearCellText(editor, currentCellPath);
+          });
+        }
+      }
+    };
+    const handleCopy = (event, isCut) => {
+      try {
+        const isTextSelected = isHavingSelection(editor);
+        const {
+          startCellPath
+        } = tableSelection || {};
+        const customCopy = startCellPath?.length;
+        if (customCopy && !isTextSelected) {
+          event.preventDefault(); // Prevent default copy behavior
+
+          const {
+            tablePath
+          } = otherProps;
+          const [node] = Editor.node(editor, tablePath);
+          const copiedTableNode = createCopiedTableStructure(editor, tableSelection, node, tablePath);
+          const tableNode = [copiedTableNode];
+          const encodedTableNode = encodeToBase64(tableNode);
+          event.clipboardData.setData("application/x-slate-fragment", encodedTableNode);
+          const textData = serializeToText(tableNode);
+          event.clipboardData.setData("text/plain", textData);
+          const tableDom = tableNodeToDom(copiedTableNode);
+          event.clipboardData.setData("text/html", tableDom?.outerHTML);
+          if (isCut) {
+            clearCellText(editor, startCellPath);
+          }
+        }
+      } catch (err) {
+        console.log(err);
+      }
+    };
+    const handleCut = e => {
+      // unable to find the text selected or not here, that why handling it on handleKeyDown
+
+      if (!isTextSelected) {
+        e.preventDefault();
+        handleCopy(e, true);
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    window.addEventListener("copy", handleCopy);
+    window.addEventListener("cut", handleCut);
+    return () => {
+      window.removeEventListener("keydown", handleKeyDown);
+      window.removeEventListener("copy", handleCopy);
+      window.removeEventListener("cut", handleCut);
+    };
+  }, [tableSelection, editor, tableSelection]);
+
+  // useEffect(() => {
+  //   selectFirstCell(tablePath, editor, updateTableSelection);
+  // }, []);
+
+  return /*#__PURE__*/_jsx(TableContext.Provider, {
+    value: values,
+    children: /*#__PURE__*/_jsxs(DndContext, {
+      sensors: sensors,
+      onDragEnd: data => handleDragEnd(data, editor, resetAll),
+      children: [/*#__PURE__*/_jsx(ClickAwayListener, {
+        onClickAway: () => setTableSelection(getDefaultTableSelection()),
+        children: /*#__PURE__*/_jsx("div", {
+          children: children
+        })
+      }), /*#__PURE__*/_jsx(DragOverlay, {})]
+    })
+  });
+};
+function useTable() {
+  return useContext(TableContext);
+}
+export default useTable;

package/dist/Editor/plugins/withCustomDeleteBackward.js

@@ -64,7 +64,7 @@ const withCustomDeleteBackward = editor => {
 
         // Check if current node is a list item and is the last one, signature node
         const [node] = Editor.nodes(editor, {
-          match: n => BACKWARD_BLOCKS?.includes(n.type) // Adjust based on your list item type
+          match: n => BACKWARD_BLOCKS.includes(n.type) // Adjust based on your list item type
         });
 
         if (node) {

package/dist/Editor/plugins/withEmbeds.js

@@ -40,32 +40,36 @@ const withEmbeds = editor => {
     }
   };
   editor.insertBreak = (...args) => {
-    const parentPath = Path.parent(editor.selection.focus.path);
-    const parentNode = Node.get(editor, parentPath);
-    if (editor.isVoid(parentNode)) {
-      const nextPath = Path.next(parentPath);
-      Transforms.insertNodes(editor, {
-        type: "paragraph",
-        children: [{
-          text: ""
-        }]
-      }, {
-        at: nextPath,
-        select: true // Focus on this node once inserted
-      });
-    } else if (AvoidCopying.indexOf(parentNode?.type) >= 0) {
-      const nextPath = Path.next(parentPath);
-      Transforms.insertNodes(editor, {
-        type: "paragraph",
-        children: [{
-          text: ""
-        }]
-      }, {
-        at: nextPath,
-        select: true // Focus on this node once inserted
-      });
-    } else {
-      insertBreak(...args);
+    try {
+      const parentPath = Path.parent(editor.selection.focus.path);
+      const parentNode = Node.get(editor, parentPath);
+      if (editor.isVoid(parentNode)) {
+        const nextPath = Path.next(parentPath);
+        Transforms.insertNodes(editor, {
+          type: "paragraph",
+          children: [{
+            text: ""
+          }]
+        }, {
+          at: nextPath,
+          select: true // Focus on this node once inserted
+        });
+      } else if (AvoidCopying.indexOf(parentNode?.type) >= 0) {
+        const nextPath = Path.next(parentPath);
+        Transforms.insertNodes(editor, {
+          type: "paragraph",
+          children: [{
+            text: ""
+          }]
+        }, {
+          at: nextPath,
+          select: true // Focus on this node once inserted
+        });
+      } else {
+        insertBreak(...args);
+      }
+    } catch (err) {
+      console.log(err);
     }
   };
   return editor;

package/dist/Editor/plugins/withHTML.js

@@ -2,6 +2,45 @@ import { Transforms, Editor, Element, Node, Path } from "slate";
 import deserialize from "../helper/deserialize";
 import { decodeAndParseBase64 } from "../utils/helper";
 const avoidDefaultInsert = ["table", "grid"];
+const NON_TEXT_TAGS = ["ol", "ul", "img", "table", "video", "a", "button", "GOOGLE-SHEETS-HTML-ORIGIN"];
+const ALLOWED_TEXT_NODES = ["paragraph", "title", "headingOne", "headingTwo", "headingThree"];
+const parseCopiedHTML = html => {
+  const parsed = new DOMParser().parseFromString(html, "text/html");
+
+  // if ol, ul are inside li, remove and push ol,ul after that li to maintain format between our slate list and external source list's json
+  parsed.querySelectorAll("li > ul, li > ol").forEach(list => {
+    // Find the parent li
+    const parentLi = list.parentElement;
+
+    // Move the list after the parent li
+    parentLi.after(list);
+  });
+
+  // to handle google docs list
+  parsed.querySelectorAll("li p, li div").forEach(element => {
+    const parent = element.parentNode;
+    // Move all child nodes of <p> or <div> to its parent <li>
+    while (element.firstChild) {
+      parent.insertBefore(element.firstChild, element);
+    }
+    // Remove the <p> or <div> element
+    parent.removeChild(element);
+  });
+
+  // claude.ai, copy list inbetween, some li tags are not wrapped with ul or ol
+  parsed.querySelectorAll("li").forEach(li => {
+    // Check if the parent of <li> is not a <ul> or <ol>
+    if (!li.parentElement || li.parentElement.tagName !== "UL" && li.parentElement.tagName !== "OL") {
+      // Create a <ul> element
+      const ul = document.createElement("ul");
+      // Append the <li> to the <ul>
+      ul.appendChild(li.cloneNode(true)); // Clone the <li>
+      // Replace the original <li> in the DOM with the <ul>
+      li.replaceWith(ul);
+    }
+  });
+  return parsed;
+};
 const loopChildren = (children = [], defaultInsert) => {
   if (!children?.length) {
     return defaultInsert;
@@ -26,7 +65,7 @@ const getCurrentElement = editor => {
     return null;
   }
 };
-const getCurrentElementText = editor => {
+export const getCurrentElementText = editor => {
   try {
     if (editor.selection) {
       return Editor.string(editor, editor?.selection?.anchor?.path);
@@ -61,12 +100,23 @@ const insertAtNextNode = (editor, formattedFragment) => {
     console.log(err);
   }
 };
-const handleInsert = (editor, defaultInsert, fragment = []) => {
-  if (getCurrentElementText(editor) && fragment.some(f => f.type === "table")) {
-    insertAtNextNode(editor, fragment);
-  } else {
-    defaultInsert();
-  }
+
+// const handleInsert = (editor, defaultInsert, fragment = []) => {
+//   if (
+//     getCurrentElementText(editor) &&
+//     fragment.some((f) => f.type === "table")
+//   ) {
+//     insertAtNextNode(editor, fragment);
+//   } else {
+//     defaultInsert();
+//   }
+// };
+
+const getTableCellChild = (fragment = []) => {
+  const table = fragment.find(node => node.type === "table");
+  const row = table?.children?.find(node => node.type === "table-row");
+  const cell = row?.children?.find(node => node.type === "table-cell");
+  return cell?.children || [];
 };
 const formatFragment = {
   "list-item": fragment => {
@@ -115,8 +165,21 @@ const withHtml = editor => {
     const html = data?.getData("text/html");
     const currentEl = getCurrentElement(editor);
     const eltype = currentEl?.type;
+    const firstNode = editor?.children?.[0];
+    const titlePath = firstNode?.type === "topbanner" ? 1 : 0;
+    const isTitlePath = editor.needLayout && editor?.selection?.anchor?.path[0] === titlePath;
     if (slateHTML && !formatFragment[eltype]) {
+      const [tableCellNode] = Editor.nodes(editor, {
+        match: n => !Editor.isEditor(n) && Element.isElement(n) && n.type === "table-cell"
+      });
       const decoded = decodeAndParseBase64(slateHTML);
+      if (tableCellNode) {
+        const tableCellChild = getTableCellChild(decoded);
+        if (tableCellChild?.length) {
+          Transforms.insertFragment(editor, tableCellChild);
+          return;
+        }
+      }
       const tableNode = getFocusedNode(editor, "table");
       const onlyTextNode = getFocusedNode(editor, "freegrid");
 
@@ -154,22 +217,38 @@ const withHtml = editor => {
           Transforms.insertText(editor, text);
         }
       } else {
-        handleInsert(editor, () => insertData(data), decoded);
+        const isTextNode = ALLOWED_TEXT_NODES.includes(decoded?.[0]?.type);
+        if (isTitlePath && !isTextNode) {
+          insertAtNextNode(editor, decoded);
+          return;
+        }
+        const currentText = getCurrentElementText(editor);
+        if (currentText?.trim() && !isTextNode) {
+          insertAtNextNode(editor, decoded);
+          return;
+        }
+        insertData(data);
       }
     } else if (html) {
-      const parsed = new DOMParser().parseFromString(html, "text/html");
+      const parsed = parseCopiedHTML(html);
+      const rootElement = parsed.body;
+      const isNonText = rootElement ? rootElement?.querySelector(NON_TEXT_TAGS.toString()) : false;
       const isGoogleSheet = parsed.body.querySelector("google-sheets-html-origin");
       if (isGoogleSheet) {
         if (editor.isChatEditor) {
           return;
         }
-        const table = parsed.body.querySelector("table");
+        const table = rootElement.querySelector("table");
         const colGrp = table.querySelector("colgroup");
         if (colGrp) {
           colGrp.remove();
         }
         const fragment = deserialize(table);
-        Transforms.insertFragment(editor, [fragment]);
+        if (isTitlePath) {
+          insertAtNextNode(editor, [fragment]);
+        } else {
+          Transforms.insertFragment(editor, [fragment]);
+        }
         return;
       }
       const fragment = deserialize(parsed.body);
@@ -183,7 +262,16 @@ const withHtml = editor => {
       if (editor.isChatEditor && is_img_table) {
         return;
       }
-      handleInsert(editor, () => Transforms.insertFragment(editor, formattedFragment), formattedFragment);
+      if (isTitlePath && isNonText) {
+        insertAtNextNode(editor, formattedFragment);
+        return;
+      }
+      const currentText = getCurrentElementText(editor);
+      if (currentText?.trim() && isNonText) {
+        insertAtNextNode(editor, formattedFragment);
+        return;
+      }
+      Transforms.insertFragment(editor, formattedFragment);
       return;
     } else {
       insertData(data);

package/dist/Editor/plugins/withLayout.js

@@ -58,6 +58,7 @@ const withLayout = editor => {
         Transforms.insertNodes(editor, paragraph, {
           at: path.concat(1)
         });
+        return;
       }
       ORDERS_LAYOUT.forEach((enforce, index) => {
         if (index < editor.children.length) {