@manta-eu/react 0.1.0

package/dist/routes/data-explorer/components/record-detail/RecordDetail.d.ts

@@ -0,0 +1,12 @@
+type RecordDetailProps = {
+    prefix: string;
+    typeName: string;
+    recordId: string;
+};
+export declare function RecordDetail(props: RecordDetailProps): import("react/jsx-runtime").JSX.Element;
+type EntityDetailProps = {
+    iri: string;
+};
+export declare function EntityDetail(props: EntityDetailProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=RecordDetail.d.ts.map

package/dist/routes/data-explorer/components/record-detail/RecordDetail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordDetail.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/RecordDetail.tsx"],"names":[],"mappings":"AAuBA,KAAK,iBAAiB,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CA8DpD;AAiDD,KAAK,iBAAiB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CA+DpD"}

package/dist/routes/data-explorer/components/record-detail/RecordDetail.js

@@ -0,0 +1,92 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { humanizeEntityName } from "@manta-eu/client/shared/agent-mode";
+import { isFileIri } from "@manta-eu/client/shared/fileIri";
+import { iriLocalName, isFullIri, wellKnownPredicates } from "@manta-eu/client/shared/rdf-namespaces";
+import { redirectPath } from "@manta-eu/ldo/redirect-queries";
+import { generateHexColorBasedOnName } from "@manta-eu/lib/color";
+import { isPresent } from "@manta-eu/lib/present";
+import { Link } from "react-router";
+import { classIriFor, classPath, classRef, explorerCrumb, groupCrumb } from "../../namespaces.js";
+import { Breadcrumbs } from "../Breadcrumbs.js";
+import { DetailHeader, TypeBadge } from "../DetailHeader.js";
+import { LoadingRows, StatusText } from "../RawTriples.js";
+import { ScrollableTabsList } from "../ScrollableTabsList.js";
+import { useActiveClass } from "../SelectionProvider.js";
+import { FieldList } from "./Fields.js";
+import { RecordActions } from "./RecordActions.js";
+import { RecordTabs } from "./RecordTabs.js";
+import { Badge } from "#components/badge/index";
+import { Tabs, TabsContent, TabsTrigger } from "#components/tabs/index";
+import { useInstanceLabel, useOntologyTerm, useRedirectEndpoint } from "#ldo-ui";
+import { blankTitle, decodeBlankKey, isBlankKey, useBlankRecord } from "#routes/data-explorer/blank-record";
+import { useRecordIri } from "#routes/data-explorer/records";
+import { useTriples } from "#routes/data-explorer/triples";
+export function RecordDetail(props) {
+    const { prefix, typeName, recordId } = props;
+    const classIri = classIriFor(prefix, typeName);
+    const term = useOntologyTerm(classIri);
+    const redirectEndpoint = useRedirectEndpoint();
+    const blankKey = isBlankKey(recordId) ? decodeBlankKey(recordId) : undefined;
+    const { iri, isLoading, error } = useRecordIri(blankKey ? undefined : classIri, recordId);
+    const blank = useBlankRecord(classIri, blankKey);
+    const instanceLabel = useInstanceLabel(iri);
+    useActiveClass(classIri);
+    if (!classIri)
+        return _jsxs(StatusText, { children: ["Unknown type ", typeName, "."] });
+    const { color } = generateHexColorBasedOnName(prefix);
+    const title = blankKey ? blankTitle(blankKey) || (term?.label ?? typeName) : (instanceLabel ?? recordId);
+    const trail = [
+        explorerCrumb,
+        groupCrumb(prefix),
+        { label: term?.label ?? typeName, to: classPath(prefix, typeName) },
+        { label: title },
+    ];
+    return (_jsxs("div", { className: "flex flex-col gap-6", children: [_jsx(Breadcrumbs, { trail: trail }), _jsx(DetailHeader, { title: title, iri: blankKey ? undefined : iri, iriHref: iri ? redirectPath(iri, redirectEndpoint) : undefined, actions: !blankKey && isPresent(iri) ? _jsx(RecordActions, { iri: iri, typeIris: [classIri] }) : undefined, badges: _jsxs(_Fragment, { children: [_jsx(TypeBadge, { color: color, asChild: true, children: _jsx(Link, { to: classPath(prefix, typeName), className: "hover:underline", children: term?.label ?? typeName }) }), _jsx(Badge, { variant: "secondary", size: "sm", children: blankKey ? "Blank node" : "Record" })] }) }), blankKey ? (_jsx(BlankRecordBody, { typeName: typeName, record: blank })) : (_jsx(IriRecordBody, { typeName: typeName, recordId: recordId, classIri: classIri, iri: iri, isLoading: isLoading, error: error }))] }));
+}
+function BlankRecordBody(props) {
+    const { typeName, record } = props;
+    if (record.isLoading)
+        return _jsx(LoadingRows, {});
+    if (record.error)
+        return _jsx(StatusText, { children: "Failed to resolve the record." });
+    if (record.ambiguous)
+        return _jsxs(StatusText, { children: ["Multiple ", typeName, " records match this identifier."] });
+    if (!record.found)
+        return _jsxs(StatusText, { children: ["No ", typeName, " matches this identifier."] });
+    return (_jsxs(Tabs, { defaultValue: "fields", size: "small", children: [_jsx(ScrollableTabsList, { children: _jsx(TabsTrigger, { value: "fields", children: "Fields" }) }), _jsx(TabsContent, { value: "fields", className: "pt-2", children: _jsx(FieldList, { triples: record.triples }) })] }));
+}
+function IriRecordBody(props) {
+    const { typeName, recordId, classIri, iri, isLoading, error } = props;
+    if (isLoading)
+        return _jsx(LoadingRows, {});
+    if (error)
+        return _jsx(StatusText, { children: "Failed to resolve the record." });
+    if (!iri) {
+        return (_jsxs(StatusText, { children: ["No ", typeName, " with schema:identifier = ", recordId, "."] }));
+    }
+    return _jsx(RecordTabs, { iri: iri, typeIris: [classIri] });
+}
+export function EntityDetail(props) {
+    const { iri } = props;
+    const validIri = isFullIri(iri) || isFileIri(iri) ? iri : undefined;
+    const { triples, isLoading, error } = useTriples(validIri);
+    const instanceLabel = useInstanceLabel(validIri);
+    const redirectEndpoint = useRedirectEndpoint();
+    const typeIris = triples
+        .filter((row) => row.predicate === wellKnownPredicates.type && row.objectIsIri)
+        .map((row) => row.object);
+    const typeIri = typeIris[0];
+    const type = typeIri ? classRef(typeIri) : undefined;
+    const term = useOntologyTerm(typeIri);
+    useActiveClass(type?.iri);
+    const { color } = generateHexColorBasedOnName(type?.prefix ?? "entity");
+    if (!validIri)
+        return _jsxs(StatusText, { children: ["Unknown entity ", iri, "."] });
+    const title = instanceLabel ?? humanizeEntityName(iriLocalName(iri));
+    const trail = [
+        explorerCrumb,
+        ...(type ? [groupCrumb(type.prefix), { label: term?.label ?? type.localName, to: type.path }] : []),
+        { label: title },
+    ];
+    return (_jsxs("div", { className: "flex flex-col gap-6", children: [_jsx(Breadcrumbs, { trail: trail }), _jsx(DetailHeader, { title: title, iri: iri, iriHref: redirectPath(iri, redirectEndpoint), actions: isPresent(typeIris) ? _jsx(RecordActions, { iri: validIri, typeIris: typeIris }) : undefined, badges: _jsxs(_Fragment, { children: [type && (_jsx(TypeBadge, { color: color, asChild: true, children: _jsx(Link, { to: type.path, className: "hover:underline", children: term?.label ?? type.localName }) })), _jsx(Badge, { variant: "secondary", size: "sm", children: "Record" })] }) }), isLoading && _jsx(LoadingRows, {}), error && _jsx(StatusText, { children: "Failed to load the record." }), !isLoading && !error && _jsx(RecordTabs, { iri: iri, typeIris: typeIris })] }));
+}

package/dist/routes/data-explorer/components/record-detail/RecordTabs.d.ts

@@ -0,0 +1,7 @@
+type RecordTabsProps = {
+    iri: string;
+    typeIris: string[];
+};
+export declare function RecordTabs(props: RecordTabsProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=RecordTabs.d.ts.map

package/dist/routes/data-explorer/components/record-detail/RecordTabs.d.ts.map

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

package/dist/routes/data-explorer/components/record-detail/RecordTabs.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RawTriples } from "../RawTriples.js";
+import { ScrollableTabsList } from "../ScrollableTabsList.js";
+import { ChatPreview } from "./ChatPreview.js";
+import { Fields } from "./Fields.js";
+import { IncomingReferences } from "./IncomingReferences.js";
+import { Tabs, TabsContent, TabsTrigger } from "#components/tabs/index";
+import { useTabParam } from "#hooks/useTabParam";
+const recordTabs = [
+    { value: "fields", label: "Fields" },
+    { value: "referenced", label: "Referenced by" },
+    { value: "chat-preview", label: "Chat Preview" },
+    { value: "raw", label: "Raw" },
+];
+export function RecordTabs(props) {
+    const { iri, typeIris } = props;
+    const [activeTab, selectTab] = useTabParam(recordTabs, "fields");
+    return (_jsxs(Tabs, { value: activeTab, onValueChange: selectTab, size: "small", children: [_jsx(ScrollableTabsList, { activeValue: activeTab, children: recordTabs.map((tab) => (_jsx(TabsTrigger, { value: tab.value, children: tab.label }, tab.value))) }), _jsx(TabsContent, { value: "fields", className: "pt-2", children: _jsx(Fields, { iri: iri }) }), _jsx(TabsContent, { value: "referenced", className: "pt-2", children: _jsx(IncomingReferences, { iri: iri }) }), _jsx(TabsContent, { value: "chat-preview", className: "pt-2", children: _jsx(ChatPreview, { entityIri: iri, typeIris: typeIris }) }), _jsx(TabsContent, { value: "raw", className: "pt-2", children: _jsx(RawTriples, { subjectIri: iri }) })] }));
+}

package/dist/routes/data-explorer/components/record-detail/action-properties.d.ts

@@ -0,0 +1,9 @@
+import type { ShaclFormStore } from "@ulb-darmstadt/shacl-form";
+export type PropertyMap = Record<string, unknown>;
+export declare function propertiesFromStore(store: ShaclFormStore, subjectIri: string): PropertyMap;
+export declare function baselineFromStore(store: ShaclFormStore, subjectIri: string): PropertyMap | null;
+/** Only what changed: the backend merges the rest, and a predicate the form dropped cannot express a retraction. */
+export declare function changedProperties(current: PropertyMap, next: PropertyMap): PropertyMap;
+/** The predicates the edit cleared: a patch cannot retract, so the caller must refuse rather than claim success. */
+export declare function removedPredicates(current: PropertyMap, next: PropertyMap): string[];
+//# sourceMappingURL=action-properties.d.ts.map

package/dist/routes/data-explorer/components/record-detail/action-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-properties.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/action-properties.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA2DlD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,CAE1F;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAI/F;AASD,oHAAoH;AACpH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,GAAG,WAAW,CAUtF;AAED,oHAAoH;AACpH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CAEnF"}

package/dist/routes/data-explorer/components/record-detail/action-properties.js

@@ -0,0 +1,72 @@
+import { namespaces, wellKnownPredicates } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+const xsdString = `${namespaces.xsd}string`;
+/** The form stamps this on every serialization; it describes the shape, not the record. */
+const conformsTo = `${namespaces.dcterms}conformsTo`;
+function literalValue(value, datatype) {
+    if (!datatype || datatype === xsdString)
+        return value;
+    return { "@value": value, "@type": datatype };
+}
+function addValue(properties, predicate, value) {
+    const existing = properties[predicate];
+    if (existing === undefined) {
+        properties[predicate] = value;
+        return;
+    }
+    properties[predicate] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+}
+// `seen` is path-scoped: a cycle still terminates, but two references to one blank node each get described.
+function nodeDescription(store, subject, visited, includeType) {
+    const properties = {};
+    const seen = new Set(visited).add(subject);
+    for (const quad of store.getQuads(null, null, null, null)) {
+        if (quad.subject.value !== subject)
+            continue;
+        if (quad.predicate.value === conformsTo)
+            continue;
+        const isType = quad.predicate.value === wellKnownPredicates.type;
+        if (isType && !includeType)
+            continue;
+        let value;
+        if (quad.object.termType === "NamedNode") {
+            value = isType ? quad.object.value : { "@id": quad.object.value };
+        }
+        else if (quad.object.termType === "BlankNode") {
+            if (seen.has(quad.object.value))
+                continue;
+            value = nodeDescription(store, quad.object.value, seen, true);
+        }
+        else {
+            value = literalValue(quad.object.value, quad.object.datatype?.value);
+        }
+        addValue(properties, isType ? "@type" : quad.predicate.value, value);
+    }
+    return properties;
+}
+export function propertiesFromStore(store, subjectIri) {
+    return nodeDescription(store, subjectIri, new Set(), false);
+}
+export function baselineFromStore(store, subjectIri) {
+    if (!isPresent(store.getQuads(null, null, null, null)))
+        return null;
+    return propertiesFromStore(store, subjectIri);
+}
+function sameValue(left, right) {
+    const normalize = (value) => Array.isArray(value) ? JSON.stringify(value.map((entry) => JSON.stringify(entry)).sort()) : JSON.stringify(value);
+    return normalize(left) === normalize(right);
+}
+/** Only what changed: the backend merges the rest, and a predicate the form dropped cannot express a retraction. */
+export function changedProperties(current, next) {
+    const changed = {};
+    for (const [predicate, value] of Object.entries(next)) {
+        if (sameValue(current[predicate], value))
+            continue;
+        changed[predicate] = value;
+    }
+    return changed;
+}
+/** The predicates the edit cleared: a patch cannot retract, so the caller must refuse rather than claim success. */
+export function removedPredicates(current, next) {
+    return Object.keys(current).filter((predicate) => !(predicate in next));
+}

package/dist/routes/data-explorer/components/record-detail/action-shapes.d.ts

@@ -0,0 +1,27 @@
+import { type ActionShapeSpec } from "#ldo-ui";
+export declare function actionShapesForTypes(typeIris: string[]): ActionShapeSpec[];
+export type RecordActionShape = {
+    actionShape: string;
+    /** The record's own type the shape matched on; the backend resolves its handler from this. */
+    rdfType: string;
+    supportsCreate: boolean;
+    supportsUpdate: boolean;
+    supportsDelete: boolean;
+};
+type ShapeRow = {
+    actionShape: string;
+    rdfTypes: string[];
+    supportsCreate: boolean;
+    supportsUpdate: boolean;
+    supportsDelete: boolean;
+};
+export declare function matchShapesToTypes(shapes: ShapeRow[], typeIris: string[]): RecordActionShape[];
+export type UseRecordActionShapesResult = {
+    shapes: RecordActionShape[];
+    isLoading: boolean;
+    error: string | null;
+};
+/** Reads the handler registry live: it, not the generated catalog, decides what can actually run. */
+export declare function useRecordActionShapes(typeIris: string[]): UseRecordActionShapesResult;
+export {};
+//# sourceMappingURL=action-shapes.d.ts.map

package/dist/routes/data-explorer/components/record-detail/action-shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-shapes.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/action-shapes.ts"],"names":[],"mappings":"AACA,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAGtE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,eAAe,EAAE,CAI1E;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,8FAA8F;IAC9F,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,CAoB9F;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,qGAAqG;AACrG,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,2BAA2B,CAYrF"}

package/dist/routes/data-explorer/components/record-detail/action-shapes.js

@@ -0,0 +1,38 @@
+import { useSupportedActionShapesQuery } from "@manta-eu/client";
+import { supportedActionShapes } from "#ldo-ui";
+import { useMantaClient } from "#providers/MantaClientProvider";
+export function actionShapesForTypes(typeIris) {
+    const types = new Set(typeIris);
+    return supportedActionShapes.filter((shape) => shape.targetRdfTypes.some((target) => types.has(target)));
+}
+export function matchShapesToTypes(shapes, typeIris) {
+    const types = new Set(typeIris);
+    return shapes
+        .flatMap((shape) => {
+        const rdfType = shape.rdfTypes.find((candidate) => types.has(candidate));
+        if (!rdfType)
+            return [];
+        return [
+            {
+                actionShape: shape.actionShape,
+                rdfType,
+                supportsCreate: shape.supportsCreate,
+                supportsUpdate: shape.supportsUpdate,
+                supportsDelete: shape.supportsDelete,
+            },
+        ];
+    })
+        .sort((left, right) => left.actionShape.localeCompare(right.actionShape));
+}
+/** Reads the handler registry live: it, not the generated catalog, decides what can actually run. */
+export function useRecordActionShapes(typeIris) {
+    const { mantaClient } = useMantaClient();
+    const { data, isLoading, error } = useSupportedActionShapesQuery(mantaClient);
+    const response = data?.supportedActionShapes;
+    const queryError = error instanceof Error ? error.message : null;
+    return {
+        shapes: matchShapesToTypes(response?.supportedActionShapes ?? [], typeIris),
+        isLoading,
+        error: response?.error ?? queryError,
+    };
+}

package/dist/routes/data-explorer/components/record-detail/index.d.ts

@@ -0,0 +1,2 @@
+export { EntityDetail, RecordDetail } from "./RecordDetail.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/routes/data-explorer/components/record-detail/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/routes/data-explorer/components/record-detail/index.js

@@ -0,0 +1 @@
+export { EntityDetail, RecordDetail } from "./RecordDetail.js";

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

@@ -0,0 +1,83 @@
+import { type GQLCoverageRulesQuery } from "@manta-eu/client";
+import type { RDF } from "ldkit/rdf";
+export type CoverageTerm = {
+    iri: string;
+    group: string;
+    name: string;
+    isClass: boolean;
+    label?: string;
+    comment?: string;
+    ruleIris?: readonly string[];
+};
+export type CoverageTotals = {
+    terms: number;
+    labeled: number;
+    described: number;
+    complete: number;
+};
+export type CoverageGroup = CoverageTotals & {
+    group: string;
+    label: string;
+    labeledPercent: number;
+};
+export type RuleUsageTotals = {
+    terms: number;
+    usedByRules: number;
+};
+export type RuleUsageGroup = RuleUsageTotals & {
+    group: string;
+    label: string;
+    usedByRulesPercent: number;
+};
+type RuleUsageCoverage = {
+    totals: RuleUsageTotals;
+    groups: RuleUsageGroup[];
+};
+type CoverageRulesResponse = GQLCoverageRulesQuery["rules"];
+export type UnobservedRuleTerm = {
+    iri: string;
+    group: string;
+    name: string;
+    kinds: readonly ("class" | "predicate")[];
+    bodyRuleIris: readonly string[];
+    headRuleIris: readonly string[];
+};
+export type UnobservedRuleVocabulary = {
+    totalReferencedTerms: number;
+    terms: UnobservedRuleTerm[];
+};
+type RuleUsageJoinResult = {
+    terms: CoverageTerm[];
+    ruleUsageAvailable: boolean;
+    ruleUsageResponseError: Error | undefined;
+    unobservedRuleVocabulary: UnobservedRuleVocabulary | undefined;
+};
+export declare const coverageGraphIri: string;
+export declare const coverageQuery: string;
+export declare function coverageTerms(bindings: RDF.Bindings[]): CoverageTerm[];
+export declare function coverageTotals(terms: CoverageTerm[]): CoverageTotals;
+export declare function joinRuleUsage(terms: CoverageTerm[], response?: CoverageRulesResponse): RuleUsageJoinResult;
+export declare function buildRuleUsage(terms: readonly CoverageTerm[]): RuleUsageCoverage;
+export declare function buildCoverageGroups(terms: CoverageTerm[]): CoverageGroup[];
+export declare const coverageStatuses: readonly ["nolabel", "nodesc", "unused", "complete", "all"];
+export type CoverageStatus = (typeof coverageStatuses)[number];
+type CoverageFilter = {
+    group?: string;
+    status?: CoverageStatus;
+    query?: string;
+};
+export declare function filterCoverageTerms(terms: CoverageTerm[], filter: CoverageFilter): CoverageTerm[];
+export declare function coverageStatusCounts(terms: CoverageTerm[]): Record<CoverageStatus, number>;
+export declare function coveragePercent(covered: number, total: number): number;
+export declare function useTermCoverage(): {
+    terms: CoverageTerm[];
+    updatedAt: string | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    isRuleUsageLoading: boolean;
+    ruleUsageError: {} | undefined;
+    ruleUsageAvailable: boolean;
+    unobservedRuleVocabulary: UnobservedRuleVocabulary | undefined;
+};
+export {};
+//# sourceMappingURL=coverage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/coverage.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,230 @@
+import { useCoverageRulesQuery } from "@manta-eu/client";
+import { expandPrefix, iriLocalName, iriNamespace } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { SELECT } from "ldkit/sparql";
+import { groupBy, prop } from "ramda";
+import { useMemo } from "react";
+import { match } from "ts-pattern";
+import { commentBinding } from "./classes.js";
+import { matchesNameQuery } from "./families.js";
+import { iriTerm } from "./filter-query.js";
+import { localName, namespaceLabel, prefixForIri, prefixes } from "./namespaces.js";
+import { bindingValue, useSparqlSelect } from "#ldo-ui";
+import { useMantaClient } from "#providers/index";
+export const coverageGraphIri = expandPrefix(":coverage");
+const observedClassIri = expandPrefix(":ObservedClass");
+const observedPredicateIri = expandPrefix(":ObservedPredicate");
+const termLabelIri = expandPrefix(":termLabel");
+const termCommentIri = expandPrefix(":termComment");
+const dateModifiedIri = expandPrefix("schema:dateModified");
+export const coverageQuery = `${prefixes}${SELECT.DISTINCT `?term ?isClass ?label ?comment ?updatedAt`.WHERE `
+  GRAPH ${iriTerm(coverageGraphIri)} {
+    {
+      { ?term a ${iriTerm(observedClassIri)} . BIND(true AS ?isClass) }
+      UNION
+      { ?term a ${iriTerm(observedPredicateIri)} . BIND(false AS ?isClass) }
+    }
+    OPTIONAL { ?term ${iriTerm(termLabelIri)} ?label }
+    OPTIONAL { ?term ${iriTerm(termCommentIri)} ?comment }
+    OPTIONAL { ${iriTerm(coverageGraphIri)} ${iriTerm(dateModifiedIri)} ?updatedAt }
+  }
+`.build()}`;
+function termName(iri, prefix) {
+    const mappedName = prefix ? localName(iri, prefix) : "";
+    const trailingSegment = iri.slice(iriNamespace(iri).length).replace(/^[:#/]/, "");
+    return mappedName || trailingSegment || iriLocalName(iri);
+}
+function firstAlphabetically(values) {
+    return values.filter(isPresent).sort()[0];
+}
+function compareTerms(a, b) {
+    return a.group.localeCompare(b.group) || a.name.localeCompare(b.name);
+}
+export function coverageTerms(bindings) {
+    const rows = bindings.flatMap((binding) => {
+        const iri = bindingValue(binding, "term");
+        if (!iri)
+            return [];
+        return [
+            {
+                iri,
+                isClass: bindingValue(binding, "isClass") === "true",
+                label: bindingValue(binding, "label"),
+                comment: commentBinding(binding),
+            },
+        ];
+    });
+    return Object.values(groupBy(prop("iri"), rows))
+        .flatMap((group = []) => {
+        const [first] = group;
+        if (!first)
+            return [];
+        const prefix = prefixForIri(first.iri);
+        return [
+            {
+                iri: first.iri,
+                group: prefix ?? iriNamespace(first.iri),
+                name: termName(first.iri, prefix),
+                isClass: group.some((term) => term.isClass),
+                label: firstAlphabetically(group.map((term) => term.label)),
+                comment: firstAlphabetically(group.map((term) => term.comment)),
+            },
+        ];
+    })
+        .sort(compareTerms);
+}
+export function coverageTotals(terms) {
+    return {
+        terms: terms.length,
+        labeled: terms.filter((term) => term.label).length,
+        described: terms.filter((term) => term.comment).length,
+        complete: terms.filter((term) => matchesStatus(term, "complete")).length,
+    };
+}
+function buildRuleVocabularyIndex(rules) {
+    const references = rules.flatMap(({ ruleIri, committedVocabulary }) => {
+        if (!committedVocabulary)
+            return [];
+        return ["body", "head"].flatMap((position) => [
+            ...committedVocabulary[position].classes.map((iri) => ({ iri, ruleIri, position, kind: "class" })),
+            ...committedVocabulary[position].predicates.map((iri) => ({
+                iri,
+                ruleIri,
+                position,
+                kind: "predicate",
+            })),
+        ]);
+    });
+    return new Map(Object.entries(groupBy(prop("iri"), references)).map(([iri, entries = []]) => [
+        iri,
+        {
+            iri,
+            kinds: ["class", "predicate"].filter((kind) => entries.some((entry) => entry.kind === kind)),
+            bodyRuleIris: [
+                ...new Set(entries.filter(({ position }) => position === "body").map(({ ruleIri }) => ruleIri)),
+            ].sort(),
+            headRuleIris: [
+                ...new Set(entries.filter(({ position }) => position === "head").map(({ ruleIri }) => ruleIri)),
+            ].sort(),
+        },
+    ]));
+}
+export function joinRuleUsage(terms, response) {
+    const unavailable = {
+        terms,
+        ruleUsageAvailable: false,
+        ruleUsageResponseError: undefined,
+        unobservedRuleVocabulary: undefined,
+    };
+    if (!response)
+        return unavailable;
+    if (response.error) {
+        return { ...unavailable, ruleUsageResponseError: new Error(response.error) };
+    }
+    if (response.count !== response.rules.length) {
+        return {
+            ...unavailable,
+            ruleUsageResponseError: new Error(`Rule usage is incomplete: received ${response.rules.length} of ${response.count} rules.`),
+        };
+    }
+    const invalidRule = response.rules.find(({ committedVocabulary }) => committedVocabulary?.error);
+    if (invalidRule?.committedVocabulary?.error) {
+        return {
+            ...unavailable,
+            ruleUsageResponseError: new Error(`Could not read committed vocabulary for ${invalidRule.ruleIri}: ${invalidRule.committedVocabulary.error}`),
+        };
+    }
+    const vocabularyIndex = buildRuleVocabularyIndex(response.rules);
+    const observedIris = new Set(terms.map(prop("iri")));
+    const unobservedTerms = [...vocabularyIndex.values()]
+        .filter(({ iri }) => !observedIris.has(iri))
+        .map((term) => {
+        const prefix = prefixForIri(term.iri);
+        return {
+            ...term,
+            group: prefix ?? iriNamespace(term.iri),
+            name: termName(term.iri, prefix),
+        };
+    })
+        .sort((a, b) => b.bodyRuleIris.length - a.bodyRuleIris.length ||
+        b.headRuleIris.length - a.headRuleIris.length ||
+        compareTerms(a, b));
+    return {
+        terms: terms.map((term) => ({ ...term, ruleIris: vocabularyIndex.get(term.iri)?.bodyRuleIris ?? [] })),
+        ruleUsageAvailable: true,
+        ruleUsageResponseError: undefined,
+        unobservedRuleVocabulary: { totalReferencedTerms: vocabularyIndex.size, terms: unobservedTerms },
+    };
+}
+export function buildRuleUsage(terms) {
+    const groups = Object.entries(groupBy(prop("group"), terms)).map(([group, groupTerms = []]) => {
+        const totals = {
+            terms: groupTerms.length,
+            usedByRules: groupTerms.filter(({ ruleIris }) => isPresent(ruleIris)).length,
+        };
+        return {
+            group,
+            label: namespaceLabel(group),
+            ...totals,
+            usedByRulesPercent: coveragePercent(totals.usedByRules, totals.terms),
+        };
+    });
+    const totals = groups.reduce((result, group) => ({
+        terms: result.terms + group.terms,
+        usedByRules: result.usedByRules + group.usedByRules,
+    }), { terms: 0, usedByRules: 0 });
+    return { totals, groups };
+}
+export function buildCoverageGroups(terms) {
+    return Object.entries(groupBy(prop("group"), terms))
+        .map(([group, groupTerms = []]) => {
+        const totals = coverageTotals(groupTerms);
+        return {
+            group,
+            label: namespaceLabel(group),
+            ...totals,
+            labeledPercent: coveragePercent(totals.labeled, totals.terms),
+        };
+    })
+        .sort((a, b) => a.labeledPercent - b.labeledPercent || b.terms - a.terms);
+}
+export const coverageStatuses = ["nolabel", "nodesc", "unused", "complete", "all"];
+function matchesStatus(term, status) {
+    return match(status)
+        .with("nolabel", () => !isPresent(term.label))
+        .with("nodesc", () => !isPresent(term.comment))
+        .with("unused", () => term.ruleIris !== undefined && !isPresent(term.ruleIris))
+        .with("complete", () => isPresent(term.label) && isPresent(term.comment))
+        .with("all", () => true)
+        .exhaustive();
+}
+export function filterCoverageTerms(terms, filter) {
+    const { group, status = "all", query = "" } = filter;
+    const needle = query.trim();
+    return terms.filter((term) => (!isPresent(group) || term.group === group) &&
+        matchesStatus(term, status) &&
+        matchesNameQuery(`${term.name} ${term.iri}`, needle));
+}
+export function coverageStatusCounts(terms) {
+    return Object.fromEntries(coverageStatuses.map((status) => [status, terms.filter((term) => matchesStatus(term, status)).length]));
+}
+export function coveragePercent(covered, total) {
+    return total ? Math.round((covered / total) * 100) : 0;
+}
+export function useTermCoverage() {
+    const { mantaClient } = useMantaClient();
+    const { data: bindings, isLoading, error, } = useSparqlSelect({ query: coverageQuery, queryKey: ["data-explorer", "term-coverage"] });
+    const { data: rulesData, isLoading: isRuleUsageLoading, error: ruleUsageQueryError, } = useCoverageRulesQuery(mantaClient);
+    const coverage = useMemo(() => joinRuleUsage(coverageTerms(bindings ?? []), error ? undefined : rulesData?.rules), [bindings, error, rulesData]);
+    const first = bindings?.[0];
+    return {
+        terms: coverage.terms,
+        updatedAt: first && bindingValue(first, "updatedAt"),
+        isLoading,
+        error,
+        isRuleUsageLoading,
+        ruleUsageError: ruleUsageQueryError ?? coverage.ruleUsageResponseError,
+        ruleUsageAvailable: coverage.ruleUsageAvailable,
+        unobservedRuleVocabulary: coverage.unobservedRuleVocabulary,
+    };
+}

package/dist/routes/data-explorer/declared-namespaces.d.ts

@@ -0,0 +1,4 @@
+export declare function useDeclaredNamespaces(): {
+    isLoading: boolean;
+};
+//# sourceMappingURL=declared-namespaces.d.ts.map

package/dist/routes/data-explorer/declared-namespaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declared-namespaces.d.ts","sourceRoot":"","sources":["../../../src/routes/data-explorer/declared-namespaces.ts"],"names":[],"mappings":"AA2CA,wBAAgB,qBAAqB;;EAUpC"}