@mattisvensson/strapi-plugin-webatlas 0.7.1 → 0.8.0

package/dist/_chunks/{index-BFMLU2kR.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-C6Dorrjz.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";
@@ -4649,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();
@@ -10586,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);
@@ -10595,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) {
@@ -10605,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;
 }
@@ -11838,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);
@@ -12027,7 +12027,8 @@ const Navigation = () => {
       navigationItems,
       activeId,
       overId,
-      offsetLeft
+      offsetLeft,
+      config?.navigation.maxDepth || 3
     ) : null;
     setProjected(projection);
   }, [activeId, overId, offsetLeft, navigationItems]);
@@ -12227,4 +12228,3 @@ const App = () => {
 export {
   App as default
 };
-//# sourceMappingURL=index-BFMLU2kR.mjs.map

package/dist/admin/index.js

@@ -1,5 +0,0 @@
-"use strict";
-const index = require("../_chunks/index-2J9mPFyV.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-C6Dorrjz.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

@@ -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

@@ -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.1",
+  "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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/_chunks/en-Deg4n_IM.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const en = {
-  "webatlas.navigation.page.title": "Navigation",
-  "webatlas.navigation.page.subtitle.noNavigationSelected": "No navigation selected",
-  "webatlas.navigation.page.emptyNavigation": "You have no navigations yet...",
-  "webatlas.navigation.page.createNewNavigation": "Create new navigation",
-  "webatlas.navigation.page.createNewItem": "Create new item",
-  "webatlas.navigation.page.newItemButton": "New Item",
-  "webatlas.navigation.page.selectNavigation": "Select Navigation",
-  "webatlas.navigation.page.navItem.addChildren": "Add children",
-  "webatlas.routes.page.title": "Routes",
-  "webatlas.routes.page.subtitle": "Overview of all existing routes",
-  "webatlas.routes.page.emptyRoutes": "No routes found",
-  "webatlas.routes.page.column.type": "Type",
-  "webatlas.routes.page.searchPlaceholder": "Search routes",
-  "webatlas.settings.page.subtitle": "Configure your Webatlas plugin settings",
-  "webatlas.settings.page.enabledContentTypes": "Enabled Content Types",
-  "webatlas.settings.page.enabledContentTypes.hint": "Select the content types for which you want to enable URL aliases",
-  "webatlas.settings.page.enabledContentTypes.placeholder": "Select content types...",
-  "webatlas.settings.page.contentTypeSettings": "Content Type settings",
-  "webatlas.settings.page.defaultField": "Default URL Alias field",
-  "webatlas.settings.page.defaultField.hint": 'The selected field from the content type will be used to generate the URL alias. Use a field that is unique and descriptive, such as a "title" or "name".',
-  "webatlas.settings.page.defaultField.error": "Please select a default field",
-  "webatlas.settings.page.urlAliasPattern": "URL Alias Pattern",
-  "webatlas.settings.page.urlAliasPattern.hint": 'The pattern to prepend to the generated URL alias. For example, if you enter "blog" and the value of default field is "My First Post", the generated URL alias will be "blog/my-first-post". Leave empty for no prefix.',
-  "webatlas.settings.page.urlAliasPattern.tooltip": "Leading and trailing slashes will be removed. Spaces will be replaced with hyphens. Special characters will be encoded.",
-  "webatlas.settings.page.urlAliasPattern.placeholder": "e.g. blog",
-  "webatlas.modal.navOverview.confirmText": "New navigation",
-  "webatlas.modal.navOverview.closeText": "Cancel",
-  "webatlas.modal.navOverview.titleText": "Navigation overview",
-  "webatlas.modal.navOverview.loadingText": "Creating",
-  "webatlas.modal.navModal.internalItem": "Internal item",
-  "webatlas.modal.navModal.externalItem": "External item",
-  "webatlas.modal.navModal.wrapperItem": "Wrapper item",
-  "webatlas.modal.navEdit.confirmText": "Update",
-  "webatlas.modal.navEdit.closeText": "Cancel",
-  "webatlas.modal.navEdit.titleText": "Edit navigation:",
-  "webatlas.modal.navEdit.loadingText": "Updating",
-  "webatlas.modal.delete.cancelText": "No, keep",
-  "webatlas.modal.delete.confirmText": "Yes, delete",
-  "webatlas.modal.delete.message.start": "You are about to delete the following",
-  "webatlas.modal.delete.message.navItem": "navigation item",
-  "webatlas.modal.delete.message.navigation": "navigation",
-  "webatlas.modal.delete.message.end": "This can not be undone. Are you sure?",
-  "webatlas.modal.nameField.label": "Name",
-  "webatlas.modal.activeField.label": "Active",
-  "webatlas.modal.activeField.onLabel": "Yes",
-  "webatlas.modal.activeField.offLabel": "No",
-  "webatlas.modal.wrapperItem.titleText.create": "Create new wrapper item",
-  "webatlas.modal.wrapperItem.titleText.edit": "Edit wrapper item:",
-  "webatlas.modal.wrapperItem.loadingText.create": "Adding",
-  "webatlas.modal.wrapperItem.loadingText.edit": "Saving",
-  "webatlas.modal.wrapperItem.titleField.label": "Title",
-  "webatlas.modal.wrapperItem.titleField.placeholder": "e.g. About us",
-  "webatlas.modal.internalItem.titleText.create": "Add new navigation item",
-  "webatlas.modal.internalItem.loadingText.create": "Creating",
-  "webatlas.modal.internalItem.contentType.label": "Content Type",
-  "webatlas.modal.internalItem.contentType.placeholder": "Select a content type",
-  "webatlas.modal.internalItem.entity.label": "Entity",
-  "webatlas.modal.internalItem.entity.placeholder": "Select an entity",
-  "webatlas.modal.internalItem.loadingText.edit": "Saving",
-  "webatlas.modal.externalItem.titleText.create": "Create new external item",
-  "webatlas.modal.externalItem.loadingText.create": "Adding",
-  "webatlas.modal.externalItem.titleText.edit": "Edit external route:",
-  "webatlas.modal.externalItem.loadingText.edit": "Saving",
-  "webatlas.modal.externalItem.routeField.placeholder": "e.g. https://example.com",
-  "webatlas.modal.item.titleField.label": "Title",
-  "webatlas.modal.item.titleField.placeholder": "e.g. About Us",
-  "webatlas.modal.item.routeField.label": "Route",
-  "webatlas.modal.item.routeField.placeholder": "e.g. about/",
-  "webatlas.components.URLInfo.checking": "Checking if URL is available...",
-  "webatlas.components.URLInfo.available": "URL is available",
-  "webatlas.components.URLInfo.notAvailable": "URL is not available. Replaced with",
-  "webatlas.components.CMEditViewAside.loading": "Loading...",
-  "webatlas.components.CMEditViewAside.notAllowed.start": "This content type is not allowed for",
-  "webatlas.components.CMEditViewAside.notAllowed.end": "If you wish to use it, please contact your administrator",
-  "webatlas.components.CMEditViewAside.notConfigured.start": "This content type is not configured for",
-  "webatlas.components.CMEditViewAside.notConfigured.middle": "If you wish to use it, please configure it in the",
-  "webatlas.components.CMEditViewAside.notConfigured.end": "settings",
-  "webatlas.components.CMEditViewAside.alias.urlInput.tooltip": "The following characters are valid: A-Z, a-z, 0-9, /, -, _, $, ., +, !, *, ', (, )",
-  "webatlas.components.CMEditViewAside.alias.urlInput.label": "URL",
-  "webatlas.components.CMEditViewAside.alias.urlInput.start": "Edit the",
-  "webatlas.components.CMEditViewAside.alias.urlInput.end": "field to generate a URL",
-  "webatlas.components.CMEditViewAside.alias.overrideCheckbox": "Override automatic URL generation",
-  "webatlas.components.CMEditViewAside.alias.uidRoute.label": "UID route",
-  "webatlas.components.CMEditViewAside.alias.uidRoute.hint": "Permanent UID route, cannot be changed",
-  "webatlas.components.CMEditViewAside.alias.documentIdRoute.label": "Document ID route",
-  "webatlas.components.CMEditViewAside.alias.documentIdRoute.hint": "Permanent Document ID route, cannot be changed",
-  "webatlas.components.CMEditViewAside.alias.newRouteInfo": "A new URL route will be created upon saving this entry.",
-  "webatlas.route.type.internal": "Internal",
-  "webatlas.route.type.external": "External",
-  "webatlas.route.type.wrapper": "Wrapper",
-  "webatlas.link.navigation": "Navigation",
-  "webatlas.link.routes": "Routes",
-  "webatlas.title": "Title",
-  "webatlas.route": "Route",
-  "webatlas.actions": "Actions",
-  "webatlas.delete": "Delete",
-  "webatlas.edit": "Edit",
-  "webatlas.add": "Add",
-  "webatlas.cancel": "Cancel",
-  "webatlas.save": "Save",
-  "webatlas.select": "Select",
-  "webatlas.manage": "Manage",
-  "webatlas.published": "Published",
-  "webatlas.draft": "Draft",
-  "webatlas.modified": "Modified",
-  "webatlas.deleted": "Deleted",
-  "webatlas.restore": "Restore",
-  "webatlas.notification.error": "An error occurred",
-  "webatlas.notification.settings.saved": "Settings saved successfully",
-  "webatlas.notification.routes.fetchFailed": "Failed to fetch routes",
-  "webatlas.notification.navigation.saveNavigationFailed": "Error updating navigation item",
-  "webatlas.notification.navigation.navigationSaved": "Navigation updated successfully",
-  "webatlas.notification.navigation.fetchFailed": "Failed to fetch navigations",
-  "webatlas.notification.navigation.notFound": "Navigation not found. Redirected to navigation",
-  "webatlas.notification.navigation.creationFailed": "Creation of navigation failed"
-};
-exports.default = en;
-//# sourceMappingURL=en-Deg4n_IM.js.map

package/dist/_chunks/en-Deg4n_IM.js.map

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

package/dist/_chunks/en-DqC5aDzA.mjs.map

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