@elementor/editor-components 3.35.0-473 → 3.35.0-475

package/dist/index.mjs

@@ -2319,31 +2319,48 @@ var archiveComponent = (componentId, componentName) => {
 // src/store/actions/load-components-assets.ts
 import { isDocumentDirty, setDocumentModifiedStatus as setDocumentModifiedStatus5 } from "@elementor/editor-documents";
 
-// src/utils/get-component-ids.ts
-var getComponentIds = async (elements) => {
-  const components = elements.map(async ({ widgetType, elType, elements: childElements, settings }) => {
-    const ids = [];
-    const isComponent = isComponentInstance({ widgetType, elType });
-    if (isComponent) {
-      const componentId = settings?.component_instance?.value?.component_id.value;
-      if (!componentId) {
-        return;
-      }
-      const document = await getComponentDocumentData(componentId);
-      childElements = document?.elements;
-      if (Boolean(componentId)) {
+// src/utils/get-component-documents.ts
+async function getComponentDocuments(elements, cache = /* @__PURE__ */ new Map()) {
+  const componentIds = await getComponentIds(elements, cache);
+  return getDocumentsMap(componentIds, cache);
+}
+async function getComponentIds(elements, cache) {
+  const results = await Promise.all(
+    elements.map(async ({ widgetType, elType, elements: childElements, settings }) => {
+      const ids = [];
+      if (isComponentInstance({ widgetType, elType })) {
+        const componentId = settings?.component_instance?.value?.component_id.value;
+        if (!componentId) {
+          return ids;
+        }
         ids.push(componentId);
+        if (!cache.has(componentId)) {
+          cache.set(componentId, getComponentDocumentData(componentId));
+        }
+        const doc = await cache.get(componentId);
+        childElements = doc?.elements;
       }
-    }
-    if (!!childElements?.length) {
-      const newIds = await getComponentIds(childElements);
-      ids.push(...Array.from(new Set(newIds)));
-    }
-    return ids;
-  });
-  const result = (await Promise.all(components)).flat();
-  return Array.from(new Set(result)).filter((value) => value !== void 0);
-};
+      if (childElements?.length) {
+        const childIds = await getComponentIds(childElements, cache);
+        ids.push(...childIds);
+      }
+      return ids;
+    })
+  );
+  return [...new Set(results.flat())];
+}
+async function getDocumentsMap(ids, cache) {
+  const documents = await Promise.all(
+    ids.map(async (id2) => {
+      const document = await cache.get(id2);
+      if (!document) {
+        return null;
+      }
+      return [id2, document];
+    })
+  );
+  return new Map(documents.filter((document) => document !== null));
+}
 
 // src/store/actions/load-components-overridable-props.ts
 import { __dispatch as dispatch10, __getState as getState12 } from "@elementor/store";
@@ -2372,48 +2389,47 @@ async function loadComponentOverrides(componentId) {
 
 // src/store/actions/load-components-styles.ts
 import { __dispatch as dispatch11, __getState as getState13 } from "@elementor/store";
-async function loadComponentsStyles(componentIds) {
-  if (!componentIds.length) {
+function loadComponentsStyles(documents) {
+  if (!documents.size) {
     return;
   }
   const knownComponents = selectStyles(getState13());
-  const unknownComponentIds = componentIds.filter((id2) => !knownComponents[id2]);
-  if (!unknownComponentIds.length) {
+  const unknownDocuments = new Map([...documents.entries()].filter(([id2]) => !knownComponents[id2]));
+  if (!unknownDocuments.size) {
     return;
   }
-  await addComponentStyles(unknownComponentIds);
-}
-async function addComponentStyles(ids) {
-  const newComponents = await loadStyles(ids);
-  addStyles(newComponents);
-}
-async function loadStyles(ids) {
-  return Promise.all(ids.map(async (id2) => [id2, await apiClient.getComponentConfig(id2)]));
+  addStyles(unknownDocuments);
 }
-function addStyles(data) {
+function addStyles(documents) {
   const styles = Object.fromEntries(
-    data.map(([componentId, componentData]) => [componentId, extractStyles(componentData)])
+    [...documents.entries()].map(([id2, document]) => [id2, extractStylesFromDocument(document)])
   );
   dispatch11(slice.actions.addStyles(styles));
 }
-function extractStyles(element) {
-  return [...Object.values(element.styles ?? {}), ...(element.elements ?? []).flatMap(extractStyles)];
+function extractStylesFromDocument(document) {
+  if (!document.elements?.length) {
+    return [];
+  }
+  return document.elements.flatMap(extractStylesFromElement);
+}
+function extractStylesFromElement(element) {
+  return [
+    ...Object.values(element.styles ?? {}),
+    ...(element.elements ?? []).flatMap(extractStylesFromElement)
+  ];
 }
 
 // src/store/actions/load-components-assets.ts
 async function loadComponentsAssets(elements) {
-  const componentIds = await getComponentIds(elements);
+  const documents = await getComponentDocuments(elements);
   return Promise.all([
-    updateDocumentState(componentIds),
-    loadComponentsOverridableProps(componentIds),
-    loadComponentsStyles(componentIds)
+    updateDocumentState(documents),
+    loadComponentsOverridableProps([...documents.keys()]),
+    loadComponentsStyles(documents)
   ]);
 }
-async function updateDocumentState(componentIds) {
-  const components = (await Promise.all(componentIds.map(getComponentDocumentData))).filter(
-    (document) => !!document
-  );
-  const isDrafted = components.some(isDocumentDirty);
+function updateDocumentState(documents) {
+  const isDrafted = [...documents.values()].some(isDocumentDirty);
   if (isDrafted) {
     setDocumentModifiedStatus5(true);
   }
@@ -5087,9 +5103,8 @@ async function updateComponentsBeforeSave({ status, elements }) {
   if (status !== "publish") {
     return;
   }
-  const componentIds = await getComponentIds(elements);
-  const componentDocumentData = await Promise.all(componentIds.map(getComponentDocumentData));
-  const draftIds = componentDocumentData.filter((document) => !!document).filter(isDocumentDirty2).map((document) => document.id);
+  const documents = await getComponentDocuments(elements);
+  const draftIds = [...documents.values()].filter(isDocumentDirty2).map((document) => document.id);
   if (draftIds.length === 0) {
     return;
   }