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

package/src/restriction-menu/taxonomy-restriction-menu.tsx

@@ -1,6 +1,7 @@
 "use client";
 
 import { DomainEntityModel } from "@c-rex/interfaces";
+import type { TaxonomyResult } from "@c-rex/services/read-models";
 import { FC, ReactNode, useMemo, useState } from "react";
 import * as ComponentOptions from "../generated/client-components";
 import { Skeleton } from "@c-rex/ui/skeleton";
@@ -34,6 +35,7 @@ export type TaxonomyRestrictionMenuProps = {
     fetchMode?: RestrictionMenuFetchMode;
     showAllWhenEmpty?: boolean;
     queryParams?: GenericQueryParams;
+    hierarchyTaxonomy?: TaxonomyResult;
     multipleSelection?: boolean;
     updatePosition?: boolean;
 };
@@ -54,6 +56,7 @@ export const TaxonomyRestrictionMenu: FC<TaxonomyRestrictionMenuProps> = ({
     fetchMode = "deferred",
     showAllWhenEmpty = true,
     navigationMenuListClassName = "items-center justify-start gap-4 flex-row",
+    hierarchyTaxonomy,
     multipleSelection = true,
     updatePosition = true,
 }) => {
@@ -108,6 +111,7 @@ export const TaxonomyRestrictionMenu: FC<TaxonomyRestrictionMenuProps> = ({
                         restrictField={restrictField}
                         items={data.items || []}
                         enableHierarchy={enableHierarchy}
+                        hierarchyTaxonomy={hierarchyTaxonomy}
                         hasMoreItems={hasMoreItems}
                         showAllWhenEmpty={showAllWhenEmpty}
                         itemsByRow={itemsByRow}

package/src/results/filter-navbar.tsx

@@ -9,7 +9,7 @@ import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@c-rex
 import { DEVICE_OPTIONS, OPERATOR_OPTIONS } from "@c-rex/constants";
 import { Tags } from "@c-rex/interfaces";
 import { useBreakpoint } from "@c-rex/ui/hooks";
-import { applyFacetPropertyVisibility, FacetLabelOverrides, memoizeFilteredTags } from "./filter-sidebar/utils";
+import { applyFacetPropertyVisibility, FacetPresentation, memoizeFilteredTags } from "./filter-sidebar/utils";
 import { useFilterSidebarState } from "./filter-sidebar/context";
 import { useSearchSettingsStore } from "../stores/search-settings-store";
 import { useRestrictionStore } from "../stores/restriction-store";
@@ -25,7 +25,8 @@ type filterModel = {
 
 type FilterNavbarProps = {
     tags?: Tags
-    facetLabelOverrides?: FacetLabelOverrides
+    facetPresentation?: FacetPresentation
+    facetLabelOverrides?: FacetPresentation
     includeZeroHits?: boolean
     includeProperties?: string[]
     excludeProperties?: string[]
@@ -33,6 +34,7 @@ type FilterNavbarProps = {
 
 export const FilterNavbar: FC<FilterNavbarProps> = ({
     tags,
+    facetPresentation,
     facetLabelOverrides,
     includeZeroHits = true,
     includeProperties,
@@ -45,6 +47,7 @@ export const FilterNavbar: FC<FilterNavbarProps> = ({
     const { setIsMobileFiltersOpen } = useFilterSidebarState();
     const restrictionList = useRestrictionStore((state) => state.restrictionList);
     const startSearchNavigation = useSearchNavigationStore((state) => state.start);
+    const effectiveFacetPresentation = facetPresentation || facetLabelOverrides;
     const [params, setParams] = useQueryStates({
         language: parseAsString.withDefault(useSearchSettingsStore.getState().language || ''),
         page: parseAsInteger.withDefault(1),
@@ -68,11 +71,11 @@ export const FilterNavbar: FC<FilterNavbarProps> = ({
     const filteredTags = useMemo(() => {
         const resolved = memoizeFilteredTags(tags, params.filter, params.packages, {
             uiLanguage: locale,
-            labelOverrides: facetLabelOverrides,
+            facetPresentation: effectiveFacetPresentation,
             includeZeroHits,
         });
         return applyFacetPropertyVisibility(resolved, includeProperties, excludeProperties);
-    }, [tags, params.filter, params.packages, locale, facetLabelOverrides, includeZeroHits, includeProperties, excludeProperties]);
+    }, [tags, params.filter, params.packages, locale, effectiveFacetPresentation, includeZeroHits, includeProperties, excludeProperties]);
     const hasMobileFilters = Object.entries(filteredTags).length > 0;
 
     const humanizeMetadataKey = (key: string): string =>

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" });
     });
 });
-