@flozy/editor 11.0.6 → 11.0.8

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

@@ -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);
@@ -98,8 +101,11 @@ export const EditorProvider = ({
     setOpenAI,
     updateDragging,
     fontFamilies,
-    setFontFamilies
-  }), [path, editor?.selection, selectedPath, selectedElement, contextMenu, openAI, popupType, drop]);
+    setFontFamilies,
+    openTheme,
+    setOpenTheme,
+    triggerRender
+  }), [path, editor?.selection, selectedPath, selectedElement, contextMenu, openAI, popupType, drop, openTheme]);
   return /*#__PURE__*/_jsx(EditorContext.Provider, {
     value: otherValues,
     children: children

package/dist/Editor/hooks/useTable.js

@@ -25,6 +25,63 @@ import { createCopiedTableStructure, getRectangleBounds, tableNodeToDom } from "
 // };
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
+function moveToAdjacentTableCell(editor, reverse = false, otherProps, tableSelection, updateTableSelection) {
+  try {
+    const {
+      startCellPath,
+      endCellPath
+    } = tableSelection;
+    if (startCellPath && startCellPath.toString() === endCellPath.toString()) {
+      const {
+        tableNode,
+        tablePath
+      } = otherProps;
+      const cellPath = startCellPath.slice(tablePath.length - 1);
+      const rows = tableNode.children;
+      const currentRowIndex = cellPath[1];
+      const currentColIndex = cellPath[2];
+      const numRows = rows.length;
+      const numCols = rows[0]?.children?.length || 0;
+
+      // Calculate new indices
+      let newRowIndex = currentRowIndex;
+      let newColIndex = currentColIndex;
+      if (reverse) {
+        // ALT + TAB: Go to previous cell
+        if (currentColIndex > 0) {
+          newColIndex--;
+        } else if (currentRowIndex > 0) {
+          newRowIndex--;
+          newColIndex = rows[newRowIndex].children.length - 1;
+        } else {
+          return; // At first cell, do nothing
+        }
+      } else {
+        // TAB: Go to next cell
+        if (currentColIndex < numCols - 1) {
+          newColIndex++;
+        } else if (currentRowIndex < numRows - 1) {
+          newRowIndex++;
+          newColIndex = 0;
+        } else {
+          return; // At last cell, do nothing
+        }
+      }
+
+      const nextCellPath = [...tablePath, newRowIndex, newColIndex];
+
+      // Move the selection into the next cell
+      Transforms.select(editor, Editor.start(editor, nextCellPath));
+      updateTableSelection({
+        startCellPath: nextCellPath,
+        endCellPath: nextCellPath,
+        isDragging: false
+      });
+    }
+  } catch (err) {
+    console.log("Error on pressing tab in table", err);
+  }
+}
 const handleDragEnd = (dragData, editor, resetAll) => {
   const {
     active,
@@ -127,7 +184,11 @@ export const TableProvider = ({
     let isTextSelected;
     const handleKeyDown = event => {
       const isCutKey = (event.ctrlKey || event.metaKey) && event.key === "x";
-      if (isCutKey) {
+      if (event.key === "Tab") {
+        event.preventDefault();
+        const isReverse = event.shiftKey;
+        moveToAdjacentTableCell(editor, isReverse, otherProps, tableSelection, updateTableSelection);
+      } else if (isCutKey) {
         isTextSelected = isHavingSelection(editor);
       } else if (event.key === "Backspace") {
         const selectedCells = getSelectedCells();

package/dist/Editor/hooks/useThemeValues.js

@@ -0,0 +1,63 @@
+import { useEffect, useState } from "react";
+import { getElementProperty } from "../helper/theme";
+import { ReactEditor } from "slate-react";
+import { Node } from "slate";
+import { useEditorTheme } from "./useEditorTheme";
+function useThemeValues() {
+  return {};
+}
+export default useThemeValues;
+export function useButtonStyle(value, key, element) {
+  const [buttonStyle, setButtonStyle] = useState(value);
+  const {
+    selectedTheme
+  } = useEditorTheme();
+  const themeBtnProps = selectedTheme?.elementProps?.button || {};
+  useEffect(() => {
+    const color = getColorValue(value, key, element, themeBtnProps);
+    setButtonStyle({
+      color
+    });
+  }, [value, key, element]);
+  return {
+    buttonStyle
+  };
+}
+const DEFAULT_MAP_THEMES = {
+  textColor: "color",
+  bgColor: "backgroundColor"
+};
+const hoverMap = (theme, format) => {
+  const hover = theme?.hover || {};
+  const key = DEFAULT_MAP_THEMES[format];
+  return hover[key];
+};
+const MAP_THEME_KEYS = {
+  ...DEFAULT_MAP_THEMES,
+  textColorHover: hoverMap,
+  bgColorHover: hoverMap
+};
+const getColorValue = (val, key, elementProps, themeBtnProps) => {
+  const themeKey = MAP_THEME_KEYS[key];
+  if (elementProps?.type === "button" && !val && themeKey) {
+    if (typeof themeKey === "string") {
+      return themeBtnProps[themeKey];
+    } else {
+      return themeKey(themeBtnProps, key);
+    }
+  }
+  return val;
+};
+export function getButtonElementStyle(editor, element, stylePropertyName) {
+  try {
+    const path = ReactEditor.findPath(editor, element);
+    if (path?.length) {
+      const currentEle = Node.get(editor, path);
+      const dom = ReactEditor.toDOMNode(editor, currentEle);
+      const editorBtn = dom?.querySelector(".button.theme-element");
+      return getElementProperty(editorBtn, stylePropertyName);
+    }
+  } catch (err) {
+    // console.log(err);
+  }
+}

package/dist/Editor/plugins/withEmbeds.js

@@ -1,5 +1,7 @@
 import { Transforms, Path, Node } from "slate";
-const AvoidCopying = ["headingOne", "headingTwo", "headingThree", "blockquote"];
+import { isListItem } from "../utils/helper";
+import { customizeEnterEvent } from "../utils/events";
+const AvoidCopying = ["headingOne", "headingTwo", "headingThree", "headingFour", "headingFive", "headingSix", "paragraphOne", "paragraphTwo", "paragraphThree", "blockquote"];
 const BlockTypes = ["grid"];
 const withEmbeds = editor => {
   const {
@@ -53,6 +55,15 @@ const withEmbeds = editor => {
   };
   editor.insertBreak = (...args) => {
     try {
+      const ele = isListItem(editor);
+      if (ele && ele[0]) {
+        const {
+          breakNext
+        } = customizeEnterEvent(editor, ele);
+        if (breakNext) {
+          return;
+        }
+      }
       const parentPath = Path.parent(editor.selection.focus.path);
       const parentNode = Node.get(editor, parentPath);
       if (editor.isVoid(parentNode)) {

package/dist/Editor/plugins/withHTML.js

@@ -3,7 +3,7 @@ import deserialize from "../helper/deserialize";
 import { decodeAndParseBase64 } from "../utils/helper";
 import convertMDToHTML from "../helper/markdown";
 const avoidDefaultInsert = ["table", "grid"];
-const NON_TEXT_TAGS = ["ol", "ul", "img", "table", "video", "a", "button", "GOOGLE-SHEETS-HTML-ORIGIN"];
+const NON_TEXT_TAGS = ["ol", "ul", "img", "table", "video", "a", "button", "GOOGLE-SHEETS-HTML-ORIGIN", "hr"];
 const ALLOWED_TEXT_NODES = ["paragraph", "title", "headingOne", "headingTwo", "headingThree", "headingFour", "headingFive", "headingSix"];
 const parseCopiedHTML = html => {
   const parsed = new DOMParser().parseFromString(html, "text/html");
@@ -31,6 +31,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
@@ -56,7 +58,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);
@@ -151,6 +153,52 @@ const getFocusedNode = (editor, nodeType = "") => {
   }
 };
 const voidTypes = ["image", "page-settings"];
+
+// 🧠 Split the fragment into first text and rest
+const splitFragment = fragment => {
+  let found = false;
+  let firstText = "";
+  const rest = [];
+  for (const node of fragment) {
+    if (found) {
+      rest.push(node);
+      continue;
+    }
+    const textNodeEntry = [...Node.texts(node)].find(([n]) => n.text.trim().length > 0);
+    if (textNodeEntry) {
+      const [textNode, path] = textNodeEntry;
+      firstText = textNode.text;
+
+      // Remove the first text node from the node
+      const cloned = JSON.parse(JSON.stringify(node));
+      let pointer = cloned;
+      for (let i = 0; i < path.length - 1; i++) {
+        pointer = pointer.children[path[i]];
+      }
+
+      // Remove the first text portion or replace with remaining text
+      const index = path[path.length - 1];
+      // const original = pointer.children[index];
+      // const remainingText = original.text.slice(firstText.length);
+
+      // if (remainingText) {
+      //   pointer.children[index] = { ...original, text: remainingText };
+      // } else {
+      //   pointer.children.splice(index, 1);
+      // }
+
+      pointer.children.splice(index, 1);
+      if (cloned.children.length > 0) {
+        rest.push(cloned);
+      }
+      found = true;
+    } else {
+      rest.push(node); // fallback
+    }
+  }
+
+  return [firstText, rest];
+};
 const withHtml = editor => {
   const {
     insertData,
@@ -278,7 +326,14 @@ const withHtml = editor => {
         const firstNodePasted = formattedFragment[0];
         const isAllowedTextNode = ALLOWED_TEXT_NODES.includes(firstNodePasted?.type || "");
         if (isAllowedTextNode) {
-          Transforms.insertFragment(editor, formattedFragment);
+          const [firstText, remainingFragment] = splitFragment(fragment);
+          Transforms.insertFragment(editor, [{
+            text: firstText
+          }]);
+          insertAtNextNode(editor, remainingFragment);
+          if (editor.getTitleSaveData) {
+            editor.getTitleSaveData(firstText);
+          }
         } else {
           insertAtNextNode(editor, formattedFragment);
         }

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/service/fileupload.js

@@ -1,3 +1,4 @@
+import { Transforms } from "slate";
 export const uploadFile = async (formData, props) => {
   try {
     const response = await fetch(`${props.API_HOST}/general/notes/file_upload`, {
@@ -13,4 +14,73 @@ export const uploadFile = async (formData, props) => {
     console.log(err);
     return err;
   }
+};
+export const formatFileSize = bytes => {
+  const MB = bytes / (1024 * 1024);
+  if (MB < 100) {
+    return `${MB.toFixed(2)} MB`;
+  } else {
+    const GB = MB / 1024;
+    return `${GB.toFixed(2)} GB`;
+  }
+};
+export const insertUploadStatusNodeForAttachment = (editor, file) => {
+  const uploadId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const node = {
+    type: getFileTypeFromName(file?.name),
+    url: "",
+    fileName: file?.name,
+    uploadId,
+    file: file,
+    isUploading: true,
+    isUpload: true,
+    fileSize: file?.size,
+    children: [{
+      text: ""
+    }]
+  };
+  Transforms.insertNodes(editor, node);
+  return uploadId;
+};
+export const getFileTypeFromName = fileName => {
+  const extension = fileName.split(".").pop()?.toLowerCase();
+  if (!extension) return "unknown";
+  switch (extension) {
+    case "pdf":
+      return "pdf";
+    case "doc":
+    case "docx":
+    case "rtf":
+    case "txt":
+    case "pages":
+      return "doc";
+    case "xls":
+    case "xlsx":
+    case "csv":
+    case "numbers":
+      return "xls";
+    case "ppt":
+    case "pptx":
+    case "key":
+      return "ppt";
+    default:
+      return "docs";
+  }
+};
+export const buildUpdateData = (data, url) => {
+  if (typeof data === "string") {
+    return {
+      url: data
+    };
+  }
+  if (typeof data?.url?.embedURL === "string") {
+    return {
+      url: data.url.embedURL
+    };
+  }
+  const resolvedUrl = data?.url && data.url !== "none" ? data.url : typeof url === "string" ? url : "";
+  return {
+    ...data,
+    url: resolvedUrl
+  };
 };