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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name":  "@c-rex/components",
-    "version":  "0.3.0-build.39",
+    "version":  "0.3.0-build.40",
     "files":  [
                   "src"
               ],

package/src/info/information-unit-metadata-grid-client.tsx

@@ -12,32 +12,18 @@ import { InformationUnitsGetAllClient } from "../generated/client-components";
 import type {
     CommonItemsModel,
     InformationUnitModel,
-    LiteralModel,
-    ObjectRefModel,
-    RenditionModel,
 } from "@c-rex/interfaces";
+import type { AvailableLanguageVersion } from "@c-rex/services/read-models";
 import {
-    INFORMATION_UNIT_PROPERTY_PRESENTATION,
-    type InformationUnitPropertyKey,
-} from "@c-rex/services/metadata-presentation-config";
-import type { AvailableLanguageVersion, MetadataFacetLabelOverrides } from "@c-rex/services/read-models";
+    buildMetadataDisplayRows,
+    type MetadataFacetLabelOverrides,
+} from "@c-rex/services/metadata-display-builder";
 import { resolveMetadataDisplayProperties } from "@c-rex/services/metadata-view-profile";
 import {
     extractCountryCodeFromLanguage,
-    getFileRenditionGroups,
     resolvePreferredLanguage,
-    sortAndDeduplicateLanguages,
 } from "@c-rex/utils";
 
-type MetadataDisplayRow = {
-    key: InformationUnitPropertyKey;
-    label: string;
-    labelSource: "translationKey" | "direct";
-    values: string[];
-    valueType?: "text" | "language" | "rendition";
-    renditions?: RenditionModel[];
-};
-
 type Props = {
     title: string;
     linkPattern: string;
@@ -51,198 +37,6 @@ type Props = {
     availableInVersions?: AvailableLanguageVersion[];
 };
 
-const resolveLiteralLabel = (labels?: LiteralModel[] | null, uiLanguage?: string): string | undefined => {
-    if (!labels || labels.length === 0) return undefined;
-    const language = uiLanguage || "en";
-    const preferred = resolvePreferredLanguage(
-        labels.map((item) => item.language || ""),
-        language
-    );
-    if (preferred) {
-        const exact = labels.find((item) => item.language === preferred)?.value;
-        if (exact) return exact;
-    }
-    return labels.find((item) => item.value)?.value || undefined;
-};
-
-const resolveObjectRefLabel = (item: ObjectRefModel, uiLanguage: string): string | undefined => {
-    return resolveLiteralLabel(item.labels || [], uiLanguage) || item.shortId || item.id || undefined;
-};
-
-const resolveObjectRefClassLabel = (item: ObjectRefModel, uiLanguage: string): string | undefined => {
-    return resolveLiteralLabel(item.class?.labels || [], uiLanguage)
-        || item.class?.shortId
-        || item.class?.id
-        || undefined;
-};
-
-const asObjectRefArray = (value: unknown): ObjectRefModel[] => {
-    if (!Array.isArray(value)) return [];
-    return value.filter((item): item is ObjectRefModel => Boolean(item && typeof item === "object"));
-};
-
-const asLiteralArray = (value: unknown): LiteralModel[] => {
-    if (!Array.isArray(value)) return [];
-    return value.filter((item): item is LiteralModel => Boolean(item && typeof item === "object"));
-};
-
-const buildMetadataDisplayRows = (
-    data: CommonItemsModel,
-    uiLanguage: string,
-    includeProperties: InformationUnitPropertyKey[],
-    overrides?: MetadataFacetLabelOverrides
-): MetadataDisplayRow[] => {
-    const preferredTitle = resolveLiteralLabel(data.titles || [], uiLanguage) || resolveLiteralLabel(data.labels || [], uiLanguage);
-    const rows: MetadataDisplayRow[] = [];
-
-    for (const key of includeProperties) {
-        const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[key];
-        if (!config?.metadataDisplay?.supported) continue;
-
-        if (key === "labels") continue;
-
-        if (key === "titles") {
-            if (preferredTitle) {
-                rows.push({
-                    key,
-                    label: key,
-                    labelSource: "translationKey",
-                    values: [preferredTitle],
-                    valueType: "text",
-                });
-            }
-            continue;
-        }
-
-        const value = (data as InformationUnitModel)[key];
-        if (value == null) continue;
-
-        if (key === "languages") {
-            const languages = sortAndDeduplicateLanguages((value as string[]) || []);
-            if (languages.length > 0) {
-                rows.push({
-                    key,
-                    label: key,
-                    labelSource: "translationKey",
-                    values: languages,
-                    valueType: "language",
-                });
-            }
-            continue;
-        }
-
-        if (config.valueKind === "scalar") {
-            rows.push({
-                key,
-                label: key,
-                labelSource: "translationKey",
-                values: [String(value)],
-                valueType: "text",
-            });
-            continue;
-        }
-
-        if (config.valueKind === "stringArray") {
-            const values = Array.from(new Set((value as string[]).map((item) => String(item)).filter(Boolean)));
-            if (values.length > 0) {
-                rows.push({
-                    key,
-                    label: key,
-                    labelSource: "translationKey",
-                    values,
-                    valueType: "text",
-                });
-            }
-            continue;
-        }
-
-        if (config.valueKind === "literalArray") {
-            const preferred = resolveLiteralLabel(asLiteralArray(value), uiLanguage);
-            if (preferred) {
-                rows.push({
-                    key,
-                    label: key,
-                    labelSource: "translationKey",
-                    values: [preferred],
-                    valueType: "text",
-                });
-            }
-            continue;
-        }
-
-        if (config.valueKind === "objectRef") {
-            const label = resolveObjectRefLabel(value as ObjectRefModel, uiLanguage);
-            if (label) {
-                rows.push({
-                    key,
-                    label: key,
-                    labelSource: "translationKey",
-                    values: [label],
-                    valueType: "text",
-                });
-            }
-            continue;
-        }
-
-        if (config.valueKind === "objectRefArray") {
-            const refs = asObjectRefArray(value);
-            if (refs.length === 0) continue;
-
-            const groupedValues = new Map<string, Set<string>>();
-
-            refs.forEach((ref) => {
-                const shortId = ref.shortId || "";
-                const override = shortId ? overrides?.[key]?.[shortId] : undefined;
-                const valueLabel = override?.label || resolveObjectRefLabel(ref, uiLanguage);
-                if (!valueLabel) return;
-
-                const sectionLabel = config.metadataDisplay.sectionStrategy === "none"
-                    ? key
-                    : override?.sectionLabel || resolveObjectRefClassLabel(ref, uiLanguage) || key;
-
-                const existing = groupedValues.get(sectionLabel) || new Set<string>();
-                existing.add(valueLabel);
-                groupedValues.set(sectionLabel, existing);
-            });
-
-            Array.from(groupedValues.entries())
-                .sort(([left], [right]) => left.localeCompare(right))
-                .forEach(([sectionLabel, valueSet]) => {
-                    const values = Array.from(valueSet).sort((a, b) => a.localeCompare(b));
-                    if (values.length === 0) return;
-
-                    rows.push({
-                        key,
-                        label: sectionLabel,
-                        labelSource: sectionLabel === key ? "translationKey" : "direct",
-                        values,
-                        valueType: "text",
-                    });
-                });
-            continue;
-        }
-
-        if (config.valueKind === "renditionArray") {
-            const renditions = Array.isArray(value)
-                ? value.filter((item): item is RenditionModel => Boolean(item && typeof item === "object"))
-                : [];
-            if (renditions.length === 0) continue;
-            if (getFileRenditionGroups({ renditions }).length === 0) continue;
-
-            rows.push({
-                key,
-                label: "files",
-                labelSource: "translationKey",
-                values: [],
-                valueType: "rendition",
-                renditions,
-            });
-        }
-    }
-
-    return rows;
-};
-
 const normalizeVersionItems = (items: CommonItemsModel[], uiLanguage: string) => {
     const uniqueByShortId = new Map<string, { shortId: string; language: string }>();
 
@@ -339,7 +133,11 @@ export const InformationUnitMetadataGridClient = ({
                 : [...(metadataExcludeProperties || []), "renditions"],
         });
 
-        return buildMetadataDisplayRows(data, locale, includeProperties, metadataLabelOverrides);
+        return buildMetadataDisplayRows(data as InformationUnitModel, {
+            uiLanguage: locale,
+            includeProperties,
+            overrides: metadataLabelOverrides,
+        });
     }, [data, locale, metadataExcludeProperties, metadataIncludeProperties, metadataLabelOverrides, showFileRenditions]);
 
     const cardContent = (

package/src/restriction-menu/__tests__/restriction-hierarchy.test.ts

@@ -0,0 +1,12 @@
+import { isRestrictionHierarchyNodeSelectable } from "../restriction-hierarchy";
+
+describe("restriction hierarchy semantics", () => {
+    it("treats materialized structural taxonomy nodes as non-selectable", () => {
+        expect(isRestrictionHierarchyNodeSelectable({ isStructural: true })).toBe(false);
+    });
+
+    it("keeps live taxonomy nodes selectable", () => {
+        expect(isRestrictionHierarchyNodeSelectable({ isStructural: false })).toBe(true);
+        expect(isRestrictionHierarchyNodeSelectable({})).toBe(true);
+    });
+});

package/src/restriction-menu/restriction-hierarchy.ts

@@ -0,0 +1,7 @@
+export type RestrictionHierarchyNode = {
+    isStructural?: boolean;
+};
+
+export const isRestrictionHierarchyNodeSelectable = (
+    item: RestrictionHierarchyNode
+): boolean => !item.isStructural;

package/src/restriction-menu/restriction-selection-command-menu.tsx

@@ -9,6 +9,7 @@ import {
 import { RestrictionNavigationItem } from "./restriction-menu-item";
 import { parseAsString, useQueryState, useQueryStates } from "nuqs";
 import { DomainEntityModel, ObjectRefModel } from "@c-rex/interfaces";
+import type { TaxonomyResult } from "@c-rex/services/read-models";
 import { useLocale, useTranslations } from 'next-intl'
 import { cn, getLabelByLang } from "@c-rex/utils";
 import { useRestrictionStore } from "../stores/restriction-store";
@@ -20,12 +21,15 @@ import { Button } from "@c-rex/ui/button";
 import { Check, ChevronDown } from "lucide-react";
 import { useSearchNavigationStore } from "../stores/search-navigation-store";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@c-rex/ui/tooltip";
+import { buildTaxonomyHierarchy, type HierarchyItem } from "../taxonomy/hierarchy";
+import { isRestrictionHierarchyNodeSelectable } from "./restriction-hierarchy";
 
 type Props = {
     restrictField: string
     navigationMenuListClassName?: string
     items: DomainEntityModel[],
     enableHierarchy?: boolean,
+    hierarchyTaxonomy?: TaxonomyResult,
     hasMoreItems?: boolean,
     showAllWhenEmpty?: boolean,
     onRequestMore?: () => void,
@@ -41,6 +45,10 @@ type RestrictionTreeNode = {
     children: RestrictionTreeNode[];
 };
 
+type RestrictionHierarchyItem = HierarchyItem & {
+    item?: DomainEntityModel;
+};
+
 const hasSelectedDescendant = (node: RestrictionTreeNode, selectedShortIds: Set<string>): boolean => {
     const shortId = node.item.shortId;
     if (shortId && selectedShortIds.has(shortId)) return true;
@@ -64,6 +72,13 @@ const extractParentKeys = (item: DomainEntityModel): string[] => {
     });
 };
 
+const extractParentIds = (item: DomainEntityModel): string[] => {
+    const withParents = item as DomainEntityModel & { parents?: ObjectRefModel[] | null };
+    return (withParents.parents || [])
+        .map((parent) => parent.id || parent.shortId)
+        .filter((parentId): parentId is string => Boolean(parentId));
+};
+
 const buildRestrictionTree = (items: DomainEntityModel[]): RestrictionTreeNode[] => {
     const nodes = new Map<string, RestrictionTreeNode>();
     items.forEach((item) => {
@@ -217,18 +232,25 @@ const RestrictionCommandDialog: FC<RestrictionCommandDialogProps> = ({
                                 const groupShortId = node.item.shortId ?? "";
                                 const groupLabel = fmt(getLabelByLang(node.item.labels, lang) ?? groupShortId);
                                 const groupIsSelected = selectedRestrictionIds.has(groupShortId);
+                                const groupIsSelectable = isRestrictionHierarchyNodeSelectable(node.item);
 
                                 return (
                                     <>
-                                        <CommandItem
-                                            key={groupShortId}
-                                            value={groupLabel}
-                                            onSelect={() => handleSelect(groupShortId, groupIsSelected)}
-                                            className="cursor-pointer"
-                                        >
-                                            <span className={cn("flex-1", groupIsSelected && "font-medium")}>{groupLabel}</span>
-                                            {groupIsSelected && <Check className="h-4 w-4 shrink-0 text-primary" />}
-                                        </CommandItem>
+                                        {groupIsSelectable ? (
+                                            <CommandItem
+                                                key={groupShortId}
+                                                value={groupLabel}
+                                                onSelect={() => handleSelect(groupShortId, groupIsSelected)}
+                                                className="cursor-pointer"
+                                            >
+                                                <span className={cn("flex-1", groupIsSelected && "font-medium")}>{groupLabel}</span>
+                                                {groupIsSelected && <Check className="h-4 w-4 shrink-0 text-primary" />}
+                                            </CommandItem>
+                                        ) : (
+                                            <div key={groupShortId} className="px-2 py-3 text-sm text-muted-foreground">
+                                                {groupLabel}
+                                            </div>
+                                        )}
                                         {node.children.map((child) => {
                                             const shortId = child.item.shortId ?? "";
                                             const childLabel = fmt(getLabelByLang(child.item.labels, lang) ?? shortId);
@@ -260,6 +282,7 @@ export const RestrictionSelectionCommandMenu: FC<Props> = ({
     items,
     restrictField,
     enableHierarchy = false,
+    hierarchyTaxonomy,
     hasMoreItems = false,
     showAllWhenEmpty = true,
     onRequestMore,
@@ -313,8 +336,39 @@ export const RestrictionSelectionCommandMenu: FC<Props> = ({
 
     const hierarchyRoots = useMemo(() => {
         if (!enableHierarchy) return [];
-        return buildRestrictionTree(sortedItems);
-    }, [enableHierarchy, sortedItems]);
+        if (!hierarchyTaxonomy) return buildRestrictionTree(sortedItems);
+
+        const hierarchy = buildTaxonomyHierarchy<RestrictionHierarchyItem>(
+            sortedItems.map((item) => ({
+                shortId: item.shortId || item.id || "",
+                label: getLabelByLang(item.labels, lang) || item.shortId || item.id || "",
+                active: selectedRestrictionIds.has(item.shortId || ""),
+                hits: 0,
+                total: 0,
+                taxonomyId: item.id || undefined,
+                parentIds: extractParentIds(item),
+                item,
+            })),
+            hierarchyTaxonomy
+        );
+
+        const toTreeNode = (node: RestrictionHierarchyItem): RestrictionTreeNode => {
+            const nodeKey = node.taxonomyId || node.shortId;
+            const runtimeItem = node.item || {
+                id: node.taxonomyId,
+                shortId: node.shortId,
+                labels: [{ language: lang, value: node.label }],
+                isStructural: node.isStructural,
+            } as DomainEntityModel;
+
+            return {
+                item: runtimeItem,
+                children: (hierarchy.children.get(nodeKey) || []).map((child) => toTreeNode(child)),
+            };
+        };
+
+        return hierarchy.roots.map((root) => toTreeNode(root));
+    }, [enableHierarchy, hierarchyTaxonomy, lang, selectedRestrictionIds, sortedItems]);
 
     const device = useBreakpoint();
     const [visibleCount, setVisibleCount] = useState(0);
@@ -383,6 +437,7 @@ export const RestrictionSelectionCommandMenu: FC<Props> = ({
                 {enableHierarchy && visibleHierarchyRoots.map((rootNode) => {
                     const shortId = rootNode.item.shortId || "";
                     const hasChildren = rootNode.children.length > 0;
+                    const isSelectable = isRestrictionHierarchyNodeSelectable(rootNode.item);
                     const rawLabel = getLabelByLang(rootNode.item.labels, lang);
                     const label = rawLabel
                     const rootSelected = restrictionValues.includes(shortId);
@@ -390,6 +445,16 @@ export const RestrictionSelectionCommandMenu: FC<Props> = ({
                     const shouldHighlightBranch = hasActiveDescendant && !rootSelected;
 
                     if (!hasChildren) {
+                        if (!isSelectable) {
+                            return (
+                                <NavigationMenuItem key={shortId}>
+                                    <div className="flex min-h-9 items-center rounded-full border border-transparent px-4 py-2 text-sm text-muted-foreground">
+                                        {label}
+                                    </div>
+                                </NavigationMenuItem>
+                            );
+                        }
+
                         return (
                             <RestrictionNavigationItem
                                 key={shortId}

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

@@ -11,12 +11,15 @@ import {
 import { RestrictionDropdownItem, RestrictionNavigationItem } from "./restriction-menu-item";
 import { parseAsString, useQueryStates } from "nuqs";
 import { DomainEntityModel, ObjectRefModel } from "@c-rex/interfaces";
+import type { TaxonomyResult } from "@c-rex/services/read-models";
 import { useLocale, useTranslations } from 'next-intl'
 import { cn, getLabelByLang } from "@c-rex/utils";
 import { useRestrictionStore } from "../stores/restriction-store";
 import { useBreakpoint } from "@c-rex/ui/hooks";
 import { DEVICE_OPTIONS } from "@c-rex/constants";
 import { ChevronDown, ChevronRight } from "lucide-react";
+import { buildTaxonomyHierarchy, type HierarchyItem } from "../taxonomy/hierarchy";
+import { isRestrictionHierarchyNodeSelectable } from "./restriction-hierarchy";
 
 
 type Props = {
@@ -24,6 +27,7 @@ type Props = {
     navigationMenuListClassName?: string
     items: DomainEntityModel[],
     enableHierarchy?: boolean,
+    hierarchyTaxonomy?: TaxonomyResult,
     hasMoreItems?: boolean,
     showAllWhenEmpty?: boolean,
     onRequestMore?: () => void,
@@ -41,6 +45,10 @@ type RestrictionTreeNode = {
     children: RestrictionTreeNode[];
 };
 
+type RestrictionHierarchyItem = HierarchyItem & {
+    item?: DomainEntityModel;
+};
+
 const hasSelectedDescendant = (node: RestrictionTreeNode, selectedShortIds: Set<string>): boolean => {
     const shortId = node.item.shortId;
     if (shortId && selectedShortIds.has(shortId)) {
@@ -68,6 +76,13 @@ const extractParentKeys = (item: DomainEntityModel): string[] => {
         });
 };
 
+const extractParentIds = (item: DomainEntityModel): string[] => {
+    const withParents = item as DomainEntityModel & { parents?: ObjectRefModel[] | null };
+    return (withParents.parents || [])
+        .map((parent) => parent.id || parent.shortId)
+        .filter((parentId): parentId is string => Boolean(parentId));
+};
+
 const buildRestrictionTree = (items: DomainEntityModel[]): RestrictionTreeNode[] => {
     const nodes = new Map<string, RestrictionTreeNode>();
     items.forEach((item) => {
@@ -116,6 +131,7 @@ export const RestrictionSelectionMenu: FC<Props> = ({
     items,
     restrictField,
     enableHierarchy = false,
+    hierarchyTaxonomy,
     hasMoreItems = false,
     showAllWhenEmpty = true,
     onRequestMore,
@@ -181,10 +197,40 @@ export const RestrictionSelectionMenu: FC<Props> = ({
         return sorted;
     }, [items, restrictionValues, updatePosition]);
 
-    const hierarchyRoots = useMemo(() => {
+    const hierarchyTree = useMemo(() => {
         if (!enableHierarchy) return [];
-        return buildRestrictionTree(sortedItems);
-    }, [enableHierarchy, sortedItems]);
+        if (!hierarchyTaxonomy) return buildRestrictionTree(sortedItems);
+
+        const hierarchy = buildTaxonomyHierarchy<RestrictionHierarchyItem>(
+            sortedItems.map((item) => ({
+                shortId: item.shortId || item.id || "",
+                label: getLabelByLang(item.labels, lang) || item.shortId || item.id || "",
+                active: selectedRestrictionIds.has(item.shortId || ""),
+                hits: 0,
+                total: 0,
+                taxonomyId: item.id || undefined,
+                parentIds: extractParentIds(item),
+                item,
+            })),
+            hierarchyTaxonomy
+        );
+
+        const toTreeNode = (node: RestrictionHierarchyItem): RestrictionTreeNode => {
+            const nodeKey = node.taxonomyId || node.shortId;
+            const runtimeItem = node.item || {
+                id: node.taxonomyId,
+                shortId: node.shortId,
+                labels: [{ language: lang, value: node.label }],
+            } as DomainEntityModel;
+
+            return {
+                item: runtimeItem,
+                children: (hierarchy.children.get(nodeKey) || []).map((child) => toTreeNode(child)),
+            };
+        };
+
+        return hierarchy.roots.map((root) => toTreeNode(root));
+    }, [enableHierarchy, hierarchyTaxonomy, lang, selectedRestrictionIds, sortedItems]);
 
     const device = useBreakpoint();
     const [visibleCount, setVisibleCount] = useState(0);
@@ -201,7 +247,7 @@ export const RestrictionSelectionMenu: FC<Props> = ({
         if (visibleCount == 0) return;
 
         if (enableHierarchy) {
-            const roots = hierarchyRoots.map((node) => node.item);
+            const roots = hierarchyTree.map((node) => node.item);
             setVisibleItems(roots.slice(0, visibleCount));
             setHiddenItems(roots.slice(visibleCount));
             return;
@@ -209,19 +255,19 @@ export const RestrictionSelectionMenu: FC<Props> = ({
 
         setVisibleItems(sortedItems.slice(0, visibleCount));
         setHiddenItems(sortedItems.slice(visibleCount));
-    }, [enableHierarchy, hierarchyRoots, sortedItems, visibleCount]);
+    }, [enableHierarchy, hierarchyTree, sortedItems, visibleCount]);
 
     const visibleHierarchyRoots = useMemo(() => {
         if (!enableHierarchy) return [];
         const visibleRootShortIds = new Set(visibleItems.map((item) => item.shortId).filter(Boolean));
-        return hierarchyRoots.filter((root) => root.item.shortId && visibleRootShortIds.has(root.item.shortId));
-    }, [enableHierarchy, hierarchyRoots, visibleItems]);
+        return hierarchyTree.filter((root) => root.item.shortId && visibleRootShortIds.has(root.item.shortId));
+    }, [enableHierarchy, hierarchyTree, visibleItems]);
 
     const hiddenHierarchyRoots = useMemo(() => {
         if (!enableHierarchy) return [];
         const hiddenRootShortIds = new Set(hiddenItems.map((item) => item.shortId).filter(Boolean));
-        return hierarchyRoots.filter((root) => root.item.shortId && hiddenRootShortIds.has(root.item.shortId));
-    }, [enableHierarchy, hierarchyRoots, hiddenItems]);
+        return hierarchyTree.filter((root) => root.item.shortId && hiddenRootShortIds.has(root.item.shortId));
+    }, [enableHierarchy, hierarchyTree, hiddenItems]);
 
     const [expandedNodes, setExpandedNodes] = useState<Record<string, boolean>>({});
     const toggleExpanded = (shortId: string) => {
@@ -234,8 +280,10 @@ export const RestrictionSelectionMenu: FC<Props> = ({
         const isRootNode = depth === 0;
         const isExpanded = isRootNode || expandedNodes[shortId] === true;
         const isSelected = restrictionValues.includes(shortId);
+        const isSelectable = isRestrictionHierarchyNodeSelectable(node.item);
         const hasActiveDescendant = hasChildren && node.children.some((child) => hasSelectedDescendant(child, selectedRestrictionIds));
         const shouldHighlightBranch = hasActiveDescendant && !isSelected;
+        const label = getLabelByLang(node.item.labels, lang);
 
         return (
             <li key={`tree-node-${shortId}`} className="flex flex-col w-full">
@@ -259,12 +307,18 @@ export const RestrictionSelectionMenu: FC<Props> = ({
                             shouldHighlightBranch && "bg-primary/5 ring-1 ring-primary/10"
                         )}
                     >
-                        <RestrictionDropdownItem
-                            shortId={shortId}
-                            restrictField={restrictField}
-                            label={getLabelByLang(node.item.labels, lang)}
-                            selected={isSelected}
-                        />
+                        {isSelectable ? (
+                            <RestrictionDropdownItem
+                                shortId={shortId}
+                                restrictField={restrictField}
+                                label={label}
+                                selected={isSelected}
+                            />
+                        ) : (
+                            <div className="flex min-h-10 w-full items-center rounded-full px-4 py-2 text-sm text-muted-foreground">
+                                {label}
+                            </div>
+                        )}
                     </div>
                     {shouldHighlightBranch ? (
                         <span
@@ -309,12 +363,23 @@ export const RestrictionSelectionMenu: FC<Props> = ({
                 {enableHierarchy && visibleHierarchyRoots.map((rootNode) => {
                     const shortId = rootNode.item.shortId || "";
                     const hasChildren = rootNode.children.length > 0;
+                    const isSelectable = isRestrictionHierarchyNodeSelectable(rootNode.item);
                     const label = getLabelByLang(rootNode.item.labels, lang);
                     const rootSelected = restrictionValues.includes(shortId);
                     const hasActiveDescendant = hasChildren && hasSelectedDescendant(rootNode, selectedRestrictionIds);
                     const shouldHighlightBranch = hasActiveDescendant && !rootSelected;
 
                     if (!hasChildren) {
+                        if (!isSelectable) {
+                            return (
+                                <NavigationMenuItem key={shortId}>
+                                    <div className="flex min-h-9 items-center rounded-full border border-transparent px-4 py-2 text-sm text-muted-foreground">
+                                        {label}
+                                    </div>
+                                </NavigationMenuItem>
+                            );
+                        }
+
                         return (
                             <RestrictionNavigationItem
                                 key={shortId}

package/src/restriction-menu/taxonomy-restriction-command-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";
@@ -29,6 +30,8 @@ export type TaxonomyRestrictionCommandMenuProps = {
     fetchMode?: RestrictionMenuFetchMode;
     showAllWhenEmpty?: boolean;
     queryParams?: GenericQueryParams;
+    stripLabelPrefix?: string;
+    hierarchyTaxonomy?: TaxonomyResult;
 };
 
 export const TaxonomyRestrictionCommandMenu: FC<TaxonomyRestrictionCommandMenuProps> = ({
@@ -41,6 +44,8 @@ export const TaxonomyRestrictionCommandMenu: FC<TaxonomyRestrictionCommandMenuPr
     fetchMode = "deferred",
     showAllWhenEmpty = true,
     navigationMenuListClassName = "items-center justify-start gap-4 flex-row",
+    stripLabelPrefix,
+    hierarchyTaxonomy,
 }) => {
     const [loadAll, setLoadAll] = useState(false);
     const RequestComponent = ComponentOptions[requestType] as unknown as FC<GenericRequestProps>;
@@ -92,6 +97,7 @@ export const TaxonomyRestrictionCommandMenu: FC<TaxonomyRestrictionCommandMenuPr
                         restrictField={restrictField}
                         items={data.items || []}
                         enableHierarchy={enableHierarchy}
+                        hierarchyTaxonomy={hierarchyTaxonomy}
                         hasMoreItems={hasMoreItems}
                         showAllWhenEmpty={showAllWhenEmpty}
                         onRequestMore={() => {