@manta-eu/react 0.1.0

package/dist/lib/action-plan-detail.js

@@ -0,0 +1,317 @@
+import { baseIri, namespaces, wellKnownPredicates } from "@manta-eu/rdf-lib/namespaces";
+const schemaNs = namespaces.schema;
+// --- RdfNode helpers ---
+function getTypes(node) {
+    return new Set((node.get(wellKnownPredicates.type) ?? []).map((t) => t.value));
+}
+function getStr(node, predicate) {
+    const term = node.get(predicate)?.[0];
+    return term ? term.value : null;
+}
+function getNum(node, predicate) {
+    const str = getStr(node, predicate);
+    if (str === null)
+        return null;
+    const n = Number(str);
+    return Number.isFinite(n) ? n : null;
+}
+function getRef(node, predicate) {
+    const term = node.get(predicate)?.[0];
+    return term && term.termType === "NamedNode" ? term.value : null;
+}
+function getRefs(node, predicate) {
+    return (node.get(predicate) ?? []).filter((t) => t.termType === "NamedNode").map((t) => t.value);
+}
+function resolve(graph, node, predicate) {
+    const iri = getRef(node, predicate);
+    return iri ? graph.get(iri) : undefined;
+}
+function resolveAll(graph, node, predicate) {
+    return getRefs(node, predicate)
+        .map((iri) => graph.get(iri))
+        .filter((n) => n !== undefined);
+}
+// --- Quantitative values ---
+const stateValues = ["DRAFT", "RUNNING", "COMPLETED", "FAILED", "TIMED_OUT"];
+function parseQuantitativeNode(node) {
+    const types = getTypes(node);
+    const unitCode = getStr(node, `${schemaNs}unitCode`) ?? "ONE";
+    const unitText = getStr(node, `${schemaNs}unitText`) ?? null;
+    const exactValue = getStr(node, `${schemaNs}value`);
+    const minValue = getStr(node, `${schemaNs}minValue`);
+    const maxValue = getStr(node, `${schemaNs}maxValue`);
+    if (types.has(`${schemaNs}ExactQuantitativeValue`) && exactValue) {
+        return { __typename: "ExactQuantitativeValue", value: exactValue, unitCode, unitText };
+    }
+    if (minValue && maxValue) {
+        return { __typename: "ApproximateQuantitativeValue", minValue, maxValue, unitCode, unitText };
+    }
+    if (exactValue) {
+        return { __typename: "ExactQuantitativeValue", value: exactValue, unitCode, unitText };
+    }
+    return undefined;
+}
+function parseQuantitativeField(graph, node, predicate) {
+    const refNode = resolve(graph, node, predicate);
+    return refNode ? parseQuantitativeNode(refNode) : undefined;
+}
+// --- HowTo parsing ---
+function parseDirectionOrTip(node) {
+    const types = getTypes(node);
+    const position = getNum(node, `${schemaNs}position`) ?? 0;
+    const text = getStr(node, `${schemaNs}text`) ?? "";
+    if (types.has(`${schemaNs}HowToDirection`)) {
+        return {
+            __typename: "HowToDirection",
+            position,
+            text,
+            beforeMedia: undefined,
+            duringMedia: undefined,
+            afterMedia: undefined,
+        };
+    }
+    if (types.has(`${schemaNs}HowToTip`)) {
+        return { __typename: "HowToTip", position, text };
+    }
+    return null;
+}
+function parseHowToStep(graph, node) {
+    const itemNodes = resolveAll(graph, node, `${schemaNs}itemListElement`);
+    const itemListElement = itemNodes.length > 0
+        ? itemNodes.map(parseDirectionOrTip).filter((i) => i !== null)
+        : undefined;
+    return {
+        __typename: "HowToStep",
+        name: getStr(node, `${schemaNs}name`) ?? "",
+        position: getNum(node, `${schemaNs}position`) ?? 0,
+        text: getStr(node, `${schemaNs}text`) ?? null,
+        timeRequired: getStr(node, `${schemaNs}timeRequired`) ?? null,
+        url: getStr(node, `${schemaNs}url`) ?? null,
+        itemListElement,
+        image: undefined,
+        beforeMedia: undefined,
+        duringMedia: undefined,
+        afterMedia: undefined,
+    };
+}
+function parseHowToSection(graph, node) {
+    const stepNodes = resolveAll(graph, node, `${schemaNs}itemListElement`);
+    const itemListElement = stepNodes
+        .filter((n) => getStr(n, `${schemaNs}name`) !== null)
+        .map((n) => parseHowToStep(graph, n))
+        .sort((a, b) => a.position - b.position);
+    return {
+        __typename: "HowToSection",
+        name: getStr(node, `${schemaNs}name`) ?? "",
+        position: getNum(node, `${schemaNs}position`) ?? 0,
+        itemListElement,
+    };
+}
+function extractSteps(graph, howToNode) {
+    return resolveAll(graph, howToNode, `${schemaNs}step`)
+        .filter((n) => getNum(n, `${schemaNs}position`) !== null)
+        .map((n) => {
+        if (getTypes(n).has(`${schemaNs}HowToSection`)) {
+            return parseHowToSection(graph, n);
+        }
+        if (getStr(n, `${schemaNs}name`) && getTypes(n).has(`${schemaNs}HowToStep`)) {
+            return parseHowToStep(graph, n);
+        }
+        return undefined;
+    })
+        .filter((s) => s !== undefined)
+        .sort((a, b) => a.position - b.position);
+}
+function extractHowToItems(graph, howToNode, predicate, typeName) {
+    return resolveAll(graph, howToNode, predicate)
+        .map((n) => {
+        const name = getStr(n, `${schemaNs}name`);
+        if (!name)
+            return undefined;
+        const base = {
+            __typename: typeName,
+            name,
+            url: getStr(n, `${schemaNs}url`) ?? undefined,
+            requiredQuantity: getNum(n, `${schemaNs}requiredQuantity`) ?? undefined,
+            image: undefined,
+        };
+        if (typeName === "HowToSupply") {
+            return { ...base, estimatedCost: parseQuantitativeField(graph, n, `${schemaNs}estimatedCost`) };
+        }
+        return base;
+    })
+        .filter((i) => i !== undefined);
+}
+function extractHowTo(graph) {
+    let howToIri;
+    let howToNode;
+    for (const [iri, node] of graph) {
+        if (getTypes(node).has(`${schemaNs}HowTo`)) {
+            howToIri = iri;
+            howToNode = node;
+            break;
+        }
+    }
+    if (!howToNode || !howToIri)
+        return null;
+    return {
+        id: howToIri,
+        name: getStr(howToNode, `${schemaNs}name`) ?? getStr(howToNode, `${schemaNs}description`) ?? howToIri,
+        description: getStr(howToNode, `${schemaNs}description`) ?? null,
+        datePublished: getStr(howToNode, `${schemaNs}datePublished`) ?? null,
+        dateModified: getStr(howToNode, `${schemaNs}dateModified`) ?? null,
+        inLanguage: getStr(howToNode, `${schemaNs}inLanguage`) ?? null,
+        prepTime: getStr(howToNode, `${schemaNs}prepTime`) ?? null,
+        performTime: getStr(howToNode, `${schemaNs}performTime`) ?? null,
+        totalTime: getStr(howToNode, `${schemaNs}totalTime`) ?? null,
+        confidenceScore: getNum(howToNode, `${baseIri}confidenceScore`) ?? null,
+        estimatedCost: parseQuantitativeField(graph, howToNode, `${schemaNs}estimatedCost`),
+        estimatedReturn: parseQuantitativeField(graph, howToNode, `${schemaNs}estimatedReturn`) ??
+            parseQuantitativeField(graph, howToNode, `${baseIri}estimatedReturn`),
+        estimatedROI: parseQuantitativeField(graph, howToNode, `${schemaNs}estimatedROI`),
+        yield: parseQuantitativeField(graph, howToNode, `${schemaNs}yield`),
+        tool: extractHowToItems(graph, howToNode, `${schemaNs}tool`, "HowToTool"),
+        supply: extractHowToItems(graph, howToNode, `${schemaNs}supply`, "HowToSupply"),
+        step: extractSteps(graph, howToNode),
+    };
+}
+// --- Integration detection ---
+export const integrationNamespaces = {
+    META: namespaces.meta,
+    GOOGLE: namespaces.google,
+    LINKEDIN: namespaces.linkedin,
+    SHOPIFY: namespaces.shopify,
+    SNAPCHAT: namespaces.snap,
+    WOOCOMMERCE: namespaces.woo,
+};
+export function integrationForIri(iri) {
+    if (iri.startsWith(integrationNamespaces.META) ||
+        iri.includes("Meta") ||
+        iri.includes("Facebook") ||
+        iri.includes("Instagram"))
+        return "META";
+    if (iri.startsWith(integrationNamespaces.GOOGLE) || iri.includes("Google") || iri.includes("AdWords"))
+        return "GOOGLE";
+    if (iri.startsWith(integrationNamespaces.LINKEDIN) || iri.includes("LinkedIn") || iri.includes("Linkedin"))
+        return "LINKEDIN";
+    if (iri.startsWith(integrationNamespaces.SHOPIFY) || iri.includes("Shopify"))
+        return "SHOPIFY";
+    if (iri.startsWith(integrationNamespaces.SNAPCHAT) || iri.includes("Snap") || iri.includes("Snapchat"))
+        return "SNAPCHAT";
+    if (iri.startsWith(integrationNamespaces.WOOCOMMERCE) || iri.includes("Woo") || iri.includes("Woocommerce"))
+        return "WOOCOMMERCE";
+    return null;
+}
+function detectPrimaryIntegration(graph) {
+    const counts = new Map();
+    for (const [subject, predicates] of graph) {
+        const signals = [subject];
+        for (const type of getTypes(predicates))
+            signals.push(type);
+        for (const [predicate, terms] of predicates) {
+            signals.push(predicate);
+            for (const term of terms)
+                signals.push(term.value);
+        }
+        for (const signal of signals) {
+            const integration = integrationForIri(signal);
+            if (integration) {
+                counts.set(integration, (counts.get(integration) ?? 0) + 1);
+            }
+        }
+    }
+    let winner = null;
+    let winnerCount = 0;
+    for (const [integration, count] of counts) {
+        if (count > winnerCount) {
+            winner = integration;
+            winnerCount = count;
+        }
+    }
+    return winner;
+}
+// --- Potential profit ---
+function calculatePotentialProfit(estimatedCost, estimatedReturn) {
+    if (!estimatedReturn)
+        return undefined;
+    const unitCode = estimatedReturn.unitCode;
+    const unitText = estimatedReturn.unitText;
+    if (estimatedCost && (estimatedCost.unitCode !== unitCode || estimatedCost.unitText !== unitText))
+        return undefined;
+    const exactCost = estimatedCost?.__typename === "ExactQuantitativeValue" ? Number.parseFloat(estimatedCost.value) : Number.NaN;
+    const exactReturn = estimatedReturn.__typename === "ExactQuantitativeValue" ? Number.parseFloat(estimatedReturn.value) : Number.NaN;
+    if (estimatedCost?.__typename === "ExactQuantitativeValue" &&
+        estimatedReturn.__typename === "ExactQuantitativeValue" &&
+        Number.isFinite(exactCost) &&
+        Number.isFinite(exactReturn)) {
+        return { __typename: "ExactQuantitativeValue", value: (exactReturn - exactCost).toFixed(2), unitCode, unitText };
+    }
+    const minCost = estimatedCost?.__typename === "ApproximateQuantitativeValue"
+        ? Number.parseFloat(estimatedCost.minValue)
+        : Number.isFinite(exactCost)
+            ? exactCost
+            : 0;
+    const maxCost = estimatedCost?.__typename === "ApproximateQuantitativeValue"
+        ? Number.parseFloat(estimatedCost.maxValue)
+        : Number.isFinite(exactCost)
+            ? exactCost
+            : 0;
+    const minReturn = estimatedReturn.__typename === "ApproximateQuantitativeValue"
+        ? Number.parseFloat(estimatedReturn.minValue)
+        : Number.isFinite(exactReturn)
+            ? exactReturn
+            : 0;
+    const maxReturn = estimatedReturn.__typename === "ApproximateQuantitativeValue"
+        ? Number.parseFloat(estimatedReturn.maxValue)
+        : Number.isFinite(exactReturn)
+            ? exactReturn
+            : 0;
+    if (![minCost, maxCost, minReturn, maxReturn].every(Number.isFinite))
+        return undefined;
+    return {
+        __typename: "ApproximateQuantitativeValue",
+        minValue: Math.min(minReturn - minCost, maxReturn - maxCost).toFixed(2),
+        maxValue: Math.max(minReturn - minCost, maxReturn - maxCost).toFixed(2),
+        unitCode,
+        unitText,
+    };
+}
+export function parseActionPlanDetail(graph, planGraphIri, options) {
+    const { hasCurrentFacts, hasExecutionHistory, stateOverride } = options;
+    const planNode = graph.get(planGraphIri);
+    const howTo = extractHowTo(graph);
+    const estimatedCost = howTo?.estimatedCost ??
+        (planNode ? parseQuantitativeField(graph, planNode, `${schemaNs}estimatedCost`) : undefined);
+    const estimatedReturn = howTo?.estimatedReturn ??
+        (planNode
+            ? (parseQuantitativeField(graph, planNode, `${schemaNs}estimatedReturn`) ??
+                parseQuantitativeField(graph, planNode, `${baseIri}estimatedReturn`))
+            : undefined);
+    const estimatedROI = howTo?.estimatedROI ?? (planNode ? parseQuantitativeField(graph, planNode, `${schemaNs}estimatedROI`) : undefined);
+    const explicitUpside = howTo?.yield ?? (planNode ? parseQuantitativeField(graph, planNode, `${schemaNs}yield`) : undefined);
+    const rawFallbackState = planNode ? getStr(planNode, `${baseIri}state`)?.toUpperCase() : undefined;
+    const fallbackState = stateValues.includes(rawFallbackState)
+        ? rawFallbackState
+        : "DRAFT";
+    const state = stateOverride ?? fallbackState;
+    return {
+        iri: planGraphIri,
+        hasCurrentFacts,
+        hasExecutionHistory,
+        description: planNode
+            ? (getStr(planNode, `${schemaNs}description`) ?? getStr(planNode, "http://www.w3.org/2000/01/rdf-schema#label"))
+            : null,
+        duration: (planNode ? (getStr(planNode, `${baseIri}duration`) ?? getStr(planNode, `${schemaNs}duration`)) : null) ??
+            howTo?.totalTime ??
+            null,
+        state,
+        primaryIntegration: detectPrimaryIntegration(graph),
+        estimatedCost,
+        estimatedReturn,
+        estimatedROI,
+        potentialProfit: explicitUpside ?? calculatePotentialProfit(estimatedCost, estimatedReturn),
+        confidenceScore: howTo?.confidenceScore ?? null,
+        howTo,
+        graphDocument: graph,
+    };
+}

package/dist/lib/activity-changeset.d.ts

@@ -0,0 +1,34 @@
+import type { RDF } from "ldkit/rdf";
+import type { OntologyTerm } from "./ontology-terms.js";
+export type ActivityChangeKind = "created" | "updated" | "deleted";
+export type ActivityFieldDiff = {
+    predicate: string;
+    field: string;
+    before: string | null;
+    after: string | null;
+};
+export type ActivityChangeTriple = {
+    predicate: string;
+    object: string;
+    objectIsIri: boolean;
+};
+export type ActivityChangeGroup = {
+    entityIri: string;
+    entityLabel: string;
+    entityType: string | null;
+    changeKind: ActivityChangeKind;
+    diffs: ActivityFieldDiff[];
+    triples: ActivityChangeTriple[];
+    startedAt: string | null;
+    endedAt: string | null;
+    generatedIris: string[];
+};
+export type ActivityChangeSetResult = {
+    groups: ActivityChangeGroup[];
+};
+export declare function collectChangeSetIris(bindings: RDF.Bindings[]): string[];
+export declare function collectChangeSetPredicates(bindings: RDF.Bindings[]): string[];
+export declare function processChangeSetBindings(bindings: RDF.Bindings[], labels: Map<string, string>, terms?: Map<string, OntologyTerm>, generatedByChild?: Map<string, string[]>): {
+    groups: ActivityChangeGroup[];
+};
+//# sourceMappingURL=activity-changeset.d.ts.map

package/dist/lib/activity-changeset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-changeset.d.ts","sourceRoot":"","sources":["../../src/lib/activity-changeset.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAIrC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAQrD,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEnE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAG3B,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAEhC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,mBAAmB,EAAE,CAAC;CAC/B,CAAC;AA2IF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,YAY5D;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,YAiBlE;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,EACxB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACjC,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;;EAiDzC"}

package/dist/lib/activity-changeset.js

@@ -0,0 +1,172 @@
+import { isQueryableTermIri } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { rdf, wellKnownPredicates } from "@manta-eu/rdf-lib/namespaces";
+import { formatDisplayValue } from "../graph/property-formatters.js";
+import { DefaultMap } from "./default-map.js";
+import { extractLabel, extractTypeName, formatPropertyLabel } from "./iri-labels.js";
+import { bindingNodeIri, bindingValue } from "./rdf-helpers.js";
+const rdfTypeIri = rdf.type;
+// `:actionShape` links a planned subject to its request shape — structural noise in a diff.
+const hiddenDiffPredicates = new Set([wellKnownPredicates.actionShape]);
+function isIriLike(value) {
+    return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("urn:");
+}
+function iriLocalName(iri) {
+    const segments = iri.split(/[#/]/).filter(Boolean);
+    return segments[segments.length - 1] ?? iri;
+}
+function isNamePredicate(iri) {
+    const name = iriLocalName(iri).toLowerCase();
+    return name === "name" || name === "title" || name === "label";
+}
+function pickValue(entry) {
+    if (!isPresent(entry))
+        return null;
+    return entry.additions[0] ?? entry.removals[0] ?? null;
+}
+function resolveIriLabel(value, labels, predicate) {
+    return labels.get(value) || extractLabel(value, predicate) || iriLocalName(value);
+}
+function displayObjectValue(value, labels, predicate, field, valueScale) {
+    if (isIriLike(value))
+        return resolveIriLabel(value, labels, predicate);
+    return formatDisplayValue(value, { predicate, predicateLabel: field, valueScale });
+}
+function displayEntityName(value, labels) {
+    return isIriLike(value) ? resolveIriLabel(value, labels) : value;
+}
+function entityTypeFromIri(iri) {
+    const prefix = iriLocalName(iri).split("_")[0] ?? "";
+    return /^[A-Za-z]{2,}$/.test(prefix) ? prefix : null;
+}
+function joinValues(values, labels, predicate, field, valueScale) {
+    if (!isPresent(values))
+        return null;
+    return values.map((value) => displayObjectValue(value, labels, predicate, field, valueScale)).join(", ");
+}
+// `:actionShape` is kept though the diff table hides it — it routes a planned action to its own card.
+function buildChangeTriples(predicateEntries) {
+    return predicateEntries.flatMap(([predicate, values]) => values.additions.map((value) => ({ predicate, object: value, objectIsIri: isIriLike(value) })));
+}
+function buildTypeReplacementDiff(typeEntry) {
+    if (!typeEntry || typeEntry.additions.length === 0 || typeEntry.removals.length === 0)
+        return null;
+    return {
+        predicate: rdfTypeIri,
+        field: formatPropertyLabel(rdfTypeIri),
+        before: typeEntry.removals.map(extractTypeName).join(", "),
+        after: typeEntry.additions.map(extractTypeName).join(", "),
+    };
+}
+function deriveChangeKind(typeEntry) {
+    const typeAdded = isPresent(typeEntry?.additions);
+    const typeRemoved = isPresent(typeEntry?.removals);
+    if (typeAdded && !typeRemoved)
+        return "created";
+    if (typeRemoved && !typeAdded)
+        return "deleted";
+    return "updated";
+}
+function accumulateBindings(bindings) {
+    const subjects = new DefaultMap(() => ({
+        predicates: new DefaultMap(() => ({ additions: [], removals: [] })),
+        startedAt: null,
+        endedAt: null,
+        childIris: new Set(),
+    }));
+    for (const binding of bindings) {
+        const stmtSubject = bindingNodeIri(binding, "stmtSubject");
+        const predicate = bindingValue(binding, "predicate");
+        const object = bindingValue(binding, "object");
+        const kind = bindingValue(binding, "kind");
+        if (!stmtSubject || !predicate || object == null || !kind)
+            continue;
+        const subject = subjects.get(stmtSubject);
+        const childStart = bindingValue(binding, "childStart");
+        const childEnd = bindingValue(binding, "childEnd");
+        const child = bindingNodeIri(binding, "child");
+        if (child)
+            subject.childIris.add(child);
+        // Span all children; compare by parsed time (ISO fractional-second width varies).
+        if (childStart && (!subject.startedAt || Date.parse(childStart) < Date.parse(subject.startedAt))) {
+            subject.startedAt = childStart;
+        }
+        if (childEnd && (!subject.endedAt || Date.parse(childEnd) > Date.parse(subject.endedAt))) {
+            subject.endedAt = childEnd;
+        }
+        const predicateEntry = subject.predicates.get(predicate);
+        if (kind === "addition") {
+            predicateEntry.additions.push(object);
+        }
+        else {
+            predicateEntry.removals.push(object);
+        }
+    }
+    return subjects;
+}
+export function collectChangeSetIris(bindings) {
+    const iris = new Set();
+    for (const binding of bindings) {
+        const stmtSubject = bindingNodeIri(binding, "stmtSubject");
+        const object = bindingValue(binding, "object");
+        if (stmtSubject && isQueryableTermIri(stmtSubject))
+            iris.add(stmtSubject);
+        if (object && isIriLike(object))
+            iris.add(object);
+    }
+    return Array.from(iris);
+}
+export function collectChangeSetPredicates(bindings) {
+    const predicates = new Set();
+    for (const binding of bindings) {
+        const predicate = bindingValue(binding, "predicate");
+        if (predicate &&
+            predicate !== rdfTypeIri &&
+            !hiddenDiffPredicates.has(predicate) &&
+            isQueryableTermIri(predicate)) {
+            predicates.add(predicate);
+        }
+    }
+    return Array.from(predicates);
+}
+export function processChangeSetBindings(bindings, labels, terms, generatedByChild) {
+    const subjects = accumulateBindings(bindings);
+    const groups = Array.from(subjects.entries()).map(([subjectIri, subjectEntry]) => {
+        const predicateEntries = Array.from(subjectEntry.predicates.entries());
+        const typeEntry = predicateEntries.find(([predicate]) => predicate === rdfTypeIri)?.[1];
+        const typeIri = pickValue(typeEntry);
+        const entityType = typeIri ? iriLocalName(typeIri) : entityTypeFromIri(subjectIri);
+        const nameValue = pickValue(predicateEntries.find(([predicate]) => isNamePredicate(predicate))?.[1]);
+        const fieldDiffs = predicateEntries
+            .filter(([predicate]) => predicate !== rdfTypeIri && !hiddenDiffPredicates.has(predicate))
+            .map(([predicate, values]) => {
+            const field = formatPropertyLabel(predicate);
+            const valueScale = terms?.get(predicate)?.valueScale;
+            return {
+                predicate,
+                field,
+                before: joinValues(values.removals, labels, predicate, field, valueScale),
+                after: joinValues(values.additions, labels, predicate, field, valueScale),
+            };
+        });
+        const typeDiff = buildTypeReplacementDiff(typeEntry);
+        const diffs = typeDiff ? [typeDiff, ...fieldDiffs] : fieldDiffs;
+        const entityLabel = (nameValue ? displayEntityName(nameValue, labels) : "") ||
+            labels.get(subjectIri) ||
+            (entityType ? extractTypeName(entityType) : "") ||
+            extractLabel(subjectIri) ||
+            "Entity";
+        return {
+            entityIri: subjectIri,
+            entityLabel,
+            entityType,
+            changeKind: deriveChangeKind(typeEntry),
+            diffs,
+            triples: buildChangeTriples(predicateEntries),
+            startedAt: subjectEntry.startedAt,
+            endedAt: subjectEntry.endedAt,
+            generatedIris: [...subjectEntry.childIris].flatMap((child) => generatedByChild?.get(child) ?? []).sort(),
+        };
+    });
+    return { groups };
+}

package/dist/lib/build-config.d.ts

@@ -0,0 +1,6 @@
+import type { KeycloakRealm } from "@manta-eu/client/shared/constants";
+export declare const currentRealm: KeycloakRealm;
+export declare const isDevBuild: boolean;
+export declare const enableDatastoreManagement: boolean;
+export declare const enableDatastoreSwitching: boolean;
+//# sourceMappingURL=build-config.d.ts.map

package/dist/lib/build-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-config.d.ts","sourceRoot":"","sources":["../../src/lib/build-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAoBvE,eAAO,MAAM,YAAY,EAAE,aAA6B,CAAC;AAEzD,eAAO,MAAM,UAAU,SAA0B,CAAC;AAGlD,eAAO,MAAM,yBAAyB,SAIe,CAAC;AAEtD,eAAO,MAAM,wBAAwB,SAIe,CAAC"}

package/dist/lib/build-config.js

@@ -0,0 +1,20 @@
+import { activeRealm } from "@manta-eu/ldo/realm";
+import { z } from "zod";
+function buildEnv() {
+    const viteEnv = import.meta.env;
+    const nodeEnv = globalThis.process?.env;
+    return viteEnv ?? nodeEnv ?? {};
+}
+export const currentRealm = activeRealm();
+export const isDevBuild = buildEnv().DEV === true;
+// Gates the "Manage Datastores" nav item and profile-menu switching; off while rolling out.
+export const enableDatastoreManagement = z
+    .union([z.boolean(), z.stringbool()])
+    .optional()
+    .default(false)
+    .parse(buildEnv().VITE_ENABLE_DATASTORE_MANAGEMENT);
+export const enableDatastoreSwitching = z
+    .union([z.boolean(), z.stringbool()])
+    .optional()
+    .default(false)
+    .parse(buildEnv().VITE_ENABLE_DATASTORE_SWITCHING);

package/dist/lib/chat-types.d.ts

@@ -0,0 +1,42 @@
+import type { MantaModelId } from "@manta-eu/client/shared/model";
+import type { ReactNode } from "react";
+import type { Datastore } from "#ldo-ui";
+export type User = {
+    id: string;
+    email: string;
+    name?: string | null | undefined;
+};
+export type { Datastore };
+import type { PageContext } from "@manta-eu/client/shared/page-context";
+export type { PageContext };
+export type CopilotMenuDefaults = {
+    openInManta: ReactNode | null;
+    debugMessages: ReactNode | null;
+    clearChat: ReactNode | null;
+};
+export type AuthenticatedChatProps = {
+    datastore?: Datastore;
+    user: User;
+    isOperator: boolean;
+    canSwitchDatastore?: boolean;
+    onLogout?: () => void;
+    onClose?: () => void;
+    onSelectPlan?: (planIri: string) => void;
+    datastores?: Datastore[];
+    collapsible?: boolean;
+    isCollapsed?: boolean;
+    pageContext?: PageContext;
+    allowedModels?: MantaModelId[];
+    initialPrompt?: string;
+    title?: string;
+    welcomeSubtitle?: string;
+    assistantName?: string;
+    mark?: ReactNode;
+    renderMenuItems?: (defaults: CopilotMenuDefaults) => ReactNode[];
+};
+export type ResolvedChatProps = AuthenticatedChatProps & {
+    datastores: Datastore[];
+};
+export declare function resolveChatProps(props: AuthenticatedChatProps): ResolvedChatProps;
+export type ConnectionState = "open" | "closed" | "connecting" | "closing" | "unknown";
+//# sourceMappingURL=chat-types.d.ts.map

package/dist/lib/chat-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-types.d.ts","sourceRoot":"","sources":["../../src/lib/chat-types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,MAAM,MAAM,IAAI,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAClC,CAAC;AAEF,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAExE,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,SAAS,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,SAAS,GAAG,IAAI,CAAC;IAChC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;CAC7B,CAAC;AAGF,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,EAAE,OAAO,CAAC;IACpB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,aAAa,CAAC,EAAE,YAAY,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,mBAAmB,KAAK,SAAS,EAAE,CAAC;CAClE,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,sBAAsB,GAAG;IACvD,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,sBAAsB,GAAG,iBAAiB,CAEjF;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC"}

package/dist/lib/chat-types.js

@@ -0,0 +1,3 @@
+export function resolveChatProps(props) {
+    return { ...props, datastores: props.datastores ?? [] };
+}

package/dist/lib/datastore-route-paths.d.ts

@@ -0,0 +1,5 @@
+export { datastoreRoutePaths, notFoundRoutePath } from "@manta-eu/client/shared/datastore-route-table";
+export type { RouteElements } from "@manta-eu/client/shared/datastore-route-table";
+export declare function isDatastoreRoutePath(pathname: string): boolean;
+export declare function datastoreSwitchFallbackPath(pathname: string): string | undefined;
+//# sourceMappingURL=datastore-route-paths.d.ts.map

package/dist/lib/datastore-route-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore-route-paths.d.ts","sourceRoot":"","sources":["../../src/lib/datastore-route-paths.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AACvG,YAAY,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAC;AAGnF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAG9D;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,sBAW3D"}

package/dist/lib/datastore-route-paths.js

@@ -0,0 +1,19 @@
+import { datastoreRoutes, notFoundRoutePath } from "@manta-eu/client/shared/datastore-route-table";
+import { length, maxBy } from "ramda";
+import { matchRoutes } from "react-router";
+export { datastoreRoutePaths, notFoundRoutePath } from "@manta-eu/client/shared/datastore-route-table";
+// The catch-all matches every path, so landing on it means no real route claims this one.
+export function isDatastoreRoutePath(pathname) {
+    const matched = matchRoutes(datastoreRoutes, pathname)?.at(-1)?.route.path;
+    return matched !== undefined && matched !== notFoundRoutePath;
+}
+export function datastoreSwitchFallbackPath(pathname) {
+    const route = matchRoutes(datastoreRoutes, pathname)?.at(-1)?.route;
+    if (!route?.path.includes("/:"))
+        return undefined;
+    const staticPrefix = route.path.slice(0, route.path.indexOf("/:"));
+    return datastoreRoutes
+        .filter(({ path }) => path === staticPrefix || staticPrefix.startsWith(`${path}/`))
+        .map(({ path }) => path)
+        .reduce(maxBy(length), "/");
+}

package/dist/lib/datastore-routes.d.ts

@@ -0,0 +1,4 @@
+import { type RouteElements } from "@manta-eu/client/shared/datastore-route-table";
+export declare function getDatastoreRoutes(elements: RouteElements): import("react/jsx-runtime").JSX.Element;
+export declare function getGlobalRoutes(elements: RouteElements): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=datastore-routes.d.ts.map

package/dist/lib/datastore-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore-routes.d.ts","sourceRoot":"","sources":["../../src/lib/datastore-routes.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,+CAA+C,CAAC;AAavD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,aAAa,2CAEzD;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,aAAa,2CAOtD"}

package/dist/lib/datastore-routes.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { datastoreRoutes, globalRoutes, notFoundElement, } from "@manta-eu/client/shared/datastore-route-table";
+import { Route, Routes } from "react-router";
+function renderRoute(route, elements) {
+    const { path, render, children } = route;
+    return (_jsx(Route, { path: path, element: render(elements), children: children?.map((child) => renderRoute(child, elements)) }, path));
+}
+export function getDatastoreRoutes(elements) {
+    return _jsx(Routes, { children: datastoreRoutes.map((route) => renderRoute(route, elements)) });
+}
+export function getGlobalRoutes(elements) {
+    return (_jsxs(Routes, { children: [globalRoutes.map((route) => renderRoute(route, elements)), _jsx(Route, { path: "*", element: elements.EnterDatastore ?? notFoundElement(elements) })] }));
+}