@elementor/editor-components 4.2.0-915 → 4.2.0-917

package/dist/index.mjs

@@ -1061,9 +1061,14 @@ import { DetachIcon } from "@elementor/icons";
 import { __ as __10 } from "@wordpress/i18n";
 
 // src/utils/detach-component-instance/detach-component-instance.ts
-import { getContainer, replaceElement } from "@elementor/editor-elements";
+import { doAfterRender } from "@elementor/editor-canvas";
+import {
+  getContainer,
+  replaceElement,
+  selectElement
+} from "@elementor/editor-elements";
 import { undoable } from "@elementor/editor-v1-adapters";
-import { __dispatch as dispatch2, __getState as getState3 } from "@elementor/store";
+import { __getState as getState3 } from "@elementor/store";
 import { __ as __9 } from "@wordpress/i18n";
 
 // src/prop-types/component-instance-overrides-prop-type.ts
@@ -1259,7 +1264,7 @@ function resolvePropValue(propValue, overrideMap, options) {
     return resolveOverridableOverride(matchingOverride, originValue);
   }
   const matchingOverrideValue = componentInstanceOverridePropTypeUtil.extract(matchingOverride)?.override_value;
-  return matchingOverrideValue;
+  return matchingOverrideValue ?? originValue;
 }
 function resolveOverridableOverride(matchingOverride, originValue) {
   if (!originValue || !componentInstanceOverridePropTypeUtil.isValid(originValue)) {
@@ -1322,6 +1327,9 @@ function getOverridableOverride(propValue) {
 }
 
 // src/utils/detach-component-instance/detach-component-instance.ts
+var DETACH_EVENT = "elementor/components/detach-instance";
+var DETACH_UNDO_EVENT = "elementor/components/undo-detach-instance";
+var DETACH_REDO_EVENT = "elementor/components/redo-detach-instance";
 async function detachComponentInstance({
   instanceId,
   componentId,
@@ -1347,14 +1355,22 @@ async function detachComponentInstance({
           rootElement,
           overrides
         );
-        const editedComponentOnDetach = selectCurrentComponentId(getState3());
-        const overridablePropsBeforeDetach = editedComponentOnDetach ? selectOverridableProps(getState3(), editedComponentOnDetach) ?? null : null;
         const originalInstanceModel = instanceContainer.model.toJSON();
+        const actionId = (/* @__PURE__ */ new Date()).getTime();
+        window.dispatchEvent(
+          new CustomEvent(DETACH_EVENT, {
+            detail: {
+              detachedInstanceId: instanceId,
+              detachActionId: actionId
+            }
+          })
+        );
         const detachedElement = replaceElement({
           currentElementId: instanceId,
           newElement: detachedInstanceElementData,
           withHistory: false
         });
+        selectElement(detachedElement.id);
         const componentUid = selectComponent(getState3(), componentId)?.uid;
         trackComponentEvent({
           action: "detached",
@@ -1368,47 +1384,48 @@ async function detachComponentInstance({
         return {
           detachedElement,
           detachedInstanceElementData,
-          editedComponentOnDetach,
-          overridablePropsBeforeDetach,
-          originalInstanceModel
+          originalInstanceModel,
+          actionId
         };
       },
-      undo: (_, {
-        detachedElement,
-        originalInstanceModel,
-        overridablePropsBeforeDetach,
-        editedComponentOnDetach
-      }) => {
+      undo: (_, { detachedElement, originalInstanceModel, actionId }) => {
         const restoredInstance = replaceElement({
           currentElementId: detachedElement.id,
           newElement: originalInstanceModel,
           withHistory: false
         });
-        const currentComponentId = selectCurrentComponentId(getState3());
-        if (currentComponentId && currentComponentId === editedComponentOnDetach && overridablePropsBeforeDetach) {
-          dispatch2(
-            slice.actions.setOverridableProps({
-              componentId: currentComponentId,
-              overridableProps: overridablePropsBeforeDetach
-            })
-          );
-        }
+        window.dispatchEvent(
+          new CustomEvent(DETACH_UNDO_EVENT, {
+            detail: {
+              restoredInstanceId: restoredInstance.id,
+              detachActionId: actionId
+            }
+          })
+        );
+        doAfterRender([restoredInstance.id], () => {
+          selectElement(restoredInstance.id);
+        });
         return restoredInstance;
       },
       redo: (_, doReturn, restoredInstance) => {
-        const { detachedInstanceElementData } = doReturn;
-        const editedComponentOnDetach = selectCurrentComponentId(getState3());
-        const overridablePropsBeforeDetach = editedComponentOnDetach ? selectOverridableProps(getState3(), editedComponentOnDetach) ?? null : null;
+        const { detachedInstanceElementData, actionId } = doReturn;
         const detachedElement = replaceElement({
           currentElementId: restoredInstance.id,
           newElement: detachedInstanceElementData,
           withHistory: false
         });
+        window.dispatchEvent(
+          new CustomEvent(DETACH_REDO_EVENT, {
+            detail: {
+              detachedInstanceId: detachedElement.id,
+              detachActionId: actionId
+            }
+          })
+        );
+        selectElement(detachedElement.id);
         return {
           ...doReturn,
-          detachedElement,
-          editedComponentOnDetach,
-          overridablePropsBeforeDetach
+          detachedElement
         };
       }
     },
@@ -1645,40 +1662,40 @@ function getOverrideValue(overrideProp) {
 }
 
 // src/store/dispatchers.ts
-import { __dispatch as dispatch3, __getStore as getStore } from "@elementor/store";
+import { __dispatch as dispatch2, __getStore as getStore } from "@elementor/store";
 function safeDispatch() {
   return getStore()?.dispatch;
 }
 var componentsActions = {
   add(components) {
-    dispatch3(slice.actions.add(components));
+    dispatch2(slice.actions.add(components));
   },
   load(components) {
-    dispatch3(slice.actions.load(components));
+    dispatch2(slice.actions.load(components));
   },
   addUnpublished(component) {
-    dispatch3(slice.actions.addUnpublished(component));
+    dispatch2(slice.actions.addUnpublished(component));
   },
   removeUnpublished(uids) {
-    dispatch3(slice.actions.removeUnpublished(uids));
+    dispatch2(slice.actions.removeUnpublished(uids));
   },
   resetUnpublished() {
-    dispatch3(slice.actions.resetUnpublished());
+    dispatch2(slice.actions.resetUnpublished());
   },
   removeStyles(id) {
-    dispatch3(slice.actions.removeStyles({ id }));
+    dispatch2(slice.actions.removeStyles({ id }));
   },
   addStyles(styles) {
-    dispatch3(slice.actions.addStyles(styles));
+    dispatch2(slice.actions.addStyles(styles));
   },
   addCreatedThisSession(uid) {
-    dispatch3(slice.actions.addCreatedThisSession(uid));
+    dispatch2(slice.actions.addCreatedThisSession(uid));
   },
   removeCreatedThisSession(uid) {
-    dispatch3(slice.actions.removeCreatedThisSession(uid));
+    dispatch2(slice.actions.removeCreatedThisSession(uid));
   },
   archive(componentId) {
-    dispatch3(slice.actions.archive(componentId));
+    dispatch2(slice.actions.archive(componentId));
   },
   setCurrentComponentId(id) {
     safeDispatch()?.(slice.actions.setCurrentComponentId(id));
@@ -1687,19 +1704,19 @@ var componentsActions = {
     safeDispatch()?.(slice.actions.setPath(path));
   },
   setOverridableProps(componentId, overridableProps) {
-    dispatch3(slice.actions.setOverridableProps({ componentId, overridableProps }));
+    dispatch2(slice.actions.setOverridableProps({ componentId, overridableProps }));
   },
   rename(componentUid, name) {
-    dispatch3(slice.actions.rename({ componentUid, name }));
+    dispatch2(slice.actions.rename({ componentUid, name }));
   },
   cleanUpdatedComponentNames() {
-    dispatch3(slice.actions.cleanUpdatedComponentNames());
+    dispatch2(slice.actions.cleanUpdatedComponentNames());
   },
   updateComponentSanitizedAttribute(componentId, attribute) {
-    dispatch3(slice.actions.updateComponentSanitizedAttribute({ componentId, attribute }));
+    dispatch2(slice.actions.updateComponentSanitizedAttribute({ componentId, attribute }));
   },
   resetSanitizedComponents() {
-    dispatch3(slice.actions.resetSanitizedComponents());
+    dispatch2(slice.actions.resetSanitizedComponents());
   }
 };
 
@@ -2544,19 +2561,19 @@ async function getDocumentsMap(ids, cache) {
 }
 
 // src/store/actions/load-components-overridable-props.ts
-import { __dispatch as dispatch4, __getState as getState6 } from "@elementor/store";
+import { __dispatch as dispatch3, __getState as getState6 } from "@elementor/store";
 async function loadComponentsOverridableProps(componentIds) {
   const unloadedIds = componentIds.filter((id) => !selectIsOverridablePropsLoaded(getState6(), id));
   if (!unloadedIds.length) {
     return;
   }
   const { data } = await apiClient.getOverridableProps(unloadedIds);
-  dispatch4(slice.actions.loadOverridableProps(data));
+  dispatch3(slice.actions.loadOverridableProps(data));
 }
 
 // src/store/actions/load-components-styles.ts
 import { addDocumentClasses } from "@elementor/editor-global-classes";
-import { __dispatch as dispatch5, __getState as getState7 } from "@elementor/store";
+import { __dispatch as dispatch4, __getState as getState7 } from "@elementor/store";
 function loadComponentsStyles(documents) {
   if (!documents.size) {
     return;
@@ -2575,7 +2592,7 @@ function addStyles(documents) {
       return [id, extractStylesFromDocument(document2)];
     })
   );
-  dispatch5(slice.actions.addStyles(styles));
+  dispatch4(slice.actions.addStyles(styles));
 }
 function extractStylesFromDocument(document2) {
   if (!document2.elements?.length) {
@@ -2647,7 +2664,7 @@ function formatComponentElementsId(elements, path) {
 
 // src/utils/switch-to-component.ts
 import { invalidateDocumentData, switchToDocument } from "@elementor/editor-documents";
-import { getCurrentDocumentContainer, selectElement } from "@elementor/editor-elements";
+import { getCurrentDocumentContainer, selectElement as selectElement2 } from "@elementor/editor-elements";
 import { __privateRunCommand as runCommand } from "@elementor/editor-v1-adapters";
 async function switchToComponent(componentId, componentInstanceId, element) {
   const selector = getSelector(element, componentInstanceId);
@@ -2661,7 +2678,7 @@ async function switchToComponent(componentId, componentInstanceId, element) {
   const currentDocumentContainer = getCurrentDocumentContainer();
   const topLevelElement = currentDocumentContainer?.children?.[0];
   if (topLevelElement) {
-    selectElement(topLevelElement.id);
+    selectElement2(topLevelElement.id);
     expandNavigator();
   }
 }
@@ -3030,10 +3047,10 @@ function createComponentModel() {
 
 // src/populate-store.ts
 import { useEffect as useEffect2 } from "react";
-import { __dispatch as dispatch6 } from "@elementor/store";
+import { __dispatch as dispatch5 } from "@elementor/store";
 function PopulateStore() {
   useEffect2(() => {
-    dispatch6(loadComponents());
+    dispatch5(loadComponents());
   }, []);
   return null;
 }
@@ -3166,10 +3183,10 @@ function blockCircularPaste(args) {
 }
 
 // src/store/actions/remove-component-styles.ts
-import { __dispatch as dispatch7 } from "@elementor/store";
+import { __dispatch as dispatch6 } from "@elementor/store";
 function removeComponentStyles(id) {
   apiClient.invalidateComponentConfigCache(id);
-  dispatch7(slice.actions.removeStyles({ id }));
+  dispatch6(slice.actions.removeStyles({ id }));
 }
 
 // src/store/components-styles-provider.ts