@flozy/editor 9.3.2 → 9.3.3

package/dist/Editor/hooks/useEditorTheme.js

@@ -0,0 +1,153 @@
+import { useSlate } from "slate-react";
+import { defaultTheme } from "../theme";
+import { getPageSettings, updatePageSettings } from "../utils/pageSettings";
+import { HEADING_THEME_FIELDS, PARAGRAPH_THEME_FIELDS } from "../helper/theme";
+import { useEditorContext } from "./useMouseMove";
+const MAP_FIELDS = {
+  HEADING: HEADING_THEME_FIELDS,
+  PARAGRAPH: PARAGRAPH_THEME_FIELDS
+};
+const MAP_FONT_FIELD_KEYS = {
+  HEADING: "headingFontFamily",
+  PARAGRAPH: "paragraphFontFamily"
+};
+function getUpdatePayload(prevTheme = {}, update, actionData) {
+  const {
+    action,
+    fieldName
+  } = actionData || {};
+  const {
+    theme: prev
+  } = prevTheme;
+  let theme = {};
+  let themeProps = {};
+  switch (action) {
+    case "THEME_CHANGE":
+      theme = update;
+      break;
+    case "CSS_VAR_CHANGE":
+      const prevCssVars = prev?.cssVars || {};
+      const prevValue = prevCssVars[fieldName] || {};
+      themeProps = {
+        ...(prev || {}),
+        cssVars: {
+          ...prevCssVars,
+          [fieldName]: {
+            ...prevValue,
+            ...update
+          }
+        }
+      };
+      theme = {
+        ...prevTheme,
+        theme: themeProps
+      };
+      break;
+    case "ELEMENT_PROPS_CHANGE":
+      const prevEleProps = prev?.elementProps || {};
+      const prevEleValue = prevEleProps[fieldName] || {};
+      themeProps = {
+        ...(prev || {}),
+        elementProps: {
+          ...prevEleProps,
+          [fieldName]: {
+            ...prevEleValue,
+            ...update
+          }
+        }
+      };
+      theme = {
+        ...prevTheme,
+        theme: themeProps
+      };
+      break;
+    case "OTHER_PROPS_CHANGE":
+      themeProps = {
+        ...(prev || {}),
+        otherProps: {
+          ...(prev.otherProps || {}),
+          ...update
+        }
+      };
+      theme = {
+        ...prevTheme,
+        theme: themeProps
+      };
+      break;
+    case "FONT_CHANGE":
+      const {
+        elementProps = {},
+        otherProps = {}
+      } = prev;
+      const {
+        fieldType
+      } = actionData || {};
+      const fields = MAP_FIELDS[fieldType];
+      const fontFieldsUpdate = {};
+      fields?.forEach(field => {
+        const prevFieldData = elementProps[field];
+        fontFieldsUpdate[field] = {
+          ...prevFieldData,
+          ...update
+        };
+      });
+      const FONT_KEY_FOR_FIELD = MAP_FONT_FIELD_KEYS[fieldType];
+      themeProps = {
+        ...(prev || {}),
+        elementProps: {
+          ...elementProps,
+          ...fontFieldsUpdate
+        },
+        otherProps: {
+          ...otherProps,
+          [FONT_KEY_FOR_FIELD]: update?.fontFamily
+        }
+      };
+      theme = {
+        ...prevTheme,
+        theme: themeProps
+      };
+      break;
+    default:
+      theme = {
+        ...prevTheme,
+        ...(update || {})
+      };
+      break;
+  }
+  return theme;
+}
+const updateTheme = (editor, pageSt, update, actionData, triggerRender) => {
+  const {
+    pageProps
+  } = pageSt || {};
+  const {
+    theme
+  } = pageProps || {};
+  const updatedTheme = getUpdatePayload(theme, update, actionData);
+  updatePageSettings(editor, {
+    ...(pageProps || {}),
+    theme: updatedTheme
+  });
+  triggerRender();
+};
+export const useEditorTheme = () => {
+  const editor = useSlate();
+  const {
+    triggerRender
+  } = useEditorContext();
+  const {
+    element: pageSt
+  } = getPageSettings(editor) || {};
+  const {
+    pageProps
+  } = pageSt || {};
+  const {
+    theme
+  } = pageProps || {};
+  return {
+    selectedTheme: theme?.theme || defaultTheme?.theme,
+    updateTheme: (update, actionData) => updateTheme(editor, pageSt, update, actionData, triggerRender),
+    theme
+  };
+};

package/dist/Editor/hooks/useMouseMove.js

@@ -1,4 +1,4 @@
-import { useEffect, useState, createContext, useContext, useMemo, useCallback } from "react";
+import { useEffect, useState, createContext, useContext, useMemo } from "react";
 import { getSelectedText } from "../utils/helper";
 import { debounce } from "../helper";
 import { defaultFontFamilies } from "../common/FontLoader/FontList";
@@ -21,7 +21,10 @@ export const useEditorSelection = editor => {
 export const EditorProvider = ({
   editor,
   theme,
-  children
+  children,
+  openTheme = false,
+  setOpenTheme = () => {},
+  triggerRender
 }) => {
   const [previous, setPrevious] = useState("");
   const [drop, setDrop] = useState(0);
@@ -100,9 +103,12 @@ export const EditorProvider = ({
     updateDragging,
     fontFamilies,
     setFontFamilies,
+    openTheme,
+    setOpenTheme,
     activeBreakPoint,
-    setActiveBreakPoint
-  }), [path, editor?.selection, selectedPath, selectedElement, contextMenu, openAI, popupType, drop, activeBreakPoint]);
+    setActiveBreakPoint,
+    triggerRender
+  }), [path, editor?.selection, selectedPath, selectedElement, contextMenu, openAI, popupType, drop, openTheme, activeBreakPoint]);
   return /*#__PURE__*/_jsx(EditorContext.Provider, {
     value: otherValues,
     children: children
@@ -115,7 +121,13 @@ const useMouseMove = dragging => {
   const [event, setEvent] = useState({
     target: null
   });
-  const onMouseMove = useCallback(debounce(e => {
+  useEffect(() => {
+    addListener();
+    return () => {
+      removeListener();
+    };
+  }, []);
+  const onMouseMove = e => {
     if (!dragging?.id) {
       const dpath = e?.target?.closest(".dpath");
       if (dpath) {
@@ -124,14 +136,14 @@ const useMouseMove = dragging => {
         });
       }
     }
-  }, 100), [dragging]);
-  useEffect(() => {
-    document.addEventListener("mousemove", onMouseMove);
-    return () => {
-      document.removeEventListener("mousemove", onMouseMove);
-      onMouseMove.cancel(); // Cancel any pending debounced calls
-    };
-  }, [onMouseMove]);
+  };
+  const debounceMouseMove = debounce(onMouseMove, 100);
+  const addListener = () => {
+    document.addEventListener("mousemove", debounceMouseMove);
+  };
+  const removeListener = () => {
+    document.removeEventListener("mousemove", debounceMouseMove);
+  };
   return [event];
 };
 export default useMouseMove;

package/dist/Editor/hooks/useTable.js

@@ -184,7 +184,7 @@ export const TableProvider = ({
       window.removeEventListener("copy", handleCopy);
       window.removeEventListener("cut", handleCut);
     };
-  }, [tableSelection, editor]);
+  }, [tableSelection, editor, tableSelection]);
 
   // useEffect(() => {
   //   selectFirstCell(tablePath, editor, updateTableSelection);

package/dist/Editor/plugins/withEmbeds.js

@@ -1,5 +1,5 @@
 import { Transforms, Path, Node } from "slate";
-const AvoidCopying = ["headingOne", "headingTwo", "headingThree", "blockquote"];
+const AvoidCopying = ["headingOne", "headingTwo", "headingThree", "headingFour", "headingFive", "headingSix", "paragraphOne", "paragraphTwo", "paragraphThree", "blockquote"];
 const BlockTypes = ["grid"];
 const withEmbeds = editor => {
   const {

package/dist/Editor/plugins/withHTML.js

@@ -30,6 +30,8 @@ const parseCopiedHTML = html => {
 
   // claude.ai, copy list inbetween, some li tags are not wrapped with ul or ol
   parsed.querySelectorAll("li").forEach(li => {
+    li.innerHTML = li.innerHTML.replace(/^\n+|\n+$/g, ""); // Removes leading and trailing newlines
+
     // 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
@@ -55,7 +57,7 @@ const loopChildren = (children = [], defaultInsert) => {
   }
   return defaultInsert;
 };
-const getCurrentElement = editor => {
+export const getCurrentElement = editor => {
   try {
     if (editor.selection) {
       return Node.parent(editor, editor?.selection?.anchor?.path);
@@ -236,9 +238,9 @@ const withHtml = editor => {
       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;
-        }
+        // if (editor.isChatEditor) {
+        //   return;
+        // }
         const table = rootElement.querySelector("table");
         const colGrp = table.querySelector("colgroup");
         if (colGrp) {
@@ -260,15 +262,18 @@ const withHtml = editor => {
         return;
       }
       const formattedFragment = normalizeFragment ? normalizeFragment(fragment) : fragment;
-      let is_img_table = false;
-      formattedFragment.map(f => {
-        if (f.type === "image" || f?.type?.includes("table")) {
-          is_img_table = true;
-        }
-      });
-      if (editor.isChatEditor && is_img_table) {
-        return;
-      }
+
+      // let is_img_table = false;
+      // formattedFragment.map((f) => {
+      //   if (f.type === "image" || f?.type?.includes("table")) {
+      //     is_img_table = true;
+      //   }
+      // });
+
+      // if (editor.isChatEditor && is_img_table) {
+      //   return;
+      // }
+
       if (isTitlePath && isNonText) {
         insertAtNextNode(editor, formattedFragment);
         return;

package/dist/Editor/plugins/withLayout.js

@@ -27,7 +27,8 @@ const ORDERS_LAYOUT_VALIDATIONS = {
 };
 const withLayout = editor => {
   const {
-    normalizeNode
+    normalizeNode,
+    translation
   } = editor;
   editor.normalizeNode = ([node, path]) => {
     if (path.length === 0) {
@@ -39,7 +40,7 @@ const withLayout = editor => {
           const title = {
             type: "title",
             children: [{
-              text: "Untitled"
+              text: translation ? translation("Untitled") : "Untitled"
             }]
           };
           Transforms.insertNodes(editor, title, {

package/dist/Editor/plugins/withTable.js

@@ -1,6 +1,6 @@
 import { Editor, Range, Point, Element, Transforms, Node } from "slate";
 import { TableUtil, createTableCell } from "../utils/table";
-const NON_DELETABLE_BLOCKS = ["table-cell", "carousel-item"];
+const NON_DELETABLE_BLOCKS = ["table-cell", "carousel-item", "page-settings"];
 const withTable = editor => {
   const {
     deleteBackward,

package/dist/Editor/theme/ThemeList.js

@@ -1,181 +1,58 @@
-import { MenuItem, Select, useTheme } from "@mui/material";
-import { fontOptions } from "../utils/font";
-import { toolbarGroups } from "../Toolbar/toolbarGroups";
+import { Box, MenuItem, Select } from "@mui/material";
+import { defaultTheme } from ".";
+import { useEditorTheme } from "../hooks/useEditorTheme";
+import { useEffect, useState } from "react";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
-const themes = [{
-  label: "Theme 1",
-  colors: ["#c90c1f", "#ff5d05"]
-}, {
-  label: "Theme 2",
-  colors: ["#4c0be3", "#43f7ee"]
-}, {
-  label: "Theme 3",
-  colors: ["#22f20f", "#fff705"]
-}];
-const allTools = toolbarGroups.flat();
-function ThemeList(props) {
+function ThemeList({
+  editor,
+  services = () => {}
+}) {
+  const [themes, setThemes] = useState([]);
+  const [loading, setLoading] = useState(false);
+  console.log("loading", loading);
+  const getThemesList = async () => {
+    setLoading(true);
+    try {
+      const result = await services("getThemes", {});
+      setThemes(result?.data || []);
+    } catch (err) {
+      console.log(err);
+    }
+    setLoading(false);
+  };
   const {
-    selectedTheme,
-    setSelectedTheme
-  } = props;
-  const fontWeight = allTools.find(f => f.format === "fontWeight");
-  const fontStyles = [{
-    text: "Bold",
-    value: "bold",
-    styleField: "fontWeight"
-  }, {
-    text: "Italic",
-    value: "italic",
-    styleField: "fontStyle"
-  }
-  // {
-  //   text: "Underline",
-  //   value: "underline",
-  //   styleField: "textDecoration",
-  // },
-  // {
-  //   text: "Line through",
-  //   value: "line-through",
-  //   styleField: "textDecoration",
-  // },
-  ];
-
-  const theme = useTheme();
-  const colorVars = theme?.vars?.colors || {};
-  const handleTypographyTheme = (key, value, elementType) => {
-    setSelectedTheme(prev => {
-      const newValue = {
-        ...prev,
-        typography: {
-          ...(prev.typography || {}),
-          [elementType]: {
-            ...(prev?.typography?.[elementType] || {}),
-            [key]: value
-          }
-        }
-      };
-      if (!value) {
-        delete newValue?.typography?.[elementType]?.[key];
-      }
-      return newValue;
-    });
+    updateTheme
+  } = useEditorTheme();
+  useEffect(() => {
+    getThemesList();
+  }, []);
+  const handleThemeChange = e => {
+    const {
+      value
+    } = e.target;
+    const selectedTheme = themes.find(t => t.id === value) || defaultTheme;
+    updateTheme(selectedTheme, "THEME_CHANGE");
   };
-  return /*#__PURE__*/_jsxs("div", {
-    children: [themes.map((theme, i) => {
-      return /*#__PURE__*/_jsxs("button", {
-        style: {
-          margin: "10px"
-        },
-        onClick: () => setSelectedTheme(prev => ({
-          ...prev,
-          colors: theme.colors
-        })),
-        children: [theme.label, /*#__PURE__*/_jsx("div", {
-          children: theme.colors.map((c, j) => {
-            return /*#__PURE__*/_jsx("div", {
-              style: {
-                width: "20px",
-                height: "20px",
-                background: c,
-                margin: "10px"
-              }
-            }, j);
-          })
-        })]
-      }, i);
-    }), /*#__PURE__*/_jsxs("div", {
-      children: ["Heading 1 Font Family", /*#__PURE__*/_jsx(Select
-      // value={""}
-      , {
-        label: "Font Family",
-        onChange: e => {
-          handleTypographyTheme("fontFamily", e.target.value, "h1");
-        },
-        children: fontOptions.map((font, i) => {
-          const {
-            text,
-            value
-          } = font;
-          return /*#__PURE__*/_jsx(MenuItem, {
-            value: value,
-            children: text
-          }, i);
-        })
-      }), "Font Weight", /*#__PURE__*/_jsx(Select
-      // value={""}
-      , {
-        label: "Font Weight",
-        onChange: e => {
-          handleTypographyTheme("fontWeight", e.target.value, "h1");
-        },
-        children: fontWeight.options.map((option, i) => {
-          const {
-            text,
-            value
-          } = option;
-          return /*#__PURE__*/_jsx(MenuItem, {
-            value: value,
-            children: text
-          }, i);
-        })
-      }), /*#__PURE__*/_jsx("input", {
-        type: "number",
-        placeholder: "font size",
-        onChange: e => {
-          handleTypographyTheme("fontSize", e.target.value, "h1");
-        }
-      }), /*#__PURE__*/_jsxs("div", {
-        children: ["Text", /*#__PURE__*/_jsx("br", {}), "Theme color", Object.values(colorVars).map((colorVar, i) => {
-          return /*#__PURE__*/_jsx("button", {
-            style: {
-              width: "20px",
-              height: "20px",
-              background: colorVar,
-              margin: "10px",
-              outline: "none"
-            },
-            onClick: () => handleTypographyTheme("color", colorVar, "h1")
-          }, i);
-        }), "normal color", /*#__PURE__*/_jsx("button", {
-          style: {
-            width: "20px",
-            height: "20px",
-            background: "#ff00e1",
-            margin: "10px",
-            outline: "none"
-          },
-          onClick: () => handleTypographyTheme("color", "#ff00e1", "h1")
-        })]
-      }), /*#__PURE__*/_jsxs("div", {
-        children: ["Font styles", fontStyles.map((option, i) => {
-          const styles = selectedTheme?.typography?.h1 || {};
-          const {
-            text,
-            value,
-            styleField
-          } = option;
-          return /*#__PURE__*/_jsxs("button", {
-            onClick: () => {
-              handleTypographyTheme(styleField, styles[styleField] === value ? null : value, "h1");
-            },
-            children: [text, " ", styles[styleField] === value]
-          }, i);
-        })]
-      }), /*#__PURE__*/_jsx("input", {
-        type: "number",
-        placeholder: "Margin text Spacing",
-        onChange: e => {
-          handleTypographyTheme("letterSpacing", e.target.value, "h1");
-        }
-      }), /*#__PURE__*/_jsx("input", {
-        type: "number",
-        placeholder: "Line spacing",
-        onChange: e => {
-          handleTypographyTheme("lineHeight", e.target.value, "h1");
-        }
+  return /*#__PURE__*/_jsx(Box, {
+    sx: {
+      padding: "10px",
+      background: "#efefef",
+      borderRadius: "6px"
+    },
+    children: /*#__PURE__*/_jsxs(Select, {
+      onChange: handleThemeChange,
+      defaultValue: 0,
+      children: [/*#__PURE__*/_jsx(MenuItem, {
+        value: 0,
+        children: "Default Theme"
+      }), themes.map((theme, i) => {
+        return /*#__PURE__*/_jsx(MenuItem, {
+          value: theme?.id,
+          children: theme?.name
+        }, i);
       })]
-    })]
+    })
   });
 }
 export default ThemeList;