@elementor/editor-elements 3.33.0-271 → 3.33.0-273

package/dist/index.mjs

@@ -1,5 +1,5 @@
-// src/hooks/use-element-setting.ts
-import { __privateUseListenTo as useListenTo, commandEndEvent } from "@elementor/editor-v1-adapters";
+// src/hooks/use-element-children.ts
+import { __privateUseListenTo as useListenTo, commandEndEvent, v1ReadyEvent } from "@elementor/editor-v1-adapters";
 
 // src/sync/get-container.ts
 import { __privateRunCommand as runCommand } from "@elementor/editor-v1-adapters";
@@ -16,6 +16,55 @@ var selectElement = (elementId) => {
   }
 };
 
+// src/hooks/use-element-children.ts
+function useElementChildren(elementId, childrenTypes) {
+  return useListenTo(
+    [
+      v1ReadyEvent(),
+      commandEndEvent("document/elements/create"),
+      commandEndEvent("document/elements/delete"),
+      commandEndEvent("document/elements/update"),
+      commandEndEvent("document/elements/set-settings")
+    ],
+    () => {
+      const container = getContainer(elementId);
+      const elementChildren = childrenTypes.reduce((acc, type) => {
+        acc[type] = [];
+        return acc;
+      }, {});
+      container?.children?.forEachRecursive?.(({ model, id }) => {
+        const elType = model.get("elType");
+        if (elType && elType in elementChildren) {
+          elementChildren[elType].push({ id });
+        }
+      });
+      return elementChildren;
+    },
+    [elementId]
+  );
+}
+
+// src/hooks/use-element-editor-settings.ts
+import { __privateUseListenTo as useListenTo2, windowEvent } from "@elementor/editor-v1-adapters";
+
+// src/sync/get-element-editor-settings.ts
+function getElementEditorSettings(elementId) {
+  const container = getContainer(elementId);
+  return container?.model.get("editor_settings") ?? {};
+}
+
+// src/hooks/use-element-editor-settings.ts
+var useElementEditorSettings = (elementId) => {
+  return useListenTo2(
+    windowEvent("elementor/element/update_editor_settings"),
+    () => getElementEditorSettings(elementId),
+    [elementId]
+  );
+};
+
+// src/hooks/use-element-setting.ts
+import { __privateUseListenTo as useListenTo3, commandEndEvent as commandEndEvent2 } from "@elementor/editor-v1-adapters";
+
 // src/sync/get-element-setting.ts
 var getElementSetting = (elementId, settingKey) => {
   const container = getContainer(elementId);
@@ -27,15 +76,15 @@ var getElementSettings = (elementId, settingKey) => {
 
 // src/hooks/use-element-setting.ts
 var useElementSetting = (elementId, settingKey) => {
-  return useListenTo(
-    commandEndEvent("document/elements/set-settings"),
+  return useListenTo3(
+    commandEndEvent2("document/elements/set-settings"),
     () => getElementSetting(elementId, settingKey),
     [elementId, settingKey]
   );
 };
 var useElementSettings = (elementId, settingKeys) => {
-  return useListenTo(
-    commandEndEvent("document/elements/set-settings"),
+  return useListenTo3(
+    commandEndEvent2("document/elements/set-settings"),
     () => settingKeys.reduce((settings, key) => {
       const value = getElementSetting(elementId, key);
       if (value !== null) {
@@ -47,8 +96,28 @@ var useElementSettings = (elementId, settingKeys) => {
   );
 };
 
+// src/hooks/use-parent-element.ts
+import { __privateUseListenTo as useListenTo4, commandEndEvent as commandEndEvent3 } from "@elementor/editor-v1-adapters";
+function useParentElement(elementId) {
+  return useListenTo4(
+    [commandEndEvent3("document/elements/create")],
+    () => {
+      if (!elementId) {
+        return null;
+      }
+      const extendedWindow = window;
+      const element = extendedWindow?.elementor?.getContainer?.(elementId);
+      if (!element) {
+        return null;
+      }
+      return element.parent;
+    },
+    [elementId]
+  );
+}
+
 // src/hooks/use-selected-element.ts
-import { __privateUseListenTo as useListenTo2, commandEndEvent as commandEndEvent2 } from "@elementor/editor-v1-adapters";
+import { __privateUseListenTo as useListenTo5, commandEndEvent as commandEndEvent4 } from "@elementor/editor-v1-adapters";
 
 // src/sync/get-widgets-cache.ts
 function getWidgetsCache() {
@@ -97,12 +166,12 @@ function getSelectedElements() {
 
 // src/hooks/use-selected-element.ts
 function useSelectedElement() {
-  const elements = useListenTo2(
+  const elements = useListenTo5(
     [
-      commandEndEvent2("document/elements/select"),
-      commandEndEvent2("document/elements/deselect"),
-      commandEndEvent2("document/elements/select-all"),
-      commandEndEvent2("document/elements/deselect-all")
+      commandEndEvent4("document/elements/select"),
+      commandEndEvent4("document/elements/deselect"),
+      commandEndEvent4("document/elements/select-all"),
+      commandEndEvent4("document/elements/deselect-all")
     ],
     getSelectedElements
   );
@@ -114,73 +183,6 @@ function useSelectedElement() {
   return { element, elementType };
 }
 
-// src/hooks/use-parent-element.ts
-import { __privateUseListenTo as useListenTo3, commandEndEvent as commandEndEvent3 } from "@elementor/editor-v1-adapters";
-function useParentElement(elementId) {
-  return useListenTo3(
-    [commandEndEvent3("document/elements/create")],
-    () => {
-      if (!elementId) {
-        return null;
-      }
-      const extendedWindow = window;
-      const element = extendedWindow?.elementor?.getContainer?.(elementId);
-      if (!element) {
-        return null;
-      }
-      return element.parent;
-    },
-    [elementId]
-  );
-}
-
-// src/hooks/use-element-children.ts
-import { __privateUseListenTo as useListenTo4, commandEndEvent as commandEndEvent4, v1ReadyEvent } from "@elementor/editor-v1-adapters";
-function useElementChildren(elementId, childrenTypes) {
-  return useListenTo4(
-    [
-      v1ReadyEvent(),
-      commandEndEvent4("document/elements/create"),
-      commandEndEvent4("document/elements/delete"),
-      commandEndEvent4("document/elements/update"),
-      commandEndEvent4("document/elements/set-settings")
-    ],
-    () => {
-      const container = getContainer(elementId);
-      const elementChildren = childrenTypes.reduce((acc, type) => {
-        acc[type] = [];
-        return acc;
-      }, {});
-      container?.children?.forEachRecursive?.(({ model, id }) => {
-        const elType = model.get("elType");
-        if (elType && elType in elementChildren) {
-          elementChildren[elType].push({ id });
-        }
-      });
-      return elementChildren;
-    },
-    [elementId]
-  );
-}
-
-// src/hooks/use-element-editor-settings.ts
-import { __privateUseListenTo as useListenTo5, windowEvent } from "@elementor/editor-v1-adapters";
-
-// src/sync/get-element-editor-settings.ts
-function getElementEditorSettings(elementId) {
-  const container = getContainer(elementId);
-  return container?.model.get("editor_settings") ?? {};
-}
-
-// src/hooks/use-element-editor-settings.ts
-var useElementEditorSettings = (elementId) => {
-  return useListenTo5(
-    windowEvent("elementor/element/update_editor_settings"),
-    () => getElementEditorSettings(elementId),
-    [elementId]
-  );
-};
-
 // src/sync/create-element.ts
 import { __privateRunCommandSync as runCommandSync } from "@elementor/editor-v1-adapters";
 function createElement({ containerId, model, options }) {
@@ -195,23 +197,9 @@ function createElement({ containerId, model, options }) {
   });
 }
 
-// src/sync/update-element-editor-settings.ts
-import { __privateRunCommandSync as runCommandSync2 } from "@elementor/editor-v1-adapters";
-var updateElementEditorSettings = ({
-  elementId,
-  settings
-}) => {
-  const element = getContainer(elementId);
-  if (!element) {
-    throw new Error(`Element with id ${elementId} not found`);
-  }
-  const editorSettings = element.model.get("editor_settings") ?? {};
-  element.model.set("editor_settings", { ...editorSettings, ...settings });
-  setDocumentModifiedStatus(true);
-};
-function setDocumentModifiedStatus(status) {
-  runCommandSync2("document/save/set-is-modified", { status }, { internal: true });
-}
+// src/sync/create-elements.ts
+import { undoable } from "@elementor/editor-v1-adapters";
+import { __ } from "@wordpress/i18n";
 
 // src/sync/delete-element.ts
 import { __privateRunCommand as runCommand2 } from "@elementor/editor-v1-adapters";
@@ -229,97 +217,60 @@ function deleteElement({
   });
 }
 
-// src/sync/move-element.ts
-function moveElement({ elementId, targetContainerId, options = {} }) {
-  const container = getContainer(elementId);
-  const target = getContainer(targetContainerId);
-  if (!container) {
-    throw new Error(`Element with ID "${elementId}" not found`);
-  }
-  if (!target) {
-    throw new Error(`Target container with ID "${targetContainerId}" not found`);
-  }
-  const modelToRecreate = container.model.toJSON();
-  deleteElement({
-    elementId,
-    // prevent inner history from being created
-    options: { ...options, useHistory: false }
-  });
-  const newContainer = createElement({
-    containerId: targetContainerId,
-    model: modelToRecreate,
-    // prevent inner history from being created
-    options: { edit: false, ...options, useHistory: false }
-  });
-  return newContainer;
-}
-
-// src/sync/move-elements.ts
-import { undoable } from "@elementor/editor-v1-adapters";
-import { __ } from "@wordpress/i18n";
-var moveElements = ({
-  moves: movesToMake,
+// src/sync/create-elements.ts
+var createElements = ({
+  elements,
   title,
-  subtitle = __("Elements moved", "elementor")
+  subtitle = __("Item added", "elementor")
 }) => {
-  const undoableMove = undoable(
+  const undoableCreate = undoable(
     {
-      do: ({ moves }) => {
-        const movedElements = [];
-        moves.forEach((move) => {
-          const { elementId } = move;
-          const sourceContainer = getContainer(elementId);
-          if (!sourceContainer) {
-            throw new Error(`Element with ID "${elementId}" not found`);
-          }
-          const originalContainerId = sourceContainer.parent?.id || "";
-          const originalIndex = sourceContainer.parent?.children?.indexOf(sourceContainer) ?? -1;
-          const originalPosition = {
-            elementId,
-            originalContainerId,
-            originalIndex
-          };
-          const element = moveElement({
-            ...move,
-            options: { ...move.options, useHistory: false }
+      do: ({ elements: elementsParam }) => {
+        const createdElements = [];
+        elementsParam.forEach((createParams) => {
+          const { options, ...elementParams } = createParams;
+          const element = createElement({
+            ...elementParams,
+            options: { ...options, useHistory: false }
           });
-          movedElements.push({
+          const elementId = element.id;
+          createdElements.push({
             elementId,
-            originalPosition,
-            move,
-            element
+            model: element.model?.toJSON() || {},
+            createParams: {
+              ...createParams
+            }
           });
         });
-        return { movedElements };
+        return { createdElements };
       },
-      undo: (_, { movedElements }) => {
-        [...movedElements].reverse().forEach(({ originalPosition }) => {
-          const { elementId, originalContainerId, originalIndex } = originalPosition;
-          moveElement({
+      undo: (_, { createdElements }) => {
+        [...createdElements].reverse().forEach(({ elementId }) => {
+          deleteElement({
             elementId,
-            targetContainerId: originalContainerId,
-            options: {
-              useHistory: false,
-              at: originalIndex >= 0 ? originalIndex : void 0
-            }
+            options: { useHistory: false }
           });
         });
       },
-      redo: (_, { movedElements }) => {
-        const newMovedElements = [];
-        movedElements.forEach(({ move, originalPosition }) => {
-          const element = moveElement({
-            ...move,
-            options: { ...move.options, useHistory: false }
-          });
-          newMovedElements.push({
-            elementId: move.elementId,
-            originalPosition,
-            move,
-            element
+      redo: (_, { createdElements }) => {
+        const newElements = [];
+        createdElements.forEach(({ createParams, model }) => {
+          const element = createElement({
+            containerId: createParams.containerId,
+            model,
+            options: { ...createParams.options, useHistory: false }
           });
+          const elementId = element.id;
+          const container = getContainer(elementId);
+          if (container) {
+            newElements.push({
+              elementId,
+              model: container.model.toJSON(),
+              createParams
+            });
+          }
         });
-        return { movedElements: newMovedElements };
+        return { createdElements: newElements };
       }
     },
     {
@@ -327,9 +278,23 @@ var moveElements = ({
       subtitle
     }
   );
-  return undoableMove({ moves: movesToMake });
+  return undoableCreate({ elements });
 };
 
+// src/sync/drop-element.ts
+import { __privateRunCommandSync as runCommandSync2 } from "@elementor/editor-v1-adapters";
+function dropElement({ containerId, model, options }) {
+  const container = getContainer(containerId);
+  if (!container) {
+    throw new Error(`Container with ID "${containerId}" not found`);
+  }
+  return runCommandSync2("preview/drop", {
+    container,
+    model,
+    options
+  });
+}
+
 // src/sync/duplicate-element.ts
 function duplicateElement({ elementId, options = {} }) {
   const elementToDuplicate = getContainer(elementId);
@@ -353,81 +318,15 @@ function duplicateElement({ elementId, options = {} }) {
   });
 }
 
-// src/sync/create-elements.ts
+// src/sync/duplicate-elements.ts
 import { undoable as undoable2 } from "@elementor/editor-v1-adapters";
 import { __ as __2 } from "@wordpress/i18n";
-var createElements = ({
-  elements,
-  title,
-  subtitle = __2("Item added", "elementor")
-}) => {
-  const undoableCreate = undoable2(
-    {
-      do: ({ elements: elementsParam }) => {
-        const createdElements = [];
-        elementsParam.forEach((createParams) => {
-          const { options, ...elementParams } = createParams;
-          const element = createElement({
-            ...elementParams,
-            options: { ...options, useHistory: false }
-          });
-          const elementId = element.id;
-          createdElements.push({
-            elementId,
-            model: element.model?.toJSON() || {},
-            createParams: {
-              ...createParams
-            }
-          });
-        });
-        return { createdElements };
-      },
-      undo: (_, { createdElements }) => {
-        [...createdElements].reverse().forEach(({ elementId }) => {
-          deleteElement({
-            elementId,
-            options: { useHistory: false }
-          });
-        });
-      },
-      redo: (_, { createdElements }) => {
-        const newElements = [];
-        createdElements.forEach(({ createParams, model }) => {
-          const element = createElement({
-            containerId: createParams.containerId,
-            model,
-            options: { ...createParams.options, useHistory: false }
-          });
-          const elementId = element.id;
-          const container = getContainer(elementId);
-          if (container) {
-            newElements.push({
-              elementId,
-              model: container.model.toJSON(),
-              createParams
-            });
-          }
-        });
-        return { createdElements: newElements };
-      }
-    },
-    {
-      title,
-      subtitle
-    }
-  );
-  return undoableCreate({ elements });
-};
-
-// src/sync/duplicate-elements.ts
-import { undoable as undoable3 } from "@elementor/editor-v1-adapters";
-import { __ as __3 } from "@wordpress/i18n";
 var duplicateElements = ({
   elementIds,
   title,
-  subtitle = __3("Item duplicated", "elementor")
+  subtitle = __2("Item duplicated", "elementor")
 }) => {
-  const undoableDuplicate = undoable3(
+  const undoableDuplicate = undoable2(
     {
       do: ({ elementIds: elementIdsToDuplicate }) => {
         const duplicatedElements = elementIdsToDuplicate.reduce((acc, elementId) => {
@@ -492,6 +391,192 @@ var duplicateElements = ({
   return undoableDuplicate({ elementIds });
 };
 
+// src/sync/generate-element-id.ts
+var generateElementId = () => {
+  const extendedWindow = window;
+  return extendedWindow.elementorCommon?.helpers?.getUniqueId?.() ?? `el-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+};
+
+// src/sync/get-current-document-container.ts
+function getCurrentDocumentContainer() {
+  const extendedWindow = window;
+  return extendedWindow.elementor?.documents?.getCurrent?.()?.container ?? null;
+}
+
+// src/sync/get-current-document-id.ts
+function getCurrentDocumentId() {
+  const extendedWindow = window;
+  return extendedWindow.elementor?.documents?.getCurrentId?.() ?? null;
+}
+
+// src/errors.ts
+import { createError } from "@elementor/utils";
+var ElementNotFoundError = createError({
+  code: "element_not_found",
+  message: "Element not found."
+});
+var StyleNotFoundError = createError({
+  code: "style_not_found",
+  message: "Style not found."
+});
+var ElementTypeNotExistsError = createError({
+  code: "element_type_not_exists",
+  message: "Element type does not exist."
+});
+var ElementLabelNotExistsError = createError({
+  code: "element_label_not_exists",
+  message: "Element label does not exist."
+});
+var ElementParentNotFoundError = createError({
+  code: "element_parent_not_found",
+  message: "Element parent not found."
+});
+var ElementIndexNotFoundError = createError({
+  code: "element_index_not_found",
+  message: "Element index not found."
+});
+
+// src/sync/get-element-label.ts
+function getElementLabel(elementId) {
+  if (!elementId) {
+    elementId = getSelectedElements()?.[0]?.id;
+  }
+  const container = getContainer(elementId);
+  const type = container?.model.get("widgetType") || container?.model.get("elType");
+  if (!type) {
+    throw new ElementTypeNotExistsError({ context: { elementId } });
+  }
+  const label = getWidgetsCache()?.[type]?.title;
+  if (!label) {
+    throw new ElementLabelNotExistsError({ context: { elementType: type } });
+  }
+  return label;
+}
+
+// src/sync/get-element-styles.ts
+var getElementStyles = (elementID) => {
+  const container = getContainer(elementID);
+  return container?.model.get("styles") || null;
+};
+
+// src/sync/get-elements.ts
+function getElements(root) {
+  const container = root ? getContainer(root) : getCurrentDocumentContainer();
+  if (!container) {
+    return [];
+  }
+  const children = [...container.model.get("elements") ?? []].flatMap(
+    (childModel) => getElements(childModel.get("id"))
+  );
+  return [container, ...children];
+}
+
+// src/sync/move-element.ts
+function moveElement({ elementId, targetContainerId, options = {} }) {
+  const container = getContainer(elementId);
+  const target = getContainer(targetContainerId);
+  if (!container) {
+    throw new Error(`Element with ID "${elementId}" not found`);
+  }
+  if (!target) {
+    throw new Error(`Target container with ID "${targetContainerId}" not found`);
+  }
+  const modelToRecreate = container.model.toJSON();
+  deleteElement({
+    elementId,
+    // prevent inner history from being created
+    options: { ...options, useHistory: false }
+  });
+  const newContainer = createElement({
+    containerId: targetContainerId,
+    model: modelToRecreate,
+    // prevent inner history from being created
+    options: { edit: false, ...options, useHistory: false }
+  });
+  return newContainer;
+}
+
+// src/sync/move-elements.ts
+import { undoable as undoable3 } from "@elementor/editor-v1-adapters";
+import { __ as __3 } from "@wordpress/i18n";
+var moveElements = ({
+  moves: movesToMake,
+  title,
+  subtitle = __3("Elements moved", "elementor"),
+  onMoveElements,
+  onRestoreElements
+}) => {
+  const undoableMove = undoable3(
+    {
+      do: ({ moves }) => {
+        const movedElements = [];
+        moves.forEach((move) => {
+          const { elementId } = move;
+          const sourceContainer = getContainer(elementId);
+          if (!sourceContainer) {
+            throw new Error(`Element with ID "${elementId}" not found`);
+          }
+          const originalContainerId = sourceContainer.parent?.id || "";
+          const originalIndex = sourceContainer.parent?.children?.indexOf(sourceContainer) ?? -1;
+          const originalPosition = {
+            elementId,
+            originalContainerId,
+            originalIndex
+          };
+          const element = moveElement({
+            ...move,
+            options: { ...move.options, useHistory: false }
+          });
+          onMoveElements?.();
+          movedElements.push({
+            elementId,
+            originalPosition,
+            move,
+            element
+          });
+        });
+        return { movedElements };
+      },
+      undo: (_, { movedElements }) => {
+        [...movedElements].reverse().forEach(({ originalPosition }) => {
+          const { elementId, originalContainerId, originalIndex } = originalPosition;
+          onRestoreElements?.();
+          moveElement({
+            elementId,
+            targetContainerId: originalContainerId,
+            options: {
+              useHistory: false,
+              at: originalIndex >= 0 ? originalIndex : void 0
+            }
+          });
+        });
+      },
+      redo: (_, { movedElements }) => {
+        const newMovedElements = [];
+        movedElements.forEach(({ move, originalPosition }) => {
+          const element = moveElement({
+            ...move,
+            options: { ...move.options, useHistory: false }
+          });
+          onMoveElements?.();
+          newMovedElements.push({
+            elementId: move.elementId,
+            originalPosition,
+            move,
+            element
+          });
+        });
+        return { movedElements: newMovedElements };
+      }
+    },
+    {
+      title,
+      subtitle
+    }
+  );
+  return undoableMove({ moves: movesToMake });
+};
+
 // src/sync/remove-elements.ts
 import { undoable as undoable4 } from "@elementor/editor-v1-adapters";
 import { __ as __4 } from "@wordpress/i18n";
@@ -520,18 +605,17 @@ var removeElements = ({
             });
           }
         });
-        const results = elementIdsParam.map((elementId) => {
-          return deleteElement({
+        onRemoveElements?.();
+        elementIdsParam.forEach((elementId) => {
+          deleteElement({
             elementId,
             options: { useHistory: false }
           });
         });
-        Promise.all(results).then(() => {
-          onRemoveElements?.();
-        });
         return { elementIds: elementIdsParam, removedElements };
       },
       undo: (_, { removedElements }) => {
+        onRestoreElements?.();
         [...removedElements].reverse().forEach(({ model, parent, at }) => {
           if (parent && model) {
             createElement({
@@ -541,16 +625,15 @@ var removeElements = ({
             });
           }
         });
-        onRestoreElements?.();
       },
       redo: (_, { elementIds: originalElementIds, removedElements }) => {
+        onRemoveElements?.();
         originalElementIds.forEach((elementId) => {
           deleteElement({
             elementId,
             options: { useHistory: false }
           });
         });
-        onRemoveElements?.();
         return { elementIds: originalElementIds, removedElements };
       }
     },
@@ -562,82 +645,65 @@ var removeElements = ({
   return undoableRemove({ elementIds });
 };
 
-// src/sync/get-element-styles.ts
-var getElementStyles = (elementID) => {
-  const container = getContainer(elementID);
-  return container?.model.get("styles") || null;
+// src/sync/replace-element.ts
+var replaceElement = ({ currentElement, newElement, withHistory = true }) => {
+  const { containerId, index } = getNewElementLocation(currentElement, newElement);
+  createElement({
+    containerId,
+    model: newElement,
+    options: { at: index, useHistory: withHistory }
+  });
+  deleteElement({ elementId: currentElement.id, options: { useHistory: withHistory } });
 };
-
-// src/errors.ts
-import { createError } from "@elementor/utils";
-var ElementNotFoundError = createError({
-  code: "element_not_found",
-  message: "Element not found."
-});
-var StyleNotFoundError = createError({
-  code: "style_not_found",
-  message: "Style not found."
-});
-var ElementTypeNotExistsError = createError({
-  code: "element_type_not_exists",
-  message: "Element type does not exist."
-});
-var ElementLabelNotExistsError = createError({
-  code: "element_label_not_exists",
-  message: "Element label does not exist."
-});
-var ElementParentNotFoundError = createError({
-  code: "element_parent_not_found",
-  message: "Element parent not found."
-});
-var ElementIndexNotFoundError = createError({
-  code: "element_index_not_found",
-  message: "Element index not found."
-});
-
-// src/sync/get-element-label.ts
-function getElementLabel(elementId) {
-  if (!elementId) {
-    elementId = getSelectedElements()?.[0]?.id;
+function getNewElementLocation(currentElement, newElement) {
+  let location;
+  const currentElementContainer = getContainer(currentElement.id);
+  if (!currentElementContainer) {
+    throw new ElementNotFoundError({ context: { elementId: currentElement.id } });
   }
-  const container = getContainer(elementId);
-  const type = container?.model.get("widgetType") || container?.model.get("elType");
-  if (!type) {
-    throw new ElementTypeNotExistsError({ context: { elementId } });
+  const parent = currentElementContainer.parent;
+  if (!parent) {
+    throw new ElementParentNotFoundError({ context: { elementId: currentElement.id } });
   }
-  const label = getWidgetsCache()?.[type]?.title;
-  if (!label) {
-    throw new ElementLabelNotExistsError({ context: { elementType: type } });
+  const elementIndex = currentElementContainer.view?._index ?? 0;
+  if (elementIndex === void 0 || elementIndex === -1) {
+    throw new ElementIndexNotFoundError({ context: { elementId: currentElement.id } });
   }
-  return label;
+  location = { containerId: parent.id, index: elementIndex };
+  if (parent.id === "document" && newElement.elType === "widget") {
+    location = createWrapperForWidget(parent.id, elementIndex);
+  }
+  return location;
 }
-
-// src/sync/get-current-document-container.ts
-function getCurrentDocumentContainer() {
-  const extendedWindow = window;
-  return extendedWindow.elementor?.documents?.getCurrent?.()?.container ?? null;
+function createWrapperForWidget(parentId, elementIndex) {
+  const container = createElement({
+    containerId: parentId,
+    model: { elType: "container" },
+    options: { at: elementIndex, useHistory: false }
+  });
+  return { containerId: container.id, index: 0 };
 }
 
-// src/sync/get-elements.ts
-function getElements(root) {
-  const container = root ? getContainer(root) : getCurrentDocumentContainer();
-  if (!container) {
-    return [];
+// src/sync/update-element-editor-settings.ts
+import { __privateRunCommandSync as runCommandSync3 } from "@elementor/editor-v1-adapters";
+var updateElementEditorSettings = ({
+  elementId,
+  settings
+}) => {
+  const element = getContainer(elementId);
+  if (!element) {
+    throw new Error(`Element with id ${elementId} not found`);
   }
-  const children = [...container.model.get("elements") ?? []].flatMap(
-    (childModel) => getElements(childModel.get("id"))
-  );
-  return [container, ...children];
-}
-
-// src/sync/get-current-document-id.ts
-function getCurrentDocumentId() {
-  const extendedWindow = window;
-  return extendedWindow.elementor?.documents?.getCurrentId?.() ?? null;
+  const editorSettings = element.model.get("editor_settings") ?? {};
+  element.model.set("editor_settings", { ...editorSettings, ...settings });
+  setDocumentModifiedStatus(true);
+};
+function setDocumentModifiedStatus(status) {
+  runCommandSync3("document/save/set-is-modified", { status }, { internal: true });
 }
 
 // src/sync/update-element-settings.ts
-import { __privateRunCommandSync as runCommandSync3 } from "@elementor/editor-v1-adapters";
+import { __privateRunCommandSync as runCommandSync4 } from "@elementor/editor-v1-adapters";
 var updateElementSettings = ({ id, props, withHistory = true }) => {
   const container = getContainer(id);
   const args = {
@@ -645,69 +711,94 @@ var updateElementSettings = ({ id, props, withHistory = true }) => {
     settings: { ...props }
   };
   if (withHistory) {
-    runCommandSync3("document/elements/settings", args);
+    runCommandSync4("document/elements/settings", args);
   } else {
-    runCommandSync3("document/elements/set-settings", args, { internal: true });
+    runCommandSync4("document/elements/set-settings", args, { internal: true });
   }
 };
 
-// src/sync/generate-element-id.ts
-var generateElementId = () => {
-  const extendedWindow = window;
-  return extendedWindow.elementorCommon?.helpers?.getUniqueId?.() ?? `el-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-};
-
-// src/sync/replace-element.ts
-var replaceElement = ({ currentElement, newElement, withHistory = true }) => {
-  const { containerId, index } = getNewElementLocation(currentElement, newElement);
-  createElement({
-    containerId,
-    model: newElement,
-    options: { at: index, useHistory: withHistory }
-  });
-  deleteElement({ elementId: currentElement.id, options: { useHistory: withHistory } });
-};
-function getNewElementLocation(currentElement, newElement) {
-  let location;
-  const currentElementContainer = getContainer(currentElement.id);
-  if (!currentElementContainer) {
-    throw new ElementNotFoundError({ context: { elementId: currentElement.id } });
+// src/link-restriction.ts
+function getLinkInLinkRestriction(elementId) {
+  const anchoredDescendantId = getAnchoredDescendantId(elementId);
+  if (anchoredDescendantId) {
+    return {
+      shouldRestrict: true,
+      reason: "descendant",
+      elementId: anchoredDescendantId
+    };
   }
-  const parent = currentElementContainer.parent;
-  if (!parent) {
-    throw new ElementParentNotFoundError({ context: { elementId: currentElement.id } });
+  const ancestor = getAnchoredAncestorId(elementId);
+  if (ancestor) {
+    return {
+      shouldRestrict: true,
+      reason: "ancestor",
+      elementId: ancestor
+    };
   }
-  const elementIndex = currentElementContainer.view?._index ?? 0;
-  if (elementIndex === void 0 || elementIndex === -1) {
-    throw new ElementIndexNotFoundError({ context: { elementId: currentElement.id } });
+  return {
+    shouldRestrict: false
+  };
+}
+function getAnchoredDescendantId(elementId) {
+  const element = getElementDOM(elementId);
+  if (!element) {
+    return null;
   }
-  location = { containerId: parent.id, index: elementIndex };
-  if (parent.id === "document" && newElement.elType === "widget") {
-    location = createWrapperForWidget(parent.id, elementIndex);
+  for (const childAnchorElement of Array.from(element.querySelectorAll("a"))) {
+    const childElementId = findElementIdOf(childAnchorElement);
+    if (childElementId !== elementId) {
+      return childElementId;
+    }
   }
-  return location;
+  return null;
 }
-function createWrapperForWidget(parentId, elementIndex) {
-  const container = createElement({
-    containerId: parentId,
-    model: { elType: "container" },
-    options: { at: elementIndex, useHistory: false }
-  });
-  return { containerId: container.id, index: 0 };
+function getAnchoredAncestorId(elementId) {
+  const element = getElementDOM(elementId);
+  if (!element || element.parentElement === null) {
+    return null;
+  }
+  const parentAnchor = element.parentElement.closest("a");
+  return parentAnchor ? findElementIdOf(parentAnchor) : null;
 }
-
-// src/sync/drop-element.ts
-import { __privateRunCommandSync as runCommandSync4 } from "@elementor/editor-v1-adapters";
-function dropElement({ containerId, model, options }) {
-  const container = getContainer(containerId);
-  if (!container) {
-    throw new Error(`Container with ID "${containerId}" not found`);
+function isElementAnchored(elementId) {
+  const element = getElementDOM(elementId);
+  if (!element) {
+    return false;
+  }
+  if (isAnchorTag(element.tagName)) {
+    return true;
+  }
+  return doesElementContainAnchor(element);
+}
+function doesElementContainAnchor(element) {
+  for (const child of element.children) {
+    if (isElementorElement(child)) {
+      continue;
+    }
+    if (isAnchorTag(child.tagName)) {
+      return true;
+    }
+    if (doesElementContainAnchor(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+function findElementIdOf(element) {
+  return element.closest("[data-id]")?.dataset.id || null;
+}
+function getElementDOM(id) {
+  try {
+    return getContainer(id)?.view?.el || null;
+  } catch {
+    return null;
   }
-  return runCommandSync4("preview/drop", {
-    container,
-    model,
-    options
-  });
+}
+function isAnchorTag(tagName) {
+  return tagName.toLowerCase() === "a";
+}
+function isElementorElement(element) {
+  return element.hasAttribute("data-id");
 }
 
 // src/styles/consts.ts
@@ -837,6 +928,14 @@ function shouldCreateNewLocalStyle(payload) {
   return !payload?.styleId && !payload?.provider;
 }
 
+// src/styles/delete-element-style.ts
+function deleteElementStyle(elementId, styleId) {
+  mutateElementStyles(elementId, (styles) => {
+    delete styles[styleId];
+    return styles;
+  });
+}
+
 // src/styles/update-element-style.ts
 import { mergeProps } from "@elementor/editor-props";
 import { getVariantByMeta } from "@elementor/editor-styles";
@@ -858,97 +957,9 @@ function updateElementStyle(args) {
   });
 }
 
-// src/styles/delete-element-style.ts
-function deleteElementStyle(elementId, styleId) {
-  mutateElementStyles(elementId, (styles) => {
-    delete styles[styleId];
-    return styles;
-  });
-}
-
-// src/link-restriction.ts
-function getLinkInLinkRestriction(elementId) {
-  const anchoredDescendantId = getAnchoredDescendantId(elementId);
-  if (anchoredDescendantId) {
-    return {
-      shouldRestrict: true,
-      reason: "descendant",
-      elementId: anchoredDescendantId
-    };
-  }
-  const ancestor = getAnchoredAncestorId(elementId);
-  if (ancestor) {
-    return {
-      shouldRestrict: true,
-      reason: "ancestor",
-      elementId: ancestor
-    };
-  }
-  return {
-    shouldRestrict: false
-  };
-}
-function getAnchoredDescendantId(elementId) {
-  const element = getElementDOM(elementId);
-  if (!element) {
-    return null;
-  }
-  for (const childAnchorElement of Array.from(element.querySelectorAll("a"))) {
-    const childElementId = findElementIdOf(childAnchorElement);
-    if (childElementId !== elementId) {
-      return childElementId;
-    }
-  }
-  return null;
-}
-function getAnchoredAncestorId(elementId) {
-  const element = getElementDOM(elementId);
-  if (!element || element.parentElement === null) {
-    return null;
-  }
-  const parentAnchor = element.parentElement.closest("a");
-  return parentAnchor ? findElementIdOf(parentAnchor) : null;
-}
-function isElementAnchored(elementId) {
-  const element = getElementDOM(elementId);
-  if (!element) {
-    return false;
-  }
-  if (isAnchorTag(element.tagName)) {
-    return true;
-  }
-  return doesElementContainAnchor(element);
-}
-function doesElementContainAnchor(element) {
-  for (const child of element.children) {
-    if (isElementorElement(child)) {
-      continue;
-    }
-    if (isAnchorTag(child.tagName)) {
-      return true;
-    }
-    if (doesElementContainAnchor(child)) {
-      return true;
-    }
-  }
-  return false;
-}
-function findElementIdOf(element) {
-  return element.closest("[data-id]")?.dataset.id || null;
-}
-function getElementDOM(id) {
-  try {
-    return getContainer(id)?.view?.el || null;
-  } catch {
-    return null;
-  }
-}
-function isAnchorTag(tagName) {
-  return tagName.toLowerCase() === "a";
-}
-function isElementorElement(element) {
-  return element.hasAttribute("data-id");
-}
+// src/hooks/use-element-interactions.ts
+import { useState } from "react";
+import { __privateUseListenTo as useListenTo6, windowEvent as windowEvent3 } from "@elementor/editor-v1-adapters";
 
 // src/sync/get-element-interactions.ts
 function getElementInteractions(elementId) {
@@ -960,6 +971,23 @@ function getElementInteractions(elementId) {
   return JSON.stringify(interactions);
 }
 
+// src/hooks/use-element-interactions.ts
+var useElementInteractions = (elementId) => {
+  const [interactions, setInteractions] = useState(() => {
+    const initial = getElementInteractions(elementId);
+    return initial;
+  });
+  useListenTo6(
+    windowEvent3("elementor/element/update_interactions"),
+    () => {
+      const newInteractions = getElementInteractions(elementId);
+      setInteractions(newInteractions);
+    },
+    [elementId]
+  );
+  return interactions;
+};
+
 // src/sync/update-element-interactions.ts
 import { __privateRunCommandSync as runCommandSync6 } from "@elementor/editor-v1-adapters";
 var updateElementInteractions = ({
@@ -981,25 +1009,6 @@ function setDocumentModifiedStatus2(status) {
   runCommandSync6("document/save/set-is-modified", { status }, { internal: true });
 }
 
-// src/hooks/use-element-interactions.ts
-import { useState } from "react";
-import { __privateUseListenTo as useListenTo6, windowEvent as windowEvent3 } from "@elementor/editor-v1-adapters";
-var useElementInteractions = (elementId) => {
-  const [interactions, setInteractions] = useState(() => {
-    const initial = getElementInteractions(elementId);
-    return initial;
-  });
-  useListenTo6(
-    windowEvent3("elementor/element/update_interactions"),
-    () => {
-      const newInteractions = getElementInteractions(elementId);
-      setInteractions(newInteractions);
-    },
-    [elementId]
-  );
-  return interactions;
-};
-
 // src/mcp/index.ts
 import { getMCPByDomain as getMCPByDomain2 } from "@elementor/editor-mcp";