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

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}

package/src/taxonomy/__tests__/hierarchy.test.ts

@@ -0,0 +1,144 @@
+import { buildTaxonomyHierarchy, type HierarchyItem } from "../hierarchy";
+
+describe("taxonomy hierarchy", () => {
+    it("merges runtime items into the cached taxonomy hierarchy and materializes missing parents structurally", () => {
+        const items: HierarchyItem[] = [
+            {
+                shortId: "catChild",
+                label: "Child",
+                active: false,
+                hits: 2,
+                total: 2,
+                taxonomyId: "category-child",
+                parentIds: ["category-root"],
+            },
+        ];
+
+        const hierarchy = buildTaxonomyHierarchy(items, {
+            generatedAt: "2026-04-16T00:00:00.000Z",
+            roots: [],
+            nodesById: {
+                "category-root": {
+                    id: "category-root",
+                    shortId: "catRoot",
+                    label: "Root",
+                    parentIds: [],
+                },
+                "category-child": {
+                    id: "category-child",
+                    shortId: "catChild",
+                    label: "Child",
+                    parentIds: ["category-root"],
+                },
+            },
+        });
+
+        expect(hierarchy.roots).toEqual([
+            expect.objectContaining({
+                shortId: "catRoot",
+                taxonomyId: "category-root",
+                isStructural: true,
+            }),
+        ]);
+        expect(hierarchy.children.get("category-root")).toEqual([
+            expect.objectContaining({
+                shortId: "catChild",
+                taxonomyId: "category-child",
+                label: "Child",
+                hits: 2,
+                total: 2,
+            }),
+        ]);
+    });
+
+    it("falls back to the local parent links when no taxonomy is provided", () => {
+        const items: HierarchyItem[] = [
+            {
+                shortId: "root",
+                label: "Root",
+                active: false,
+                hits: 1,
+                total: 1,
+            },
+            {
+                shortId: "child",
+                label: "Child",
+                active: false,
+                hits: 1,
+                total: 1,
+                parentIds: ["root"],
+            },
+        ];
+
+        const hierarchy = buildTaxonomyHierarchy(items);
+
+        expect(hierarchy.roots.map((item) => item.shortId)).toEqual(["root"]);
+        expect(hierarchy.children.get("root")?.map((item) => item.shortId)).toEqual(["child"]);
+    });
+
+    it("attaches polyhierarchical nodes to all known parents", () => {
+        const items: HierarchyItem[] = [
+            {
+                shortId: "parent-a",
+                label: "Parent A",
+                active: false,
+                hits: 1,
+                total: 1,
+            },
+            {
+                shortId: "parent-b",
+                label: "Parent B",
+                active: false,
+                hits: 1,
+                total: 1,
+            },
+            {
+                shortId: "child",
+                label: "Child",
+                active: false,
+                hits: 1,
+                total: 1,
+                parentIds: ["parent-a", "parent-b"],
+            },
+        ];
+
+        const hierarchy = buildTaxonomyHierarchy(items);
+
+        expect(hierarchy.children.get("parent-a")?.map((item) => item.shortId)).toEqual(["child"]);
+        expect(hierarchy.children.get("parent-b")?.map((item) => item.shortId)).toEqual(["child"]);
+    });
+
+    it("matches taxonomy nodes by shortId when runtime facet items have no stable taxonomy id", () => {
+        const items: HierarchyItem[] = [
+            {
+                shortId: "catChild",
+                label: "Child",
+                active: false,
+                hits: 2,
+                total: 2,
+            },
+        ];
+
+        const hierarchy = buildTaxonomyHierarchy(items, {
+            generatedAt: "2026-04-24T00:00:00.000Z",
+            roots: [],
+            nodesById: {
+                "category-root": {
+                    id: "category-root",
+                    shortId: "catRoot",
+                    label: "Root",
+                    parentIds: [],
+                },
+                "category-child": {
+                    id: "category-child",
+                    shortId: "catChild",
+                    label: "Child",
+                    parentIds: ["category-root"],
+                },
+            },
+        });
+
+        expect(hierarchy.roots.map((item) => item.shortId)).toEqual(["catRoot"]);
+        expect(hierarchy.children.get("category-root")?.map((item) => item.shortId)).toEqual(["catChild"]);
+    });
+});

package/src/taxonomy/hierarchy.ts

@@ -0,0 +1,137 @@
+import type { TaxonomyResult } from "@c-rex/services/read-models";
+
+export type HierarchyItem = {
+    shortId: string;
+    label: string;
+    active: boolean;
+    hits: number;
+    total: number;
+    taxonomyId?: string;
+    parentIds?: string[];
+    isStructural?: boolean;
+};
+
+export type HierarchyTree<TItem extends HierarchyItem> = {
+    roots: TItem[];
+    children: Map<string, TItem[]>;
+};
+
+const sortItems = <TItem extends HierarchyItem>(items: TItem[]) =>
+    items.sort((a, b) => a.label.localeCompare(b.label));
+
+export const buildTaxonomyHierarchy = <TItem extends HierarchyItem>(
+    items: TItem[],
+    taxonomy?: TaxonomyResult
+): HierarchyTree<TItem> => {
+    if (taxonomy) {
+        const selectedById = new Map<string, TItem>();
+        const includedIds = new Set<string>();
+        const resolveTaxonomyNodeId = (item: TItem): string | undefined => {
+            const directId = item.taxonomyId || item.shortId;
+            if (directId && taxonomy.nodesById[directId]) return directId;
+
+            return Object.values(taxonomy.nodesById).find((node) => (
+                Boolean(item.taxonomyId && node.id === item.taxonomyId) ||
+                Boolean(item.shortId && node.shortId === item.shortId)
+            ))?.id;
+        };
+
+        const includeAncestorChain = (nodeId: string) => {
+            const visited = new Set<string>();
+            const stack = [nodeId];
+
+            while (stack.length > 0) {
+                const currentId = stack.pop();
+                if (!currentId || visited.has(currentId)) continue;
+                visited.add(currentId);
+
+                const currentNode = taxonomy.nodesById[currentId];
+                (currentNode?.parentIds || []).forEach((parentId) => {
+                    if (taxonomy.nodesById[parentId]) {
+                        includedIds.add(parentId);
+                        stack.push(parentId);
+                    }
+                });
+            }
+        };
+
+        items.forEach((item) => {
+            const itemId = resolveTaxonomyNodeId(item);
+            if (!itemId) return;
+
+            selectedById.set(itemId, item);
+            includedIds.add(itemId);
+            includeAncestorChain(itemId);
+        });
+
+        const byId = new Map<string, TItem>();
+        const children = new Map<string, TItem[]>();
+        const parentedIds = new Set<string>();
+
+        Array.from(includedIds).forEach((nodeId) => {
+            const taxonomyNode = taxonomy.nodesById[nodeId];
+            if (!taxonomyNode) return;
+
+            byId.set(nodeId, selectedById.get(nodeId) || {
+                shortId: taxonomyNode.shortId || nodeId,
+                label: taxonomyNode.label,
+                active: false,
+                hits: 0,
+                total: 0,
+                taxonomyId: taxonomyNode.id,
+                parentIds: taxonomyNode.parentIds || [],
+                isStructural: true,
+            } as TItem);
+            children.set(nodeId, []);
+        });
+
+        Array.from(includedIds).forEach((nodeId) => {
+            const current = byId.get(nodeId);
+            const taxonomyNode = taxonomy.nodesById[nodeId];
+            if (!current || !taxonomyNode) return;
+
+            (taxonomyNode.parentIds || [])
+                .filter((id) => byId.has(id))
+                .forEach((parentKey) => {
+                    children.get(parentKey)?.push(current);
+                    parentedIds.add(nodeId);
+                });
+        });
+
+        const roots = Array.from(byId.entries())
+            .filter(([nodeId]) => !parentedIds.has(nodeId))
+            .map(([, node]) => node);
+
+        sortItems(roots);
+        children.forEach((nodes) => sortItems(nodes));
+
+        return { roots, children };
+    }
+
+    const byId = new Map<string, TItem>();
+    const children = new Map<string, TItem[]>();
+    const roots: TItem[] = [];
+
+    items.forEach((item) => {
+        const key = item.taxonomyId || item.shortId;
+        byId.set(key, item);
+        children.set(key, []);
+    });
+
+    items.forEach((item) => {
+        const parentKeys = (item.parentIds || []).filter((id) => byId.has(id));
+        if (parentKeys.length === 0) {
+            roots.push(item);
+            return;
+        }
+
+        parentKeys.forEach((parentKey) => {
+            children.get(parentKey)?.push(item);
+        });
+    });
+
+    sortItems(roots);
+    children.forEach((nodes) => sortItems(nodes));
+
+    return { roots, children };
+};