@flozy/editor 11.2.2 → 11.2.4

package/dist/Editor/Elements/Embed/Image.js

@@ -1,10 +1,17 @@
-import React, { useEffect, useState } from "react";
+import React, { useEffect, useRef, useState } from "react";
 import { useSlateStatic, ReactEditor } from "slate-react";
 import { Node, Transforms, Editor } from "slate";
 import AspectRatioIcon from "@mui/icons-material/AspectRatio";
+import IconButton from "@mui/material/IconButton";
+import Tooltip from "@mui/material/Tooltip";
+import Box from "@mui/material/Box";
+import useTheme from "@mui/material/styles/useTheme";
+import useMediaQuery from "@mui/material/useMediaQuery";
+import Grid from "@mui/material/Grid";
+import CircularProgress from "@mui/material/CircularProgress";
+import HighlightOffRoundedIcon from "@mui/icons-material/HighlightOffRounded";
 import useResize from "../../utils/customHooks/useResize";
 import EmbedPopup from "./EmbedPopup";
-import { IconButton, Tooltip, Box, useTheme, useMediaQuery } from "@mui/material";
 import { LinkIcon } from "../../common/iconslist";
 import { useEditorContext } from "../../hooks/useMouseMove";
 import { getTRBLBreakPoints, getBreakPointsValue, groupByBreakpoint } from "../../helper/theme";
@@ -16,8 +23,11 @@ import { handleLinkType } from "../../utils/helper";
 import { wrapThemeBreakpoints } from "../FreeGrid/breakpointConstants";
 import useCommonStyle from "../../commonStyle";
 import SettingsIcon from "../../assets/svg/SettingsIcon";
+import ImageSelector from "../../common/ImageSelector/ImageSelector";
+import { buildUpdateData } from "../../service/fileupload";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
 const ToolBar = ({
   isEmpty,
   onSettings,
@@ -67,27 +77,112 @@ const ImageContent = props => {
     objectFit,
     webAddress,
     readOnly,
-    setOpenSettings,
+    // setOpenSettings, // Unused - component uses internal state
     handleImageClick,
     onTouchEnd,
     path,
     theme,
     classes,
-    translation
+    translation,
+    setUploadPopupOpen,
+    uploadStatus,
+    setUploadStatus,
+    uniqueId,
+    uploadTerminator,
+    editor
   } = props;
-  return !url ? !readOnly ? /*#__PURE__*/_jsxs(Box, {
+  const cancelUpload = e => {
+    e.stopPropagation();
+    uploadTerminator(uniqueId, setUploadStatus);
+    Transforms.setNodes(editor, {
+      isUpload: false,
+      isUploading: false,
+      file: null
+    }, {
+      at: path
+    });
+  };
+  return !url ? !readOnly ? /*#__PURE__*/_jsx(Box, {
     component: "button",
     className: "element-empty-btn",
     contentEditable: false,
     onClick: () => {
-      setOpenSettings(true);
+      if (!uploadStatus?.isUploading) setUploadPopupOpen(true);
     },
     sx: {
       ...classes.emptyThumbBtn
     },
-    children: [/*#__PURE__*/_jsx(Icon, {
-      icon: "image"
-    }), translation("Add Image")]
+    children: uploadStatus?.isUploading ? /*#__PURE__*/_jsxs(Grid, {
+      container: true,
+      direction: "row",
+      style: {
+        display: "flex",
+        justifyContent: "space-between"
+      },
+      children: [/*#__PURE__*/_jsx(Grid, {
+        style: {
+          width: "80%"
+        },
+        children: /*#__PURE__*/_jsxs(Grid, {
+          container: true,
+          direction: "row",
+          sx: {
+            justifyContent: "flex-start",
+            alignItems: "center"
+            // gap: 1,
+          },
+          children: [/*#__PURE__*/_jsx(Grid, {
+            children: /*#__PURE__*/_jsx(Icon, {
+              icon: "image"
+            })
+          }), /*#__PURE__*/_jsx(Grid, {
+            style: {
+              width: "80%"
+            },
+            children: /*#__PURE__*/_jsxs(Box, {
+              display: "flex",
+              flexDirection: "column",
+              alignItems: "flex-start",
+              justifyContent: "flex-start",
+              children: [/*#__PURE__*/_jsx(Box, {
+                className: "truncateText",
+                children: uploadStatus?.fileName
+              }), /*#__PURE__*/_jsxs(Box, {
+                display: "flex",
+                alignItems: "center",
+                gap: 1,
+                marginTop: 1,
+                children: [/*#__PURE__*/_jsx(Box, {
+                  children: uploadStatus?.fileSize
+                }), /*#__PURE__*/_jsx(CircularProgress, {
+                  variant: "determinate",
+                  value: uploadStatus?.uploadPercentage ?? 0,
+                  className: "circularProgress-cls",
+                  size: 15,
+                  thickness: 8
+                }), /*#__PURE__*/_jsx(Box, {
+                  children: `${uploadStatus?.uploadPercentage?.toFixed(0) ?? 0}%`
+                })]
+              })]
+            })
+          })]
+        })
+      }), /*#__PURE__*/_jsx(Grid, {
+        children: /*#__PURE__*/_jsx(HighlightOffRoundedIcon, {
+          className: "uploadCancel",
+          sx: {
+            cursor: "pointer"
+          },
+          onClick: e => {
+            cancelUpload(e);
+          }
+        })
+      })]
+    }) : /*#__PURE__*/_jsxs(_Fragment, {
+      children: [/*#__PURE__*/_jsx(Icon, {
+        icon: "image"
+      }), translation("Add Image")]
+    })
   }) : /*#__PURE__*/_jsxs(Box, {
     sx: {
       color: "#64748B !important",
@@ -143,11 +238,20 @@ const Image = props => {
     webAddress,
     isNewTab,
     linkType,
-    framePos
+    framePos,
+    file,
+    isUploading,
+    uniqueId,
+    fromFreeGrid
   } = element;
   const {
     readOnly,
-    translation
+    translation,
+    services,
+    uploadFile,
+    resumeUploadState,
+    uploadTerminator,
+    isUploadInProgress = () => false
   } = customProps;
   const {
     vertical,
@@ -162,6 +266,13 @@ const Image = props => {
   const path = ReactEditor.findPath(editor, element);
   const [openNav, setOpenNav] = useState(false);
   const isEmpty = !url && !readOnly;
+  const [openUploadPopup, setUploadPopupOpen] = useState(false);
+  const [uploadStatus, setUploadStatus] = useState({
+    isUploading: false,
+    uploadPercentage: 0
+  });
+  const xhrRef = useRef(null);
+  const trackingProcessedRef = useRef(false);
   const getSize = () => {
     if (element?.size === undefined) {
       return {
@@ -217,32 +328,178 @@ const Image = props => {
       console.log(err);
     }
   };
+  const noUploadTracks = () => {
+    setUploadStatus({
+      isUploading: false,
+      uploadPercentage: 0,
+      fileName: null,
+      fileSize: null
+    });
+    Transforms.setNodes(editor, {
+      isUploading: false
+    }, {
+      at: path
+    });
+  };
+  useEffect(() => {
+    const isUploading = isUploadInProgress(uniqueId);
+    if (fromFreeGrid) {
+      if (isUploading) {
+        resumeUploadState(uniqueId, setUploadStatus, onSave, noUploadTracks, "image");
+      } else {
+        if (!isUploading) {
+          handleImageUpload({
+            file: file
+          });
+        }
+      }
+    }
+  }, [uniqueId, isUploading, file]);
   useEffect(() => {
     if (editor && ele && ele[1] !== undefined) {
       const dom = ReactEditor.toDOMNode(editor, element);
       setParentDOM(dom);
       onLoad(getSize());
     }
+    if (uniqueId && isUploading) {
+      resumeUploadState(uniqueId, setUploadStatus, onSave, noUploadTracks, "image");
+    } else if (file && isUploading) {
+      handleImageUpload({
+        file: file
+      });
+    }
   }, []);
   const onSettings = () => {
     setOpenSettings(true);
   };
-  const onSave = data => {
+  const onSave = async (data, isUploadCompletion = false) => {
+    // Determine if this is from recent uploads or choose assets - check both object and string data
+    const isFromRecentUploads = typeof data === 'object' && data?.source === "recent" || typeof data === 'string' && data.includes('recent');
+
+    // Only track if this is NOT an upload completion AND we haven't processed tracking yet
+    // Upload completions will be tracked by the uploadFile function in main app
+    // Also skip tracking if the source is "recent" (selected from recent uploads or choose assets)
+    if (data && !isUploadCompletion && !trackingProcessedRef.current && !isFromRecentUploads) {
+      // Mark tracking as processed
+      trackingProcessedRef.current = true;
+      try {
+        // Import utility functions
+        const {
+          getImageMimeTypeFromExtension,
+          extractFileInfoFromUrl
+        } = await import("../../utils/attachments");
+
+        // Extract URL from data (could be string or object)
+        const urlToTrack = typeof data === 'string' ? data : data?.embedURL || data?.url;
+        if (urlToTrack) {
+          // Extract filename and extension from URL
+          const {
+            filename,
+            extension
+          } = extractFileInfoFromUrl(urlToTrack);
+          const mimeType = getImageMimeTypeFromExtension(extension);
+          const trackingData = {
+            file_url: urlToTrack,
+            name: filename || 'Untitled Image',
+            mime_type: mimeType,
+            resource_type: "flozy_editor",
+            resource_id: customProps?.page_id,
+            status: 1,
+            created_on: new Date().toISOString()
+          };
+
+          // Try main app service first, fallback to direct implementation
+          if (customProps.services && typeof customProps.services === 'function') {
+            try {
+              // const result = await customProps.services('trackEditorUploads', {
+              await customProps.services('trackEditorUploads', {
+                fileData: trackingData,
+                category: 'image'
+              });
+            } catch (error) {
+              console.warn('Main app service failed, falling back to direct tracking:', error);
+            }
+          }
+        }
+      } catch (error) {
+        console.error("Failed to track image URL:", error);
+      }
+    } else {}
     try {
-      const updateData = {
-        ...data
-      };
-      delete updateData.children;
-      Transforms.setNodes(editor, {
-        ...updateData
-      }, {
-        at: path
-      });
-      onClose();
+      if (!data?.url?.file) {
+        const updateData = buildUpdateData(data, url);
+        delete updateData.children;
+        Transforms.select(editor, path);
+        ReactEditor.focus(editor);
+        const finalUpdateData = {
+          ...updateData,
+          isUpload: false,
+          isUploading: false,
+          file: null,
+          source: data?.source
+        };
+        Transforms.setNodes(editor, finalUpdateData, {
+          at: path
+        });
+        onClose();
+      } else {
+        handleImageUpload({
+          file: data?.url?.file,
+          isUpload: true,
+          setUploadStatus,
+          services: services
+        });
+        onClose();
+        onSave("", true); // Mark as upload completion
+      }
     } catch (err) {
       console.log(err);
     }
   };
+  const handleImageUpload = async uploadProp => {
+    try {
+      // Check if this is a recent upload (has source "recent") or manual URL entry (isUpload === false)
+      if (uploadProp?.isUpload === false || uploadProp?.source === "recent") {
+        // Pass the full uploadProp object to preserve source information
+        onSave(uploadProp, false); // Manual URL entry or recent upload, not upload completion
+      } else {
+        // Reset tracking flag for new upload
+        trackingProcessedRef.current = false;
+        const isAlreadyUploading = isUploadInProgress(uniqueId);
+        let result = {};
+        if (uploadProp?.file && !isAlreadyUploading) {
+          result = await services("uploadFile", uploadProp?.file);
+        }
+        const uploadUrl = result?.data?.[0];
+        if (uploadUrl) {
+          const id = !uniqueId ? crypto?.randomUUID() : uniqueId;
+          const fileEntry = {
+            ...uploadProp,
+            xhrRef,
+            presidnedURL: uploadUrl,
+            status: "uploading"
+          };
+          uploadFile(id, fileEntry, setUploadStatus, onSave, "image");
+          if (!fromFreeGrid) {
+            Transforms.setNodes(editor, {
+              uniqueId: id,
+              isUploading: true
+            }, {
+              at: path
+            });
+          } else {
+            Transforms.setNodes(editor, {
+              isUploading: true
+            }, {
+              at: path
+            });
+          }
+        }
+      }
+    } catch (error) {
+      console.log(error);
+    }
+  };
   const onClose = () => {
     setOpenSettings(false);
   };
@@ -252,8 +509,9 @@ const Image = props => {
     });
   };
   const onPosChange = data => {
-    onSave(data);
+    onSave(data, false); // Manual position change, not upload completion
   };
+
   const getWidth = () => {
     if (resizing) {
       return {
@@ -324,7 +582,16 @@ const Image = props => {
         path: path,
         theme: theme,
         classes: classes,
-        translation: translation
+        translation: translation,
+        setUploadPopupOpen: setUploadPopupOpen,
+        openUploadPopup: openUploadPopup,
+        uploadStatus: uploadStatus,
+        setUploadStatus: setUploadStatus,
+        xhrRef: xhrRef,
+        onClose: onClose,
+        uniqueId: uniqueId,
+        uploadTerminator: uploadTerminator,
+        editor: editor
       }), url && frames[frame] ? /*#__PURE__*/_jsx(Box, {
         component: "div",
         className: "image-frame",
@@ -365,14 +632,28 @@ const Image = props => {
           linkType,
           webAddress: navValue,
           isNewTab: openInNewTab
-        });
+        }, false); // Manual link setting, not upload completion
+
         setOpenNav(false);
       },
       navType: linkType,
       navValue: webAddress,
       openInNewTab: isNewTab,
       customProps: customProps
-    }) : null]
+    }) : null, openUploadPopup && /*#__PURE__*/_jsx(ImageSelector, {
+      open: true,
+      title: "Image",
+      onClose: () => setUploadPopupOpen(false),
+      customProps: customProps,
+      onSelectImage: img => {
+        handleImageUpload(img);
+        setUploadPopupOpen(false);
+      },
+      openUploadPopup: openUploadPopup,
+      setUploadPopupOpen: setUploadPopupOpen,
+      setUploadStatus: setUploadStatus,
+      xhrRef: xhrRef
+    })]
   });
 };
 export default Image;