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

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 };
+};