@manta-eu/react 0.1.0

package/dist/hooks/resolved-terms.js

@@ -0,0 +1,100 @@
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { createTermBatcher } from "../lib/term-batcher.js";
+export function createResolvedTermsContext() {
+    const Context = createContext(null);
+    const empty = new Map();
+    function useResolvedTerms(iris) {
+        const context = useContext(Context);
+        const request = context?.request;
+        const all = context?.values ?? empty;
+        const irisKey = iris.join("\n");
+        useEffect(() => {
+            if (!request || iris.length === 0)
+                return;
+            request(iris);
+        }, [request, irisKey]);
+        return useMemo(() => {
+            const subset = new Map();
+            for (const iri of iris) {
+                const value = all.get(iri);
+                if (value !== undefined)
+                    subset.set(iri, value);
+            }
+            return subset;
+        }, [all, irisKey]);
+    }
+    function useResolvedTerm(iri) {
+        const values = useResolvedTerms(iri ? [iri] : []);
+        if (!iri)
+            return undefined;
+        return values.get(iri);
+    }
+    return { Context, useResolvedTerms, useResolvedTerm };
+}
+export function useResolvedTermsState(loadTerms, unresolvedValue) {
+    const [values, setValues] = useState(new Map());
+    const [settledIris, setSettledIris] = useState(new Set());
+    const [failedIris, setFailedIris] = useState(new Set());
+    const activeBatcherRef = useRef(null);
+    const batcher = useMemo(() => {
+        const created = createTermBatcher({
+            loadTerms,
+            unresolvedValue,
+            onTermsResolved: (resolved) => {
+                if (activeBatcherRef.current !== created)
+                    return;
+                setValues((current) => {
+                    const next = new Map(current);
+                    for (const [iri, value] of resolved) {
+                        next.set(iri, value);
+                    }
+                    return next;
+                });
+            },
+            onBatchSettled: (iris) => {
+                if (activeBatcherRef.current !== created)
+                    return;
+                setSettledIris((current) => {
+                    const next = new Set(current);
+                    for (const iri of iris) {
+                        next.add(iri);
+                    }
+                    return next;
+                });
+                setFailedIris((current) => {
+                    if (!iris.some((iri) => current.has(iri)))
+                        return current;
+                    const next = new Set(current);
+                    for (const iri of iris) {
+                        next.delete(iri);
+                    }
+                    return next;
+                });
+            },
+            onBatchFailed: (iris) => {
+                if (activeBatcherRef.current !== created)
+                    return;
+                setFailedIris((current) => {
+                    const next = new Set(current);
+                    for (const iri of iris) {
+                        next.add(iri);
+                    }
+                    return next;
+                });
+            },
+        });
+        return created;
+    }, [loadTerms, unresolvedValue]);
+    useEffect(() => {
+        activeBatcherRef.current = batcher;
+        setValues(new Map());
+        setSettledIris(new Set());
+        setFailedIris(new Set());
+        return () => {
+            activeBatcherRef.current = null;
+            batcher.cancel();
+        };
+    }, [batcher]);
+    const request = useCallback((iris) => batcher.request(iris), [batcher]);
+    return useMemo(() => ({ values, request, settledIris, failedIris }), [values, request, settledIris, failedIris]);
+}

package/dist/hooks/use-action-plan-detail.d.ts

@@ -0,0 +1,11 @@
+export type UseActionPlanDetailOptions = {
+    planGraphIri: string;
+    limit?: number;
+    enabled?: boolean;
+};
+export declare function useActionPlanDetail(config: UseActionPlanDetailOptions): {
+    error: Error | null;
+    data: import("../ldo-ui.js").ActionPlanDetailModel | null;
+    isLoading: boolean;
+};
+//# sourceMappingURL=use-action-plan-detail.d.ts.map

package/dist/hooks/use-action-plan-detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-action-plan-detail.d.ts","sourceRoot":"","sources":["../../src/hooks/use-action-plan-detail.ts"],"names":[],"mappings":"AAgBA,MAAM,MAAM,0BAA0B,GAAG;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AA6BF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,0BAA0B;;;;EAkErE"}

package/dist/hooks/use-action-plan-detail.js

@@ -0,0 +1,90 @@
+import { prependMissingSparqlPrefixes } from "@manta-eu/rdf-lib/namespaces";
+import { DataFactory } from "ldkit/rdf";
+import { CONSTRUCT } from "ldkit/sparql";
+import { useMemo } from "react";
+import { parseActionPlanDetail } from "../lib/action-plan-detail.js";
+import { buildExplicitStateQuery, buildSinglePlanStateQuery, coerceActionPlanState, mergeStates, readStateBinding, } from "../lib/provenance-state.js";
+import { useSparqlConstruct, useSparqlSelect } from "./use-sparql-construct.js";
+const df = new DataFactory();
+function clampLimit(limit, defaultLimit, maxLimit) {
+    const value = limit ?? defaultLimit;
+    return Math.min(Math.max(1, value), maxLimit);
+}
+function buildActionPlanDetailQuery(planGraphIri, limit) {
+    const validatedLimit = clampLimit(limit, 500, 1000);
+    return prependMissingSparqlPrefixes(CONSTRUCT `
+    ?subject ?predicate ?object .
+    ?subject a ?type .
+    ?subject rdfs:label ?label .
+    ?object rdfs:label ?objectLabel .
+  `.WHERE `
+    GRAPH ${df.namedNode(planGraphIri)} {
+      ?subject ?predicate ?object .
+      OPTIONAL { ?subject a ?type }
+      OPTIONAL { ?subject rdfs:label ?label }
+      OPTIONAL { ?object rdfs:label ?objectLabel }
+    }
+  `
+        .LIMIT(validatedLimit)
+        .build());
+}
+export function useActionPlanDetail(config) {
+    const { planGraphIri, limit, enabled = true } = config;
+    const query = buildActionPlanDetailQuery(planGraphIri, limit);
+    const queryResult = useSparqlConstruct({
+        query,
+        queryKey: ["ldo-ui", planGraphIri, "action-plan-detail", limit],
+        enabled: enabled && !!planGraphIri,
+    });
+    const stateResult = useSparqlSelect({
+        query: buildSinglePlanStateQuery(planGraphIri),
+        queryKey: ["ldo-ui", planGraphIri, "action-plan-state"],
+        enabled: enabled && !!planGraphIri,
+    });
+    const explicitStateResult = useSparqlSelect({
+        query: buildExplicitStateQuery(planGraphIri),
+        queryKey: ["ldo-ui", planGraphIri, "action-plan-explicit-state"],
+        enabled: enabled && !!planGraphIri,
+    });
+    const stateBinding = stateResult.data?.[0];
+    const explicitStateValue = explicitStateResult.data?.[0]?.get("explicitState")?.value;
+    const hasCurrentFacts = stateBinding?.get("hasCurrentFacts")?.value === "true";
+    const hasExecutionHistory = !!stateBinding?.get("latestStarted");
+    const hasExplicitPlanState = explicitStateValue !== undefined;
+    const hasGraphData = (queryResult.data?.size ?? 0) > 0;
+    const hasPlanEvidence = hasCurrentFacts || hasExecutionHistory || hasExplicitPlanState || hasGraphData;
+    const state = useMemo(() => {
+        const provenanceState = readStateBinding(stateBinding);
+        const explicitState = coerceActionPlanState(explicitStateValue);
+        return mergeStates(provenanceState, explicitState);
+    }, [stateBinding, explicitStateValue]);
+    const { data, parseError } = useMemo(() => {
+        if (!queryResult.data || !planGraphIri) {
+            return { data: null, parseError: null };
+        }
+        if (!hasPlanEvidence) {
+            return { data: null, parseError: null };
+        }
+        try {
+            return {
+                data: parseActionPlanDetail(queryResult.data, planGraphIri, {
+                    stateOverride: state,
+                    hasCurrentFacts,
+                    hasExecutionHistory,
+                }),
+                parseError: null,
+            };
+        }
+        catch (error) {
+            return {
+                data: null,
+                parseError: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+    }, [queryResult.data, planGraphIri, state, hasCurrentFacts, hasExecutionHistory, hasPlanEvidence]);
+    return {
+        error: queryResult.error ?? stateResult.error ?? explicitStateResult.error ?? parseError,
+        data,
+        isLoading: queryResult.isLoading || stateResult.isLoading || explicitStateResult.isLoading,
+    };
+}

package/dist/hooks/use-action-plan-diff.d.ts

@@ -0,0 +1,24 @@
+export type PlanDiffByType = {
+    typeIri: string;
+    typeName: string;
+    addedCount: number;
+    updatedCount: number;
+};
+export type PlanDiffResult = {
+    planGraph: string;
+    byTypes: PlanDiffByType[];
+    deleted: string[];
+    summary: {
+        added: number;
+        updated: number;
+        deleted: number;
+        types: number;
+    };
+    error?: string | null;
+};
+export type UseActionPlanDiffOptions = {
+    planGraphIri: string;
+    enabled?: boolean;
+};
+export declare function useActionPlanDiff(config: UseActionPlanDiffOptions): import("@tanstack/react-query").UseQueryResult<PlanDiffResult, Error>;
+//# sourceMappingURL=use-action-plan-diff.d.ts.map

package/dist/hooks/use-action-plan-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-action-plan-diff.d.ts","sourceRoot":"","sources":["../../src/hooks/use-action-plan-diff.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAwEF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,yEAwDjE"}

package/dist/hooks/use-action-plan-diff.js

@@ -0,0 +1,110 @@
+import { useQuery } from "@tanstack/react-query";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { extractTypeName } from "../lib/iri-labels.js";
+import { bindingCount, collectBindings, bindingValue } from "../lib/rdf-helpers.js";
+import { useSparqlEngine, useSparqlOptions } from "./use-sparql-options.js";
+const df = new DataFactory();
+const owlNothing = "http://www.w3.org/2002/07/owl#Nothing";
+function groupByType(bindings) {
+    const result = new Map();
+    for (const binding of bindings) {
+        const rdfType = binding.type;
+        const subject = binding.subject;
+        if (!rdfType || !subject)
+            continue;
+        if (!result.has(rdfType)) {
+            result.set(rdfType, new Set());
+        }
+        result.get(rdfType)?.add(subject);
+    }
+    return result;
+}
+function computeTypeDiff(typeIri, planSet, defaultSet) {
+    let addedCount = 0;
+    let updatedCount = 0;
+    for (const subject of planSet) {
+        if (defaultSet.has(subject)) {
+            updatedCount++;
+        }
+        else {
+            addedCount++;
+        }
+    }
+    return { typeIri, typeName: extractTypeName(typeIri), addedCount, updatedCount };
+}
+function processDiff(planBindings, defaultBindings, planGraphIri) {
+    const planByType = groupByType(planBindings);
+    const defaultByType = groupByType(defaultBindings);
+    const deleted = Array.from(planByType.get(owlNothing) ?? []);
+    planByType.delete(owlNothing);
+    const allTypes = new Set([...planByType.keys(), ...defaultByType.keys()]);
+    const byTypes = [];
+    for (const typeIri of allTypes) {
+        const planSet = planByType.get(typeIri) ?? new Set();
+        const defaultSet = defaultByType.get(typeIri) ?? new Set();
+        const diff = computeTypeDiff(typeIri, planSet, defaultSet);
+        if (diff.addedCount > 0 || diff.updatedCount > 0) {
+            byTypes.push(diff);
+        }
+    }
+    return {
+        planGraph: planGraphIri,
+        byTypes,
+        deleted,
+        summary: {
+            added: byTypes.reduce((acc, t) => acc + t.addedCount, 0),
+            updated: byTypes.reduce((acc, t) => acc + t.updatedCount, 0),
+            deleted: deleted.length,
+            types: byTypes.length,
+        },
+    };
+}
+export function useActionPlanDiff(config) {
+    const { planGraphIri, enabled = true } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    const context = options;
+    return useQuery({
+        queryKey: ["ldo-ui", planGraphIri, "action-plan-diff", engine, context],
+        queryFn: async () => {
+            const planNode = df.namedNode(planGraphIri);
+            const graphCheckQuery = SELECT `(COUNT(*) AS ?count)`.WHERE `GRAPH ${planNode} { ?s ?p ?o }`.build();
+            const graphCheckStream = await engine.queryBindings(graphCheckQuery, context);
+            const graphCheckBindings = await collectBindings(graphCheckStream);
+            const count = bindingCount(graphCheckBindings[0], "count") ?? 0;
+            if (count === 0) {
+                return {
+                    planGraph: planGraphIri,
+                    byTypes: [],
+                    deleted: [],
+                    summary: { added: 0, updated: 0, deleted: 0, types: 0 },
+                    error: `Named graph <${planGraphIri}> is empty or does not exist`,
+                };
+            }
+            const planSubjectsQuery = SELECT.DISTINCT `?subject ?type`.WHERE `
+        GRAPH ${planNode} {
+          ?subject a ?type EXPLICIT FALSE
+        }
+      `.build();
+            const defaultSubjectsQuery = SELECT.DISTINCT `?subject ?type`.WHERE `
+        ?subject a ?type .
+        FILTER EXISTS {
+          GRAPH ${planNode} { ?subject ?p2 ?o2 EXPLICIT FALSE }
+        }
+      `.build();
+            const [planStream, defaultStream] = await Promise.all([
+                engine.queryBindings(planSubjectsQuery, context),
+                engine.queryBindings(defaultSubjectsQuery, context),
+            ]);
+            const [planRdf, defaultRdf] = await Promise.all([collectBindings(planStream), collectBindings(defaultStream)]);
+            const planBindings = planRdf.map((b) => ({ subject: bindingValue(b, "subject"), type: bindingValue(b, "type") }));
+            const defaultBindings = defaultRdf.map((b) => ({
+                subject: bindingValue(b, "subject"),
+                type: bindingValue(b, "type"),
+            }));
+            return processDiff(planBindings, defaultBindings, planGraphIri);
+        },
+        enabled: enabled && !!planGraphIri,
+    });
+}

package/dist/hooks/use-action-plan-entity-metrics.d.ts

@@ -0,0 +1,30 @@
+export type EntityLevel = "CAMPAIGN" | "AD_SET" | "AD";
+export type PlanEntityMetric = {
+    subject: string;
+    typeIri: string;
+    label: string;
+    hierarchyLabel: string;
+    level: EntityLevel;
+    campaignIri: string | null;
+    adsetIri: string | null;
+    campaignLabel: string | null;
+    adsetLabel: string | null;
+    pauseReason: string | null;
+    scaleReason: string | null;
+    wastedSpend: number | null;
+    currentRoas: number | null;
+    dailyBudget: number | null;
+    previousDailyBudget: number | null;
+    budgetIncreaseFactor: number | null;
+};
+export type EntityMetricsResult = {
+    entities: PlanEntityMetric[];
+    count: number;
+    error: string | null;
+};
+export type UseActionPlanEntityMetricsOptions = {
+    planGraphIri: string;
+    enabled?: boolean;
+};
+export declare function useActionPlanEntityMetrics(config: UseActionPlanEntityMetricsOptions): import("@tanstack/react-query").UseQueryResult<EntityMetricsResult, Error>;
+//# sourceMappingURL=use-action-plan-entity-metrics.d.ts.map

package/dist/hooks/use-action-plan-entity-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-action-plan-entity-metrics.d.ts","sourceRoot":"","sources":["../../src/hooks/use-action-plan-entity-metrics.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,QAAQ,GAAG,IAAI,CAAC;AAEvD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,WAAW,CAAC;IACnB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAsEF,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,iCAAiC,8EA0CnF"}

package/dist/hooks/use-action-plan-entity-metrics.js

@@ -0,0 +1,83 @@
+import { google, meta } from "@manta-eu/ldo/namespaces";
+import { GoogleAdGroupAdPlanSchema, GoogleAdGroupPlanSchema, GoogleCampaignPlanSchema, MetaAdPlanSchema, MetaAdSetPlanSchema, MetaCampaignPlanSchema, } from "@manta-eu/rdf-lib/action-plan-schemas";
+import { useQuery } from "@tanstack/react-query";
+import { createLens } from "ldkit";
+import { extractLabel } from "../lib/iri-labels.js";
+import { useSparqlOptions } from "./use-sparql-options.js";
+function entityLabel(entity) {
+    return entity.schemaName?.toString() ?? entity.label?.toString() ?? extractLabel(entity.$id);
+}
+function buildHierarchyLabel(subjectLabel, campaignLabel, adsetLabel, level) {
+    if (level === "AD")
+        return [campaignLabel, adsetLabel, subjectLabel].filter(Boolean).join(" | ");
+    if (level === "AD_SET")
+        return [campaignLabel, subjectLabel].filter(Boolean).join(" | ");
+    return subjectLabel;
+}
+function toMetric(entity, level, typeIri, campaignLabelMap, adGroupLabelMap) {
+    const subjectLabel = entityLabel(entity);
+    const parentAdGroupIri = entity.adSet ?? entity.adGroup ?? null;
+    const campaignLabel = entity.campaign
+        ? (campaignLabelMap.get(entity.campaign) ?? extractLabel(entity.campaign))
+        : null;
+    const adsetLabel = parentAdGroupIri
+        ? (adGroupLabelMap.get(parentAdGroupIri) ?? extractLabel(parentAdGroupIri))
+        : null;
+    return {
+        subject: entity.$id,
+        typeIri,
+        label: subjectLabel,
+        hierarchyLabel: buildHierarchyLabel(subjectLabel, campaignLabel, adsetLabel, level),
+        level,
+        campaignIri: entity.campaign ?? null,
+        adsetIri: parentAdGroupIri,
+        campaignLabel,
+        adsetLabel,
+        pauseReason: entity.pauseReason?.toString() ?? null,
+        scaleReason: entity.scaleReason?.toString() ?? null,
+        wastedSpend: entity.wastedSpend ?? null,
+        currentRoas: entity.currentRoas ?? null,
+        // COALESCE: meta.dailyBudget (entity.dailyBudget from Meta schema) preferred over base-vocab variant
+        dailyBudget: entity.dailyBudget ?? entity.planDailyBudget ?? null,
+        previousDailyBudget: entity.previousDailyBudget ?? null,
+        budgetIncreaseFactor: entity.budgetIncreaseFactor ?? null,
+    };
+}
+export function useActionPlanEntityMetrics(config) {
+    const { planGraphIri, enabled = true } = config;
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: ["ldo-ui", planGraphIri, "action-plan-entity-metrics"],
+        queryFn: async () => {
+            const findInGraph = (schema, typeIri) => createLens(schema, options)
+                .find({ where: `GRAPH <${planGraphIri}> { ?iri a <${typeIri}> }` })
+                .then((r) => r);
+            const [metaCampaigns, metaAdSets, metaAds, gCampaigns, gAdGroups, gAdGroupAds] = await Promise.all([
+                findInGraph(MetaCampaignPlanSchema, meta.Campaign),
+                findInGraph(MetaAdSetPlanSchema, meta.AdSet),
+                findInGraph(MetaAdPlanSchema, meta.Ad),
+                findInGraph(GoogleCampaignPlanSchema, google.Campaign),
+                findInGraph(GoogleAdGroupPlanSchema, google.AdGroup),
+                findInGraph(GoogleAdGroupAdPlanSchema, google.AdGroupAd),
+            ]);
+            const campaignLabelMap = new Map([
+                ...metaCampaigns.map((c) => [c.$id, entityLabel(c)]),
+                ...gCampaigns.map((c) => [c.$id, entityLabel(c)]),
+            ]);
+            const adGroupLabelMap = new Map([
+                ...metaAdSets.map((a) => [a.$id, entityLabel(a)]),
+                ...gAdGroups.map((a) => [a.$id, entityLabel(a)]),
+            ]);
+            const entities = [
+                ...metaCampaigns.map((e) => toMetric(e, "CAMPAIGN", meta.Campaign, campaignLabelMap, adGroupLabelMap)),
+                ...metaAdSets.map((e) => toMetric(e, "AD_SET", meta.AdSet, campaignLabelMap, adGroupLabelMap)),
+                ...metaAds.map((e) => toMetric(e, "AD", meta.Ad, campaignLabelMap, adGroupLabelMap)),
+                ...gCampaigns.map((e) => toMetric(e, "CAMPAIGN", google.Campaign, campaignLabelMap, adGroupLabelMap)),
+                ...gAdGroups.map((e) => toMetric(e, "AD_SET", google.AdGroup, campaignLabelMap, adGroupLabelMap)),
+                ...gAdGroupAds.map((e) => toMetric(e, "AD", google.AdGroupAd, campaignLabelMap, adGroupLabelMap)),
+            ];
+            return { entities, count: entities.length, error: null };
+        },
+        enabled: enabled && !!planGraphIri,
+    });
+}

package/dist/hooks/use-action-plan-execution-provenance.d.ts

@@ -0,0 +1,38 @@
+export type ExecutionProvenanceEntity = {
+    iri: string;
+    label: string | null;
+    typeName: string | null;
+    relation: "used" | "generated" | "invalidated";
+};
+export type ExecutionProvenanceActivity = {
+    iri: string;
+    parentActivityIri: string | null;
+    isPlanActivity: boolean;
+    startedAtTime: string | null;
+    endedAtTime: string | null;
+    operationType: string | null;
+    errorMessage: string | null;
+    dryRun: boolean;
+    associatedAgentIris: string[];
+    entityIri: string | null;
+    entityLabel: string;
+    entityTypeName: string | null;
+    entities: ExecutionProvenanceEntity[];
+};
+export type ActionPlanExecutionProvenanceResult = {
+    planActivityIri: string | null;
+    planStartedAtTime: string | null;
+    planEndedAtTime: string | null;
+    planErrorMessage: string | null;
+    planDryRun: boolean;
+    activities: ExecutionProvenanceActivity[];
+    count: number;
+    error: string | null;
+};
+export type UseActionPlanExecutionProvenanceOptions = {
+    planGraphIri: string;
+    enabled?: boolean;
+    refetchIntervalMs?: number | false;
+};
+export declare function useActionPlanExecutionProvenance(config: UseActionPlanExecutionProvenanceOptions): import("@tanstack/react-query").UseQueryResult<ActionPlanExecutionProvenanceResult, Error>;
+//# sourceMappingURL=use-action-plan-execution-provenance.d.ts.map

package/dist/hooks/use-action-plan-execution-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-action-plan-execution-provenance.d.ts","sourceRoot":"","sources":["../../src/hooks/use-action-plan-execution-provenance.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,yBAAyB,GAAG;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,aAAa,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,EAAE,yBAAyB,EAAE,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG;IAChD,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,2BAA2B,EAAE,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,uCAAuC,GAAG;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CACpC,CAAC;AAgSF,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,uCAAuC,8FAmB/F"}