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

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;

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

@@ -1,14 +1,25 @@
 import { FilterItem, Tags } from "@c-rex/interfaces";
 import { EN_LANG } from "@c-rex/constants";
-import type { TaxonomyResult } from "@c-rex/services/read-models";
-
-export type FacetLabelOverride = {
+import {
+    type InformationUnitPropertyKey,
+    type TaxonomyResult,
+} from "@c-rex/services/read-models";
+import {
+    isMetadataGroupDenied,
+    isMetadataPropertyRuntimeSuppressed,
+} from "@c-rex/services/metadata-visibility-policy";
+
+export type FacetPresentationItem = {
     label: string;
     groupLabel?: string;
     sectionLabel?: string;
+    hidden?: boolean;
 };
 
-export type FacetLabelOverrides = Partial<Record<string, Record<string, FacetLabelOverride>>>;
+export type FacetPresentation = Partial<Record<string, Record<string, FacetPresentationItem>>>;
+
+export type FacetLabelOverride = FacetPresentationItem;
+export type FacetLabelOverrides = FacetPresentation;
 
 export type ResolvedFilterItem = FilterItem & {
     groupLabel?: string;
@@ -20,6 +31,20 @@ export type ResolvedFilterItem = FilterItem & {
 
 export type FacetTaxonomies = Partial<Record<string, TaxonomyResult>>;
 
+export const resolveFacetTaxonomy = (
+    facetKey: string,
+    facetTaxonomies?: FacetTaxonomies
+): TaxonomyResult | undefined => {
+    if (!facetTaxonomies) return undefined;
+    if (facetTaxonomies[facetKey]) return facetTaxonomies[facetKey];
+
+    if (facetKey === "categories") {
+        return facetTaxonomies.informationSubjects;
+    }
+
+    return undefined;
+};
+
 export const updateFilterParam = (key: string, item: FilterItem, filter: string | null): Record<string, string | null> => {
 
     if (key === "packages") {
@@ -93,24 +118,28 @@ export const clearData = (
     tags: Tags,
     options?: {
         uiLanguage?: string;
-        labelOverrides?: FacetLabelOverrides;
+        facetPresentation?: FacetPresentation;
+        labelOverrides?: FacetPresentation;
         includeZeroHits?: boolean;
         facetTaxonomies?: FacetTaxonomies;
     }
 ): Record<string, ResolvedFilterItem[]> => {
     const includeZeroHits = options?.includeZeroHits ?? true;
+    const facetPresentation = options?.facetPresentation || options?.labelOverrides;
     const filteredTags: Record<string, ResolvedFilterItem[]> = {}
     const taxonomyNodesByFacet = Object.entries(options?.facetTaxonomies || {}).reduce<Record<string, Map<string, {
         id: string;
         shortId?: string;
         label: string;
         parentIds: string[];
+        classId?: string;
     }>>>((acc, [facetKey, taxonomy]) => {
         const nodes = new Map<string, {
             id: string;
             shortId?: string;
             label: string;
             parentIds: string[];
+            classId?: string;
         }>();
 
         Object.values(taxonomy?.nodesById || {}).forEach((node) => {
@@ -119,6 +148,7 @@ export const clearData = (
                 shortId: node.shortId,
                 label: node.label,
                 parentIds: node.parentIds || [],
+                classId: node.classRef?.id,
             };
             nodes.set(node.id, normalized);
             if (node.shortId) {
@@ -130,7 +160,14 @@ export const clearData = (
         return acc;
     }, {});
 
+    if (!taxonomyNodesByFacet.categories && taxonomyNodesByFacet.informationSubjects) {
+        taxonomyNodesByFacet.categories = taxonomyNodesByFacet.informationSubjects;
+    }
+
     for (const [key, value] of Object.entries(tags)) {
+        if (isMetadataPropertyRuntimeSuppressed(key as InformationUnitPropertyKey)) {
+            continue;
+        }
         if (!value || !value.items || value.items.length === 0) {
             continue;
         }
@@ -139,13 +176,16 @@ export const clearData = (
             if (item?.shortId === undefined) return null
             if (!includeZeroHits && Number(item.hits) === 0) return null
 
-            const override = options?.labelOverrides?.[key]?.[item.shortId];
             const runtimeItem = item as typeof item & {
                 id?: string;
                 parents?: Array<{ id?: string; shortId?: string }>;
             };
+            const presentationItem = facetPresentation?.[key]?.[item.shortId]
+                || (runtimeItem.id ? facetPresentation?.[key]?.[runtimeItem.id] : undefined);
             const taxonomyNode = taxonomyNodesByFacet[key]?.get(runtimeItem.id || item.shortId);
-            const label = override?.label || taxonomyNode?.label || resolveLabelByLanguage(item.labels || [], options?.uiLanguage);
+            if (presentationItem?.hidden) return null;
+            if (isMetadataGroupDenied(key as InformationUnitPropertyKey, { classId: taxonomyNode?.classId })) return null;
+            const label = presentationItem?.label || taxonomyNode?.label || resolveLabelByLanguage(item.labels || [], options?.uiLanguage);
             if (!label) return null;
             const taxonomyId = taxonomyNode?.id || runtimeItem.id;
             const parentIds = taxonomyNode?.parentIds || (runtimeItem.parents || [])
@@ -158,8 +198,8 @@ export const clearData = (
                 label,
                 active: false,
                 shortId: item.shortId,
-                groupLabel: override?.groupLabel,
-                sectionLabel: override?.sectionLabel,
+                groupLabel: presentationItem?.groupLabel,
+                sectionLabel: presentationItem?.sectionLabel,
                 taxonomyId,
                 parentIds,
             }
@@ -182,7 +222,8 @@ export const memoizeFilteredTags = (
     packages: string | null,
     options?: {
         uiLanguage?: string;
-        labelOverrides?: FacetLabelOverrides;
+        facetPresentation?: FacetPresentation;
+        labelOverrides?: FacetPresentation;
         includeZeroHits?: boolean;
         facetTaxonomies?: FacetTaxonomies;
     }
@@ -247,9 +288,49 @@ export const applyFacetPropertyVisibility = (
     ]);
 
     return Object.entries(tags).reduce<Record<string, ResolvedFilterItem[]>>((acc, [key, value]) => {
+        if (isMetadataPropertyRuntimeSuppressed(key as InformationUnitPropertyKey)) return acc;
         if (includeSet.size > 0 && !includeSet.has(key)) return acc;
         if (excludeSet.has(key)) return acc;
         acc[key] = value;
         return acc;
     }, {});
 }
+
+export const pruneHierarchyFacetItemsForMerge = (
+    facetKey: string,
+    items: ResolvedFilterItem[]
+): ResolvedFilterItem[] => {
+    const isCategoryFacet = facetKey === "categories" || facetKey === "informationSubjects";
+    if (!isCategoryFacet) return items;
+
+    const hasActiveSelection = items.some((item) => item.active);
+    if (!hasActiveSelection) return items;
+
+    return items.filter((item) => item.active || Number(item.hits) > 0 || Number(item.total) > 0);
+};
+
+export const resolveHierarchyFacetCountLabel = (
+    item: ResolvedFilterItem,
+    childItems: ResolvedFilterItem[]
+): string | undefined => {
+    if (item.isStructural && childItems.length > 0) {
+        return undefined;
+    }
+
+    return `(${item.hits}/${item.total})`;
+};
+
+export const shouldRenderFacetHierarchy = (
+    items: ResolvedFilterItem[],
+    options?: { hasTaxonomy?: boolean }
+): boolean => {
+    const hasTaxonomy = options?.hasTaxonomy ?? false;
+    const hasSectionLabels = items.some((item) => Boolean(item.sectionLabel));
+    const hasParentRelations = items.some((item) => (item.parentIds || []).length > 0);
+
+    if (hasTaxonomy) {
+        return hasParentRelations;
+    }
+
+    return !hasSectionLabels && hasParentRelations;
+};

package/src/results/generic/search-results-client.tsx

@@ -14,7 +14,7 @@ import { GenericTableResultList } from "./table-result-list";
 import { Pagination } from "../pagination";
 import { Skeleton } from "@c-rex/ui/skeleton";
 import type { CommonItemsModel, ResultContainerModel, Tags } from "@c-rex/interfaces";
-import type { FacetLabelOverrides } from "../filter-sidebar/utils";
+import type { FacetPresentation } from "../filter-sidebar/utils";
 
 type SerializedError = { message: string; name: string } | null;
 
@@ -41,7 +41,8 @@ export type GenericSearchResultsClientProps<
     linkPattern: string;
     addPackageId: boolean;
     showFilesColumn?: boolean;
-    facetLabelOverrides?: FacetLabelOverrides;
+    facetPresentation?: FacetPresentation;
+    facetLabelOverrides?: FacetPresentation;
     informationSubjectsTaxonomy?: NonNullable<FilterSidebarProps["facetTaxonomies"]>["informationSubjects"];
     facetExcludeProperties?: string[];
 };
@@ -83,7 +84,8 @@ type SearchResultsBodyProps<TItem extends CommonItemsModel> = {
     data: ResultContainerModel<TItem> | null;
     error: SerializedError;
     isLoading: boolean;
-    facetLabelOverrides?: FacetLabelOverrides;
+    facetPresentation?: FacetPresentation;
+    facetLabelOverrides?: FacetPresentation;
     informationSubjectsTaxonomy?: NonNullable<FilterSidebarProps["facetTaxonomies"]>["informationSubjects"];
     facetExcludeProperties: string[];
     search: string;
@@ -96,6 +98,7 @@ const SearchResultsBody = <TItem extends CommonItemsModel>({
     data,
     error,
     isLoading,
+    facetPresentation,
     facetLabelOverrides,
     informationSubjectsTaxonomy,
     facetExcludeProperties,
@@ -105,6 +108,7 @@ const SearchResultsBody = <TItem extends CommonItemsModel>({
     showFilesColumn,
 }: SearchResultsBodyProps<TItem>) => {
     const [lastFacetTags, setLastFacetTags] = useState<Tags | undefined>(undefined);
+    const effectiveFacetPresentation = facetPresentation || facetLabelOverrides;
 
     useEffect(() => {
         if (hasFacetTags(data?.tags)) {
@@ -129,7 +133,7 @@ const SearchResultsBody = <TItem extends CommonItemsModel>({
             <div className="flex flex-col gap-4 pb-4">
                 <FilterNavbar
                     tags={effectiveTags}
-                    facetLabelOverrides={facetLabelOverrides}
+                    facetPresentation={effectiveFacetPresentation}
                     excludeProperties={facetExcludeProperties}
                 />
                 <Empty />
@@ -142,7 +146,7 @@ const SearchResultsBody = <TItem extends CommonItemsModel>({
             <div className="flex flex-col gap-4 pb-4">
                 <FilterNavbar
                     tags={effectiveTags}
-                    facetLabelOverrides={facetLabelOverrides}
+                    facetPresentation={effectiveFacetPresentation}
                     excludeProperties={facetExcludeProperties}
                 />
 
@@ -150,7 +154,7 @@ const SearchResultsBody = <TItem extends CommonItemsModel>({
                     <FilterSidebar
                         tags={effectiveTags}
                         totalItemCount={data.pageInfo.totalItemCount}
-                        facetLabelOverrides={facetLabelOverrides}
+                        facetPresentation={effectiveFacetPresentation}
                         facetTaxonomies={informationSubjectsTaxonomy ? { informationSubjects: informationSubjectsTaxonomy } : undefined}
                         excludeProperties={facetExcludeProperties}
                     />
@@ -167,7 +171,7 @@ const SearchResultsBody = <TItem extends CommonItemsModel>({
         <div className="flex flex-col gap-4 pb-4">
             <FilterNavbar
                 tags={effectiveTags}
-                facetLabelOverrides={facetLabelOverrides}
+                facetPresentation={effectiveFacetPresentation}
                 excludeProperties={facetExcludeProperties}
             />
 
@@ -175,7 +179,7 @@ const SearchResultsBody = <TItem extends CommonItemsModel>({
                 <FilterSidebar
                     tags={effectiveTags}
                     totalItemCount={data.pageInfo.totalItemCount}
-                    facetLabelOverrides={facetLabelOverrides}
+                    facetPresentation={effectiveFacetPresentation}
                     facetTaxonomies={informationSubjectsTaxonomy ? { informationSubjects: informationSubjectsTaxonomy } : undefined}
                     excludeProperties={facetExcludeProperties}
                 />
@@ -211,6 +215,7 @@ export const GenericSearchResultsClient = <
     linkPattern,
     addPackageId,
     showFilesColumn = false,
+    facetPresentation,
     facetLabelOverrides,
     informationSubjectsTaxonomy,
     facetExcludeProperties = [],
@@ -244,6 +249,7 @@ export const GenericSearchResultsClient = <
                         data={data}
                         error={error}
                         isLoading={isLoading}
+                        facetPresentation={facetPresentation}
                         facetLabelOverrides={facetLabelOverrides}
                         informationSubjectsTaxonomy={informationSubjectsTaxonomy}
                         facetExcludeProperties={facetExcludeProperties}