@mattisvensson/strapi-plugin-webatlas 0.7.0 → 0.8.0

package/dist/_chunks/{index-B6MYtu3A.mjs → index-Z3qq1ab8.mjs}

@@ -5,7 +5,7 @@ import { Box, Typography, Dialog, Button, Modal, Flex, SingleSelect, SingleSelec
 import { useState, useEffect, createContext, useRef, useContext, useReducer, useCallback, useMemo, forwardRef } from "react";
 import { createPortal } from "react-dom";
 import { useIntl } from "react-intl";
-import { u as useApi, g as getTranslation, d as debounce, a as duplicateCheck, t as transformToUrl, U as URLInfo } from "./index-CZ5qsGXH.mjs";
+import { u as useApi, g as getTranslation, d as debounce, a as duplicateCheck, t as transformToUrl, U as URLInfo, b as usePluginConfig } from "./index-DSPh-fHL.mjs";
 import { useFetchClient, useNotification, Page, Layouts } from "@strapi/strapi/admin";
 import { C as Center, F as FullLoader } from "./FullLoader-CrPED_dY.mjs";
 import { EmptyDocuments } from "@strapi/icons/symbols";
@@ -97,7 +97,6 @@ function Delete({ variant, item, onDelete }) {
   const { setModalType } = useContext(ModalContext);
   const { formatMessage } = useIntl();
   const { deleteNavigation } = useApi();
-  useNavigate();
   const handleDelete = async () => {
     try {
       if (variant === "NavDelete") {
@@ -4650,31 +4649,30 @@ function ItemCreateComponent({
   }, [path.needsUrlCheck, entityRoute?.documentId]);
   useEffect(() => {
     async function fetchRoute() {
-      if (selectedContentType?.contentType && selectedEntity?.id) {
-        setLoadingRoute(true);
-        try {
-          const route = await getRelatedRoute(selectedEntity.documentId);
-          if (!route) throw new Error("No route found for the selected entity");
-          dispatchPath({ type: "NO_URL_CHECK", payload: route.fullPath });
-          dispatchPath({ type: "SET_UIDPATH", payload: route.uidPath });
-          dispatchPath({ type: "SET_INITIALPATH", payload: route.fullPath });
-          dispatchItemState({ type: "SET_TITLE", payload: route.title });
-          dispatchItemState({ type: "SET_ACTIVE", payload: route.active });
-          dispatchItemState({ type: "SET_INTERNAL", payload: route.internal });
-          dispatchItemState({ type: "SET_OVERRIDE", payload: route.isOverride });
-          initialState.current = {
-            title: route.title,
-            slug: route.fullPath,
-            active: route.active,
-            internal: route.internal,
-            isOverride: route.isOverride
-          };
-          setEntityRoute(route);
-        } catch (err) {
-          console.log(err);
-        } finally {
-          setLoadingRoute(false);
-        }
+      if (!selectedContentType?.contentType || !selectedEntity?.documentId) return;
+      setLoadingRoute(true);
+      try {
+        const route = await getRelatedRoute(selectedEntity.documentId);
+        if (!route) throw new Error("No route found for the selected entity");
+        dispatchPath({ type: "NO_URL_CHECK", payload: route.fullPath });
+        dispatchPath({ type: "SET_UIDPATH", payload: route.uidPath });
+        dispatchPath({ type: "SET_INITIALPATH", payload: route.fullPath });
+        dispatchItemState({ type: "SET_TITLE", payload: route.title });
+        dispatchItemState({ type: "SET_ACTIVE", payload: route.active });
+        dispatchItemState({ type: "SET_INTERNAL", payload: route.internal });
+        dispatchItemState({ type: "SET_OVERRIDE", payload: route.isOverride });
+        initialState.current = {
+          title: route.title,
+          slug: route.fullPath,
+          active: route.active,
+          internal: route.internal,
+          isOverride: route.isOverride
+        };
+        setEntityRoute(route);
+      } catch (err) {
+        console.log(err);
+      } finally {
+        setLoadingRoute(false);
       }
     }
     fetchRoute();
@@ -10587,7 +10585,7 @@ const measuring = {
   }
 };
 const indentationWidth = 48;
-function getProjection(items, activeId, overId, dragOffset) {
+function getProjection(items, activeId, overId, dragOffset, maxDepthValue) {
   if (!items) return { depth: 0, maxDepth: 0, minDepth: 0 };
   const overItemIndex = items.findIndex(({ id }) => id === overId);
   const activeItemIndex = items.findIndex(({ id }) => id === activeId);
@@ -10596,7 +10594,7 @@ function getProjection(items, activeId, overId, dragOffset) {
   const previousItem = newItems[overItemIndex - 1];
   const dragDepth = getDragDepth(dragOffset, indentationWidth);
   const projectedDepth = activeItem && typeof activeItem.depth === "number" ? activeItem.depth + dragDepth : 0;
-  let maxDepth = getMaxDepth({ previousItem });
+  let maxDepth = getMaxDepth({ previousItem, maxDepthValue });
   let minDepth = 0;
   let depth = projectedDepth;
   if (projectedDepth >= maxDepth) {
@@ -10606,9 +10604,9 @@ function getProjection(items, activeId, overId, dragOffset) {
   }
   return { depth, maxDepth, minDepth };
 }
-function getMaxDepth({ previousItem }) {
+function getMaxDepth({ previousItem, maxDepthValue }) {
   if (previousItem && typeof previousItem.depth === "number") {
-    return previousItem.depth + 1;
+    return Math.min(previousItem.depth + 1, maxDepthValue - 1);
   }
   return 0;
 }
@@ -11839,6 +11837,7 @@ const Navigation = () => {
   const [isSavingNavigation, setIsSavingNavigation] = useState(false);
   const [loading, setLoading] = useState(true);
   const cachedNavigations = useRef(null);
+  const { config } = usePluginConfig();
   const [projected, setProjected] = useState(null);
   const [activeItem, setActiveItem] = useState();
   const [activeId, setActiveId] = useState(null);
@@ -11907,9 +11906,9 @@ const Navigation = () => {
     async function fetchNavigations() {
       if (!navigationId) {
         const navs = await getNavigation({ variant: "namesOnly" });
-        if (navs && navs.length > 0) {
+        if (navs && navs.length > 0)
           navigate(`/plugins/webatlas/navigation/${navs[0].documentId}`);
-        }
+        setLoading(false);
         return;
       }
       if (cachedNavigations.current) {
@@ -12028,11 +12027,12 @@ const Navigation = () => {
       navigationItems,
       activeId,
       overId,
-      offsetLeft
+      offsetLeft,
+      config?.navigation.maxDepth || 3
     ) : null;
     setProjected(projection);
   }, [activeId, overId, offsetLeft, navigationItems]);
-  if (loading || !navigationId) {
+  if (loading) {
     return /* @__PURE__ */ jsx(PageWrapper, { navigations, loading, children: /* @__PURE__ */ jsx(FullLoader, {}) });
   }
   return /* @__PURE__ */ jsx(ModalContext.Provider, { value: { modalType, setModalType }, children: /* @__PURE__ */ jsxs(SelectedNavigationContext.Provider, { value: { selectedNavigation, setSelectedNavigation }, children: [
@@ -12125,8 +12125,9 @@ const Navigation = () => {
       {
         variant: "NavDelete",
         item: actionItem,
-        onDelete: async () => {
+        onDelete: async (deletedItem) => {
           cachedNavigations.current = null;
+          setNavigations((navs) => navs.filter((nav) => nav.id !== deletedItem.id));
           navigate("/plugins/webatlas/navigation");
         }
       }
@@ -12153,9 +12154,9 @@ const Navigation = () => {
       {
         variant: "ItemDelete",
         item: actionItem,
-        onDelete: (editedItem) => {
+        onDelete: (deletedItem) => {
           setNavigationItems(
-            (items) => items?.map((item) => item.id === editedItem.id ? editedItem : item)
+            (items) => items?.map((item) => item.id === deletedItem.id ? deletedItem : item)
           );
         }
       }
@@ -12227,4 +12228,3 @@ const App = () => {
 export {
   App as default
 };
-//# sourceMappingURL=index-B6MYtu3A.mjs.map

package/dist/admin/index.js

@@ -1,5 +0,0 @@
-"use strict";
-const index = require("../_chunks/index-BOEv4jIJ.js");
-require("react/jsx-runtime");
-module.exports = index.index;
-//# sourceMappingURL=index.js.map

package/dist/admin/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/admin/index.mjs

@@ -1,6 +1,5 @@
-import { i } from "../_chunks/index-CZ5qsGXH.mjs";
+import { i } from "../_chunks/index-DSPh-fHL.mjs";
 import "react/jsx-runtime";
 export {
   i as default
 };
-//# sourceMappingURL=index.mjs.map

package/dist/admin/src/hooks/usePluginConfig.d.ts

@@ -3,7 +3,7 @@ type UsePluginConfigResponse = {
     config: PluginConfig | null;
     loading: boolean;
     fetchError: string | null;
-    setConfig: (body: PluginConfig) => Promise<void>;
+    setConfig: (body: Partial<PluginConfig>) => Promise<void>;
 };
 export default function usePluginConfig(): UsePluginConfigResponse;
 export {};

package/dist/admin/src/pages/Settings/{ContentTypeAccordion.d.ts → General/ContentTypeAccordion.d.ts}

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import type { ContentType, ConfigContentType } from '../../../../types';
+import type { ContentType, ConfigContentType } from '../../../../../types';
 export default function ContentTypeAccordion({ contentType, contentTypeSettings, dispatch }: {
     contentType: ContentType | undefined;
     contentTypeSettings: ConfigContentType;

package/dist/admin/src/pages/Settings/Navigation/index.d.ts

@@ -0,0 +1,2 @@
+declare const Settings: () => import("react/jsx-runtime").JSX.Element;
+export default Settings;

package/dist/admin/src/pages/Settings/PageWrapper.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="react" />
-export default function PageWrapper({ settingsState, initialState, save, isSaving, children }: {
-    settingsState?: any;
-    initialState?: any;
+export default function PageWrapper({ save, isSaving, disabledCondition, children }: {
     save?: () => void;
-    isSaving?: boolean;
+    isSaving: boolean;
+    disabledCondition: boolean;
     children: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/utils/dnd.d.ts

@@ -6,7 +6,7 @@ export declare const measuring: {
     };
 };
 export declare const indentationWidth = 48;
-export declare function getProjection(items: NestedNavItem[] | undefined, activeId: UniqueIdentifier, overId: UniqueIdentifier, dragOffset: number): {
+export declare function getProjection(items: NestedNavItem[] | undefined, activeId: UniqueIdentifier, overId: UniqueIdentifier, dragOffset: number, maxDepthValue: number): {
     depth: number;
     maxDepth: number;
     minDepth: number;

package/dist/server/index.js

@@ -20,7 +20,7 @@ function transformToUrl(input) {
   input = input.replace(/-+/g, "-");
   return input;
 }
-const version = "0.7.0";
+const version = "0.7.1";
 const keywords = [];
 const type = "commonjs";
 const exports$1 = {
@@ -5550,21 +5550,31 @@ async function createExternalRoute(data) {
 }
 const admin = ({ strapi: strapi2 }) => ({
   async updateConfig(newConfig) {
-    if (!newConfig || !newConfig.selectedContentTypes) return;
+    if (!newConfig) return;
+    let newConfigMerged;
     try {
-      const routes2 = await strapi2.documents(waRoute).findMany();
-      const invalidRoutes = routes2.filter((route2) => !newConfig.selectedContentTypes.find((type2) => type2.uid === route2.relatedContentType));
-      invalidRoutes?.map(async (route2) => {
-        await strapi2.documents(waRoute).delete({
-          documentId: route2.documentId
-        });
-      });
+      const pluginStore = await strapi2.store({ type: "plugin", name: PLUGIN_ID });
+      const config2 = await pluginStore.get({ key: "config" });
+      newConfigMerged = { ...config2, ...newConfig };
+      await pluginStore.set({ key: "config", value: newConfigMerged });
     } catch (err) {
       console.log(err);
-      return "Error. Couldn't delete invalid routes";
+      return "Error. Couldn't update config";
     }
-    const pluginStore = await strapi2.store({ type: "plugin", name: PLUGIN_ID });
-    await pluginStore.set({ key: "config", value: newConfig });
+    if (newConfigMerged.selectedContentTypes) {
+      try {
+        const routes2 = await strapi2.documents(waRoute).findMany();
+        const invalidRoutes = routes2.filter(
+          (route2) => !newConfigMerged.selectedContentTypes.find((type2) => type2.uid === route2.relatedContentType)
+        );
+        for (const route2 of invalidRoutes) {
+          await strapi2.documents(waRoute).delete({ documentId: route2.documentId });
+        }
+      } catch (err) {
+        console.log(err);
+      }
+    }
+    return newConfigMerged;
   },
   async getConfig() {
     const pluginStore = await strapi2.store({ type: "plugin", name: PLUGIN_ID });
@@ -5916,4 +5926,3 @@ const index = {
   middlewares
 };
 module.exports = index;
-//# sourceMappingURL=index.js.map

package/dist/server/index.mjs

@@ -19,7 +19,7 @@ function transformToUrl(input) {
   input = input.replace(/-+/g, "-");
   return input;
 }
-const version = "0.7.0";
+const version = "0.7.1";
 const keywords = [];
 const type = "commonjs";
 const exports = {
@@ -5549,21 +5549,31 @@ async function createExternalRoute(data) {
 }
 const admin = ({ strapi: strapi2 }) => ({
   async updateConfig(newConfig) {
-    if (!newConfig || !newConfig.selectedContentTypes) return;
+    if (!newConfig) return;
+    let newConfigMerged;
     try {
-      const routes2 = await strapi2.documents(waRoute).findMany();
-      const invalidRoutes = routes2.filter((route2) => !newConfig.selectedContentTypes.find((type2) => type2.uid === route2.relatedContentType));
-      invalidRoutes?.map(async (route2) => {
-        await strapi2.documents(waRoute).delete({
-          documentId: route2.documentId
-        });
-      });
+      const pluginStore = await strapi2.store({ type: "plugin", name: PLUGIN_ID });
+      const config2 = await pluginStore.get({ key: "config" });
+      newConfigMerged = { ...config2, ...newConfig };
+      await pluginStore.set({ key: "config", value: newConfigMerged });
     } catch (err) {
       console.log(err);
-      return "Error. Couldn't delete invalid routes";
+      return "Error. Couldn't update config";
     }
-    const pluginStore = await strapi2.store({ type: "plugin", name: PLUGIN_ID });
-    await pluginStore.set({ key: "config", value: newConfig });
+    if (newConfigMerged.selectedContentTypes) {
+      try {
+        const routes2 = await strapi2.documents(waRoute).findMany();
+        const invalidRoutes = routes2.filter(
+          (route2) => !newConfigMerged.selectedContentTypes.find((type2) => type2.uid === route2.relatedContentType)
+        );
+        for (const route2 of invalidRoutes) {
+          await strapi2.documents(waRoute).delete({ documentId: route2.documentId });
+        }
+      } catch (err) {
+        console.log(err);
+      }
+    }
+    return newConfigMerged;
   },
   async getConfig() {
     const pluginStore = await strapi2.store({ type: "plugin", name: PLUGIN_ID });
@@ -5917,4 +5927,3 @@ const index = {
 export {
   index as default
 };
-//# sourceMappingURL=index.mjs.map

package/dist/server/src/index.d.ts

@@ -62,7 +62,7 @@ declare const _default: {
         admin: ({ strapi }: {
             strapi: any;
         }) => {
-            updateConfig(newConfig: any): Promise<string>;
+            updateConfig(newConfig: Partial<import("../../types").PluginConfig>): Promise<import("../../types").PluginConfig | "Error. Couldn't update config">;
             getConfig(): Promise<any>;
             getRoutes(): Promise<any>;
             updateRoute(documentId: string, data: any): Promise<any>;

package/dist/server/src/services/admin.d.ts

@@ -1,8 +1,8 @@
-import type { NavigationInput, NestedNavItem, StructuredNavigationVariant } from "../../../types";
+import type { NavigationInput, NestedNavItem, PluginConfig, StructuredNavigationVariant } from "../../../types";
 declare const _default: ({ strapi }: {
     strapi: any;
 }) => {
-    updateConfig(newConfig: any): Promise<string>;
+    updateConfig(newConfig: Partial<PluginConfig>): Promise<PluginConfig | "Error. Couldn't update config">;
     getConfig(): Promise<any>;
     getRoutes(): Promise<any>;
     updateRoute(documentId: string, data: any): Promise<any>;

package/dist/server/src/services/index.d.ts

@@ -2,7 +2,7 @@ declare const _default: {
     admin: ({ strapi }: {
         strapi: any;
     }) => {
-        updateConfig(newConfig: any): Promise<string>;
+        updateConfig(newConfig: Partial<import("../../../types").PluginConfig>): Promise<import("../../../types").PluginConfig | "Error. Couldn't update config">;
         getConfig(): Promise<any>;
         getRoutes(): Promise<any>;
         updateRoute(documentId: string, data: any): Promise<any>;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.0",
+  "version": "0.8.0",
   "keywords": [],
   "type": "commonjs",
   "exports": {

package/dist/_chunks/FullLoader-CrPED_dY.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"FullLoader-CrPED_dY.mjs","sources":["../../admin/src/components/UI/Center.tsx","../../admin/src/components/UI/FullLoader.tsx"],"sourcesContent":["import { Flex } from '@strapi/design-system';\n\nexport default function Center({ height = 400, children }: { height?: number, children: React.ReactNode }) {\n\n  return (\n    <Flex direction=\"column\" minHeight={`${height}px`} justifyContent=\"center\">\n      {children}\n    </Flex>\n  )\n}","import { Loader, Box } from '@strapi/design-system';\nimport Center from './Center';\n\nexport default function FullLoader({ height }: { height?: number }) {\n  return (\n    <Center height={height}>\n      <Loader>Loading...</Loader>\n    </Center>\n  );\n}"],"names":[],"mappings":";;AAEA,SAAwB,OAAO,EAAE,SAAS,KAAK,YAA4D;AAGvG,SAAA,oBAAC,MAAK,EAAA,WAAU,UAAS,WAAW,GAAG,MAAM,MAAM,gBAAe,UAC/D,SACH,CAAA;AAEJ;ACNwB,SAAA,WAAW,EAAE,UAA+B;AAClE,6BACG,QAAO,EAAA,QACN,UAAC,oBAAA,QAAA,EAAO,wBAAU,EACpB,CAAA;AAEJ;"}

package/dist/_chunks/de-BZc1BkzH.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const de = {
-  "webatlas.navigation.page.title": "Navigation",
-  "webatlas.navigation.page.subtitle.noNavigationSelected": "Keine Navigation ausgewählt",
-  "webatlas.navigation.page.emptyNavigation": "Es existiert noch keine Navigation...",
-  "webatlas.navigation.page.createNewNavigation": "Neue Navigation erstellen",
-  "webatlas.navigation.page.createNewItem": "Neues Element erstellen",
-  "webatlas.navigation.page.newItemButton": "Neues Element",
-  "webatlas.navigation.page.selectNavigation": "Navigation auswählen",
-  "webatlas.navigation.page.navItem.addChildren": "Unterelement hinzufügen",
-  "webatlas.routes.page.title": "Routen",
-  "webatlas.routes.page.subtitle": "Übersicht aller vorhandenen Routen",
-  "webatlas.routes.page.emptyRoutes": "Es wurden keine Routen gefunden",
-  "webatlas.routes.page.column.type": "Typ",
-  "webatlas.routes.page.searchPlaceholder": "Routen suchen",
-  "webatlas.settings.page.subtitle": "Konfigurieren Sie Ihre Webatlas-Plugin-Einstellungen",
-  "webatlas.settings.page.enabledContentTypes": "Aktivierte Inhaltstypen",
-  "webatlas.settings.page.enabledContentTypes.hint": "Wählen Sie die Inhaltstypen aus, für die Sie URL-Aliase aktivieren möchten",
-  "webatlas.settings.page.enabledContentTypes.placeholder": "Inhaltstypen auswählen...",
-  "webatlas.settings.page.contentTypeSettings": "Inhaltstyp-Einstellungen",
-  "webatlas.settings.page.defaultField": "Standard URL-Alias Feld",
-  "webatlas.settings.page.defaultField.hint": 'Das ausgewählte Feld aus dem Inhaltstyp wird verwendet, um den URL-Alias zu generieren. Verwenden Sie ein Feld, das einzigartig und beschreibend ist, wie z.B. "Titel" oder "Name".',
-  "webatlas.settings.page.defaultField.error": "Bitte wählen Sie ein Standardfeld aus",
-  "webatlas.settings.page.urlAliasPattern": "URL-Alias Muster",
-  "webatlas.settings.page.urlAliasPattern.hint": 'Das Muster, das dem generierten URL-Alias vorangestellt wird. Wenn Sie z.B. "blog" eingeben und der Wert des Standardfelds "Mein erster Beitrag" ist, wird der generierte URL-Alias "blog/mein-erster-beitrag" sein. Lassen Sie es leer für kein Präfix.',
-  "webatlas.settings.page.urlAliasPattern.tooltip": "Führende und abschließende Schrägstriche werden entfernt. Leerzeichen werden durch Bindestriche ersetzt. Sonderzeichen werden kodiert.",
-  "webatlas.settings.page.urlAliasPattern.placeholder": "z.B. blog",
-  "webatlas.modal.navOverview.confirmText": "Neue Navigation",
-  "webatlas.modal.navOverview.closeText": "Abbrechen",
-  "webatlas.modal.navOverview.titleText": "Navigationsübersicht",
-  "webatlas.modal.navOverview.loadingText": "Erstellen",
-  "webatlas.modal.navModal.internalItem": "Internes Element",
-  "webatlas.modal.navModal.externalItem": "Externes Element",
-  "webatlas.modal.navModal.wrapperItem": "Wrapper Element",
-  "webatlas.modal.navEdit.confirmText": "Aktualisieren",
-  "webatlas.modal.navEdit.closeText": "Abbrechen",
-  "webatlas.modal.navEdit.titleText": "Navigation bearbeiten:",
-  "webatlas.modal.navEdit.loadingText": "Aktualisieren",
-  "webatlas.modal.delete.cancelText": "Nein, behalten",
-  "webatlas.modal.delete.confirmText": "Ja, löschen",
-  "webatlas.modal.delete.message.start": "Sie löschen gerade",
-  "webatlas.modal.delete.message.navItem": "das Navigationselement",
-  "webatlas.modal.delete.message.navigation": "die Navigation",
-  "webatlas.modal.delete.message.end": "Dies kann nicht rückgängig gemacht werden. Sind Sie sicher?",
-  "webatlas.modal.nameField.label": "Name",
-  "webatlas.modal.activeField.label": "Aktiv",
-  "webatlas.modal.activeField.onLabel": "Ja",
-  "webatlas.modal.activeField.offLabel": "Nein",
-  "webatlas.modal.wrapperItem.titleText.create": "Neues Wrapper-Element erstellen",
-  "webatlas.modal.wrapperItem.titleText.edit": "Wrapper-Element bearbeiten:",
-  "webatlas.modal.wrapperItem.loadingText.create": "Wird hinzugefügt",
-  "webatlas.modal.wrapperItem.loadingText.edit": "Wird gespeichert",
-  "webatlas.modal.wrapperItem.titleField.label": "Titel",
-  "webatlas.modal.wrapperItem.titleField.placeholder": "z.B. Über uns",
-  "webatlas.modal.internalItem.titleText.create": "Neues Navigationselement hinzufügen",
-  "webatlas.modal.internalItem.loadingText.create": "Wird erstellt",
-  "webatlas.modal.internalItem.contentType.label": "Inhaltstyp",
-  "webatlas.modal.internalItem.contentType.placeholder": "Wählen Sie einen Inhaltstyp",
-  "webatlas.modal.internalItem.entity.label": "Entität",
-  "webatlas.modal.internalItem.entity.placeholder": "Wählen Sie eine Entität",
-  "webatlas.modal.internalItem.loadingText.edit": "Wird gespeichert",
-  "webatlas.modal.externalItem.titleText.create": "Neues externes Element erstellen",
-  "webatlas.modal.externalItem.loadingText.create": "Wird hinzugefügt",
-  "webatlas.modal.externalItem.titleText.edit": "Externen Pfad bearbeiten:",
-  "webatlas.modal.externalItem.loadingText.edit": "Wird gespeichert",
-  "webatlas.modal.externalItem.routeField.placeholder": "z.B. https://example.com",
-  "webatlas.modal.item.titleField.label": "Titel",
-  "webatlas.modal.item.titleField.placeholder": "z.B. Über uns",
-  "webatlas.modal.item.routeField.label": "Route",
-  "webatlas.modal.item.routeField.placeholder": "z.B. ueber/",
-  "webatlas.components.URLInfo.checking": "Überprüfe, ob die URL verfügbar ist...",
-  "webatlas.components.URLInfo.available": "URL ist verfügbar",
-  "webatlas.components.URLInfo.notAvailable": "URL ist nicht verfügbar. Ersetzt durch",
-  "webatlas.components.CMEditViewAside.loading": "Wird geladen...",
-  "webatlas.components.CMEditViewAside.notAllowed.start": "Dieser Inhaltstyp ist nicht erlaubt für",
-  "webatlas.components.CMEditViewAside.notAllowed.end": "Wenn Sie ihn verwenden möchten, wenden Sie sich bitte an Ihren Administrator",
-  "webatlas.components.CMEditViewAside.notConfigured.start": "Dieser Inhaltstyp ist nicht konfiguriert für",
-  "webatlas.components.CMEditViewAside.notConfigured.middle": "Wenn Sie ihn verwenden möchten, konfigurieren Sie ihn bitte in den",
-  "webatlas.components.CMEditViewAside.notConfigured.end": "Einstellungen",
-  "webatlas.components.CMEditViewAside.alias.urlInput.tooltip": "Die folgenden Zeichen sind gültig: A-Z, a-z, 0-9, /, -, _, $, ., +, !, *, ', (, )",
-  "webatlas.components.CMEditViewAside.alias.urlInput.label": "URL",
-  "webatlas.components.CMEditViewAside.alias.urlInput.start": "Bearbeiten Sie das",
-  "webatlas.components.CMEditViewAside.alias.urlInput.end": "Feld, um eine URL zu generieren",
-  "webatlas.components.CMEditViewAside.alias.overrideCheckbox": "Automatische URL-Generierung überschreiben",
-  "webatlas.components.CMEditViewAside.alias.uidRoute.label": "UID Route",
-  "webatlas.components.CMEditViewAside.alias.uidRoute.hint": "Permanente UID-Route, kann nicht geändert werden",
-  "webatlas.components.CMEditViewAside.alias.documentIdRoute.label": "Dokumenten-ID Route",
-  "webatlas.components.CMEditViewAside.alias.documentIdRoute.hint": "Permanente Dokumenten-ID-Route, kann nicht geändert werden",
-  "webatlas.components.CMEditViewAside.alias.newRouteInfo": "Eine neue URL-Route wird beim Speichern dieses Eintrags erstellt.",
-  "webatlas.route.type.internal": "Intern",
-  "webatlas.route.type.external": "Extern",
-  "webatlas.route.type.wrapper": "Wrapper",
-  "webatlas.link.navigation": "Navigation",
-  "webatlas.link.routes": "Routen",
-  "webatlas.title": "Titel",
-  "webatlas.route": "Route",
-  "webatlas.actions": "Aktionen",
-  "webatlas.delete": "Löschen",
-  "webatlas.edit": "Bearbeiten",
-  "webatlas.add": "Hinzufügen",
-  "webatlas.cancel": "Abbrechen",
-  "webatlas.save": "Speichern",
-  "webatlas.select": "Auswählen",
-  "webatlas.manage": "Verwalten",
-  "webatlas.published": "Veröffentlicht",
-  "webatlas.draft": "Entwurf",
-  "webatlas.modified": "Geändert",
-  "webatlas.deleted": "Gelöscht",
-  "webatlas.restore": "Wiederherstellen",
-  "webatlas.notification.error": "Ein Fehler ist aufgetreten",
-  "webatlas.notification.settings.saved": "Einstellungen erfolgreich gespeichert",
-  "webatlas.notification.routes.fetchFailed": "Routen konnten nicht abgerufen werden",
-  "webatlas.notification.navigation.saveNavigationFailed": "Fehler beim Aktualisieren des Navigationselements",
-  "webatlas.notification.navigation.navigationSaved": "Navigation erfolgreich aktualisiert",
-  "webatlas.notification.navigation.fetchFailed": "Fehler beim Abrufen der Navigationen",
-  "webatlas.notification.navigation.notFound": "Navigation nicht gefunden. Zur Navigation weitergeleitet",
-  "webatlas.notification.navigation.creationFailed": "Erstellung der Navigation fehlgeschlagen"
-};
-exports.default = de;
-//# sourceMappingURL=de-BZc1BkzH.js.map

package/dist/_chunks/de-BZc1BkzH.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"de-BZc1BkzH.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/_chunks/de-oxxH8hft.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"de-oxxH8hft.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}