@c-rex/components 0.3.0-build.38 → 0.3.0-build.40

package/src/results/filter-sidebar/__tests__/utils.test.ts

@@ -2,7 +2,11 @@ import { Tags } from "@c-rex/interfaces";
 import {
     clearData,
     memoizeFilteredTags,
+    pruneHierarchyFacetItemsForMerge,
+    resolveHierarchyFacetCountLabel,
+    resolveFacetTaxonomy,
     resolveLabelByLanguage,
+    shouldRenderFacetHierarchy,
     updateFilterParam,
     removeFilterItem,
 } from "../utils";
@@ -63,7 +67,7 @@ describe("filter-sidebar utils", () => {
         const result = clearData(tags, { uiLanguage: "en" });
 
         expect(result.informationSubjects).toHaveLength(2);
-        expect(result.informationSubjects?.map((item) => item.shortId)).toEqual(["subA", "subB"]);
+        expect(result.informationSubjects?.map((item) => item.shortId)).toEqual(["subB", "subA"]);
     });
 
     it("clearData excludes zero-hit entries when includeZeroHits is false", () => {
@@ -89,7 +93,8 @@ describe("filter-sidebar utils", () => {
             },
         });
 
-        expect(result.informationSubjects?.[0]).toMatchObject({
+        const overriddenItem = result.informationSubjects?.find((item) => item.shortId === "subA");
+        expect(overriddenItem).toMatchObject({
             label: "Overridden Label",
             groupLabel: "Subject Group",
             sectionLabel: "Process",
@@ -97,6 +102,168 @@ describe("filter-sidebar utils", () => {
         });
     });
 
+    it("clearData resolves facet presentation by id when shortId lookup is unavailable", () => {
+        const tags = createTags();
+        const result = clearData(tags, {
+            uiLanguage: "en",
+            labelOverrides: {
+                informationSubjects: {
+                    "https://example.org/subA": {
+                        label: "ID Matched Label",
+                        sectionLabel: "Process",
+                    },
+                },
+            },
+        });
+
+        expect(result.informationSubjects?.find((item) => item.shortId === "subA")).toMatchObject({
+            label: "ID Matched Label",
+            sectionLabel: "Process",
+            taxonomyId: "https://example.org/subA",
+        });
+    });
+
+    it("clearData keeps party role section labels from overrides instead of raw predicate labels", () => {
+        const tags = {
+            parties: {
+                labels: ["related to party"],
+                items: [
+                    {
+                        hits: 1,
+                        total: 1,
+                        labels: [{ language: "de", value: "Deutsche Gesetzliche Unfallversicherung e.V." }],
+                        shortId: "dguv",
+                        id: "https://example.org/party/dguv",
+                    } as unknown as Tags[string]["items"][number],
+                ],
+            },
+        } as unknown as Tags;
+
+        const result = clearData(tags, {
+            uiLanguage: "de-DE",
+            labelOverrides: {
+                parties: {
+                    dguv: {
+                        label: "Deutsche Gesetzliche Unfallversicherung e.V.",
+                        sectionLabel: "Traeger",
+                    },
+                },
+            },
+        });
+
+        expect(result.parties?.[0]).toMatchObject({
+            label: "Deutsche Gesetzliche Unfallversicherung e.V.",
+            sectionLabel: "Traeger",
+        });
+        expect(result.parties?.[0]?.sectionLabel).not.toBe("related to party");
+    });
+
+    it("resolves categories taxonomy through the cached informationSubjects hierarchy alias", () => {
+        const taxonomy = {
+            generatedAt: "2026-04-10T00:00:00.000Z",
+            roots: [],
+            nodesById: {
+                "category-root": {
+                    id: "category-root",
+                    shortId: "catRoot",
+                    label: "Root category",
+                    parentIds: [],
+                },
+            },
+        };
+
+        expect(resolveFacetTaxonomy("categories", { informationSubjects: taxonomy })).toBe(taxonomy);
+    });
+
+    it("clearData merges category tags into the cached category hierarchy alias", () => {
+        const tags = {
+            categories: {
+                labels: ["Categories"],
+                items: [
+                    {
+                        hits: 2,
+                        total: 2,
+                        labels: [{ language: "de", value: "Unterkategorie" }],
+                        shortId: "catChild",
+                        id: "category-child",
+                    } as unknown as Tags[string]["items"][number],
+                ],
+            },
+        } as unknown as Tags;
+
+        const result = clearData(tags, {
+            uiLanguage: "de-DE",
+            facetTaxonomies: {
+                informationSubjects: {
+                    generatedAt: "2026-04-10T00:00:00.000Z",
+                    roots: [],
+                    nodesById: {
+                        "category-root": {
+                            id: "category-root",
+                            shortId: "catRoot",
+                            label: "Wurzel",
+                            parentIds: [],
+                        },
+                        "category-child": {
+                            id: "category-child",
+                            shortId: "catChild",
+                            label: "Unterkategorie",
+                            parentIds: ["category-root"],
+                        },
+                    },
+                },
+            },
+        });
+
+        expect(result.categories?.[0]).toMatchObject({
+            shortId: "catChild",
+            label: "Unterkategorie",
+            taxonomyId: "category-child",
+            parentIds: ["category-root"],
+        });
+    });
+
+    it("clearData hides denied qualification groups from semantic facet output", () => {
+        const tags = {
+            qualifications: {
+                labels: ["Qualifications"],
+                items: [
+                    {
+                        hits: 4,
+                        total: 4,
+                        labels: [{ language: "en", value: "License A" }],
+                        shortId: "qualA",
+                        id: "qualification-a",
+                    } as unknown as Tags[string]["items"][number],
+                ],
+            },
+        } as unknown as Tags;
+
+        const result = clearData(tags, {
+            uiLanguage: "en-US",
+            facetTaxonomies: {
+                qualifications: {
+                    generatedAt: "2026-04-10T00:00:00.000Z",
+                    roots: [],
+                    nodesById: {
+                        "qualification-a": {
+                            id: "qualification-a",
+                            shortId: "qualA",
+                            label: "License A",
+                            parentIds: [],
+                            classRef: {
+                                id: "https://ids.c-crex.net/ns/iirds/ext#ContentLicense",
+                                label: "Content License",
+                            },
+                        },
+                    },
+                },
+            },
+        });
+
+        expect(result.qualifications).toBeUndefined();
+    });
+
     it("memoizeFilteredTags marks active filters and active package", () => {
         const tags = createTags();
         const result = memoizeFilteredTags(tags, "informationSubjects.shortId=subA", "pkgA", {
@@ -108,6 +275,136 @@ describe("filter-sidebar utils", () => {
         expect(result.packages?.find((item) => item.shortId === "pkgA")?.active).toBe(true);
     });
 
+    it("prunes zero-hit category siblings from the hierarchy merge seed when a category is selected", () => {
+        const items = [
+            {
+                shortId: "selected",
+                taxonomyId: "selected-id",
+                label: "Selected",
+                active: true,
+                hits: 211,
+                total: 211,
+                parentIds: ["parent-id"],
+            },
+            {
+                shortId: "sibling-zero",
+                taxonomyId: "sibling-zero-id",
+                label: "Sibling Zero",
+                active: false,
+                hits: 0,
+                total: 0,
+                parentIds: ["parent-id"],
+            },
+            {
+                shortId: "sibling-live",
+                taxonomyId: "sibling-live-id",
+                label: "Sibling Live",
+                active: false,
+                hits: 5,
+                total: 5,
+                parentIds: ["parent-id"],
+            },
+        ];
+
+        expect(pruneHierarchyFacetItemsForMerge("categories", [...items])).toEqual([items[0], items[2]]);
+    });
+
+    it("keeps zero-hit category items untouched when no category is selected", () => {
+        const items = [
+            {
+                shortId: "category-a",
+                taxonomyId: "category-a-id",
+                label: "Category A",
+                active: false,
+                hits: 0,
+                total: 0,
+                parentIds: [],
+            },
+            {
+                shortId: "category-b",
+                taxonomyId: "category-b-id",
+                label: "Category B",
+                active: false,
+                hits: 3,
+                total: 3,
+                parentIds: [],
+            },
+        ];
+
+        expect(pruneHierarchyFacetItemsForMerge("informationSubjects", items)).toEqual(items);
+    });
+
+    it("hides the misleading 0/0 count for structural category parents with visible children", () => {
+        const item = {
+            shortId: "category-parent",
+            taxonomyId: "category-parent-id",
+            label: "Category Parent",
+            active: false,
+            hits: 0,
+            total: 0,
+            parentIds: [],
+            isStructural: true,
+        };
+        const child = {
+            shortId: "category-child",
+            taxonomyId: "category-child-id",
+            label: "Category Child",
+            active: false,
+            hits: 4,
+            total: 4,
+            parentIds: ["category-parent-id"],
+        };
+
+        expect(resolveHierarchyFacetCountLabel(item, [child])).toBeUndefined();
+    });
+
+    it("keeps count labels for live hierarchy nodes", () => {
+        const item = {
+            shortId: "category-child",
+            taxonomyId: "category-child-id",
+            label: "Category Child",
+            active: false,
+            hits: 4,
+            total: 7,
+            parentIds: ["category-parent-id"],
+        };
+
+        expect(resolveHierarchyFacetCountLabel(item, [])).toBe("(4/7)");
+    });
+
+    it("renders taxonomy-backed facets as flat groups when no parent relations exist", () => {
+        const items = [
+            {
+                shortId: "subject-a",
+                taxonomyId: "subject-a-id",
+                label: "Abkuerzungsbeschreibung",
+                sectionLabel: "Formalitaet",
+                active: false,
+                hits: 3,
+                total: 3,
+                parentIds: [],
+            },
+        ];
+
+        expect(shouldRenderFacetHierarchy(items, { hasTaxonomy: true })).toBe(false);
+    });
+
+    it("renders taxonomy-backed facets as hierarchy when parent relations exist", () => {
+        const items = [
+            {
+                shortId: "category-child",
+                taxonomyId: "category-child-id",
+                label: "Unterkategorie",
+                active: false,
+                hits: 4,
+                total: 4,
+                parentIds: ["category-root-id"],
+            },
+        ];
+
+        expect(shouldRenderFacetHierarchy(items, { hasTaxonomy: true })).toBe(true);
+    });
+
     it("updateFilterParam and removeFilterItem keep query behavior stable", () => {
         expect(updateFilterParam("packages", { shortId: "pkgA", hits: 0, total: 0, label: "", active: false }, null)).toEqual({
             packages: "pkgA",
@@ -126,4 +423,3 @@ describe("filter-sidebar utils", () => {
         ).toEqual({ filter: "packages.shortId=pkgA" });
     });
 });
-

package/src/results/filter-sidebar/index.tsx

@@ -21,14 +21,19 @@ import { Button } from "@c-rex/ui/button";
 import { parseAsString, useQueryStates } from "nuqs";
 import {
     applyFacetPropertyVisibility,
-    FacetLabelOverrides,
+    FacetPresentation,
     FacetTaxonomies,
     memoizeFilteredTags,
+    pruneHierarchyFacetItemsForMerge,
     removeFilterItem,
+    resolveHierarchyFacetCountLabel,
+    resolveFacetTaxonomy,
     ResolvedFilterItem,
     resolveLabelByLanguage,
+    shouldRenderFacetHierarchy,
     updateFilterParam
 } from "./utils";
+import { buildTaxonomyHierarchy } from "../../taxonomy/hierarchy";
 import { FilterItem, Tags } from "@c-rex/interfaces";
 import type { TaxonomyResult } from "@c-rex/services/read-models";
 import { useSearchNavigationStore } from "../../stores/search-navigation-store";
@@ -39,7 +44,8 @@ import { useFilterSidebarState } from "./context";
 export interface FilterSidebarProps {
     tags?: Tags
     totalItemCount?: number
-    facetLabelOverrides?: FacetLabelOverrides
+    facetPresentation?: FacetPresentation
+    facetLabelOverrides?: FacetPresentation
     facetTaxonomies?: FacetTaxonomies
     includeZeroHits?: boolean
     includeProperties?: string[]
@@ -49,6 +55,7 @@ export interface FilterSidebarProps {
 const FilterSidebar: FC<FilterSidebarProps> = ({
     tags,
     totalItemCount,
+    facetPresentation,
     facetLabelOverrides,
     facetTaxonomies,
     includeZeroHits = true,
@@ -56,6 +63,7 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
     excludeProperties,
 }) => {
     const t = useTranslations();
+    const tagT = useTranslations("filter.tags");
     const locale = useLocale();
     const device = useBreakpoint();
     const isMobile = device !== null && (device === DEVICE_OPTIONS.MOBILE || device === DEVICE_OPTIONS.TABLET);
@@ -68,16 +76,17 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
         shallow: false,
     });
     const startSearchNavigation = useSearchNavigationStore((state) => state.start);
+    const effectiveFacetPresentation = facetPresentation || facetLabelOverrides;
 
     const filteredTags = useMemo(() => {
         const resolved = memoizeFilteredTags(tags, params.filter, params.packages, {
             uiLanguage: locale,
-            labelOverrides: facetLabelOverrides,
+            facetPresentation: effectiveFacetPresentation,
             includeZeroHits,
             facetTaxonomies,
         });
         return applyFacetPropertyVisibility(resolved, includeProperties, excludeProperties);
-    }, [tags, params.filter, params.packages, locale, facetLabelOverrides, facetTaxonomies, includeZeroHits, includeProperties, excludeProperties]);
+    }, [tags, params.filter, params.packages, locale, effectiveFacetPresentation, facetTaxonomies, includeZeroHits, includeProperties, excludeProperties]);
     const [expandedFacetItems, setExpandedFacetItems] = useState<Record<string, number>>({});
     const [expandedHierarchyNodes, setExpandedHierarchyNodes] = useState<Record<string, boolean>>({});
     const getVisibleCount = (key: string, total: number) => expandedFacetItems[key] || Math.min(total, 10);
@@ -106,14 +115,23 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
     }
 
     const resolvePropertyLabel = (propertyKey: string): string => {
-        const taxonomy = facetTaxonomies?.[propertyKey];
+        const taxonomy = resolveFacetTaxonomy(propertyKey, facetTaxonomies);
         const virtualRootLabel = taxonomy?.roots?.length === 1 && taxonomy.roots[0]?.isVirtualGroup
             ? taxonomy.roots[0].label
             : undefined;
-        if (virtualRootLabel) {
+        if (virtualRootLabel && virtualRootLabel !== "Ungrouped") {
             return virtualRootLabel;
         }
 
+        try {
+            const translated = tagT(propertyKey as Parameters<typeof tagT>[0]);
+            if (translated && translated !== propertyKey) {
+                return translated;
+            }
+        } catch {
+            // Fallback to API labels when no UI translation exists for the facet key.
+        }
+
         const rawLabels = (tags?.[propertyKey]?.labels as unknown[] | undefined) || [];
         const normalized = rawLabels
             .map((item) => {
@@ -135,100 +153,14 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
         return resolveLabelByLanguage(normalized, locale) || propertyKey;
     };
 
-    const isHierarchicalFacet = (items: ResolvedFilterItem[]): boolean => items.some((item) => (item.parentIds || []).length > 0);
-
     const buildHierarchy = (propertyKey: string, items: ResolvedFilterItem[]) => {
-        const taxonomy = facetTaxonomies?.[propertyKey] as TaxonomyResult | undefined;
+        const taxonomy = resolveFacetTaxonomy(propertyKey, facetTaxonomies) as TaxonomyResult | undefined;
         if (taxonomy) {
-            const selectedById = new Map<string, ResolvedFilterItem>();
-            const includedIds = new Set<string>();
-
-            items.forEach((item) => {
-                const itemId = item.taxonomyId || item.shortId;
-                if (!itemId) return;
-                selectedById.set(itemId, item);
-                includedIds.add(itemId);
-
-                const taxonomyNode = taxonomy.nodesById[itemId];
-                (taxonomyNode?.ancestorIds || []).forEach((ancestorId) => {
-                    if (taxonomy.nodesById[ancestorId]) includedIds.add(ancestorId);
-                });
-                (taxonomyNode?.parentIds || []).forEach((parentId) => {
-                    if (taxonomy.nodesById[parentId]) includedIds.add(parentId);
-                });
-            });
-
-            const byId = new Map<string, ResolvedFilterItem>();
-            const children = new Map<string, ResolvedFilterItem[]>();
-
-            Array.from(includedIds).forEach((nodeId) => {
-                const taxonomyNode = taxonomy.nodesById[nodeId];
-                if (!taxonomyNode) return;
-
-                const selected = selectedById.get(nodeId);
-
-                byId.set(nodeId, selected || {
-                    shortId: taxonomyNode.shortId || nodeId,
-                    label: taxonomyNode.label,
-                    active: false,
-                    hits: 0,
-                    total: 0,
-                    taxonomyId: taxonomyNode.id,
-                    parentIds: taxonomyNode.parentIds || [],
-                    isStructural: true,
-                });
-                children.set(nodeId, []);
-            });
-
-            Array.from(includedIds).forEach((nodeId) => {
-                const current = byId.get(nodeId);
-                const taxonomyNode = taxonomy.nodesById[nodeId];
-                if (!current || !taxonomyNode) return;
-
-                const parentKey = (taxonomyNode.parentIds || []).find((id) => byId.has(id));
-                if (parentKey) {
-                    children.get(parentKey)?.push(current);
-                }
-            });
-
-            const roots = Array.from(byId.values()).filter((node) => {
-                const nodeId = node.taxonomyId || node.shortId;
-                const taxonomyNode = nodeId ? taxonomy.nodesById[nodeId] : undefined;
-                return !(taxonomyNode?.parentIds || []).some((id) => byId.has(id));
-            });
-
-            const sortItems = (nodes: ResolvedFilterItem[]) => nodes.sort((a, b) => a.label.localeCompare(b.label));
-            sortItems(roots);
-            children.forEach((nodes) => sortItems(nodes));
-
-            return { roots, children };
+            const mergeSeedItems = pruneHierarchyFacetItemsForMerge(propertyKey, items);
+            return buildTaxonomyHierarchy(mergeSeedItems, taxonomy);
         }
 
-        const byId = new Map<string, ResolvedFilterItem>();
-        const children = new Map<string, ResolvedFilterItem[]>();
-        const roots: ResolvedFilterItem[] = [];
-
-        items.forEach((item) => {
-            const key = item.taxonomyId || item.shortId;
-            byId.set(key, item);
-            children.set(key, []);
-        });
-
-        items.forEach((item) => {
-            const parentKey = (item.parentIds || []).find((id) => byId.has(id));
-            if (!parentKey) {
-                roots.push(item);
-                return;
-            }
-
-            children.get(parentKey)?.push(item);
-        });
-
-        const sortItems = (nodes: ResolvedFilterItem[]) => nodes.sort((a, b) => a.label.localeCompare(b.label));
-        sortItems(roots);
-        children.forEach((nodes) => sortItems(nodes));
-
-        return { roots, children };
+        return buildTaxonomyHierarchy(items);
     };
 
     const renderFacetItems = (key: string, items: ResolvedFilterItem[]) => {
@@ -341,7 +273,13 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
         const itemKey = item.taxonomyId || item.shortId;
         const children = childrenMap.get(itemKey) || [];
         const hasChildren = children.length > 0;
-        const expanded = expandedHierarchyNodes[itemKey] !== false;
+        const countLabel = resolveHierarchyFacetCountLabel(item, children);
+        const expanded = hasChildren
+            ? depth === 0
+                ? expandedHierarchyNodes[itemKey] === true
+                : expandedHierarchyNodes[itemKey] !== false
+            : false;
+        const toggleSlotClass = "mt-1 inline-flex h-5 w-5 shrink-0 items-center justify-center";
 
         return (
             <SidebarMenuSubItem key={item.shortId}>
@@ -350,16 +288,14 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
                         {hasChildren ? (
                             <button
                                 type="button"
-                                className="mt-1 rounded p-0.5 hover:bg-sidebar-accent"
+                                className={`${toggleSlotClass} rounded hover:bg-sidebar-accent`}
                                 onClick={() => setExpandedHierarchyNodes((prev) => ({ ...prev, [itemKey]: !prev[itemKey] }))}
                                 aria-label={expanded ? "Collapse" : "Expand"}
                             >
                                 {expanded ? <ChevronDown className="h-4 w-4" /> : <ChevronRight className="h-4 w-4" />}
                             </button>
-                        ) : depth > 0 ? (
-                            <span className="inline-block w-5" />
                         ) : (
-                            <span className="inline-block w-0" />
+                            <span className={toggleSlotClass} aria-hidden="true" />
                         )}
                         <SidebarMenuSubButton
                             className={item.isStructural ? "!py-1.5 cursor-default text-muted-foreground" : "cursor-pointer !py-1.5"}
@@ -369,7 +305,7 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
                             onClick={item.isStructural ? undefined : () => onClickHandler(propertyKey, item)}
                             style={{ marginLeft: depth * 14 }}
                         >
-                            {item.label} ({item.hits}/{item.total})
+                            {item.label}{countLabel ? ` ${countLabel}` : ""}
                             {item.active && <Check className="ml-2" />}
                         </SidebarMenuSubButton>
                     </div>
@@ -387,10 +323,10 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
         <SidebarContent className="!gap-0 capitalize" suppressHydrationWarning>
             {Object.entries(filteredTags).map(([key, value]) => {
                 const items = value as ResolvedFilterItem[];
-                const hasTaxonomy = Boolean(facetTaxonomies?.[key]);
-                const hasSectionLabels = !hasTaxonomy && items.some((item) => Boolean(item.sectionLabel));
+                const hasTaxonomy = Boolean(resolveFacetTaxonomy(key, facetTaxonomies));
                 const propertyLabel = resolvePropertyLabel(key);
-                const hierarchicalFacet = hasTaxonomy || (!hasSectionLabels && isHierarchicalFacet(items));
+                const hasSectionLabels = items.some((item) => Boolean(item.sectionLabel));
+                const hierarchicalFacet = shouldRenderFacetHierarchy(items, { hasTaxonomy });
                 const hierarchy = hierarchicalFacet ? buildHierarchy(key, items) : undefined;
                 const visibleRootCount = getVisibleCount(key, hierarchy?.roots.length || 0);
                 const visibleRoots = hierarchy?.roots.slice(0, visibleRootCount) || [];
@@ -455,7 +391,7 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
                                 <div className="sr-only">{propertyLabel}</div>
                                 {Object.entries(
                                     items.reduce<Record<string, ResolvedFilterItem[]>>((acc, item) => {
-                                        const sectionLabel = item.sectionLabel || "Other";
+                                        const sectionLabel = item.sectionLabel || propertyLabel;
                                         if (!acc[sectionLabel]) acc[sectionLabel] = [];
                                         acc[sectionLabel].push(item);
                                         return acc;
@@ -464,6 +400,13 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
                                     .sort(([a], [b]) => a.localeCompare(b))
                                     .map(([sectionLabel, sectionItems]) => {
                                         const hasNestedGroups = sectionItems.some((item) => Boolean(item.groupLabel));
+                                        const sectionHasTaxonomy = Boolean(resolveFacetTaxonomy(key, facetTaxonomies));
+                                        const sectionHierarchy = sectionHasTaxonomy ? buildHierarchy(key, sectionItems) : undefined;
+                                        const shouldRenderSectionHierarchy = sectionHasTaxonomy && (sectionHierarchy?.roots.length || 0) > 0;
+                                        const visibleSectionRootCount = getVisibleCount(`${key}:${sectionLabel}`, sectionHierarchy?.roots.length || 0);
+                                        const visibleSectionRoots = sectionHierarchy?.roots.slice(0, visibleSectionRootCount) || [];
+                                        const hasMoreSectionRoots = (sectionHierarchy?.roots.length || 0) > visibleSectionRootCount;
+                                        const canShowLessSectionRoots = visibleSectionRootCount > getInitialVisibleCount(sectionHierarchy?.roots.length || 0);
                                         return (
                                             <Collapsible
                                                 defaultOpen
@@ -484,13 +427,39 @@ const FilterSidebar: FC<FilterSidebarProps> = ({
                                                         <SidebarGroupContent>
                                                             <SidebarMenu className="!gap-0.5">
                                                                 <SidebarMenuSub className="!ml-2 !pl-1.5 !py-0 !gap-0.5">
-                                                                    {!hasNestedGroups &&
+                                                                    {shouldRenderSectionHierarchy && !hasNestedGroups &&
+                                                                        visibleSectionRoots.map((item) => renderHierarchyNode(key, item, sectionHierarchy!.children, 0))}
+                                                                    {shouldRenderSectionHierarchy && !hasNestedGroups && (hasMoreSectionRoots || canShowLessSectionRoots) && (
+                                                                        <SidebarMenuSubItem>
+                                                                            <div className="flex items-center gap-3 px-2">
+                                                                                {hasMoreSectionRoots && (
+                                                                                    <Button
+                                                                                        variant="ghost"
+                                                                                        className="justify-start px-0 text-sm"
+                                                                                        onClick={() => showMore(`${key}:${sectionLabel}`, sectionHierarchy?.roots.length || 0)}
+                                                                                    >
+                                                                                        {t("more")}
+                                                                                    </Button>
+                                                                                )}
+                                                                                {canShowLessSectionRoots && (
+                                                                                    <Button
+                                                                                        variant="ghost"
+                                                                                        className="justify-start px-0 text-sm"
+                                                                                        onClick={() => showLess(`${key}:${sectionLabel}`, sectionHierarchy?.roots.length || 0)}
+                                                                                    >
+                                                                                        {t("less")}
+                                                                                    </Button>
+                                                                                )}
+                                                                            </div>
+                                                                        </SidebarMenuSubItem>
+                                                                    )}
+                                                                    {!shouldRenderSectionHierarchy && !hasNestedGroups &&
                                                                         renderGroupedItems(key, `${key}:${sectionLabel}`, sectionItems)}
 
                                                                     {hasNestedGroups &&
                                                                         Object.entries(
                                                                             sectionItems.reduce<Record<string, ResolvedFilterItem[]>>((acc, item) => {
-                                                                                const groupLabel = item.groupLabel || "Other";
+                                                                                const groupLabel = item.groupLabel || sectionLabel;
                                                                                 if (!acc[groupLabel]) acc[groupLabel] = [];
                                                                                 acc[groupLabel].push(item);
                                                                                 return acc;