@manta-eu/react 0.1.0

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

@@ -0,0 +1,109 @@
+import { entityPath, entitySegment, explorerPath } from "@manta-eu/client/shared/explorer-paths";
+import { isFileIri } from "@manta-eu/client/shared/fileIri";
+import { compactUri, infrastructureNamespaces, labeledNamespaces, namespaces, validateFullIri, } from "@manta-eu/client/shared/rdf-namespaces";
+import { isQueryableTermIri } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+export const prefixes = `
+PREFIX rdf: <${namespaces.rdf}>
+PREFIX rdfs: <${namespaces.rdfs}>
+PREFIX schema: <${namespaces.schema}>
+PREFIX sh: <${namespaces.sh}>
+PREFIX dcterms: <${namespaces.dcterms}>
+PREFIX owl: <${namespaces.owl}>
+`;
+const explorerNamespaces = {
+    ...Object.fromEntries(Object.entries(namespaces)
+        .filter(([prefix, iri]) => !!iri && !infrastructureNamespaces.has(prefix))
+        .map(([prefix, iri]) => [prefix, { iri, label: prefix }])),
+    ...labeledNamespaces,
+};
+function longestNamespaceFirst(entries) {
+    return Object.entries(entries).sort(([, a], [, b]) => b.iri.length - a.iri.length);
+}
+let knownNamespaces = explorerNamespaces;
+let knownNamespaceEntries = longestNamespaceFirst(knownNamespaces);
+let declaredSources = {};
+const builtInIris = new Set(Object.values(explorerNamespaces).map((meta) => meta.iri));
+export function registerDeclaredNamespaces(declared) {
+    const unregistered = Object.fromEntries(Object.entries(declared).filter(([, meta]) => !builtInIris.has(meta.iri)));
+    knownNamespaces = { ...unregistered, ...explorerNamespaces };
+    knownNamespaceEntries = longestNamespaceFirst(knownNamespaces);
+    declaredSources = Object.fromEntries(Object.values(unregistered).flatMap((entry) => (entry.source ? [[entry.source.iri, entry.source]] : [])));
+}
+export function isDeclaredSource(key) {
+    return key in declaredSources;
+}
+export function groupKeyFor(prefix) {
+    return knownNamespaces[prefix]?.source?.iri ?? prefix;
+}
+const realmVocabRoot = namespaces[""].replace(/#$/, "/");
+export const allNamespacesLabel = "All namespaces";
+export function namespaceLabel(key) {
+    return knownNamespaces[key]?.label ?? declaredSources[key]?.label ?? compactUri(key).replace(/:$/, "");
+}
+export function namespaceIriFor(key) {
+    if (!key)
+        return undefined;
+    return knownNamespaces[key]?.iri ?? declaredSources[key]?.iri ?? `${realmVocabRoot}${key}#`;
+}
+export function prefixForIri(iri) {
+    const registered = knownNamespaceEntries.find(([, meta]) => iri.startsWith(meta.iri))?.[0];
+    if (registered)
+        return registered;
+    if (!iri.startsWith(realmVocabRoot))
+        return undefined;
+    const rest = iri.slice(realmVocabRoot.length);
+    const segment = rest.split(/[#/]/)[0];
+    return rest.startsWith(`${segment}#`) ? segment || undefined : undefined;
+}
+export function localName(iri, prefix) {
+    const base = namespaceIriFor(prefix);
+    return base && iri.startsWith(base) ? iri.slice(base.length) : "";
+}
+export { entityPath, entitySegment, explorerPath };
+export const recentSegment = "recent";
+export const coverageSegment = "coverage";
+export const recentPath = `${explorerPath}/${recentSegment}`;
+export const coveragePath = `${explorerPath}/${coverageSegment}`;
+export const explorerCrumb = { label: "Data", to: explorerPath };
+export function isExplorerPrefix(value) {
+    return isPresent(value) && !infrastructureNamespaces.has(value);
+}
+export function isNamespaceSegment(segment) {
+    return isPresent(segment) && ![recentSegment, coverageSegment, entitySegment].includes(segment);
+}
+export function namespacePath(key) {
+    return `${explorerPath}/${encodeURIComponent(key)}`;
+}
+export function groupCrumb(prefix) {
+    const group = groupKeyFor(prefix);
+    return { label: namespaceLabel(group), to: namespacePath(group) };
+}
+export function classPath(prefix, name) {
+    return `${explorerPath}/${prefix}/${name}`;
+}
+export function recordPath(prefix, type, id) {
+    return `${explorerPath}/${prefix}/${type}/${encodeURIComponent(id)}`;
+}
+export function classRef(iri) {
+    const prefix = prefixForIri(iri);
+    if (!prefix)
+        return undefined;
+    const name = localName(iri, prefix);
+    if (!name)
+        return undefined;
+    return { iri, prefix, localName: name, path: classPath(prefix, name) };
+}
+export function safeIri(iri) {
+    if (isFileIri(iri))
+        return iri;
+    validateFullIri(iri);
+    return iri;
+}
+export function classIriFor(prefix, name) {
+    const base = namespaceIriFor(prefix);
+    if (!base)
+        return undefined;
+    const iri = `${base}${name}`;
+    return isQueryableTermIri(iri) ? iri : undefined;
+}

package/dist/routes/data-explorer/paged-sparql.d.ts

@@ -0,0 +1,24 @@
+import type { SparqlBinding } from "@manta-eu/client/types/sparql-types";
+export declare function useSparqlCount(key: string, query: string, enabled: boolean): {
+    count: number | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+type PagedSparqlOptions<Row, Cursor> = {
+    queryKey: readonly unknown[];
+    enabled: boolean;
+    buildQuery: (after: Cursor | undefined) => string;
+    parseRow: (binding: SparqlBinding) => Row[];
+    cursorFromRow: (row: Row) => Cursor;
+};
+export declare function usePagedSparql<Row, Cursor>(options: PagedSparqlOptions<Row, Cursor>): {
+    rows: Row[];
+    isLoading: boolean;
+    isRefetching: boolean;
+    error: Error | null;
+    hasMore: boolean;
+    isLoadingMore: boolean;
+    loadMore: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<Row[], unknown>, Error>>;
+};
+export {};
+//# sourceMappingURL=paged-sparql.d.ts.map

package/dist/routes/data-explorer/paged-sparql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paged-sparql.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/paged-sparql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AASzE,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;;;;EAQ1E;AAED,KAAK,kBAAkB,CAAC,GAAG,EAAE,MAAM,IAAI;IACrC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,CAAC;IAClD,QAAQ,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,GAAG,EAAE,CAAC;IAC5C,aAAa,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC;CACrC,CAAC;AAEF,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,CAAC,GAAG,EAAE,MAAM,CAAC;;;;;;;;EAoCnF"}

package/dist/routes/data-explorer/paged-sparql.js

@@ -0,0 +1,45 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { keepPreviousData, useInfiniteQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+import { sparqlPageSize } from "./filter-query.js";
+import { postSparqlSelect } from "./sparql-client.js";
+import { bindingCount, useSparqlSelect } from "#ldo-ui";
+import { useMantaClient } from "#providers/index";
+export function useSparqlCount(key, query, enabled) {
+    const { data, isLoading, error } = useSparqlSelect({
+        query,
+        queryKey: ["data-explorer", key, query],
+        enabled: enabled && isPresent(query),
+    });
+    return { count: data?.[0] ? bindingCount(data[0], "n") : undefined, isLoading, error };
+}
+export function usePagedSparql(options) {
+    const { queryKey, enabled, buildQuery, parseRow, cursorFromRow } = options;
+    const { sparqlFetch } = useMantaClient();
+    const firstPageQuery = buildQuery(undefined);
+    const query = useInfiniteQuery({
+        queryKey: [...queryKey, firstPageQuery],
+        enabled: enabled && isPresent(firstPageQuery),
+        placeholderData: keepPreviousData,
+        // Tuple-wrapped page param: react-query types pageParam as unknown for a bare generic Cursor.
+        initialPageParam: undefined,
+        getNextPageParam: (lastPage) => {
+            const last = lastPage[lastPage.length - 1];
+            return lastPage.length === sparqlPageSize && last ? [cursorFromRow(last)] : undefined;
+        },
+        queryFn: async ({ pageParam, signal }) => {
+            const results = await postSparqlSelect(sparqlFetch, buildQuery(pageParam?.[0]), { signal });
+            return results.results.bindings.flatMap(parseRow);
+        },
+    });
+    const rows = useMemo(() => (query.data?.pages ?? []).flat(), [query.data]);
+    return {
+        rows,
+        isLoading: query.isLoading,
+        isRefetching: query.isPlaceholderData && query.isFetching,
+        error: query.error,
+        hasMore: query.hasNextPage && !query.isPlaceholderData,
+        isLoadingMore: query.isFetchingNextPage,
+        loadMore: query.fetchNextPage,
+    };
+}

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

@@ -0,0 +1,27 @@
+import { type ClassRef } from "./namespaces.js";
+export type ModifiedLabels = {
+    relative: string;
+    absolute: string;
+};
+export declare function modifiedLabels(modified: string): ModifiedLabels | undefined;
+export declare const recentTypesLimit = 10;
+export type RecentType = ClassRef & {
+    count: number;
+    modified: string;
+};
+export declare function useRecentTypes(): {
+    types: RecentType[];
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare const recentInstancesLimit = 10;
+export type RecentInstance = {
+    iri: string;
+    modified: string;
+};
+export declare function useRecentInstances(classIri: string): {
+    instances: RecentInstance[];
+    isLoading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=recents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recents.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/recents.ts"],"names":[],"mappings":"AAIA,OAAO,EAA+B,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG1E,MAAM,MAAM,cAAc,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAM3E;AAID,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAkBnC,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAExE,wBAAgB,cAAc;;;;EAwB7B;AAED,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAYvC,MAAM,MAAM,cAAc,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM;;;;EAsBlD"}

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

@@ -0,0 +1,64 @@
+import { format, formatDistanceToNow, parseISO } from "date-fns";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { useMemo } from "react";
+import { classRef, prefixes, safeIri } from "./namespaces.js";
+import { bindingCount, bindingValue, useSparqlSelect } from "#ldo-ui";
+export function modifiedLabels(modified) {
+    const date = parseISO(modified);
+    if (Number.isNaN(date.getTime()))
+        return undefined;
+    return { relative: formatDistanceToNow(date, { addSuffix: true }), absolute: format(date, "PPp") };
+}
+const df = new DataFactory();
+export const recentTypesLimit = 10;
+// STR() ordering because sources mix xsd:date and xsd:dateTime, which RDFox will not compare as temporals
+const recentlyModifiedTypesSubquery = SELECT `?type (MAX(STR(?modified)) AS ?lastModified)`.WHERE `
+  ?dated schema:dateModified ?modified .
+  ?dated a ?type .
+  FILTER(isIRI(?dated))
+`.GROUP_BY `?type`.ORDER_BY `DESC(?lastModified)`
+    .LIMIT(recentTypesLimit)
+    .build();
+// Total counts computed only for the shortlisted types; aggregating over every ?s a ?type triple is too slow
+const recentTypesQuery = `${prefixes}${SELECT `?type ?lastModified (COUNT(DISTINCT ?s) AS ?count)`.WHERE `
+  { ${recentlyModifiedTypesSubquery} }
+  ?s a ?type .
+  FILTER(isIRI(?s))
+`.GROUP_BY `?type ?lastModified`.ORDER_BY `DESC(?lastModified)`.build()}`;
+export function useRecentTypes() {
+    const { data: bindings, isLoading, error, } = useSparqlSelect({
+        query: recentTypesQuery,
+        queryKey: ["data-explorer", "recent-types"],
+    });
+    const types = useMemo(() => (bindings ?? []).flatMap((binding) => {
+        const iri = bindingValue(binding, "type");
+        const modified = bindingValue(binding, "lastModified");
+        const count = bindingCount(binding, "count");
+        const ref = iri ? classRef(iri) : undefined;
+        return ref && modified && count !== undefined ? [{ ...ref, count, modified }] : [];
+    }), [bindings]);
+    return { types, isLoading, error };
+}
+export const recentInstancesLimit = 10;
+function recentInstancesQuery(classIri) {
+    return `${prefixes}${SELECT `?s (MAX(STR(?modified)) AS ?lastModified)`.WHERE `
+  ?s a ${df.namedNode(safeIri(classIri))} .
+  ?s schema:dateModified ?modified .
+  FILTER(isIRI(?s))
+`.GROUP_BY `?s`.ORDER_BY `DESC(?lastModified) STR(?s)`
+        .LIMIT(recentInstancesLimit)
+        .build()}`;
+}
+export function useRecentInstances(classIri) {
+    const { data: bindings, isLoading, error, } = useSparqlSelect({
+        query: recentInstancesQuery(classIri),
+        queryKey: ["data-explorer", "recent-instances", classIri],
+    });
+    const instances = useMemo(() => (bindings ?? []).flatMap((binding) => {
+        const iri = bindingValue(binding, "s");
+        const modified = bindingValue(binding, "lastModified");
+        return iri && modified ? [{ iri, modified }] : [];
+    }), [bindings]);
+    return { instances, isLoading, error };
+}

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

@@ -0,0 +1,33 @@
+import { type SegmentFilter } from "./filter-query.js";
+export declare function useHasIdentifiers(classIri: string | undefined): {
+    hasIdentifiers: boolean;
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useRecordIri(classIri: string | undefined, identifier: string | undefined): {
+    iri: string | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+type IncomingReference = {
+    iri: string;
+    predicate: string;
+    modified: string;
+    typeIri?: string;
+};
+export declare function useReferencesTo(objectIri: string | undefined, filter: SegmentFilter): {
+    isLoading: boolean;
+    isRefetching: boolean;
+    error: Error | null;
+    hasMore: boolean;
+    isLoadingMore: boolean;
+    loadMore: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<IncomingReference[], unknown>, Error>>;
+    references: IncomingReference[];
+};
+export declare function useReferencesToCount(objectIri: string | undefined, filter: SegmentFilter, enabled: boolean): {
+    count: number | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+export {};
+//# sourceMappingURL=records.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/records.ts"],"names":[],"mappings":"AAGA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAcrE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS;;;;EAY7D;AASD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS;;;;EAexF;AAED,KAAK,iBAAiB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhG,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,aAAa;;;;;;;;EAoBnF;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO;;;;EAI1G"}

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

@@ -0,0 +1,61 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { buildCountQuery } from "./filter-query.js";
+import { prefixes, safeIri } from "./namespaces.js";
+import { usePagedSparql, useSparqlCount } from "./paged-sparql.js";
+import { referenceAnchor, referencesToQuery } from "./reference-query.js";
+import { bindingValue, useSparqlSelect } from "#ldo-ui";
+const df = new DataFactory();
+function hasIdentifiersQuery(classIri) {
+    return `${prefixes}${SELECT `?s`.WHERE `?s a ${df.namedNode(safeIri(classIri))} ; schema:identifier ?identifier`
+        .LIMIT(1)
+        .build()}`;
+}
+export function useHasIdentifiers(classIri) {
+    const { data: bindings, isLoading, error, } = useSparqlSelect({
+        query: classIri ? hasIdentifiersQuery(classIri) : "",
+        queryKey: ["data-explorer", "has-identifiers", classIri ?? ""],
+        enabled: isPresent(classIri),
+    });
+    return { hasIdentifiers: isPresent(bindings), isLoading, error };
+}
+function recordIriQuery(classIri, identifier) {
+    return `${prefixes}${SELECT `?s`
+        .WHERE `?s a ${df.namedNode(safeIri(classIri))} ; schema:identifier ${df.literal(identifier)}`
+        .LIMIT(1)
+        .build()}`;
+}
+export function useRecordIri(classIri, identifier) {
+    const enabled = isPresent(classIri) && isPresent(identifier);
+    const { data: bindings, isLoading, error, } = useSparqlSelect({
+        query: enabled ? recordIriQuery(classIri, identifier) : "",
+        queryKey: ["data-explorer", "record-iri", classIri ?? "", identifier ?? ""],
+        enabled,
+    });
+    const iri = bindings?.[0] ? bindingValue(bindings[0], "s") : undefined;
+    return { iri, isLoading, error };
+}
+export function useReferencesTo(objectIri, filter) {
+    const { rows: references, ...paging } = usePagedSparql({
+        queryKey: ["data-explorer", "references-to"],
+        enabled: isPresent(objectIri),
+        buildQuery: (after) => (objectIri ? referencesToQuery(objectIri, filter, after) : ""),
+        parseRow: (binding) => binding.s && binding.p
+            ? [
+                {
+                    iri: binding.s.value,
+                    predicate: binding.p.value,
+                    modified: binding.sortKey?.value ?? "",
+                    typeIri: binding.type?.value,
+                },
+            ]
+            : [],
+        cursorFromRow: (row) => ({ modified: row.modified, iri: row.iri, predicate: row.predicate }),
+    });
+    return { references, ...paging };
+}
+export function useReferencesToCount(objectIri, filter, enabled) {
+    const query = objectIri ? buildCountQuery(referenceAnchor(objectIri), filter, "?s ?p") : "";
+    return useSparqlCount("references-to-count", query, isPresent(objectIri) && enabled);
+}

package/dist/routes/data-explorer/reference-query.d.ts

@@ -0,0 +1,10 @@
+import { type SegmentFilter } from "./filter-query.js";
+export declare function referenceAnchor(objectIri: string): string;
+export declare function referenceSubjectAnchor(objectIri: string): string;
+export type ReferenceCursor = {
+    modified: string;
+    iri: string;
+    predicate: string;
+};
+export declare function referencesToQuery(objectIri: string, filter: SegmentFilter, after: ReferenceCursor | undefined): string;
+//# sourceMappingURL=reference-query.d.ts.map

package/dist/routes/data-explorer/reference-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-query.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/reference-query.ts"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAC;AAGxB,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,MAAM,MAAM,eAAe,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAInF,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,eAAe,GAAG,SAAS,GACjC,MAAM,CAYR"}

package/dist/routes/data-explorer/reference-query.js

@@ -0,0 +1,19 @@
+import { rdf } from "ldkit/namespaces";
+import { recencyCursorFilter, sparqlPageSize, stringLiteral, whereBody, withRecencySortKey, } from "./filter-query.js";
+import { safeIri } from "./namespaces.js";
+export function referenceAnchor(objectIri) {
+    return `?s ?p <${safeIri(objectIri)}> . FILTER(isIRI(?s) && ?p != <${rdf.type}>)`;
+}
+export function referenceSubjectAnchor(objectIri) {
+    return `{ SELECT DISTINCT ?s WHERE { ${referenceAnchor(objectIri)} } }`;
+}
+const referenceOrder = "DESC(?sortKey) STR(?s) STR(?p)";
+export function referencesToQuery(objectIri, filter, after) {
+    const cursor = after
+        ? recencyCursorFilter(after.modified, `STR(?s) > ${stringLiteral(after.iri)} || (STR(?s) = ${stringLiteral(after.iri)} && STR(?p) > ${stringLiteral(after.predicate)})`)
+        : "";
+    return `SELECT ?s ?p ?sortKey (SAMPLE(?rowType) AS ?type) WHERE {
+  { SELECT ?s ?p ?sortKey WHERE { ${withRecencySortKey(whereBody(referenceAnchor(objectIri), filter), "?s ?p")} ${cursor} } ORDER BY ${referenceOrder} LIMIT ${sparqlPageSize} }
+  OPTIONAL { ?s a ?rowType }
+} GROUP BY ?s ?p ?sortKey ORDER BY ${referenceOrder}`;
+}

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

@@ -0,0 +1,33 @@
+export type ShapeTerm = {
+    value: string;
+    isIri: boolean;
+    isBlank: boolean;
+    datatype?: string;
+};
+export type ShapeConstraintRow = {
+    shape: string;
+    path: string;
+    predicate: string;
+    value: ShapeTerm;
+    listValue?: ShapeTerm;
+};
+export type ShapeConstraint = {
+    predicate: string;
+    value: ShapeTerm;
+    listValues?: ShapeTerm[];
+};
+export type ShapeProperty = {
+    path: string;
+    constraints: ShapeConstraint[];
+};
+export type ClassShape = {
+    iri: string;
+    properties: ShapeProperty[];
+};
+export declare function groupShapeConstraints(rows: ShapeConstraintRow[]): ClassShape[];
+export declare function useClassShapes(classIri: string | undefined): {
+    shapes: ClassShape[];
+    isLoading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=shapes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/shapes.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,SAAS,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,UAAU,CAAC,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC;AAEhG,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,eAAe,EAAE,CAAA;CAAE,CAAC;AAE7E,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,aAAa,EAAE,CAAA;CAAE,CAAC;AAmBtE,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,kBAAkB,EAAE,GAAG,UAAU,EAAE,CAgB9E;AAyBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS;;;;EAuB1D"}

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

@@ -0,0 +1,78 @@
+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, uniqBy } from "ramda";
+import { useMemo } from "react";
+import { prefixes, safeIri } from "./namespaces.js";
+import { bindingValue, useSparqlSelect } from "#ldo-ui";
+const df = new DataFactory();
+function constraintFor(rows) {
+    const [first] = rows;
+    if (!first)
+        return [];
+    const listValues = uniqBy(prop("value"), rows.flatMap((row) => (row.listValue && !row.listValue.isBlank ? [row.listValue] : []))).sort((a, b) => a.value.localeCompare(b.value));
+    if (isPresent(listValues))
+        return [{ predicate: first.predicate, value: first.value, listValues }];
+    if (first.value.isBlank)
+        return [];
+    return [{ predicate: first.predicate, value: first.value }];
+}
+export function groupShapeConstraints(rows) {
+    return Object.entries(groupBy((row) => row.shape, rows))
+        .map(([shapeIri, shapeRows]) => ({
+        iri: shapeIri,
+        properties: Object.entries(groupBy((row) => row.path, shapeRows ?? []))
+            .map(([path, pathRows]) => ({
+            path,
+            constraints: Object.values(groupBy((row) => `${row.predicate} ${row.value.value}`, pathRows ?? []))
+                .flatMap((constraintRows) => constraintFor(constraintRows ?? []))
+                .sort((a, b) => a.predicate.localeCompare(b.predicate)),
+        }))
+            .filter((property) => isPresent(property.constraints))
+            .sort((a, b) => a.path.localeCompare(b.path)),
+    }))
+        .filter((shape) => isPresent(shape.properties))
+        .sort((a, b) => a.iri.localeCompare(b.iri));
+}
+function shapeDetailsQuery(classIri) {
+    return `${prefixes}${SELECT.DISTINCT `?shape ?path ?constraint ?value ?listValue`.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 ; ?constraint ?value .
+    FILTER(?constraint NOT IN (sh:path, rdf:type))
+    OPTIONAL { ?value rdf:rest*/rdf:first ?listValue }
+  }
+`.build()}`;
+}
+function shapeTerm(term) {
+    if (!term)
+        return undefined;
+    return {
+        value: term.value,
+        isIri: term.termType === "NamedNode",
+        isBlank: term.termType === "BlankNode",
+        datatype: term.termType === "Literal" ? term.datatype.value : undefined,
+    };
+}
+export function useClassShapes(classIri) {
+    const { data, isLoading, error } = useSparqlSelect({
+        query: classIri ? shapeDetailsQuery(classIri) : "",
+        queryKey: ["data-explorer", "shape-details", classIri ?? ""],
+        enabled: isPresent(classIri),
+    });
+    const shapes = useMemo(() => {
+        const rows = (data ?? []).flatMap((binding) => {
+            const shape = bindingValue(binding, "shape");
+            const path = bindingValue(binding, "path");
+            const predicate = bindingValue(binding, "constraint");
+            const value = shapeTerm(binding.get("value"));
+            if (!shape || !path || !predicate || !value)
+                return [];
+            return [{ shape, path, predicate, value, listValue: shapeTerm(binding.get("listValue")) }];
+        });
+        return groupShapeConstraints(rows);
+    }, [data]);
+    return { shapes, isLoading, error };
+}

package/dist/routes/data-explorer/sparql-client.d.ts

@@ -0,0 +1,3 @@
+import type { SparqlFetch, SparqlFetchOptions } from "#providers/manta-client-context";
+export declare function postSparqlSelect(sparqlFetch: SparqlFetch, query: string, options?: SparqlFetchOptions): Promise<import("@manta-eu/ldo/sparql-types").SparqlJsonResults>;
+//# sourceMappingURL=sparql-client.d.ts.map

package/dist/routes/data-explorer/sparql-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparql-client.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/sparql-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAIvF,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,mEAgB/G"}

package/dist/routes/data-explorer/sparql-client.js

@@ -0,0 +1,16 @@
+import { isSparqlJsonResults } from "@manta-eu/client/types/sparql-types";
+const queryTimeoutMs = 30_000;
+export async function postSparqlSelect(sparqlFetch, query, options = {}) {
+    const { signal, factDomain } = options;
+    const timeout = AbortSignal.timeout(queryTimeoutMs);
+    const response = await sparqlFetch(query, {
+        signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+        factDomain,
+    });
+    if (!response.ok)
+        throw new Error(`SPARQL query failed: ${response.status}`);
+    const results = await response.json();
+    if (!isSparqlJsonResults(results))
+        throw new Error("Malformed SPARQL results");
+    return results;
+}

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

@@ -0,0 +1,15 @@
+export type TripleRow = {
+    predicate: string;
+    object: string;
+    objectIsIri: boolean;
+    objectIsBlank?: boolean;
+    datatype?: string;
+};
+export declare function useTriples(subjectIri: string | undefined, graphIri?: string): {
+    triples: TripleRow[];
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function derivedFactKey(predicate: string, object: string): string;
+export declare function useDerivedFacts(subjectIri: string | undefined): Set<string>;
+//# sourceMappingURL=triples.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triples.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/triples.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,SAAS,GAAG;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AASF,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM;;;;EAiC3E;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,eAyB7D"}

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

@@ -0,0 +1,58 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { useQuery } from "@tanstack/react-query";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT, sparql } from "ldkit/sparql";
+import { useMemo } from "react";
+import { safeIri } from "./namespaces.js";
+import { postSparqlSelect } from "./sparql-client.js";
+import { bindingValue, useSparqlSelect } from "#ldo-ui";
+import { useMantaClient } from "#providers/index";
+const df = new DataFactory();
+function triplesQuery(subjectIri, graphIri) {
+    const pattern = sparql `${df.namedNode(safeIri(subjectIri))} ?p ?o`;
+    const graphPattern = graphIri ? sparql `GRAPH ${df.namedNode(safeIri(graphIri))} { ${pattern} }` : pattern;
+    return SELECT `?p ?o`.WHERE `${graphPattern}`.build();
+}
+export function useTriples(subjectIri, graphIri) {
+    const { data: bindings, isLoading, error, } = useSparqlSelect({
+        query: subjectIri ? triplesQuery(subjectIri, graphIri) : "",
+        queryKey: ["data-explorer", "triples", subjectIri ?? "", graphIri ?? ""],
+        enabled: isPresent(subjectIri),
+    });
+    const triples = useMemo(() => (bindings ?? []).flatMap((binding) => {
+        const predicate = bindingValue(binding, "p");
+        const objectTerm = binding.get("o");
+        if (!predicate || !objectTerm)
+            return [];
+        return [
+            {
+                predicate,
+                object: objectTerm.value,
+                objectIsIri: objectTerm.termType === "NamedNode",
+                objectIsBlank: objectTerm.termType === "BlankNode",
+                datatype: objectTerm.termType === "Literal" ? objectTerm.datatype.value : undefined,
+            },
+        ];
+    }), [bindings]);
+    return { triples, isLoading, error };
+}
+export function derivedFactKey(predicate, object) {
+    return `${predicate} ${object}`;
+}
+export function useDerivedFacts(subjectIri) {
+    const { sparqlFetch } = useMantaClient();
+    const { data } = useQuery({
+        queryKey: ["data-explorer", "derived-facts", subjectIri ?? ""],
+        enabled: isPresent(subjectIri),
+        queryFn: async ({ signal }) => {
+            if (!subjectIri)
+                return undefined;
+            return postSparqlSelect(sparqlFetch, triplesQuery(subjectIri), { signal, factDomain: "derived" });
+        },
+    });
+    return useMemo(() => new Set((data?.results.bindings ?? []).flatMap((binding) => {
+        const predicate = binding.p;
+        const object = binding.o;
+        return predicate && object ? [derivedFactKey(predicate.value, object.value)] : [];
+    })), [data]);
+}

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

@@ -0,0 +1,11 @@
+import type { ClassShape } from "./shapes.js";
+import type { TripleRow } from "./triples.js";
+export type TurtleTerm = {
+    value: string;
+    isIri: boolean;
+    isBlank?: boolean;
+    datatype?: string;
+};
+export declare function turtleForSubject(subjectIri: string, rows: TripleRow[]): string;
+export declare function turtleForShape(shape: ClassShape, targetClassIri: string): string;
+//# sourceMappingURL=turtle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"turtle.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/turtle.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,UAAU,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAW3C,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAqDjG,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM,CAe9E;AAYD,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAiBhF"}