@mattisvensson/strapi-plugin-webatlas 0.1.0

package/dist/_chunks/index-CJUhT0VV.js

@@ -0,0 +1,773 @@
+"use strict";
+const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
+const icons = require("@strapi/icons");
+const admin = require("@strapi/strapi/admin");
+const designSystem = require("@strapi/design-system");
+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 version = "0.1.0";
+const keywords = [];
+const type = "commonjs";
+const exports$1 = {
+  "./package.json": "./package.json",
+  "./strapi-admin": {
+    types: "./dist/admin/src/index.d.ts",
+    source: "./admin/src/index.tsx",
+    "import": "./dist/admin/index.mjs",
+    require: "./dist/admin/index.js",
+    "default": "./dist/admin/index.js"
+  },
+  "./strapi-server": {
+    types: "./dist/server/src/index.d.ts",
+    source: "./server/src/index.ts",
+    "import": "./dist/server/index.mjs",
+    require: "./dist/server/index.js",
+    "default": "./dist/server/index.js"
+  }
+};
+const files = [
+  "dist"
+];
+const scripts = {
+  build: "strapi-plugin build && yalc push --publish",
+  watch: "strapi-plugin watch",
+  "watch:link": "strapi-plugin watch:link",
+  verify: "strapi-plugin verify",
+  "test:ts:front": "tsc -p admin/tsconfig.json",
+  "test:ts:back": "tsc -p server/tsconfig.json",
+  "test:jest": "ENV_PATH=./playground/.env  jest --verbose --runInBand --forceExit",
+  "test:cypress": "cypress run",
+  "test:cypress:open": "cypress open",
+  "playground:install": "yarn playground:yalc-add-link && cd playground && yarn install",
+  "playground:yalc-add": "cd playground && yalc add strapi-plugin-boilerplate",
+  "playground:yalc-add-link": "cd playground && yalc add --link strapi-plugin-boilerplate",
+  "playground:build": "cd playground && yarn build",
+  "playground:develop": "cd playground && yarn develop",
+  "playground:start": "cd playground && yarn start"
+};
+const dependencies = {
+  "@dnd-kit/core": "^6.3.1",
+  "@dnd-kit/sortable": "^10.0.0",
+  "@dnd-kit/utilities": "^3.2.2",
+  "@strapi/design-system": "^2.0.0-rc.14",
+  "@strapi/icons": "^2.0.0-rc.14",
+  "react-intl": "^7.1.0"
+};
+const devDependencies = {
+  "@strapi/sdk-plugin": "^5.0.0",
+  "@strapi/strapi": "^5.0.0",
+  "@strapi/typescript-utils": "^5.0.0",
+  "@types/react": "^19.0.0",
+  "@types/react-dom": "^19.0.0",
+  cypress: "^13.9.0",
+  "cypress-terminal-report": "^6.0.2",
+  jest: "^29.7.0",
+  prettier: "^3.4.2",
+  react: "^19.0.0",
+  "react-router-dom": "^6.0.0",
+  supertest: "^7.0.0",
+  typescript: "^5.7.2"
+};
+const peerDependencies = {
+  "@strapi/strapi": "^5.0.0",
+  react: "^17.0.0 || ^18.0.0",
+  "react-dom": "^17.0.0 || ^18.0.0",
+  "react-router-dom": "^6.0.0",
+  "styled-components": "^6.0.0"
+};
+const description = "A strapi plugin to manage URL routes and navigations.";
+const strapi = {
+  name: "webatlas",
+  displayName: "Webatlas",
+  description: "A strapi plugin to manage URL routes and navigations.",
+  kind: "plugin"
+};
+const name = "@mattisvensson/strapi-plugin-webatlas";
+const license = "MIT";
+const repository = {
+  type: "git",
+  url: "git+ssh://git@github.com:mattisvensson/strapi-plugin-webatlas.git"
+};
+const bugs = {
+  url: "https://github.com/mattisvensson/strapi-plugin-webatlas/issues"
+};
+const homepage = "https://github.com/mattisvensson/strapi-plugin-webatlas#readme";
+const author = {
+  name: "Matti Svensson",
+  email: "mattisvensson@web.de",
+  url: "https://mattisvensson.com"
+};
+const maintainers = [
+  {
+    name: "Matti Svensson",
+    email: "mattisvensson@web.de",
+    url: "https://mattisvensson.com"
+  }
+];
+const packageManager = "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e";
+const pluginPkg = {
+  version,
+  keywords,
+  type,
+  exports: exports$1,
+  files,
+  scripts,
+  dependencies,
+  devDependencies,
+  peerDependencies,
+  description,
+  strapi,
+  name,
+  license,
+  repository,
+  bugs,
+  homepage,
+  author,
+  maintainers,
+  packageManager
+};
+const PLUGIN_ID = pluginPkg.strapi.name.replace(/^(@[^-,.][\w,-]+\/|strapi-)plugin-/i, "") || "webatlas";
+const PLUGIN_NAME = pluginPkg.strapi.displayName;
+const Initializer = ({ setPlugin }) => {
+  const ref = React.useRef(setPlugin);
+  React.useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const RouteIcon = () => /* @__PURE__ */ jsxRuntime.jsx(icons.Link, {});
+const NavigationIcon = () => /* @__PURE__ */ jsxRuntime.jsx(icons.List, {});
+function useApi() {
+  const { get, post, put, del } = admin.useFetchClient();
+  const fetchAllContentTypes = async () => {
+    const { data } = await get("/content-manager/content-types");
+    return data.data;
+  };
+  const fetchAllEntities = async (contentTypes) => {
+    try {
+      if (!contentTypes) {
+        const { data } = await get("/webatlas/config");
+        contentTypes = data?.selectedContentTypes || [];
+      }
+      const allContentTypes = await fetchAllContentTypes();
+      let entities = [];
+      if (contentTypes && contentTypes.length > 0) {
+        entities = await Promise.all(
+          contentTypes.map(async (contentType) => {
+            const { data } = await get(`/content-manager/collection-types/${contentType.uid}`);
+            const entity = allContentTypes.find((ct) => ct.uid === contentType.uid);
+            if (!entity) {
+              throw new Error(`Content type ${contentType} not found`);
+            }
+            return {
+              entities: data.results,
+              label: entity.info.displayName,
+              contentType
+            };
+          })
+        );
+      }
+      return entities;
+    } catch (err) {
+      console.error(err);
+      throw err;
+    }
+  };
+  const getRouteByRelated = async (relatedDocumentId, populate) => {
+    const { data } = await get(`/content-manager/collection-types/plugin::webatlas.route?filters[relatedDocumentId][$eq]=${relatedDocumentId}${populate ? "&populate" + populate : ""}`);
+    if (data?.results) return data.results[0];
+    return null;
+  };
+  const createExternalRoute = async (body) => {
+    const { data } = await post("/webatlas/route/external", {
+      data: {
+        ...body
+      }
+    });
+    return data;
+  };
+  const getRoutes = async () => {
+    const { data } = await get("/webatlas/route");
+    return data;
+  };
+  const updateRoute = async (body, documentId) => {
+    const { data } = await put(`/webatlas/route?documentId=${documentId}`, {
+      data: {
+        ...body
+      }
+    });
+    return data;
+  };
+  const createNavItem = async (body) => {
+    const { data } = await post("/webatlas/navitem", {
+      data: {
+        ...body
+      }
+    });
+    return data;
+  };
+  const updateNavItem = async (documentId, body) => {
+    const { data } = await put(`/webatlas/navitem?documentId=${documentId}`, {
+      data: {
+        ...body
+      }
+    });
+    return data;
+  };
+  const deleteNavItem = async (documentId) => {
+    const { data } = await del(`/webatlas/navitem?documentId=${documentId}`);
+    return data;
+  };
+  const getStructuredNavigation = async (documentId, variant = "nested") => {
+    const { data } = await get(`/webatlas/navigation?documentId=${documentId}&variant=${variant}`);
+    return data;
+  };
+  const deleteNavigation = async (documentId) => {
+    const { data } = await del(`/webatlas/navigation?documentId=${documentId}`);
+    return data;
+  };
+  const updateNavigation = async (documentId, body) => {
+    const { data } = await put(`/webatlas/navigation?documentId=${documentId}`, {
+      data: body
+    });
+    return data;
+  };
+  return { fetchAllContentTypes, fetchAllEntities, getRouteByRelated, createExternalRoute, getRoutes, updateRoute, createNavItem, updateNavItem, deleteNavItem, getStructuredNavigation, deleteNavigation, updateNavigation };
+}
+const useAllContentTypes = () => {
+  const { fetchAllContentTypes } = useApi();
+  const [contentTypes, setContentTypes] = React.useState([]);
+  const [loading, setLoading] = React.useState(true);
+  const [error, setError] = React.useState(null);
+  React.useEffect(() => {
+    const fetchEntities = async () => {
+      try {
+        const result = await fetchAllContentTypes();
+        setContentTypes(result);
+        setLoading(false);
+      } catch (err) {
+        setError(err);
+        setLoading(false);
+      }
+    };
+    fetchEntities();
+  }, []);
+  return { contentTypes, loading, error };
+};
+function usePluginConfig() {
+  const { put, get } = admin.useFetchClient();
+  const [data, setData] = React.useState(null);
+  const [loading, setLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  React.useEffect(() => {
+    const fetchData = async () => {
+      setLoading(true);
+      try {
+        const { data: { data: contentTypesArray } } = await get("/content-manager/content-types");
+        let { data: config } = await get("/webatlas/config");
+        if (!config || !config.selectedContentTypes) {
+          throw new Error(`HTTP error! Couldn't fetch plugin config`);
+        }
+        const allowedContentTypes = contentTypesArray.filter(
+          (type2) => type2.pluginOptions?.webatlas?.active === true
+        );
+        const contentTypeUids = new Set(allowedContentTypes.map((type2) => type2.uid));
+        const activeContentTypes = config.selectedContentTypes.filter((type2) => contentTypeUids.has(type2.uid));
+        if (JSON.stringify(activeContentTypes) !== JSON.stringify(config.selectedContentTypes)) {
+          config = { ...config, selectedContentTypes: activeContentTypes };
+          setConfig(config);
+        }
+        setData(config);
+        setLoading(false);
+      } catch (error2) {
+        setError(error2.message);
+        setLoading(false);
+      }
+    };
+    fetchData();
+  }, []);
+  async function setConfig(body) {
+    try {
+      await put("/webatlas/config", {
+        ...body
+      });
+    } catch (error2) {
+      setError(error2.message);
+    }
+  }
+  return { data, loading, error, setConfig };
+}
+function transformToUrl(input) {
+  const specialCharMap = {
+    "ü": "ue",
+    "ä": "ae",
+    "ö": "oe"
+  };
+  if (!input || typeof input !== "string") return "";
+  input = input.toLowerCase();
+  input = input.replace(/\/+/g, "/");
+  input = input.startsWith("/") ? input.slice(1) : input;
+  input = input.endsWith("/") ? input.slice(0, -1) : input;
+  for (const char in specialCharMap) {
+    const regex = new RegExp(char, "g");
+    input = input.replace(regex, specialCharMap[char]);
+  }
+  input = input.trim();
+  input = input.replace(/\s+/g, "-");
+  input = input.replace(/[^A-Za-z0-9$\-_.+!*'()/]/g, "");
+  input = input.replace(/-+/g, "-");
+  return input;
+}
+function Tooltip({ description: description2 }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingLeft: 1, paddingRight: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Tooltip, { description: description2, children: /* @__PURE__ */ jsxRuntime.jsx(icons.Information, { "aria-hidden": "true" }) }) });
+}
+function debounce(func, wait) {
+  let timeout;
+  return function executedFunction(...args) {
+    const later = () => {
+      clearTimeout(timeout);
+      func(...args);
+    };
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+  };
+}
+function URLInfo({ validationState, replacement }) {
+  if (validationState === "initial") return null;
+  let color = "neutral800";
+  let text = "Checking if URL is available...";
+  if (validationState === "checking") {
+    color = "neutral800";
+    text = "Checking if URL is available...";
+  } else if (validationState === "done") {
+    color = replacement ? "danger500" : "success500";
+    text = replacement ? `URL is not available. Replaced with "${replacement}".` : "URL is available";
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 2, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: color, children: text }) });
+}
+async function duplicateCheck(url, routeDocumentId) {
+  if (!url) throw new Error("URL is required");
+  try {
+    const res = await fetch(`/webatlas/checkUniquePath?path=${transformToUrl(url)}${routeDocumentId ? `&targetRouteDocumentId=${routeDocumentId}` : ""}`);
+    if (!res.ok) throw new Error(`Network response was not ok: ${res.status} ${res.statusText}`);
+    return await res.text();
+  } catch (err) {
+    console.error("Error in duplicateCheck:", err);
+    throw new Error("Failed to check URL uniqueness");
+  }
+}
+function reducer(state, action) {
+  switch (action.type) {
+    case "DEFAULT":
+      return {
+        ...state,
+        value: transformToUrl(action.payload),
+        prevValue: state.value,
+        needsUrlCheck: true
+      };
+    case "NO_URL_CHECK":
+      return {
+        ...state,
+        value: transformToUrl(action.payload),
+        prevValue: state.value,
+        needsUrlCheck: false
+      };
+    case "NO_TRANSFORM_AND_CHECK":
+      return {
+        ...state,
+        value: action.payload,
+        prevValue: state.value,
+        needsUrlCheck: false
+      };
+    case "RESET_URL_CHECK_FLAG":
+      return { ...state, needsUrlCheck: false };
+    case "SET_UIDPATH":
+      return { ...state, uIdPath: action.payload };
+    case "SET_DOCUMENTIDPATH":
+      return { ...state, documentIdPath: action.payload };
+    default:
+      throw new Error();
+  }
+}
+const Alias = ({ config }) => {
+  const { layout, form } = admin.unstable_useContentManagerContext();
+  const { initialValues, values, onChange } = form;
+  const { getRouteByRelated } = useApi();
+  const [routeId, setRouteId] = React.useState();
+  const [isOverride, setIsOverride] = React.useState(false);
+  const [validationState, setValidationState] = React.useState("initial");
+  const [replacement, setReplacement] = React.useState("");
+  const [initialLoadComplete, setInitialLoadComplete] = React.useState(false);
+  const [path, dispatchPath] = React.useReducer(reducer, {
+    needsUrlCheck: false,
+    value: "",
+    prevValue: "",
+    uIdPath: ""
+  });
+  const hasUserChangedField = React.useRef(false);
+  const initialPath = React.useRef("");
+  const prevValueRef = React.useRef(null);
+  if (!config) return null;
+  const debouncedCheckUrl = React.useCallback(debounce(checkUrl, 500), []);
+  React.useEffect(() => {
+    onChange("webatlas_path", path.value);
+    onChange("webatlas_override", isOverride);
+  }, [path.value, routeId, isOverride]);
+  const debouncedValueEffect = React.useMemo(
+    () => debounce((currentValues) => {
+      const key = config?.default;
+      if (!key) return;
+      const currentValue = currentValues[key];
+      if (!currentValue) {
+        dispatchPath({ type: "NO_URL_CHECK", payload: "" });
+        return;
+      }
+      if (initialLoadComplete && (hasUserChangedField.current || !routeId) && prevValueRef.current !== currentValue && !isOverride) {
+        const path2 = config.pattern ? `${config.pattern}/${currentValue}` : `${currentValue}`;
+        if (currentValue === initialValues[key]) {
+          dispatchPath({ type: "NO_URL_CHECK", payload: path2 });
+        } else {
+          dispatchPath({ type: "DEFAULT", payload: path2 });
+        }
+        prevValueRef.current = currentValue;
+      }
+    }, 500),
+    [config?.default, config?.pattern, initialValues, isOverride, initialLoadComplete, routeId]
+  );
+  React.useEffect(() => {
+    if (!initialLoadComplete) return;
+    const key = config?.default;
+    if (!key) return;
+    const currentValue = values[key];
+    const initialValue = initialValues[key];
+    if (currentValue !== initialValue) {
+      hasUserChangedField.current = true;
+    }
+    debouncedValueEffect(values);
+  }, [values, debouncedValueEffect, initialLoadComplete]);
+  React.useEffect(() => {
+    if (path.needsUrlCheck && path.value) {
+      if (path.uIdPath === path.value || initialPath.current === path.value) return;
+      debouncedCheckUrl(path.value);
+      dispatchPath({ type: "RESET_URL_CHECK_FLAG" });
+    }
+  }, [path.needsUrlCheck]);
+  React.useEffect(() => {
+    async function getTypes() {
+      if (!initialValues.documentId) {
+        setInitialLoadComplete(true);
+        return;
+      }
+      try {
+        const route = await getRouteByRelated(initialValues.documentId);
+        if (!route) return;
+        initialPath.current = initialValues.webatlas_path || route.uIdPath;
+        setRouteId(route.id);
+        setIsOverride(route.isOverride || false);
+        dispatchPath({ type: "NO_TRANSFORM_AND_CHECK", payload: route.fullPath || "" });
+        dispatchPath({ type: "SET_UIDPATH", payload: route.uidPath || "" });
+        dispatchPath({ type: "SET_DOCUMENTIDPATH", payload: route.documentIdPath || "" });
+        const key = config?.default;
+        if (key) {
+          prevValueRef.current = values[key];
+        }
+      } catch (err) {
+        setRouteId(null);
+        console.log(err);
+      }
+      setInitialLoadComplete(true);
+    }
+    getTypes();
+  }, [config]);
+  React.useEffect(() => {
+    if (initialValues.webatlas_path) dispatchPath({ type: "NO_URL_CHECK", payload: initialValues.webatlas_path });
+    if (initialValues.webatlas_override) setIsOverride(initialValues.webatlas_override);
+  }, []);
+  async function checkUrl(url) {
+    if (!url) return;
+    setValidationState("checking");
+    setReplacement("");
+    try {
+      const data = await duplicateCheck(url);
+      if (!data || data === url) return;
+      dispatchPath({ type: "NO_URL_CHECK", payload: data });
+      setReplacement(data);
+    } catch (err) {
+      console.log(err);
+    } finally {
+      setValidationState("done");
+    }
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Box,
+    {
+      as: "aside",
+      "aria-labelledby": "URL Route",
+      width: "100%",
+      children: /* @__PURE__ */ jsxRuntime.jsxs(
+        designSystem.Flex,
+        {
+          direction: "column",
+          alignItems: "stretch",
+          gap: 4,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { hint: !initialValues.id && !config.default ? "[id] will be replaced with the entry ID" : "", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Label, { children: [
+                  "URL",
+                  /* @__PURE__ */ jsxRuntime.jsx(Tooltip, { description: "The following characters are valid: A-Z, a-z, 0-9, /, -, _, $, ., +, !, *, ', (, )" })
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  designSystem.Field.Input,
+                  {
+                    id: "url-input",
+                    value: path.value,
+                    placeholder: config.default ? `Edit the "${config.default}" field to generate a URL` : `${layout.list.settings.displayName?.toLowerCase()}/[id]`,
+                    onChange: (e) => dispatchPath({ type: "NO_TRANSFORM_AND_CHECK", payload: e.target.value }),
+                    disabled: !isOverride,
+                    onBlur: (e) => {
+                      if (e.target.value === path.prevValue) return;
+                      dispatchPath({ type: "DEFAULT", payload: e.target.value });
+                    }
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, {})
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsx(URLInfo, { validationState, replacement }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                designSystem.Flex,
+                {
+                  gap: 2,
+                  paddingTop: 2,
+                  children: /* @__PURE__ */ jsxRuntime.jsx(
+                    designSystem.Checkbox,
+                    {
+                      id: "override-url",
+                      checked: isOverride,
+                      onCheckedChange: () => setIsOverride((prev) => !prev),
+                      children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral600", children: "Override generated URL" })
+                    }
+                  )
+                }
+              )
+            ] }),
+            path.uIdPath && path.documentIdPath && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Divider, {}) }),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { children: /* @__PURE__ */ jsxRuntime.jsxs(
+                designSystem.Field.Root,
+                {
+                  hint: "Permanent UID path, cannot be changed.",
+                  label: "UID path",
+                  children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, {}),
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      designSystem.Field.Input,
+                      {
+                        value: path.uIdPath,
+                        disabled: true
+                      }
+                    ),
+                    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, {})
+                  ]
+                }
+              ) }),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { children: /* @__PURE__ */ jsxRuntime.jsxs(
+                designSystem.Field.Root,
+                {
+                  hint: "Permanent DocumentID path, cannot be changed.",
+                  label: "DocumentID path",
+                  children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, {}),
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      designSystem.Field.Input,
+                      {
+                        value: path.documentIdPath,
+                        disabled: true
+                      }
+                    ),
+                    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, {})
+                  ]
+                }
+              ) })
+            ] })
+          ]
+        }
+      )
+    }
+  );
+};
+const CMEditViewAside = () => {
+  const { model } = admin.unstable_useContentManagerContext();
+  const { contentTypes } = useAllContentTypes();
+  const { data: config } = usePluginConfig();
+  const [contentTypeConfig, setContentTypeConfig] = React.useState(null);
+  const [isAllowedContentType, setIsAllowedContentType] = React.useState(false);
+  const [isActiveContentType, setIsActiveContentType] = React.useState(true);
+  const [isLoading, setIsLoading] = React.useState(true);
+  React.useEffect(() => {
+    if (!config) return;
+    const modelConfig = contentTypes?.find((ct) => ct.uid === model);
+    if (modelConfig?.pluginOptions?.webatlas?.active) setIsAllowedContentType(true);
+    config?.selectedContentTypes?.map((type2) => {
+      if (type2.uid === model) {
+        setIsActiveContentType(true);
+        setContentTypeConfig(type2);
+      }
+    });
+    setIsLoading(false);
+  }, [config]);
+  React.useEffect(() => {
+    const label = Array.from(document.querySelectorAll("label")).find((l) => l.textContent?.startsWith("webatlas_path"));
+    if (label) {
+      let parentDiv = label.closest("div");
+      for (let i = 0; i < 2; i++) {
+        if (parentDiv) {
+          parentDiv = parentDiv.parentElement;
+        }
+      }
+      if (parentDiv) {
+        const grandParentDiv = parentDiv.parentElement;
+        if (grandParentDiv && grandParentDiv.children.length === 1) {
+          grandParentDiv.parentElement?.remove();
+          return;
+        } else {
+          parentDiv.remove();
+        }
+      }
+    }
+  }, []);
+  if (!isLoading) return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral600", children: "Loading..." });
+  if (!isAllowedContentType) return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { textColor: "neutral600", children: [
+    "This content type is not allowed for ",
+    /* @__PURE__ */ jsxRuntime.jsx("strong", { children: "WebAtlas" }),
+    ". If you wish to use it, please contact your administrator."
+  ] });
+  if (isActiveContentType || !contentTypeConfig) return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { textColor: "neutral600", children: [
+    "This content type is not configured for ",
+    /* @__PURE__ */ jsxRuntime.jsx("strong", { children: "WebAtlas" }),
+    ". If you wish to use it, please configure it in the",
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Link, { href: "/admin/settings/webatlas/configuration", marginLeft: 1, children: "settings" }),
+    "."
+  ] });
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(Alias, { config: contentTypeConfig }) });
+};
+const index = {
+  register(app) {
+    app.addMenuLink({
+      to: `/plugins/${PLUGIN_ID}/routes`,
+      icon: RouteIcon,
+      intlLabel: {
+        id: `${PLUGIN_ID}.link.routes`,
+        defaultMessage: "Routes"
+      },
+      Component: async () => {
+        const component = await Promise.resolve().then(() => require("./index-B8hoZtTR.js"));
+        return { default: component.default };
+      },
+      permissions: [
+        // Uncomment to set the permissions of the plugin here
+        // {
+        //   action: '', // the action name should be plugin::plugin-name.actionType
+        //   subject: null,
+        // },
+      ]
+    });
+    app.addMenuLink({
+      to: `/plugins/${PLUGIN_ID}/navigation`,
+      icon: NavigationIcon,
+      intlLabel: {
+        id: `${PLUGIN_ID}.link.navigation`,
+        defaultMessage: "Navigation"
+      },
+      Component: async () => {
+        const component = await Promise.resolve().then(() => require("./index-D9yK1vNq.js"));
+        return { default: component.default };
+      },
+      permissions: [
+        // Uncomment to set the permissions of the plugin here
+        // {
+        //   action: '', // the action name should be plugin::plugin-name.actionType
+        //   subject: null,
+        // },
+      ]
+    });
+    app.addSettingsLink(
+      {
+        id: PLUGIN_ID,
+        intlLabel: {
+          id: `${PLUGIN_ID}.settings.section`,
+          defaultMessage: "Webatlas"
+        }
+      },
+      {
+        intlLabel: {
+          id: `${PLUGIN_ID}.settings.section`,
+          defaultMessage: "Configuration"
+        },
+        id: PLUGIN_ID,
+        to: `/settings/${PLUGIN_ID}/configuration`,
+        Component: async () => {
+          return await Promise.resolve().then(() => require(
+            /* webpackChunkName: "webatlas-settings-page" */
+            "./index-B76GOOtR.js"
+          ));
+        },
+        permissions: [
+          // Uncomment to set the permissions of the plugin here
+          // {
+          //   action: '', // the action name should be plugin::plugin-name.actionType
+          //   subject: null,
+          // },
+        ]
+      }
+    );
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_NAME
+    });
+  },
+  bootstrap(app) {
+    app.getPlugin("content-manager").apis.addEditViewSidePanel([() => ({
+      title: "URL Alias",
+      content: /* @__PURE__ */ jsxRuntime.jsx(CMEditViewAside, {})
+    })]);
+  },
+  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("./en-B4KWt_jN.js")) }), `./translations/${locale}.json`, 3);
+          return { data, locale };
+        } catch {
+          return { data: {}, locale };
+        }
+      })
+    );
+  }
+};
+exports.Tooltip = Tooltip;
+exports.URLInfo = URLInfo;
+exports.debounce = debounce;
+exports.duplicateCheck = duplicateCheck;
+exports.index = index;
+exports.transformToUrl = transformToUrl;
+exports.useAllContentTypes = useAllContentTypes;
+exports.useApi = useApi;
+exports.usePluginConfig = usePluginConfig;