@manta-eu/react 0.1.0

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

@@ -0,0 +1,180 @@
+import { humanCount } from "@manta-eu/lib/humanize";
+import { prependMissingSparqlPrefixes, prov } from "@manta-eu/rdf-lib/namespaces";
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import { SELECT } from "ldkit/sparql";
+import { match } from "ts-pattern";
+import { shortenUri } from "../graph/graph-utils.js";
+import { extractLabel } from "../lib/iri-labels.js";
+import { bindingCount, bindingValue, collectBindings, sanitizeSparqlLiteral } from "../lib/rdf-helpers.js";
+import { optionsToContext, useSparqlEngine, useSparqlOptions } from "./use-sparql-options.js";
+// SPARQL FILTERs for the activity pattern; empty when no filter is set, so the
+// default feed query is unchanged.
+export function activityFilterClauses(filters) {
+    if (!filters)
+        return "";
+    const clauses = [];
+    const search = filters.search?.trim();
+    if (search) {
+        clauses.push(`FILTER(CONTAINS(LCASE(STR(?plan)), LCASE("${sanitizeSparqlLiteral(search)}")))`);
+    }
+    const statusClause = match(filters.status)
+        .with("completed", () => "FILTER(EXISTS { ?activity prov:endedAtTime ?endedFilter } && NOT EXISTS { ?activity :errorMessage ?errorFilter })")
+        .with("failed", () => "FILTER EXISTS { ?activity :errorMessage ?errorFilter }")
+        .with("running", () => "FILTER(NOT EXISTS { ?activity prov:endedAtTime ?endedFilter } && NOT EXISTS { ?activity :errorMessage ?errorFilter })")
+        .otherwise(() => null);
+    if (statusClause)
+        clauses.push(statusClause);
+    return clauses.join("\n        ");
+}
+function buildActivityFeedQuery(limit, offset, filters) {
+    const query = SELECT `
+    ?activity ?startedAt ?endedAt ?errorMessage ?planGraph
+    ?agentType ?agentLabel ?childUsed
+  `.WHERE `
+    {
+      SELECT DISTINCT ?activity ?startedAt WHERE {
+        ?activity a prov:Activity ;
+                  prov:used ?plan ;
+                  prov:startedAtTime ?startedAt .
+        ?plan a prov:Plan .
+        FILTER NOT EXISTS { ?activity :dryRun ?dryRunFlag . FILTER(STR(?dryRunFlag) = "true") }
+        ${activityFilterClauses(filters)}
+      }
+      ORDER BY DESC(?startedAt) ?activity
+      LIMIT ${String(limit)}
+      OFFSET ${String(offset)}
+    }
+    ?activity prov:used ?planGraph .
+    ?planGraph a prov:Plan .
+    OPTIONAL { ?activity prov:endedAtTime ?endedAt }
+    OPTIONAL { ?activity :errorMessage ?errorMessage }
+    OPTIONAL {
+      ?activity prov:wasAssociatedWith ?agent .
+      ?agent a ?agentType .
+      OPTIONAL { ?agent rdfs:label ?agentLabel }
+    }
+    OPTIONAL {
+      ?child prov:wasInformedBy ?activity ;
+             prov:used ?childUsed .
+    }
+  `.ORDER_BY `DESC(?startedAt) ?activity`.build();
+    return prependMissingSparqlPrefixes(query);
+}
+function buildActivityFeedCountQuery(filters) {
+    const query = SELECT `(COUNT(DISTINCT ?activity) AS ?count)`.WHERE `
+    ?activity a prov:Activity ;
+              prov:used ?plan ;
+              prov:startedAtTime ?startedAt .
+    ?plan a prov:Plan .
+    FILTER NOT EXISTS { ?activity :dryRun ?dryRunFlag . FILTER(STR(?dryRunFlag) = "true") }
+    ${activityFilterClauses(filters)}
+  `.build();
+    return prependMissingSparqlPrefixes(query);
+}
+function parseAgentKind(typeIri) {
+    return typeIri === prov.Person ? "Person" : "SoftwareAgent";
+}
+function entityTypeFromIri(iri) {
+    const [typeName] = shortenUri(iri).split("_");
+    return typeName || null;
+}
+function humanizeTypeName(typeName) {
+    return typeName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase();
+}
+export function processActivityFeedBindings(bindings, pageSize) {
+    const activityMap = new Map();
+    for (const binding of bindings) {
+        const activityIri = bindingValue(binding, "activity");
+        if (!activityIri)
+            continue;
+        const startedAt = bindingValue(binding, "startedAt");
+        if (!startedAt)
+            continue;
+        let entry = activityMap.get(activityIri);
+        if (!entry) {
+            entry = {
+                iri: activityIri,
+                startedAtTime: startedAt,
+                endedAtTime: bindingValue(binding, "endedAt") ?? null,
+                errorMessage: bindingValue(binding, "errorMessage") ?? null,
+                planGraph: bindingValue(binding, "planGraph") ?? null,
+                agentLabel: null,
+                agentKind: "SoftwareAgent",
+                affected: new Set(),
+            };
+            activityMap.set(activityIri, entry);
+        }
+        const agentType = bindingValue(binding, "agentType");
+        if (agentType && entry.agentKind !== "Person") {
+            entry.agentKind = parseAgentKind(agentType);
+        }
+        const agentLabel = bindingValue(binding, "agentLabel");
+        if (agentLabel && !entry.agentLabel) {
+            entry.agentLabel = agentLabel;
+        }
+        const childUsed = bindingValue(binding, "childUsed");
+        if (childUsed) {
+            entry.affected.add(childUsed);
+        }
+    }
+    return Array.from(activityMap.values())
+        .slice(0, pageSize)
+        .map((entry) => {
+        let affectedTypeName = null;
+        let mixed = false;
+        for (const iri of entry.affected) {
+            const typeName = entityTypeFromIri(iri);
+            if (!typeName)
+                continue;
+            if (affectedTypeName == null) {
+                affectedTypeName = typeName;
+            }
+            else if (affectedTypeName !== typeName) {
+                mixed = true;
+                break;
+            }
+        }
+        const resolvedTypeName = mixed ? null : affectedTypeName;
+        const affectedNoun = resolvedTypeName ? humanizeTypeName(resolvedTypeName) : "entity";
+        return {
+            iri: entry.iri,
+            startedAtTime: entry.startedAtTime,
+            endedAtTime: entry.endedAtTime,
+            errorMessage: entry.errorMessage,
+            planLabel: entry.planGraph ? extractLabel(entry.planGraph) || shortenUri(entry.planGraph) : "Action plan",
+            planGraphIri: entry.planGraph,
+            agentLabel: entry.agentLabel,
+            agentKind: entry.agentKind,
+            affectedIris: Array.from(entry.affected),
+            affectedCount: entry.affected.size,
+            affectedTypeName: resolvedTypeName,
+            humanAffectedLabel: humanCount(entry.affected.size, affectedNoun),
+        };
+    });
+}
+export function useActivityFeed(config = {}) {
+    const { page = 1, pageSize = 10, enabled = true, filters } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    const offset = Math.max(0, (page - 1) * pageSize);
+    return useQuery({
+        queryKey: ["ldo-ui", "activity-feed", page, pageSize, filters, engine, options],
+        queryFn: async () => {
+            const context = optionsToContext(options);
+            const [pageStream, countStream] = await Promise.all([
+                engine.queryBindings(buildActivityFeedQuery(pageSize, offset, filters), context),
+                engine.queryBindings(buildActivityFeedCountQuery(filters), context),
+            ]);
+            const [pageBindings, countBindings] = await Promise.all([
+                collectBindings(pageStream),
+                collectBindings(countStream),
+            ]);
+            const activities = processActivityFeedBindings(pageBindings, pageSize);
+            const countBinding = countBindings[0];
+            const totalCount = countBinding ? (bindingCount(countBinding, "count") ?? 0) : 0;
+            return { activities, totalCount };
+        },
+        enabled,
+        placeholderData: keepPreviousData,
+    });
+}

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

@@ -0,0 +1,18 @@
+export type ActivityStatus = "completed" | "failed" | "running";
+export type ActivityDetail = {
+    iri: string;
+    planLabel: string;
+    planGraphIri: string | null;
+    status: ActivityStatus;
+    startedAtTime: string;
+    endedAtTime: string | null;
+    errorMessage: string | null;
+};
+export type UseActivityOptions = {
+    activityIri: string | undefined;
+    enabled?: boolean;
+};
+export declare function buildActivityQuery(activityIri: string): string;
+export declare function statusFor(endedAt: string | null, errorMessage: string | null): ActivityStatus;
+export declare function useActivity(config: UseActivityOptions): import("@tanstack/react-query").UseQueryResult<ActivityDetail | null, Error>;
+//# sourceMappingURL=use-activity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-activity.d.ts","sourceRoot":"","sources":["../../src/hooks/use-activity.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEhE,MAAM,MAAM,cAAc,GAAG;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,cAAc,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,UAarD;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,cAAc,CAK7F;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,kBAAkB,gFAmCrD"}

package/dist/hooks/use-activity.js

@@ -0,0 +1,60 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { prependMissingSparqlPrefixes } from "@manta-eu/rdf-lib/namespaces";
+import { useQuery } from "@tanstack/react-query";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { shortenUri } from "../graph/graph-utils.js";
+import { extractLabel } from "../lib/iri-labels.js";
+import { bindingValue, collectBindings } from "../lib/rdf-helpers.js";
+import { optionsToContext, useSparqlEngine, useSparqlOptions } from "./use-sparql-options.js";
+const df = new DataFactory();
+export function buildActivityQuery(activityIri) {
+    const activityNode = df.namedNode(activityIri);
+    return prependMissingSparqlPrefixes(SELECT `?startedAt ?endedAt ?errorMessage ?planGraph`.WHERE `
+    ${activityNode} a prov:Activity ;
+                    prov:used ?planGraph ;
+                    prov:startedAtTime ?startedAt .
+    ?planGraph a prov:Plan .
+    OPTIONAL { ${activityNode} prov:endedAtTime ?endedAt }
+    OPTIONAL { ${activityNode} :errorMessage ?errorMessage }
+  `.build());
+}
+export function statusFor(endedAt, errorMessage) {
+    if (errorMessage)
+        return "failed";
+    if (!endedAt)
+        return "running";
+    return "completed";
+}
+export function useActivity(config) {
+    const { activityIri, enabled = true } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: ["ldo-ui", "activity", activityIri, engine, options],
+        enabled: enabled && isPresent(activityIri),
+        queryFn: async () => {
+            if (!activityIri)
+                return null;
+            const stream = await engine.queryBindings(buildActivityQuery(activityIri), optionsToContext(options));
+            const [binding] = await collectBindings(stream);
+            if (!binding)
+                return null;
+            const startedAtTime = bindingValue(binding, "startedAt");
+            if (!startedAtTime)
+                return null;
+            const planGraphIri = bindingValue(binding, "planGraph") ?? null;
+            const endedAtTime = bindingValue(binding, "endedAt") ?? null;
+            const errorMessage = bindingValue(binding, "errorMessage") ?? null;
+            return {
+                iri: activityIri,
+                planLabel: planGraphIri ? extractLabel(planGraphIri) || shortenUri(planGraphIri) : "Action plan",
+                planGraphIri,
+                status: statusFor(endedAtTime, errorMessage),
+                startedAtTime,
+                endedAtTime,
+                errorMessage,
+            };
+        },
+    });
+}

package/dist/hooks/use-connected-account-entity-iris.d.ts

@@ -0,0 +1,15 @@
+import type { IRI } from "@manta-eu/rdf-lib/namespaces";
+import type { RDF } from "ldkit/rdf";
+export declare const connectedAccountEntityIrisQuery: string;
+/** Pure binder: entity IRIs that a `:ConnectedAccount` points at via `schema:sameAs`. */
+export declare function connectedAccountEntityIrisFromBindings(bindings: RDF.Bindings[]): ReadonlySet<IRI>;
+/**
+ * Live set of connected-account entity IRIs in the datastore.
+ * Used to decide which nodes get the recursive entity-relation tree (integrations-backed,
+ * not a hardcoded type list).
+ */
+export declare function useConnectedAccountEntityIris(): {
+    iris: ReadonlySet<IRI>;
+    isLoading: boolean;
+};
+//# sourceMappingURL=use-connected-account-entity-iris.d.ts.map

package/dist/hooks/use-connected-account-entity-iris.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-connected-account-entity-iris.d.ts","sourceRoot":"","sources":["../../src/hooks/use-connected-account-entity-iris.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAUrC,eAAO,MAAM,+BAA+B,QAInC,CAAC;AAEV,yFAAyF;AACzF,wBAAgB,sCAAsC,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,GAAG,WAAW,CAAC,GAAG,CAAC,CAOjG;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,IAAI;IAC/C,IAAI,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;CACpB,CASA"}

package/dist/hooks/use-connected-account-entity-iris.js

@@ -0,0 +1,34 @@
+import { m } from "@manta-eu/ldo/namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { useMemo } from "react";
+import { bindingValue } from "../lib/rdf-helpers.js";
+import { useSparqlSelect } from "./use-sparql-construct.js";
+const df = new DataFactory();
+const connectedAccountType = df.namedNode(m.ConnectedAccount);
+export const connectedAccountEntityIrisQuery = SELECT.DISTINCT `?entity`.WHERE `
+  ?account a ${connectedAccountType} ;
+           schema:sameAs ?entity .
+  FILTER(isIRI(?entity))
+`.build();
+/** Pure binder: entity IRIs that a `:ConnectedAccount` points at via `schema:sameAs`. */
+export function connectedAccountEntityIrisFromBindings(bindings) {
+    return new Set(bindings.flatMap((binding) => {
+        const entity = bindingValue(binding, "entity");
+        return isPresent(entity) ? [entity] : [];
+    }));
+}
+/**
+ * Live set of connected-account entity IRIs in the datastore.
+ * Used to decide which nodes get the recursive entity-relation tree (integrations-backed,
+ * not a hardcoded type list).
+ */
+export function useConnectedAccountEntityIris() {
+    const { data, isLoading } = useSparqlSelect({
+        query: connectedAccountEntityIrisQuery,
+        queryKey: ["ldo-ui", "connected-account-entity-iris"],
+    });
+    const iris = useMemo(() => connectedAccountEntityIrisFromBindings(data ?? []), [data]);
+    return { iris, isLoading };
+}

package/dist/hooks/use-conversation-starters.d.ts

@@ -0,0 +1,7 @@
+export declare function useConversationStarters(): import("@tanstack/react-query").UseQueryResult<{
+    $id: string;
+    label: string;
+    integration: string | null;
+    priority: number;
+}[], Error>;
+//# sourceMappingURL=use-conversation-starters.d.ts.map

package/dist/hooks/use-conversation-starters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-starters.d.ts","sourceRoot":"","sources":["../../src/hooks/use-conversation-starters.ts"],"names":[],"mappings":"AAKA,wBAAgB,uBAAuB;;;;;YAUtC"}

package/dist/hooks/use-conversation-starters.js

@@ -0,0 +1,15 @@
+import { ConversationStarterSchema } from "@manta-eu/ldo";
+import { useQuery } from "@tanstack/react-query";
+import { createLens } from "ldkit";
+import { useSparqlOptions } from "./use-sparql-options.js";
+export function useConversationStarters() {
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: [ConversationStarterSchema, options],
+        staleTime: 5 * 60 * 1000,
+        queryFn: async () => {
+            const entities = await createLens(ConversationStarterSchema, options).find();
+            return [...entities].sort((a, b) => a.priority - b.priority);
+        },
+    });
+}

package/dist/hooks/use-entity-connection-count.d.ts

@@ -0,0 +1,2 @@
+export declare function useEntityConnectionCount(iri: string): number | undefined;
+//# sourceMappingURL=use-entity-connection-count.d.ts.map

package/dist/hooks/use-entity-connection-count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-connection-count.d.ts","sourceRoot":"","sources":["../../src/hooks/use-entity-connection-count.ts"],"names":[],"mappings":"AAYA,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAsBxE"}

package/dist/hooks/use-entity-connection-count.js

@@ -0,0 +1,29 @@
+import { isValidFullIri, wellKnownPredicates } from "@manta-eu/rdf-lib/namespaces";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { useSparqlSelect } from "./use-sparql-construct.js";
+const df = new DataFactory();
+const rdfType = df.namedNode(wellKnownPredicates.type);
+// Distinct resource neighbors of the entity in the KG, in BOTH directions: outbound IRI objects
+// (skipping literal attribute values and rdf:type) and inbound subjects (e.g. the campaigns that
+// point at a google:Customer). Type-agnostic, so it works for every connected-account type without
+// needing per-vendor relation predicates.
+export function useEntityConnectionCount(iri) {
+    const safe = isValidFullIri(iri);
+    const node = safe ? df.namedNode(iri) : undefined;
+    const query = node
+        ? SELECT `(COUNT(DISTINCT ?neighbor) AS ?n)`.WHERE `
+        { ${node} ?outbound ?neighbor . FILTER(isIRI(?neighbor)) FILTER(?outbound != ${rdfType}) }
+        UNION
+        { ?neighbor ?inbound ${node} }
+      `.build()
+        : "";
+    const { data } = useSparqlSelect({
+        query,
+        queryKey: ["ldo-ui", "connection-count", iri],
+        enabled: safe,
+    });
+    const raw = data?.[0]?.get("n")?.value;
+    const count = raw ? Number(raw) : undefined;
+    return Number.isFinite(count) ? count : undefined;
+}

package/dist/hooks/use-entity-neighbors.d.ts

@@ -0,0 +1,16 @@
+export type EntityNeighbor = {
+    iri: string;
+    typeIri?: string;
+    label: string;
+};
+/**
+ * Distinct IRI neighbors of an entity (outbound objects + inbound subjects), with an optional
+ * rdf:type and a display label (schema:name / rdfs:label / local name). Outbound rdf:type edges
+ * are excluded so class IRIs do not appear as tree rows.
+ */
+export declare function useEntityNeighbors(iri: string): {
+    neighbors: EntityNeighbor[];
+    isLoading: boolean;
+    isError: boolean;
+};
+//# sourceMappingURL=use-entity-neighbors.d.ts.map

package/dist/hooks/use-entity-neighbors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-neighbors.d.ts","sourceRoot":"","sources":["../../src/hooks/use-entity-neighbors.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,cAAc,GAAG;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAIF;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG;IAC/C,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB,CAmDA"}

package/dist/hooks/use-entity-neighbors.js

@@ -0,0 +1,56 @@
+import { formatEntityName, isValidFullIri, prependMissingSparqlPrefixes, wellKnownPredicates, } from "@manta-eu/rdf-lib/namespaces";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { useMemo } from "react";
+import { useSparqlSelect } from "./use-sparql-construct.js";
+const df = new DataFactory();
+const rdfType = df.namedNode(wellKnownPredicates.type);
+const neighborLimit = 500;
+/**
+ * Distinct IRI neighbors of an entity (outbound objects + inbound subjects), with an optional
+ * rdf:type and a display label (schema:name / rdfs:label / local name). Outbound rdf:type edges
+ * are excluded so class IRIs do not appear as tree rows.
+ */
+export function useEntityNeighbors(iri) {
+    const safe = isValidFullIri(iri);
+    const node = df.namedNode(iri);
+    const query = safe
+        ? prependMissingSparqlPrefixes(SELECT.DISTINCT `?neighbor ?type ?name ?label`.WHERE `
+        {
+          { ${node} ?outbound ?neighbor . FILTER(isIRI(?neighbor)) FILTER(?outbound != ${rdfType}) }
+          UNION
+          { ?neighbor ?inbound ${node} . FILTER(isIRI(?neighbor)) }
+        }
+        OPTIONAL { ?neighbor a ?type }
+        OPTIONAL { ?neighbor schema:name ?name }
+        OPTIONAL { ?neighbor rdfs:label ?label }
+      `
+            .LIMIT(neighborLimit)
+            .build())
+        : "";
+    const { data, isLoading, isError } = useSparqlSelect({
+        query,
+        queryKey: ["ldo-ui", "entity-neighbors", iri],
+        enabled: safe,
+    });
+    const neighbors = useMemo(() => {
+        if (!data)
+            return [];
+        const byIri = new Map();
+        for (const binding of data) {
+            const neighborIri = binding.get("neighbor")?.value;
+            if (!neighborIri || neighborIri === iri)
+                continue;
+            const existing = byIri.get(neighborIri);
+            const name = binding.get("name")?.value;
+            const labelTerm = binding.get("label")?.value;
+            byIri.set(neighborIri, {
+                iri: neighborIri,
+                typeIri: binding.get("type")?.value ?? existing?.typeIri,
+                label: name ?? labelTerm ?? existing?.label ?? formatEntityName(neighborIri),
+            });
+        }
+        return [...byIri.values()].sort((a, b) => a.label.localeCompare(b.label));
+    }, [data, iri]);
+    return { neighbors, isLoading, isError };
+}

package/dist/hooks/use-entity-nodes.d.ts

@@ -0,0 +1,10 @@
+import { findEntityNode } from "../graph/EntityCard.js";
+import type { RdfGraph } from "../lib/rdf-helpers.js";
+export type EntityNode = NonNullable<ReturnType<typeof findEntityNode>>;
+export declare function buildEntitySubgraphsQuery(iris: string[]): string;
+export declare function graphToEntityNodes(graph: RdfGraph, iris: string[]): Map<string, EntityNode>;
+export declare function useEntityNodes(iris: string[]): {
+    nodesByIri: Map<string, EntityNode>;
+    isLoading: boolean;
+};
+//# sourceMappingURL=use-entity-nodes.d.ts.map

package/dist/hooks/use-entity-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-nodes.d.ts","sourceRoot":"","sources":["../../src/hooks/use-entity-nodes.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAGnD,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC;AAExE,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAOhE;AAOD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAU3F;AAID,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAAE,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAgB1G"}

package/dist/hooks/use-entity-nodes.js

@@ -0,0 +1,40 @@
+import { isQueryableTermIri } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { useMemo } from "react";
+import { findEntityNode } from "../graph/EntityCard.js";
+import { rdfGraphToNodesAndEdges } from "../graph/graph-model.js";
+import { useSparqlConstruct } from "./use-sparql-construct.js";
+export function buildEntitySubgraphsQuery(iris) {
+    const values = iris
+        .filter(isQueryableTermIri)
+        .map((iri) => `<${iri}>`)
+        .join(" ");
+    return `CONSTRUCT { ?s ?p ?o . } WHERE { VALUES ?s { ${values} } ?s ?p ?o . }`;
+}
+// A graph change refreshes every ldo-ui query right away, so this only skips refetching on remount.
+const nodeStaleTime = 5 * 60 * 1000;
+// Topology fields (connectionCount, isHub, childIds, depth) are derived from the whole
+// graph, so a node's shape depends on which other IRIs were batched into the same fetch.
+export function graphToEntityNodes(graph, iris) {
+    const { nodes } = rdfGraphToNodesAndEdges(graph);
+    const nodesByIri = new Map();
+    for (const iri of iris) {
+        const node = findEntityNode(nodes, iri);
+        if (node)
+            nodesByIri.set(iri, node);
+    }
+    return nodesByIri;
+}
+// One CONSTRUCT for the whole set instead of one per entity — callers that render every
+// node at once (e.g. an activity timeline) would otherwise fan out N queries on mount.
+export function useEntityNodes(iris) {
+    const queryableIris = useMemo(() => [...new Set(iris.filter(isQueryableTermIri))], [iris]);
+    const { data: graph, isLoading } = useSparqlConstruct({
+        query: isPresent(queryableIris) ? buildEntitySubgraphsQuery(queryableIris) : "",
+        queryKey: ["ldo-ui", "entity-nodes", queryableIris],
+        enabled: isPresent(queryableIris),
+        staleTime: nodeStaleTime,
+    });
+    const nodesByIri = useMemo(() => (graph ? graphToEntityNodes(graph, queryableIris) : new Map()), [graph, queryableIris]);
+    return { nodesByIri, isLoading: isPresent(queryableIris) && isLoading };
+}

package/dist/hooks/use-entity-relations.d.ts

@@ -0,0 +1,11 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type Schema } from "ldkit";
+import type { LensEntity } from "./lens-entity.js";
+export declare const entityRelationsQueryKey: <S extends Schema>(iri: string, schema: S) => readonly ["ldo-ui", "entity-relations", string, S];
+export type UseEntityRelationsOptions<S extends Schema> = {
+    schema: S;
+    iri: string;
+    enabled?: boolean;
+};
+export declare function useEntityRelations<S extends Schema>(config: UseEntityRelationsOptions<S>): UseQueryResult<LensEntity<S> | null, Error>;
+//# sourceMappingURL=use-entity-relations.d.ts.map

package/dist/hooks/use-entity-relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-relations.d.ts","sourceRoot":"","sources":["../../src/hooks/use-entity-relations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAc,KAAK,MAAM,EAAE,MAAM,OAAO,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,MAAM,EAAE,KAAK,MAAM,EAAE,QAAQ,CAAC,uDAC1B,CAAC;AAEvD,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,MAAM,IAAI;IACxD,MAAM,EAAE,CAAC,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,EACjD,MAAM,EAAE,yBAAyB,CAAC,CAAC,CAAC,GACnC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,CAY7C"}

package/dist/hooks/use-entity-relations.js

@@ -0,0 +1,16 @@
+import { useQuery } from "@tanstack/react-query";
+import { createLens } from "ldkit";
+import { useSparqlOptions } from "./use-sparql-options.js";
+export const entityRelationsQueryKey = (iri, schema) => ["ldo-ui", "entity-relations", iri, schema];
+export function useEntityRelations(config) {
+    const { schema, iri, enabled = true } = config;
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: entityRelationsQueryKey(iri, schema),
+        queryFn: async () => {
+            const lens = createLens(schema, options);
+            return lens.findByIri(iri);
+        },
+        enabled: enabled && !!iri,
+    });
+}

package/dist/hooks/use-entity.d.ts

@@ -0,0 +1,27 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type Options, type Schema, type SchemaInterface } from "ldkit";
+export declare function loadEntities<S extends Schema>(schema: S, iris: readonly string[], options: Options): Promise<Map<string, SchemaInterface<S>>>;
+export declare const entityQueryKey: <S extends Schema>(iri: string, schema: S) => readonly ["ldo-ui", "entity", string, S];
+export declare const entitiesQueryKey: <S extends Schema>(schema: S) => readonly ["ldo-ui", "entities", S];
+export declare const entitiesByIrisQueryKey: <S extends Schema>(iris: readonly string[], schema: S) => readonly ["ldo-ui", "entities-by-iris", readonly string[], S];
+export type UseEntityOptions<S extends Schema> = {
+    schema: S;
+    iri: string;
+    enabled?: boolean;
+};
+export declare function useEntity<S extends Schema>(config: UseEntityOptions<S>): UseQueryResult<import("@tanstack/react-query").NoInfer<SchemaInterface<S> | null>, Error>;
+export type UseEntitiesByIrisOptions<S extends Schema> = {
+    schema: S;
+    iris: readonly string[];
+    enabled?: boolean;
+};
+export declare function useEntitiesByIris<S extends Schema>(config: UseEntitiesByIrisOptions<S>): UseQueryResult<(SchemaInterface<S> | undefined)[], Error>;
+export type UseEntitiesOptions<S extends Schema> = {
+    schema: S;
+    enabled?: boolean;
+};
+export type Entity<T> = T extends Record<string, unknown> ? {
+    [Key in keyof T]: T[Key];
+} : T;
+export declare function useEntities<S extends Schema>(config: UseEntitiesOptions<S>): UseQueryResult<Entity<SchemaInterface<S>>[], Error>;
+//# sourceMappingURL=use-entity.d.ts.map

package/dist/hooks/use-entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity.d.ts","sourceRoot":"","sources":["../../src/hooks/use-entity.ts"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAc,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,eAAe,EAAE,MAAM,OAAO,CAAC;AAwDpF,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,GAYhF,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAC1D;AAED,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,MAAM,EAAE,KAAK,MAAM,EAAE,QAAQ,CAAC,6CAA+C,CAAC;AACvH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,CAAC,uCAA4C,CAAC;AACzG,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,EAAE,MAAM,SAAS,MAAM,EAAE,EAAE,QAAQ,CAAC,kEACpC,CAAC;AAIxD,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,IAAI;IAC/C,MAAM,EAAE,CAAC,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,6FAWtE;AAED,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,MAAM,IAAI;IACvD,MAAM,EAAE,CAAC,CAAC;IACV,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,wBAAwB,CAAC,CAAC,CAAC,6DAgBtF;AAED,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,MAAM,IAAI;IACjD,MAAM,EAAE,CAAC,CAAC;IACV,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAIF,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;KAAG,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;CAAE,GAAG,CAAC,CAAC;AAE7F,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAC1C,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC5B,cAAc,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,CAAC,CAarD"}