@manta-eu/react 0.1.0

package/dist/rdfox-explain/tree-model.js

@@ -0,0 +1,450 @@
+import { classAssertionFromAtom, isDatalogAtom, isLiteralTerm, isVariableTerm, literalToDisplayText, propertyAssertionFromAtom, termToDatalogText, unwrapTermExpression, } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { countBy } from "ramda";
+import { match, P } from "ts-pattern";
+import { parseDatalogRuleCached, parseGroundedDatalogRuleCached } from "../rules/datalog-cache.js";
+import { aggregateBindingSegments } from "../rules/rule-narrative-aggregates.js";
+import { buildFilterRow } from "../rules/rule-narrative-filters.js";
+import { labeledEntitySegment } from "../rules/rule-narrative-format.js";
+import { createRuleNarrativeRenderer } from "../rules/rule-narrative-renderer.js";
+export function isRDFoxExplainOutput(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    return Object.values(value).every((entry) => typeof entry === "object" && entry !== null);
+}
+export function isTypeFact(node) {
+    return node.spo?.predicate === "rdf:type";
+}
+export function isFactNode(node) {
+    return node.kind === "derived-fact" || node.kind === "explicit-fact";
+}
+export function multipleSupports(node) {
+    const supports = node.supports ?? [];
+    return supports.length > 1 ? supports : undefined;
+}
+export function subjectTypeTerm(tree, subject) {
+    const typeFact = Object.values(tree.byId).find((node) => isTypeFact(node) && node.spo?.subject === subject);
+    return typeFact?.spo?.object;
+}
+export function consumingRuleNode(tree, node) {
+    if (node.id === tree.root.id) {
+        return node.rule ? node : undefined;
+    }
+    const parent = node.parentId ? tree.byId[node.parentId] : undefined;
+    return parent?.rule ? parent : undefined;
+}
+// The named graph may follow the closing bracket with no space: ":p[_:b, 1]:Graph".
+const bracketFactPattern = /^([^[\s]+)\[(.*)\]/;
+const tripleFactPattern = /^(\S+)\s+(\S+)\s+(.+)$/;
+const functionAtomPattern = /^[A-Za-z]\w*\(/;
+export function buildExplainPath(spo) {
+    const params = new URLSearchParams({
+        subject: spo.subject,
+        object: spo.object,
+    });
+    if (spo.predicate)
+        params.set("predicate", spo.predicate);
+    if (spo.namedGraph)
+        params.set("namedGraph", spo.namedGraph);
+    if (spo.objectDatatype)
+        params.set("objectDatatype", spo.objectDatatype);
+    return `/explain?${params.toString()}`;
+}
+export function parseFactStatement(text) {
+    const trimmed = text.trim();
+    if (functionAtomPattern.test(trimmed))
+        return undefined;
+    const bracketMatch = trimmed.match(bracketFactPattern);
+    if (bracketMatch) {
+        const [, head, rawArgs] = bracketMatch;
+        const args = splitTopLevel(rawArgs ?? "", ",").map((part) => part.trim());
+        if (!head || !args[0])
+            return undefined;
+        if (args.length === 1) {
+            return { subject: args[0], predicate: "rdf:type", object: head };
+        }
+        const object = args.slice(1).join(", ").trim();
+        if (!object)
+            return undefined;
+        return { subject: args[0], predicate: head, object };
+    }
+    const tripleMatch = trimmed.match(tripleFactPattern);
+    if (!tripleMatch)
+        return undefined;
+    const [, subject, predicate, object] = tripleMatch;
+    if (!subject || !predicate || !object)
+        return undefined;
+    return {
+        subject,
+        predicate: predicate === "a" ? "rdf:type" : predicate,
+        object: object.trim(),
+    };
+}
+export function normalize(output) {
+    const entries = flattenFacts(output);
+    if (!isPresent(entries))
+        return null;
+    const entriesByKey = new Map();
+    for (const entry of entries) {
+        if (!entriesByKey.has(entry.key))
+            entriesByKey.set(entry.key, entry);
+    }
+    const referencedKeys = collectReferencedFactKeys(entries, entriesByKey);
+    const rootEntry = entries.find((entry) => !referencedKeys.has(entry.key)) ?? entries[0];
+    if (!rootEntry)
+        return null;
+    const byId = {};
+    function appendFactNode(args) {
+        const { entry, id, parentId, path, bodyIndex } = args;
+        const ruleInstance = firstRuleInstance(entry.fact);
+        const rule = ruleInstance?.rule;
+        const supports = ruleInstanceViews(entry.fact);
+        const node = {
+            id,
+            kind: factNodeKind(entry.fact),
+            display: entry.fact.fact ?? entry.key,
+            rule,
+            groundedRule: ruleInstance?.["grounded-rule"],
+            parentId,
+            childIds: [],
+            bodyIndex,
+            spo: typeof entry.fact.fact === "string" ? parseFactStatement(entry.fact.fact) : undefined,
+            provenance: provenanceForFact(entry.fact, rule),
+            ...(isPresent(supports) && { supports }),
+        };
+        byId[id] = node;
+        if (rule && !path.has(entry.key)) {
+            const nextPath = new Set(path).add(entry.key);
+            const bodyTerms = getRuleBodyTerms(rule);
+            const groundedBodyTerms = node.groundedRule ? getRuleBodyTerms(node.groundedRule) : [];
+            const bodyFormulas = ruleBodyFormulas(rule, bodyTerms.length);
+            const groundedAst = node.groundedRule ? parseGroundedDatalogRuleCached(node.groundedRule).ast : null;
+            const groundedBodyFormulas = groundedAst?.body.length === bodyTerms.length ? groundedAst.body : undefined;
+            const narrativeRenderer = groundedAst
+                ? createRuleNarrativeRenderer(groundedAst, { plainValues: true })
+                : undefined;
+            node.childIds = (ruleInstance?.["body-facts"] ?? [])
+                .map((bodyFact, index) => appendBodyFact({
+                bodyFact,
+                bodyTerm: bodyTerms[index],
+                bodyFormula: bodyFormulas?.[index],
+                groundedFormula: groundedBodyFormulas?.[index],
+                narrativeRenderer,
+                groundedBodyTerm: groundedBodyTerms[index],
+                parentId: id,
+                index,
+                path: nextPath,
+            }))
+                .filter((childId) => isPresent(childId));
+        }
+        return id;
+    }
+    function appendBodyFact(args) {
+        const { bodyFact, bodyTerm, bodyFormula, groundedFormula, narrativeRenderer, groundedBodyTerm, parentId, index, path, } = args;
+        const id = `${parentId}:body:${index}`;
+        if (typeof bodyFact === "string") {
+            const referencedEntry = entriesByKey.get(bodyFact);
+            if (referencedEntry) {
+                const nodeId = appendFactNode({ entry: referencedEntry, id, parentId, path, bodyIndex: index });
+                const node = byId[nodeId];
+                if (node?.kind === "skolem" && groundedFormula) {
+                    node.skolemTerm = skolemOutputTerm(groundedFormula);
+                }
+                return nodeId;
+            }
+            byId[id] = {
+                id,
+                kind: "explicit-fact",
+                display: bodyFact,
+                parentId,
+                childIds: [],
+                bodyIndex: index,
+                spo: parseFactStatement(bodyFact),
+                provenance: "explicit",
+            };
+            return id;
+        }
+        if (!bodyTerm)
+            return undefined;
+        byId[id] = {
+            id,
+            kind: bodyFormula ? kindForBodyFormula(bodyFormula) : kindForSyntheticTerm(bodyTerm),
+            display: bodyTerm,
+            groundedDisplay: groundedBodyTerm,
+            parentId,
+            childIds: [],
+            bodyIndex: index,
+            narrative: groundedFormula && narrativeRenderer && formulaNarrative(groundedFormula, narrativeRenderer),
+            aggregateOutputs: bodyFormula && groundedFormula && narrativeRenderer
+                ? aggregateOutputsOf(bodyFormula, groundedFormula, narrativeRenderer)
+                : undefined,
+            skolemTerm: groundedFormula && skolemOutputTerm(groundedFormula),
+            negatedSpo: groundedFormula && negatedFactSpo(groundedFormula),
+        };
+        return id;
+    }
+    const rootId = appendFactNode({ entry: rootEntry, id: rootEntry.id, parentId: null, path: new Set() });
+    return {
+        root: byId[rootId],
+        byId,
+    };
+}
+function factNodeKind(fact) {
+    const text = (fact.fact ?? "").trim();
+    if (functionAtomPattern.test(text))
+        return kindForSyntheticTerm(text);
+    return fact.type === "explicit" ? "explicit-fact" : "derived-fact";
+}
+function flattenFacts(output) {
+    return Object.entries(output).flatMap(([key, value]) => {
+        const values = Array.isArray(value) ? value : [value];
+        return values.flatMap((fact, index) => {
+            if (!isRDFoxFact(fact))
+                return [];
+            return [
+                {
+                    key,
+                    id: values.length === 1 ? `fact:${key}` : `fact:${key}:${index}`,
+                    fact,
+                },
+            ];
+        });
+    });
+}
+function isRDFoxFact(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectReferencedFactKeys(entries, entriesByKey) {
+    const result = new Set();
+    for (const entry of entries) {
+        for (const ruleInstance of entry.fact["rule-instances"] ?? []) {
+            for (const bodyFact of ruleInstance["body-facts"] ?? []) {
+                if (typeof bodyFact === "string" && entriesByKey.has(bodyFact)) {
+                    result.add(bodyFact);
+                }
+            }
+        }
+    }
+    return result;
+}
+function firstRuleInstance(fact) {
+    return fact["rule-instances"]?.find((candidate) => typeof candidate.rule === "string");
+}
+function ruleInstanceViews(fact) {
+    return (fact["rule-instances"] ?? [])
+        .filter((instance) => typeof instance.rule === "string")
+        .map((instance) => ({
+        rule: instance.rule,
+        groundedRule: instance["grounded-rule"],
+        bodyFacts: instance["body-facts"] ?? [],
+    }));
+}
+function provenanceForFact(fact, rule) {
+    return match(fact.type)
+        .returnType()
+        .with("false", () => "absent")
+        .with("explicit", () => "explicit")
+        .otherwise(() => (rule && ruleHeadValueIsComputed(rule) ? "computed" : "derived"));
+}
+function ruleHeadValueIsComputed(rule) {
+    const ast = parseDatalogRuleCached(rule).ast;
+    if (!ast)
+        return false;
+    const headObjectVariable = headObjectVariableName(ast.head[0]);
+    if (!headObjectVariable)
+        return false;
+    return ast.body.some((formula) => formula.type === "bind" && formula.variable === headObjectVariable);
+}
+function headObjectVariableName(head) {
+    if (!head)
+        return undefined;
+    return match(head)
+        .with({ type: "property" }, (atom) => (atom.object.type === "variable" ? atom.object.name : undefined))
+        .with({ type: "triple" }, (atom) => (atom.object.type === "variable" ? atom.object.name : undefined))
+        .otherwise(() => undefined);
+}
+export function ruleHeadText(rule) {
+    return (rule
+        .split(":-")[0]
+        ?.trim()
+        .replace(/\s*\.$/, "") ?? rule);
+}
+export function ruleHeadTerms(rule) {
+    return splitTopLevel(ruleHeadText(rule), ",")
+        .map((part) => part.trim())
+        .filter(isPresent);
+}
+export function getRuleBodyTerms(rule) {
+    const body = bodyText(rule);
+    if (!body)
+        return [];
+    return splitTopLevel(body, ",")
+        .map((part) => part.trim().replace(/\s+\.$/, ""))
+        .filter(isPresent);
+}
+function bodyText(rule) {
+    if (rule.includes(":-")) {
+        return rule
+            .split(":-")
+            .slice(1)
+            .join(":-")
+            .trim()
+            .replace(/\s*\.$/, "");
+    }
+    if (rule.includes("=>")) {
+        return rule
+            .split("=>")[0]
+            ?.trim()
+            .replace(/\s*\.$/, "");
+    }
+    return undefined;
+}
+export function kindForBodyFormula(formula) {
+    return match(formula)
+        .with({ type: P.union("triple", "property", "class", "general") }, () => "derived-fact")
+        .with({ type: "negation" }, () => "negation")
+        .with({ type: "aggregate" }, () => "aggregate")
+        .with({ type: "bind" }, () => "bind")
+        .with({ type: "filter" }, () => "filter")
+        .with({ type: "skolem" }, () => "skolem")
+        .exhaustive();
+}
+function formulaNarrative(groundedFormula, renderer) {
+    try {
+        return match(groundedFormula)
+            .with({ type: "filter" }, (filter) => buildFilterRow(filter, renderer).segments)
+            .with({ type: "bind" }, (bind) => renderer.expressionSegments(bind.expression, { labelVariables: true }))
+            .otherwise(() => undefined);
+    }
+    catch {
+        return undefined;
+    }
+}
+function negatedFactSpo(groundedFormula) {
+    return match(groundedFormula)
+        .with({ type: "negation", formulas: [P.when(isDatalogAtom)] }, ({ formulas, existentialVars }) => {
+        const atom = formulas[0];
+        if (!atom || isPresent(existentialVars ?? []))
+            return undefined;
+        const classAssertion = classAssertionFromAtom(atom);
+        if (classAssertion) {
+            return {
+                subject: termToDatalogText(classAssertion.instance),
+                predicate: "rdf:type",
+                object: classAssertion.className,
+            };
+        }
+        const propertyAssertion = propertyAssertionFromAtom(atom);
+        if (!propertyAssertion)
+            return undefined;
+        return {
+            subject: termToDatalogText(propertyAssertion.subject),
+            predicate: propertyAssertion.predicate,
+            object: termToDatalogText(propertyAssertion.object),
+        };
+    })
+        .otherwise(() => undefined);
+}
+function skolemOutputTerm(groundedFormula) {
+    return match(groundedFormula)
+        .with({ type: "skolem" }, ({ args }) => {
+        const lastArgument = args[args.length - 1];
+        const output = lastArgument ? unwrapTermExpression(lastArgument) : null;
+        return output ? termToDatalogText(output) : undefined;
+    })
+        .otherwise(() => undefined);
+}
+function sourceTermsByVariable(atoms) {
+    return new Map(atoms.filter(isDatalogAtom).flatMap((atom) => {
+        const assertion = propertyAssertionFromAtom(atom);
+        return assertion && isVariableTerm(assertion.object)
+            ? [[assertion.object.name, assertion.predicate]]
+            : [];
+    }));
+}
+function aggregateOutputsOf(bodyFormula, groundedFormula, renderer) {
+    return match([bodyFormula, groundedFormula])
+        .with([{ type: "aggregate" }, { type: "aggregate" }], ([aggregate, grounded]) => {
+        const sourceTermByVariable = sourceTermsByVariable(aggregate.atoms);
+        const variableCountBySourceTerm = countBy((term) => term, [...sourceTermByVariable.values()]);
+        const expressionSegments = (expression) => renderer.expressionSegments(expression).map((segment) => {
+            if (segment.kind !== "variable")
+                return segment;
+            const sourceTerm = sourceTermByVariable.get(segment.name);
+            return sourceTerm && variableCountBySourceTerm[sourceTerm] === 1
+                ? labeledEntitySegment(sourceTerm, "predicate")
+                : segment;
+        });
+        const outputs = (aggregate.bindings ?? []).flatMap((binding, index) => {
+            const value = grounded.bindings?.[index]?.groundedTarget;
+            if (!value)
+                return [];
+            return [
+                {
+                    segments: aggregateBindingSegments(binding, expressionSegments),
+                    variable: binding.variable,
+                    value: isLiteralTerm(value) ? literalToDisplayText(value) : termToDatalogText(value),
+                },
+            ];
+        });
+        return isPresent(outputs) ? outputs : undefined;
+    })
+        .otherwise(() => undefined);
+}
+function ruleBodyFormulas(rule, expectedCount) {
+    const ast = parseDatalogRuleCached(rule).ast ?? parseGroundedDatalogRuleCached(rule).ast ?? undefined;
+    if (!ast || ast.body.length !== expectedCount)
+        return undefined;
+    return ast.body;
+}
+const atomPattern = /^[^\s(]+\[/;
+export function kindForSyntheticTerm(term) {
+    const trimmed = term.trim();
+    if (atomPattern.test(trimmed)) {
+        return "derived-fact";
+    }
+    const normalized = trimmed.toUpperCase();
+    if (normalized.startsWith("NOT")) {
+        return "negation";
+    }
+    if (normalized.startsWith("BIND")) {
+        return "bind";
+    }
+    if (normalized.startsWith("SKOLEM")) {
+        return "skolem";
+    }
+    if (normalized.startsWith("FILTER") || normalized.startsWith("EXISTS")) {
+        return "filter";
+    }
+    if (normalized.includes("AGGREGATE") || normalized.includes("GROUP BY")) {
+        return "aggregate";
+    }
+    return "filter";
+}
+const openingBrackets = new Set(["[", "(", "{"]);
+const closingBrackets = new Set(["]", ")", "}"]);
+function bracketDepthDelta(char) {
+    if (openingBrackets.has(char))
+        return 1;
+    if (closingBrackets.has(char))
+        return -1;
+    return 0;
+}
+function splitTopLevel(input, separator) {
+    const initial = { segments: [], current: "", depth: 0, inString: false, escaped: false };
+    const scan = [...input].reduce((state, char) => {
+        if (state.escaped) {
+            return { ...state, escaped: false, current: state.current + char };
+        }
+        if (char === "\\") {
+            return { ...state, escaped: true, current: state.current + char };
+        }
+        const inString = char === `"` ? !state.inString : state.inString;
+        const depth = inString ? state.depth : Math.max(0, state.depth + bracketDepthDelta(char));
+        if (!inString && depth === 0 && char === separator) {
+            return { ...state, inString, depth, segments: [...state.segments, state.current], current: "" };
+        }
+        return { ...state, inString, depth, current: state.current + char };
+    }, initial);
+    return [...scan.segments, scan.current];
+}

package/dist/rdfox-explain/use-fact-measure.d.ts

@@ -0,0 +1,4 @@
+import { type MeasureKind } from "../lib/measure.js";
+export declare function useFactMeasure(predicate?: string): MeasureKind | undefined;
+export declare function useFactMeasures(predicates: (string | undefined)[]): Map<string, MeasureKind>;
+//# sourceMappingURL=use-fact-measure.d.ts.map

package/dist/rdfox-explain/use-fact-measure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-fact-measure.d.ts","sourceRoot":"","sources":["../../src/rdfox-explain/use-fact-measure.ts"],"names":[],"mappings":"AACA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGvE,wBAAgB,cAAc,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAE1E;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAmB5F"}

package/dist/rdfox-explain/use-fact-measure.js

@@ -0,0 +1,21 @@
+import { useOntologyTerms } from "../hooks/use-ontology-terms.js";
+import { measureFromUnitCode } from "../lib/measure.js";
+import { ontologyTermIri } from "../ontology/OntologyTermText.js";
+export function useFactMeasure(predicate) {
+    return useFactMeasures([predicate]).get(predicate ?? "");
+}
+export function useFactMeasures(predicates) {
+    const iris = predicates.flatMap((predicate) => {
+        const iri = predicate ? ontologyTermIri(predicate) : undefined;
+        return iri ? [iri] : [];
+    });
+    const terms = useOntologyTerms(iris);
+    const measures = new Map();
+    for (const predicate of predicates) {
+        const iri = predicate ? ontologyTermIri(predicate) : undefined;
+        const measure = iri ? measureFromUnitCode(terms.get(iri)?.unitCode) : undefined;
+        if (predicate && measure)
+            measures.set(predicate, measure);
+    }
+    return measures;
+}

package/dist/routes/activity/change-display.d.ts

@@ -0,0 +1,9 @@
+import type { ActivityFieldDiff } from "#ldo-ui";
+export type DiffChangeType = "added" | "changed" | "removed";
+export declare function shortenValue(value: string): string;
+export declare function diffChangeType(diff: ActivityFieldDiff): DiffChangeType;
+export type DiffRowProps = {
+    diff: ActivityFieldDiff;
+};
+export declare function DiffRow(props: DiffRowProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=change-display.d.ts.map

package/dist/routes/activity/change-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-display.d.ts","sourceRoot":"","sources":["../../../src/routes/activity/change-display.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAGjD,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;AAc7D,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,UAUzC;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,iBAAiB,GAAG,cAAc,CAEtE;AAED,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAEvD,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,2CAiC1C"}

package/dist/routes/activity/change-display.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { Badge } from "#components/badge/index";
+import { cn } from "#lib/utils";
+const diffRowTint = {
+    changed: "bg-warning/40",
+    added: "bg-success/40",
+    removed: "bg-muted/40",
+};
+const diffBadge = {
+    changed: { label: "changed", variant: "warning" },
+    added: { label: "new", variant: "success" },
+    removed: { label: "removed", className: "bg-muted text-muted-foreground" },
+};
+export function shortenValue(value) {
+    const url = URL.canParse(value) ? new URL(value) : null;
+    if (!url?.protocol.match(/^(https?|s3):$/))
+        return value;
+    const [withoutQuery] = value.split("?");
+    const segment = (withoutQuery ?? value).split("/").filter(Boolean).pop();
+    return segment || value;
+}
+export function diffChangeType(diff) {
+    return isPresent(diff.after) ? (isPresent(diff.before) ? "changed" : "added") : "removed";
+}
+export function DiffRow(props) {
+    const { field, before, after } = props.diff;
+    const changeType = diffChangeType(props.diff);
+    const badge = diffBadge[changeType];
+    return (_jsxs("div", { className: cn("grid grid-cols-[fit-content(150px)_minmax(0,1fr)_auto] items-baseline gap-2 rounded-md px-2 py-1", diffRowTint[changeType]), children: [_jsx("span", { className: "typography-small text-muted-foreground truncate", title: field, children: field }), _jsxs("div", { className: "min-w-0 line-clamp-2 break-words text-right", children: [isPresent(before) && (_jsx("span", { className: "typography-small text-muted-foreground line-through mr-1.5", title: before, children: shortenValue(before) })), isPresent(after) && (_jsx("span", { className: "typography-small text-default-foreground", title: after, children: shortenValue(after) }))] }), _jsx(Badge, { size: "sm", variant: badge.variant, className: cn("shrink-0", badge.className), children: badge.label })] }));
+}

package/dist/routes/activity/components/ActivityFilters.d.ts

@@ -0,0 +1,9 @@
+import type { ActivityStatusFilter } from "#ldo-ui";
+export type ActivityFiltersProps = {
+    search: string;
+    onSearchChange: (value: string) => void;
+    status: ActivityStatusFilter;
+    onStatusChange: (value: ActivityStatusFilter) => void;
+};
+export declare function ActivityFilters(props: ActivityFiltersProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ActivityFilters.d.ts.map

package/dist/routes/activity/components/ActivityFilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityFilters.d.ts","sourceRoot":"","sources":["../../../../src/routes/activity/components/ActivityFilters.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAgFpD,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,cAAc,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC;CACvD,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,2CAgC1D"}

package/dist/routes/activity/components/ActivityFilters.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { ChevronDown, X } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { useDebounceValue } from "usehooks-ts";
+import { Button } from "#components/button/index";
+import { Dropdown, DropdownContent, DropdownGroup, DropdownItem, DropdownTrigger } from "#components/dropdown/index";
+import { FilterSection, FilterSheet } from "#components/filter-sheet/index";
+import { SearchInput } from "#components/input/index";
+import { cn } from "#lib/utils";
+const statusOptions = [
+    { id: "all", label: "All statuses" },
+    { id: "completed", label: "Completed", dotClass: "bg-success-foreground" },
+    { id: "failed", label: "Failed", dotClass: "bg-error-foreground" },
+    { id: "running", label: "Running", dotClass: "bg-warning-foreground" },
+];
+function StatusDropdown(props) {
+    const { value, onChange } = props;
+    const selected = statusOptions.find((option) => option.id === value);
+    const isAll = value === "all";
+    return (_jsxs(Dropdown, { children: [_jsx(DropdownTrigger, { asChild: true, children: _jsxs(Button, { variant: "tertiary", size: "base", rounded: "lg", children: [_jsxs("span", { className: "flex items-center gap-2", children: [!isAll && selected?.dotClass && _jsx("span", { className: cn("size-2.5 rounded-full", selected.dotClass) }), _jsx("span", { children: isAll ? "Status" : selected?.label })] }), _jsx(ChevronDown, { className: "size-4" })] }) }), _jsx(DropdownContent, { align: "start", className: "w-48", children: _jsx(DropdownGroup, { label: "Show statuses", children: statusOptions.map((option) => (_jsx(DropdownItem, { selected: option.id === value, onClick: () => onChange(option.id), icon: _jsx("span", { className: cn("size-2 rounded-full", option.dotClass ?? "opacity-0") }), children: option.label }, option.id))) }) })] }));
+}
+function ActivitySearch(props) {
+    const { value, onChange } = props;
+    const [input, setInput] = useState(value);
+    const [debounced] = useDebounceValue(input, 300);
+    const previousDebounced = useRef(debounced);
+    const previousValue = useRef(value);
+    useEffect(() => {
+        if (previousDebounced.current === debounced)
+            return;
+        previousDebounced.current = debounced;
+        if (debounced !== value)
+            onChange(debounced);
+    }, [debounced, value, onChange]);
+    useEffect(() => {
+        if (previousValue.current === value)
+            return;
+        previousValue.current = value;
+        if (value !== debounced)
+            setInput(value);
+    }, [value, debounced]);
+    return (_jsx("div", { className: "min-w-0 flex-1 sm:w-64 sm:flex-none", children: _jsx(SearchInput, { placeholder: "Search activity\u2026", value: input, onChange: (event) => setInput(event.target.value), clearValue: () => setInput(""), autoComplete: "off" }) }));
+}
+export function ActivityFilters(props) {
+    const { search, onSearchChange, status, onStatusChange } = props;
+    const hasActiveFilters = isPresent(search) || status !== "all";
+    // Count search too: Reset clears it, so the count that gates Reset must include it.
+    const activeFilterCount = (isPresent(search) ? 1 : 0) + (status !== "all" ? 1 : 0);
+    function handleClear() {
+        onSearchChange("");
+        onStatusChange("all");
+    }
+    return (_jsxs("div", { className: "flex min-w-0 flex-wrap items-center gap-2", children: [_jsx(ActivitySearch, { value: search, onChange: onSearchChange }), _jsx("div", { className: "sm:hidden", children: _jsx(FilterSheet, { activeCount: activeFilterCount, onReset: handleClear, children: _jsx(FilterSection, { title: "Status", children: _jsx(StatusDropdown, { value: status, onChange: onStatusChange }) }) }) }), _jsxs("div", { className: "hidden sm:contents", children: [_jsx(StatusDropdown, { value: status, onChange: onStatusChange }), hasActiveFilters && (_jsx(Button, { variant: "ghost", size: "base", rounded: "lg", onClick: handleClear, icon: X, children: "Clear filters" }))] })] }));
+}

package/dist/routes/activity/components/ActivityStatusBadge.d.ts

@@ -0,0 +1,6 @@
+import type { ActivityStatus } from "#ldo-ui";
+export type ActivityStatusBadgeProps = {
+    status: ActivityStatus;
+};
+export declare function ActivityStatusBadge(props: ActivityStatusBadgeProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ActivityStatusBadge.d.ts.map

package/dist/routes/activity/components/ActivityStatusBadge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityStatusBadge.d.ts","sourceRoot":"","sources":["../../../../src/routes/activity/components/ActivityStatusBadge.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAQ9C,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,cAAc,CAAC;CACxB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,2CAQlE"}

package/dist/routes/activity/components/ActivityStatusBadge.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Badge } from "#components/badge/index";
+const statusConfig = {
+    failed: { label: "Failed", variant: "destructive" },
+    completed: { label: "Completed", variant: "success" },
+    running: { label: "Running", variant: "info" },
+};
+export function ActivityStatusBadge(props) {
+    const { label, variant } = statusConfig[props.status];
+    return (_jsx(Badge, { variant: variant, size: "sm", children: label }));
+}

package/dist/routes/activity/components/ActivityTable.d.ts

@@ -0,0 +1,13 @@
+import type { Activity } from "../types.js";
+type ActivityTableProps = {
+    activities: Activity[];
+    onRowClick?: (activity: Activity) => void;
+    isLoading?: boolean;
+    pageIndex?: number;
+    pageSize?: number;
+    onPageChange?: (pageIndex: number) => void;
+    totalPages?: number;
+};
+export declare function ActivityTable(props: ActivityTableProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=ActivityTable.d.ts.map

package/dist/routes/activity/components/ActivityTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityTable.d.ts","sourceRoot":"","sources":["../../../../src/routes/activity/components/ActivityTable.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAYzC,KAAK,kBAAkB,GAAG;IACxB,UAAU,EAAE,QAAQ,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC1C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,2CAkEtD"}