strapi-plugin-cm-subnav-stacker 0.0.1

package/dist/admin/index.mjs

@@ -0,0 +1,911 @@
+import { useRef, useEffect, useState } from "react";
+import { jsx, Fragment, jsxs } from "react/jsx-runtime";
+import * as ReactDOM from "react-dom/client";
+import { DesignSystemProvider, Box, Accordion, SubNav, SubNavHeader, SubNavSections, SubNavSection, Link, Button, SubNavLink } from "@strapi/design-system";
+import { getFetchClient } from "@strapi/strapi/admin";
+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 = "cm-subnav-stacker";
+const Initializer = ({ setPlugin }) => {
+  const ref = useRef(setPlugin);
+  useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const defaultDelimiter = " | ";
+const defaultTemplate = "accordion";
+const navQuery = 'nav[aria-label="Content Manager"]';
+const getPluginConfig = async () => {
+  let delimiter = process.env.CM_SUBNAV_STACKER_DELIMITER || defaultDelimiter;
+  let template = process.env.CM_SUBNAV_STACKER_TEMPLATE || defaultTemplate;
+  const config = await fetch(`/cm-subnav-stacker/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) => ct.uid.startsWith("api::")).map((ct) => {
+    const displayName = ct.schema.displayName || ct.apiID;
+    const 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 = () => {
+    let nav = document.querySelector(navQuery);
+    if (!nav) {
+      nav = document.querySelector("nav");
+    }
+    if (!nav) return;
+    const navLinks = nav.querySelectorAll('a[href*="/admin/content-manager/"]');
+    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('a[href*="/admin/content-manager/"]') || target.querySelector('a[href*="/admin/content-manager/"]');
+          if (navItem) {
+            cleanNavigationItems();
+            break;
+          }
+        }
+      }
+    }
+  });
+  headerObserver.observe(document.body, {
+    childList: true,
+    subtree: true,
+    characterData: true
+  });
+  return headerObserver;
+};
+const hideCollectionTypeHeaders = () => {
+  let nav = document.querySelector(navQuery);
+  if (!nav) {
+    nav = document.querySelector("nav");
+  }
+  if (!nav) return;
+  const allSpans = nav.querySelectorAll("span");
+  allSpans.forEach((span) => {
+    const text = span.textContent?.trim();
+    if (text === "Collection Types" || text === "Single Types") {
+      let parent = span.parentElement;
+      for (let i = 0; i < 8 && parent; i++) {
+        parent.querySelector("span");
+        const allSpansInParent = parent.querySelectorAll("span");
+        let hasCountBadge = false;
+        allSpansInParent.forEach((s) => {
+          const spanText = s.textContent?.trim();
+          if (spanText && /^\d+$/.test(spanText)) {
+            hasCountBadge = true;
+          }
+        });
+        if (hasCountBadge && parent.textContent?.includes(text)) {
+          const parentOl = parent.querySelector("ol");
+          if (!parentOl) {
+            parent.style.display = "none";
+            break;
+          }
+        }
+        parent = parent.parentElement;
+      }
+    }
+  });
+};
+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 OfficialNavigation = ({ groups }) => {
+  return /* @__PURE__ */ jsx(Box, { background: "neutral100", children: /* @__PURE__ */ jsxs(SubNav, { "aria-label": "Content Manager", style: { background: "transparent", height: "auto" }, children: [
+    /* @__PURE__ */ jsx(SubNavHeader, { label: "All" }),
+    /* @__PURE__ */ jsx(SubNavSections, { children: groups.map((group) => /* @__PURE__ */ jsx(OfficialContentTypeGroupSection, { group }, group.name)) })
+  ] }) });
+};
+const OfficialContentTypeGroupSection = ({ group }) => {
+  if (group.items.length === 0) return null;
+  const collectionTypes = group.items.filter((item) => item.kind === "collectionType");
+  const singleTypes = group.items.filter((item) => item.kind === "singleType");
+  const allTypes = [...collectionTypes, ...singleTypes];
+  return /* @__PURE__ */ jsx(SubNavSection, { label: group.name, collapsable: true, children: allTypes.map((item) => /* @__PURE__ */ jsx(OfficialContentTypeLink, { contentType: item }, item.uid)) });
+};
+const OfficialContentTypeLink = ({ contentType }) => {
+  const isActive = window.location.pathname.includes(contentType.uid);
+  return /* @__PURE__ */ jsx(
+    SubNavLink,
+    {
+      href: contentType.href,
+      active: isActive,
+      style: { background: "transparent" },
+      className: isActive ? "active" : "",
+      onClick: (e) => {
+        e.preventDefault();
+        if (window.history && window.history.pushState) {
+          window.history.pushState({}, "", contentType.href);
+          window.dispatchEvent(new PopStateEvent("popstate"));
+        } else {
+          window.location.href = contentType.href;
+        }
+      },
+      children: contentType.displayName
+    }
+  );
+};
+const V5Navigation = ({ groups }) => {
+  return /* @__PURE__ */ jsxs("div", { style: {
+    gap: 8,
+    alignItems: "stretch",
+    flexDirection: "column",
+    display: "flex"
+  }, children: [
+    /* @__PURE__ */ jsx("div", { style: {
+      paddingInlineStart: "20px",
+      paddingInlineEnd: "20px"
+    }, children: /* @__PURE__ */ jsx("div", { style: {
+      alignItems: "center",
+      justifyContent: "space-between",
+      flexDirection: "row",
+      display: "flex"
+    }, children: /* @__PURE__ */ jsx("div", { style: {
+      alignItems: "center",
+      flexDirection: "row",
+      display: "flex"
+    }, children: /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx("span", { style: {
+      fontWeight: 600,
+      fontSize: "1.1rem",
+      lineHeight: 1.45,
+      textTransform: "uppercase",
+      color: "#666687"
+    }, children: "All" }) }) }) }) }),
+    /* @__PURE__ */ jsx(
+      "ol",
+      {
+        style: {
+          gap: 2,
+          alignItems: "stretch",
+          flexDirection: "column",
+          display: "flex",
+          marginInlineStart: 8,
+          marginInlineEnd: 8
+        },
+        children: groups.map((group, index2) => /* @__PURE__ */ jsx(V5ContentTypeGroupSection, { group }, `${group.name}-${index2}`))
+      }
+    )
+  ] });
+};
+const V5ContentTypeGroupSection = ({ group }) => {
+  if (group.items.length === 0) return null;
+  const collectionTypes = group.items.filter((item) => item.kind === "collectionType");
+  const singleTypes = group.items.filter((item) => item.kind === "singleType");
+  const allTypes = [...collectionTypes, ...singleTypes];
+  const [expanded, setExpanded] = useState(false);
+  useEffect(() => {
+    allTypes.some((item) => window.location.pathname.includes(item.uid)) && setExpanded(true);
+  }, []);
+  return allTypes.length === 1 ? /* @__PURE__ */ jsx(V5ContentTypeLink, { contentType: allTypes[0], asMain: true }, `${allTypes[0].uid}-0`) : /* @__PURE__ */ jsxs("li", { children: [
+    /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          alignItems: "center",
+          justifyContent: "space-between",
+          flexDirection: "row",
+          display: "flex"
+        },
+        children: /* @__PURE__ */ jsxs(
+          "button",
+          {
+            style: {
+              cursor: "pointer",
+              width: "100%",
+              border: "none",
+              padding: 0,
+              background: "transparent",
+              display: "flex",
+              alignItems: "center",
+              height: 32,
+              borderRadius: 4,
+              paddingLeft: 12,
+              paddingRight: 12,
+              paddingTop: 8,
+              paddingBottom: 8
+            },
+            className: `${expanded ? "expanded" : ""}`,
+            onClick: () => setExpanded(!expanded),
+            children: [
+              /* @__PURE__ */ jsx("div", { style: {
+                width: "100%",
+                textAlign: "left",
+                paddingInlineEnd: "8px"
+              }, children: /* @__PURE__ */ jsx("span", { style: {
+                fontSize: "1.4rem",
+                lineHeight: "1.43",
+                color: "#32324d",
+                fontWeight: 500
+              }, children: group.name }) }),
+              /* @__PURE__ */ jsx(
+                "svg",
+                {
+                  xmlns: "http://www.w3.org/2000/svg",
+                  viewBox: "0 0 32 32",
+                  width: 16,
+                  height: 16,
+                  fill: "#8e8ea9",
+                  "aria-hidden": "true",
+                  style: {
+                    transform: expanded ? "rotate(0deg)" : "rotate(-90deg)",
+                    transition: "transform 0.5s"
+                  },
+                  children: /* @__PURE__ */ 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__ */ jsx(
+      "ul",
+      {
+        style: {
+          gap: 2,
+          alignItems: "stretch",
+          flexDirection: "column",
+          display: "flex",
+          maxHeight: expanded ? 1e3 : 0,
+          overflow: "hidden",
+          transition: expanded ? "max-height 1s ease-in-out" : "max-height 0.5s cubic-bezier(0, 1, 0, 1)"
+        },
+        className: `custom-nav-group-items ${expanded ? "expanded" : ""}`,
+        children: allTypes.map((item, index2) => /* @__PURE__ */ jsx(V5ContentTypeLink, { contentType: item }, `${item.uid}-${index2}`))
+      }
+    )
+  ] });
+};
+const V5ContentTypeLink = ({ contentType, asMain }) => {
+  const isActive = window.location.pathname.includes(contentType.uid);
+  return /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(
+    Link,
+    {
+      style: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "space-between",
+        textDecoration: "none",
+        height: 32,
+        color: isActive ? "#271fe0" : "#32324d",
+        backgroundColor: isActive ? "#f0f0ff" : "transparent",
+        fontWeight: isActive ? 500 : "normal",
+        borderRadius: "4px"
+      },
+      className: `custom-nav-item ${isActive ? "active" : ""}`,
+      href: contentType.href,
+      onClick: (e) => {
+        e.preventDefault();
+        if (window.history && window.history.pushState) {
+          window.history.pushState({}, "", contentType.href);
+          window.dispatchEvent(new PopStateEvent("popstate"));
+        } else {
+          window.location.href = contentType.href;
+        }
+      },
+      children: /* @__PURE__ */ jsx("div", { style: {
+        paddingLeft: asMain ? "12px" : "24px"
+      }, children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            gap: 4,
+            alignItems: "center",
+            justifyContent: "space-between",
+            flexDirection: "row",
+            display: "flex"
+          },
+          children: /* @__PURE__ */ jsx("div", { style: {
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap",
+            overflow: "hidden",
+            fontSize: "1.4rem",
+            lineHeight: "1.43",
+            color: isActive ? "#271fe0" : "#32324d",
+            fontWeight: asMain ? 500 : "normal"
+          }, children: contentType.displayName })
+        }
+      ) })
+    }
+  ) });
+};
+const AccordionNavigation = ({ groups }) => {
+  const value = groups.find(
+    (group) => group.items.find((item) => window.location.pathname.includes(item.uid))
+  )?.name;
+  return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(
+    Accordion.Root,
+    {
+      defaultValue: value,
+      style: { border: "none", borderRadius: 0 },
+      children: groups.map((group) => /* @__PURE__ */ jsx(AccordionContentTypeGroupSection, { group }, group.name))
+    }
+  ) });
+};
+const AccordionContentTypeGroupSection = ({ group }) => {
+  if (group.items.length === 0) return null;
+  const collectionTypes = group.items.filter((item) => item.kind === "collectionType");
+  const singleTypes = group.items.filter((item) => item.kind === "singleType");
+  const allTypes = [...collectionTypes, ...singleTypes];
+  return /* @__PURE__ */ jsxs(
+    Accordion.Item,
+    {
+      value: `${group.name}`,
+      style: { border: "none", borderRadius: 0 },
+      children: [
+        /* @__PURE__ */ jsx(Accordion.Header, { children: /* @__PURE__ */ jsx(Accordion.Trigger, { children: group.name }) }),
+        /* @__PURE__ */ jsx(Accordion.Content, { children: allTypes.map((item) => /* @__PURE__ */ jsx(AccordionContentTypeLink, { contentType: item }, item.uid)) })
+      ]
+    },
+    group.name
+  );
+};
+const AccordionContentTypeLink = ({ contentType }) => {
+  const isActive = window.location.pathname.includes(contentType.uid);
+  return /* @__PURE__ */ jsx(
+    Link,
+    {
+      href: contentType.href,
+      style: { textDecoration: "none", display: "block" },
+      onClick: (e) => {
+        e.preventDefault();
+        if (window.history && window.history.pushState) {
+          window.history.pushState({}, "", contentType.href);
+          window.dispatchEvent(new PopStateEvent("popstate"));
+        } else {
+          window.location.href = contentType.href;
+        }
+      },
+      children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: isActive ? "secondary" : "ghost",
+          fullWidth: true,
+          size: "L",
+          style: {
+            paddingLeft: 56,
+            justifyContent: "start",
+            borderRadius: 0,
+            borderLeft: "none",
+            borderRight: "none",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap",
+            overflow: "hidden"
+          },
+          children: contentType.displayName
+        }
+      )
+    }
+  );
+};
+const NavigationApp = () => {
+  const [groups, setGroups] = useState([]);
+  const [currentPath, setCurrentPath] = useState(window.location.pathname);
+  const [isSearching, setIsSearching] = useState(false);
+  const [template, setTemplate] = 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 } = getFetchClient();
+        const { data } = await get("/admin/users/me/permissions");
+        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 } = getFetchClient();
+        const response = await get("/content-type-builder/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) => permissions.some(
+              (p) => p.action === "plugin::content-manager.explorer.read" && p.subject === ct.uid
+            )
+          );
+          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();
+    }
+  };
+  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]);
+  useEffect(() => {
+    initialize();
+    const hideCollectionHeaders = (hide = true) => {
+      let nav = document.querySelector(navQuery);
+      if (!nav) {
+        nav = document.querySelector("nav");
+      }
+      if (!nav) return;
+      const allSpans = nav.querySelectorAll("span");
+      allSpans.forEach((span) => {
+        const text = span.textContent?.trim();
+        if (text === "Collection Types" || text === "Single Types") {
+          let parent = span.parentElement;
+          for (let i = 0; i < 5 && parent; i++) {
+            if (parent.classList.contains("hvPsis") || parent.tagName === "DIV" && parent.querySelector("span")?.textContent?.match(/^\d+$/)) {
+              parent.style.display = hide ? "none" : "";
+              break;
+            }
+            parent = parent.parentElement;
+          }
+        }
+      });
+    };
+    hideCollectionHeaders(true);
+    const toggleIsSearching = (isSearching2) => {
+      let nav = document.querySelector(navQuery);
+      if (!nav) {
+        nav = document.querySelector("nav");
+      }
+      if (!nav) return;
+      const allOls = nav.querySelectorAll("ol");
+      const otherNavs = [];
+      allOls.forEach((ol) => {
+        const liChildren = Array.from(ol.children).filter(
+          (el) => el.tagName === "LI" && el.id !== "stack-nav-container"
+        );
+        otherNavs.push(...liChildren);
+      });
+      console.log("toggleIsSearching called with:", isSearching2, "Found other nav items:", otherNavs.length);
+      setIsSearching(isSearching2);
+      if (isSearching2) {
+        otherNavs.forEach((nav2) => {
+          nav2.style.display = "initial";
+        });
+        hideCollectionHeaders(false);
+      } else {
+        otherNavs.forEach((nav2) => {
+          nav2.style.display = "none";
+        });
+        hideCollectionHeaders(true);
+      }
+      const customNavContainer = document.getElementById("stack-nav-container");
+      if (customNavContainer) {
+        const customNavItems = customNavContainer.querySelectorAll("li");
+        console.log("Found custom nav items to toggle:", customNavItems.length);
+        customNavItems.forEach((item) => {
+          if (isSearching2) {
+            item.style.display = "none";
+          } else {
+            item.style.display = "";
+          }
+        });
+      }
+    };
+    const checkSearchInput = () => {
+      if (window.location.pathname === currentPath) {
+        const searchNav = document.querySelector(`${navQuery} input`);
+        if (searchNav) {
+          const value = searchNav.value;
+          toggleIsSearching(!!value);
+          return searchNav;
+        } else {
+          toggleIsSearching(false);
+          return null;
+        }
+      }
+      return null;
+    };
+    const searchInput = checkSearchInput();
+    let inputObserver = null;
+    if (searchInput) {
+      searchInput.addEventListener("input", () => {
+        const value = searchInput.value;
+        toggleIsSearching(!!value);
+      });
+      inputObserver = new MutationObserver((mutations) => {
+        mutations.forEach((mutation) => {
+          if (mutation.type === "attributes" && mutation.attributeName === "value") {
+            const value = searchInput.value;
+            toggleIsSearching(!!value);
+          }
+        });
+      });
+      inputObserver.observe(searchInput, {
+        attributes: true,
+        attributeFilter: ["value"]
+      });
+    }
+    const navObserver = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        if (mutation.type === "childList" && mutation.addedNodes.length > 0) {
+          const searchInput2 = checkSearchInput();
+          if (searchInput2 && !inputObserver) {
+            searchInput2.addEventListener("input", () => {
+              const value = searchInput2.value;
+              toggleIsSearching(!!value);
+            });
+            inputObserver = new MutationObserver((mutations2) => {
+              mutations2.forEach((mutation2) => {
+                if (mutation2.type === "attributes" && mutation2.attributeName === "value") {
+                  const value = searchInput2.value;
+                  toggleIsSearching(!!value);
+                }
+              });
+            });
+            inputObserver.observe(searchInput2, {
+              attributes: true,
+              attributeFilter: ["value"]
+            });
+            break;
+          }
+        }
+      }
+    });
+    navObserver.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+    return () => {
+      if (inputObserver) {
+        inputObserver.disconnect();
+      }
+      navObserver.disconnect();
+    };
+  }, []);
+  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 ? /* @__PURE__ */ jsx(DesignSystemProvider, { children: template === "accordion" ? /* @__PURE__ */ jsx(AccordionNavigation, { groups }) : template === "v5" ? /* @__PURE__ */ jsx(V5Navigation, { groups }) : /* @__PURE__ */ jsx(OfficialNavigation, { groups }) }) : /* @__PURE__ */ jsx(Fragment, {});
+};
+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 setupNavigationReplacement = () => {
+  if (window.navObserver) {
+    window.navObserver.disconnect();
+    window.navObserver = void 0;
+  }
+  console.log("Setting up navigation observer...");
+  const processNavigation = (originalNav) => {
+    console.log("Found Content Manager navigation", originalNav);
+    const existingNav = document.getElementById("stack-nav-container");
+    if (existingNav) {
+      console.log("Custom navigation already exists");
+      if (existingNav.children.length === 0) {
+        const root2 = ReactDOM.createRoot(existingNav);
+        root2.render(/* @__PURE__ */ jsx(NavigationApp, {}));
+      }
+      return;
+    }
+    const navContainer = document.createElement("li");
+    navContainer.id = "stack-nav-container";
+    navContainer.className = "stack-navigation";
+    originalNav.prepend(navContainer);
+    console.log("Custom navigation container added, rendering React app...");
+    const root = ReactDOM.createRoot(navContainer);
+    root.render(/* @__PURE__ */ jsx(NavigationApp, {}));
+  };
+  let nav = document.querySelector(navQuery);
+  console.log("Looking for nav element with aria-label:", navQuery, "Found:", !!nav);
+  if (!nav) {
+    nav = document.querySelector("nav");
+    console.log("Fallback: Looking for any nav element, Found:", !!nav);
+  }
+  if (!nav) {
+    const allNavs = Array.from(document.querySelectorAll("nav"));
+    nav = allNavs.find((n) => {
+      const text = n.textContent || "";
+      return text.includes("Collection Types") || text.includes("Single Types");
+    }) || null;
+    console.log("Fallback: Looking for nav with Collection Types text, Found:", !!nav);
+  }
+  if (nav) {
+    const allOls = Array.from(nav.querySelectorAll("ol"));
+    console.log("Found", allOls.length, "ol elements in nav");
+    const mainOl = allOls.find((ol) => {
+      const hasStack = ol.querySelector("#stack-nav-container");
+      const hasCollectionTypes = ol.textContent?.includes("Collection Types");
+      const hasSingleTypes = ol.textContent?.includes("Single Types");
+      if (hasStack) return true;
+      return (hasCollectionTypes || hasSingleTypes) && ol.parentElement?.closest("ol") === null;
+    });
+    console.log("Found main ol:", !!mainOl);
+    if (mainOl) {
+      processNavigation(mainOl);
+      return;
+    }
+    if (allOls.length > 0) {
+      console.log("Fallback: using first ol element");
+      processNavigation(allOls[0]);
+      return;
+    }
+  }
+  console.log("Navigation not found yet - will retry via observer");
+};
+const isPluginEnabled$1 = async () => {
+  try {
+    const response = await fetch("/cm-subnav-stacker/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")) {
+        let navElement = document.querySelector(navQuery);
+        if (!navElement) {
+          navElement = document.querySelector("nav");
+        }
+        if (!navElement) {
+          const allNavs = Array.from(document.querySelectorAll("nav"));
+          navElement = allNavs.find((n) => {
+            const text = n.textContent || "";
+            return text.includes("Collection Types") || text.includes("Single Types");
+          }) || null;
+        }
+        let navContainer = null;
+        if (navElement) {
+          const allOls = Array.from(navElement.querySelectorAll("ol"));
+          navContainer = allOls.find((ol) => {
+            const hasStack = ol.querySelector("#stack-nav-container");
+            const hasCollectionTypes = ol.textContent?.includes("Collection Types");
+            return hasStack || hasCollectionTypes && ol.parentElement?.closest("ol") === null;
+          }) || allOls[0] || null;
+        }
+        const customNav = document.getElementById("stack-nav-container");
+        if (navContainer && !customNav) {
+          console.log("Navigation detected without custom navigation, reinitializing...");
+          setupNavigationReplacement();
+        }
+        hideCollectionTypeHeaders();
+        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("✅ cm-subnav-stacker is enabled, initializing navigation...");
+      setupContinuousNavigationCheck();
+    } else {
+      console.log("⏸️ cm-subnav-stacker is disabled, skipping initialization.");
+    }
+  });
+}
+const isPluginEnabled = async () => {
+  try {
+    const response = await fetch("/cm-subnav-stacker/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("✅ cm-subnav-stacker is enabled, building navigation...");
+        buildNavigation();
+      } else {
+        console.log("⏸️ cm-subnav-stacker 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": () => import("../_chunks/en-Byx4XI2L.mjs") }), `./translations/${locale}.json`, 3);
+          return { data, locale };
+        } catch {
+          return { data: {}, locale };
+        }
+      })
+    );
+  }
+};
+export {
+  index as default
+};