@manta-eu/react 0.1.0

package/dist/routes/data-explorer/class-properties.js

@@ -0,0 +1,136 @@
+import { ontologyGraphIri, shaclGraphIri } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { groupBy, prop, uniq, uniqBy } from "ramda";
+import { useMemo } from "react";
+import { commentBinding } from "./classes.js";
+import { prefixes, safeIri } from "./namespaces.js";
+import { bindingCount, bindingValue, useSparqlSelect } from "#ldo-ui";
+const df = new DataFactory();
+function classPropertiesQuery(classIri) {
+    return `${prefixes}${SELECT.DISTINCT `?property ?label ?comment ?unitCode`.WHERE `
+  GRAPH ${df.namedNode(ontologyGraphIri)} {
+    ?property schema:domainIncludes ${df.namedNode(safeIri(classIri))} .
+    OPTIONAL { ?property rdfs:label ?label }
+    OPTIONAL { ?property rdfs:comment ?comment }
+    OPTIONAL { ?property schema:unitCode ?unitCode }
+  }
+`.build()}`;
+}
+function shapeConstraintsQuery(classIri) {
+    return `${prefixes}${SELECT `?path ?minCount ?allowedValue`.WHERE `
+  VALUES ?shapeGraph { ${df.namedNode(ontologyGraphIri)} ${df.namedNode(shaclGraphIri)} }
+  GRAPH ?shapeGraph {
+    ?shape sh:targetClass ${df.namedNode(safeIri(classIri))} ; sh:property ?propertyShape .
+    ?propertyShape sh:path ?path .
+    OPTIONAL { ?propertyShape sh:minCount ?minCount }
+    OPTIONAL { ?propertyShape sh:in ?list . ?list rdf:rest*/rdf:first ?allowedValue }
+  }
+`.build()}`;
+}
+function observedPropertiesQuery(anchor) {
+    return `${prefixes}SELECT ?property (COUNT(DISTINCT ?s) AS ?count) (SAMPLE(?value) AS ?example) WHERE {
+  ${anchor} ?s ?property ?value .
+  FILTER(?property != rdf:type)
+} GROUP BY ?property`;
+}
+export function useObservedProperties(anchor) {
+    const { data, isLoading, error } = useSparqlSelect({
+        query: anchor ? observedPropertiesQuery(anchor) : "",
+        queryKey: ["data-explorer", "observed-properties", anchor ?? ""],
+        enabled: isPresent(anchor),
+    });
+    const observed = useMemo(() => (data ?? []).flatMap((binding) => {
+        const iri = bindingValue(binding, "property");
+        const count = bindingCount(binding, "count");
+        const exampleTerm = binding.get("example");
+        const example = exampleTerm?.termType === "Literal" ? exampleTerm.value : undefined;
+        const exampleDatatype = exampleTerm?.termType === "Literal" ? exampleTerm.datatype.value : undefined;
+        return iri && count !== undefined ? [{ iri, count, example, exampleDatatype }] : [];
+    }), [data]);
+    return { observed, isLoading, error };
+}
+export function useClassProperties(classIri) {
+    const enabled = isPresent(classIri);
+    const propertiesResult = useSparqlSelect({
+        query: classIri ? classPropertiesQuery(classIri) : "",
+        queryKey: ["data-explorer", "class-properties", classIri ?? ""],
+        enabled,
+    });
+    const constraintsResult = useSparqlSelect({
+        query: classIri ? shapeConstraintsQuery(classIri) : "",
+        queryKey: ["data-explorer", "shape-constraints", classIri ?? ""],
+        enabled,
+    });
+    const properties = useMemo(() => {
+        const constraintRows = (constraintsResult.data ?? []).flatMap((binding) => {
+            const path = bindingValue(binding, "path");
+            return path
+                ? [{ path, minCount: bindingValue(binding, "minCount"), allowedValue: bindingValue(binding, "allowedValue") }]
+                : [];
+        });
+        const constraintsByPath = new Map(Object.entries(groupBy(prop("path"), constraintRows)).map(([path, rows = []]) => [
+            path,
+            {
+                required: rows.some((row) => Number.parseInt(row.minCount ?? "", 10) >= 1),
+                allowedValues: uniq(rows.flatMap((row) => (row.allowedValue ? [row.allowedValue] : []))),
+            },
+        ]));
+        const declared = uniqBy(prop("iri"), (propertiesResult.data ?? []).flatMap((binding) => {
+            const iri = bindingValue(binding, "property");
+            return iri
+                ? [
+                    {
+                        iri,
+                        label: bindingValue(binding, "label"),
+                        comment: commentBinding(binding),
+                        unitCode: bindingValue(binding, "unitCode"),
+                    },
+                ]
+                : [];
+        }));
+        const declaredIris = new Set(declared.map((property) => property.iri));
+        const declaredWithConstraints = declared.map((property) => ({
+            ...property,
+            required: constraintsByPath.get(property.iri)?.required ?? false,
+            allowedValues: constraintsByPath.get(property.iri)?.allowedValues ?? [],
+        }));
+        const constraintOnly = Array.from(constraintsByPath)
+            .filter(([path]) => !declaredIris.has(path))
+            .map(([path, constraint]) => ({ iri: path, ...constraint }));
+        const merged = [...declaredWithConstraints, ...constraintOnly];
+        return merged.sort((a, b) => (a.label ?? a.iri).localeCompare(b.label ?? b.iri));
+    }, [propertiesResult.data, constraintsResult.data]);
+    return {
+        properties,
+        isLoading: propertiesResult.isLoading || constraintsResult.isLoading,
+        error: propertiesResult.error ?? constraintsResult.error,
+    };
+}
+export function mergeDeclaredAndObserved(declared, observed, relationPredicateIris = new Set()) {
+    const declaredIris = new Set(declared.map((property) => property.iri));
+    const observedByIri = new Map(observed.map((entry) => [entry.iri, entry]));
+    const declaredMerged = declared.map((property) => ({
+        ...property,
+        declared: true,
+        observed: observedByIri.has(property.iri),
+        usageCount: observedByIri.get(property.iri)?.count,
+        example: observedByIri.get(property.iri)?.example,
+        exampleDatatype: observedByIri.get(property.iri)?.exampleDatatype,
+    }));
+    const observedOnly = observed
+        .filter((entry) => !declaredIris.has(entry.iri))
+        .map((entry) => ({
+        iri: entry.iri,
+        required: false,
+        allowedValues: [],
+        declared: false,
+        observed: true,
+        usageCount: entry.count,
+        example: entry.example,
+        exampleDatatype: entry.exampleDatatype,
+    }));
+    const merged = [...declaredMerged, ...observedOnly].filter((property) => !relationPredicateIris.has(property.iri));
+    return merged.sort((a, b) => (a.label ?? a.iri).localeCompare(b.label ?? b.iri));
+}

package/dist/routes/data-explorer/class-relations.d.ts

@@ -0,0 +1,24 @@
+export type RelatedClass = {
+    iri: string;
+    prefix: string;
+    localName: string;
+    label?: string;
+};
+export type ClassRelation = {
+    predicate: string;
+    otherClassIri: string;
+    count: number;
+};
+export declare function useClassRelations(classIri: string | undefined): {
+    outgoing: ClassRelation[];
+    incoming: ClassRelation[];
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useRelatedClasses(classIri: string | undefined): {
+    isLoading: boolean;
+    error: Error | null;
+    parents: RelatedClass[];
+    children: RelatedClass[];
+};
+//# sourceMappingURL=class-relations.d.ts.map

package/dist/routes/data-explorer/class-relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-relations.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/class-relations.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,YAAY,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9F,MAAM,MAAM,aAAa,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AA2BxF,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS;;;;;EAe7D;AAgBD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS;;;;;EAgC7D"}

package/dist/routes/data-explorer/class-relations.js

@@ -0,0 +1,74 @@
+import { ontologyGraphIri } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { uniqBy } from "ramda";
+import { useMemo } from "react";
+import { classRef, prefixes, safeIri } from "./namespaces.js";
+import { bindingCount, bindingValue, useSparqlSelect } from "#ldo-ui";
+const df = new DataFactory();
+function classRelationsQuery(classIri) {
+    const node = df.namedNode(safeIri(classIri));
+    return `${prefixes}${SELECT `?property ?otherType ?direction (COUNT(*) AS ?count)`.WHERE `
+  { ?s a ${node} ; ?property ?o . ?o a ?otherType . BIND("outgoing" AS ?direction) }
+  UNION
+  { ?s a ?otherType ; ?property ?o . ?o a ${node} . BIND("incoming" AS ?direction) }
+  FILTER(?property != rdf:type)
+`.GROUP_BY `?property ?otherType ?direction`.build()}`;
+}
+function relationsFromBindings(bindings, direction) {
+    return bindings
+        .flatMap((binding) => {
+        const predicate = bindingValue(binding, "property");
+        const otherClassIri = bindingValue(binding, "otherType");
+        const count = bindingCount(binding, "count");
+        if (bindingValue(binding, "direction") !== direction)
+            return [];
+        return predicate && otherClassIri && count !== undefined ? [{ predicate, otherClassIri, count }] : [];
+    })
+        .sort((a, b) => b.count - a.count || a.predicate.localeCompare(b.predicate));
+}
+export function useClassRelations(classIri) {
+    const { data: bindings, isLoading, error, } = useSparqlSelect({
+        query: classIri ? classRelationsQuery(classIri) : "",
+        queryKey: ["data-explorer", "class-relations", classIri ?? ""],
+        enabled: isPresent(classIri),
+    });
+    const outgoing = useMemo(() => relationsFromBindings(bindings ?? [], "outgoing"), [bindings]);
+    const incoming = useMemo(() => relationsFromBindings(bindings ?? [], "incoming"), [bindings]);
+    return { outgoing, incoming, isLoading, error };
+}
+function relatedClassesQuery(classIri) {
+    const node = df.namedNode(safeIri(classIri));
+    return `${prefixes}${SELECT `?rel ?label ?direction`.WHERE `
+  GRAPH ${df.namedNode(ontologyGraphIri)} {
+    { ${node} rdfs:subClassOf ?rel . BIND("parent" AS ?direction) }
+    UNION
+    { ?rel rdfs:subClassOf ${node} . BIND("child" AS ?direction) }
+    OPTIONAL { ?rel rdfs:label ?label }
+    FILTER(isIRI(?rel))
+  }
+`.build()}`;
+}
+export function useRelatedClasses(classIri) {
+    const { data: bindings, isLoading, error, } = useSparqlSelect({
+        query: classIri ? relatedClassesQuery(classIri) : "",
+        queryKey: ["data-explorer", "related-classes", classIri ?? ""],
+        enabled: isPresent(classIri),
+    });
+    const related = useMemo(() => {
+        const rows = (bindings ?? []).flatMap((binding) => {
+            const iri = bindingValue(binding, "rel");
+            const direction = bindingValue(binding, "direction");
+            const base = iri ? classRef(iri) : undefined;
+            return base && direction ? [{ ...base, label: bindingValue(binding, "label"), direction }] : [];
+        });
+        const unique = uniqBy((row) => `${row.direction}:${row.iri}`, rows);
+        const sortByLabel = (list) => [...list].sort((a, b) => (a.label ?? a.localName).localeCompare(b.label ?? b.localName));
+        return {
+            parents: sortByLabel(unique.filter((row) => row.direction === "parent")),
+            children: sortByLabel(unique.filter((row) => row.direction === "child")),
+        };
+    }, [bindings]);
+    return { ...related, isLoading, error };
+}

package/dist/routes/data-explorer/classes.d.ts

@@ -0,0 +1,36 @@
+import { type RDF } from "ldkit/rdf";
+export type ExplorerClass = {
+    iri: string;
+    prefix: string;
+    localName: string;
+    label?: string;
+    comment?: string;
+};
+export declare function commentBinding(binding: RDF.Bindings): string | undefined;
+export declare function useExplorerClasses(): {
+    classes: ExplorerClass[];
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useInstanceCounts(): {
+    counts: Map<string, number>;
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useSubclassEdges(): Map<string, string[]>;
+export type ClassNode = ExplorerClass & {
+    children: ClassNode[];
+};
+export type ClassGroup = {
+    group: string;
+    label: string;
+    tree: ClassNode[];
+    classCount: number;
+    records: number;
+};
+export declare function classesFromCounts(classes: ExplorerClass[], counts: Map<string, number>): ExplorerClass[];
+export declare function totalRecords(counts: Map<string, number>, classes: ExplorerClass[]): number;
+export declare function classesInNamespace(classes: ExplorerClass[], counts: Map<string, number>, prefix: string): ExplorerClass[];
+export declare function subclassTree(classes: ExplorerClass[], parentByChild: Map<string, string[]>, counts: Map<string, number>): ClassNode[];
+export declare function buildClassGroups(classes: ExplorerClass[], filter: string, counts: Map<string, number>, parentByChild: Map<string, string[]>): ClassGroup[];
+//# sourceMappingURL=classes.d.ts.map

package/dist/routes/data-explorer/classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classes.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/classes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AASlD,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,GAAG,CAAC,QAAQ,GAAG,MAAM,GAAG,SAAS,CAExE;AAsBD,wBAAgB,kBAAkB;;;;EAiCjC;AAID,wBAAgB,iBAAiB;;;;EAwBhC;AASD,wBAAgB,gBAAgB,0BAoB/B;AAED,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG;IAAE,QAAQ,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC;AAElE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAYF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,aAAa,EAAE,CAcxG;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,MAAM,CAE1F;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EAAE,EACxB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,MAAM,EAAE,MAAM,GACb,aAAa,EAAE,CAIjB;AAMD,wBAAgB,YAAY,CAC1B,OAAO,EAAE,aAAa,EAAE,EACxB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACpC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1B,SAAS,EAAE,CAab;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,aAAa,EAAE,EACxB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACnC,UAAU,EAAE,CAsBd"}

package/dist/routes/data-explorer/classes.js

@@ -0,0 +1,150 @@
+import { ontologyGraphIri, shaclGraphIri } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { groupBy, sum, uniq, uniqBy, prop } from "ramda";
+import { useMemo } from "react";
+import { groupKeyFor, localName, namespaceLabel, prefixForIri, prefixes } from "./namespaces.js";
+import { bindingCount, bindingValue, cleanOntologyComment, useSparqlSelect } from "#ldo-ui";
+const df = new DataFactory();
+export function commentBinding(binding) {
+    return cleanOntologyComment(bindingValue(binding, "comment"));
+}
+const classesQuery = `${prefixes}${SELECT.DISTINCT `?class ?label ?comment`.WHERE `
+  {
+    GRAPH ${df.namedNode(ontologyGraphIri)} {
+      { ?class a rdfs:Class }
+      UNION { ?class a owl:Class }
+      UNION { ?p schema:domainIncludes ?class }
+      UNION { ?shape sh:targetClass ?class }
+      UNION { ?class rdfs:subClassOf ?parent }
+      UNION { ?child rdfs:subClassOf ?class }
+    }
+  }
+  UNION {
+    GRAPH ${df.namedNode(shaclGraphIri)} { ?shapeInShaclGraph sh:targetClass ?class }
+  }
+  OPTIONAL { GRAPH ${df.namedNode(ontologyGraphIri)} { ?class rdfs:label ?label } }
+  OPTIONAL { GRAPH ${df.namedNode(ontologyGraphIri)} { ?class rdfs:comment ?comment } }
+  FILTER NOT EXISTS { GRAPH ${df.namedNode(ontologyGraphIri)} { ?class a sh:NodeShape } }
+  FILTER(isIRI(?class))
+`.build()}`;
+export function useExplorerClasses() {
+    const { data: bindings, isLoading, error, } = useSparqlSelect({ query: classesQuery, queryKey: ["data-explorer", "classes"] });
+    const classes = useMemo(() => {
+        const rows = (bindings ?? []).flatMap((binding) => {
+            const iri = bindingValue(binding, "class");
+            const prefix = iri ? prefixForIri(iri) : undefined;
+            if (!iri || !prefix)
+                return [];
+            const name = localName(iri, prefix);
+            if (!name)
+                return [];
+            return [
+                {
+                    iri,
+                    prefix,
+                    localName: name,
+                    label: bindingValue(binding, "label"),
+                    comment: commentBinding(binding),
+                },
+            ];
+        });
+        return uniqBy(prop("iri"), rows).sort((a, b) => (a.label ?? a.localName).localeCompare(b.label ?? b.localName));
+    }, [bindings]);
+    return { classes, isLoading, error };
+}
+const instanceCountsQuery = SELECT `?type (COUNT(?s) AS ?count)`.WHERE `?s a ?type`.GROUP_BY `?type`.build();
+export function useInstanceCounts() {
+    const { data: bindings, isLoading, error, } = useSparqlSelect({
+        query: instanceCountsQuery,
+        queryKey: ["data-explorer", "instance-counts"],
+    });
+    const counts = useMemo(() => new Map((bindings ?? []).flatMap((binding) => {
+        const iri = bindingValue(binding, "type");
+        const count = bindingCount(binding, "count");
+        return iri && count !== undefined ? [[iri, count]] : [];
+    })), [bindings]);
+    return { counts, isLoading, error };
+}
+const subclassEdgesQuery = `${prefixes}${SELECT `?child ?parent`.WHERE `
+  GRAPH ${df.namedNode(ontologyGraphIri)} {
+    ?child rdfs:subClassOf ?parent .
+    FILTER(isIRI(?child) && isIRI(?parent))
+  }
+`.build()}`;
+export function useSubclassEdges() {
+    const { data: bindings } = useSparqlSelect({
+        query: subclassEdgesQuery,
+        queryKey: ["data-explorer", "subclass-edges"],
+    });
+    return useMemo(() => {
+        const edges = (bindings ?? []).flatMap((binding) => {
+            const child = bindingValue(binding, "child");
+            const parent = bindingValue(binding, "parent");
+            return child && parent ? [{ child, parent }] : [];
+        });
+        const byChild = groupBy((edge) => edge.child, edges);
+        return new Map(Object.entries(byChild).map(([child, es = []]) => [child, uniq(es.map((edge) => edge.parent))]));
+    }, [bindings]);
+}
+function recordCount(counts, entry) {
+    return counts.get(entry.iri) ?? 0;
+}
+function compareByRecordThenLabel(a, b, counts) {
+    return (recordCount(counts, b) - recordCount(counts, a) || (a.label ?? a.localName).localeCompare(b.label ?? b.localName));
+}
+export function classesFromCounts(classes, counts) {
+    const known = new Set(classes.map((entry) => entry.iri));
+    return [...counts.keys()]
+        .filter((iri) => !known.has(iri))
+        .flatMap((iri) => {
+        const prefix = prefixForIri(iri);
+        if (!prefix)
+            return [];
+        const name = localName(iri, prefix);
+        return name ? [{ iri, prefix, localName: name }] : [];
+    });
+}
+export function totalRecords(counts, classes) {
+    return sum(classes.map((entry) => recordCount(counts, entry)));
+}
+export function classesInNamespace(classes, counts, prefix) {
+    return [...classes, ...classesFromCounts(classes, counts)]
+        .filter((entry) => groupKeyFor(entry.prefix) === prefix)
+        .sort((a, b) => compareByRecordThenLabel(a, b, counts));
+}
+function matchesQuery(entry, query, groupLabel) {
+    return !query || `${entry.label ?? ""} ${entry.localName} ${groupLabel}`.toLowerCase().includes(query);
+}
+export function subclassTree(classes, parentByChild, counts) {
+    const inGroup = new Set(classes.map((entry) => entry.iri));
+    const parentOf = (entry) => (parentByChild.get(entry.iri) ?? []).find((parent) => parent !== entry.iri && inGroup.has(parent));
+    const byParent = groupBy((entry) => parentOf(entry) ?? "", classes);
+    const sorted = (list) => [...list].sort((a, b) => compareByRecordThenLabel(a, b, counts));
+    const toNode = (entry) => ({
+        ...entry,
+        children: sorted(byParent[entry.iri] ?? []).map(toNode),
+    });
+    return sorted(byParent[""] ?? []).map(toNode);
+}
+export function buildClassGroups(classes, filter, counts, parentByChild) {
+    const query = filter.trim().toLowerCase();
+    const matched = [...classes, ...classesFromCounts(classes, counts)].filter((entry) => matchesQuery(entry, query, namespaceLabel(groupKeyFor(entry.prefix))));
+    const byGroup = groupBy((entry) => groupKeyFor(entry.prefix), matched);
+    return Object.entries(byGroup)
+        .flatMap(([group, groupClasses = []]) => {
+        if (!isPresent(groupClasses))
+            return [];
+        return [
+            {
+                group,
+                label: namespaceLabel(group),
+                tree: subclassTree(groupClasses, parentByChild, counts),
+                classCount: groupClasses.length,
+                records: totalRecords(counts, groupClasses),
+            },
+        ];
+    })
+        .sort((a, b) => b.records - a.records || b.classCount - a.classCount);
+}

package/dist/routes/data-explorer/components/ArrowLink.d.ts

@@ -0,0 +1,3 @@
+export declare const arrowLinkClass = "inline-flex items-center gap-1 text-primary underline decoration-primary/30 underline-offset-2 transition-colors hover:decoration-primary";
+export declare function ArrowLinkIcon(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ArrowLink.d.ts.map

package/dist/routes/data-explorer/components/ArrowLink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArrowLink.d.ts","sourceRoot":"","sources":["../../../../src/routes/data-explorer/components/ArrowLink.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,8IACkH,CAAC;AAE9I,wBAAgB,aAAa,4CAE5B"}

package/dist/routes/data-explorer/components/ArrowLink.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ArrowUpRight } from "lucide-react";
+export const arrowLinkClass = "inline-flex items-center gap-1 text-primary underline decoration-primary/30 underline-offset-2 transition-colors hover:decoration-primary";
+export function ArrowLinkIcon() {
+    return _jsx(ArrowUpRight, { className: "size-3.5 shrink-0 text-primary/70" });
+}

package/dist/routes/data-explorer/components/Breadcrumbs.d.ts

@@ -0,0 +1,10 @@
+export type Crumb = {
+    label: string;
+    to?: string;
+};
+type BreadcrumbsProps = {
+    trail: Crumb[];
+};
+export declare function Breadcrumbs(props: BreadcrumbsProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=Breadcrumbs.d.ts.map

package/dist/routes/data-explorer/components/Breadcrumbs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Breadcrumbs.d.ts","sourceRoot":"","sources":["../../../../src/routes/data-explorer/components/Breadcrumbs.tsx"],"names":[],"mappings":"AAIA,MAAM,MAAM,KAAK,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnD,KAAK,gBAAgB,GAAG;IAAE,KAAK,EAAE,KAAK,EAAE,CAAA;CAAE,CAAC;AAE3C,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,2CAoBlD"}

package/dist/routes/data-explorer/components/Breadcrumbs.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ChevronRight } from "lucide-react";
+import { Fragment } from "react";
+import { Link } from "react-router";
+export function Breadcrumbs(props) {
+    const { trail } = props;
+    return (_jsx("nav", { className: "scrollbar-hide typography-small flex min-w-0 items-center gap-1.5 overflow-x-auto text-muted-foreground", children: trail.map((crumb, index) => (_jsxs(Fragment, { children: [index > 0 && _jsx(ChevronRight, { className: "size-3.5 shrink-0 text-muted-foreground/40" }), crumb.to ? (_jsx(Link, { to: crumb.to, className: "shrink-0 capitalize hover:text-default-foreground hover:underline", children: crumb.label })) : (_jsx("span", { className: "shrink-0 whitespace-nowrap text-default-foreground", children: crumb.label }))] }, `${index}:${crumb.label}`))) }));
+}

package/dist/routes/data-explorer/components/ClassTreeNodes.d.ts

@@ -0,0 +1,14 @@
+import type { ClassNode } from "../classes.js";
+type ClassTreeNodesProps = {
+    nodes: ClassNode[];
+    depth: number;
+    counts: Map<string, number>;
+    collapsed: ReadonlySet<string>;
+    forceOpen: boolean;
+    onToggle: (iri: string) => void;
+    selectedClassIri?: string;
+    selectedAncestors: ReadonlySet<string>;
+};
+export declare function ClassTreeNodes(props: ClassTreeNodesProps): import("react/jsx-runtime").JSX.Element[];
+export {};
+//# sourceMappingURL=ClassTreeNodes.d.ts.map

package/dist/routes/data-explorer/components/ClassTreeNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassTreeNodes.d.ts","sourceRoot":"","sources":["../../../../src/routes/data-explorer/components/ClassTreeNodes.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAO5C,KAAK,mBAAmB,GAAG;IACzB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/B,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACxC,CAAC;AAEF,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,6CAoExD"}

package/dist/routes/data-explorer/components/ClassTreeNodes.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { ChevronRight } from "lucide-react";
+import { Link } from "react-router";
+import { classPath } from "../namespaces.js";
+import { RailSelectionMarker } from "./RailSelectionMarker.js";
+import { railCountClass, railDisclosureClass, railRowClass, railRowLinkClass } from "./railStyles.js";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "#components/collapsible/index";
+import { cn } from "#lib/utils";
+export function ClassTreeNodes(props) {
+    const { nodes, depth, counts, collapsed, forceOpen, onToggle, selectedClassIri, selectedAncestors } = props;
+    return nodes.map((node) => {
+        const isSelected = node.iri === selectedClassIri;
+        const count = counts.get(node.iri);
+        const hasChildren = isPresent(node.children);
+        const forcedOpen = forceOpen || selectedAncestors.has(node.iri);
+        const isOpen = forcedOpen || !collapsed.has(node.iri);
+        const row = (_jsxs("div", { className: railRowClass(isSelected), style: { paddingLeft: `${0.75 + depth * 0.85}rem` }, children: [isSelected && _jsx(RailSelectionMarker, {}), hasChildren ? (_jsx(CollapsibleTrigger, { "aria-label": `${isOpen ? "Collapse" : "Expand"} ${node.label ?? node.localName}`, className: railDisclosureClass, children: _jsx(ChevronRight, { className: cn("size-3.5 text-muted-foreground/60 transition-transform", isOpen && "rotate-90") }) })) : (_jsx("span", { className: "size-5 shrink-0" })), _jsxs(Link, { to: classPath(node.prefix, node.localName), "data-selected": isSelected || undefined, "aria-current": isSelected ? "page" : undefined, className: cn(railRowLinkClass, "pl-1"), children: [_jsx("span", { className: cn("min-w-0 flex-1 truncate", isSelected && "typography-small-medium text-accent-foreground", !isSelected &&
+                                (count ? "typography-small text-default-foreground/80" : "typography-small text-muted-foreground")), children: node.label ?? node.localName }), !!count && _jsx("span", { className: railCountClass(isSelected), children: count.toLocaleString() })] })] }));
+        if (!hasChildren)
+            return _jsx("div", { children: row }, node.iri);
+        return (_jsxs(Collapsible, { open: isOpen, onOpenChange: () => forcedOpen || onToggle(node.iri), children: [row, _jsx(CollapsibleContent, { children: _jsx(ClassTreeNodes, { nodes: node.children, depth: depth + 1, counts: counts, collapsed: collapsed, forceOpen: forceOpen, onToggle: onToggle, selectedClassIri: selectedClassIri, selectedAncestors: selectedAncestors }) })] }, node.iri));
+    });
+}

package/dist/routes/data-explorer/components/CountLabel.d.ts

@@ -0,0 +1,8 @@
+type CountLabelProps = {
+    count?: number;
+    isFiltered?: boolean;
+    hasError?: boolean;
+};
+export declare function CountLabel(props: CountLabelProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=CountLabel.d.ts.map

package/dist/routes/data-explorer/components/CountLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CountLabel.d.ts","sourceRoot":"","sources":["../../../../src/routes/data-explorer/components/CountLabel.tsx"],"names":[],"mappings":"AAEA,KAAK,eAAe,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEpF,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CAOhD"}

package/dist/routes/data-explorer/components/CountLabel.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { humanCount } from "@manta-eu/lib/humanize";
+export function CountLabel(props) {
+    const { count, isFiltered, hasError } = props;
+    const fallback = hasError ? "n/a" : "…";
+    const label = count === undefined ? fallback : `${humanCount(count, "record")}${isFiltered ? " match" : ""}`;
+    return _jsx("p", { className: "typography-tiny text-muted-foreground", children: label });
+}

package/dist/routes/data-explorer/components/DataExplorerLayout.d.ts

@@ -0,0 +1,2 @@
+export declare function DataExplorerLayout(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DataExplorerLayout.d.ts.map

package/dist/routes/data-explorer/components/DataExplorerLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataExplorerLayout.d.ts","sourceRoot":"","sources":["../../../../src/routes/data-explorer/components/DataExplorerLayout.tsx"],"names":[],"mappings":"AA6BA,wBAAgB,kBAAkB,4CAuDjC"}

package/dist/routes/data-explorer/components/DataExplorerLayout.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useQueryClient } from "@tanstack/react-query";
+import { Database } from "lucide-react";
+import { useEffect } from "react";
+import { Outlet, useMatch } from "react-router";
+import { useDeclaredNamespaces } from "../declared-namespaces.js";
+import { useRailState } from "../hooks/useRailState.js";
+import { coveragePath, explorerPath } from "../namespaces.js";
+import { Rail } from "./Rail.js";
+import { RailSheet } from "./RailSheet.js";
+import { LoadingRows } from "./RawTriples.js";
+import { SelectionProvider } from "./SelectionProvider.js";
+import { PageBody, PageHeader } from "#components/layouts/page/index";
+import { RouteLayout } from "#components/layouts/RouteLayout";
+import { cn } from "#lib/utils";
+import { useAuthContext } from "#providers/AuthContext";
+const ontologyStaleTime = 5 * 60 * 1000;
+function useExplorerQueryDefaults() {
+    const queryClient = useQueryClient();
+    useEffect(() => {
+        queryClient.setQueryDefaults(["data-explorer"], {
+            staleTime: ontologyStaleTime,
+            refetchOnWindowFocus: false,
+        });
+    }, [queryClient]);
+}
+export function DataExplorerLayout() {
+    const { datastore, datastores, user, logout, isOperator, canSwitchDatastore } = useAuthContext();
+    const isIndex = Boolean(useMatch(explorerPath));
+    const isFullPage = Boolean(useMatch(coveragePath));
+    const railState = useRailState();
+    const { isLoading: isLoadingNamespaces } = useDeclaredNamespaces();
+    useExplorerQueryDefaults();
+    return (_jsx(RouteLayout, { user: user, datastore: datastore, datastores: datastores, isOperator: isOperator, canSwitchDatastore: canSwitchDatastore, logout: logout, children: _jsxs(SelectionProvider, { children: [_jsx(PageHeader, { title: "Data Explorer", icon: Database, actions: !isFullPage && !isIndex && _jsx(RailSheet, { state: railState }) }), _jsxs("div", { className: "flex min-h-0 flex-1", children: [isLoadingNamespaces && (_jsx("div", { className: "px-4 py-3 sm:px-6 sm:py-4", children: _jsx(LoadingRows, { rows: 8 }) })), !isLoadingNamespaces && !isFullPage && (_jsx(Rail, { state: railState, className: cn("shrink-0 border-muted-border md:w-72 md:border-r", isIndex ? "flex w-full" : "hidden md:flex") })), !isLoadingNamespaces && (_jsx(PageBody, { className: cn("min-w-0 p-0", isFullPage && "flex min-h-0 flex-col", isIndex && "max-md:hidden"), children: _jsx("div", { className: cn("px-4 py-3 sm:px-6 sm:py-4", isFullPage ? "flex min-h-0 flex-1 flex-col" : "max-w-5xl"), children: _jsx(Outlet, {}) }) }))] })] }) }));
+}

package/dist/routes/data-explorer/components/DetailHeader.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from "react";
+type TypeBadgeProps = {
+    color: string;
+    className?: string;
+    asChild?: boolean;
+    children: ReactNode;
+};
+export declare function TypeBadge(props: TypeBadgeProps): import("react/jsx-runtime").JSX.Element;
+type DetailHeaderProps = {
+    badges?: ReactNode;
+    titleBadges?: ReactNode;
+    actions?: ReactNode;
+    title: string;
+    iri?: string;
+    iriHref?: string;
+};
+export declare function DetailHeader(props: DetailHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=DetailHeader.d.ts.map

package/dist/routes/data-explorer/components/DetailHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DetailHeader.d.ts","sourceRoot":"","sources":["../../../../src/routes/data-explorer/components/DetailHeader.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAKvC,KAAK,cAAc,GAAG;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,2CAc9C;AAED,KAAK,iBAAiB,GAAG;IACvB,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CAiCpD"}

package/dist/routes/data-explorer/components/DetailHeader.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ArrowLinkIcon, arrowLinkClass } from "./ArrowLink.js";
+import { Badge } from "#components/badge/index";
+import { cn } from "#lib/utils";
+export function TypeBadge(props) {
+    const { color, className, asChild, children } = props;
+    return (_jsx(Badge, { variant: "secondary", size: "sm", style: { backgroundColor: `color-mix(in srgb, ${color} 15%, transparent)`, color }, className: className, asChild: asChild, children: children }));
+}
+export function DetailHeader(props) {
+    const { badges, titleBadges, actions, title, iri, iriHref } = props;
+    return (_jsxs("div", { children: [badges && _jsx("div", { className: "mb-3 flex items-center gap-2", children: badges }), _jsxs("div", { className: "flex items-start justify-between gap-4", children: [_jsxs("div", { className: "flex items-center gap-3", children: [_jsx("h2", { className: "typography-header wrap-break-words text-default-foreground", children: title }), titleBadges] }), actions && _jsx("div", { className: "flex shrink-0 items-center gap-2", children: actions })] }), iri &&
+                (iriHref ? (_jsxs("a", { href: iriHref, target: "_blank", rel: "noreferrer", className: cn("typography-tiny mt-1.5 break-all font-mono", arrowLinkClass), children: [iri, _jsx(ArrowLinkIcon, {})] })) : (_jsx("p", { className: "typography-tiny mt-1.5 break-all font-mono text-muted-foreground", children: iri })))] }));
+}

package/dist/routes/data-explorer/components/ExplorerEmptyState.d.ts

@@ -0,0 +1,2 @@
+export declare function ExplorerEmptyState(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ExplorerEmptyState.d.ts.map

package/dist/routes/data-explorer/components/ExplorerEmptyState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExplorerEmptyState.d.ts","sourceRoot":"","sources":["../../../../src/routes/data-explorer/components/ExplorerEmptyState.tsx"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,4CAajC"}