@mattisvensson/strapi-plugin-webatlas 0.3.1 → 0.4.2

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

@@ -0,0 +1,4 @@
+import type { Route } from '../../../../types';
+export default function TableRow({ route }: {
+    route: Route;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { ContentType, ConfigContentType } from '../../../../types';
+export default function ContentTypeAccordion({ contentType, contentTypeSettings, dispatch }: {
+    contentType: ContentType | undefined;
+    contentTypeSettings: ConfigContentType;
+    dispatch: React.Dispatch<any>;
+}): import("react/jsx-runtime").JSX.Element | null;

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

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

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

@@ -0,0 +1,25 @@
+import type { NestedNavItem, Entity, GroupedEntities } from '../../../types';
+type CreateTempNavItemObjectParams = {
+    parentId: string | undefined;
+    entityRoute: {
+        documentId: string;
+    } | null;
+    selectedNavigation: {
+        documentId: string;
+    } | null;
+    navItemState: {
+        active?: boolean;
+        isOverride?: boolean;
+        title?: string;
+    };
+    selectedEntity: Entity | undefined | null;
+    selectedContentType: GroupedEntities | undefined | null;
+    path?: {
+        value: string;
+        uidPath: string;
+    };
+    wrapper?: boolean;
+    internal?: boolean;
+};
+export default function createTempNavItemObject({ parentId, entityRoute, selectedNavigation, navItemState, selectedEntity, selectedContentType, path, wrapper, internal, }: CreateTempNavItemObjectParams): NestedNavItem;
+export {};

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

@@ -4,4 +4,5 @@ import { isNestedNavigation, isNestedNavItem } from "./typeChecks";
 import getTranslation from "./getTranslation";
 import countChildren from "./countChildren";
 import getRouteType from "./getRouteType";
-export { debounce, duplicateCheck, isNestedNavigation, isNestedNavItem, getTranslation, countChildren, getRouteType };
+import createTempNavItemObject from "./createTempNavItemObject";
+export { debounce, duplicateCheck, isNestedNavigation, isNestedNavItem, getTranslation, countChildren, getRouteType, createTempNavItemObject };

package/dist/server/index.js

@@ -20,7 +20,7 @@ function transformToUrl(input) {
   input = input.replace(/-+/g, "-");
   return input;
 }
-const version = "0.3.1";
+const version = "0.4.1";
 const keywords = [];
 const type = "commonjs";
 const exports$1 = {
@@ -1128,16 +1128,6 @@ const admin$2 = () => ({
       return ctx.throw(500, e);
     }
   },
-  async createExternalRoute(ctx) {
-    try {
-      const { data } = ctx.request.body;
-      return await getAdminService().createExternalRoute(
-        data
-      );
-    } catch (e) {
-      return ctx.throw(500, e);
-    }
-  },
   async getRelatedRoute(ctx) {
     try {
       const { documentId } = ctx.query;
@@ -1173,38 +1163,20 @@ const admin$2 = () => ({
       return ctx.throw(500, e);
     }
   },
-  async deleteNavigation(ctx) {
+  async updateNavigationItemStructure(ctx) {
     try {
-      const { documentId } = ctx.query;
-      if (!documentId) return ctx.throw(400, "Navigation documentId is required");
-      return await getAdminService().deleteNavigation(documentId);
+      const { navigationId, navigationItems } = ctx.request.body;
+      if (!navigationId || !navigationItems) return ctx.throw(400, "NavigationId and Navigation items are required");
+      return await getAdminService().updateNavigationItemStructure(navigationId, navigationItems);
     } catch (e) {
       return ctx.throw(500, e);
     }
   },
-  async createNavItem(ctx) {
-    try {
-      const { data } = ctx.request.body;
-      return await getAdminService().createNavItem(data);
-    } catch (e) {
-      return ctx.throw(500, e);
-    }
-  },
-  async updateNavItem(ctx) {
-    try {
-      const { documentId } = ctx.query;
-      if (!documentId) return ctx.throw(400, "NavItem documentId is required");
-      const { data } = ctx.request.body;
-      return await getAdminService().updateNavItem(documentId, data);
-    } catch (e) {
-      return ctx.throw(500, e);
-    }
-  },
-  async deleteNavItem(ctx) {
+  async deleteNavigation(ctx) {
     try {
       const { documentId } = ctx.query;
-      if (!documentId) return ctx.throw(400, "NavItem documentId is required");
-      return await getAdminService().deleteNavItem(documentId);
+      if (!documentId) return ctx.throw(400, "Navigation documentId is required");
+      return await getAdminService().deleteNavigation(documentId);
     } catch (e) {
       return ctx.throw(500, e);
     }
@@ -1288,15 +1260,6 @@ const admin$1 = {
         auth: false
       }
     },
-    {
-      method: "POST",
-      path: "/route/external",
-      handler: "admin.createExternalRoute",
-      config: {
-        policies: [],
-        auth: false
-      }
-    },
     {
       method: "GET",
       path: "/route/related",
@@ -1333,28 +1296,10 @@ const admin$1 = {
         auth: false
       }
     },
-    {
-      method: "DELETE",
-      path: "/navigation",
-      handler: "admin.deleteNavigation",
-      config: {
-        policies: [],
-        auth: false
-      }
-    },
-    {
-      method: "POST",
-      path: "/navitem",
-      handler: "admin.createNavItem",
-      config: {
-        policies: [],
-        auth: false
-      }
-    },
     {
       method: "PUT",
-      path: "/navitem",
-      handler: "admin.updateNavItem",
+      path: "/navigation/items",
+      handler: "admin.updateNavigationItemStructure",
       config: {
         policies: [],
         auth: false
@@ -1362,8 +1307,8 @@ const admin$1 = {
     },
     {
       method: "DELETE",
-      path: "/navitem",
-      handler: "admin.deleteNavItem",
+      path: "/navigation",
+      handler: "admin.deleteNavigation",
       config: {
         policies: [],
         auth: false
@@ -1416,49 +1361,54 @@ function buildStructuredNavigation(navigation2, variant = "nested") {
   const rootItems = [];
   if (!navigation2.items || navigation2.items?.length === 0) return navigation2;
   navigation2.items.forEach((item) => {
-    itemsById.set(item.id, { ...item, items: [] });
+    itemsById.set(item.documentId, { ...item, items: [] });
   });
-  if (variant === "nested") {
-    navigation2.items.forEach((item) => {
-      const newItem = itemsById.get(item.id);
-      if (!newItem) return null;
-      if (item.parent) {
-        const parentItem = itemsById.get(item.parent.id);
-        parentItem && parentItem.items.push(newItem);
-      } else {
-        rootItems.push(newItem);
-      }
-    });
-    sortItems(rootItems);
-    return { ...navigation2, items: rootItems };
-  } else if (variant === "flat") {
-    let itemsToProcess = [...navigation2.items];
-    let itemsProcessed = /* @__PURE__ */ new Set();
-    while (itemsToProcess.length > 0) {
-      const remainingItems = [];
-      itemsToProcess.forEach((item) => {
-        const newItem = itemsById.get(item.id);
+  try {
+    if (variant === "nested") {
+      navigation2.items.forEach((item) => {
+        const newItem = itemsById.get(item.documentId);
         if (!newItem) return null;
         if (item.parent) {
-          const parentItem = itemsById.get(item.parent.id);
-          if (!parentItem || !itemsProcessed.has(item.parent.id)) {
-            remainingItems.push(item);
-            return;
-          }
-          newItem.depth = parentItem.depth !== void 0 ? parentItem.depth + 1 : 0;
-          parentItem.items.push(newItem);
+          const parentItem = itemsById.get(item.parent.documentId);
+          parentItem && parentItem.items.push(newItem);
         } else {
-          newItem.depth = 0;
           rootItems.push(newItem);
         }
-        itemsById.set(item.id, newItem);
-        itemsProcessed.add(item.id);
       });
-      itemsToProcess = remainingItems;
+      sortItems(rootItems);
+      return { ...navigation2, items: rootItems };
+    } else if (variant === "flat") {
+      let itemsToProcess = [...navigation2.items];
+      let itemsProcessed = /* @__PURE__ */ new Set();
+      while (itemsToProcess.length > 0) {
+        const remainingItems = [];
+        itemsToProcess.forEach((item) => {
+          const newItem = itemsById.get(item.documentId);
+          if (!newItem) return null;
+          if (item.parent) {
+            const parentItem = itemsById.get(item.parent.documentId);
+            if (!parentItem || !itemsProcessed.has(item.parent.documentId)) {
+              remainingItems.push(item);
+              return;
+            }
+            newItem.depth = parentItem.depth !== void 0 ? parentItem.depth + 1 : 0;
+            parentItem.items.push(newItem);
+          } else {
+            newItem.depth = 0;
+            rootItems.push(newItem);
+          }
+          itemsById.set(item.documentId, newItem);
+          itemsProcessed.add(item.documentId);
+        });
+        itemsToProcess = remainingItems;
+      }
+      const sortedItems = sortItems(rootItems);
+      const flattenedItems = flattenItems(sortedItems);
+      return { ...navigation2, items: flattenedItems };
     }
-    const sortedItems = sortItems(rootItems);
-    const flattenedItems = flattenItems(sortedItems);
-    return { ...navigation2, items: flattenedItems };
+  } catch (error) {
+    console.error(error);
+    throw error;
   }
 }
 const flattenItems = (items, result = []) => {
@@ -5524,6 +5474,80 @@ function removeWaFields(obj) {
   delete obj["webatlas_override"];
   return obj;
 }
+async function createNavItem(data) {
+  try {
+    if (!data.route || !data.navigation) return null;
+    const parent = data.parent ? await strapi.documents(waNavItem).findOne({
+      documentId: data.parent,
+      populate: ["route"]
+    }) : null;
+    const route2 = data.route ? await strapi.documents(waRoute).findOne({
+      documentId: data.route
+    }) : null;
+    let fullPath = route2.slug;
+    if (route2.internal && !route2.isOverride && parent?.route.internal) fullPath = getFullPath(parent?.route?.fullPath, route2.slug);
+    await strapi.documents(waRoute).update({
+      documentId: data.route,
+      data: {
+        fullPath
+      }
+    });
+    const entity = await strapi.documents(waNavItem).create({
+      data: {
+        navigation: data.navigation,
+        route: data.route || null,
+        parent: data.parent || null
+      }
+    });
+    return entity;
+  } catch (e) {
+    console.log(e);
+  }
+}
+async function updateNavItem(documentId, data) {
+  try {
+    const updateData = {};
+    if (data.navigation !== void 0 && data.navigation !== null && data.navigation !== "") updateData.navigation = data.navigation;
+    if (data.route !== void 0 && data.route !== null && data.route !== "") updateData.route = data.route;
+    if (data.parent !== void 0) updateData.parent = data.parent;
+    if (data.order !== void 0 && typeof data.order === "number") updateData.order = data.order;
+    return await strapi.documents(waNavItem).update({
+      documentId,
+      data: updateData
+    });
+  } catch (e) {
+    console.log(e);
+  }
+}
+async function deleteNavItem(documentId) {
+  try {
+    await strapi.documents(waNavItem).delete({
+      documentId
+    });
+    return true;
+  } catch (e) {
+    console.log(e);
+  }
+}
+async function createExternalRoute(data) {
+  try {
+    return await strapi.documents(waRoute).create({
+      data: {
+        title: data.title,
+        slug: data.fullPath,
+        fullPath: data.fullPath,
+        relatedContentType: "",
+        relatedId: 0,
+        relatedDocumentId: "",
+        uidPath: "",
+        internal: false,
+        wrapper: data.wrapper
+      }
+    });
+  } catch (e) {
+    console.log(e);
+  }
+}
 const admin = ({ strapi: strapi2 }) => ({
   async updateConfig(newConfig) {
     if (!newConfig || !newConfig.selectedContentTypes) return;
@@ -5587,25 +5611,6 @@ const admin = ({ strapi: strapi2 }) => ({
       console.log(e);
     }
   },
-  async createExternalRoute(data) {
-    try {
-      return await strapi2.documents(waRoute).create({
-        data: {
-          title: data.title,
-          slug: data.fullPath,
-          fullPath: data.fullPath,
-          relatedContentType: "",
-          relatedId: 0,
-          relatedDocumentId: "",
-          uidPath: "",
-          internal: false,
-          wrapper: data.wrapper
-        }
-      });
-    } catch (e) {
-      console.log(e);
-    }
-  },
   async getRelatedRoute(documentId) {
     try {
       return await strapi2.db?.query(waRoute).findOne({
@@ -5625,14 +5630,17 @@ const admin = ({ strapi: strapi2 }) => ({
           documentId,
           populate: ["items", "items.route", "items.parent"]
         });
+        if (!navigation2) throw new Error("Navigation not found");
+        if (variant)
+          navigation2 = buildStructuredNavigation(navigation2, variant);
       } else {
         navigation2 = await strapi2.documents(waNavigation).findMany({
           populate: ["items", "items.route", "items.parent"]
         });
-      }
-      if (!navigation2) throw new Error("Navigation not found");
-      if (variant) {
-        navigation2 = buildStructuredNavigation(navigation2, variant);
+        if (!navigation2) throw new Error("Navigation not found");
+        if (variant) {
+          navigation2 = navigation2.map((nav) => buildStructuredNavigation(nav, variant));
+        }
       }
       return navigation2;
     } catch (e) {
@@ -5686,60 +5694,102 @@ const admin = ({ strapi: strapi2 }) => ({
       console.log(e);
     }
   },
-  async createNavItem(data) {
-    try {
-      if (!data.route || !data.navigation) return false;
-      const parent = data.parent ? await strapi2.documents(waNavItem).findOne({
-        documentId: data.parent,
-        populate: ["route"]
-      }) : null;
-      const route2 = data.route ? await strapi2.documents(waRoute).findOne({
-        documentId: data.route
-      }) : null;
-      let fullPath = route2.slug;
-      if (route2.internal && !route2.isOverride && parent?.route.internal) fullPath = getFullPath(parent?.route?.fullPath, route2.slug);
-      await strapi2.documents(waRoute).update({
-        documentId: data.route,
-        data: {
-          fullPath
+  async updateNavigationItemStructure(navigationId, navigationItems) {
+    if (!navigationId || !navigationItems) return;
+    let error = false;
+    let groupIndices = [];
+    let parentIds = [];
+    const newNavItemsMap = /* @__PURE__ */ new Map();
+    for (const [index2, item] of navigationItems.entries()) {
+      if (item.deleted) {
+        try {
+          item.documentId && await deleteNavItem(item.documentId);
+        } catch (error2) {
+          error2 = true;
+          console.error("Error deleting navigation item ", error2);
         }
-      });
-      const entity = await strapi2.documents(waNavItem).create({
-        data: {
-          navigation: data.navigation,
-          route: data.route || null,
-          parent: data.parent || null
+        continue;
+      }
+      if (item.parent?.documentId.startsWith("temp-")) {
+        const newItem = newNavItemsMap.get(item.parent.documentId);
+        item.isNew.parent = newItem?.documentId;
+      }
+      if (item.update && !item.isNew) {
+        try {
+          await this.updateRoute(item.route.documentId, {
+            title: item.update.title || item.route.title,
+            slug: item.update.slug || item.route.slug,
+            fullPath: item.update.fullPath || item.route.fullPath,
+            isOverride: item.update.isOverride !== void 0 ? item.update.isOverride : item.route.isOverride
+          });
+        } catch (error2) {
+          error2 = true;
+          console.error("Error updating route ", error2);
         }
-      });
-      return entity;
-    } catch (e) {
-      console.log(e);
-    }
-  },
-  async updateNavItem(documentId, data) {
-    try {
-      return await strapi2.documents(waNavItem).update({
-        documentId,
-        data: {
-          navigation: data.navigation || null,
-          route: data.route || null,
-          parent: data.parent || null,
-          order: data.order || 0
+      }
+      const previousItem = navigationItems[index2 - 1];
+      if (typeof item.depth !== "number") {
+        return;
+      }
+      if (item.depth === 0) {
+        if (groupIndices[0] !== void 0) {
+          groupIndices[0] = groupIndices[0] + 1;
+        } else {
+          groupIndices[0] = 0;
         }
-      });
-    } catch (e) {
-      console.log(e);
-    }
-  },
-  async deleteNavItem(documentId) {
-    try {
-      await strapi2.documents(waNavItem).delete({
-        documentId
-      });
-      return true;
-    } catch (e) {
-      console.log(e);
+        parentIds = [];
+      } else if (typeof previousItem.depth === "number" && item.depth === previousItem.depth + 1) {
+        parentIds.push(previousItem.documentId);
+        groupIndices[item.depth] = 0;
+      } else if (typeof previousItem.depth === "number" && item.depth <= previousItem.depth) {
+        const diff = previousItem.depth - item.depth;
+        for (let i = 0; i < diff; i++) {
+          parentIds.pop();
+          groupIndices.pop();
+        }
+        groupIndices[item.depth] = (groupIndices[item.depth] || 0) + 1;
+      }
+      try {
+        if (item.isNew) {
+          if (item.isNew.route) {
+            await createNavItem({
+              route: item.isNew.route,
+              parent: item.isNew.parent,
+              navigation: item.isNew.navigation,
+              order: groupIndices[item.depth]
+            });
+          } else {
+            const newRoute = await createExternalRoute({
+              title: item.route.title,
+              slug: item.route.slug,
+              fullPath: item.route.fullPath,
+              wrapper: item.route.wrapper,
+              internal: item.route.internal
+              // isOverride: item.route.isOverride,
+              // active: item.route.active,
+            });
+            const newNavItem = await createNavItem({
+              route: newRoute.documentId,
+              navigation: navigationId,
+              parent: item.isNew.parent,
+              order: groupIndices[item.depth]
+            });
+            if (newNavItem) newNavItemsMap.set(item.documentId, newNavItem);
+          }
+        } else {
+          await updateNavItem(item.documentId, {
+            navigation: void 0,
+            route: void 0,
+            order: groupIndices[item.depth] || 0,
+            parent: parentIds.at(-1) || null
+          });
+        }
+      } catch (errorMsg) {
+        error = true;
+        console.error("Error updating navigation item ", errorMsg);
+      }
     }
+    return !error;
   },
   async checkUniquePath(initialPath, targetRouteDocumentId = null) {
     try {
@@ -5855,4 +5905,3 @@ const index = {
   middlewares
 };
 module.exports = index;
-//# sourceMappingURL=index.js.map