@manta-eu/react 0.1.0

package/dist/hooks/use-action-plans-list.js

@@ -0,0 +1,403 @@
+import { vocabBase } from "@manta-eu/ldo/realm";
+import { m } from "@manta-eu/rdf-lib/namespaces";
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT, sparql } from "ldkit/sparql";
+import { clamp, splitEvery } from "ramda";
+import { match, P } from "ts-pattern";
+import { integrationNamespaces, parseActionPlanDetail, } from "../lib/action-plan-detail.js";
+import { identifierWordRules, splitIdentifierWords } from "../lib/iri-labels.js";
+import { coerceActionPlanState } from "../lib/provenance-state.js";
+import { bindingCount, collectBindings } from "../lib/rdf-helpers.js";
+import { optionsToContext, useSparqlEngine, useSparqlOptions } from "./use-sparql-options.js";
+const df = new DataFactory();
+const defaultLimit = 10;
+const maxLimit = 50;
+const detailTripleLimit = 1000;
+const detailGraphBatchSize = 6;
+const actionPlanStates = ["DRAFT", "RUNNING", "COMPLETED", "FAILED", "TIMED_OUT"];
+function clampLimit(value) {
+    return clamp(1, maxLimit, value ?? defaultLimit);
+}
+function clampOffset(value) {
+    return clamp(0, Infinity, value ?? 0);
+}
+function orderByExpr(orderBy) {
+    const direction = orderBy?.direction === "ASC" ? "ASC" : "DESC";
+    const field = orderBy?.field ?? "STATE";
+    return match(field)
+        .with("STATE", () => `${direction}(?stateOrderValue) ${direction}(?graph)`)
+        .with("MANTA_PRIORITY", "CREATED_AT", () => `${direction}(?graph)`)
+        .exhaustive();
+}
+function stateFilterClause(states) {
+    return match(states)
+        .with(P.nullish, () => "")
+        .otherwise((stateList) => {
+        const stateSet = new Set(actionPlanStates);
+        const normalizedStates = Array.from(new Set(stateList.filter((state) => stateSet.has(state)))).sort();
+        return match(normalizedStates)
+            .with([], () => "FILTER(false) .")
+            .otherwise((validStates) => {
+            const values = validStates.map((state) => sparql `${df.literal(state)}`).join(", ");
+            return `FILTER(?stateValue IN (${values})) .`;
+        });
+    });
+}
+function graphIrisClause(graphIris, variable = "graph") {
+    return match(graphIris)
+        .with(P.nullish, () => "")
+        .with([], () => `VALUES ?${variable} {}`)
+        .otherwise((iris) => {
+        const values = Array.from(new Set(iris), (iri) => sparql `${df.namedNode(iri)}`).join(" ");
+        return `VALUES ?${variable} { ${values} }`;
+    });
+}
+const xsdDateTime = df.namedNode("http://www.w3.org/2001/XMLSchema#dateTime");
+function normalizeSearchTerm(raw) {
+    return splitIdentifierWords(raw).toLowerCase();
+}
+function normalizedGraphExpr() {
+    const replaced = identifierWordRules.reduce((expr, [pattern, replacement]) => `REPLACE(${expr}, "${pattern}", "${replacement}")`, "STR(?graph)");
+    return `LCASE(${replaced})`;
+}
+function searchFilterClause(search) {
+    const trimmed = search?.trim();
+    if (!trimmed)
+        return "";
+    const term = sparql `${df.literal(normalizeSearchTerm(trimmed))}`;
+    return `FILTER (CONTAINS(${normalizedGraphExpr()}, ${term})) .`;
+}
+function integrationMatchExpr(namespaceIris) {
+    return namespaceIris
+        .flatMap((ns) => [
+        `STRSTARTS(STR(?intSubject), "${ns}")`,
+        `STRSTARTS(STR(?intPredicate), "${ns}")`,
+        `(isIRI(?intObject) && STRSTARTS(STR(?intObject), "${ns}"))`,
+    ])
+        .join(" || ");
+}
+function integrationGraphsSubquery(namespaceIris) {
+    return `{ SELECT DISTINCT ?graph WHERE {
+    GRAPH ?graph { ?intSubject ?intPredicate ?intObject . }
+    FILTER (${integrationMatchExpr(namespaceIris)})
+  } }`;
+}
+function integrationsFilterClause(integrations) {
+    return match(integrations)
+        .with(P.nullish, () => "")
+        .with([], () => "FILTER(false) .")
+        .otherwise((selected) => {
+        const unique = Array.from(new Set(selected));
+        const selectedNamespaces = unique
+            .filter((integration) => integration !== "NONE")
+            .map((integration) => integrationNamespaces[integration]);
+        const includeNone = unique.includes("NONE");
+        const allNamespaces = Object.values(integrationNamespaces);
+        if (selectedNamespaces.length > 0 && includeNone) {
+            const allGraphs = integrationGraphsSubquery(allNamespaces);
+            const selectedGraphs = integrationGraphsSubquery(selectedNamespaces);
+            return `MINUS { ${allGraphs} MINUS { ${selectedGraphs} } }`;
+        }
+        if (includeNone)
+            return `MINUS { ${integrationGraphsSubquery(allNamespaces)} }`;
+        if (selectedNamespaces.length > 0)
+            return integrationGraphsSubquery(selectedNamespaces);
+        return "FILTER(false) .";
+    });
+}
+function pendingApprovalGraphsSubquery() {
+    return `{ SELECT DISTINCT ?graph WHERE {
+    GRAPH ?graph {
+      ?manualAction <${m.isManualAction}> true .
+      OPTIONAL { ?manualAction <${m.status}> ?manualActionStatus . }
+    }
+    FILTER (!BOUND(?manualActionStatus) || UCASE(REPLACE(STR(?manualActionStatus), "^.*[#/]", "")) = "PENDING")
+  } }`;
+}
+function approvalFilterClause(approval) {
+    return match(approval)
+        .with(P.nullish, () => "")
+        .with("NEEDS_APPROVAL", () => pendingApprovalGraphsSubquery())
+        .with("NO_PENDING", () => `MINUS { ${pendingApprovalGraphsSubquery()} }`)
+        .exhaustive();
+}
+function lastRunRangeClause(args) {
+    const clauses = [];
+    if (args.lastRunFrom) {
+        clauses.push(sparql `FILTER (BOUND(?latestStarted) && ?latestStarted >= ${df.literal(args.lastRunFrom, xsdDateTime)}) .`);
+    }
+    if (args.lastRunTo) {
+        clauses.push(sparql `FILTER (BOUND(?latestStarted) && ?latestStarted <= ${df.literal(args.lastRunTo, xsdDateTime)}) .`);
+    }
+    return clauses.join("\n");
+}
+function commonGraphFilters(args) {
+    return [
+        `FILTER (!CONTAINS(LCASE(STR(?graph)), "shacl")) .`,
+        searchFilterClause(args.search),
+        integrationsFilterClause(args.integrations),
+        approvalFilterClause(args.approval),
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function currentPlanGraphPattern(graphIris) {
+    return `${graphIrisClause(graphIris)}
+  GRAPH ?graph {
+    ?candidateSubject ?candidatePredicate ?candidateObject EXPLICIT FALSE .
+  }`;
+}
+function provenancePlanGraphPattern(graphIris) {
+    return `${graphIrisClause(graphIris, "candidatePlanGraph")}
+  ?candidateActivity :topLevelRunOf ?candidatePlanGraph .
+  BIND(?candidatePlanGraph AS ?graph)`;
+}
+function savedPlanGraphPattern(graphIris) {
+    return `${graphIrisClause(graphIris)}
+  GRAPH ?graph { ?savedPlan a :ActionPlan . }
+  FILTER (?savedPlan = ?graph)`;
+}
+function candidateGraphsSubquery(availability, graphIris) {
+    const currentPlans = currentPlanGraphPattern(graphIris);
+    const pastRuns = provenancePlanGraphPattern(graphIris);
+    const candidates = match(availability ?? "CURRENT")
+        .with("CURRENT", () => currentPlans)
+        .with("PAST_RUNS_ONLY", () => `${pastRuns}\nMINUS { ${currentPlans} }`)
+        .with("ALL", () => `{ ${currentPlans} }\nUNION\n{ ${pastRuns} }\nUNION\n{ ${savedPlanGraphPattern(graphIris)} }`)
+        .exhaustive();
+    const query = SELECT.DISTINCT `?graph`.WHERE `${candidates}`.build();
+    return `{ ${query} }`;
+}
+function currentPlansWithCountsSubquery(graphIris) {
+    const query = SELECT `
+    ?graph
+    (COUNT(*) AS ?currentStatements)
+    (COUNT(DISTINCT ?currentSubject) AS ?currentSubjects)
+  `.WHERE `
+    ${graphIrisClause(graphIris)}
+    GRAPH ?graph {
+      ?currentSubject ?currentPredicate ?currentObject EXPLICIT FALSE .
+    }
+  `.GROUP_BY `?graph`.build();
+    return `{ ${query} }`;
+}
+function nonCurrentPlansWithZeroCountsPattern(availability, graphIris) {
+    const pastRuns = provenancePlanGraphPattern(graphIris);
+    const candidates = match(availability)
+        .with("PAST_RUNS_ONLY", () => pastRuns)
+        .with("ALL", () => `{ ${pastRuns} }\nUNION\n{ ${savedPlanGraphPattern(graphIris)} }`)
+        .exhaustive();
+    const query = SELECT.DISTINCT `?graph`.WHERE `
+    { ${candidates} }
+    MINUS { ${currentPlanGraphPattern(graphIris)} }
+  `.build();
+    return `{ { ${query} }
+    BIND(0 AS ?currentStatements)
+    BIND(0 AS ?currentSubjects)
+  }`;
+}
+function planRowsPattern(availability, graphIris) {
+    const currentPlans = currentPlansWithCountsSubquery(graphIris);
+    return match(availability ?? "CURRENT")
+        .with("CURRENT", () => currentPlans)
+        .with("PAST_RUNS_ONLY", () => nonCurrentPlansWithZeroCountsPattern("PAST_RUNS_ONLY", graphIris))
+        .with("ALL", () => `${currentPlans}\nUNION\n${nonCurrentPlansWithZeroCountsPattern("ALL", graphIris)}`)
+        .exhaustive();
+}
+function latestRunPatternClause() {
+    return `
+    OPTIONAL { ?graph :planState ?rawStateValue . }
+    OPTIONAL { ?graph :latestStarted ?latestStarted . }
+    OPTIONAL { ?graph :latestDryRun ?dryRunFlag . }
+    BIND(COALESCE(?rawStateValue, "DRAFT") AS ?stateValue)
+  `;
+}
+export function buildListQuery(args) {
+    const limit = clampLimit(args.limit);
+    const offset = clampOffset(args.offset);
+    const stateClause = stateFilterClause(args.states);
+    const lastRunClause = lastRunRangeClause(args);
+    const orderBy = orderByExpr(args.orderBy);
+    return SELECT `
+    ?graph
+    (COALESCE(SAMPLE(?currentStatements), 0) AS ?statements)
+    (COALESCE(SAMPLE(?currentSubjects), 0) AS ?subjects)
+    ?stateValue
+    ?stateOrderValue
+    ?latestStarted
+    ?dryRunFlag
+  `.WHERE `
+    ${planRowsPattern(args.availability, args.graphIris)}
+    ${commonGraphFilters(args)}
+    ${latestRunPatternClause()}
+    BIND(
+      IF(?stateValue = "DRAFT", 1,
+        IF(?stateValue = "FAILED", 2,
+          IF(?stateValue = "TIMED_OUT", 3,
+            IF(?stateValue = "RUNNING", 4,
+              IF(?stateValue = "COMPLETED", 5, 1))))) AS ?stateOrderValue
+    )
+    ${stateClause}
+    ${lastRunClause}
+  `.GROUP_BY `?graph ?stateValue ?stateOrderValue ?latestStarted ?dryRunFlag`.ORDER_BY `${orderBy}`
+        .LIMIT(limit)
+        .OFFSET(offset)
+        .build();
+}
+export function buildCountQuery(args) {
+    const stateFilter = stateFilterClause(args.states);
+    const lastRunClause = lastRunRangeClause(args);
+    const provenanceClauses = stateFilter || lastRunClause
+        ? [latestRunPatternClause(), stateFilter, lastRunClause].filter(Boolean).join("\n")
+        : "";
+    return SELECT `(COUNT(DISTINCT ?graph) AS ?totalCount)`.WHERE `
+    ${candidateGraphsSubquery(args.availability, args.graphIris)}
+    ${commonGraphFilters(args)}
+    ${provenanceClauses}
+  `.build();
+}
+function buildDetailSubquery(planGraphIri) {
+    const planGraphNode = df.namedNode(planGraphIri);
+    return SELECT `?planGraph ?subject ?predicate ?object`.WHERE `
+    BIND(${planGraphNode} AS ?planGraph)
+    GRAPH ${planGraphNode} {
+      ?subject ?predicate ?object .
+    }
+  `
+        .LIMIT(detailTripleLimit)
+        .build();
+}
+function buildDetailBatchQuery(planGraphIris) {
+    const subqueries = planGraphIris.map((iri) => `{ ${buildDetailSubquery(iri)} }`);
+    return `SELECT ?planGraph ?subject ?predicate ?object WHERE {\n${subqueries.join("\nUNION\n")}\n}`;
+}
+function groupDetailBindings(bindings) {
+    const byGraph = new Map();
+    for (const binding of bindings) {
+        const planGraph = binding.get("planGraph")?.value;
+        const subject = binding.get("subject")?.value;
+        const predicate = binding.get("predicate")?.value;
+        const object = binding.get("object");
+        if (!planGraph || !subject || !predicate || !object)
+            continue;
+        let graph = byGraph.get(planGraph);
+        if (!graph) {
+            graph = new Map();
+            byGraph.set(planGraph, graph);
+        }
+        let node = graph.get(subject);
+        if (!node) {
+            node = new Map();
+            graph.set(subject, node);
+        }
+        let terms = node.get(predicate);
+        if (!terms) {
+            terms = [];
+            node.set(predicate, terms);
+        }
+        terms.push(object);
+    }
+    return byGraph;
+}
+function countActions(graph) {
+    const actionShapeIri = `${vocabBase}actionShape`;
+    const stateIri = `${vocabBase}state`;
+    const rdfTypeIri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+    const typeCounts = new Map();
+    let total = 0;
+    let completed = 0;
+    for (const [, predicates] of graph) {
+        if (!predicates.has(actionShapeIri))
+            continue;
+        total += 1;
+        const types = predicates.get(rdfTypeIri) ?? [];
+        for (const t of types) {
+            const raw = t.value;
+            const short = raw.split(/[#/]/).pop() ?? raw;
+            typeCounts.set(short, (typeCounts.get(short) ?? 0) + 1);
+        }
+        const stateTerms = predicates.get(stateIri) ?? [];
+        if (stateTerms.some((term) => term.value === "COMPLETED"))
+            completed += 1;
+    }
+    const actionCountByType = Array.from(typeCounts.entries()).map(([typeName, count]) => ({ typeName, count }));
+    return { actionCount: total, completedActionCount: completed, actionCountByType };
+}
+export function buildActionPlanSummary(binding, detailGraph) {
+    const hasCurrentFacts = binding.statements > 0;
+    const parsed = parseActionPlanDetail(detailGraph, binding.graph, {
+        stateOverride: binding.state,
+        hasCurrentFacts,
+        hasExecutionHistory: binding.lastRunAt !== null,
+    });
+    const counts = countActions(detailGraph);
+    return {
+        ...parsed,
+        statements: binding.statements,
+        subjects: binding.subjects,
+        lastRunAt: binding.lastRunAt,
+        dryRun: binding.dryRun,
+        ...counts,
+    };
+}
+async function fetchTotalCount(engine, context, variables) {
+    const stream = await engine.queryBindings(buildCountQuery(variables), context);
+    const bindings = await collectBindings(stream);
+    const [first] = bindings;
+    return first ? (bindingCount(first, "totalCount") ?? 0) : 0;
+}
+async function fetchPageBindings(engine, context, variables) {
+    const stream = await engine.queryBindings(buildListQuery(variables), context);
+    const bindings = await collectBindings(stream);
+    return bindings.flatMap((b) => {
+        const iri = b.get("graph")?.value;
+        if (!iri)
+            return [];
+        return [
+            {
+                graph: iri,
+                state: coerceActionPlanState(b.get("stateValue")?.value),
+                statements: bindingCount(b, "statements") ?? 0,
+                subjects: bindingCount(b, "subjects") ?? 0,
+                lastRunAt: b.get("latestStarted")?.value ?? null,
+                dryRun: b.get("dryRunFlag")?.value === "true",
+            },
+        ];
+    });
+}
+async function fetchDetailsForPage(engine, context, pageBindings) {
+    if (pageBindings.length === 0)
+        return new Map();
+    const bindingGroups = [];
+    for (const batch of splitEvery(detailGraphBatchSize, pageBindings)) {
+        const stream = await engine.queryBindings(buildDetailBatchQuery(batch.map((binding) => binding.graph)), context);
+        bindingGroups.push(await collectBindings(stream));
+    }
+    const bindings = bindingGroups.flat();
+    return groupDetailBindings(bindings);
+}
+export const actionPlansListQueryKeyRoot = ["ldo-ui", "action-plans-list"];
+export function useActionPlansList(config = {}) {
+    const { enabled = true, refetchInterval, ...variables } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: [...actionPlansListQueryKeyRoot, variables, options, engine],
+        queryFn: async () => {
+            const context = optionsToContext(options);
+            const [pageBindings, totalCount] = await Promise.all([
+                fetchPageBindings(engine, context, variables),
+                fetchTotalCount(engine, context, variables),
+            ]);
+            if (pageBindings.length === 0)
+                return { plans: [], totalCount };
+            const detailsByGraph = await fetchDetailsForPage(engine, context, pageBindings);
+            const plans = pageBindings.map((b) => buildActionPlanSummary(b, detailsByGraph.get(b.graph) ?? new Map()));
+            return { plans, totalCount };
+        },
+        enabled,
+        refetchInterval,
+        placeholderData: config.keepPreviousData ? keepPreviousData : undefined,
+    });
+}

package/dist/hooks/use-activity-changeset.d.ts

@@ -0,0 +1,10 @@
+import { type RDF } from "ldkit/rdf";
+import type { ActivityChangeSetResult } from "../lib/activity-changeset.js";
+export type { ActivityChangeGroup, ActivityChangeKind, ActivityChangeSetResult, ActivityChangeTriple, ActivityFieldDiff, } from "../lib/activity-changeset.js";
+export type UseActivityChangeSetOptions = {
+    activityIri: string | undefined;
+    enabled?: boolean;
+};
+export declare function bindingsToGeneratedIris(bindings: RDF.Bindings[]): Map<string, string[]>;
+export declare function useActivityChangeSet(config: UseActivityChangeSetOptions): import("@tanstack/react-query").UseQueryResult<ActivityChangeSetResult, Error>;
+//# sourceMappingURL=use-activity-changeset.d.ts.map

package/dist/hooks/use-activity-changeset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-activity-changeset.d.ts","sourceRoot":"","sources":["../../src/hooks/use-activity-changeset.ts"],"names":[],"mappings":"AAGA,OAAO,EAAe,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AAElD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAOzE,YAAY,EACV,mBAAmB,EACnB,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,2BAA2B,CAAC;AAMnC,MAAM,MAAM,2BAA2B,GAAG;IACxC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAwCF,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAevF;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,2BAA2B,kFA8DvE"}

package/dist/hooks/use-activity-changeset.js

@@ -0,0 +1,105 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { baseIri, cs, m, prependMissingSparqlPrefixes, rdf } from "@manta-eu/rdf-lib/namespaces";
+import { useQuery } from "@tanstack/react-query";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { collectChangeSetIris, collectChangeSetPredicates, processChangeSetBindings } from "../lib/activity-changeset.js";
+import { bindingsToInstanceLabels, buildInstanceLabelsQuery } from "../lib/instance-labels.js";
+import { bindingsToOntologyTerms, buildOntologyTermsQuery } from "../lib/ontology-terms.js";
+import { bindingNodeIri, collectBindings } from "../lib/rdf-helpers.js";
+import { optionsToContext, useSparqlEngine, useSparqlOptions } from "./use-sparql-options.js";
+const df = new DataFactory();
+const ontologyGraphIri = `${baseIri}ontology`;
+function buildChangeSetQuery(planActivityIri) {
+    const planActivityNode = df.namedNode(planActivityIri);
+    return prependMissingSparqlPrefixes(SELECT `?kind ?stmtSubject ?predicate ?object ?child ?childStart ?childEnd`.WHERE `
+    ?child prov:wasInformedBy ${planActivityNode} ;
+           <${m.changeSet}> ?changeSet .
+    OPTIONAL { ?child prov:startedAtTime ?childStart }
+    OPTIONAL { ?child prov:endedAtTime ?childEnd }
+    {
+      ?changeSet <${cs.addition}> ?statement .
+      BIND("addition" AS ?kind)
+    }
+    UNION
+    {
+      ?changeSet <${cs.removal}> ?statement .
+      BIND("removal" AS ?kind)
+    }
+    ?statement <${rdf.subject}> ?stmtSubject ;
+               <${rdf.predicate}> ?predicate ;
+               <${rdf.object}> ?object .
+  `.ORDER_BY `?stmtSubject ?predicate`.build());
+}
+// Keyed on the child activity: the change's own subject is a blank node, and blank-node labels do not
+// survive into a second query.
+function buildGeneratedEntitiesQuery(planActivityIri) {
+    const planActivityNode = df.namedNode(planActivityIri);
+    return prependMissingSparqlPrefixes(SELECT `?child ?generated`.WHERE `
+    ?child prov:wasInformedBy ${planActivityNode} ;
+           prov:generated ?generated .
+  `.build());
+}
+export function bindingsToGeneratedIris(bindings) {
+    const byChild = new Map();
+    for (const binding of bindings) {
+        const child = bindingNodeIri(binding, "child");
+        const generated = bindingNodeIri(binding, "generated");
+        if (!child || !generated)
+            continue;
+        const entry = byChild.get(child) ?? new Set();
+        entry.add(generated);
+        byChild.set(child, entry);
+    }
+    return new Map([...byChild].map(([child, iris]) => [child, [...iris].sort()]));
+}
+export function useActivityChangeSet(config) {
+    const { activityIri, enabled = true } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: ["ldo-ui", "activity-changeset", activityIri, engine, options],
+        enabled: enabled && isPresent(activityIri),
+        queryFn: async () => {
+            if (!activityIri)
+                return { groups: [] };
+            const query = buildChangeSetQuery(activityIri);
+            const stream = await engine.queryBindings(query, optionsToContext(options));
+            const bindings = await collectBindings(stream);
+            const iris = collectChangeSetIris(bindings);
+            let labels = new Map();
+            if (isPresent(iris)) {
+                try {
+                    const labelStream = await engine.queryBindings(buildInstanceLabelsQuery(iris), optionsToContext(options));
+                    labels = bindingsToInstanceLabels(await collectBindings(labelStream));
+                }
+                catch (error) {
+                    console.debug("Failed to load change-set instance labels", error);
+                    labels = new Map();
+                }
+            }
+            const predicates = collectChangeSetPredicates(bindings);
+            let terms = new Map();
+            if (isPresent(predicates)) {
+                try {
+                    const termStream = await engine.queryBindings(buildOntologyTermsQuery(predicates, ontologyGraphIri), optionsToContext(options));
+                    terms = bindingsToOntologyTerms(await collectBindings(termStream));
+                }
+                catch (error) {
+                    console.debug("Failed to load ontology terms for change set", error);
+                    terms = new Map();
+                }
+            }
+            let generatedIris = new Map();
+            try {
+                const generatedStream = await engine.queryBindings(buildGeneratedEntitiesQuery(activityIri), optionsToContext(options));
+                generatedIris = bindingsToGeneratedIris(await collectBindings(generatedStream));
+            }
+            catch (error) {
+                console.debug("Failed to load the entities this run generated", error);
+                generatedIris = new Map();
+            }
+            return processChangeSetBindings(bindings, labels, terms, generatedIris);
+        },
+    });
+}

package/dist/hooks/use-activity-feed.d.ts

@@ -0,0 +1,35 @@
+import type { RDF } from "ldkit/rdf";
+export type ActivityAgentKind = "Person" | "SoftwareAgent";
+export type ActivityFeedItem = {
+    iri: string;
+    startedAtTime: string;
+    endedAtTime: string | null;
+    errorMessage: string | null;
+    planLabel: string;
+    planGraphIri: string | null;
+    agentLabel: string | null;
+    agentKind: ActivityAgentKind;
+    affectedIris: string[];
+    affectedCount: number;
+    affectedTypeName: string | null;
+    humanAffectedLabel: string;
+};
+export type ActivityFeedResult = {
+    activities: ActivityFeedItem[];
+    totalCount: number;
+};
+export type ActivityStatusFilter = "all" | "completed" | "failed" | "running";
+export type ActivityFeedFilters = {
+    search?: string;
+    status?: ActivityStatusFilter;
+};
+export type UseActivityFeedOptions = {
+    page?: number;
+    pageSize?: number;
+    enabled?: boolean;
+    filters?: ActivityFeedFilters;
+};
+export declare function activityFilterClauses(filters: ActivityFeedFilters | undefined): string;
+export declare function processActivityFeedBindings(bindings: RDF.Bindings[], pageSize: number): ActivityFeedItem[];
+export declare function useActivityFeed(config?: UseActivityFeedOptions): import("@tanstack/react-query").UseQueryResult<ActivityFeedResult, Error>;
+//# sourceMappingURL=use-activity-feed.d.ts.map

package/dist/hooks/use-activity-feed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-activity-feed.d.ts","sourceRoot":"","sources":["../../src/hooks/use-activity-feed.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAQrC,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,eAAe,CAAC;AAE3D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE9E,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,oBAAoB,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC/B,CAAC;AAIF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,GAAG,MAAM,CA0BtF;AAgED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,EAAE,CA6F1G;AAED,wBAAgB,eAAe,CAAC,MAAM,GAAE,sBAA2B,6EA4BlE"}