@manta-eu/react 0.1.0

package/dist/rdfox-explain/inspector/InspectorRule.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { Copy } from "lucide-react";
+import { useState } from "react";
+import { match, P } from "ts-pattern";
+import { DatalogCode } from "../DatalogCode.js";
+import { sectionLabelClass } from "../explain-styles.js";
+import { ExplainTag } from "../ExplainTag.js";
+import { NumDot } from "../NumDot.js";
+import { PanelLabel } from "../PanelLabel.js";
+import { derivedHeadAtom, formatRuleText, maskSubstitutedLiterals, } from "../rule-presentation.js";
+import { RuleVariableTypes } from "../RuleVariableTypes.js";
+import { Button } from "#components/button/index";
+import { Tabs, TabsList, TabsTrigger } from "#components/tabs/index";
+import { useCopyToClipboard } from "#lib/use-copy-clipboard";
+import { isMaskedResolution, usePersonalDataResolutionFor } from "#ontology/use-personal-data";
+import { cn } from "#style";
+const ruleViewModeOptions = [
+    { value: "rule", label: "Rule" },
+    { value: "grounded", label: "Grounded" },
+];
+function roleForKind(kind) {
+    return match(kind)
+        .with("negation", () => "absence")
+        .with(P.union("bind", "aggregate"), () => "computes")
+        .with(P.union("filter", "skolem"), () => "guard")
+        .with(P.union("derived-fact", "explicit-fact"), () => undefined)
+        .exhaustive();
+}
+export function InspectorRule(props) {
+    const { presentation, highlightedAtomIndex, derivedFactText } = props;
+    const { copyToClipboard } = useCopyToClipboard();
+    const [viewMode, setViewMode] = useState("grounded");
+    const [showAllHeadAtoms, setShowAllHeadAtoms] = useState(false);
+    const grounded = viewMode === "grounded";
+    const ruleAtoms = [...presentation.headAtoms, ...presentation.atoms];
+    const personalDataResolutions = usePersonalDataResolutionFor(ruleAtoms.map((atom) => atom.predicateTerm));
+    const containsPersonalData = [...personalDataResolutions.values()].some(isMaskedResolution);
+    const derivedAtom = derivedHeadAtom(presentation.headAtoms, derivedFactText);
+    const otherHeadAtoms = derivedAtom ? presentation.headAtoms.filter((atom) => atom !== derivedAtom) : [];
+    // In a rule that touches personal data (or whose term lookups are still pending),
+    // every grounded literal that was substituted for a variable is masked - a PII value
+    // flows into any premise, FILTER, or BIND via unification, quoted or bare. Literals
+    // authored in the rule itself stay visible; text we cannot align is hidden entirely.
+    function maskedGrounded(groundedText, rawText) {
+        return containsPersonalData ? maskSubstitutedLiterals(rawText, groundedText) : groundedText;
+    }
+    function groundedHead() {
+        if (!containsPersonalData)
+            return presentation.groundedHeadText;
+        if (!isPresent(presentation.headAtoms)) {
+            return maskSubstitutedLiterals(presentation.headText, presentation.groundedHeadText);
+        }
+        return presentation.headAtoms.map((atom) => maskedGrounded(atom.groundedText, atom.text)).join(", ");
+    }
+    function headText() {
+        if (derivedAtom)
+            return grounded ? maskedGrounded(derivedAtom.groundedText, derivedAtom.text) : derivedAtom.text;
+        return grounded ? groundedHead() : presentation.headText;
+    }
+    function atomText(atom) {
+        return grounded ? maskedGrounded(atom.groundedText, atom.text) : atom.text;
+    }
+    const ruleText = grounded
+        ? formatRuleText(groundedHead(), presentation.atoms.map((atom) => maskedGrounded(atom.groundedText, atom.text)))
+        : presentation.ruleText;
+    return (_jsxs("div", { children: [_jsx(PanelLabel, { className: "mb-2.5", right: _jsx(Tabs, { size: "small", value: viewMode, onValueChange: (next) => {
+                        const option = ruleViewModeOptions.find((candidate) => candidate.value === next);
+                        if (option)
+                            setViewMode(option.value);
+                    }, children: _jsx(TabsList, { children: ruleViewModeOptions.map((option) => (_jsx(TabsTrigger, { value: option.value, children: option.label }, option.value))) }) }), children: "Produced by rule" }), _jsxs("div", { className: "group relative overflow-hidden rounded-[10px] border border-muted-border bg-card/60", children: [_jsx(Button, { type: "button", variant: "ghost", size: "xs", icon: Copy, iconOnly: true, "aria-label": "Copy rule", className: "absolute right-2 top-2 opacity-0 transition-opacity group-hover:opacity-100", onClick: () => void copyToClipboard(ruleText) }), _jsxs("div", { className: "grid grid-cols-[auto_1fr] items-baseline gap-x-2.5 gap-y-2 border-l-2 border-l-primary bg-primary/7 px-3.5 py-3", children: [_jsx("span", { className: cn(sectionLabelClass, "text-primary"), children: "Derives" }), _jsx(DatalogCode, { code: headText(), className: "min-w-0 typography-small" }), showAllHeadAtoms &&
+                                otherHeadAtoms.map((atom) => (_jsx(DatalogCode, { code: grounded ? maskedGrounded(atom.groundedText, atom.text) : atom.text, className: "col-start-2 min-w-0 typography-small opacity-70" }, atom.text))), isPresent(otherHeadAtoms) && (_jsx("button", { type: "button", onClick: () => setShowAllHeadAtoms(!showAllHeadAtoms), className: "col-start-2 justify-self-start typography-tiny text-muted-foreground underline decoration-dotted underline-offset-2 hover:text-body-foreground", children: showAllHeadAtoms ? "Show less" : `+${otherHeadAtoms.length} more facts` }))] }), _jsxs("div", { className: "flex items-center gap-2 border-y border-muted-border bg-faint px-3.5 py-2", children: [_jsx("span", { className: "font-mono typography-small-semibold text-muted-foreground", children: ":-" }), _jsx("span", { className: cn(sectionLabelClass, "text-muted-foreground"), children: "When every premise below holds" })] }), presentation.atoms.map((atom) => {
+                        const text = atomText(atom);
+                        const isHighlighted = atom.index === highlightedAtomIndex;
+                        const kind = atom.kind;
+                        const isNegation = kind === "negation";
+                        const isBind = kind === "bind";
+                        const role = roleForKind(kind);
+                        return (_jsxs("div", { className: cn("flex items-center gap-2.5 border-l-2 px-3.5 py-2.5 transition-colors", isHighlighted && "border-l-primary bg-primary/12", !isHighlighted && isNegation && "border-l-error-foreground/60", !isHighlighted && !isNegation && "border-l-transparent hover:bg-default-foreground/3", isBind && "border-t border-t-muted-border"), children: [_jsx(NumDot, { number: atom.index + 1, active: isHighlighted }), _jsx(DatalogCode, { code: text, className: "min-w-0 flex-1 typography-small" }), role && _jsx(ExplainTag, { variant: role, className: "ml-auto" })] }, atom.index));
+                    }), !grounded && (_jsx(RuleVariableTypes, { ruleText: presentation.ruleText, className: "border-t border-muted-border bg-faint px-3.5 py-2.5" }))] })] }));
+}

package/dist/rdfox-explain/inspector/SupportsSection.d.ts

@@ -0,0 +1,6 @@
+import type { RuleInstanceView } from "../tree-model.js";
+export type SupportsSectionProps = {
+    supports: RuleInstanceView[];
+};
+export declare function SupportsSection(props: SupportsSectionProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=SupportsSection.d.ts.map

package/dist/rdfox-explain/inspector/SupportsSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SupportsSection.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/inspector/SupportsSection.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGtD,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,kDAgD1D"}

package/dist/rdfox-explain/inspector/SupportsSection.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { nth } from "ramda";
+import { useState } from "react";
+import { datalogTextClass } from "../explain-styles.js";
+import { PanelLabel } from "../PanelLabel.js";
+import { presentRule } from "../rule-presentation.js";
+import { cn } from "#style";
+export function SupportsSection(props) {
+    const { supports } = props;
+    const [activeIndex, setActiveIndex] = useState(0);
+    const active = nth(activeIndex, supports);
+    const presentation = active?.rule ? presentRule(active.rule, active.groundedRule) : undefined;
+    if (!presentation)
+        return null;
+    return (_jsxs(_Fragment, { children: [_jsxs(PanelLabel, { className: "mb-2", right: _jsx("div", { className: "inline-flex gap-1", children: supports.map((support, index) => (_jsx("button", { type: "button", "aria-pressed": index === activeIndex, onClick: () => setActiveIndex(index), className: cn("rounded-sm-v4 border px-2 py-0.5 typography-tiny-semibold", index === activeIndex
+                            ? "border-transparent bg-primary text-primary-foreground"
+                            : "border-default-border text-muted-foreground hover:text-body-foreground"), children: index + 1 }, support.groundedRule ?? support.rule ?? index))) }), children: ["Proven ", supports.length, " independent ways"] }), _jsxs("div", { className: "flex flex-col gap-1 rounded-md border border-muted-border bg-card/60 px-3 py-2.5", children: [_jsx("div", { className: "px-1.5 typography-tiny-medium text-body-foreground", children: presentation.name }), presentation.atoms.map((atom) => (_jsx("span", { className: cn(datalogTextClass, "px-1.5 text-body-foreground"), title: atom.text, children: atom.groundedText }, atom.index)))] })] }));
+}

package/dist/rdfox-explain/inspector/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ExplainInspector.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/rdfox-explain/inspector/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/inspector/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/rdfox-explain/inspector/index.js

@@ -0,0 +1 @@
+export * from "./ExplainInspector.js";

package/dist/rdfox-explain/proof-tree/ProofFactLabel.d.ts

@@ -0,0 +1,6 @@
+import { type NormalizedNode } from "../tree-model.js";
+export type ProofFactLabelProps = {
+    node: NormalizedNode;
+};
+export declare function ProofFactLabel(props: ProofFactLabelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ProofFactLabel.d.ts.map

package/dist/rdfox-explain/proof-tree/ProofFactLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofFactLabel.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/ProofFactLabel.tsx"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAMtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,cAAc,CAAC;CACtB,CAAC;AAEF,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,2CAsBxD"}

package/dist/rdfox-explain/proof-tree/ProofFactLabel.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { datalogTextClass } from "../explain-styles.js";
+import { multipleSupports } from "../tree-model.js";
+import { SupportsTag } from "./SupportsTag.js";
+import { OntologyTermText } from "#ontology/OntologyTermText";
+import { predicateLabel } from "#rules/rule-narrative-format";
+import { cn } from "#style";
+export function ProofFactLabel(props) {
+    const { node } = props;
+    const predicate = node.spo?.predicate;
+    const supports = multipleSupports(node);
+    if (!predicate) {
+        return (_jsx("span", { className: cn(datalogTextClass, "text-body-foreground"), title: node.display, children: node.display }));
+    }
+    return (_jsxs("span", { className: "flex min-w-0 items-baseline gap-2", children: [_jsx("span", { className: "min-w-0 truncate typography-small-medium text-default-foreground first-letter:uppercase", children: _jsx(OntologyTermText, { term: predicate, fallbackLabel: predicateLabel(predicate) }) }), supports && _jsx(SupportsTag, { count: supports.length, className: "self-center" })] }));
+}

package/dist/rdfox-explain/proof-tree/ProofRowBadge.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from "react";
+import { type NormalizedNode } from "../tree-model.js";
+export type ProofRowBadgeProps = {
+    node: NormalizedNode;
+};
+export declare function ProofRowBadge(props: ProofRowBadgeProps): ReactNode;
+//# sourceMappingURL=ProofRowBadge.d.ts.map

package/dist/rdfox-explain/proof-tree/ProofRowBadge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofRowBadge.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/ProofRowBadge.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAEhE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,cAAc,CAAC;CACtB,CAAC;AAEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,SAAS,CASlE"}

package/dist/rdfox-explain/proof-tree/ProofRowBadge.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { match } from "ts-pattern";
+import { ProvenanceBadge } from "../ProvenanceBadge.js";
+import { isTypeFact } from "../tree-model.js";
+export function ProofRowBadge(props) {
+    const { node } = props;
+    return match(node.kind)
+        .with("explicit-fact", () => isTypeFact(node) ? null : _jsx(ProvenanceBadge, { provenance: "explicit", className: "shrink-0" }))
+        .with("derived-fact", "aggregate", "bind", "filter", "negation", "skolem", () => null)
+        .exhaustive();
+}

package/dist/rdfox-explain/proof-tree/ProofRowContent.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+import { type ExplainDisplayMode, type NormalizedNode } from "../tree-model.js";
+export type ProofRowContentProps = {
+    node: NormalizedNode;
+    mode: ExplainDisplayMode;
+};
+export declare function ProofRowContent(props: ProofRowContentProps): ReactNode;
+//# sourceMappingURL=ProofRowContent.d.ts.map

package/dist/rdfox-explain/proof-tree/ProofRowContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofRowContent.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/ProofRowContent.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAOvC,OAAO,EAA0B,KAAK,kBAAkB,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAarG,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,kBAAkB,CAAC;CAC1B,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,SAAS,CAiCtE"}

package/dist/rdfox-explain/proof-tree/ProofRowContent.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { Ban, Check, Fingerprint, Sigma, Variable } from "lucide-react";
+import { match } from "ts-pattern";
+import { DatalogCode } from "../DatalogCode.js";
+import { datalogTextClass } from "../explain-styles.js";
+import { ExplainTag } from "../ExplainTag.js";
+import { FactValue } from "../FactValue.js";
+import { splitComputationTerm } from "../rule-presentation.js";
+import { isFactNode, isTypeFact } from "../tree-model.js";
+import { ProofFactLabel } from "./ProofFactLabel.js";
+import { OntologyTermText } from "#ontology/OntologyTermText";
+import { classLabel, predicateLabel } from "#rules/rule-narrative-format";
+import { RuleNarrativeSegments } from "#rules/RuleNarrativeSegments";
+import { cn } from "#style";
+const filterWrapperPattern = /^FILTER\s*\((.*)\)\s*$/i;
+function stripFilterWrapper(text) {
+    return text.match(filterWrapperPattern)?.[1]?.trim() ?? text;
+}
+export function ProofRowContent(props) {
+    const { node, mode } = props;
+    if (mode === "datalog") {
+        return (_jsx("span", { className: cn(datalogTextClass, isFactNode(node) && !isTypeFact(node) ? "text-body-foreground" : "text-muted-foreground"), title: node.display, children: node.display }));
+    }
+    if (isTypeFact(node)) {
+        return (_jsxs("span", { className: "truncate typography-small italic text-muted-foreground", children: ["is a ", _jsx(OntologyTermText, { term: node.spo?.object ?? node.display })] }));
+    }
+    return match(node.kind)
+        .with("aggregate", () => _jsx(ComputationRowContent, { node: node, icon: Sigma, label: "Aggregate" }))
+        .with("bind", () => _jsx(ComputationRowContent, { node: node, icon: Variable, label: "Bind" }))
+        .with("filter", () => _jsx(FilterRowContent, { node: node }))
+        .with("negation", () => _jsx(NegationRowContent, { node: node }))
+        .with("skolem", () => _jsx(SkolemRowContent, { node: node }))
+        .with("derived-fact", "explicit-fact", () => _jsx(ProofFactLabel, { node: node }))
+        .exhaustive();
+}
+const negationPrefixPattern = /^NOT\s+/i;
+function NegationRowContent(props) {
+    const { node } = props;
+    const negated = node.negatedSpo;
+    const evaluated = node.groundedDisplay ?? node.display;
+    const absentPattern = evaluated.replace(negationPrefixPattern, "");
+    return (_jsxs("span", { className: "flex min-w-0 items-center gap-2", title: evaluated, children: [_jsx(ExplainTag, { variant: "absence", icon: Ban, children: "NOT" }), !negated && (_jsx("span", { className: "min-w-0 truncate", children: _jsx(DatalogCode, { code: absentPattern, className: "typography-small" }) })), negated && negated.predicate === "rdf:type" && (_jsxs("span", { className: "truncate typography-small italic text-muted-foreground", children: ["is a ", _jsx(OntologyTermText, { term: negated.object, fallbackLabel: classLabel(negated.object) })] })), negated && negated.predicate !== "rdf:type" && (_jsxs(_Fragment, { children: [_jsx("span", { className: "min-w-0 truncate typography-small-medium text-default-foreground first-letter:uppercase", children: _jsx(OntologyTermText, { term: negated.predicate ?? "", fallbackLabel: predicateLabel(negated.predicate ?? "") }) }), _jsx(FactValue, { value: negated.object, predicate: negated.predicate, className: "max-w-[50%] shrink-0" })] }))] }));
+}
+function SkolemRowContent(props) {
+    const { node } = props;
+    return (_jsxs("span", { className: "flex min-w-0 items-center gap-2", title: node.display, children: [_jsx(Fingerprint, { "aria-label": "Identifier", className: "size-4 shrink-0 text-muted-foreground" }), node.skolemTerm ? (_jsxs("span", { className: "min-w-0 truncate typography-small", children: [_jsx("span", { className: "text-muted-foreground", children: "Identified as " }), _jsx(OntologyTermText, { term: node.skolemTerm, className: "text-body-foreground" })] })) : (_jsx("span", { className: "min-w-0 truncate", children: _jsx(DatalogCode, { code: node.display, className: "typography-small" }) }))] }));
+}
+function ComputationRowContent(props) {
+    const { node, icon: Icon, label } = props;
+    const outputs = node.aggregateOutputs ?? [];
+    return (_jsxs("span", { className: "flex min-w-0 items-center gap-2", children: [_jsx(Icon, { "aria-label": label, className: "size-4 shrink-0 text-warning-foreground" }), isPresent(outputs) ? (_jsx("span", { className: "flex min-w-0 flex-wrap items-center gap-x-3 gap-y-1", title: node.display, children: outputs.map((output, index) => (_jsxs("span", { className: "min-w-0 typography-small text-body-foreground first-letter:uppercase", children: [_jsx(RuleNarrativeSegments, { variant: "narrative", segments: output.segments }), _jsx("span", { className: "text-placeholder-foreground", children: " = " }), _jsx(FactValue, { value: output.value, className: "max-w-full align-middle" })] }, `${index}:${output.variable}`))) })) : (_jsx("span", { className: "min-w-0 truncate typography-small text-body-foreground", title: node.display, children: node.narrative ? (_jsx(RuleNarrativeSegments, { variant: "narrative", segments: node.narrative })) : (_jsx("span", { className: cn(datalogTextClass, "text-muted-foreground"), children: splitComputationTerm(node.groundedDisplay ?? node.display)?.expression ?? node.display })) }))] }));
+}
+function FilterRowContent(props) {
+    const { node } = props;
+    const evaluated = node.groundedDisplay ?? node.display;
+    return (_jsxs("span", { className: "flex min-w-0 items-center gap-2", children: [_jsx(Check, { "aria-label": "Filter", className: "size-4 shrink-0 text-success-foreground" }), _jsx("span", { className: "min-w-0 truncate typography-small", title: node.display, children: node.narrative ? (_jsx(RuleNarrativeSegments, { variant: "narrative", segments: node.narrative })) : (_jsx(DatalogCode, { code: stripFilterWrapper(evaluated) })) }), node.groundedDisplay && !node.narrative && (_jsx("span", { className: "shrink-0 typography-small text-placeholder-foreground", children: "passes" }))] }));
+}

package/dist/rdfox-explain/proof-tree/ProofRowValue.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+import { type ExplainDisplayMode, type NormalizedNode } from "../tree-model.js";
+export type ProofRowValueProps = {
+    node: NormalizedNode;
+    mode: ExplainDisplayMode;
+    valueHueClassName?: string;
+};
+export declare function ProofRowValue(props: ProofRowValueProps): ReactNode;
+//# sourceMappingURL=ProofRowValue.d.ts.map

package/dist/rdfox-explain/proof-tree/ProofRowValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofRowValue.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/ProofRowValue.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAKvC,OAAO,EAAc,KAAK,kBAAkB,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAGzF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,kBAAkB,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,SAAS,CA+BlE"}

package/dist/rdfox-explain/proof-tree/ProofRowValue.js

@@ -0,0 +1,27 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { match } from "ts-pattern";
+import { factTokenText } from "../fact-token.js";
+import { FactValue } from "../FactValue.js";
+import { splitComputationTerm } from "../rule-presentation.js";
+import { isTypeFact } from "../tree-model.js";
+import { cn } from "#style";
+export function ProofRowValue(props) {
+    const { node, mode, valueHueClassName } = props;
+    if (mode === "datalog")
+        return null;
+    return match(node.kind)
+        .with("aggregate", () => null)
+        .with("bind", () => {
+        const result = splitComputationTerm(node.groundedDisplay ?? "")?.result;
+        if (!result)
+            return null;
+        return (_jsxs("span", { className: "max-w-[50%] shrink-0 truncate font-mono typography-small text-muted-foreground", title: result, children: ["\u2192 ", factTokenText(result)] }));
+    })
+        .with("filter", "negation", "skolem", () => null)
+        .with("derived-fact", "explicit-fact", () => {
+        if (isTypeFact(node) || !node.spo)
+            return null;
+        return (_jsx(FactValue, { value: node.spo.object, predicate: node.spo.predicate, className: cn("max-w-[50%] shrink-0", valueHueClassName) }));
+    })
+        .exhaustive();
+}

package/dist/rdfox-explain/proof-tree/ProofTree.d.ts

@@ -0,0 +1,11 @@
+import type { ExplainDisplayMode, NormalizedTree } from "../tree-model.js";
+export type ProofTreeProps = {
+    tree: NormalizedTree;
+    mode?: ExplainDisplayMode;
+    selectable?: boolean;
+    selectedNodeId?: string;
+    onSelect?: (id: string) => void;
+    className?: string;
+};
+export declare function ProofTree(props: ProofTreeProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=ProofTree.d.ts.map

package/dist/rdfox-explain/proof-tree/ProofTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofTree.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/ProofTree.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AASxE,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,kDAkG9C"}

package/dist/rdfox-explain/proof-tree/ProofTree.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { formulaHueClass } from "../formula-hues.js";
+import { getProofTreeNavigationTarget } from "./proof-tree-navigation.js";
+import { proofTreeRootView } from "./proof-tree-root-view.js";
+import { ProofTreeFormulaFooter } from "./ProofTreeFormulaFooter.js";
+import { ProofTreeNode } from "./ProofTreeNode.js";
+import { cn } from "#style";
+const navigationKeys = ["ArrowDown", "ArrowUp", "ArrowLeft", "ArrowRight", "Home", "End"];
+export function ProofTree(props) {
+    const { tree, mode = "labels", selectable = false, selectedNodeId = "", onSelect, className } = props;
+    const [expandedNodeIds, setExpandedNodeIds] = useState(new Set());
+    useEffect(() => {
+        setExpandedNodeIds(new Set());
+    }, [tree]);
+    const { formula, formulaNodeId, visibleChildren, hasPremises } = proofTreeRootView(tree);
+    const nodeCount = Object.keys(tree.byId).length;
+    const valueHueClassByNodeId = useMemo(() => {
+        const hueByNodeId = new Map();
+        formula?.inputs.forEach((input, inputIndex) => {
+            if (input.atomIndex === undefined)
+                return;
+            const childId = tree.root.childIds.find((candidate) => tree.byId[candidate]?.bodyIndex === input.atomIndex);
+            if (childId)
+                hueByNodeId.set(childId, formulaHueClass(inputIndex));
+        });
+        return hueByNodeId;
+    }, [tree, formula]);
+    function handleToggle(nodeId) {
+        setExpandedNodeIds((current) => {
+            const next = new Set(current);
+            if (next.has(nodeId)) {
+                next.delete(nodeId);
+            }
+            else {
+                next.add(nodeId);
+            }
+            return next;
+        });
+    }
+    function handleKeyDown(event) {
+        if (!navigationKeys.includes(event.key))
+            return;
+        event.preventDefault();
+        const result = getProofTreeNavigationTarget({
+            tree,
+            selectedNodeId,
+            expandedNodeIds,
+            key: event.key,
+            hiddenNodeId: formulaNodeId,
+        });
+        setExpandedNodeIds(result.expandedNodeIds);
+        if (result.selectedNodeId !== selectedNodeId) {
+            onSelect?.(result.selectedNodeId);
+        }
+    }
+    if (!hasPremises)
+        return null;
+    return (_jsxs("div", { role: "tree", tabIndex: 0, "aria-label": `RDFox proof tree with ${nodeCount} nodes`, className: cn("overflow-hidden rounded-md border border-muted-border bg-card/60 outline-none", className), onKeyDown: selectable ? handleKeyDown : undefined, children: [_jsx("div", { className: "-mt-px", children: visibleChildren.map((child) => (_jsx(ProofTreeNode, { tree: tree, node: child, depth: 0, mode: mode, selectable: selectable, selectedNodeId: selectedNodeId, expandedNodeIds: expandedNodeIds, onSelect: onSelect, onToggle: handleToggle, valueHueClassName: valueHueClassByNodeId.get(child.id) }, child.id))) }), formula && (_jsx(ProofTreeFormulaFooter, { formula: formula, mode: mode, rawText: formulaNodeId ? tree.byId[formulaNodeId]?.display : undefined }))] }));
+}

package/dist/rdfox-explain/proof-tree/ProofTreeFormulaFooter.d.ts

@@ -0,0 +1,9 @@
+import type { BindFormulaPresentation } from "../rule-presentation.js";
+import type { ExplainDisplayMode } from "../tree-model.js";
+export type ProofTreeFormulaFooterProps = {
+    formula: BindFormulaPresentation;
+    mode: ExplainDisplayMode;
+    rawText?: string;
+};
+export declare function ProofTreeFormulaFooter(props: ProofTreeFormulaFooterProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ProofTreeFormulaFooter.d.ts.map

package/dist/rdfox-explain/proof-tree/ProofTreeFormulaFooter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofTreeFormulaFooter.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/ProofTreeFormulaFooter.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAMxD,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,uBAAuB,CAAC;IACjC,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,2BAA2B,2CAgBxE"}

package/dist/rdfox-explain/proof-tree/ProofTreeFormulaFooter.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { datalogTextClass } from "../explain-styles.js";
+import { factTokenText } from "../fact-token.js";
+import { formulaHueClass } from "../formula-hues.js";
+import { ValuePill } from "../ValuePill.js";
+import { cn } from "#style";
+const variableTokenPattern = /(\?\w+)/;
+export function ProofTreeFormulaFooter(props) {
+    const { formula, mode, rawText } = props;
+    return (_jsx("div", { className: "flex items-center gap-3 border-t border-muted-border bg-faint px-3.5 py-4", children: _jsx("span", { className: "flex min-w-0 items-center gap-2.5", children: mode === "datalog" ? (_jsx("span", { className: cn(datalogTextClass, "text-body-foreground"), title: rawText, children: rawText ?? formula.expression })) : (_jsx(FormulaExpression, { formula: formula })) }) }));
+}
+function FormulaExpression(props) {
+    const { formula } = props;
+    const inputIndexByVariable = new Map(formula.inputs.map((input, index) => [input.variable, index]));
+    const tokens = formula.expression.split(variableTokenPattern).map((token, position) => {
+        const inputIndex = inputIndexByVariable.get(token);
+        const input = inputIndex !== undefined ? formula.inputs[inputIndex] : undefined;
+        if (input?.value !== undefined && inputIndex !== undefined) {
+            return (_jsx(ValuePill, { className: formulaHueClass(inputIndex), children: factTokenText(input.value) }, `${token}-${position}`));
+        }
+        return (_jsx("span", { className: "text-muted-foreground", children: token }, `${token}-${position}`));
+    });
+    return (_jsxs("span", { className: "flex min-w-0 flex-wrap items-center gap-1.5 font-mono typography-small", children: [tokens, _jsx("span", { className: "text-muted-foreground", children: "=" }), _jsx("span", { className: "typography-small-semibold text-default-foreground", children: factTokenText(formula.result) })] }));
+}

package/dist/rdfox-explain/proof-tree/ProofTreeNode.d.ts

@@ -0,0 +1,15 @@
+import { type ExplainDisplayMode, type NormalizedNode, type NormalizedTree } from "../tree-model.js";
+export type ProofTreeNodeProps = {
+    tree: NormalizedTree;
+    node: NormalizedNode;
+    depth: number;
+    mode: ExplainDisplayMode;
+    selectable: boolean;
+    selectedNodeId: string;
+    expandedNodeIds: Set<string>;
+    onSelect?: (id: string) => void;
+    onToggle: (id: string) => void;
+    valueHueClassName?: string;
+};
+export declare function ProofTreeNode(props: ProofTreeNodeProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ProofTreeNode.d.ts.map

package/dist/rdfox-explain/proof-tree/ProofTreeNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofTreeNode.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/ProofTreeNode.tsx"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AAOvB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,kBAAkB,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,2CA+EtD"}

package/dist/rdfox-explain/proof-tree/ProofTreeNode.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { ChevronDown, ChevronRight } from "lucide-react";
+import { selectionHighlightClass } from "../explain-styles.js";
+import { isFactNode, isTypeFact, } from "../tree-model.js";
+import { ProofRowBadge } from "./ProofRowBadge.js";
+import { ProofRowContent } from "./ProofRowContent.js";
+import { ProofRowValue } from "./ProofRowValue.js";
+import { visiblePremiseChildren } from "./visible-premises.js";
+import { cn } from "#style";
+export function ProofTreeNode(props) {
+    const { tree, node, depth, mode, selectable, selectedNodeId, expandedNodeIds, onSelect, onToggle, valueHueClassName, } = props;
+    const hasChildren = isPresent(node.childIds);
+    const isExpanded = expandedNodeIds.has(node.id);
+    const isSelectable = selectable && isFactNode(node) && onSelect !== undefined;
+    const isSelected = selectable && selectedNodeId === node.id;
+    const isCompactRow = !isFactNode(node) || isTypeFact(node);
+    const ChevronIcon = isExpanded ? ChevronDown : ChevronRight;
+    return (_jsxs("div", { role: "none", "data-depth": depth, children: [_jsxs("div", { role: "treeitem", "aria-selected": isSelected, "aria-expanded": hasChildren ? isExpanded : undefined, "data-node-id": node.id, className: cn("flex items-center gap-2.5 border-l-2 border-l-transparent border-t border-muted-border pr-3.5 transition-colors", isSelected && selectionHighlightClass, isSelectable && "cursor-pointer", isSelectable && !isSelected && "hover:bg-muted/60"), style: { paddingLeft: `${depth * 24 + 14}px` }, onClick: isSelectable ? () => onSelect(node.id) : undefined, children: [_jsxs("div", { className: cn("flex min-w-0 flex-1 items-center gap-2", isCompactRow ? "py-3" : "py-4"), children: [_jsx("button", { type: "button", className: cn("flex size-5 shrink-0 items-center justify-center rounded-sm-v4 text-muted-foreground", hasChildren ? "hover:bg-background/80" : "pointer-events-none opacity-0"), "aria-label": isExpanded ? "Collapse proof node" : "Expand proof node", tabIndex: hasChildren ? 0 : -1, onClick: (event) => {
+                                    event.stopPropagation();
+                                    onToggle(node.id);
+                                }, children: _jsx(ChevronIcon, { className: "size-4" }) }), _jsx(ProofRowContent, { node: node, mode: mode })] }), _jsx(ProofRowValue, { node: node, mode: mode, valueHueClassName: valueHueClassName }), _jsx(ProofRowBadge, { node: node })] }), hasChildren && isExpanded && (_jsx("div", { role: "group", children: visiblePremiseChildren(tree, node).map((child) => (_jsx(ProofTreeNode, { tree: tree, node: child, depth: depth + 1, mode: mode, selectable: selectable, selectedNodeId: selectedNodeId, expandedNodeIds: expandedNodeIds, onSelect: onSelect, onToggle: onToggle }, child.id))) }))] }));
+}

package/dist/rdfox-explain/proof-tree/SupportsTag.d.ts

@@ -0,0 +1,6 @@
+export type SupportsTagProps = {
+    count: number;
+    className?: string;
+};
+export declare function SupportsTag(props: SupportsTagProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SupportsTag.d.ts.map

package/dist/rdfox-explain/proof-tree/SupportsTag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SupportsTag.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/SupportsTag.tsx"],"names":[],"mappings":"AAEA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,2CAYlD"}

package/dist/rdfox-explain/proof-tree/SupportsTag.js

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { ExplainTag } from "../ExplainTag.js";
+export function SupportsTag(props) {
+    const { count, className } = props;
+    return (_jsxs(ExplainTag, { variant: "success", title: `RDFox holds ${count} independent derivations of this fact. It survives deletion of any one of them.`, className: className, children: [count, " ways"] }));
+}

package/dist/rdfox-explain/proof-tree/index.d.ts

@@ -0,0 +1,3 @@
+export { hasVisiblePremises } from "./proof-tree-root-view.js";
+export * from "./ProofTree.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/rdfox-explain/proof-tree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,cAAc,aAAa,CAAC"}

package/dist/rdfox-explain/proof-tree/index.js

@@ -0,0 +1,2 @@
+export { hasVisiblePremises } from "./proof-tree-root-view.js";
+export * from "./ProofTree.js";

package/dist/rdfox-explain/proof-tree/proof-tree-navigation.d.ts

@@ -0,0 +1,15 @@
+import type { NormalizedTree } from "../tree-model.js";
+export type ProofTreeNavigationArgs = {
+    tree: NormalizedTree;
+    selectedNodeId: string;
+    expandedNodeIds: Set<string>;
+    key: string;
+    hiddenNodeId?: string;
+};
+export type ProofTreeNavigationResult = {
+    selectedNodeId: string;
+    expandedNodeIds: Set<string>;
+};
+export declare function getProofTreeNavigationTarget(args: ProofTreeNavigationArgs): ProofTreeNavigationResult;
+export declare function getVisibleNodeIds(tree: NormalizedTree, expandedNodeIds: Set<string>, hiddenNodeId?: string): string[];
+//# sourceMappingURL=proof-tree-navigation.d.ts.map

package/dist/rdfox-explain/proof-tree/proof-tree-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-tree-navigation.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/proof-tree-navigation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpE,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC9B,CAAC;AAUF,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,uBAAuB,GAAG,yBAAyB,CA+BrG;AAqDD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBrH"}

package/dist/rdfox-explain/proof-tree/proof-tree-navigation.js

@@ -0,0 +1,80 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { match } from "ts-pattern";
+import { visiblePremiseChildren } from "./visible-premises.js";
+export function getProofTreeNavigationTarget(args) {
+    const { tree, selectedNodeId, expandedNodeIds, key, hiddenNodeId } = args;
+    const nextExpandedNodeIds = new Set(expandedNodeIds);
+    const visibleNodeIds = getVisibleNodeIds(tree, nextExpandedNodeIds, hiddenNodeId);
+    const fallbackNodeId = visibleNodeIds[0] ?? tree.root.id;
+    const selectedNode = tree.byId[selectedNodeId];
+    if (!selectedNode || !visibleNodeIds.includes(selectedNode.id)) {
+        return { selectedNodeId: fallbackNodeId, expandedNodeIds: nextExpandedNodeIds };
+    }
+    const context = {
+        tree,
+        selectedNode,
+        visibleNodeIds,
+        expandedNodeIds: nextExpandedNodeIds,
+        fallbackNodeId,
+    };
+    return match(key)
+        .with("ArrowRight", () => navigateRight(context))
+        .with("ArrowLeft", () => navigateLeft(context))
+        .with("ArrowDown", () => navigateVertically(context, 1))
+        .with("ArrowUp", () => navigateVertically(context, -1))
+        .with("Home", () => ({ selectedNodeId: fallbackNodeId, expandedNodeIds: nextExpandedNodeIds }))
+        .with("End", () => ({
+        selectedNodeId: visibleNodeIds[visibleNodeIds.length - 1] ?? selectedNode.id,
+        expandedNodeIds: nextExpandedNodeIds,
+    }))
+        .otherwise(() => keepSelection(context));
+}
+function keepSelection(context) {
+    return { selectedNodeId: context.selectedNode.id, expandedNodeIds: context.expandedNodeIds };
+}
+function navigateRight(context) {
+    const { selectedNode, visibleNodeIds, expandedNodeIds } = context;
+    if (isPresent(selectedNode.childIds) && !expandedNodeIds.has(selectedNode.id)) {
+        expandedNodeIds.add(selectedNode.id);
+        return { selectedNodeId: selectedNode.id, expandedNodeIds };
+    }
+    const firstVisibleChildId = selectedNode.childIds.find((id) => visibleNodeIds.includes(id));
+    if (firstVisibleChildId && expandedNodeIds.has(selectedNode.id)) {
+        return { selectedNodeId: firstVisibleChildId, expandedNodeIds };
+    }
+    return keepSelection(context);
+}
+function navigateLeft(context) {
+    const { tree, selectedNode, expandedNodeIds } = context;
+    if (isPresent(selectedNode.childIds) && expandedNodeIds.has(selectedNode.id)) {
+        expandedNodeIds.delete(selectedNode.id);
+        return { selectedNodeId: selectedNode.id, expandedNodeIds };
+    }
+    if (selectedNode.parentId && selectedNode.parentId !== tree.root.id) {
+        return { selectedNodeId: selectedNode.parentId, expandedNodeIds };
+    }
+    return keepSelection(context);
+}
+function navigateVertically(context, step) {
+    const { selectedNode, visibleNodeIds, expandedNodeIds } = context;
+    const selectedIndex = visibleNodeIds.indexOf(selectedNode.id);
+    if (selectedIndex < 0)
+        return keepSelection(context);
+    const targetIndex = step === 1 ? Math.min(visibleNodeIds.length - 1, selectedIndex + 1) : Math.max(0, selectedIndex - 1);
+    return { selectedNodeId: visibleNodeIds[targetIndex] ?? selectedNode.id, expandedNodeIds };
+}
+export function getVisibleNodeIds(tree, expandedNodeIds, hiddenNodeId) {
+    const result = [];
+    function visit(node) {
+        result.push(node.id);
+        if (!expandedNodeIds.has(node.id))
+            return;
+        for (const child of visiblePremiseChildren(tree, node)) {
+            visit(child);
+        }
+    }
+    for (const child of visiblePremiseChildren(tree, tree.root, hiddenNodeId)) {
+        visit(child);
+    }
+    return result;
+}