Minor simplifcations

Author: dan-lee

packages/zudoku/src/lib/plugins/openapi/util/buildTagCategories.test.ts

@@ -142,32 +142,14 @@ describe("buildTagCategories", () => {
     expect(contacts?.type).toBe("category");
 
     if (contacts?.type === "category") {
-      // Operations from the "Contacts" tag come first, then "Notes" as a child
+      // Operations from the "Contacts" tag come first, then "Notes" as a child.
+      // "Contacts" must not appear as a nested child of itself.
       expect(contacts.items).toHaveLength(2);
       expect(contacts.items[0]?.label).toBe("Contacts op");
       expect(contacts.items[1]?.label).toBe("Notes");
     }
   });
 
-  it("excludes self-reference when tagGroup includes its own name in tags", () => {
-    const tagCategories = new Map<string, NavigationItem>([
-      ["Contacts", makeTag("Contacts")],
-      ["Notes", makeTag("Notes")],
-    ]);
-
-    const result = buildTagCategories({
-      tagCategories,
-      tagGroups: [{ name: "Contacts", tags: ["Contacts", "Notes"] }],
-    });
-
-    const contacts = result[0];
-    if (contacts?.type === "category") {
-      // "Contacts" tag should NOT appear as a nested child of itself
-      const childLabels = contacts.items.map((i) => i.label);
-      expect(childLabels).not.toContain("Contacts");
-    }
-  });
-
   it("excludes merged tag from ungrouped results", () => {
     const tagCategories = new Map<string, NavigationItem>([
       ["Contacts", makeTag("Contacts")],

packages/zudoku/src/lib/plugins/openapi/util/buildTagCategories.ts

@@ -8,41 +8,44 @@ type BuildTagCategoriesOptions = {
   expandAllTags?: boolean;
 };
 
+// Merges tags and x-tagGroups with the same name into a single sidebar
+// category (mimics OpenAPI 3.2.0 "Enhanced tags" behaviour).
 export const buildTagCategories = ({
   tagCategories,
   tagGroups,
   expandAllTags,
 }: BuildTagCategoriesOptions): NavigationItem[] => {
   const consumedTags = new Set<string>();
 
-  const groupedCategories: NavigationItem[] = tagGroups.flatMap((group) => {
+  const groupedCategories = tagGroups.flatMap<NavigationItem>((group) => {
+    // Use a same-named tag as base so its operations appear first
     const matchingTag = tagCategories.get(group.name);
     const base = matchingTag?.type === "category" ? matchingTag : undefined;
 
     if (base) consumedTags.add(group.name);
 
-    const childTags = group.tags
-      .filter((name) => name !== group.name && tagCategories.has(name))
-      .flatMap((name) => {
-        consumedTags.add(name);
-        const tag = tagCategories.get(name);
-        return tag ? [tag] : [];
-      });
+    // Exclude group's own name to avoid nesting a tag inside itself
+    const childTags = group.tags.flatMap((name) => {
+      if (name === group.name) return [];
+      const tag = tagCategories.get(name);
+      if (!tag) return [];
+      consumedTags.add(name);
+      return tag;
+    });
 
     if (!base && childTags.length === 0) return [];
 
-    return [
-      {
-        ...base,
-        type: "category" as const,
-        label: base?.label ?? group.name,
-        items: [...(base?.items ?? []), ...childTags],
-        collapsible: base?.collapsible ?? true,
-        collapsed: base?.collapsed ?? !expandAllTags,
-      },
-    ];
+    return {
+      ...base,
+      type: "category",
+      label: base?.label ?? group.name,
+      items: [...(base?.items ?? []), ...childTags],
+      collapsible: base?.collapsible ?? true,
+      collapsed: base?.collapsed ?? !expandAllTags,
+    };
   });
 
+  // Tags not claimed by any group appear as standalone entries
   const ungroupedCategories = Array.from(tagCategories.entries())
     .filter(([name]) => !consumedTags.has(name))
     .map(([, cat]) => cat);