@manta-eu/react 0.1.0

package/dist/routes/data-explorer/components/ontology-coverage/UnobservedRuleVocabulary.js

@@ -0,0 +1,96 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { humanCount } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+import { useReactTable } from "@tanstack/react-table";
+import { CircleCheck, FileCode2 } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import { Link } from "react-router";
+import { classRef, namespaceLabel } from "../../namespaces.js";
+import { NamespaceSwatch } from "../NamespaceSwatch.js";
+import { TruncateTooltip } from "../TruncateTooltip.js";
+import { RuleReferencesCell } from "./RuleReferencesCell.js";
+import { Badge } from "#components/badge/index";
+import { EmptyState } from "#components/empty-state/index";
+import { SearchInput } from "#components/input/index";
+import { PaginationBlock } from "#components/pagination/index";
+import { createTableConfig, DataTable } from "#components/table/index";
+import { shouldClampPageIndex, useFittedPagination } from "#hooks/useFittedPagination";
+import { sectionLabelClass } from "#ldo-ui";
+import { cn } from "#lib/utils";
+import { matchesNameQuery } from "#routes/data-explorer/families";
+const tableGeometry = { headerRowHeight: 52, rowHeight: 51, reservedHeight: 58 };
+const initialSorting = [
+    { id: "bodyRules", desc: true },
+    { id: "headRules", desc: true },
+];
+function columnHeader(label) {
+    return () => _jsx("span", { className: cn(sectionLabelClass, "text-muted-foreground"), children: label });
+}
+const columns = [
+    {
+        id: "term",
+        accessorFn: (term) => term.name,
+        header: columnHeader("Term"),
+        cell: ({ row }) => {
+            const term = row.original;
+            const ref = term.kinds.includes("class") ? classRef(term.iri) : undefined;
+            return (_jsxs("div", { className: "min-w-0", children: [ref ? (_jsx(Link, { to: ref.path, className: "typography-small-medium block truncate text-default-foreground hover:underline", children: term.name })) : (_jsx(TruncateTooltip, { text: term.name, className: "typography-small-medium block truncate text-default-foreground" })), _jsx(TruncateTooltip, { text: term.iri, className: "block truncate font-mono text-[11px] leading-4 text-muted-foreground/60" })] }));
+        },
+    },
+    {
+        id: "namespace",
+        accessorFn: (term) => namespaceLabel(term.group),
+        header: columnHeader("Namespace"),
+        cell: ({ row }) => (_jsxs("span", { className: "flex items-center gap-2", children: [_jsx(NamespaceSwatch, { name: row.original.group }), _jsx("span", { className: "typography-small truncate text-muted-foreground", children: namespaceLabel(row.original.group) })] })),
+    },
+    {
+        id: "kind",
+        accessorFn: (term) => term.kinds.join(","),
+        header: columnHeader("Kind"),
+        cell: ({ row }) => (_jsx("span", { className: "flex items-center gap-1", children: row.original.kinds.map((kind) => (_jsx(Badge, { variant: "secondary", size: "sm", children: kind === "class" ? "type" : "field" }, kind))) })),
+    },
+    {
+        id: "bodyRules",
+        accessorFn: (term) => term.bodyRuleIris.length,
+        header: columnHeader("Consumed by"),
+        cell: ({ row }) => (_jsx(RuleReferencesCell, { ruleIris: row.original.bodyRuleIris, popoverTitle: "Rules consuming this term" })),
+    },
+    {
+        id: "headRules",
+        accessorFn: (term) => term.headRuleIris.length,
+        header: columnHeader("Derived by"),
+        cell: ({ row }) => (_jsx(RuleReferencesCell, { ruleIris: row.original.headRuleIris, popoverTitle: "Rules deriving this term" })),
+    },
+];
+export function UnobservedRuleVocabulary(props) {
+    const { vocabulary } = props;
+    const [query, setQuery] = useState("");
+    const [sorting, setSorting] = useState(initialSorting);
+    const [pageIndex, setPageIndex] = useState(0);
+    const filteredTerms = useMemo(() => vocabulary.terms.filter((term) => matchesNameQuery(`${term.name} ${term.iri} ${namespaceLabel(term.group)}`, query.trim())), [query, vocabulary.terms]);
+    const { containerRef, pageSize } = useFittedPagination({
+        ...tableGeometry,
+        pageIndex,
+        onPageIndexChange: setPageIndex,
+    });
+    const totalPages = Math.max(1, Math.ceil(filteredTerms.length / pageSize));
+    const activePageIndex = Math.min(pageIndex, totalPages - 1);
+    const pagination = useMemo(() => ({ pageIndex: activePageIndex, pageSize }), [activePageIndex, pageSize]);
+    useEffect(() => {
+        if (shouldClampPageIndex({ pageIndex, totalPages }))
+            setPageIndex(totalPages - 1);
+    }, [pageIndex, totalPages]);
+    const table = useReactTable({
+        ...createTableConfig({ data: filteredTerms, columns, sorting, setSorting, pagination }),
+        autoResetPageIndex: false,
+    });
+    function changeQuery(next) {
+        setQuery(next);
+        setPageIndex(0);
+    }
+    return (_jsxs("div", { className: "flex min-h-0 flex-1 flex-col gap-3.5 pt-1", children: [_jsxs("div", { className: "flex flex-wrap items-start justify-between gap-3", children: [_jsxs("div", { className: "flex max-w-2xl flex-col gap-1", children: [_jsxs("span", { className: "flex items-center gap-2", children: [_jsx("h3", { className: "typography-small-medium text-default-foreground", children: "Rule vocabulary not observed in current data" }), _jsx(Badge, { variant: "secondary", size: "sm", children: humanCount(vocabulary.terms.length, "term") })] }), _jsx("p", { className: "typography-small text-muted-foreground", children: "Committed rules reference these terms, but they are absent from the latest coverage observation. Rule bodies consume terms; rule heads derive them." })] }), isPresent(vocabulary.terms) && (_jsx("div", { className: "w-full sm:w-56", children: _jsx(SearchInput, { size: "sm", placeholder: "Search rule vocabulary\u2026", value: query, onChange: (event) => changeQuery(event.target.value) }) }))] }), !isPresent(vocabulary.terms) ? (_jsx(EmptyState, { icon: vocabulary.totalReferencedTerms === 0 ? FileCode2 : CircleCheck, title: vocabulary.totalReferencedTerms === 0
+                    ? "No committed rule vocabulary to compare"
+                    : "All committed rule vocabulary is currently observed", description: vocabulary.totalReferencedTerms === 0
+                    ? "Committed rules will appear here once they reference classes or predicates."
+                    : "Every class and predicate referenced by committed rules appears in the latest coverage observation.", className: "h-full" })) : (_jsxs("div", { ref: containerRef, className: "flex min-h-0 flex-1 flex-col gap-3", children: [_jsx(DataTable, { table: table, className: "min-h-0 flex-1 overflow-y-hidden", noResultsMessage: "No rule vocabulary matches your search." }), totalPages > 1 && (_jsx(PaginationBlock, { showPageSize: true, pageSize: pageSize, totalCount: filteredTerms.length, currentPageIndex: activePageIndex, totalPages: totalPages, onPageChange: setPageIndex }))] }))] }));
+}

package/dist/routes/data-explorer/components/ontology-coverage/index.d.ts

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

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

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

package/dist/routes/data-explorer/components/ontology-coverage/index.js

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

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

@@ -0,0 +1,6 @@
+export declare const railFocusClass = "outline-none focus-visible:ring-2 focus-visible:ring-active-border/50";
+export declare const railDisclosureClass: string;
+export declare const railRowLinkClass: string;
+export declare function railRowClass(isSelected: boolean): string;
+export declare function railCountClass(isSelected: boolean): string;
+//# sourceMappingURL=railStyles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"railStyles.d.ts","sourceRoot":"","sources":["../../../../src/routes/data-explorer/components/railStyles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,0EAA0E,CAAC;AAEtG,eAAO,MAAM,mBAAmB,QAG/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAwF,CAAC;AAEtH,wBAAgB,YAAY,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,CAExD;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,CAE1D"}

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

@@ -0,0 +1,10 @@
+import { cn } from "#lib/utils";
+export const railFocusClass = "outline-none focus-visible:ring-2 focus-visible:ring-active-border/50";
+export const railDisclosureClass = cn("flex size-5 shrink-0 items-center justify-center rounded transition-colors hover:bg-muted/60", railFocusClass);
+export const railRowLinkClass = cn("flex min-w-0 flex-1 items-center gap-2 rounded-md py-1.5 pr-2.5", railFocusClass);
+export function railRowClass(isSelected) {
+    return cn("relative flex items-center rounded-md transition-colors", isSelected ? "bg-accent/40" : "hover:bg-muted");
+}
+export function railCountClass(isSelected) {
+    return cn("typography-tiny tabular-nums", isSelected ? "text-accent-foreground" : "text-muted-foreground");
+}

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

@@ -0,0 +1,16 @@
+import { type PropertyMap } from "./action-properties.js";
+import type { TripleRow } from "#routes/data-explorer/triples";
+export type ActionFormMode = "create" | "update";
+export type ActionFormDialogProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    mode: ActionFormMode;
+    actionShape: string;
+    subjectIri: string;
+    /** The record's current state, prefilled into the form. Empty for a creation. */
+    triples: TripleRow[];
+    isPending: boolean;
+    onSubmit: (properties: PropertyMap) => void;
+};
+export declare function ActionFormDialog(props: ActionFormDialogProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ActionFormDialog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ActionFormDialog.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/ActionFormDialog.tsx"],"names":[],"mappings":"AAMA,OAAO,EAKL,KAAK,WAAW,EACjB,MAAM,qBAAqB,CAAC;AAY7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAG/D,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEjD,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,IAAI,EAAE,cAAc,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iFAAiF;IACjF,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,IAAI,CAAC;CAC7C,CAAC;AAeF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,2CAkH5D"}

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

@@ -0,0 +1,76 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useShaclShapesQuery } from "@manta-eu/client";
+import { compactUri } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { LoadingRows, StatusText } from "../RawTriples.js";
+import { baselineFromStore, changedProperties, propertiesFromStore, removedPredicates, } from "./action-properties.js";
+import { Button } from "#components/button/index";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "#components/modal/index";
+import { ShaclForm } from "#ldo-ui";
+import { useMantaClient } from "#providers/MantaClientProvider";
+import { turtleForSubject } from "#routes/data-explorer/turtle";
+const copyByMode = {
+    create: {
+        title: "Create in the connected system",
+        description: "Every field you fill in is sent as the new record's desired state.",
+        submitLabel: "Create",
+    },
+    update: {
+        title: "Update in the connected system",
+        description: "Only the fields you change are sent; everything else keeps its current value.",
+        submitLabel: "Update",
+    },
+};
+export function ActionFormDialog(props) {
+    const { open, onOpenChange, mode, actionShape, subjectIri, triples, isPending, onSubmit } = props;
+    const { mantaClient } = useMantaClient();
+    const baselineRef = useRef(null);
+    const [refusal, setRefusal] = useState(null);
+    const [formElement, setFormElement] = useState(null);
+    const attachForm = useCallback((element) => setFormElement(element), []);
+    const { data, isLoading, error } = useShaclShapesQuery(mantaClient, { shapeIri: actionShape }, { enabled: open });
+    const hasShapesError = isPresent(error);
+    const shapesTurtle = data?.shaclShapes.turtle;
+    const isUpdate = mode === "update";
+    const copy = copyByMode[mode];
+    const valuesTurtle = useMemo(() => (isPresent(triples) ? turtleForSubject(subjectIri, triples) : undefined), [subjectIri, triples]);
+    useEffect(() => {
+        if (!formElement || !isUpdate)
+            return;
+        // Baseline is the form's own serialization: its editors normalize literals, the triples do not.
+        function captureBaseline() {
+            const store = formElement?.toRDF();
+            const baseline = store ? baselineFromStore(store, subjectIri) : null;
+            if (baseline)
+                baselineRef.current = baseline;
+        }
+        captureBaseline();
+        formElement.addEventListener("ready", captureBaseline);
+        return () => formElement.removeEventListener("ready", captureBaseline);
+    }, [formElement, isUpdate, subjectIri]);
+    function submit() {
+        const store = formElement?.toRDF();
+        const baseline = baselineRef.current;
+        if (!store || (isUpdate && !baseline)) {
+            setRefusal("The form is not ready yet.");
+            return;
+        }
+        const edited = propertiesFromStore(store, subjectIri);
+        if (isUpdate && baseline) {
+            const cleared = removedPredicates(baseline, edited);
+            if (isPresent(cleared)) {
+                setRefusal(`Clearing ${cleared.map(compactUri).join(", ")} is not supported - restore a value to continue.`);
+                return;
+            }
+        }
+        const properties = isUpdate && baseline ? changedProperties(baseline, edited) : edited;
+        if (!isPresent(Object.keys(properties))) {
+            setRefusal(isUpdate ? "Nothing changed." : "Fill in at least one field.");
+            return;
+        }
+        setRefusal(null);
+        onSubmit(properties);
+    }
+    return (_jsx(Dialog, { open: open, onOpenChange: onOpenChange, children: _jsxs(DialogContent, { className: "flex max-h-[85vh] flex-col overflow-hidden", children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { text: copy.title }), _jsxs(DialogDescription, { children: [copy.description, " Shape ", _jsx("code", { className: "font-mono", children: compactUri(actionShape) }), "."] })] }), _jsxs("div", { className: "min-h-0 flex-1 overflow-y-auto", children: [isLoading && _jsx(LoadingRows, { rows: 4 }), hasShapesError && _jsx(StatusText, { children: "Failed to load the form for this shape." }), !isLoading && !hasShapesError && !shapesTurtle && _jsx(StatusText, { children: "This shape defines no fields." }), shapesTurtle && (_jsx(ShaclForm, { shapes: shapesTurtle, shapeSubject: actionShape, values: valuesTurtle, valuesSubject: subjectIri, collapse: "open", formRef: attachForm }))] }), refusal && (_jsx(StatusText, { className: "text-error-foreground", role: "alert", children: refusal })), _jsxs(DialogFooter, { children: [_jsx(Button, { variant: "tertiary", size: "sm", onClick: () => onOpenChange(false), children: "Cancel" }), _jsx(Button, { size: "sm", onClick: submit, isLoading: isPending, disabled: !shapesTurtle, children: copy.submitLabel })] })] }) }));
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ChatPreview.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/ChatPreview.tsx"],"names":[],"mappings":"AAmBA,KAAK,gBAAgB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AA6DlE,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,2CAuClD"}

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

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { compactUri } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { useMemo } from "react";
+import { safeIri } from "../../namespaces.js";
+import { LoadingRows, StatusText } from "../RawTriples.js";
+import { actionShapesForTypes } from "./action-shapes.js";
+import { Badge } from "#components/badge/index";
+import { findEntityNode, GenericView, getEntityView, rdfGraphToNodesAndEdges, sectionLabelClass, useSparqlConstruct, } from "#ldo-ui";
+import { cn } from "#lib/utils";
+function entitySubgraphQuery(entityIri) {
+    const term = `<${safeIri(entityIri)}>`;
+    return `CONSTRUCT { ${term} ?p ?o . } WHERE { ${term} ?p ?o . }`;
+}
+function useEntityNode(entityIri) {
+    const { data: graph, isLoading, error, } = useSparqlConstruct({
+        query: entitySubgraphQuery(entityIri),
+        queryKey: ["data-explorer", "entity-chat-preview", entityIri],
+    });
+    const node = useMemo(() => {
+        if (!graph)
+            return undefined;
+        return findEntityNode(rdfGraphToNodesAndEdges(graph).nodes, entityIri);
+    }, [graph, entityIri]);
+    return { node, isLoading, error };
+}
+function ActionShapeRow(props) {
+    const { shape, nodeData } = props;
+    const ShapeView = getEntityView(shape.targetRdfTypes[0], shape.iri);
+    const previewData = nodeData ? { ...nodeData, actionShape: shape.iri } : undefined;
+    return (_jsxs("div", { className: "grid grid-cols-[minmax(0,1fr)_auto] items-center gap-6 px-4 py-3.5", children: [_jsxs("div", { className: "flex min-w-0 flex-col gap-1.5", children: [_jsx("code", { className: "typography-small-medium break-all font-mono text-default-foreground", children: compactUri(shape.iri) }), _jsx("div", { className: "flex flex-wrap gap-1", children: shape.operations.map((operation) => (_jsx(Badge, { variant: "secondary", size: "sm", children: operation }, operation))) })] }), _jsx("div", { className: "flex shrink-0 items-center justify-end pl-2", children: ShapeView && previewData ? (_jsx(ShapeView, { data: previewData })) : (_jsx("span", { className: "typography-tiny italic text-muted-foreground", children: "No preview available" })) })] }));
+}
+export function ChatPreview(props) {
+    const { entityIri, typeIris } = props;
+    const { node, isLoading, error } = useEntityNode(entityIri);
+    const actionShapes = actionShapesForTypes(typeIris);
+    if (isLoading)
+        return _jsx(LoadingRows, { rows: 2 });
+    if (error)
+        return _jsx(StatusText, { children: "Failed to load the chat preview for this record." });
+    if (!node)
+        return _jsx(StatusText, { children: "Nothing to preview." });
+    const EntityView = getEntityView(node.data.type, node.data.actionShape) ?? GenericView;
+    return (_jsxs("div", { className: "flex flex-col gap-6", children: [_jsxs("section", { children: [_jsx("h3", { className: cn(sectionLabelClass, "mb-1.5 text-muted-foreground"), children: "Chat rendering" }), _jsx("div", { className: "max-w-md", children: _jsx(EntityView, { data: node.data }) })] }), _jsxs("section", { children: [_jsx("h3", { className: cn(sectionLabelClass, "mb-1.5 text-muted-foreground"), children: "Possible actions" }), isPresent(actionShapes) ? (_jsx("div", { className: "overflow-hidden rounded-xl border border-muted-border", children: actionShapes.map((shape, index) => (_jsx("div", { className: cn(index > 0 && "border-t border-muted-border/50"), children: _jsx(ActionShapeRow, { shape: shape, nodeData: node.data }) }, shape.iri))) })) : (_jsx(StatusText, { children: "No actions target this record's type." }))] })] }));
+}

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

@@ -0,0 +1,10 @@
+import type { RecordActionShape } from "./action-shapes.js";
+type CreateActionProps = {
+    shape: RecordActionShape;
+    label?: string;
+    qualifyLabel: boolean;
+};
+/** Always mints a fresh subject: an addition on a subject that already has state is re-derived as an update. */
+export declare function CreateAction(props: CreateActionProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=CreateAction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CreateAction.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/CreateAction.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAMzD,KAAK,iBAAiB,GAAG;IAAE,KAAK,EAAE,iBAAiB,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CAAC;AAE7F,gHAAgH;AAChH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CAmBpD"}

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

@@ -0,0 +1,41 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { GQLExecuteActionErrorCode } from "@manta-eu/client";
+import { humanizeEntityName } from "@manta-eu/client/shared/agent-mode";
+import { compactUri, iriLocalName } from "@manta-eu/client/shared/rdf-namespaces";
+import { useState } from "react";
+import { toast } from "sonner";
+import { ActionFormDialog } from "./ActionFormDialog.js";
+import { Button } from "#components/button/index";
+import { useExecuteAction } from "#hooks/useExecuteAction";
+import { mintSubjectIri } from "#lib/action-document";
+/** Always mints a fresh subject: an addition on a subject that already has state is re-derived as an update. */
+export function CreateAction(props) {
+    const { shape, label, qualifyLabel } = props;
+    const [subjectIri, setSubjectIri] = useState(null);
+    const name = qualifyLabel
+        ? compactUri(shape.actionShape)
+        : (label ?? humanizeEntityName(iriLocalName(shape.rdfType)));
+    return (_jsxs(_Fragment, { children: [_jsxs(Button, { variant: "secondary", size: "sm", onClick: () => setSubjectIri(mintSubjectIri(shape.rdfType)), children: ["New ", name] }), subjectIri && (_jsx(CreateDialog, { subjectIri: subjectIri, shape: shape, onClose: () => setSubjectIri(null) }, subjectIri))] }));
+}
+function CreateDialog(props) {
+    const { subjectIri, shape, onClose } = props;
+    const { addition, isPending } = useExecuteAction({
+        subjectIri,
+        rdfType: shape.rdfType,
+        actionShape: shape.actionShape,
+    });
+    async function submit(properties) {
+        const result = await addition(properties);
+        if (result.success) {
+            toast.success("Creation started", { description: "Manta is applying the change in the background." });
+            onClose();
+            return;
+        }
+        if (result.code === GQLExecuteActionErrorCode.Conflict) {
+            toast.warning("A creation is already running for this record", { description: "Try again once it finishes." });
+            return;
+        }
+        toast.error("Failed to start the creation", { description: result.error });
+    }
+    return (_jsx(ActionFormDialog, { open: true, onOpenChange: (nextOpen) => !nextOpen && onClose(), mode: "create", actionShape: shape.actionShape, subjectIri: subjectIri, triples: [], isPending: isPending, onSubmit: submit }));
+}

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

@@ -0,0 +1,13 @@
+import { type TripleRow } from "#routes/data-explorer/triples";
+type FieldListProps = {
+    triples: TripleRow[];
+    subjectIri?: string;
+    derivedFacts?: ReadonlySet<string>;
+};
+export declare function FieldList(props: FieldListProps): import("react/jsx-runtime").JSX.Element;
+type FieldsProps = {
+    iri: string;
+};
+export declare function Fields(props: FieldsProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=Fields.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Fields.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/Fields.tsx"],"names":[],"mappings":"AAUA,OAAO,EAA+C,KAAK,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAuB5G,KAAK,cAAc,GAAG;IAAE,OAAO,EAAE,SAAS,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAExG,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,2CAqB9C;AAED,KAAK,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnC,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,2CAWxC"}

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

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { humanizeEntityName } from "@manta-eu/client/shared/agent-mode";
+import { iriLocalName, wellKnownPredicates } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { Fragment, useState } from "react";
+import { Link } from "react-router";
+import { entityPath } from "../../namespaces.js";
+import { ArrowLinkIcon, arrowLinkClass } from "../ArrowLink.js";
+import { LoadingRows, StatusText } from "../RawTriples.js";
+import { Button } from "#components/button/index";
+import { buildExplainPath, formatPropertyLabel, OntologyTermText, useFactMeasures } from "#ldo-ui";
+import { derivedFactKey, useDerivedFacts, useTriples } from "#routes/data-explorer/triples";
+import { formatLiteralValue, groupFieldRows, isBooleanDatatype, isNumericDatatype, } from "#routes/data-explorer/values";
+function datalogObjectTerm(row) {
+    if (row.objectIsIri)
+        return row.object;
+    const { datatype } = row;
+    if (isNumericDatatype(datatype) || isBooleanDatatype(datatype))
+        return row.object;
+    return JSON.stringify(row.object);
+}
+const visibleFieldRows = 5;
+const noDerivedFacts = new Set();
+export function FieldList(props) {
+    const { triples, subjectIri, derivedFacts } = props;
+    const fields = triples.filter((row) => row.predicate !== wellKnownPredicates.type);
+    const measures = useFactMeasures(fields.map((row) => row.predicate));
+    if (!isPresent(fields))
+        return _jsx(StatusText, { children: "No fields." });
+    return (_jsx("div", { className: "flex flex-col", children: groupFieldRows(fields).map((group) => (_jsx(FieldGroupSection, { subjectIri: subjectIri, group: group, derivedFacts: derivedFacts ?? noDerivedFacts, measure: measures.get(group.predicate) }, group.predicate))) }));
+}
+export function Fields(props) {
+    const { iri } = props;
+    const { triples, isLoading, error } = useTriples(iri);
+    const derivedFacts = useDerivedFacts(iri);
+    if (isLoading)
+        return _jsx(LoadingRows, {});
+    if (error)
+        return _jsx(StatusText, { children: "Failed to load fields." });
+    return _jsx(FieldList, { triples: triples, subjectIri: iri, derivedFacts: derivedFacts });
+}
+function FieldGroupSection(props) {
+    const { subjectIri, group, derivedFacts, measure } = props;
+    const [expanded, setExpanded] = useState(false);
+    const rows = expanded ? group.rows : group.rows.slice(0, visibleFieldRows);
+    const hiddenCount = group.rows.length - rows.length;
+    return (_jsxs("div", { className: "-mx-2 grid grid-cols-[minmax(0,6.5rem)_minmax(0,1fr)_auto] items-baseline gap-x-3 gap-y-2.5 rounded-md border-t border-muted-border/50 px-2 py-3.5 transition-colors hover:bg-muted/30 sm:grid-cols-[minmax(0,12.5rem)_minmax(0,1fr)_auto] sm:gap-x-5", children: [_jsxs("span", { className: "typography-small min-w-0 break-words text-muted-foreground", children: [_jsx(OntologyTermText, { term: group.predicate, fallbackLabel: formatPropertyLabel(group.predicate), className: "typography-small first-letter:uppercase" }), group.rows.length > 1 && (_jsx("span", { className: "typography-tiny ml-1.5 tabular-nums text-muted-foreground/60", children: group.rows.length }))] }), rows.map((row, index) => (_jsxs(Fragment, { children: [index > 0 && _jsx("span", {}), _jsx(FieldValue, { row: row, measure: measure }), subjectIri && derivedFacts.has(derivedFactKey(row.predicate, row.object)) ? (_jsx(Link, { to: buildExplainPath({ subject: subjectIri, predicate: row.predicate, object: datalogObjectTerm(row) }), className: "typography-small text-muted-foreground hover:text-primary hover:underline", children: "Why?" })) : (_jsx("span", {}))] }, `${row.object}:${index}`))), (hiddenCount > 0 || expanded) && (_jsx(Button, { variant: "ghost", size: "xs", className: "col-start-2 h-auto w-fit p-1 text-primary", onClick: () => setExpanded(!expanded), children: expanded ? "Show less" : `Show all ${group.rows.length.toLocaleString()}` }))] }));
+}
+function FieldValue(props) {
+    const { row, measure } = props;
+    if (!row.objectIsIri) {
+        return (_jsx("span", { className: "typography-body min-w-0 break-words text-default-foreground", children: formatLiteralValue(row.object, row.datatype, measure) }));
+    }
+    return (_jsx("span", { className: "typography-body min-w-0 break-words text-default-foreground", children: _jsxs(Link, { to: entityPath(row.object), className: arrowLinkClass, children: [_jsx(OntologyTermText, { term: row.object, fallbackLabel: humanizeEntityName(iriLocalName(row.object)), className: "typography-body text-primary" }), _jsx(ArrowLinkIcon, {})] }) }));
+}

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

@@ -0,0 +1,6 @@
+type IncomingReferencesProps = {
+    iri: string;
+};
+export declare function IncomingReferences(props: IncomingReferencesProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=IncomingReferences.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IncomingReferences.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/IncomingReferences.tsx"],"names":[],"mappings":"AAcA,KAAK,uBAAuB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/C,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,2CAwDhE"}

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

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { useState } from "react";
+import { useDebounceValue } from "usehooks-ts";
+import { classRef, entityPath } from "../../namespaces.js";
+import { CountLabel } from "../CountLabel.js";
+import { LoadMoreButton } from "../LoadMoreButton.js";
+import { ModifiedAgo } from "../ModifiedAgo.js";
+import { EntityName, LinkList, LinkRow, LoadingRows, StatusText } from "../RawTriples.js";
+import { SegmentBuilder } from "../SegmentBuilder.js";
+import { formatPropertyLabel } from "#ldo-ui";
+import { hasActiveConditions } from "#routes/data-explorer/filter-query";
+import { useReferencesTo, useReferencesToCount } from "#routes/data-explorer/records";
+import { referenceSubjectAnchor } from "#routes/data-explorer/reference-query";
+export function IncomingReferences(props) {
+    const { iri } = props;
+    const [filter, setFilter] = useState({ groups: [] });
+    const [debouncedFilter] = useDebounceValue(filter, 300);
+    const { references, isLoading, isRefetching, error, hasMore, isLoadingMore, loadMore } = useReferencesTo(iri, debouncedFilter);
+    const { count: queriedCount, error: countError } = useReferencesToCount(iri, debouncedFilter, hasMore);
+    const isFiltered = hasActiveConditions(debouncedFilter);
+    const isSettled = !isLoading && !isRefetching && !error;
+    const count = isSettled && !hasMore ? references.length : queriedCount;
+    return (_jsxs("div", { className: "flex flex-col gap-3", children: [_jsx(SegmentBuilder, { anchor: referenceSubjectAnchor(iri), filter: filter, onChange: setFilter }), _jsx(CountLabel, { count: count, isFiltered: isFiltered, hasError: isPresent(countError) }), isLoading && _jsx(LoadingRows, {}), error && _jsx(StatusText, { children: "Failed to load references." }), !isLoading && !error && !isPresent(references) && (_jsx(StatusText, { children: isFiltered ? "No references match this filter." : "Nothing references this record." })), isPresent(references) && (_jsx(LinkList, { isStale: isRefetching, children: references.map((reference) => {
+                    const type = reference.typeIri ? classRef(reference.typeIri) : undefined;
+                    return (_jsxs(LinkRow, { to: entityPath(reference.iri), children: [_jsxs("div", { className: "min-w-0 flex-1", children: [_jsx(EntityName, { iri: reference.iri }), _jsxs("span", { className: "typography-tiny block text-muted-foreground", children: [type && _jsx("span", { className: "after:mx-1.5 after:content-['\u00B7']", children: type.localName }), "via", " ", formatPropertyLabel(reference.predicate)] })] }), _jsx(ModifiedAgo, { modified: reference.modified })] }, `${reference.predicate}:${reference.iri}`));
+                }) })), _jsx(LoadMoreButton, { hasMore: hasMore, isLoading: isLoadingMore, onClick: () => loadMore() })] }));
+}

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

@@ -0,0 +1,8 @@
+type RecordActionFeedbackProps = {
+    subjectIri: string;
+    planGraphIri: string;
+};
+/** The mutations only start a run; the outcome comes from the PROV-O activities keyed by the returned plan graph. */
+export declare function RecordActionFeedback(props: RecordActionFeedbackProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=RecordActionFeedback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RecordActionFeedback.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/RecordActionFeedback.tsx"],"names":[],"mappings":"AAOA,KAAK,yBAAyB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAK9E,qHAAqH;AACrH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,2CA4EpE"}

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

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { buildActivityHref } from "@manta-eu/client/shared/agent-mode";
+import { isPresent } from "@manta-eu/lib/present";
+import { useQueryClient } from "@tanstack/react-query";
+import { useEffect, useRef, useState } from "react";
+import { Link } from "react-router";
+import { useActionPlanExecutionProvenance } from "#ldo-ui";
+const pollIntervalMs = 2000;
+const pollCeilingMs = 5 * 60 * 1000;
+/** The mutations only start a run; the outcome comes from the PROV-O activities keyed by the returned plan graph. */
+export function RecordActionFeedback(props) {
+    const { subjectIri, planGraphIri } = props;
+    const queryClient = useQueryClient();
+    const [isSettled, setIsSettled] = useState(false);
+    const [gaveUp, setGaveUp] = useState(false);
+    const startedAtRef = useRef(Date.now());
+    const { data } = useActionPlanExecutionProvenance({
+        planGraphIri,
+        refetchIntervalMs: isSettled || gaveUp ? false : pollIntervalMs,
+    });
+    const endedAt = data?.planEndedAtTime;
+    const failure = data?.planErrorMessage ??
+        data?.activities.find((activity) => isPresent(activity.errorMessage))?.errorMessage ??
+        null;
+    // The activity route walks from the plan activity to its handler children, so the plan is the link target.
+    const activityIri = data?.planActivityIri;
+    useEffect(() => {
+        if (!isPresent(endedAt) || isSettled)
+            return;
+        setIsSettled(true);
+        void queryClient.invalidateQueries({ queryKey: ["data-explorer", "triples", subjectIri] });
+    }, [endedAt, isSettled, queryClient, subjectIri]);
+    useEffect(() => {
+        if (isSettled || gaveUp)
+            return;
+        const remainingMs = Math.max(0, startedAtRef.current + pollCeilingMs - Date.now());
+        const timer = setTimeout(() => setGaveUp(true), remainingMs);
+        return () => clearTimeout(timer);
+    }, [isSettled, gaveUp]);
+    if (!isPresent(endedAt)) {
+        if (gaveUp) {
+            return (_jsx("span", { role: "status", className: "typography-tiny text-muted-foreground", children: "Still running - check the activity log" }));
+        }
+        return (_jsx("span", { role: "status", className: "typography-tiny text-muted-foreground", children: "Applying..." }));
+    }
+    if (isPresent(failure)) {
+        return (_jsx("span", { role: "status", className: "typography-tiny text-error-foreground", title: failure, children: "Failed" }));
+    }
+    if (!isPresent(activityIri)) {
+        return (_jsx("span", { role: "status", className: "typography-tiny text-muted-foreground", children: "Applied" }));
+    }
+    return (_jsx("span", { role: "status", children: _jsx(Link, { to: buildActivityHref(activityIri), className: "typography-tiny text-muted-foreground hover:underline", children: "Applied - see what changed" }) }));
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"RecordActions.d.ts","sourceRoot":"","sources":["../../../../../src/routes/data-explorer/components/record-detail/RecordActions.tsx"],"names":[],"mappings":"AAcA,KAAK,kBAAkB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE9D,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,2CAsBtD"}

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

@@ -0,0 +1,56 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { GQLExecuteActionErrorCode } from "@manta-eu/client";
+import { compactUri } from "@manta-eu/client/shared/rdf-namespaces";
+import { useState } from "react";
+import { toast } from "sonner";
+import { useRecordActionShapes } from "./action-shapes.js";
+import { ActionFormDialog } from "./ActionFormDialog.js";
+import { CreateAction } from "./CreateAction.js";
+import { RecordActionFeedback } from "./RecordActionFeedback.js";
+import { Button } from "#components/button/index";
+import { DeleteConfirmationDialog } from "#components/layouts/DeleteConfirmationDialog";
+import { useExecuteAction } from "#hooks/useExecuteAction";
+import { useTriples } from "#routes/data-explorer/triples";
+export function RecordActions(props) {
+    const { iri, typeIris } = props;
+    const { shapes, error } = useRecordActionShapes(typeIris);
+    const { triples, isLoading: triplesLoading } = useTriples(iri);
+    if (error)
+        return _jsx("span", { className: "typography-tiny text-muted-foreground", children: "Actions unavailable" });
+    return (_jsx(_Fragment, { children: shapes.map((shape) => (_jsx(ShapeActions, { subjectIri: iri, shape: shape, triples: triples, triplesLoading: triplesLoading, qualifyLabels: shapes.length > 1 }, `${iri}|${shape.actionShape}`))) }));
+}
+function ShapeActions(props) {
+    const { subjectIri, shape, triples, triplesLoading, qualifyLabels } = props;
+    const { update, deletion, isPending } = useExecuteAction({
+        subjectIri,
+        rdfType: shape.rdfType,
+        actionShape: shape.actionShape,
+    });
+    const [isEditing, setIsEditing] = useState(false);
+    const [isConfirmingDelete, setIsConfirmingDelete] = useState(false);
+    const [runGraphIri, setRunGraphIri] = useState(null);
+    const suffix = qualifyLabels ? ` ${compactUri(shape.actionShape)}` : "";
+    async function report(label, start) {
+        const result = await start();
+        if (result.success) {
+            setRunGraphIri(result.namedGraphIri);
+            toast.success(`${label} started`, { description: "Manta is applying the change in the background." });
+            return true;
+        }
+        if (result.code === GQLExecuteActionErrorCode.Conflict) {
+            toast.warning("An action is already running on this record", { description: "Try again once it finishes." });
+            return false;
+        }
+        toast.error(`Failed to start the ${label.toLowerCase()}`, { description: result.error });
+        return false;
+    }
+    async function submitForm(properties) {
+        const started = await report("Update", () => update(properties));
+        if (started)
+            setIsEditing(false);
+    }
+    function confirmDelete() {
+        void report("Deletion", deletion);
+    }
+    return (_jsxs(_Fragment, { children: [runGraphIri && _jsx(RecordActionFeedback, { subjectIri: subjectIri, planGraphIri: runGraphIri }, runGraphIri), shape.supportsCreate && _jsx(CreateAction, { shape: shape, qualifyLabel: qualifyLabels }), shape.supportsUpdate && (_jsxs(Button, { variant: "secondary", size: "sm", onClick: () => setIsEditing(true), disabled: isPending || triplesLoading, children: ["Edit", suffix] })), shape.supportsDelete && (_jsxs(Button, { variant: "destructive", size: "sm", onClick: () => setIsConfirmingDelete(true), disabled: isPending, children: ["Delete", suffix] })), isEditing && (_jsx(ActionFormDialog, { open: true, mode: "update", onOpenChange: (nextOpen) => !nextOpen && setIsEditing(false), actionShape: shape.actionShape, subjectIri: subjectIri, triples: triples, isPending: isPending, onSubmit: submitForm })), isConfirmingDelete && (_jsx(DeleteConfirmationDialog, { title: "Delete in the connected system", description: `Are you sure you want to delete ${compactUri(subjectIri)}? Manta asks the system that owns this record to remove it, and this cannot be undone.`, confirmLabel: "Delete", open: true, onOpenChange: (nextOpen) => !nextOpen && setIsConfirmingDelete(false), onConfirm: confirmDelete, onCancel: () => setIsConfirmingDelete(false) }))] }));
+}