@manta-eu/react 0.1.0

package/dist/graph/graph-model.js

@@ -0,0 +1,440 @@
+import { labelPredicateSuffixes } from "@manta-eu/rdf-lib/detail-view-types";
+import { expandPrefix, wellKnownPredicates } from "@manta-eu/rdf-lib/namespaces";
+import { applyDagreLayout, computeEdgeSiblingIndices, computeHubThreshold, detectRelationshipType, } from "./graph-layout.js";
+import { humanizePredicateName, shortenUri } from "./graph-utils.js";
+import { readVocabValue } from "./nodes/typed-node-helpers.js";
+import { mantaLightTheme } from "./themes.js";
+const labelPredicate = wellKnownPredicates.label;
+const rdfType = wellKnownPredicates.type;
+const actionShapePredicate = wellKnownPredicates.actionShape;
+function firstStringValue(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.find((item) => typeof item === "string");
+    return undefined;
+}
+const shaclHiddenTypeIris = new Set([expandPrefix("sh:ValidationReport"), expandPrefix("sh:ValidationResult")]);
+function collectHiddenSubjects(graph) {
+    const hidden = new Set();
+    for (const [subjectId, predicates] of graph) {
+        const typeTerms = predicates.get(rdfType) ?? [];
+        if (typeTerms.some((term) => term.termType === "NamedNode" && shaclHiddenTypeIris.has(term.value))) {
+            hidden.add(subjectId);
+        }
+    }
+    return hidden;
+}
+function isLabelPredicate(predicate) {
+    const lower = predicate.toLowerCase();
+    return labelPredicateSuffixes.some((suffix) => lower.endsWith(suffix));
+}
+function createOrGetNodeAccumulator(nodeData, connectionCounts, subjectId) {
+    let node = nodeData.get(subjectId);
+    if (!node) {
+        node = { data: {} };
+        nodeData.set(subjectId, node);
+        connectionCounts.set(subjectId, 0);
+    }
+    return node;
+}
+function mergeNodeValue(target, key, value) {
+    const existing = target[key];
+    if (existing === undefined) {
+        target[key] = value;
+        return;
+    }
+    if (Array.isArray(existing)) {
+        if (!existing.includes(value)) {
+            existing.push(value);
+        }
+        return;
+    }
+    if (existing !== value) {
+        target[key] = [existing, value];
+    }
+}
+function displayLabel(id, label, type, data) {
+    if (label)
+        return label;
+    if (data) {
+        const rankValue = readVocabValue(data, "rank") ?? data["rank"];
+        if (rankValue !== undefined) {
+            return `#${rankValue}`;
+        }
+        for (const [key, value] of Object.entries(data)) {
+            if (isLabelPredicate(key) && typeof value === "string") {
+                return value;
+            }
+        }
+        const nameVal = data["schema:name"] ?? data[":originalFilename"] ?? data[":name"];
+        if (typeof nameVal === "string")
+            return nameVal;
+    }
+    let localName;
+    try {
+        localName = decodeURIComponent(shortenUri(id)).replace(/^[:#]/, "");
+    }
+    catch {
+        localName = shortenUri(id).replace(/^[:#]/, "");
+    }
+    if (type) {
+        const typeName = shortenUri(type)
+            .replace(/^[:#]/, "")
+            .replace(/([a-z])([A-Z])/g, "$1 $2");
+        const idSuffix = localName.replace(new RegExp(`^${typeName.replace(/\s/g, "")}[_-]?`), "");
+        if (idSuffix && idSuffix !== localName && idSuffix.length > 6) {
+            return `${typeName} ${idSuffix.slice(0, 8)}...`;
+        }
+        return typeName;
+    }
+    return localName.length > 40 ? `${localName.slice(0, 35)}...` : localName;
+}
+function buildNodesAndEdges(nodeData, connectionCounts, edges, direction) {
+    const parentChildMap = new Map();
+    const childParentMap = new Map();
+    for (const edge of edges) {
+        const children = parentChildMap.get(edge.source) || [];
+        children.push(edge.target);
+        parentChildMap.set(edge.source, children);
+        childParentMap.set(edge.target, edge.source);
+    }
+    const nodeDepths = new Map();
+    function calculateDepth(nodeId, visited = new Set()) {
+        if (visited.has(nodeId))
+            return 0;
+        visited.add(nodeId);
+        if (nodeDepths.has(nodeId))
+            return nodeDepths.get(nodeId);
+        const parentId = childParentMap.get(nodeId);
+        const depth = parentId ? calculateDepth(parentId, visited) + 1 : 0;
+        nodeDepths.set(nodeId, depth);
+        return depth;
+    }
+    for (const id of nodeData.keys()) {
+        calculateDepth(id);
+    }
+    const allNodeIds = new Set(nodeData.keys());
+    const hubThreshold = computeHubThreshold(connectionCounts);
+    const graphNodes = Array.from(nodeData).map(([id, { label, type, data }]) => {
+        const childIds = (parentChildMap.get(id) || []).filter((childId) => allNodeIds.has(childId));
+        const parentId = childParentMap.get(id);
+        const depth = nodeDepths.get(id) || 0;
+        const connCount = connectionCounts.get(id) || 0;
+        const properties = [];
+        for (const [key, value] of Object.entries(data)) {
+            if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+                properties.push({ key: humanizePredicateName(key), value: String(value), iri: key });
+            }
+            else if (Array.isArray(value)) {
+                const merged = value
+                    .filter((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+                    .map((v) => String(v))
+                    .join(" | ");
+                if (merged.length > 0) {
+                    properties.push({ key: humanizePredicateName(key), value: merged, iri: key });
+                }
+            }
+        }
+        const actionShape = firstStringValue(data[actionShapePredicate]);
+        return {
+            id,
+            type: "rdfNode",
+            position: { x: 0, y: 0 },
+            data: {
+                label: displayLabel(id, label, type, data),
+                type,
+                connectionCount: connCount,
+                isHub: connCount >= hubThreshold,
+                jsonLd: { "@id": id, "@type": type, ...data },
+                properties,
+                childIds,
+                parentId,
+                isCollapsed: false,
+                hasChildren: childIds.length > 0,
+                depth,
+                actionShape,
+            },
+        };
+    });
+    const filteredEdges = edges.filter((edge) => allNodeIds.has(edge.source) && allNodeIds.has(edge.target));
+    const labelCounts = new Map();
+    for (const edge of filteredEdges) {
+        const key = `${edge.target}::${edge.label}`;
+        labelCounts.set(key, (labelCounts.get(key) ?? 0) + 1);
+    }
+    const labelShownForKey = new Set();
+    const graphEdges = filteredEdges.map((edge) => {
+        const key = `${edge.target}::${edge.label}`;
+        const count = labelCounts.get(key) ?? 1;
+        const isDuplicate = count > 3;
+        let edgeLabel = edge.label;
+        if (isDuplicate) {
+            if (!labelShownForKey.has(key)) {
+                labelShownForKey.add(key);
+                edgeLabel = `${edge.label} (x${count})`;
+            }
+            else {
+                edgeLabel = "";
+            }
+        }
+        const sourceNode = nodeData.get(edge.source);
+        const targetNode = nodeData.get(edge.target);
+        const relationshipType = detectRelationshipType(sourceNode?.type, targetNode?.type);
+        const markerColor = mantaLightTheme.edge.relationship[relationshipType];
+        return {
+            ...edge,
+            type: "labeledEdge",
+            animated: false,
+            label: edgeLabel,
+            data: { label: edgeLabel, relationshipType, edgeIndex: 0, edgeSiblingCount: 1 },
+            markerEnd: { type: "arrowclosed", color: markerColor, width: 20, height: 20 },
+        };
+    });
+    computeEdgeSiblingIndices(graphEdges);
+    const layoutedNodes = applyDagreLayout(graphNodes, graphEdges, direction);
+    return { nodes: layoutedNodes, edges: graphEdges, parentChildMap };
+}
+function greedyTypePath(start, outgoingNeighbors, typeByNodeId, maxLength) {
+    const path = [start];
+    const visited = new Set([start]);
+    let current = start;
+    for (let step = 0; step < maxLength; step++) {
+        const neighbors = outgoingNeighbors.get(current) ?? [];
+        let best;
+        let bestScore = -Infinity;
+        for (const neighbor of neighbors) {
+            if (visited.has(neighbor))
+                continue;
+            const neighborType = typeByNodeId.get(neighbor);
+            if (!neighborType)
+                continue;
+            const neighborNeighbors = outgoingNeighbors.get(neighbor) ?? [];
+            const score = neighborNeighbors.filter((n) => !visited.has(n)).length;
+            if (score > bestScore) {
+                bestScore = score;
+                best = neighbor;
+            }
+        }
+        if (!best)
+            break;
+        path.push(best);
+        visited.add(best);
+        current = best;
+    }
+    return path;
+}
+function findRepresentativeChainNodeIds(nodes, edges) {
+    const outgoingNeighbors = new Map();
+    const typeByNodeId = new Map();
+    for (const node of nodes) {
+        typeByNodeId.set(node.id, node.data.type ?? "unknown");
+    }
+    for (const edge of edges) {
+        const neighbors = outgoingNeighbors.get(edge.source) ?? [];
+        neighbors.push(edge.target);
+        outgoingNeighbors.set(edge.source, neighbors);
+    }
+    const roots = nodes.filter((n) => !edges.some((e) => e.target === n.id));
+    const startNode = roots[0]?.id ?? nodes[0]?.id;
+    if (!startNode)
+        return new Set();
+    const chain = greedyTypePath(startNode, outgoingNeighbors, typeByNodeId, 10);
+    return new Set(chain);
+}
+export function rdfGraphToNodesAndEdges(graph, granularity = "subject", direction = "LR") {
+    if (granularity === "subject-object") {
+        throw new Error("Granularity 'subject-object' not implemented yet");
+    }
+    let hasTypes = false;
+    for (const predicates of graph.values()) {
+        if (predicates.has(rdfType)) {
+            hasTypes = true;
+            break;
+        }
+    }
+    if (!hasTypes) {
+        return { nodes: [], edges: [], parentChildMap: new Map() };
+    }
+    const hiddenSubjects = collectHiddenSubjects(graph);
+    const definedSubjects = new Set(graph.keys());
+    const uuidPattern = /[0-9a-f]{8}-[0-9a-f]{4}-/i;
+    const longNumericPattern = /\d{10,}/;
+    const leafValueSchemes = ["http://", "https://", "s3://"];
+    function isEnumLikeRef(targetId) {
+        if (definedSubjects.has(targetId))
+            return false;
+        const isNamespacedIri = targetId.includes("#") || targetId.includes("vocab");
+        // A stored file is a value to render, not a neighbor: without `s3:` a key with a long digit run reads as a ref.
+        if (!isNamespacedIri && leafValueSchemes.some((scheme) => targetId.startsWith(scheme)))
+            return true;
+        const localName = targetId.split(/[#/]/).pop() ?? targetId;
+        if (uuidPattern.test(localName) || longNumericPattern.test(localName))
+            return false;
+        return true;
+    }
+    const nodeData = new Map();
+    const connectionCounts = new Map();
+    const edges = [];
+    for (const [subjectId, predicates] of graph) {
+        if (hiddenSubjects.has(subjectId))
+            continue;
+        const node = createOrGetNodeAccumulator(nodeData, connectionCounts, subjectId);
+        const typeTerms = predicates.get(rdfType) ?? [];
+        const primaryType = typeTerms.find((t) => t.termType === "NamedNode")?.value;
+        if (primaryType) {
+            node.type = primaryType;
+        }
+        for (const [predicate, terms] of predicates) {
+            if (predicate === rdfType)
+                continue;
+            if (predicate === labelPredicate || isLabelPredicate(predicate)) {
+                const labelValue = terms.find((t) => t.termType === "Literal")?.value;
+                if (labelValue) {
+                    if (!node.label) {
+                        node.label = labelValue;
+                    }
+                    node.data[predicate] = labelValue;
+                }
+                continue;
+            }
+            for (const term of terms) {
+                if (term.termType === "NamedNode" || term.termType === "BlankNode") {
+                    const targetId = term.value;
+                    if (hiddenSubjects.has(targetId))
+                        continue;
+                    if (isEnumLikeRef(targetId)) {
+                        mergeNodeValue(node.data, predicate, targetId);
+                        continue;
+                    }
+                    createOrGetNodeAccumulator(nodeData, connectionCounts, targetId);
+                    connectionCounts.set(subjectId, (connectionCounts.get(subjectId) || 0) + 1);
+                    connectionCounts.set(targetId, (connectionCounts.get(targetId) || 0) + 1);
+                    edges.push({
+                        source: subjectId,
+                        target: targetId,
+                        id: `${subjectId}-${predicate}-${targetId}`,
+                        label: humanizePredicateName(predicate),
+                    });
+                    continue;
+                }
+                if (term.termType === "Literal") {
+                    mergeNodeValue(node.data, predicate, term.value);
+                }
+            }
+        }
+    }
+    return buildNodesAndEdges(nodeData, connectionCounts, edges, direction);
+}
+export function rdfGraphToSummaryNodesAndEdges(graph, direction = "LR") {
+    const detailed = rdfGraphToNodesAndEdges(graph, "subject", direction);
+    if (detailed.nodes.length === 0) {
+        return { nodes: [], edges: [], parentChildMap: new Map() };
+    }
+    const typeGroups = new Map();
+    const nodeTypeMap = new Map();
+    for (const node of detailed.nodes) {
+        const primaryType = node.data.type ?? "unknown";
+        nodeTypeMap.set(node.id, primaryType);
+        let group = typeGroups.get(primaryType);
+        if (!group) {
+            group = { count: 0, nodes: [] };
+            typeGroups.set(primaryType, group);
+        }
+        group.count++;
+        group.nodes.push(node);
+    }
+    const typeEdges = new Map();
+    for (const edge of detailed.edges) {
+        const sourceType = nodeTypeMap.get(edge.source);
+        const targetType = nodeTypeMap.get(edge.target);
+        if (!sourceType || !targetType || sourceType === targetType)
+            continue;
+        const edgeKey = `${sourceType}-->${targetType}`;
+        let edgeData = typeEdges.get(edgeKey);
+        if (!edgeData) {
+            edgeData = { source: sourceType, target: targetType, count: 0, labels: new Set() };
+            typeEdges.set(edgeKey, edgeData);
+        }
+        edgeData.count++;
+        const label = typeof edge.data?.label === "string" ? edge.data.label : typeof edge.label === "string" ? edge.label : "";
+        if (label) {
+            edgeData.labels.add(label.replace(/\s+\(x\d+\)$/, ""));
+        }
+    }
+    const chainNodeIds = findRepresentativeChainNodeIds(detailed.nodes, detailed.edges);
+    const chainTypes = new Set();
+    for (const nodeId of chainNodeIds) {
+        const type = nodeTypeMap.get(nodeId);
+        if (type) {
+            chainTypes.add(type);
+        }
+    }
+    const summaryNodes = Array.from(typeGroups).map(([type, group]) => {
+        const prioritizedInstances = [
+            ...group.nodes.filter((node) => chainNodeIds.has(node.id)),
+            ...group.nodes.filter((node) => !chainNodeIds.has(node.id)),
+        ];
+        const allInstances = prioritizedInstances.map((node) => ({
+            id: node.id,
+            label: node.data.label,
+            type,
+            properties: node.data.properties,
+        }));
+        const sampleInstances = allInstances.slice(0, 3).map((instance) => ({
+            ...instance,
+            properties: instance.properties.slice(0, 2),
+        }));
+        return {
+            id: type,
+            type: "typeSummaryNode",
+            position: { x: 0, y: 0 },
+            data: {
+                label: `${group.count} ${shortenUri(type)
+                    .replace(/^[:#]/, "")
+                    .replace(/([a-z])([A-Z])/g, "$1 $2")}`,
+                type,
+                connectionCount: group.count,
+                isHub: false,
+                jsonLd: { "@type": type, count: group.count },
+                properties: [],
+                childIds: [],
+                parentId: undefined,
+                isCollapsed: false,
+                hasChildren: false,
+                depth: 0,
+                sampleInstances,
+                allInstances,
+                isInEgoChain: chainTypes.has(type),
+            },
+        };
+    });
+    const summaryEdges = Array.from(typeEdges.values()).map((edgeData) => {
+        const label = Array.from(edgeData.labels).slice(0, 2).join(", ");
+        const relationshipType = detectRelationshipType(edgeData.source, edgeData.target);
+        const markerColor = mantaLightTheme.edge.relationship[relationshipType];
+        const edgeLabel = edgeData.count > 1 ? `${label} (x${edgeData.count})` : label;
+        return {
+            id: `${edgeData.source}-->${edgeData.target}`,
+            source: edgeData.source,
+            target: edgeData.target,
+            type: "labeledEdge",
+            animated: false,
+            label: edgeLabel,
+            data: {
+                label: edgeLabel,
+                relationshipType,
+                edgeIndex: 0,
+                edgeSiblingCount: 1,
+            },
+            markerEnd: { type: "arrowclosed", color: markerColor, width: 20, height: 20 },
+        };
+    });
+    computeEdgeSiblingIndices(summaryEdges);
+    const layoutedNodes = applyDagreLayout(summaryNodes, summaryEdges, direction, {
+        nodeDimensions: { width: 420, height: 340 },
+        ranksep: 250,
+        nodesep: 120,
+    });
+    return { nodes: layoutedNodes, edges: summaryEdges, parentChildMap: new Map() };
+}

package/dist/graph/graph-state.d.ts

@@ -0,0 +1,10 @@
+import type { LayoutDirection } from "./types.js";
+export type GraphViewMode = "graph" | "list";
+export type ContextMenuState = {
+    nodeId: string;
+    nodeLabel: string;
+    x: number;
+    y: number;
+};
+export type { LayoutDirection };
+//# sourceMappingURL=graph-state.d.ts.map

package/dist/graph/graph-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-state.d.ts","sourceRoot":"","sources":["../../src/graph/graph-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;AAE7C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,YAAY,EAAE,eAAe,EAAE,CAAC"}

package/dist/graph/graph-state.js

@@ -0,0 +1 @@
+export {};

package/dist/graph/graph-store.d.ts

@@ -0,0 +1,38 @@
+import { type RdfGraph } from "../lib/rdf-helpers.js";
+import type { ContextMenuState, GraphViewMode, LayoutDirection } from "./graph-state.js";
+import type { RDFNodeData } from "./types.js";
+export type GraphState = {
+    isGraphReady: boolean;
+    isSummaryView: boolean;
+    viewMode: GraphViewMode;
+    layoutDirection: LayoutDirection;
+    hasInitializedListCollapse: boolean;
+    selectedNode: RDFNodeData | undefined;
+    collapsedNodeIds: Set<string>;
+    contextMenu: ContextMenuState | undefined;
+    mergedGraph: RdfGraph;
+    graphVersion: number;
+    listPage: number;
+};
+export type GraphActions = {
+    setIsGraphReady: (ready: boolean) => void;
+    toggleSummaryView: () => void;
+    setSummaryView: (isSummaryView: boolean) => void;
+    toggleViewMode: () => void;
+    setViewMode: (viewMode: GraphViewMode) => void;
+    setHasInitializedListCollapse: (initialized: boolean) => void;
+    toggleLayoutDirection: () => void;
+    setSelectedNode: (node: RDFNodeData | undefined) => void;
+    toggleCollapsedNode: (nodeId: string) => void;
+    setCollapsedNodeIds: (updater: Set<string> | ((prev: Set<string>) => Set<string>)) => void;
+    setListPage: (page: number) => void;
+    setContextMenu: (menu: ContextMenuState | undefined) => void;
+    resetForNewGraph: (graph: RdfGraph) => void;
+    mergeGraph: (newGraph: RdfGraph) => void;
+};
+export type GraphStore = GraphState & GraphActions;
+export type CreateGraphStoreOptions = {
+    defaultViewMode?: GraphViewMode;
+};
+export declare function createGraphStore(initialGraph: RdfGraph, options?: CreateGraphStoreOptions): import("zustand").StoreApi<GraphStore>;
+//# sourceMappingURL=graph-store.d.ts.map

package/dist/graph/graph-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-store.d.ts","sourceRoot":"","sources":["../../src/graph/graph-store.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACtF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,aAAa,CAAC;IACxB,eAAe,EAAE,eAAe,CAAC;IACjC,0BAA0B,EAAE,OAAO,CAAC;IACpC,YAAY,EAAE,WAAW,GAAG,SAAS,CAAC;IACtC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,WAAW,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC1C,WAAW,EAAE,QAAQ,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,eAAe,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,cAAc,EAAE,CAAC,aAAa,EAAE,OAAO,KAAK,IAAI,CAAC;IACjD,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,WAAW,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;IAC/C,6BAA6B,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK,IAAI,CAAC;IAC9D,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC,eAAe,EAAE,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,KAAK,IAAI,CAAC;IACzD,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,mBAAmB,EAAE,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,CAAC;IAC3F,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,cAAc,EAAE,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,KAAK,IAAI,CAAC;IAC7D,gBAAgB,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC5C,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,YAAY,CAAC;AAEnD,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,QAAQ,EAAE,OAAO,GAAE,uBAA4B,0CAqG7F"}

package/dist/graph/graph-store.js

@@ -0,0 +1,79 @@
+import { createStore } from "zustand";
+import { mergeRdfGraphs } from "../lib/rdf-helpers.js";
+export function createGraphStore(initialGraph, options = {}) {
+    const { defaultViewMode = "list" } = options;
+    return createStore()((set) => ({
+        isGraphReady: false,
+        isSummaryView: false,
+        viewMode: defaultViewMode,
+        layoutDirection: "LR",
+        hasInitializedListCollapse: false,
+        selectedNode: undefined,
+        collapsedNodeIds: new Set(),
+        contextMenu: undefined,
+        mergedGraph: initialGraph,
+        graphVersion: 0,
+        listPage: 1,
+        setIsGraphReady: (ready) => set({ isGraphReady: ready }),
+        toggleSummaryView: () => set((state) => ({
+            isGraphReady: false,
+            isSummaryView: !state.isSummaryView,
+            graphVersion: state.graphVersion + 1,
+        })),
+        setSummaryView: (isSummaryView) => set((state) => ({
+            isGraphReady: false,
+            isSummaryView,
+            graphVersion: state.graphVersion + 1,
+        })),
+        toggleViewMode: () => set((state) => ({
+            viewMode: state.viewMode === "graph" ? "list" : "graph",
+            listPage: 1,
+        })),
+        setViewMode: (viewMode) => set({
+            viewMode,
+            listPage: 1,
+        }),
+        setHasInitializedListCollapse: (initialized) => set({
+            hasInitializedListCollapse: initialized,
+        }),
+        toggleLayoutDirection: () => set((state) => ({
+            layoutDirection: state.layoutDirection === "LR" ? "TB" : "LR",
+        })),
+        setSelectedNode: (node) => set({ selectedNode: node }),
+        toggleCollapsedNode: (nodeId) => set((state) => {
+            const next = new Set(state.collapsedNodeIds);
+            if (next.has(nodeId)) {
+                next.delete(nodeId);
+            }
+            else {
+                next.add(nodeId);
+            }
+            return { collapsedNodeIds: next };
+        }),
+        setCollapsedNodeIds: (updater) => set((state) => ({
+            collapsedNodeIds: typeof updater === "function" ? updater(state.collapsedNodeIds) : updater,
+            listPage: 1,
+        })),
+        setListPage: (page) => set({
+            listPage: Math.max(1, page),
+        }),
+        setContextMenu: (menu) => set({ contextMenu: menu }),
+        resetForNewGraph: (graph) => set({
+            mergedGraph: graph,
+            isSummaryView: false,
+            viewMode: defaultViewMode,
+            hasInitializedListCollapse: false,
+            collapsedNodeIds: new Set(),
+            selectedNode: undefined,
+            contextMenu: undefined,
+            listPage: 1,
+        }),
+        mergeGraph: (newGraph) => set((state) => ({
+            isGraphReady: false,
+            mergedGraph: mergeRdfGraphs([state.mergedGraph, newGraph]),
+            graphVersion: state.graphVersion + 1,
+            hasInitializedListCollapse: false,
+            listPage: 1,
+        })),
+    }));
+}

package/dist/graph/graph-utils.d.ts

@@ -0,0 +1,25 @@
+import type { Edge } from "@xyflow/react";
+import type { RdfGraph } from "../lib/rdf-helpers.js";
+import type { RelationshipType } from "./themes.js";
+import type { RDFNode } from "./types.js";
+export type RDFEdgeData = {
+    label: string;
+    relationshipType: RelationshipType;
+    edgeIndex: number;
+    edgeSiblingCount: number;
+};
+export type RDFEdge = Edge<RDFEdgeData>;
+export type NodesAndEdges = {
+    nodes: RDFNode[];
+    edges: RDFEdge[];
+    parentChildMap: Map<string, string[]>;
+};
+export declare function shortenUri(uri: string): string;
+export declare function humanizePredicateName(predicate: string): string;
+export declare function getAllDescendants(nodeId: string, parentChildMap: Map<string, string[]>): Set<string>;
+export declare function filterVisibleNodesAndEdges(nodes: RDFNode[], edges: RDFEdge[], collapsedNodeIds: Set<string>, parentChildMap: Map<string, string[]>): {
+    nodes: RDFNode[];
+    edges: RDFEdge[];
+};
+export declare function serializeRdfGraph(graph: RdfGraph): Record<string, Record<string, unknown[]>>;
+//# sourceMappingURL=graph-utils.d.ts.map

package/dist/graph/graph-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-utils.d.ts","sourceRoot":"","sources":["../../src/graph/graph-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvC,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;AAExC,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACvC,CAAC;AAEF,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA6B9C;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAU/D;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAcpG;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,EAAE,EAChB,KAAK,EAAE,OAAO,EAAE,EAChB,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,EAC7B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACpC;IAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAAC,KAAK,EAAE,OAAO,EAAE,CAAA;CAAE,CA6BxC;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,CAmB5F"}