@mattisvensson/strapi-plugin-webatlas 0.3.1 → 0.4.2

package/dist/_chunks/{index-BBL_eQ0G.mjs → index-CtJ_9-RB.mjs}

@@ -23,7 +23,7 @@ const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
     );
   });
 };
-const version = "0.3.0";
+const version = "0.4.1";
 const keywords = [];
 const type = "commonjs";
 const exports = {
@@ -197,14 +197,6 @@ function useApi() {
     const { data } = await get(`/webatlas/route/related?documentId=${relatedDocumentId}`);
     return data;
   };
-  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;
@@ -217,30 +209,17 @@ function useApi() {
     });
     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 getNavigation = async ({ documentId, variant } = {}) => {
+    const query = [];
+    if (documentId) query.push(`documentId=${documentId}`);
+    if (variant) query.push(`variant=${variant}`);
+    const { data } = await get(`/webatlas/navigation${query.length > 0 ? `?${query.join("&")}` : ""}`);
+    return data;
+  };
   const deleteNavigation = async (documentId) => {
     const { data } = await del(`/webatlas/navigation?documentId=${documentId}`);
     return data;
@@ -251,19 +230,24 @@ function useApi() {
     });
     return data;
   };
+  const updateNavigationItemStructure = async (documentId, navigationItems) => {
+    const { data } = await put(`/webatlas/navigation/items`, {
+      navigationId: documentId,
+      navigationItems
+    });
+    return data;
+  };
   return {
     fetchAllContentTypes,
     fetchAllEntities,
     getRelatedRoute,
-    createExternalRoute,
     getRoutes,
     updateRoute,
-    createNavItem,
-    updateNavItem,
-    deleteNavItem,
     getStructuredNavigation,
+    getNavigation,
     deleteNavigation,
-    updateNavigation
+    updateNavigation,
+    updateNavigationItemStructure
   };
 }
 const useAllContentTypes = () => {
@@ -288,31 +272,32 @@ const useAllContentTypes = () => {
 };
 function usePluginConfig() {
   const { put, get } = useFetchClient();
-  const [data, setData] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState(null);
+  const [config, setConfigData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [fetchError, setFetchError] = useState(null);
   useEffect(() => {
     const fetchData = async () => {
       setLoading(true);
+      setFetchError(null);
       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`);
+        let { data: config2 } = await get("/webatlas/config");
+        if (!config2 || !config2.selectedContentTypes) {
+          throw new 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);
+        const activeContentTypes = config2.selectedContentTypes.filter((type2) => contentTypeUids.has(type2.uid));
+        if (JSON.stringify(activeContentTypes) !== JSON.stringify(config2.selectedContentTypes)) {
+          config2 = { ...config2, selectedContentTypes: activeContentTypes };
+          await setConfig(config2);
         }
-        setData(config);
-        setLoading(false);
-      } catch (error2) {
-        setError(error2.message);
+        setConfigData(config2);
+      } catch (error) {
+        setFetchError(error.message);
+      } finally {
         setLoading(false);
       }
     };
@@ -320,14 +305,12 @@ function usePluginConfig() {
   }, []);
   async function setConfig(body) {
     try {
-      await put("/webatlas/config", {
-        ...body
-      });
-    } catch (error2) {
-      setError(error2.message);
+      await put("/webatlas/config", { ...body });
+    } catch (error) {
+      throw error;
     }
   }
-  return { data, loading, error, setConfig };
+  return { config, loading, fetchError, setConfig };
 }
 function transformToUrl(input) {
   const specialCharMap = {
@@ -3988,7 +3971,7 @@ const Alias = ({ config }) => {
 const CMEditViewAside = () => {
   const { model } = unstable_useContentManagerContext();
   const { contentTypes } = useAllContentTypes();
-  const { data: config } = usePluginConfig();
+  const { config } = usePluginConfig();
   const [contentTypeConfig, setContentTypeConfig] = useState(null);
   const [isAllowedContentType, setIsAllowedContentType] = useState(false);
   const [isActiveContentType, setIsActiveContentType] = useState(false);
@@ -4076,7 +4059,7 @@ const index = {
         defaultMessage: "Routes"
       },
       Component: async () => {
-        const component = await import("./index-DZmhgSeq.mjs");
+        const component = await import("./index-9db80XRS.mjs");
         return { default: component.default };
       },
       permissions: [
@@ -4095,7 +4078,7 @@ const index = {
         defaultMessage: "Navigation"
       },
       Component: async () => {
-        const component = await import("./index-CwHhwtOU.mjs");
+        const component = await import("./index-B4pe6Yuh.mjs");
         return { default: component.default };
       },
       permissions: [
@@ -4124,7 +4107,7 @@ const index = {
         Component: async () => {
           return await import(
             /* webpackChunkName: "webatlas-settings-page" */
-            "./index-BOq-WidK.mjs"
+            "./index-CVj7qbwh.mjs"
           );
         },
         permissions: [
@@ -4153,7 +4136,7 @@ const index = {
     return Promise.all(
       locales.map(async (locale) => {
         try {
-          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/de.json": () => import("./de-C8PE3n3B.mjs"), "./translations/en.json": () => import("./en-CR1YZvJo.mjs") }), `./translations/${locale}.json`, 3);
+          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/de.json": () => import("./de-Dn24NwJf.mjs"), "./translations/en.json": () => import("./en-D9Lxaugc.mjs") }), `./translations/${locale}.json`, 3);
           return { data, locale };
         } catch {
           return { data: {}, locale };
@@ -4166,7 +4149,6 @@ export {
   PLUGIN_NAME as P,
   Tooltip as T,
   URLInfo as U,
-  _extends as _,
   duplicateCheck as a,
   usePluginConfig as b,
   useAllContentTypes as c,

package/dist/_chunks/index-IHvD3566.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
+const designSystem = require("@strapi/design-system");
+const admin = require("@strapi/strapi/admin");
+const index = require("./index-CSYue_D0.js");
+const reactIntl = require("react-intl");
+require("@strapi/icons/symbols");
+const FullLoader = require("./FullLoader-Cmsf8xS6.js");
+function PageWrapper({
+  settingsState,
+  initialState,
+  save,
+  isSaving,
+  children
+}) {
+  const { formatMessage } = reactIntl.useIntl();
+  return /* @__PURE__ */ jsxRuntime.jsxs(admin.Page.Main, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      admin.Layouts.Header,
+      {
+        title: index.PLUGIN_NAME,
+        subtitle: formatMessage({
+          id: index.getTranslation("settings.page.subtitle"),
+          defaultMessage: "Settings"
+        }),
+        primaryAction: settingsState && initialState && save && /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Button,
+          {
+            type: "submit",
+            onClick: () => save(),
+            loading: isSaving,
+            disabled: JSON.stringify(settingsState) === JSON.stringify(initialState) || settingsState.selectedContentTypes.find((cta) => !cta.default) !== void 0 || isSaving,
+            children: formatMessage({
+              id: index.getTranslation("save"),
+              defaultMessage: "Save"
+            })
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(admin.Layouts.Content, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Box,
+      {
+        background: "neutral0",
+        borderColor: "neutral150",
+        hasRadius: true,
+        paddingBottom: 4,
+        paddingLeft: 4,
+        paddingRight: 4,
+        paddingTop: 6,
+        shadow: "tableShadow",
+        children
+      }
+    ) })
+  ] });
+}
+function ContentTypeAccordion({
+  contentType,
+  contentTypeSettings,
+  dispatch
+}) {
+  const { formatMessage } = reactIntl.useIntl();
+  if (!contentType) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Box,
+    {
+      borderColor: !contentTypeSettings.default && "danger500",
+      children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Accordion.Item, { value: contentType.uid, size: "S", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Accordion.Header, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Accordion.Trigger, { children: contentType?.info.displayName }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Accordion.Content, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { padding: 3, children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            designSystem.Field.Root,
+            {
+              name: "selectedContentTypes",
+              hint: formatMessage({
+                id: index.getTranslation("settings.page.defaultField.hint"),
+                defaultMessage: '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".'
+              }),
+              error: !contentTypeSettings.default && formatMessage({
+                id: index.getTranslation("settings.page.defaultField.error"),
+                defaultMessage: "Please select a default field"
+              }),
+              required: true,
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: formatMessage({
+                  id: index.getTranslation("settings.page.defaultField"),
+                  defaultMessage: "Default URL Alias field"
+                }) }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  designSystem.SingleSelect,
+                  {
+                    name: `defaultField-${contentType.uid}`,
+                    onClear: () => dispatch({ type: "SET_DEFAULT_FIELD", payload: { ctUid: contentType.uid, field: "" } }),
+                    value: contentTypeSettings?.default || "",
+                    onChange: (value) => dispatch({ type: "SET_DEFAULT_FIELD", payload: { ctUid: contentType.uid, field: value } }),
+                    children: Object.entries(contentType.attributes).map(([key], index2) => {
+                      if (key === "id" || key === "documentId" || key === "createdAt" || key === "updatedAt" || key === "createdBy" || key === "updatedBy" || key === "webatlas_path" || key === "webatlas_override") return null;
+                      return /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: key, children: key }, index2);
+                    })
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, {})
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 4, children: /* @__PURE__ */ jsxRuntime.jsxs(
+            designSystem.Field.Root,
+            {
+              name: "urlAliasPattern",
+              hint: formatMessage({
+                id: index.getTranslation("settings.page.urlAliasPattern.hint"),
+                defaultMessage: '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.'
+              }),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Label, { children: [
+                  formatMessage({
+                    id: index.getTranslation("settings.page.urlAliasPattern"),
+                    defaultMessage: "URL Alias Pattern"
+                  }),
+                  /* @__PURE__ */ jsxRuntime.jsx(index.Tooltip, { description: formatMessage({
+                    id: index.getTranslation("settings.page.urlAliasPattern.tooltip"),
+                    defaultMessage: "Leading and trailing slashes will be removed. Spaces will be replaced with hyphens. Special characters will be encoded."
+                  }) })
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  designSystem.Field.Input,
+                  {
+                    value: contentTypeSettings.pattern,
+                    onChange: (e) => dispatch({ type: "SET_PATTERN", payload: { ctUid: contentType.uid, pattern: e.target.value } }),
+                    disabled: !contentTypeSettings.default,
+                    type: "text",
+                    placeholder: formatMessage({
+                      id: index.getTranslation("settings.page.urlAliasPattern.placeholder"),
+                      defaultMessage: "e.g. blog"
+                    })
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, {})
+              ]
+            }
+          ) })
+        ] }) })
+      ] }, contentType.uid)
+    },
+    contentType.uid
+  );
+}
+function reducer(settingsState, action) {
+  let updatedContentTypes;
+  switch (action.type) {
+    case "SET_SELECTED_CONTENT_TYPES":
+      updatedContentTypes = action.payload.map((ct) => {
+        return settingsState.selectedContentTypes.find((cta) => cta.uid === ct.uid) || ct;
+      });
+      return { ...settingsState, selectedContentTypes: updatedContentTypes };
+    case "SET_DEFAULT_FIELD":
+      updatedContentTypes = settingsState.selectedContentTypes.map(
+        (ct) => ct.uid === action.payload.ctUid ? { ...ct, default: action.payload.field } : ct
+      );
+      return { ...settingsState, selectedContentTypes: updatedContentTypes };
+    case "SET_PATTERN":
+      updatedContentTypes = settingsState.selectedContentTypes.map(
+        (ct) => ct.uid === action.payload.ctUid ? { ...ct, pattern: index.transformToUrl(action.payload.pattern) } : ct
+      );
+      return { ...settingsState, selectedContentTypes: updatedContentTypes };
+    default:
+      throw new Error();
+  }
+}
+const Settings = () => {
+  const { config, setConfig, loading, fetchError } = index.usePluginConfig();
+  const [settingsState, dispatch] = React.useReducer(reducer, config || { selectedContentTypes: [] });
+  const { contentTypes: allContentTypesData } = index.useAllContentTypes();
+  const allContentTypes = allContentTypesData?.filter((ct) => ct.pluginOptions?.webatlas?.active === true);
+  const [initialState, setInitialState] = React.useState(config || { selectedContentTypes: [] });
+  const { toggleNotification } = admin.useNotification();
+  const { formatMessage } = reactIntl.useIntl();
+  const [isSaving, setIsSaving] = React.useState(false);
+  React.useEffect(() => {
+    setInitialState(config || { selectedContentTypes: [] });
+  }, [config]);
+  React.useEffect(() => {
+    if (!config) return;
+    dispatch({ type: "SET_SELECTED_CONTENT_TYPES", payload: config.selectedContentTypes });
+  }, [config]);
+  React.useEffect(() => {
+    if (fetchError) {
+      toggleNotification({
+        type: "danger",
+        message: formatMessage({
+          id: index.getTranslation("notification.error"),
+          defaultMessage: "An error occurred"
+        }) + ": " + fetchError
+      });
+    }
+  }, [fetchError, toggleNotification, formatMessage]);
+  async function save() {
+    if (!settingsState || settingsState.selectedContentTypes.find((cta) => !cta.default) !== void 0) return;
+    setIsSaving(true);
+    try {
+      await setConfig(settingsState);
+      setInitialState(settingsState);
+      toggleNotification({
+        type: "success",
+        message: formatMessage({
+          id: index.getTranslation("notification.settings.saved"),
+          defaultMessage: "Settings saved successfully"
+        })
+      });
+      setIsSaving(false);
+    } catch (err) {
+      setIsSaving(false);
+      toggleNotification({
+        type: "danger",
+        message: formatMessage({
+          id: index.getTranslation("notification.error"),
+          defaultMessage: "An error occurred"
+        }) + ": " + err
+      });
+      console.error(err);
+    }
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsxRuntime.jsx(PageWrapper, { children: /* @__PURE__ */ jsxRuntime.jsx(FullLoader.FullLoader, { height: 200 }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(PageWrapper, { settingsState, initialState, save, isSaving, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      designSystem.Field.Root,
+      {
+        name: "selectedContentTypes",
+        hint: formatMessage({
+          id: index.getTranslation("settings.page.enabledContentTypes.hint"),
+          defaultMessage: "Select the content types for which you want to enable URL aliases"
+        }),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: formatMessage({
+            id: index.getTranslation("settings.page.enabledContentTypes"),
+            defaultMessage: "Enabled Content Types"
+          }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.MultiSelect,
+            {
+              placeholder: formatMessage({
+                id: index.getTranslation("settings.page.enabledContentTypes.placeholder"),
+                defaultMessage: "Select content types..."
+              }),
+              onClear: () => dispatch({ type: "SET_SELECTED_CONTENT_TYPES", payload: [] }),
+              value: [...settingsState.selectedContentTypes.map((ct) => ct.uid)],
+              onChange: (value) => dispatch({
+                type: "SET_SELECTED_CONTENT_TYPES",
+                payload: value.map((v) => ({
+                  uid: v,
+                  default: "",
+                  pattern: ""
+                }))
+              }),
+              withTags: true,
+              children: allContentTypes && allContentTypes.map(
+                (item) => /* @__PURE__ */ jsxRuntime.jsx(designSystem.MultiSelectOption, { value: item.uid, children: item.info.displayName }, item.uid)
+              )
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, {})
+        ]
+      }
+    ),
+    settingsState.selectedContentTypes && settingsState.selectedContentTypes.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 4, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { name: "selectedContentTypesAccordion", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: formatMessage({
+        id: index.getTranslation("settings.page.contentTypeSettings"),
+        defaultMessage: "Content Type settings"
+      }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Accordion.Root, { children: settingsState.selectedContentTypes?.map((contentTypeSettings) => {
+        const ct = allContentTypes?.find((item) => item.uid === contentTypeSettings.uid);
+        return /* @__PURE__ */ jsxRuntime.jsx(ContentTypeAccordion, { contentType: ct, contentTypeSettings, dispatch }, contentTypeSettings.uid);
+      }) })
+    ] }) })
+  ] });
+};
+exports.default = Settings;

package/dist/admin/index.js

@@ -1,4 +1,4 @@
 "use strict";
-const index = require("../_chunks/index-CKoxbSC0.js");
+const index = require("../_chunks/index-CSYue_D0.js");
 require("react/jsx-runtime");
 module.exports = index.index;

package/dist/admin/index.mjs

@@ -1,4 +1,4 @@
-import { i } from "../_chunks/index-BBL_eQ0G.mjs";
+import { i } from "../_chunks/index-CtJ_9-RB.mjs";
 import "react/jsx-runtime";
 export {
   i as default

package/dist/admin/src/components/UI/FullLoader.d.ts

@@ -0,0 +1,3 @@
+export default function FullLoader({ height }: {
+    height?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/UI/index.d.ts

@@ -1,3 +1,4 @@
 import Center from "./Center";
 import EmptyBox from "./EmptyBox";
-export { Center, EmptyBox, };
+import FullLoader from "./FullLoader";
+export { Center, EmptyBox, FullLoader, };

package/dist/admin/src/components/modals/Delete.d.ts

@@ -2,13 +2,13 @@ import { NestedNavigation, NestedNavItem } from '../../../../types';
 type NavDelete = {
     variant: "NavDelete";
     item: NestedNavigation;
-    fetchNavigations: () => void;
+    onDelete: (editedItem: NestedNavigation) => void;
 };
 type ItemDelete = {
     variant: "ItemDelete";
     item: NestedNavItem;
-    fetchNavigations: () => void;
+    onDelete: (editedItem: NestedNavItem) => void;
 };
 type DeleteProps = NavDelete | ItemDelete;
-export default function Delete({ variant, item, fetchNavigations }: DeleteProps): import("react/jsx-runtime").JSX.Element;
+export default function Delete({ variant, item, onDelete }: DeleteProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/components/modals/NavEdit.d.ts

@@ -1,7 +1,7 @@
 import { NestedNavigation } from '../../../../types';
 type NavEditProps = {
     item: NestedNavigation;
-    fetchNavigations: () => void;
+    onEdit: () => void;
 };
-export default function NavEdit({ item, fetchNavigations }: NavEditProps): import("react/jsx-runtime").JSX.Element;
+export default function NavEdit({ item, onEdit }: NavEditProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/components/modals/externalItem/index.d.ts

@@ -1,9 +1,15 @@
 import { NestedNavItem } from '../../../../../types';
 import React from 'react';
-type externalItemProps = {
-    variant: 'ExternalCreate' | 'ExternalEdit';
-    item?: NestedNavItem;
-    parentDocumentId?: string;
+type externalCreateProps = {
+    variant: 'ExternalCreate';
+    parentId?: string;
+    onCreate: (newItem: NestedNavItem) => void;
 };
+type externalEditProps = {
+    variant: 'ExternalEdit';
+    item: NestedNavItem;
+    onSave: (editedItem: NestedNavItem) => void;
+};
+type externalItemProps = externalCreateProps | externalEditProps;
 export declare const ExternalItem: React.FC<externalItemProps>;
 export {};

package/dist/admin/src/components/modals/internalItem/internalItemCreate.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="react" />
-import { ModalItem_VariantCreate } from '../../../../../types';
+import type { ModalItem_VariantCreate } from '../../../../../types';
 export declare const ItemCreate: import("react").FC<ModalItem_VariantCreate>;

package/dist/admin/src/components/modals/wrapperItem/index.d.ts

@@ -1,9 +1,15 @@
 import { NestedNavItem } from '../../../../../types';
 import React from 'react';
-type externalItemProps = {
-    variant: 'WrapperCreate' | 'WrapperEdit';
-    item?: NestedNavItem;
-    parentDocumentId?: string;
+type wrapperCreateProps = {
+    variant: 'WrapperCreate';
+    parentId?: string;
+    onCreate: (newItem: NestedNavItem) => void;
 };
-export declare const WrapperItem: React.FC<externalItemProps>;
+type wrapperEditProps = {
+    variant: 'WrapperEdit';
+    item: NestedNavItem;
+    onSave: (editedItem: NestedNavItem) => void;
+};
+type wrapperItemProps = wrapperCreateProps | wrapperEditProps;
+export declare const WrapperItem: React.FC<wrapperItemProps>;
 export {};

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

@@ -1,15 +1,16 @@
-import { GroupedEntities, RouteSettings, NavItemSettings, ConfigContentType, StructuredNavigationVariant, NavigationInput } from '../../../types';
+import { GroupedEntities, RouteSettings, ConfigContentType, StructuredNavigationVariant, NavigationInput, NestedNavItem } from '../../../types';
 export default function useApi(): {
     fetchAllContentTypes: () => Promise<any>;
     fetchAllEntities: (contentTypes?: ConfigContentType[]) => Promise<GroupedEntities[]>;
     getRelatedRoute: (relatedDocumentId: string) => Promise<any>;
-    createExternalRoute: (body: RouteSettings) => Promise<any>;
     getRoutes: () => Promise<any>;
     updateRoute: (body: RouteSettings, documentId: string) => Promise<any>;
-    createNavItem: (body: NavItemSettings) => Promise<any>;
-    updateNavItem: (documentId: string, body: NavItemSettings) => Promise<any>;
-    deleteNavItem: (documentId: string) => Promise<any>;
     getStructuredNavigation: (documentId: string, variant?: StructuredNavigationVariant) => Promise<any>;
+    getNavigation: ({ documentId, variant }?: {
+        documentId?: string;
+        variant?: StructuredNavigationVariant;
+    }) => Promise<any>;
     deleteNavigation: (documentId: string) => Promise<any>;
     updateNavigation: (documentId: string, body: NavigationInput) => Promise<any>;
+    updateNavigationItemStructure: (documentId: string, navigationItems: NestedNavItem[]) => Promise<any>;
 };

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

@@ -2,4 +2,6 @@ import { NestedNavigation } from '../../../types';
 export default function useNavigations(): {
     navigations: NestedNavigation[];
     fetchNavigations: () => Promise<void>;
+    loading: boolean;
+    fetchError: string | null;
 };

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

@@ -1,9 +1,9 @@
 import { PluginConfig } from '../../../types';
 type UsePluginConfigResponse = {
-    data: PluginConfig | null;
+    config: PluginConfig | null;
     loading: boolean;
-    error: string | null;
-    setConfig: (body: PluginConfig) => Promise<boolean | void>;
+    fetchError: string | null;
+    setConfig: (body: PluginConfig) => Promise<void>;
 };
 export default function usePluginConfig(): UsePluginConfigResponse;
 export {};

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { NestedNavigation } from '../../../../types';
+export default function PageWrapper({ navigations, loading, children }: {
+    navigations: NestedNavigation[];
+    loading?: boolean;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export default function PageWrapper({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/pages/Routes/TableHeader.d.ts

@@ -0,0 +1 @@
+export default function TableHeader(): import("react/jsx-runtime").JSX.Element;