@elementor/editor-elements 4.0.0-543 → 4.0.0-545

package/dist/index.js

@@ -47,7 +47,6 @@ __export(index_exports, {
   getElementType: () => getElementType,
   getElements: () => getElements,
   getLinkInLinkRestriction: () => getLinkInLinkRestriction,
-  getModel: () => getModel,
   getSelectedElements: () => getSelectedElements,
   getWidgetsCache: () => getWidgetsCache,
   isElementAnchored: () => isElementAnchored,
@@ -91,22 +90,7 @@ var selectElement = (elementId) => {
   }
 };
 
-// src/sync/get-model.ts
-function getModel(id, parentModel) {
-  const extendedWindow = window;
-  const container = extendedWindow.elementor?.getContainer?.(id) ?? null;
-  if (container) {
-    return { model: container.model };
-  }
-  if (parentModel) {
-    const childModels = parentModel.get("elements") ?? [];
-    const model = childModels.find((m) => m.get("id") === id);
-    if (model) {
-      return { model };
-    }
-  }
-  return null;
-}
+// src/sync/model-utils.ts
 function findChildRecursive(model, predicate) {
   const childModels = model.get("elements") ?? [];
   for (const childModel of childModels) {
@@ -304,11 +288,7 @@ function useSelectedElement() {
 
 // src/sync/create-element.ts
 var import_editor_v1_adapters7 = require("@elementor/editor-v1-adapters");
-function createElement({ containerId, model, options }) {
-  const container = getContainer(containerId);
-  if (!container) {
-    throw new Error(`Container with ID "${containerId}" not found`);
-  }
+function createElement({ container, model, options }) {
   return (0, import_editor_v1_adapters7.__privateRunCommandSync)("document/elements/create", {
     container,
     model,
@@ -322,14 +302,7 @@ var import_i18n = require("@wordpress/i18n");
 
 // src/sync/delete-element.ts
 var import_editor_v1_adapters8 = require("@elementor/editor-v1-adapters");
-function deleteElement({
-  elementId,
-  options = {}
-}) {
-  const container = getContainer(elementId);
-  if (!container) {
-    throw new Error(`Element with ID "${elementId}" not found`);
-  }
+function deleteElement({ container, options = {} }) {
   return (0, import_editor_v1_adapters8.__privateRunCommand)("document/elements/delete", {
     container,
     options
@@ -346,48 +319,54 @@ var createElements = ({
     {
       do: ({ elements: elementsParam }) => {
         const createdElements = [];
-        elementsParam.forEach((createParams) => {
-          const { options, ...elementParams } = createParams;
+        elementsParam.forEach(({ container, options, ...elementParams }) => {
+          const parentContainer = container.lookup?.() ?? container;
+          if (!parentContainer) {
+            throw new Error("Parent container not found");
+          }
           const element = createElement({
+            container: parentContainer,
             ...elementParams,
             options: { ...options, useHistory: false }
           });
-          const elementId = element.id;
           createdElements.push({
-            elementId,
+            container: element,
+            parentContainer,
             model: element.model?.toJSON() || {},
-            createParams: {
-              ...createParams
-            }
+            options
           });
         });
         return { createdElements };
       },
       undo: (_, { createdElements }) => {
-        [...createdElements].reverse().forEach(({ elementId }) => {
-          deleteElement({
-            elementId,
-            options: { useHistory: false }
-          });
+        [...createdElements].reverse().forEach(({ container }) => {
+          const freshContainer = container.lookup?.();
+          if (freshContainer) {
+            deleteElement({
+              container: freshContainer,
+              options: { useHistory: false }
+            });
+          }
         });
       },
       redo: (_, { createdElements }) => {
         const newElements = [];
-        createdElements.forEach(({ createParams, model }) => {
+        createdElements.forEach(({ parentContainer, model, options }) => {
+          const freshParent = parentContainer.lookup?.();
+          if (!freshParent) {
+            return;
+          }
           const element = createElement({
-            containerId: createParams.containerId,
+            container: freshParent,
             model,
-            options: { ...createParams.options, useHistory: false }
+            options: { ...options, useHistory: false }
+          });
+          newElements.push({
+            container: element,
+            parentContainer: freshParent,
+            model: element.model.toJSON(),
+            options
           });
-          const elementId = element.id;
-          const container = getContainer(elementId);
-          if (container) {
-            newElements.push({
-              elementId,
-              model: container.model.toJSON(),
-              createParams
-            });
-          }
         });
         return { createdElements: newElements };
       }
@@ -416,15 +395,11 @@ function dropElement({ containerId, model, options }) {
 
 // src/sync/duplicate-element.ts
 var import_editor_v1_adapters11 = require("@elementor/editor-v1-adapters");
-function duplicateElement({ elementId, options = {} }) {
-  const elementToDuplicate = getContainer(elementId);
-  if (!elementToDuplicate) {
-    throw new Error(`Element with ID "${elementId}" not found`);
-  }
-  const currentIndex = elementToDuplicate.view?._index ?? 0;
+function duplicateElement({ element, options = {} }) {
+  const currentIndex = element.view?._index ?? 0;
   const insertPosition = options.clone !== false ? currentIndex + 1 : void 0;
   return (0, import_editor_v1_adapters11.__privateRunCommandSync)("document/elements/duplicate", {
-    container: elementToDuplicate,
+    container: element,
     options: { at: insertPosition, edit: false, ...options }
   });
 }
@@ -443,59 +418,56 @@ var duplicateElements = ({
     {
       do: ({ elementIds: elementIdsToDuplicate }) => {
         onDuplicateElements?.();
-        const duplicatedElements = elementIdsToDuplicate.reduce((acc, elementId) => {
+        const duplicatedElements = [];
+        elementIdsToDuplicate.forEach((elementId) => {
           const originalContainer = getContainer(elementId);
-          if (originalContainer?.parent) {
-            const duplicatedElement = duplicateElement({
-              elementId,
-              options: { useHistory: false }
-            });
-            acc.push({
-              id: duplicatedElement.id,
-              model: duplicatedElement.model.toJSON(),
-              originalElementId: elementId,
-              modelToRestore: duplicatedElement.model.toJSON(),
-              parentContainerId: duplicatedElement.parent?.id,
-              at: duplicatedElement.view?._index
-            });
+          if (!originalContainer?.parent) {
+            return;
           }
-          return acc;
-        }, []);
+          const duplicatedElement = duplicateElement({
+            element: originalContainer,
+            options: { useHistory: false }
+          });
+          if (!duplicatedElement.parent) {
+            return;
+          }
+          duplicatedElements.push({
+            container: duplicatedElement,
+            parentContainer: duplicatedElement.parent,
+            model: duplicatedElement.model.toJSON(),
+            at: duplicatedElement.view?._index
+          });
+        });
         return { duplicatedElements };
       },
       undo: (_, { duplicatedElements }) => {
         onRestoreElements?.();
-        [...duplicatedElements].reverse().forEach(({ id }) => {
+        [...duplicatedElements].reverse().forEach(({ container }) => {
           deleteElement({
-            elementId: id,
+            container,
             options: { useHistory: false }
           });
         });
       },
       redo: (_, { duplicatedElements: previousElements }) => {
         onDuplicateElements?.();
-        const duplicatedElements = previousElements.reduce((acc, previousElement) => {
-          if (previousElement.modelToRestore && previousElement.parentContainerId) {
+        const duplicatedElements = [];
+        previousElements.forEach(({ parentContainer, model, at }) => {
+          const freshParent = parentContainer.lookup?.();
+          if (freshParent) {
             const createdElement = createElement({
-              containerId: previousElement.parentContainerId,
-              model: previousElement.modelToRestore,
-              options: {
-                useHistory: false,
-                clone: false,
-                at: previousElement.at
-              }
+              container: freshParent,
+              model,
+              options: { useHistory: false, clone: false, at }
             });
-            acc.push({
-              id: createdElement.id,
-              model: createdElement.model.toJSON(),
-              originalElementId: previousElement.originalElementId,
-              modelToRestore: previousElement.modelToRestore,
-              parentContainerId: previousElement.parentContainerId,
-              at: previousElement.at
+            duplicatedElements.push({
+              container: createdElement,
+              parentContainer: freshParent,
+              model,
+              at
             });
           }
-          return acc;
-        }, []);
+        });
         return { duplicatedElements };
       }
     },
@@ -594,25 +566,23 @@ function getElements(root) {
 }
 
 // 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`);
+function moveElement({ element, targetContainer, options = {} }) {
+  const resolvedElement = element.lookup?.();
+  const resolvedTarget = targetContainer.lookup?.();
+  if (!resolvedElement) {
+    throw new Error(`Element not found: ${element.id}`);
   }
-  if (!target) {
-    throw new Error(`Target container with ID "${targetContainerId}" not found`);
+  if (!resolvedTarget) {
+    throw new Error(`Target container not found: ${targetContainer.id}`);
   }
-  const modelToRecreate = container.model.toJSON();
+  const modelToRecreate = resolvedElement.model.toJSON();
   deleteElement({
-    elementId,
-    // prevent inner history from being created
+    container: resolvedElement,
     options: { ...options, useHistory: false }
   });
   const newContainer = createElement({
-    containerId: targetContainerId,
+    container: resolvedTarget,
     model: modelToRecreate,
-    // prevent inner history from being created
     options: { edit: false, ...options, useHistory: false }
   });
   return newContainer;
@@ -633,39 +603,46 @@ var moveElements = ({
       do: ({ moves }) => {
         const movedElements = [];
         onMoveElements?.();
-        moves.forEach((move) => {
-          const { elementId } = move;
-          const sourceContainer = getContainer(elementId);
-          if (!sourceContainer) {
-            throw new Error(`Element with ID "${elementId}" not found`);
+        moves.forEach(({ element, targetContainer, options }) => {
+          const sourceElement = element.lookup?.() ?? element;
+          const target = targetContainer.lookup?.() ?? targetContainer;
+          if (!sourceElement) {
+            throw new Error("Element not found");
+          }
+          if (!target) {
+            throw new Error("Target container not found");
+          }
+          if (!sourceElement.parent) {
+            throw new Error("Element has no parent container");
           }
-          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 }
+          const originalContainer = sourceElement.parent;
+          const originalIndex = originalContainer.children?.indexOf(sourceElement) ?? -1;
+          const newElement = moveElement({
+            element: sourceElement,
+            targetContainer: target,
+            options: { ...options, useHistory: false }
           });
           movedElements.push({
-            elementId,
-            originalPosition,
-            move,
-            element
+            element: newElement,
+            originalContainer,
+            originalIndex,
+            targetContainer: target,
+            options
           });
         });
         return { movedElements };
       },
       undo: (_, { movedElements }) => {
         onRestoreElements?.();
-        [...movedElements].reverse().forEach(({ originalPosition }) => {
-          const { elementId, originalContainerId, originalIndex } = originalPosition;
+        [...movedElements].reverse().forEach(({ element, originalContainer, originalIndex }) => {
+          const freshElement = element.lookup?.();
+          const freshOriginalContainer = originalContainer.lookup?.();
+          if (!freshElement || !freshOriginalContainer) {
+            return;
+          }
           moveElement({
-            elementId,
-            targetContainerId: originalContainerId,
+            element: freshElement,
+            targetContainer: freshOriginalContainer,
             options: {
               useHistory: false,
               at: originalIndex >= 0 ? originalIndex : void 0
@@ -676,16 +653,24 @@ var moveElements = ({
       redo: (_, { movedElements }) => {
         const newMovedElements = [];
         onMoveElements?.();
-        movedElements.forEach(({ move, originalPosition }) => {
-          const element = moveElement({
-            ...move,
-            options: { ...move.options, useHistory: false }
+        movedElements.forEach(({ element, originalContainer, originalIndex, targetContainer, options }) => {
+          const freshElement = element.lookup?.();
+          const freshOriginalContainer = originalContainer.lookup?.();
+          const freshTarget = targetContainer.lookup?.();
+          if (!freshElement || !freshOriginalContainer || !freshTarget) {
+            return;
+          }
+          const newElement = moveElement({
+            element: freshElement,
+            targetContainer: freshTarget,
+            options: { ...options, useHistory: false }
           });
           newMovedElements.push({
-            elementId: move.elementId,
-            originalPosition,
-            move,
-            element
+            element: newElement,
+            originalContainer: freshOriginalContainer,
+            originalIndex,
+            targetContainer: freshTarget,
+            options
           });
         });
         return { movedElements: newMovedElements };
@@ -715,48 +700,58 @@ var removeElements = ({
         const removedElements = [];
         elementIdsParam.forEach((elementId) => {
           const container = getContainer(elementId);
-          if (container) {
-            const model = container.model.toJSON();
-            const parent = container.parent;
-            const at = container.view?._index ?? 0;
+          if (container?.parent) {
             removedElements.push({
-              elementId,
-              model,
-              parent: parent ?? null,
-              at
+              container,
+              parent: container.parent,
+              model: container.model.toJSON(),
+              at: container.view?._index ?? 0
             });
           }
         });
         onRemoveElements?.();
-        elementIdsParam.forEach((elementId) => {
+        removedElements.forEach(({ container }) => {
           deleteElement({
-            elementId,
+            container,
             options: { useHistory: false }
           });
         });
-        return { elementIds: elementIdsParam, removedElements };
+        return { removedElements };
       },
       undo: (_, { removedElements }) => {
         onRestoreElements?.();
-        [...removedElements].reverse().forEach(({ model, parent, at }) => {
-          if (parent && model) {
+        [...removedElements].reverse().forEach(({ parent, model, at }) => {
+          const freshParent = parent.lookup?.();
+          if (freshParent) {
             createElement({
-              containerId: parent.id,
+              container: freshParent,
               model,
               options: { useHistory: false, at }
             });
           }
         });
       },
-      redo: (_, { elementIds: originalElementIds, removedElements }) => {
+      redo: (_, { removedElements }) => {
         onRemoveElements?.();
-        originalElementIds.forEach((elementId) => {
+        const newRemovedElements = [];
+        removedElements.forEach(({ container, parent, model, at }) => {
+          const freshContainer = container.lookup?.();
+          const freshParent = parent.lookup?.();
+          if (!freshContainer || !freshParent) {
+            return;
+          }
           deleteElement({
-            elementId,
+            container: freshContainer,
             options: { useHistory: false }
           });
+          newRemovedElements.push({
+            container: freshContainer,
+            parent: freshParent,
+            model,
+            at
+          });
         });
-        return { elementIds: originalElementIds, removedElements };
+        return { removedElements: newRemovedElements };
       }
     },
     {
@@ -769,42 +764,42 @@ var removeElements = ({
 
 // src/sync/replace-element.ts
 var replaceElement = async ({ currentElement, newElement, withHistory = true }) => {
-  const { containerId, index } = getNewElementContainer(currentElement, newElement);
+  const currentElementContainer = getContainer(currentElement.id);
+  if (!currentElementContainer) {
+    throw new ElementNotFoundError({ context: { elementId: currentElement.id } });
+  }
+  const { container, index } = getNewElementContainer(currentElementContainer, newElement);
   const newElementInstance = createElement({
-    containerId,
+    container,
     model: newElement,
     options: { at: index, useHistory: withHistory }
   });
-  await deleteElement({ elementId: currentElement.id, options: { useHistory: withHistory } });
+  await deleteElement({ container: currentElementContainer, options: { useHistory: withHistory } });
   return newElementInstance;
 };
-function getNewElementContainer(currentElement, newElement) {
-  const currentElementContainer = getContainer(currentElement.id);
-  if (!currentElementContainer) {
-    throw new ElementNotFoundError({ context: { elementId: currentElement.id } });
-  }
+function getNewElementContainer(currentElementContainer, newElement) {
   const { parent } = currentElementContainer;
   if (!parent) {
-    throw new ElementParentNotFoundError({ context: { elementId: currentElement.id } });
+    throw new ElementParentNotFoundError({ context: { elementId: currentElementContainer.id } });
   }
   const elementIndex = currentElementContainer.view?._index ?? 0;
   if (elementIndex === -1) {
-    throw new ElementIndexNotFoundError({ context: { elementId: currentElement.id } });
+    throw new ElementIndexNotFoundError({ context: { elementId: currentElementContainer.id } });
   }
-  let container = { containerId: parent.id, index: elementIndex };
+  let location = { container: parent, index: elementIndex };
   if (parent.id === "document" && newElement.elType === "widget") {
-    container = createWrapperForWidget(parent.id, elementIndex);
+    location = createWrapperForWidget(parent, elementIndex);
   }
-  return container;
+  return location;
 }
 var DEFAULT_CONTAINER_TYPE = "e-flexbox";
-function createWrapperForWidget(parentId, elementIndex) {
+function createWrapperForWidget(parent, elementIndex) {
   const container = createElement({
-    containerId: parentId,
+    container: parent,
     model: { elType: DEFAULT_CONTAINER_TYPE },
     options: { at: elementIndex, useHistory: false }
   });
-  return { containerId: container.id, index: 0 };
+  return { container, index: 0 };
 }
 
 // src/sync/update-element-editor-settings.ts
@@ -819,16 +814,16 @@ var updateElementEditorSettings = ({
   }
   const editorSettings = element.model.get("editor_settings") ?? {};
   element.model.set("editor_settings", { ...editorSettings, ...settings });
-  setDocumentModifiedStatus(true);
+  (0, import_editor_v1_adapters15.__privateRunCommandSync)("document/save/set-is-modified", { status: true }, { internal: true });
 };
-function setDocumentModifiedStatus(status) {
-  (0, import_editor_v1_adapters15.__privateRunCommandSync)("document/save/set-is-modified", { status }, { internal: true });
-}
 
 // src/sync/update-element-settings.ts
 var import_editor_v1_adapters16 = require("@elementor/editor-v1-adapters");
 var updateElementSettings = ({ id, props, withHistory = true }) => {
   const container = getContainer(id);
+  if (!container) {
+    return;
+  }
   const args = {
     container,
     settings: { ...props }
@@ -1141,16 +1136,13 @@ var updateElementInteractions = ({
   }
   element.model.set("interactions", interactions);
   window.dispatchEvent(new CustomEvent("elementor/element/update_interactions"));
-  setDocumentModifiedStatus2(true);
+  (0, import_editor_v1_adapters20.__privateRunCommandSync)("document/save/set-is-modified", { status: true }, { internal: true });
 };
 var playElementInteractions = (elementId, interactionId) => {
   window.top?.dispatchEvent(
     new CustomEvent("atomic/play_interactions", { detail: { elementId, interactionId } })
   );
 };
-function setDocumentModifiedStatus2(status) {
-  (0, import_editor_v1_adapters20.__privateRunCommandSync)("document/save/set-is-modified", { status }, { internal: true });
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ELEMENT_STYLE_CHANGE_EVENT,
@@ -1180,7 +1172,6 @@ function setDocumentModifiedStatus2(status) {
   getElementType,
   getElements,
   getLinkInLinkRestriction,
-  getModel,
   getSelectedElements,
   getWidgetsCache,
   isElementAnchored,