@elementor/editor-global-classes 4.1.0-830 → 4.1.0-832

package/dist/index.mjs

@@ -120,6 +120,7 @@ var SnapshotHistory = class _SnapshotHistory {
 var localHistory = SnapshotHistory.get("global-classes");
 var initialState = {
   data: { items: {}, order: [] },
+  classLabels: {},
   initialData: {
     frontend: { items: {}, order: [] },
     preview: { items: {}, order: [] }
@@ -132,17 +133,19 @@ var slice = createSlice({
   initialState,
   reducers: {
     load(state, {
-      payload: { frontend, preview }
+      payload: { frontend, preview, classLabels }
     }) {
       state.initialData.frontend = frontend;
       state.initialData.preview = preview;
       state.data = preview;
+      state.classLabels = classLabels;
       state.isDirty = false;
     },
     add(state, { payload }) {
       localHistory.next(state.data);
       state.data.items[payload.id] = payload;
       state.data.order.unshift(payload.id);
+      state.classLabels[payload.id] = payload.label;
       state.isDirty = true;
     },
     delete(state, { payload }) {
@@ -151,6 +154,7 @@ var slice = createSlice({
         Object.entries(state.data.items).filter(([id2]) => id2 !== payload)
       );
       state.data.order = state.data.order.filter((id2) => id2 !== payload);
+      delete state.classLabels[payload];
       state.isDirty = true;
     },
     setOrder(state, { payload }) {
@@ -172,6 +176,7 @@ var slice = createSlice({
       localHistory.next(state.data);
       Object.entries(payload).forEach(([id2, { modified }]) => {
         state.data.items[id2].label = modified;
+        state.classLabels[id2] = modified;
       });
       state.isDirty = false;
     },
@@ -236,6 +241,28 @@ var slice = createSlice({
         state.data = data;
         state.isDirty = true;
       }
+    },
+    mergeExistingClasses(state, {
+      payload: { preview, frontend }
+    }) {
+      Object.entries(preview).forEach(([id2, previewClassData]) => {
+        const frontendClassData = frontend[id2];
+        if (previewClassData === null || previewClassData === void 0) {
+          return;
+        }
+        if (!(id2 in state.data.items)) {
+          state.data.items[id2] = previewClassData;
+        }
+        if (!(id2 in state.initialData.frontend.items)) {
+          state.initialData.frontend.items[id2] = frontendClassData;
+        }
+        if (!(id2 in state.initialData.preview.items)) {
+          state.initialData.preview.items[id2] = previewClassData;
+        }
+        if (!(id2 in state.classLabels)) {
+          state.classLabels[id2] = previewClassData.label;
+        }
+      });
     }
   }
 });
@@ -255,22 +282,37 @@ var getNonEmptyVariants = (style) => {
     ({ props, custom_css: customCss }) => Object.keys(props).length || customCss?.raw
   );
 };
+var placeholderDefinition = (id2, label) => ({
+  id: id2,
+  type: "class",
+  label,
+  variants: []
+});
 var selectData = (state) => state[SLICE_NAME].data;
+var selectClassLabels = (state) => state[SLICE_NAME].classLabels;
 var selectFrontendInitialData = (state) => state[SLICE_NAME].initialData.frontend;
 var selectPreviewInitialData = (state) => state[SLICE_NAME].initialData.preview;
 var selectOrder = createSelector(selectData, ({ order }) => order);
 var selectGlobalClasses = createSelector(selectData, ({ items }) => items);
 var selectIsDirty = (state) => state[SLICE_NAME].isDirty;
 var selectOrderedClasses = createSelector(
-  selectGlobalClasses,
-  selectOrder,
-  (items, order) => order.map((id2) => items[id2])
+  selectData,
+  selectClassLabels,
+  ({ items, order }, classLabels) => order.map((id2) => {
+    const loaded = items[id2];
+    if (loaded) {
+      return loaded;
+    }
+    const label = classLabels[id2];
+    return label !== void 0 ? placeholderDefinition(id2, label) : null;
+  }).filter((s) => s !== null)
 );
 var selectClass = (state, id2) => state[SLICE_NAME].data.items[id2] ?? null;
 var selectEmptyCssClass = createSelector(
   selectData,
   ({ items }) => Object.values(items).filter((cssClass) => cssClass.variants.length === 0)
 );
+var selectIsClassFetched = (state, id2) => !!state[SLICE_NAME].initialData.preview.items[id2] || !!state[SLICE_NAME].initialData.frontend.items[id2] || false;
 
 // src/hooks/use-classes-order.ts
 var useClassesOrder = () => {
@@ -356,21 +398,26 @@ import { httpService } from "@elementor/http-client";
 var RESOURCE_URL = "/global-classes";
 var BASE_URL = "elementor/v1";
 var RESOURCE_USAGE_URL = `${RESOURCE_URL}/usage`;
+var RESOURCE_POST_URL = `${RESOURCE_URL}/post`;
+var RESOURCE_STYLES_URL = `${RESOURCE_URL}/styles`;
+function saveGlobalClasses(context2, payload) {
+  return httpService().put(`${BASE_URL}${RESOURCE_URL}`, payload, {
+    params: { context: context2 }
+  });
+}
 var apiClient = {
   usage: () => httpService().get(`${BASE_URL}${RESOURCE_USAGE_URL}`),
   all: (context2 = "preview") => httpService().get(`${BASE_URL}${RESOURCE_URL}`, {
     params: { context: context2 }
   }),
-  publish: (payload) => httpService().put("elementor/v1" + RESOURCE_URL, payload, {
-    params: {
-      context: "frontend"
-    }
+  getStylesForPost: (postId, context2 = "preview") => httpService().get(`${BASE_URL}${RESOURCE_POST_URL}`, {
+    params: { context: context2, post_id: postId }
   }),
-  saveDraft: (payload) => httpService().put("elementor/v1" + RESOURCE_URL, payload, {
-    params: {
-      context: "preview"
-    }
-  })
+  getStylesByIds: (ids, context2 = "preview") => httpService().get(`${BASE_URL}${RESOURCE_STYLES_URL}`, {
+    params: { context: context2, ids: ids.join(",") }
+  }),
+  publish: (payload) => saveGlobalClasses("frontend", payload),
+  saveDraft: (payload) => saveGlobalClasses("preview", payload)
 };
 var API_ERROR_CODES = {
   DUPLICATED_LABEL: "DUPLICATED_LABEL"
@@ -718,15 +765,20 @@ var extractCssClassData = (classId) => {
   return { classTitle };
 };
 var getCssClass = (classId) => {
-  const cssClass = selectClass(getState(), classId);
-  if (!cssClass) {
-    throw new Error(`CSS class with ID ${classId} not found`);
+  const state = getState();
+  const cssClass = selectClass(state, classId);
+  if (cssClass) {
+    return cssClass;
   }
-  return cssClass;
+  const label = selectClassLabels(state)[classId];
+  if (label !== void 0) {
+    return placeholderDefinition(classId, label);
+  }
+  throw new Error(`CSS class with ID ${classId} not found`);
 };
 var trackDeleteClass = async (classId) => {
-  const totalInstances = await getTotalInstancesByCssClassID(classId);
   const classTitle = getCssClass(classId).label;
+  const totalInstances = await getTotalInstancesByCssClassID(classId);
   return { totalInstances, classTitle };
 };
 var getTotalInstancesByCssClassID = async (classId) => {
@@ -746,14 +798,19 @@ var getRemovedInfo = (classId) => {
 };
 
 // src/save-global-classes.tsx
-async function saveGlobalClasses({ context: context2, onApprove }) {
+async function saveGlobalClasses2({ context: context2, onApprove }) {
   const state = selectData(getState2());
   const apiAction = context2 === "preview" ? apiClient.saveDraft : apiClient.publish;
   const currentContext = context2 === "preview" ? selectPreviewInitialData : selectFrontendInitialData;
+  const changes = calculateChanges(state, currentContext(getState2()));
+  const touchedIds = [...changes.added, ...changes.modified];
+  const touchedItems = Object.fromEntries(
+    touchedIds.map((id2) => [id2, state.items[id2]]).filter(([, v]) => v)
+  );
   const response = await apiAction({
-    items: state.items,
+    items: touchedItems,
     order: state.order,
-    changes: calculateChanges(state, currentContext(getState2()))
+    changes
   });
   dispatch(slice.actions.reset({ context: context2 }));
   window.dispatchEvent(new CustomEvent("classes:updated", { detail: { context: context2 } }));
@@ -777,12 +834,16 @@ async function saveGlobalClasses({ context: context2, onApprove }) {
 function calculateChanges(state, initialData) {
   const stateIds = Object.keys(state.items);
   const initialDataIds = Object.keys(initialData.items);
+  const { order: stateOrder } = state;
+  const { order: initialDataOrder } = initialData;
+  const order = stateOrder.join(";") !== initialDataOrder.join(";");
   return {
     added: stateIds.filter((id2) => !initialDataIds.includes(id2)),
     deleted: initialDataIds.filter((id2) => !stateIds.includes(id2)),
     modified: stateIds.filter((id2) => {
       return id2 in initialData.items && hash(state.items[id2]) !== hash(initialData.items[id2]);
-    })
+    }),
+    order
   };
 }
 
@@ -1821,7 +1882,7 @@ var GlobalClassesList = ({
     search: { debouncedValue: searchValue }
   } = useSearchAndFilters();
   const cssClasses = useOrderedClasses();
-  const dispatch5 = useDispatch();
+  const dispatch7 = useDispatch();
   const filters = useFilters();
   const [draggedItemId, setDraggedItemId] = useState5(null);
   const draggedItemLabel = cssClasses.find((cssClass) => cssClass.id === draggedItemId)?.label ?? "";
@@ -1853,17 +1914,17 @@ var GlobalClassesList = ({
         event.stopImmediatePropagation();
         event.preventDefault();
         if (event.shiftKey) {
-          dispatch5(slice.actions.redo());
+          dispatch7(slice.actions.redo());
           return;
         }
-        dispatch5(slice.actions.undo());
+        dispatch7(slice.actions.undo());
       }
     };
     window.addEventListener("keydown", handler2, {
       capture: true
     });
     return () => window.removeEventListener("keydown", handler2);
-  }, [dispatch5]);
+  }, [dispatch7]);
   if (!cssClasses?.length) {
     return /* @__PURE__ */ React17.createElement(EmptyState, null);
   }
@@ -1920,7 +1981,7 @@ var GlobalClassesList = ({
                   newValue: newLabel,
                   source: "class-manager"
                 });
-                dispatch5(
+                dispatch7(
                   slice.actions.update({
                     style: {
                       id: cssClass.id,
@@ -1943,7 +2004,7 @@ var GlobalClassesList = ({
                 } else if (newValue && onStartSyncRequest) {
                   onStartSyncRequest(id2);
                 } else {
-                  dispatch5(
+                  dispatch7(
                     slice.actions.update({
                       style: {
                         id: id2,
@@ -1970,10 +2031,10 @@ var StyledHeader = styled6(Typography8)(({ theme, variant }) => ({
   }
 }));
 var useReorder = (draggedItemId, setDraggedItemId, draggedItemLabel) => {
-  const dispatch5 = useDispatch();
+  const dispatch7 = useDispatch();
   const order = useClassesOrder();
   const reorder = (newIds) => {
-    dispatch5(slice.actions.setOrder(newIds));
+    dispatch7(slice.actions.setOrder(newIds));
     if (draggedItemId) {
       trackGlobalClasses({
         event: "classManagerReorder",
@@ -2340,7 +2401,7 @@ var usePreventUnload = () => {
 };
 var usePublish = () => {
   return useMutation({
-    mutationFn: () => saveGlobalClasses({ context: "frontend" }),
+    mutationFn: () => saveGlobalClasses2({ context: "frontend" }),
     onSuccess: async () => {
       setDocumentModifiedStatus(false);
       if (hasDeletedItems()) {
@@ -2379,14 +2440,17 @@ var StopSyncConfirmationDialog = ({ open, onClose, onConfirm }) => {
   ));
 };
 
+// src/mcp-integration/classes-resource.ts
+import { __getState as getState5 } from "@elementor/store";
+
 // src/global-classes-styles-provider.ts
 import {
   generateId
 } from "@elementor/editor-styles";
 import { createStylesProvider } from "@elementor/editor-styles-repository";
 import {
-  __dispatch as dispatch4,
-  __getState as getState3,
+  __dispatch as dispatch6,
+  __getState as getState4,
   __subscribeWithSelector as subscribeWithSelector
 } from "@elementor/store";
 import { __ as __15 } from "@wordpress/i18n";
@@ -2407,10 +2471,112 @@ var getCapabilities = () => {
   }
 };
 
+// src/load-existing-classes.ts
+import { __dispatch as dispatch5, __getState as getState3 } from "@elementor/store";
+
+// src/load-document-classes.ts
+import { getCurrentDocument } from "@elementor/editor-documents";
+import { __dispatch as dispatch4 } from "@elementor/store";
+
+// src/utils/create-labels-for-classes.ts
+function createLabelsForClasses(entries) {
+  return Object.fromEntries(entries.map((e) => [e.id, e.label]));
+}
+
+// src/load-document-classes.ts
+function styleDefinitionsMapWithoutNull(map) {
+  return Object.fromEntries(
+    Object.entries(map).filter(
+      (entry) => entry[1] !== null
+    )
+  );
+}
+function resetGlobalClassesState(globalOrder, classLabels) {
+  dispatch4(
+    slice.actions.load({
+      preview: { items: {}, order: globalOrder },
+      frontend: { items: {}, order: globalOrder },
+      classLabels
+    })
+  );
+}
+async function loadCurrentDocumentClasses() {
+  const previewIndexRes = await apiClient.all("preview");
+  const previewIndex = previewIndexRes.data.data;
+  const classLabels = createLabelsForClasses(previewIndex);
+  const globalOrder = previewIndex.map((e) => e.id);
+  resetGlobalClassesState(globalOrder, classLabels);
+  const postId = getCurrentDocument()?.id;
+  if (!postId) {
+    return;
+  }
+  const [previewPostRes, frontendPostRes] = await Promise.all([
+    apiClient.getStylesForPost(postId, "preview"),
+    apiClient.getStylesForPost(postId, "frontend")
+  ]);
+  const previewItems = styleDefinitionsMapWithoutNull(previewPostRes.data.data);
+  const frontendItems = styleDefinitionsMapWithoutNull(frontendPostRes.data.data);
+  dispatch4(
+    slice.actions.load({
+      preview: { items: previewItems, order: globalOrder },
+      frontend: { items: frontendItems, order: globalOrder },
+      classLabels
+    })
+  );
+}
+async function addDocumentClasses(documentId) {
+  const [previewPostRes, frontendPostRes] = await Promise.all([
+    apiClient.getStylesForPost(documentId, "preview"),
+    apiClient.getStylesForPost(documentId, "frontend")
+  ]);
+  const previewItems = styleDefinitionsMapWithoutNull(previewPostRes.data.data);
+  const frontendItems = styleDefinitionsMapWithoutNull(frontendPostRes.data.data);
+  dispatch4(
+    slice.actions.mergeExistingClasses({
+      preview: previewItems,
+      frontend: frontendItems
+    })
+  );
+}
+
+// src/load-existing-classes.ts
+var pendingLoad = null;
+var pendingIds = /* @__PURE__ */ new Set();
+async function loadExistingClasses(classIds) {
+  const existingClasses = selectGlobalClasses(getState3());
+  const missingIds = classIds.filter((id2) => !(id2 in existingClasses));
+  if (missingIds.length === 0) {
+    return;
+  }
+  missingIds.forEach((id2) => pendingIds.add(id2));
+  if (pendingLoad) {
+    await pendingLoad;
+    return loadExistingClasses(classIds);
+  }
+  pendingLoad = fetchAndMergeClasses();
+  try {
+    await pendingLoad;
+  } finally {
+    pendingLoad = null;
+  }
+}
+async function fetchAndMergeClasses() {
+  const idsToFetch = Array.from(pendingIds);
+  pendingIds.clear();
+  if (idsToFetch.length === 0) {
+    return;
+  }
+  const previewResponse = await apiClient.getStylesByIds(idsToFetch, "preview");
+  const frontendResponse = await apiClient.getStylesByIds(idsToFetch, "frontend");
+  const previewItems = styleDefinitionsMapWithoutNull(previewResponse.data.data);
+  const frontendItems = styleDefinitionsMapWithoutNull(frontendResponse.data.data);
+  dispatch5(slice.actions.mergeExistingClasses({ preview: previewItems, frontend: frontendItems }));
+}
+
 // src/global-classes-styles-provider.ts
-var MAX_CLASSES = 100;
+var MAX_CLASSES = 5e3;
 var GLOBAL_CLASSES_PROVIDER_KEY = "global-classes";
-var PREGENERATED_LINK_PATTERN = /^global-(preview|frontend)-[a-zA-Z_-]+-css$/;
+var PREGENERATED_LINK_PATTERN = /^global-([0-9]+-)?(preview|frontend)-[a-zA-Z_-]+-css$/;
 var globalClassesStylesProvider = createStylesProvider({
   key: GLOBAL_CLASSES_PROVIDER_KEY,
   priority: 30,
@@ -2423,21 +2589,38 @@ var globalClassesStylesProvider = createStylesProvider({
   subscribe: (cb) => subscribeWithStates(cb),
   capabilities: getCapabilities(),
   actions: {
-    all: () => selectOrderedClasses(getState3()),
-    get: (id2) => selectClass(getState3(), id2),
+    all: () => selectOrderedClasses(getState4()),
+    get: (id2) => {
+      const state = getState4();
+      const isFetched = selectIsClassFetched(state, id2);
+      const style = selectClass(state, id2);
+      if (isFetched || style) {
+        return style;
+      }
+      loadExistingClasses([id2]);
+      const label = selectClassLabels(state)[id2] ?? id2;
+      return placeholderDefinition(id2, label);
+    },
     resolveCssName: (id2) => {
-      return selectClass(getState3(), id2)?.label ?? id2;
+      const state = getState4();
+      const loaded = selectClass(state, id2);
+      if (loaded) {
+        return loaded.label;
+      }
+      const fromIndex = selectClassLabels(state)[id2];
+      return fromIndex ?? id2;
     },
     create: (label, variants = [], id2) => {
-      const classes = selectGlobalClasses(getState3());
-      const existingLabels = Object.values(classes).map((style) => style.label);
+      const existingClasses = Object.entries(selectClassLabels(getState4()));
+      const existingLabels = existingClasses.map(([, classLabel]) => classLabel);
       if (existingLabels.includes(label)) {
         throw new GlobalClassLabelAlreadyExistsError({ context: { label } });
       }
+      const existingIds = existingClasses.map(([existingId]) => existingId);
       if (!id2) {
-        id2 = generateId("g-", Object.keys(classes));
+        id2 = generateId("g-", existingIds);
       }
-      dispatch4(
+      dispatch6(
         slice.actions.add({
           id: id2,
           type: "class",
@@ -2448,17 +2631,17 @@ var globalClassesStylesProvider = createStylesProvider({
       return id2;
     },
     update: (payload) => {
-      dispatch4(
+      dispatch6(
         slice.actions.update({
           style: payload
         })
       );
     },
     delete: (id2) => {
-      dispatch4(slice.actions.delete(id2));
+      dispatch6(slice.actions.delete(id2));
     },
     updateProps: (args) => {
-      dispatch4(
+      dispatch6(
         slice.actions.updateProps({
           id: args.id,
           meta: args.meta,
@@ -2468,7 +2651,7 @@ var globalClassesStylesProvider = createStylesProvider({
       );
     },
     updateCustomCss: (args) => {
-      dispatch4(
+      dispatch6(
         slice.actions.updateProps({
           id: args.id,
           meta: args.meta,
@@ -2485,12 +2668,12 @@ var globalClassesStylesProvider = createStylesProvider({
   }
 });
 var subscribeWithStates = (cb) => {
-  let previousState = selectData(getState3());
+  let previousState = selectData(getState4());
   return subscribeWithSelector(
-    (state) => state.globalClasses,
+    (state) => selectData(state),
     (currentState) => {
-      cb(previousState.items, currentState.data.items);
-      previousState = currentState.data;
+      cb(previousState.items, currentState.items);
+      previousState = currentState;
     }
   );
 };
@@ -2499,7 +2682,7 @@ var subscribeWithStates = (cb) => {
 var GLOBAL_CLASSES_URI = "elementor://global-classes";
 var STORAGE_KEY = "elementor-global-classes";
 var updateLocalStorageCache = () => {
-  const classes = globalClassesStylesProvider.actions.all();
+  const classes = selectOrderedClasses(getState5());
   localStorage.setItem(STORAGE_KEY, JSON.stringify(classes));
 };
 var initClassesResource = (classesMcpEntry, canvasMcpEntry) => {
@@ -2687,47 +2870,25 @@ import { useEffect as useEffect5 } from "react";
 import { GLOBAL_STYLES_IMPORTED_EVENT } from "@elementor/editor-canvas";
 import { __useDispatch as useDispatch2 } from "@elementor/store";
 function GlobalStylesImportListener() {
-  const dispatch5 = useDispatch2();
+  const dispatch7 = useDispatch2();
   useEffect5(() => {
     const handleGlobalStylesImported = (event) => {
       const importedClasses = event.detail?.global_classes;
       if (importedClasses?.items && importedClasses?.order) {
-        dispatch5(
-          slice.actions.load({
-            preview: {
-              items: importedClasses.items,
-              order: importedClasses.order
-            },
-            frontend: {
-              items: importedClasses.items,
-              order: importedClasses.order
-            }
+        const { items } = importedClasses;
+        dispatch7(
+          slice.actions.mergeExistingClasses({
+            preview: items,
+            frontend: items
           })
         );
       }
-      Promise.all([apiClient.all("preview"), apiClient.all("frontend")]).then(([previewRes, frontendRes]) => {
-        const { data: previewData } = previewRes;
-        const { data: frontendData } = frontendRes;
-        dispatch5(
-          slice.actions.load({
-            preview: {
-              items: previewData.data,
-              order: previewData.meta.order
-            },
-            frontend: {
-              items: frontendData.data,
-              order: frontendData.meta.order
-            }
-          })
-        );
-      }).catch(() => {
-      });
     };
     window.addEventListener(GLOBAL_STYLES_IMPORTED_EVENT, handleGlobalStylesImported);
     return () => {
       window.removeEventListener(GLOBAL_STYLES_IMPORTED_EVENT, handleGlobalStylesImported);
     };
-  }, [dispatch5]);
+  }, [dispatch7]);
   return null;
 }
 
@@ -2762,29 +2923,14 @@ function OpenPanelFromUrl() {
 
 // src/components/populate-store.tsx
 import { useEffect as useEffect7 } from "react";
-import { __useDispatch as useDispatch3 } from "@elementor/store";
+import { registerDataHook } from "@elementor/editor-v1-adapters";
 function PopulateStore() {
-  const dispatch5 = useDispatch3();
   useEffect7(() => {
-    Promise.all([apiClient.all("preview"), apiClient.all("frontend")]).then(
-      ([previewRes, frontendRes]) => {
-        const { data: previewData } = previewRes;
-        const { data: frontendData } = frontendRes;
-        dispatch5(
-          slice.actions.load({
-            preview: {
-              items: previewData.data,
-              order: previewData.meta.order
-            },
-            frontend: {
-              items: frontendData.data,
-              order: frontendData.meta.order
-            }
-          })
-        );
-      }
-    );
-  }, [dispatch5]);
+    loadCurrentDocumentClasses();
+    registerDataHook("after", "editor/documents/attach-preview", async () => {
+      await loadCurrentDocumentClasses();
+    });
+  }, []);
   return null;
 }
 
@@ -3153,7 +3299,7 @@ async function attemptCreate(opts) {
     }
   ]);
   try {
-    await saveGlobalClasses({ context: "frontend" });
+    await saveGlobalClasses2({ context: "frontend" });
     return newClassId;
   } catch {
     deleteClass2(newClassId);
@@ -3179,7 +3325,7 @@ async function attemptUpdate(opts) {
         state
       }
     });
-    await saveGlobalClasses({ context: "frontend" });
+    await saveGlobalClasses2({ context: "frontend" });
     return true;
   } catch {
     snapshot.forEach((style) => {
@@ -3188,7 +3334,7 @@ async function attemptUpdate(opts) {
         variants: style.variants
       });
     });
-    await saveGlobalClasses({ context: "frontend" });
+    await saveGlobalClasses2({ context: "frontend" });
     return false;
   }
 }
@@ -3208,7 +3354,7 @@ async function attemptDelete(opts) {
   }
   try {
     deleteClass2(classId);
-    await saveGlobalClasses({ context: "frontend" });
+    await saveGlobalClasses2({ context: "frontend" });
     return true;
   } catch {
     return false;
@@ -3240,8 +3386,8 @@ import { __privateListenTo as listenTo2, isExperimentActive as isExperimentActiv
 // src/sync-with-document-save.ts
 import { getCurrentUser } from "@elementor/editor-current-user";
 import { setDocumentModifiedStatus as setDocumentModifiedStatus2 } from "@elementor/editor-documents";
-import { registerDataHook } from "@elementor/editor-v1-adapters";
-import { __getState as getState4, __subscribeWithSelector as subscribeWithSelector2 } from "@elementor/store";
+import { registerDataHook as registerDataHook2 } from "@elementor/editor-v1-adapters";
+import { __getState as getState6, __subscribeWithSelector as subscribeWithSelector2 } from "@elementor/store";
 var pendingSave = null;
 function syncWithDocumentSave(panelActions) {
   const unsubscribe = syncDirtyState();
@@ -3266,7 +3412,7 @@ function triggerSave(panelActions, context2 = "preview") {
   if (pendingSave) {
     return pendingSave;
   }
-  const promise = saveGlobalClasses({
+  const promise = saveGlobalClasses2({
     context: context2,
     onApprove: panelActions?.open
   });
@@ -3277,7 +3423,7 @@ function triggerSave(panelActions, context2 = "preview") {
   return promise;
 }
 function bindSaveAction(panelActions) {
-  registerDataHook("dependency", "document/save/save", (args) => {
+  registerDataHook2("dependency", "document/save/save", (args) => {
     triggerSave(panelActions, args.status === "publish" ? "frontend" : "preview");
     return true;
   });
@@ -3293,7 +3439,7 @@ function bindBeforeSaveTemplateAction() {
   }));
 }
 function isDirty() {
-  return selectIsDirty(getState4());
+  return selectIsDirty(getState6());
 }
 
 // src/sync-with-document.tsx
@@ -3360,6 +3506,9 @@ function init() {
 export {
   ClassManagerPanelEmbedded,
   GLOBAL_CLASSES_URI,
-  init
+  addDocumentClasses,
+  createLabelsForClasses,
+  init,
+  loadExistingClasses
 };
 //# sourceMappingURL=index.mjs.map