@elementor/editor-components 4.3.0-999 → 4.3.0-beta2

package/dist/index.mjs

@@ -334,14 +334,21 @@ var useIsSanitizedComponent = (componentId, key) => {
 };
 
 // src/utils/component-document-data.ts
-import { getV1DocumentsManager } from "@elementor/editor-documents";
-var getComponentDocumentData = async (id) => {
-  const documentManager = getV1DocumentsManager();
-  try {
-    return await documentManager.request(id);
-  } catch {
-    return null;
-  }
+import { ajax as ajax2 } from "@elementor/editor-v1-adapters";
+var getComponentDocumentParams = (id) => ({
+  action: "get_document_config",
+  unique_id: `document-${id}`,
+  data: { id }
+});
+var pendingRequests = /* @__PURE__ */ new Map();
+var getComponentDocumentData = (id) => {
+  const pendingRequest = pendingRequests.get(id);
+  if (pendingRequest) {
+    return pendingRequest;
+  }
+  const request = ajax2.load(getComponentDocumentParams(id)).catch(() => null).finally(() => pendingRequests.delete(id));
+  pendingRequests.set(id, request);
+  return request;
 };
 
 // src/component-instance-transformer.ts
@@ -375,23 +382,27 @@ import { createTransformer as createTransformer2, settingsTransformersRegistry }
 var componentOverridableTransformer = createTransformer2(
   (value, options) => {
     const { overrides } = options.renderContext ?? {};
+    const originValue = normalizeOriginValue(value.origin_value);
     const overrideValue = overrides?.[value.override_key];
     if (overrideValue) {
-      const isOverride = isOriginValueOverride(value.origin_value);
-      if (isOverride) {
-        return transformOverride(value, options, overrideValue);
+      if (isOriginValueOverride(originValue)) {
+        return transformOverride(originValue, options, overrideValue);
       }
       return overrideValue;
     }
-    return value.origin_value;
+    return originValue;
   }
 );
-function transformOverride(value, options, overrideValue) {
+function normalizeOriginValue(originValue) {
+  const isEmpty = !!originValue && Object.keys(originValue).length === 0;
+  return isEmpty ? null : originValue;
+}
+function transformOverride(originValue, options, overrideValue) {
   const transformer = settingsTransformersRegistry.get("override");
   if (!transformer) {
     return null;
   }
-  const transformedValue = transformer(value.origin_value.value, options);
+  const transformedValue = transformer(originValue.value, options);
   if (!transformedValue) {
     return null;
   }
@@ -401,7 +412,7 @@ function transformOverride(value, options, overrideValue) {
   };
 }
 function isOriginValueOverride(originValue) {
-  return originValue.$$type === "override";
+  return originValue?.$$type === "override";
 }
 
 // src/component-override-transformer.ts
@@ -2612,6 +2623,65 @@ function formatComponentElementsId(elements, path) {
   });
 }
 
+// src/utils/reconcile-component-instance-elements.ts
+import {
+  getWidgetsCache as getWidgetsCache2,
+  reconcileInitialChildren
+} from "@elementor/editor-elements";
+import { hashString as hashString2 } from "@elementor/utils";
+var ELEMENT_ID_LENGTH2 = 7;
+function overridesRecordToMapping(overrides) {
+  const mapping = {};
+  for (const [key, value] of Object.entries(overrides)) {
+    mapping[key] = { value };
+  }
+  return mapping;
+}
+function getElementConfig(element) {
+  const type = element.elType === "widget" ? element.widgetType : element.elType;
+  if (!type) {
+    return void 0;
+  }
+  return getWidgetsCache2()?.[type];
+}
+function deriveIds(element, seed) {
+  const id = hashString2(seed, ELEMENT_ID_LENGTH2);
+  return {
+    ...element,
+    id,
+    elements: (element.elements ?? []).map((child, index) => deriveIds(child, `${id}_${index}`))
+  };
+}
+function reconcileElementTree(element, overridesMapping) {
+  const elementConfig = getElementConfig(element);
+  const withOverrides = applyOverridesToSettings(element.settings ?? {}, overridesMapping);
+  const effectiveSettings = unwrapOverridableSettings(withOverrides);
+  const originalChildren = element.elements ?? [];
+  const originalChildIds = new Set(originalChildren.map((child) => child.id));
+  const attributes = {
+    elements: [...originalChildren],
+    settings: effectiveSettings
+  };
+  if (elementConfig?.children_dependencies?.length) {
+    reconcileInitialChildren({
+      elementId: element.id,
+      elementConfig,
+      attributes
+    });
+  }
+  const reconciledChildren = (attributes.elements ?? []).map(
+    (child) => originalChildIds.has(child.id) ? child : deriveIds(child, `${element.id}_${child.elType}`)
+  ).map((child) => reconcileElementTree(child, overridesMapping));
+  return {
+    ...element,
+    elements: reconciledChildren
+  };
+}
+function reconcileComponentInstanceElements(elements, overrides = {}) {
+  const overridesMapping = overridesRecordToMapping(overrides);
+  return elements.map((element) => reconcileElementTree(element, overridesMapping));
+}
+
 // src/utils/switch-to-component.ts
 import { invalidateDocumentData, switchToDocument } from "@elementor/editor-documents";
 import { getCurrentDocumentContainer, selectElement as selectElement2 } from "@elementor/editor-elements";
@@ -2788,7 +2858,11 @@ function createComponentView(options) {
         };
         const instanceId = this.model.get("id");
         const elements = componentInstance.elements ?? [];
-        const formattedElements = formatComponentElementsId(elements, [instanceId]);
+        const reconciledElements = reconcileComponentInstanceElements(
+          elements,
+          componentInstance.overrides ?? {}
+        );
+        const formattedElements = formatComponentElementsId(reconciledElements, [instanceId]);
         this.collection = legacyWindow.elementor.createBackboneElementsCollection(formattedElements);
         this.collection.models.forEach(setInactiveRecursively);
         settings.component_instance = "<template data-children-placeholder></template>";