@manta-eu/react 0.1.0

package/dist/routes/rules/components/rule-value-edit.d.ts

@@ -0,0 +1,13 @@
+import { type SourceSpan } from "@manta-eu/datalog-parser";
+import { type RuleSetupModel } from "#ldo-ui";
+export type BuildResult = {
+    changed: boolean;
+    ruleText: string;
+    fieldErrors: Readonly<Record<string, string>>;
+    error: string | null;
+};
+export declare function dateTimeValueForInput(value: string): string;
+export declare function dateTimeValueFromInput(value: string): string;
+export declare function buildUpdatedRuleText(model: RuleSetupModel, values: Readonly<Record<string, string>>): BuildResult;
+export declare function spliceRuleValue(ruleText: string, span: SourceSpan, newValue: string): string;
+//# sourceMappingURL=rule-value-edit.d.ts.map

package/dist/routes/rules/components/rule-value-edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-value-edit.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/rule-value-edit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,KAAK,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAIhG,OAAO,EAAsD,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAqBlG,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAOF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI5D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,WAAW,CA2CjH;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5F"}

package/dist/routes/rules/components/rule-value-edit.js

@@ -0,0 +1,90 @@
+import { isNumericRdfValue, parseDatalogRule } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { isMatch } from "date-fns";
+import { z } from "zod";
+const requiredValueSchema = z.string().min(1, "Values cannot be empty.");
+const minutePrecisionDateTimeFormat = "yyyy-MM-dd'T'HH:mm";
+const numberSchema = requiredValueSchema.pipe(z.stringFormat("datalog-number", isNumericRdfValue, {
+    error: "Enter a valid number such as 1, 1.5, or 1e3.",
+}));
+const editableValueSchemas = {
+    number: numberSchema,
+    date: requiredValueSchema.pipe(z.iso.date({ error: "Enter a valid date in YYYY-MM-DD format." })),
+    dateTime: requiredValueSchema.pipe(z.iso.datetime({
+        precision: 0,
+        error: "Enter a UTC date/time such as 2025-01-01T12:30:00Z.",
+    })),
+};
+export function dateTimeValueForInput(value) {
+    return value.endsWith("Z") ? value.slice(0, -1) : value;
+}
+export function dateTimeValueFromInput(value) {
+    if (!value)
+        return "";
+    const withSeconds = isMatch(value, minutePrecisionDateTimeFormat) ? `${value}:00` : value;
+    return `${withSeconds}Z`;
+}
+export function buildUpdatedRuleText(model, values) {
+    const edits = model.editableValues.flatMap(({ edit: editableValue }) => {
+        const rawValue = values[editableValue.id];
+        if (rawValue === undefined)
+            return [];
+        const value = rawValue.trim();
+        if (value === editableValue.value)
+            return [];
+        return [{ editableValue, value }];
+    });
+    const ruleText = model.ast.raw;
+    if (!isPresent(edits))
+        return { changed: false, ruleText, fieldErrors: {}, error: null };
+    const fieldErrors = validateEdits(edits);
+    if (isPresent(Object.keys(fieldErrors))) {
+        return { changed: true, ruleText, fieldErrors, error: null };
+    }
+    const spanError = validateReplacementSpans(ruleText, edits);
+    if (spanError) {
+        return { changed: true, ruleText, fieldErrors: {}, error: spanError };
+    }
+    try {
+        const updatedRuleText = edits
+            .slice()
+            .sort((a, b) => b.editableValue.replacementSpan.start - a.editableValue.replacementSpan.start)
+            .reduce((currentRuleText, edit) => spliceRuleValue(currentRuleText, edit.editableValue.replacementSpan, edit.value), ruleText);
+        parseDatalogRule(updatedRuleText);
+        return { changed: true, ruleText: updatedRuleText, fieldErrors: {}, error: null };
+    }
+    catch (err) {
+        return {
+            changed: true,
+            ruleText,
+            fieldErrors: {},
+            error: err instanceof Error ? err.message : "The updated rule could not be parsed.",
+        };
+    }
+}
+export function spliceRuleValue(ruleText, span, newValue) {
+    return `${ruleText.slice(0, span.start)}${newValue}${ruleText.slice(span.end)}`;
+}
+function validateEdits(edits) {
+    const fieldErrors = {};
+    for (const edit of edits) {
+        const result = editableValueSchemas[edit.editableValue.kind].safeParse(edit.value);
+        if (!result.success) {
+            fieldErrors[edit.editableValue.id] = result.error.issues[0]?.message ?? "Invalid value.";
+        }
+    }
+    return fieldErrors;
+}
+function validateReplacementSpans(ruleText, edits) {
+    const spans = edits.map((edit) => edit.editableValue.replacementSpan).sort((a, b) => a.start - b.start);
+    for (const [index, span] of spans.entries()) {
+        if (span.start < 0 || span.end < span.start || span.end > ruleText.length) {
+            return `Invalid source span ${span.start}:${span.end}.`;
+        }
+        const previous = spans[index - 1];
+        if (previous && span.start < previous.end) {
+            return "Edited values have overlapping source spans.";
+        }
+    }
+    return null;
+}

package/dist/routes/rules/components/rules.utils.d.ts

@@ -0,0 +1,24 @@
+import type { GQLRule } from "@manta-eu/client";
+import type { Awaitable } from "@manta-eu/lib/types";
+import type { RuleActionabilityAnalysis } from "./rule-actionability.js";
+export type ActionabilityFilter = "all" | "automatic" | "manual";
+export type RuleActionabilityMap = ReadonlyMap<string, RuleActionabilityAnalysis>;
+export type RuleStatus = "committed" | "new" | "modified" | "deleted";
+export type RuleHandlers = {
+    onEditRule?: (ruleIri: string, newRule: string) => Awaitable<boolean>;
+    onDeleteRule?: (rule: GQLRule) => Awaitable<boolean>;
+    onReleaseOwnership?: (rule: GQLRule) => Awaitable<void>;
+};
+export declare function getRuleDisplayText(rule: Pick<GQLRule, "stagedRule" | "committedRule">): string;
+export declare function getRulePreview(rule: GQLRule): string;
+export declare function sortRulesForDisplay(rules: readonly GQLRule[]): GQLRule[];
+export declare function getRuleDisplayName(ruleIri: string): string;
+export declare function getRuleRouteName(ruleIri: string): string;
+export declare function decodeRuleRouteName(ruleName: string): string;
+export declare function getRuleHref(rule: Pick<GQLRule, "ruleIri">): string;
+export declare function getExternalDependentRuleIris(rule: Pick<GQLRule, "ruleIri" | "dependentRules">): string[];
+export declare function getRuleOwnerName(rule: GQLRule, ownerNameByUserId?: ReadonlyMap<string, string>): string | null;
+export declare function getRuleStatus(rule: Pick<GQLRule, "isStaged" | "isModified" | "committedRule" | "stagedRule">): RuleStatus;
+export declare function filterRulesByQuery(rules: GQLRule[], query: string): GQLRule[];
+export declare function filterRulesByActionability(rules: GQLRule[], actionabilityByRuleIri: RuleActionabilityMap, filter: ActionabilityFilter): GQLRule[];
+//# sourceMappingURL=rules.utils.d.ts.map

package/dist/routes/rules/components/rules.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.utils.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/rules.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAIhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEjE,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;AAElF,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,KAAK,GAAG,UAAU,GAAG,SAAS,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,SAAS,CAAC,OAAO,CAAC,CAAC;IACtE,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,SAAS,CAAC,OAAO,CAAC,CAAC;IACrD,kBAAkB,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,SAAS,CAAC,IAAI,CAAC,CAAC;CACzD,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,eAAe,CAAC,GAAG,MAAM,CAE9F;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,CASxE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAI1D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM5D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,MAAM,CAElE;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,gBAAgB,CAAC,GAAG,MAAM,EAAE,CAIxG;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAG9G;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,YAAY,GAAG,eAAe,GAAG,YAAY,CAAC,GAC9E,UAAU,CAaZ;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,CAiB7E;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,EAAE,EAChB,sBAAsB,EAAE,oBAAoB,EAC5C,MAAM,EAAE,mBAAmB,GAC1B,OAAO,EAAE,CAOX"}

package/dist/routes/rules/components/rules.utils.js

@@ -0,0 +1,83 @@
+import { humanizeEntityName } from "@manta-eu/client/shared/agent-mode";
+import { formatEntityName } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { ascend, descend, sortWith } from "ramda";
+import { match } from "ts-pattern";
+export function getRuleDisplayText(rule) {
+    return rule.stagedRule || rule.committedRule || "";
+}
+export function getRulePreview(rule) {
+    return getRuleDisplayText(rule).replace(/\s+/g, " ").trim();
+}
+export function sortRulesForDisplay(rules) {
+    return sortWith([
+        descend((rule) => rule.stratumIndex ?? -1),
+        ascend((rule) => rule.component ?? ""),
+        ascend((rule) => getRuleDisplayName(rule.ruleIri)),
+    ], rules);
+}
+export function getRuleDisplayName(ruleIri) {
+    const localName = formatEntityName(ruleIri);
+    const nameWithoutRulePrefix = localName.replace(/^Rule_/, "").replace(/^Rule(?=[A-Z0-9])/, "");
+    return humanizeEntityName(nameWithoutRulePrefix) || localName;
+}
+export function getRuleRouteName(ruleIri) {
+    return formatEntityName(ruleIri);
+}
+export function decodeRuleRouteName(ruleName) {
+    try {
+        return decodeURIComponent(ruleName);
+    }
+    catch {
+        return ruleName;
+    }
+}
+export function getRuleHref(rule) {
+    return `/rules/${encodeURIComponent(getRuleRouteName(rule.ruleIri))}`;
+}
+export function getExternalDependentRuleIris(rule) {
+    return [...new Set(rule.dependentRules)]
+        .filter((dependentRuleIri) => dependentRuleIri !== rule.ruleIri)
+        .sort((left, right) => getRuleDisplayName(left).localeCompare(getRuleDisplayName(right)));
+}
+export function getRuleOwnerName(rule, ownerNameByUserId) {
+    const userId = rule.ownedBy?.userId;
+    return userId ? (ownerNameByUserId?.get(userId) ?? null) : null;
+}
+export function getRuleStatus(rule) {
+    return match({
+        isStaged: rule.isStaged,
+        isModified: rule.isModified,
+        hasCommittedRule: isPresent(rule.committedRule),
+        hasStagedRule: isPresent(rule.stagedRule),
+    })
+        .returnType()
+        .with({ isStaged: false, hasCommittedRule: true }, () => "committed")
+        .with({ isStaged: true, hasCommittedRule: true, hasStagedRule: false }, () => "deleted")
+        .with({ isStaged: true, isModified: true }, () => "modified")
+        .with({ isStaged: true, hasCommittedRule: false }, () => "new")
+        .otherwise(() => "new");
+}
+export function filterRulesByQuery(rules, query) {
+    if (!query.trim())
+        return rules;
+    const normalizedQuery = query.toLowerCase();
+    return rules.filter((rule) => {
+        const ruleText = getRuleDisplayText(rule).toLowerCase();
+        const iri = rule.ruleIri.toLowerCase();
+        const name = getRuleDisplayName(rule.ruleIri).toLowerCase();
+        const owner = rule.ownedBy?.userId?.toLowerCase() || "";
+        return (ruleText.includes(normalizedQuery) ||
+            iri.includes(normalizedQuery) ||
+            name.includes(normalizedQuery) ||
+            owner.includes(normalizedQuery));
+    });
+}
+export function filterRulesByActionability(rules, actionabilityByRuleIri, filter) {
+    if (filter === "all")
+        return rules;
+    return rules.filter((rule) => {
+        const isManualActioning = actionabilityByRuleIri.get(rule.ruleIri)?.isManualActioning ?? false;
+        return filter === "automatic" ? !isManualActioning : isManualActioning;
+    });
+}

package/dist/rules/DatalogAst.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentProps } from "react";
+export type DatalogAstProps = ComponentProps<"div"> & {
+    rule: string;
+};
+export declare const DatalogAst: import("react").ForwardRefExoticComponent<Omit<DatalogAstProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=DatalogAst.d.ts.map

package/dist/rules/DatalogAst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatalogAst.d.ts","sourceRoot":"","sources":["../../src/rules/DatalogAst.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAa5C,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG;IACpD,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,UAAU,yHA4ErB,CAAC"}

package/dist/rules/DatalogAst.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { forwardRef, useCallback, useMemo, useState } from "react";
+import { DatalogAtomComponent, DatalogBodyFormulaComponent, extractVariables, assignVariableColors, getRelatedVariables, } from "./datalog-ast/index.js";
+import { parseDatalogRuleCached } from "./datalog-cache.js";
+import { cn } from "#style";
+export const DatalogAst = forwardRef(function DatalogAst(props, ref) {
+    const { rule, className, ...restProps } = props;
+    const [hoverState, setHoverState] = useState({
+        hoveredVar: null,
+        relatedVars: new Set(),
+    });
+    const { ast, error: parseError } = useMemo(() => parseDatalogRuleCached(rule), [rule]);
+    const variableColors = useMemo(() => {
+        if (!ast)
+            return {};
+        return assignVariableColors(extractVariables(ast));
+    }, [ast]);
+    const handleVariableHover = useCallback((varName) => {
+        if (!ast)
+            return;
+        if (varName) {
+            const relatedVars = getRelatedVariables(ast, varName);
+            setHoverState({ hoveredVar: varName, relatedVars });
+        }
+        else {
+            setHoverState({ hoveredVar: null, relatedVars: new Set() });
+        }
+    }, [ast]);
+    if (parseError) {
+        return (_jsx("div", { ref: ref, className: cn("rounded-md border border-error-border p-4", className), ...restProps, children: _jsx("div", { className: "font-mono typography-small text-error-foreground", children: parseError }) }));
+    }
+    if (!ast) {
+        return null;
+    }
+    return (_jsxs("div", { ref: ref, className: cn("space-y-6", className), ...restProps, children: [_jsxs("div", { children: [_jsx("h3", { className: "typography-small mb-3 text-muted-foreground", children: "Head" }), _jsx("div", { className: "space-y-3", children: ast.head.map((atom, index) => (_jsx(DatalogAtomComponent, { atom: atom, variableColors: variableColors, hoverState: hoverState, onVariableHover: handleVariableHover }, index))) })] }), isPresent(ast.body) && (_jsxs("div", { children: [_jsx("h3", { className: "typography-small mb-3 text-muted-foreground", children: "Body" }), _jsx("div", { className: "space-y-3", children: ast.body.map((formula, index) => (_jsx(DatalogBodyFormulaComponent, { formula: formula, variableColors: variableColors, hoverState: hoverState, onVariableHover: handleVariableHover }, index))) })] }))] }));
+});

package/dist/rules/RuleNarrative.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentProps } from "react";
+import { type RuleSetupModel } from "./rule-narrative.js";
+import { type RenderTermProducers } from "./RuleNarrativeSegments.js";
+export type RuleNarrativeProps = ComponentProps<"div"> & {
+    model: RuleSetupModel;
+    colorVariables?: boolean;
+    renderTermProducers?: RenderTermProducers;
+};
+export declare function RuleNarrative(props: RuleNarrativeProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RuleNarrative.d.ts.map

package/dist/rules/RuleNarrative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleNarrative.d.ts","sourceRoot":"","sources":["../../src/rules/RuleNarrative.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAG5C,OAAO,EAAwC,KAAK,cAAc,EAA2B,MAAM,kBAAkB,CAAC;AACtH,OAAO,EAAyB,KAAK,mBAAmB,EAA2B,MAAM,yBAAyB,CAAC;AAGnH,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG;IACvD,KAAK,EAAE,cAAc,CAAC;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C,CAAC;AAOF,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,2CA2CtD"}

package/dist/rules/RuleNarrative.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { extractVariables, getRelatedVariables } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { assignVariableColors } from "./datalog-ast/utils.js";
+import { RuleNarrativeSegments } from "./RuleNarrativeSegments.js";
+import { cn } from "#style";
+const emptyVariableFocus = {
+    activeVariable: null,
+    relatedVariables: new Set(),
+};
+export function RuleNarrative(props) {
+    const { model, colorVariables = true, renderTermProducers, className, ...restProps } = props;
+    const { ast, rows } = model;
+    const [variableFocus, setVariableFocus] = useState(emptyVariableFocus);
+    const variableColors = useMemo(() => {
+        if (!colorVariables)
+            return {};
+        return assignVariableColors(extractVariables(ast));
+    }, [ast, colorVariables]);
+    useEffect(() => setVariableFocus(emptyVariableFocus), [ast]);
+    const handleVariableFocus = useCallback((variableName) => {
+        if (!variableName) {
+            setVariableFocus(emptyVariableFocus);
+            return;
+        }
+        setVariableFocus({
+            activeVariable: variableName,
+            relatedVariables: getRelatedVariables(ast, variableName),
+        });
+    }, [ast]);
+    return (_jsx("div", { className: cn(className), ...restProps, children: rows.map((row, index) => (_jsx(NarrativeRowView, { row: row, isLast: index === rows.length - 1, colorVariables: colorVariables, variableColors: variableColors, variableFocus: variableFocus, onVariableFocus: handleVariableFocus, renderTermProducers: renderTermProducers }, index))) }));
+}
+const tagClassNames = {
+    IF: "border-primary/50 text-primary",
+    AND: "border-muted-border text-muted-foreground",
+    DO: "border-success-foreground/60 text-success-foreground",
+};
+function NarrativeRowView(props) {
+    const { row, isLast, colorVariables, variableColors, variableFocus, onVariableFocus, renderTermProducers } = props;
+    return (_jsxs("div", { className: cn("flex items-start gap-3 py-3", !isLast && "border-b border-muted-border"), children: [_jsx("div", { className: cn("flex size-8 shrink-0 items-center justify-center rounded-full border typography-caption-small tracking-wide", tagClassNames[row.tag], row.muted && "opacity-80"), children: row.tag }), _jsx("div", { className: "min-w-0 flex-1 pt-1.5", children: _jsx(NarrativeRowContent, { row: row, colorVariables: colorVariables, variableColors: variableColors, variableFocus: variableFocus, onVariableFocus: onVariableFocus, renderTermProducers: row.tag === "DO" ? undefined : renderTermProducers }) })] }));
+}
+function NarrativeRowContent(props) {
+    const { row, colorVariables, variableColors, variableFocus, onVariableFocus, renderTermProducers } = props;
+    return (_jsxs("div", { className: cn("typography-small leading-6", row.muted ? "text-muted-foreground" : "text-default-foreground"), children: [_jsx(RuleNarrativeSegments, { variant: "narrative", segments: row.segments, colorVariables: colorVariables, variableColors: variableColors, variableFocus: variableFocus, onVariableFocus: onVariableFocus, renderTermProducers: renderTermProducers }), isPresent(row.children) && (_jsx("div", { className: "mt-1.5 flex flex-col gap-1.5 border-l-2 border-muted-border pl-3", children: row.children.map((child, index) => (_jsx(NarrativeRowContent, { row: child, colorVariables: colorVariables, variableColors: variableColors, variableFocus: variableFocus, onVariableFocus: onVariableFocus, renderTermProducers: renderTermProducers }, index))) }))] }));
+}

package/dist/rules/RuleNarrativeSegments.d.ts

@@ -0,0 +1,24 @@
+import type { DatalogTerm } from "@manta-eu/datalog-parser";
+import type { ReactNode } from "react";
+import type { NarrativeSegment } from "./rule-narrative.js";
+export type VariableFocusState = {
+    activeVariable: string | null;
+    relatedVariables: ReadonlySet<string>;
+};
+export type RenderTermProducers = (term: string, graph: DatalogTerm | undefined) => ReactNode;
+export type RuleNarrativeSegmentsBaseProps = {
+    segments: readonly NarrativeSegment[];
+};
+export type RuleNarrativeSegmentsProps = (RuleNarrativeSegmentsBaseProps & {
+    variant: "narrative";
+    colorVariables?: boolean;
+    variableColors?: Readonly<Record<string, string>>;
+    variableFocus?: VariableFocusState;
+    onVariableFocus?: (variableName: string | null) => void;
+    renderTermProducers?: RenderTermProducers;
+}) | (RuleNarrativeSegmentsBaseProps & {
+    variant: "edit-context";
+    activeEditId: string;
+});
+export declare function RuleNarrativeSegments(props: RuleNarrativeSegmentsProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RuleNarrativeSegments.d.ts.map

package/dist/rules/RuleNarrativeSegments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleNarrativeSegments.d.ts","sourceRoot":"","sources":["../../src/rules/RuleNarrativeSegments.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAIzD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,SAAS,KAAK,SAAS,CAAC;AAE9F,MAAM,MAAM,8BAA8B,GAAG;IAC3C,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAClC,CAAC,8BAA8B,GAAG;IAChC,OAAO,EAAE,WAAW,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,eAAe,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACxD,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C,CAAC,GACF,CAAC,8BAA8B,GAAG;IAChC,OAAO,EAAE,cAAc,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC,CAAC;AAEP,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,2CAiGtE"}

package/dist/rules/RuleNarrativeSegments.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment } from "react";
+import { match } from "ts-pattern";
+import { OntologyTermText } from "../ontology/OntologyTermText.js";
+import { predicatePrefix } from "./rule-narrative-format.js";
+import { cn } from "#style";
+export function RuleNarrativeSegments(props) {
+    const { segments } = props;
+    const narrativeProps = props.variant === "narrative" ? props : undefined;
+    const renderTermProducers = narrativeProps?.renderTermProducers;
+    const useVariableColors = narrativeProps?.colorVariables ?? false;
+    const activeVariable = narrativeProps?.variableFocus?.activeVariable ?? null;
+    const relatedVariables = narrativeProps?.variableFocus?.relatedVariables;
+    const onVariableFocus = narrativeProps?.onVariableFocus;
+    return (_jsx(_Fragment, { children: segments.map((segment, index) => match(segment)
+            .with({ kind: "text" }, (text) => _jsx("span", { children: text.text }, index))
+            .with({ kind: "entity" }, (entity) => {
+            const renderPrefix = entity.prefix === "has" ? predicatePrefix : undefined;
+            return entity.term ? (_jsx(OntologyTermText, { term: entity.term, fallbackLabel: entity.text, title: entity.title, className: "typography-small-medium text-default-foreground", resolveInstanceLabel: false, tooltipExtra: renderTermProducers?.(entity.term, entity.graph), renderPrefix: renderPrefix }, index)) : (_jsxs(Fragment, { children: [renderPrefix?.(entity.text), _jsx("span", { className: "typography-small-medium text-default-foreground", title: entity.title, children: entity.text })] }, index));
+        })
+            .with({ kind: "variable" }, (variable) => {
+            const isActive = activeVariable === variable.name;
+            const isRelated = relatedVariables?.has(variable.name) ?? false;
+            const isRelatedOnly = isRelated && !isActive;
+            const isDimmed = activeVariable !== null && !isActive && !isRelated;
+            const variableColor = useVariableColors ? narrativeProps?.variableColors?.[variable.name] : undefined;
+            const onMouseEnter = onVariableFocus ? () => onVariableFocus(variable.name) : undefined;
+            const onMouseLeave = onVariableFocus ? () => onVariableFocus(null) : undefined;
+            return (_jsxs("span", { "aria-label": `Variable ?${variable.name}`, className: cn("inline-block rounded bg-faint px-1 py-px align-baseline font-mono typography-caption outline-none transition-[background-color,color,box-shadow,opacity]", useVariableColors && variableColor ? variableColor : "text-muted-foreground", isRelatedOnly && [
+                    "bg-primary/5 ring-1 ring-primary/20",
+                    !useVariableColors && "text-default-foreground",
+                ], isActive && [
+                    "bg-accent-foreground/10 ring-1 ring-active-border/30",
+                    !useVariableColors && "text-accent-foreground",
+                ], isDimmed && "opacity-60"), onMouseEnter: onMouseEnter, onMouseLeave: onMouseLeave, children: ["?", variable.name] }, index));
+        })
+            .with({ kind: "value" }, (value) => {
+            const isEditContext = props.variant === "edit-context";
+            const isActiveEdit = isEditContext && value.edit?.id === props.activeEditId;
+            return (_jsx("span", { className: cn("align-baseline font-mono typography-caption-medium", !isEditContext && "rounded bg-primary/10 px-1.5 py-px text-primary", isEditContext && !isActiveEdit && "text-muted-foreground", isActiveEdit && "rounded bg-primary/10 px-1.5 py-px text-primary ring-2 ring-primary/30"), title: value.title, children: value.text }, index));
+        })
+            .with({ kind: "code" }, (code) => (_jsx("span", { className: "font-mono typography-caption text-muted-foreground", children: code.text }, index)))
+            .exhaustive()) }));
+}

package/dist/rules/datalog-ast/DatalogAtomComponent.d.ts

@@ -0,0 +1,11 @@
+import type { DatalogAtom } from "@manta-eu/datalog-parser";
+import type { VariableColors, HoverState } from "./types.js";
+type DatalogAtomComponentProps = {
+    atom: DatalogAtom;
+    variableColors?: VariableColors;
+    hoverState?: HoverState;
+    onVariableHover?: (varName: string | null) => void;
+};
+export declare function DatalogAtomComponent(props: DatalogAtomComponentProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=DatalogAtomComponent.d.ts.map

package/dist/rules/datalog-ast/DatalogAtomComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatalogAtomComponent.d.ts","sourceRoot":"","sources":["../../../src/rules/datalog-ast/DatalogAtomComponent.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAI5D,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAG1D,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,WAAW,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,2CAqMpE"}

package/dist/rules/datalog-ast/DatalogAtomComponent.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { compactUri } from "@manta-eu/rdf-lib/namespaces";
+import { match } from "ts-pattern";
+import { DatalogTermComponent } from "./DatalogTermComponent.js";
+import { Badge } from "#components/badge/index";
+export function DatalogAtomComponent(props) {
+    const { atom, variableColors, hoverState, onVariableHover } = props;
+    return match(atom)
+        .with({ type: "triple" }, (triple) => {
+        const isTypeAssertion = triple.predicate.type === "iri" &&
+            (triple.predicate.value === "a" ||
+                triple.predicate.value === "rdf:type" ||
+                triple.predicate.value === "http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
+        if (isTypeAssertion) {
+            if (triple.object.type === "iri") {
+                return (_jsxs("div", { className: "flex items-center gap-2 flex-wrap", children: [_jsx(Badge, { variant: "primary", className: "typography-caption", children: "type" }), _jsx("span", { className: "text-muted-foreground font-mono typography-body", children: compactUri(triple.object.value) }), _jsx("span", { className: "text-muted-foreground", children: "[" }), _jsx(DatalogTermComponent, { term: triple.subject, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), _jsx("span", { className: "text-muted-foreground", children: "]" }), triple.graph && (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground", children: "@" }), _jsx(DatalogTermComponent, { term: triple.graph, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover })] }))] }));
+            }
+            return (_jsxs("div", { className: "flex items-center gap-2 flex-wrap", children: [_jsx(Badge, { variant: "primary", className: "typography-caption", children: "type" }), _jsx(DatalogTermComponent, { term: triple.subject, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), _jsx("span", { className: "text-muted-foreground font-mono", children: "a" }), _jsx(DatalogTermComponent, { term: triple.object, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), triple.graph && (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground", children: "[" }), _jsx(DatalogTermComponent, { term: triple.graph, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), _jsx("span", { className: "text-muted-foreground", children: "]" })] }))] }));
+        }
+        return (_jsxs("div", { className: "flex items-center gap-2 flex-wrap", children: [_jsx(Badge, { variant: "secondary", className: "typography-caption", children: "triple" }), _jsx(DatalogTermComponent, { term: triple.subject, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), _jsx(DatalogTermComponent, { term: triple.predicate, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), _jsx(DatalogTermComponent, { term: triple.object, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), triple.graph && (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground", children: "[" }), _jsx(DatalogTermComponent, { term: triple.graph, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), _jsx("span", { className: "text-muted-foreground", children: "]" })] }))] }));
+    })
+        .with({ type: "property" }, (property) => (_jsxs("div", { className: "flex items-center gap-2 flex-wrap", children: [_jsx(Badge, { variant: "secondary", className: "typography-caption", children: "property" }), _jsx("span", { className: "text-muted-foreground font-mono", children: compactUri(property.predicate) }), _jsx("span", { className: "text-muted-foreground", children: "[" }), _jsx(DatalogTermComponent, { term: property.subject, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), _jsx("span", { className: "text-muted-foreground", children: "," }), _jsx(DatalogTermComponent, { term: property.object, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), _jsx("span", { className: "text-muted-foreground", children: "]" }), property.graph && (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground", children: "@" }), _jsx(DatalogTermComponent, { term: property.graph, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover })] }))] })))
+        .with({ type: "class" }, (classAtom) => (_jsxs("div", { className: "flex items-center gap-2 flex-wrap", children: [_jsx(Badge, { variant: "primary", className: "typography-caption", children: "class" }), _jsx("span", { className: "text-muted-foreground font-mono typography-body", children: compactUri(classAtom.className) }), _jsx("span", { className: "text-muted-foreground", children: "[" }), _jsx(DatalogTermComponent, { term: classAtom.instance, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }), _jsx("span", { className: "text-muted-foreground", children: "]" }), classAtom.graph && (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground", children: "@" }), _jsx(DatalogTermComponent, { term: classAtom.graph, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover })] }))] })))
+        .with({ type: "general" }, (general) => (_jsxs("div", { className: "flex items-center gap-2 flex-wrap", children: [_jsx(Badge, { variant: "secondary", className: "typography-caption", children: "general" }), _jsx("span", { className: "text-muted-foreground font-mono", children: general.tableName }), _jsx("span", { className: "text-muted-foreground", children: "[" }), general.terms.map((term, i) => (_jsxs("span", { className: "inline-flex items-center gap-1", children: [i > 0 && _jsx("span", { className: "text-muted-foreground", children: "," }), _jsx(DatalogTermComponent, { term: term, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover })] }, i))), _jsx("span", { className: "text-muted-foreground", children: "]" })] })))
+        .exhaustive();
+}

package/dist/rules/datalog-ast/DatalogBodyFormulaComponent.d.ts

@@ -0,0 +1,11 @@
+import type { DatalogBodyFormula } from "@manta-eu/datalog-parser";
+import type { HoverState, VariableColors } from "./types.js";
+type DatalogBodyFormulaComponentProps = {
+    formula: DatalogBodyFormula;
+    variableColors?: VariableColors;
+    hoverState?: HoverState;
+    onVariableHover?: (varName: string | null) => void;
+};
+export declare function DatalogBodyFormulaComponent(props: DatalogBodyFormulaComponentProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=DatalogBodyFormulaComponent.d.ts.map

package/dist/rules/datalog-ast/DatalogBodyFormulaComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatalogBodyFormulaComponent.d.ts","sourceRoot":"","sources":["../../../src/rules/datalog-ast/DatalogBodyFormulaComponent.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAIV,kBAAkB,EAInB,MAAM,0BAA0B,CAAC;AAOlC,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG1D,KAAK,gCAAgC,GAAG;IACtC,OAAO,EAAE,kBAAkB,CAAC;IAC5B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACpD,CAAC;AAsBF,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,gCAAgC,2CAgIlF"}

package/dist/rules/datalog-ast/DatalogBodyFormulaComponent.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { Minus } from "lucide-react";
+import { match, P } from "ts-pattern";
+import { DatalogAtomComponent } from "./DatalogAtomComponent.js";
+import { renderExpressionWithVariables } from "./DatalogExpressionRenderer.js";
+import { DatalogTermComponent } from "./DatalogTermComponent.js";
+import { Badge } from "#components/badge/index";
+function renderAggregateExpression(binding, variableColors, hoverState, onVariableHover) {
+    if (binding.expression === "*") {
+        return "*";
+    }
+    const first = renderExpressionWithVariables(binding.expression, variableColors, hoverState, onVariableHover);
+    if (!binding.secondExpression)
+        return first;
+    return (_jsxs(_Fragment, { children: [first, _jsx("span", { className: "text-orange-100 font-mono", children: ", " }), renderExpressionWithVariables(binding.secondExpression, variableColors, hoverState, onVariableHover)] }));
+}
+export function DatalogBodyFormulaComponent(props) {
+    const { formula, variableColors, hoverState, onVariableHover } = props;
+    return match(formula)
+        .with({ type: P.union("triple", "property", "class", "general") }, (atom) => (_jsx(DatalogAtomComponent, { atom: atom, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover })))
+        .with({ type: "negation" }, (negation) => (_jsxs("div", { className: "rounded border border-red-200 bg-red-50 dark:bg-red-900/20 dark:border-red-800", children: [_jsx("div", { className: "px-3 py-2 border-b border-red-200 dark:border-red-800 bg-red-100 dark:bg-red-900/30", children: _jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Minus, { className: "size-4 text-red-600" }), _jsx(Badge, { variant: "secondary", className: "typography-tiny bg-red-500 text-white", children: "NOT EXISTS" }), isPresent(negation.existentialVars) && (_jsxs("span", { className: "typography-tiny text-red-600", children: ["(\u2203 ", negation.existentialVars.map((v) => `?${v}`).join(", "), ")"] }))] }) }), _jsx("div", { className: "p-3 space-y-3", children: negation.formulas.map((f, i) => (_jsx("div", { className: "pl-4 border-l-2 border-red-300 dark:border-red-700", children: _jsx(DatalogBodyFormulaComponent, { formula: f, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }) }, i))) })] })))
+        .with({ type: "filter" }, (filter) => (_jsxs("div", { className: "flex items-center gap-2 p-2 rounded bg-yellow-50 dark:bg-yellow-900/20 border border-yellow-200 dark:border-yellow-800", children: [_jsx(Badge, { variant: "secondary", className: "typography-tiny bg-yellow-600 text-white", children: "filter" }), _jsx("div", { className: "flex items-center gap-1", children: renderExpressionWithVariables(filter.expression, variableColors, hoverState, onVariableHover) })] })))
+        .with({ type: "bind" }, (bind) => (_jsxs("div", { className: "flex items-center gap-2 p-2 rounded bg-indigo-50 dark:bg-indigo-900/20 border border-indigo-200 dark:border-indigo-800", children: [_jsx(Badge, { variant: "secondary", className: "typography-tiny bg-indigo-600 text-white", children: "bind" }), renderExpressionWithVariables(bind.expression, variableColors, hoverState, onVariableHover), _jsx("span", { className: "text-indigo-600", children: "\u2192" }), _jsx(DatalogTermComponent, { term: { type: "variable", name: bind.variable }, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover })] })))
+        .with({ type: "aggregate" }, (aggregate) => (_jsxs("div", { className: "rounded border border-muted-border bg-gradient-to-r from-orange-500/10 to-amber-500/10", children: [_jsx("div", { className: "px-3 py-2 border-b border-muted-border bg-orange-500/20", children: _jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [_jsx(Badge, { variant: "secondary", className: "typography-tiny bg-orange-600 text-white", children: "aggregate" }), isPresent(aggregate.bindings) && (_jsxs("div", { className: "flex flex-wrap items-center gap-2 typography-small", children: [_jsx("span", { className: "text-orange-200", children: "\u2192" }), aggregate.bindings.map((b, i) => (_jsxs("div", { className: "flex shrink-0 items-center gap-1", children: [i > 0 && _jsx("span", { className: "text-orange-300", children: "," }), _jsxs("span", { className: "text-orange-100 font-mono", children: [b.distinct && "DISTINCT ", b.function, "("] }), renderAggregateExpression(b, variableColors, hoverState, onVariableHover), _jsx("span", { className: "text-orange-100 font-mono", children: ")" }), _jsx("span", { className: "text-orange-300", children: "\u2192" }), _jsx(DatalogTermComponent, { term: { type: "variable", name: b.variable }, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover })] }, i)))] }))] }) }), _jsx("div", { className: "p-3 space-y-3", children: aggregate.atoms.map((formula, index) => (_jsx("div", { className: "pl-4 border-l-2 border-orange-400/30", children: _jsx(DatalogBodyFormulaComponent, { formula: formula, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover }) }, index))) })] })))
+        .with({ type: "skolem" }, (skolem) => (_jsxs("div", { className: "flex items-center gap-2 p-2 rounded bg-purple-50 dark:bg-purple-900/20 border border-purple-200 dark:border-purple-800", children: [_jsx(Badge, { variant: "secondary", className: "typography-tiny bg-purple-600 text-white", children: "skolem" }), _jsx("span", { className: "font-mono", children: "SKOLEM(" }), skolem.args.map((arg, i) => (_jsxs("span", { children: [i > 0 && ", ", renderExpressionWithVariables(arg, variableColors, hoverState, onVariableHover)] }, i))), _jsx("span", { className: "font-mono", children: ")" })] })))
+        .exhaustive();
+}

package/dist/rules/datalog-ast/DatalogExpressionRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { DatalogExpression } from "@manta-eu/datalog-parser";
+import type { HoverState, VariableColors } from "./types.js";
+export declare function renderExpressionWithVariables(expression: DatalogExpression, variableColors?: VariableColors, hoverState?: HoverState, onVariableHover?: (varName: string | null) => void): React.ReactNode;
+//# sourceMappingURL=DatalogExpressionRenderer.d.ts.map

package/dist/rules/datalog-ast/DatalogExpressionRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatalogExpressionRenderer.d.ts","sourceRoot":"","sources":["../../../src/rules/datalog-ast/DatalogExpressionRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE1D,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,iBAAiB,EAC7B,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,CAAC,EAAE,UAAU,EACvB,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,GACjD,KAAK,CAAC,SAAS,CA2EjB"}

package/dist/rules/datalog-ast/DatalogExpressionRenderer.js

@@ -0,0 +1,19 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { match } from "ts-pattern";
+import { DatalogTermComponent } from "./DatalogTermComponent.js";
+export function renderExpressionWithVariables(expression, variableColors, hoverState, onVariableHover) {
+    return match(expression)
+        .with({ type: "binary" }, (bin) => (_jsxs("span", { children: [renderExpressionWithVariables(bin.left, variableColors, hoverState, onVariableHover), " ", bin.operator, " ", renderExpressionWithVariables(bin.right, variableColors, hoverState, onVariableHover)] })))
+        .with({ type: "unary" }, (un) => (_jsxs("span", { children: [un.operator, renderExpressionWithVariables(un.operand, variableColors, hoverState, onVariableHover)] })))
+        .with({ type: "term" }, (term) => (_jsx(DatalogTermComponent, { term: term.term, variableColors: variableColors, hoverState: hoverState, onVariableHover: onVariableHover })))
+        .with({ type: "function" }, (fn) => {
+        // Handle IF function specially with multiline formatting
+        if (fn.name.toUpperCase() === "IF" && fn.args.length === 3) {
+            return (_jsxs("div", { className: "inline-block", children: [_jsx("div", { className: "font-mono", children: "IF(" }), _jsxs("div", { className: "ml-4", children: [_jsxs("div", { className: "py-1", children: [_jsx("span", { className: "text-[#808a84] typography-tiny mr-2", children: "condition:" }), fn.args[0] && renderExpressionWithVariables(fn.args[0], variableColors, hoverState, onVariableHover)] }), _jsxs("div", { className: "py-1", children: [_jsx("span", { className: "text-[#808a84] typography-tiny mr-2", children: "then:" }), fn.args[1] && renderExpressionWithVariables(fn.args[1], variableColors, hoverState, onVariableHover)] }), _jsxs("div", { className: "py-1", children: [_jsx("span", { className: "text-[#808a84] typography-tiny mr-2", children: "else:" }), fn.args[2] && renderExpressionWithVariables(fn.args[2], variableColors, hoverState, onVariableHover)] })] }), _jsx("div", { className: "font-mono", children: ")" })] }));
+        }
+        // Handle other functions normally
+        return (_jsxs("span", { children: [fn.name, "(", fn.args.map((arg, i) => (_jsxs("span", { children: [i > 0 && ", ", renderExpressionWithVariables(arg, variableColors, hoverState, onVariableHover)] }, i))), ")"] }));
+    })
+        .with({ type: "in" }, (inExpr) => (_jsxs("span", { children: [inExpr.negated && "NOT ", renderExpressionWithVariables(inExpr.expression, variableColors, hoverState, onVariableHover), " IN (", inExpr.list.map((item, i) => (_jsxs("span", { children: [i > 0 && ", ", renderExpressionWithVariables(item, variableColors, hoverState, onVariableHover)] }, i))), ")"] })))
+        .exhaustive();
+}

package/dist/rules/datalog-ast/DatalogTermComponent.d.ts

@@ -0,0 +1,11 @@
+import type { DatalogTerm } from "@manta-eu/datalog-parser";
+import type { HoverState, VariableColors } from "./types.js";
+type DatalogTermComponentProps = {
+    term: DatalogTerm;
+    variableColors?: VariableColors;
+    hoverState?: HoverState;
+    onVariableHover?: (varName: string | null) => void;
+};
+export declare function DatalogTermComponent(props: DatalogTermComponentProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=DatalogTermComponent.d.ts.map

package/dist/rules/datalog-ast/DatalogTermComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatalogTermComponent.d.ts","sourceRoot":"","sources":["../../../src/rules/datalog-ast/DatalogTermComponent.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI1D,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,WAAW,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB,2CAoEpE"}