@antibusy/strapi-plugin-content-manager-sort 1.1.7

package/dist/admin/index.js

@@ -0,0 +1,780 @@
+"use strict";
+const react = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+const ReactDOM = require("react-dom/client");
+const admin = require("@strapi/strapi/admin");
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const ReactDOM__namespace = /* @__PURE__ */ _interopNamespace(ReactDOM);
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const PLUGIN_ID = "content-manager-sort";
+const Initializer = ({ setPlugin }) => {
+  const ref = react.useRef(setPlugin);
+  react.useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const defaultDelimiter = " | ";
+const defaultTemplate = "accordion";
+const navQuery = 'nav[aria-label="Content Manager"]';
+const stackNavContainerId = "stack-nav-container";
+const customNavContentSelector = '[data-content-manager-sort-content="true"]';
+const contentManagerLinkSelector = [
+  'a[href*="/admin/content-manager/collection-types/"]',
+  'a[href*="/admin/content-manager/single-types/"]'
+].join(", ");
+const contentManagerSearchSelector = [
+  'input[name="search_contentType"]',
+  'input[type="search"][placeholder="Search"]'
+].join(", ");
+const navigationRoots = /* @__PURE__ */ new WeakMap();
+const findContentManagerNavRoot = () => {
+  const labelledNav = document.querySelector(navQuery);
+  if (labelledNav) return labelledNav;
+  const existingNav = document.getElementById(stackNavContainerId);
+  const existingRoot = existingNav?.closest("nav, [data-radix-scroll-area-viewport], aside");
+  if (existingRoot) return existingRoot;
+  const searchInput = document.querySelector(contentManagerSearchSelector);
+  const searchRoot = searchInput?.closest("nav, [data-radix-scroll-area-viewport], aside");
+  if (searchRoot) return searchRoot;
+  const contentManagerLink = document.querySelector(contentManagerLinkSelector);
+  return contentManagerLink?.closest("nav, [data-radix-scroll-area-viewport], aside") || null;
+};
+const findContentManagerSearchInput = (root = findContentManagerNavRoot()) => {
+  return root?.querySelector(contentManagerSearchSelector) || null;
+};
+const findContentTypeLists = (root = findContentManagerNavRoot()) => {
+  if (!root) return [];
+  return Array.from(root.querySelectorAll("ol")).filter((ol) => {
+    return Boolean(
+      ol.querySelector(contentManagerLinkSelector) || ol.querySelector(`#${stackNavContainerId}`)
+    );
+  });
+};
+const findStackNavigationList = (root = findContentManagerNavRoot()) => {
+  const existingNav = document.getElementById(stackNavContainerId);
+  if (existingNav?.parentElement?.tagName === "OL") {
+    return existingNav.parentElement;
+  }
+  const lists = findContentTypeLists(root);
+  return lists.find((ol) => ol.querySelector('a[href*="/admin/content-manager/collection-types/"]')) || lists[0] || null;
+};
+const findOriginalContentTypeItems = (root = findContentManagerNavRoot()) => {
+  return findContentTypeLists(root).flatMap((ol) => {
+    return Array.from(ol.children).filter((child) => {
+      return child instanceof HTMLElement && child.tagName === "LI" && child.id !== stackNavContainerId;
+    });
+  });
+};
+const findSectionHeaderContainer = (label) => {
+  const labelText = label.textContent?.trim();
+  let parent = label.parentElement;
+  for (let i = 0; i < 8 && parent; i++) {
+    const spans = Array.from(parent.querySelectorAll("span"));
+    const hasLabel = spans.some((span) => span.textContent?.trim() === labelText);
+    const hasCountBadge = spans.some((span) => /^\d+$/.test(span.textContent?.trim() || ""));
+    const containsContentTypeList = Boolean(parent.querySelector(contentManagerLinkSelector));
+    if (parent.tagName === "DIV" && hasLabel && !containsContentTypeList && (hasCountBadge || i >= 2)) {
+      return parent;
+    }
+    parent = parent.parentElement;
+  }
+  return label.parentElement;
+};
+const hasCustomNavigationContent = () => {
+  return Boolean(
+    document.getElementById(stackNavContainerId)?.querySelector(customNavContentSelector)
+  );
+};
+const getPluginConfig = async () => {
+  let delimiter = process.env.CONTENT_MANAGER_SORT_DELIMITER || defaultDelimiter;
+  let template = process.env.CONTENT_MANAGER_SORT_TEMPLATE || defaultTemplate;
+  const config = await fetch(`/content-manager-sort/config`).then((res) => {
+    return res.json();
+  }).catch(() => ({}));
+  if (config) {
+    delimiter = config.delimiter || delimiter;
+    template = config.template || template;
+  }
+  return { delimiter, template };
+};
+const formatContentTypes = (delimiter, data) => {
+  if (!data || !data.data) return [];
+  const defaultSortOrder = data.data.length + 1e3;
+  return data.data.filter((ct) => {
+    return ct.uid.startsWith("api::") || ct.uid.startsWith("plugin::");
+  }).map((ct) => {
+    const displayName = ct.info?.displayName || ct.schema?.displayName || ct.apiID;
+    const kind = ct.kind || ct.schema?.kind;
+    const { sortOrder, cleanDisplayName } = extractSortOrder(displayName, defaultSortOrder);
+    const groupName = getContentTypeGroup(delimiter, cleanDisplayName);
+    let newDisplayName = cleanDisplayName;
+    if (newDisplayName.startsWith(groupName + delimiter)) {
+      newDisplayName = newDisplayName.slice((groupName + delimiter).length);
+    }
+    return {
+      uid: ct.uid,
+      name: ct.apiID,
+      displayName: newDisplayName,
+      group: groupName,
+      isDisplayed: true,
+      href: `/admin/content-manager/${kind === "singleType" ? "single-types" : "collection-types"}/${ct.uid}`,
+      kind,
+      sortOrder
+    };
+  });
+};
+const extractSortOrder = (displayName, defaultSortOrder = 999) => {
+  const match = displayName.match(/^\[(\d+)\]\s*/);
+  if (match) {
+    const sortOrder = parseInt(match[1], 10);
+    const cleanDisplayName = displayName.replace(/^\[\d+\]\s*/, "");
+    return { sortOrder, cleanDisplayName };
+  }
+  return { sortOrder: defaultSortOrder, cleanDisplayName: displayName };
+};
+const getContentTypeGroup = (delimiter, displayName) => {
+  const entity = displayName.split(delimiter).map((name) => name.trim());
+  return entity[0];
+};
+const cleanHeaderText = (text) => {
+  return text.replace(/^\[\d+\]\s*/, "");
+};
+const setupHeaderCleaning = () => {
+  const cleanHeaderElement = () => {
+    const headerDiv = document.querySelector('div[data-strapi-header="true"]');
+    if (headerDiv) {
+      const h1Element = headerDiv.querySelector("h1");
+      if (h1Element && h1Element.textContent) {
+        const cleanedText = cleanHeaderText(h1Element.textContent);
+        if (cleanedText !== h1Element.textContent) {
+          h1Element.textContent = cleanedText;
+        }
+      }
+    }
+  };
+  const cleanNavigationItems = () => {
+    const nav = findContentManagerNavRoot();
+    if (!nav) return;
+    const navLinks = nav.querySelectorAll(contentManagerLinkSelector);
+    navLinks.forEach((link) => {
+      const textElements = link.querySelectorAll("div, span");
+      textElements.forEach((element) => {
+        if (element.textContent && element.textContent.match(/^\[\d+\]/)) {
+          const cleanedText = cleanHeaderText(element.textContent);
+          if (cleanedText !== element.textContent) {
+            element.textContent = cleanedText;
+          }
+        }
+      });
+    });
+  };
+  cleanHeaderElement();
+  cleanNavigationItems();
+  const headerObserver = new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      if (mutation.type === "childList" || mutation.type === "characterData") {
+        const target = mutation.target;
+        if (target.nodeType === Node.ELEMENT_NODE) {
+          const headerDiv = target.closest('div[data-strapi-header="true"]') || target.querySelector('div[data-strapi-header="true"]');
+          if (headerDiv) {
+            cleanHeaderElement();
+            break;
+          }
+          const navItem = target.closest(contentManagerLinkSelector) || target.querySelector(contentManagerLinkSelector);
+          if (navItem) {
+            cleanNavigationItems();
+            break;
+          }
+        }
+      }
+    }
+  });
+  headerObserver.observe(document.body, {
+    childList: true,
+    subtree: true,
+    characterData: true
+  });
+  return headerObserver;
+};
+const hideCollectionTypeHeaders = (hide = true, root = findContentManagerNavRoot()) => {
+  if (!root) return;
+  const allSpans = root.querySelectorAll("span");
+  allSpans.forEach((span) => {
+    if (span.closest(`#${stackNavContainerId}`)) return;
+    const text = span.textContent?.trim();
+    if (text === "Collection Types" || text === "Single Types") {
+      const headerContainer = findSectionHeaderContainer(span);
+      if (headerContainer) {
+        headerContainer.style.display = hide ? "none" : "";
+      }
+    }
+  });
+};
+const setOriginalNavigationVisible = (visible, root = findContentManagerNavRoot()) => {
+  if (!root) return;
+  findOriginalContentTypeItems(root).forEach((item) => {
+    item.style.display = visible ? "" : "none";
+  });
+  hideCollectionTypeHeaders(!visible, root);
+};
+const syncOriginalNavigationVisibility = (customNavigationReady = hasCustomNavigationContent()) => {
+  const root = findContentManagerNavRoot();
+  const searchInput = findContentManagerSearchInput(root);
+  const isSearching = Boolean(searchInput?.value);
+  setOriginalNavigationVisible(isSearching || !customNavigationReady, root);
+  return isSearching;
+};
+const organizeByGroups = (contentTypes) => {
+  const groupMap = {};
+  contentTypes.forEach((contentType) => {
+    const groupName = contentType.group || "General";
+    if (!groupMap[groupName]) {
+      groupMap[groupName] = [];
+    }
+    groupMap[groupName].push(contentType);
+  });
+  Object.values(groupMap).forEach((items) => {
+    items.sort((a, b) => {
+      if (a.sortOrder !== b.sortOrder) {
+        return a.sortOrder - b.sortOrder;
+      }
+      return a.displayName.localeCompare(b.displayName);
+    });
+  });
+  const groups = Object.entries(groupMap).map(([name, items]) => {
+    const minSortOrder = Math.min(...items.map((item) => item.sortOrder));
+    return {
+      name,
+      items,
+      sortOrder: minSortOrder
+    };
+  });
+  groups.sort((a, b) => {
+    if (a.name === "General") return -1;
+    if (b.name === "General") return 1;
+    if (a.sortOrder !== b.sortOrder) {
+      return a.sortOrder - b.sortOrder;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  return groups;
+};
+const navigationFrameStyle = {
+  display: "flex",
+  flexDirection: "column",
+  gap: 8,
+  paddingBlock: 4,
+  paddingInline: 8,
+  listStyle: "none"
+};
+const navigationListStyle = {
+  display: "flex",
+  flexDirection: "column",
+  gap: 2,
+  margin: 0,
+  padding: 0,
+  listStyle: "none"
+};
+const groupTriggerStyle = {
+  alignItems: "center",
+  background: "transparent",
+  border: "none",
+  borderRadius: 4,
+  color: "#32324d",
+  cursor: "pointer",
+  display: "flex",
+  fontSize: "1.4rem",
+  fontWeight: 500,
+  height: 32,
+  justifyContent: "space-between",
+  lineHeight: "1.43",
+  paddingBlock: 8,
+  paddingInline: 12,
+  textAlign: "left",
+  width: "100%"
+};
+const getGroupItems = (group) => {
+  const collectionTypes = group.items.filter((item) => item.kind === "collectionType");
+  const singleTypes = group.items.filter((item) => item.kind === "singleType");
+  return [...collectionTypes, ...singleTypes];
+};
+const isContentTypeActive = (contentType) => {
+  return window.location.pathname.includes(contentType.uid);
+};
+const navigateToContentType = (href) => {
+  if (window.history && window.history.pushState) {
+    window.history.pushState({}, "", href);
+    window.dispatchEvent(new PopStateEvent("popstate"));
+  } else {
+    window.location.href = href;
+  }
+};
+const NavigationFrame = ({ children }) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-content-manager-sort-content": "true", style: navigationFrameStyle, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          color: "#666687",
+          fontSize: "1.1rem",
+          fontWeight: 600,
+          lineHeight: 1.45,
+          paddingInline: 12,
+          textTransform: "uppercase"
+        },
+        children: "All"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx("ul", { style: navigationListStyle, children })
+  ] });
+};
+const ContentTypeLink = ({
+  contentType,
+  asMain
+}) => {
+  const isActive = isContentTypeActive(contentType);
+  return /* @__PURE__ */ jsxRuntime.jsx("li", { style: { listStyle: "none" }, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "a",
+    {
+      className: `custom-nav-item ${isActive ? "active" : ""}`,
+      href: contentType.href,
+      style: {
+        alignItems: "center",
+        backgroundColor: isActive ? "#f0f0ff" : "transparent",
+        borderRadius: 4,
+        color: isActive ? "#271fe0" : "#32324d",
+        display: "flex",
+        fontSize: "1.4rem",
+        fontWeight: isActive || asMain ? 500 : 400,
+        height: 32,
+        lineHeight: "1.43",
+        minWidth: 0,
+        overflow: "hidden",
+        paddingInlineStart: asMain ? 12 : 24,
+        paddingInlineEnd: 12,
+        textDecoration: "none",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap"
+      },
+      onClick: (event) => {
+        if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || event.button !== 0) {
+          return;
+        }
+        event.preventDefault();
+        navigateToContentType(contentType.href);
+      },
+      children: contentType.displayName
+    }
+  ) });
+};
+const ContentTypeGroupSection = ({ directSingle, group }) => {
+  const allTypes = getGroupItems(group);
+  const isActiveGroup = allTypes.some(isContentTypeActive);
+  const [expanded, setExpanded] = react.useState(isActiveGroup);
+  react.useEffect(() => {
+    if (isActiveGroup) {
+      setExpanded(true);
+    }
+  }, [isActiveGroup]);
+  if (allTypes.length === 0) return null;
+  if (directSingle && allTypes.length === 1) {
+    return /* @__PURE__ */ jsxRuntime.jsx(ContentTypeLink, { contentType: allTypes[0], asMain: true }, `${allTypes[0].uid}-0`);
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("li", { style: { listStyle: "none" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        "aria-expanded": expanded,
+        className: `custom-nav-group-trigger ${expanded ? "expanded" : ""}`,
+        style: groupTriggerStyle,
+        onClick: () => setExpanded(!expanded),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: group.name }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "svg",
+            {
+              xmlns: "http://www.w3.org/2000/svg",
+              viewBox: "0 0 32 32",
+              width: 16,
+              height: 16,
+              fill: "#8e8ea9",
+              "aria-hidden": "true",
+              style: {
+                flexShrink: 0,
+                transform: expanded ? "rotate(0deg)" : "rotate(-90deg)",
+                transition: "transform 0.2s ease"
+              },
+              children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m27.061 13.061-10 10a1.503 1.503 0 0 1-2.125 0l-10-10a1.503 1.503 0 1 1 2.125-2.125L16 19.875l8.939-8.94a1.502 1.502 0 1 1 2.125 2.125z" })
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "ul",
+      {
+        className: `custom-nav-group-items ${expanded ? "expanded" : ""}`,
+        style: {
+          ...navigationListStyle,
+          maxHeight: expanded ? 1e3 : 0,
+          overflow: "hidden",
+          transition: expanded ? "max-height 0.25s ease-in-out" : "max-height 0.18s cubic-bezier(0, 1, 0, 1)"
+        },
+        children: allTypes.map((item) => /* @__PURE__ */ jsxRuntime.jsx(ContentTypeLink, { contentType: item }, item.uid))
+      }
+    )
+  ] });
+};
+const OfficialNavigation = ({ groups }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(NavigationFrame, { children: groups.map((group) => /* @__PURE__ */ jsxRuntime.jsx(ContentTypeGroupSection, { group }, group.name)) });
+};
+const V5Navigation = ({ groups }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(NavigationFrame, { children: groups.map((group, index2) => /* @__PURE__ */ jsxRuntime.jsx(ContentTypeGroupSection, { group, directSingle: true }, `${group.name}-${index2}`)) });
+};
+const AccordionNavigation = ({ groups }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(NavigationFrame, { children: groups.map((group) => /* @__PURE__ */ jsxRuntime.jsx(ContentTypeGroupSection, { group }, group.name)) });
+};
+const NavigationApp = () => {
+  const [groups, setGroups] = react.useState([]);
+  const [currentPath, setCurrentPath] = react.useState(window.location.pathname);
+  const [isSearching, setIsSearching] = react.useState(false);
+  const [template, setTemplate] = react.useState(null);
+  const initialize = async () => {
+    const { delimiter, template: template2 } = await getPluginConfig();
+    setTemplate(template2);
+    console.log(`Building Navigation with delimiter "${delimiter}" and template "${template2}"`);
+    async function fetchAdminPermissions() {
+      try {
+        const { get } = admin.getFetchClient();
+        const { data } = await get("/admin/users/me/permissions");
+        console.log(data);
+        const list = Array.isArray(data) ? data : data?.data ?? data?.permissions ?? [];
+        window.strapiPermissions = list;
+        console.log("Successfully fetched permissions:", list.length);
+        return list;
+      } catch (error) {
+        console.error("Error fetching permissions with getFetchClient:", error);
+        return [];
+      }
+    }
+    const fetchContentTypes = async () => {
+      try {
+        console.log("Fetching content types from API...");
+        const { get } = admin.getFetchClient();
+        const response = await get("/content-manager/content-types");
+        console.log("Raw API response:", response);
+        console.log("response.data:", response.data);
+        let rawData = response.data;
+        if (rawData && !Array.isArray(rawData) && rawData.data) {
+          rawData = rawData.data;
+        }
+        const contentTypes = formatContentTypes(delimiter, { data: rawData });
+        console.log("Formatted content types:", contentTypes.length, contentTypes);
+        let permissions = window.strapiPermissions || [];
+        if (!permissions || permissions.length === 0) {
+          console.log("Fetching permissions...");
+          permissions = await fetchAdminPermissions();
+        }
+        console.log("Permissions:", permissions.length);
+        let allowedContentTypes;
+        if (permissions.length > 0) {
+          allowedContentTypes = contentTypes.filter((ct) => {
+            const hasContentManagerRead = permissions.some(
+              (p) => p.action === "plugin::content-manager.explorer.read" && p.subject === ct.uid
+            );
+            const isPluginContentType = ct.uid.startsWith("plugin::");
+            const hasPluginRead = isPluginContentType && permissions.some(
+              (p) => p.subject === ct.uid && (p.action?.includes("read") || p.action?.includes("find") || p.action === "plugin::content-manager.explorer.read")
+            );
+            return hasContentManagerRead || hasPluginRead;
+          });
+          console.log(
+            "Allowed content types after permission filter:",
+            allowedContentTypes.length,
+            allowedContentTypes
+          );
+        } else {
+          console.warn("No permissions available, showing all content types as fallback");
+          allowedContentTypes = contentTypes;
+        }
+        window.strapiContentTypes = allowedContentTypes;
+        const groups2 = organizeByGroups(allowedContentTypes);
+        console.log("Organized groups:", groups2);
+        setGroups(groups2);
+      } catch (error) {
+        console.error("Error fetching content types:", error);
+      }
+    };
+    if (window.strapiContentTypes && window.strapiContentTypes.length > 0) {
+      console.log("Using cached content types:", window.strapiContentTypes.length);
+      const groups2 = organizeByGroups(window.strapiContentTypes);
+      console.log("Groups from cache:", groups2);
+      setGroups(groups2);
+    } else {
+      console.log("No cached content types, fetching...");
+      fetchContentTypes();
+    }
+  };
+  react.useEffect(() => {
+    const handleLocationChange = () => {
+      setCurrentPath(window.location.pathname);
+    };
+    window.addEventListener("popstate", handleLocationChange);
+    const pathCheckInterval = setInterval(() => {
+      if (window.location.pathname !== currentPath) {
+        handleLocationChange();
+      }
+    }, 100);
+    return () => {
+      window.removeEventListener("popstate", handleLocationChange);
+      clearInterval(pathCheckInterval);
+    };
+  }, [currentPath]);
+  react.useEffect(() => {
+    initialize();
+  }, []);
+  react.useEffect(() => {
+    let searchInput = null;
+    let inputObserver = null;
+    const syncNavigation = () => {
+      setIsSearching(syncOriginalNavigationVisibility());
+    };
+    const handleSearchInputChange = () => {
+      syncNavigation();
+    };
+    const disconnectInputObserver = () => {
+      if (inputObserver) {
+        inputObserver.disconnect();
+        inputObserver = null;
+      }
+      if (searchInput) {
+        searchInput.removeEventListener("input", handleSearchInputChange);
+        searchInput = null;
+      }
+    };
+    const attachSearchInput = () => {
+      const nextSearchInput = findContentManagerSearchInput();
+      if (nextSearchInput === searchInput) return;
+      disconnectInputObserver();
+      searchInput = nextSearchInput;
+      if (!searchInput) return;
+      searchInput.addEventListener("input", handleSearchInputChange);
+      inputObserver = new MutationObserver(handleSearchInputChange);
+      inputObserver.observe(searchInput, {
+        attributes: true,
+        attributeFilter: ["value"]
+      });
+    };
+    attachSearchInput();
+    syncNavigation();
+    const navObserver = new MutationObserver(() => {
+      attachSearchInput();
+      syncNavigation();
+    });
+    navObserver.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+    return () => {
+      disconnectInputObserver();
+      navObserver.disconnect();
+    };
+  }, []);
+  react.useEffect(() => {
+    const frame = window.requestAnimationFrame(() => {
+      setIsSearching(syncOriginalNavigationVisibility(groups.length > 0));
+    });
+    return () => {
+      window.cancelAnimationFrame(frame);
+    };
+  }, [currentPath, groups.length, template]);
+  console.log(
+    "NavigationApp render - groups:",
+    groups.length,
+    "isSearching:",
+    isSearching,
+    "template:",
+    template
+  );
+  if (groups.length === 0) {
+    console.log("No groups to display, returning null");
+    return null;
+  }
+  return !isSearching ? template === "accordion" ? /* @__PURE__ */ jsxRuntime.jsx(AccordionNavigation, { groups }) : template === "v5" ? /* @__PURE__ */ jsxRuntime.jsx(V5Navigation, { groups }) : /* @__PURE__ */ jsxRuntime.jsx(OfficialNavigation, { groups }) : null;
+};
+async function buildNavigation() {
+  console.log("Building stacked navigation...");
+  try {
+    if (typeof window !== "undefined") {
+      setupNavigationReplacement();
+      setupHeaderCleaning();
+      window.navigationInitialized = window.navigationInitialized || false;
+      window.reinitializeNavigation = () => {
+        setupNavigationReplacement();
+      };
+    }
+  } catch (error) {
+    console.error("Error building custom navigation:", error);
+  }
+}
+const renderNavigationApp = (container) => {
+  let root = navigationRoots.get(container);
+  if (!root) {
+    root = ReactDOM__namespace.createRoot(container);
+    navigationRoots.set(container, root);
+  }
+  root.render(/* @__PURE__ */ jsxRuntime.jsx(NavigationApp, {}));
+};
+const setupNavigationReplacement = () => {
+  if (window.navObserver) {
+    window.navObserver.disconnect();
+    window.navObserver = void 0;
+  }
+  console.log("Setting up navigation observer...");
+  const processNavigation = (navigationList2) => {
+    console.log("Found Content Manager navigation list", navigationList2);
+    const existingNav = document.getElementById(stackNavContainerId);
+    if (existingNav) {
+      console.log("Custom navigation already exists");
+      renderNavigationApp(existingNav);
+      return;
+    }
+    const navContainer = document.createElement("li");
+    navContainer.id = stackNavContainerId;
+    navContainer.className = "stack-navigation";
+    navContainer.style.listStyle = "none";
+    navContainer.style.margin = "0";
+    navContainer.style.padding = "0";
+    navigationList2.prepend(navContainer);
+    console.log("Custom navigation container added, rendering React app...");
+    renderNavigationApp(navContainer);
+  };
+  const navRoot = findContentManagerNavRoot();
+  const navigationList = findStackNavigationList(navRoot);
+  console.log("Looking for Content Manager nav root. Found:", !!navRoot, "list:", !!navigationList);
+  if (navigationList) {
+    processNavigation(navigationList);
+    return;
+  }
+  console.log("Navigation not found yet - will retry via observer");
+};
+const isPluginEnabled$1 = async () => {
+  try {
+    const response = await fetch("/content-manager-sort/config");
+    return response.ok;
+  } catch {
+    return false;
+  }
+};
+const setupContinuousNavigationCheck = () => {
+  if (window.navigationInitialized) return;
+  window.navigationInitialized = true;
+  setupNavigationReplacement();
+  setupHeaderCleaning();
+  if (!window.checkNavigationInterval) {
+    window.checkNavigationInterval = window.setInterval(() => {
+      if (window.location.pathname.includes("/admin/content-manager")) {
+        const navRoot = findContentManagerNavRoot();
+        const navContainer = findStackNavigationList(navRoot);
+        const customNav = document.getElementById(stackNavContainerId);
+        if (navContainer && !customNav) {
+          console.log("Navigation detected without custom navigation, reinitializing...");
+          setupNavigationReplacement();
+        }
+        syncOriginalNavigationVisibility(hasCustomNavigationContent());
+        const headerDiv = document.querySelector('div[data-strapi-header="true"]');
+        if (headerDiv) {
+          const h1Element = headerDiv.querySelector("h1");
+          if (h1Element && h1Element.textContent && h1Element.textContent.match(/^\[\d+\]/)) {
+            const cleanedText = cleanHeaderText(h1Element.textContent);
+            h1Element.textContent = cleanedText;
+          }
+        }
+      }
+    }, 100);
+  }
+};
+if (typeof window !== "undefined") {
+  isPluginEnabled$1().then((enabled) => {
+    if (enabled) {
+      console.log("✅ content-manager-sort is enabled, initializing navigation...");
+      document.body.style.overflowY = "hidden";
+      setupContinuousNavigationCheck();
+    } else {
+      console.log("⏸️ content-manager-sort is disabled, skipping initialization.");
+    }
+  });
+}
+const isPluginEnabled = async () => {
+  try {
+    const response = await fetch("/content-manager-sort/config");
+    return response.ok;
+  } catch {
+    return false;
+  }
+};
+const index = {
+  register(app) {
+    console.log("🎯 Content Manager Subnavigation Stacker plugin - ADMIN REGISTER function called!");
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+    isPluginEnabled().then((enabled) => {
+      if (enabled) {
+        console.log("✅ content-manager-sort is enabled, building navigation...");
+        buildNavigation();
+      } else {
+        console.log("⏸️ content-manager-sort is disabled, skipping navigation injection.");
+      }
+    });
+  },
+  async registerTrads({ locales }) {
+    return Promise.all(
+      locales.map(async (locale) => {
+        try {
+          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => Promise.resolve().then(() => require("../_chunks/en-B4KWt_jN.js")) }), `./translations/${locale}.json`, 3);
+          return { data, locale };
+        } catch {
+          return { data: {}, locale };
+        }
+      })
+    );
+  }
+};
+module.exports = index;