@manta-eu/react 0.1.0

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

@@ -0,0 +1,48 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { compactUri } from "@manta-eu/rdf-lib/namespaces";
+import { match } from "ts-pattern";
+import { OntologyTermText } from "#ontology/OntologyTermText";
+import { cn } from "#style";
+export function DatalogTermComponent(props) {
+    const { term, variableColors, hoverState, onVariableHover } = props;
+    return match(term)
+        .with({ type: "variable" }, (variable) => {
+        if (variableColors && hoverState && onVariableHover) {
+            const isMatch = hoverState.hoveredVar === variable.name;
+            const color = variableColors[variable.name] || "text-muted-foreground";
+            return (_jsxs("span", { className: cn("inline-block whitespace-nowrap font-mono cursor-pointer typography-small transition-[text-shadow] duration-150", color, isMatch && "[text-shadow:0_0_8px_currentColor]"), onMouseEnter: () => onVariableHover(variable.name), onMouseLeave: () => onVariableHover(null), children: ["?", variable.name] }));
+        }
+        return _jsxs("span", { className: "text-[#3dd68c] font-mono whitespace-nowrap", children: ["?", variable.name] });
+    })
+        .with({ type: "iri" }, (iri) => {
+        const displayValue = iri.prefixed ? compactUri(iri.value) : `<${iri.value}>`;
+        return _jsx(OntologyTermText, { term: displayValue, className: "text-blue-600 font-mono" });
+    })
+        .with({ type: "literal" }, (lit) => {
+        // Show typed literals in compact form for numeric and boolean types
+        if (lit.datatype) {
+            const isNumeric = lit.datatype.includes("integer") ||
+                lit.datatype.includes("decimal") ||
+                lit.datatype.includes("double") ||
+                lit.datatype.includes("float");
+            const isBoolean = lit.datatype.includes("boolean");
+            if (isNumeric) {
+                return _jsx("span", { className: "text-orange-500 font-mono", children: lit.value });
+            }
+            if (isBoolean) {
+                return _jsx("span", { className: "text-pink-500 font-mono", children: lit.value });
+            }
+            // For other datatypes, show full form with datatype annotation
+            const compactDatatype = compactUri(lit.datatype);
+            return (_jsxs("span", { className: "text-orange-500 font-mono", children: ["\"", lit.value, "\"", _jsxs("span", { className: "text-gray-500 typography-tiny", children: ["^^", compactDatatype] })] }));
+        }
+        // Show language-tagged literals
+        if (lit.language) {
+            return (_jsxs("span", { className: "text-orange-500 font-mono", children: ["\"", lit.value, "\"", _jsxs("span", { className: "text-gray-500", children: ["@", lit.language] })] }));
+        }
+        // Plain string literals
+        return _jsxs("span", { className: "text-orange-500 font-mono", children: ["\"", lit.value, "\""] });
+    })
+        .with({ type: "blank" }, (blank) => _jsxs("span", { className: "text-gray-500 font-mono", children: ["_:", blank.label] }))
+        .exhaustive();
+}

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

@@ -0,0 +1,7 @@
+export { DatalogAtomComponent } from "./DatalogAtomComponent.js";
+export { DatalogBodyFormulaComponent } from "./DatalogBodyFormulaComponent.js";
+export { DatalogTermComponent } from "./DatalogTermComponent.js";
+export { renderExpressionWithVariables } from "./DatalogExpressionRenderer.js";
+export { extractVariables, assignVariableColors, getRelatedVariables } from "./utils.js";
+export type { VariableColors, HoverState } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rules/datalog-ast/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACtF,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}

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

@@ -0,0 +1,5 @@
+export { DatalogAtomComponent } from "./DatalogAtomComponent.js";
+export { DatalogBodyFormulaComponent } from "./DatalogBodyFormulaComponent.js";
+export { DatalogTermComponent } from "./DatalogTermComponent.js";
+export { renderExpressionWithVariables } from "./DatalogExpressionRenderer.js";
+export { extractVariables, assignVariableColors, getRelatedVariables } from "./utils.js";

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

@@ -0,0 +1,6 @@
+export type VariableColors = Record<string, string>;
+export type HoverState = {
+    hoveredVar: string | null;
+    relatedVars: Set<string>;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/rules/datalog-ast/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEpD,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC1B,CAAC"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,3 @@
+export { extractVariables, getRelatedVariables } from "@manta-eu/datalog-parser";
+export declare function assignVariableColors(variables: string[]): Record<string, string>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/rules/datalog-ast/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAYjF,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMhF"}

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

@@ -0,0 +1,18 @@
+import { isPresent } from "@manta-eu/lib/present";
+export { extractVariables, getRelatedVariables } from "@manta-eu/datalog-parser";
+const variableColors = [
+    "text-success-foreground",
+    "text-info-foreground",
+    "text-warning-foreground",
+    "text-error-foreground",
+    "text-accent-foreground",
+    "text-default-foreground",
+    "text-creative-accent-foreground",
+];
+export function assignVariableColors(variables) {
+    const colors = {};
+    variables.filter(isPresent).forEach((varName, index) => {
+        colors[varName] = variableColors[index % variableColors.length] || "text-default-foreground";
+    });
+    return colors;
+}

package/dist/rules/datalog-cache.d.ts

@@ -0,0 +1,20 @@
+import { type DatalogRule } from "@manta-eu/datalog-parser";
+export type ParseResult = {
+    ast: DatalogRule | null;
+    error: string | null;
+};
+export type DatalogCacheState = {
+    cache: Map<string, ParseResult>;
+};
+export type DatalogCacheActions = {
+    parse: (rule: string) => ParseResult;
+    clear: () => void;
+};
+export type DatalogCacheStore = DatalogCacheState & DatalogCacheActions;
+export type RuleParser = (rule: string) => DatalogRule;
+export declare function createDatalogCacheStore(parse?: RuleParser): import("zustand").StoreApi<DatalogCacheStore>;
+export declare const datalogCacheStore: import("zustand").StoreApi<DatalogCacheStore>;
+export declare const groundedDatalogCacheStore: import("zustand").StoreApi<DatalogCacheStore>;
+export declare function parseDatalogRuleCached(rule: string): ParseResult;
+export declare function parseGroundedDatalogRuleCached(rule: string): ParseResult;
+//# sourceMappingURL=datalog-cache.d.ts.map

package/dist/rules/datalog-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datalog-cache.d.ts","sourceRoot":"","sources":["../../src/rules/datalog-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIxG,MAAM,MAAM,WAAW,GAAG;IAAE,GAAG,EAAE,WAAW,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE5E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,WAAW,CAAC;IACrC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,GAAG,mBAAmB,CAAC;AAIxE,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,WAAW,CAAC;AAUvD,wBAAgB,uBAAuB,CAAC,KAAK,GAAE,UAA6B,iDAyB3E;AAED,eAAO,MAAM,iBAAiB,+CAA4B,CAAC;AAE3D,eAAO,MAAM,yBAAyB,+CAAoD,CAAC;AAE3F,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,eAElD;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,eAE1D"}

package/dist/rules/datalog-cache.js

@@ -0,0 +1,43 @@
+import { parseDatalogRule, parseGroundedDatalogRule } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { createStore } from "zustand/vanilla";
+const maxEntries = 500;
+function parseRule(parse, rule) {
+    try {
+        return { ast: parse(rule), error: null };
+    }
+    catch (err) {
+        return { ast: null, error: err instanceof Error ? err.message : "Failed to parse rule" };
+    }
+}
+export function createDatalogCacheStore(parse = parseDatalogRule) {
+    return createStore()((set, get) => ({
+        cache: new Map(),
+        parse: (rule) => {
+            const existing = get().cache.get(rule);
+            if (existing)
+                return existing;
+            const result = parseRule(parse, rule);
+            set((state) => {
+                const next = new Map(state.cache);
+                if (next.size >= maxEntries) {
+                    const firstKey = next.keys().next().value;
+                    if (isPresent(firstKey))
+                        next.delete(firstKey);
+                }
+                next.set(rule, result);
+                return { cache: next };
+            });
+            return result;
+        },
+        clear: () => set({ cache: new Map() }),
+    }));
+}
+export const datalogCacheStore = createDatalogCacheStore();
+export const groundedDatalogCacheStore = createDatalogCacheStore(parseGroundedDatalogRule);
+export function parseDatalogRuleCached(rule) {
+    return datalogCacheStore.getState().parse(rule);
+}
+export function parseGroundedDatalogRuleCached(rule) {
+    return groundedDatalogCacheStore.getState().parse(rule);
+}

package/dist/rules/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./DatalogAst.js";
+export * from "./datalog-cache.js";
+export * from "./RuleNarrative.js";
+export * from "./rule-narrative.js";
+export * from "./rule-narrative-format.js";
+export * from "./RuleNarrativeSegments.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC"}

package/dist/rules/index.js

@@ -0,0 +1,6 @@
+export * from "./DatalogAst.js";
+export * from "./datalog-cache.js";
+export * from "./RuleNarrative.js";
+export * from "./rule-narrative.js";
+export * from "./rule-narrative-format.js";
+export * from "./RuleNarrativeSegments.js";

package/dist/rules/rule-narrative-aggregates.d.ts

@@ -0,0 +1,4 @@
+import type { AggregateBinding, DatalogExpression } from "@manta-eu/datalog-parser";
+import { type NarrativeSegment } from "./rule-narrative-format.js";
+export declare function aggregateBindingSegments(binding: AggregateBinding, expressionSegments: (expression: DatalogExpression) => NarrativeSegment[]): NarrativeSegment[];
+//# sourceMappingURL=rule-narrative-aggregates.d.ts.map

package/dist/rules/rule-narrative-aggregates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-narrative-aggregates.d.ts","sourceRoot":"","sources":["../../src/rules/rule-narrative-aggregates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEhB,iBAAiB,EAGlB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAA4B,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE1F,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,gBAAgB,EACzB,kBAAkB,EAAE,CAAC,UAAU,EAAE,iBAAiB,KAAK,gBAAgB,EAAE,GACxE,gBAAgB,EAAE,CAyDpB"}

package/dist/rules/rule-narrative-aggregates.js

@@ -0,0 +1,49 @@
+import { match, P } from "ts-pattern";
+import { codeSegment, textSegment } from "./rule-narrative-format.js";
+export function aggregateBindingSegments(binding, expressionSegments) {
+    const operand = (expression) => {
+        if (expression === "*")
+            return [codeSegment("*")];
+        const segments = expressionSegments(expression);
+        return expression.type === "term" ? segments : [codeSegment("("), ...segments, codeSegment(")")];
+    };
+    const unary = (binding, phrase) => [
+        textSegment(phrase),
+        ...(binding.distinct ? [textSegment("distinct values of ")] : []),
+        ...operand(binding.expression),
+    ];
+    const countExtreme = (binding, order) => [
+        textSegment("the number of matches where "),
+        ...operand(binding.expression),
+        textSegment(` is ${order}${binding.distinct ? " (ignoring duplicate values)" : ""}`),
+    ];
+    const selection = (binding, order, tieOrder) => [
+        ...operand(binding.expression),
+        textSegment(" where "),
+        ...operand(binding.secondExpression),
+        textSegment(` is ${order} (ties choose the ${tieOrder} result)`),
+        ...(binding.distinct ? [textSegment(" (ignoring duplicate pairs)")] : []),
+    ];
+    return match(binding)
+        .returnType()
+        .with({ function: P.optional(undefined) }, (binding) => expressionSegments(binding.expression))
+        .with({ function: "COUNT", expression: "*" }, (binding) => [
+        textSegment(binding.distinct ? "the number of distinct matches" : "the number of matches"),
+    ])
+        .with({ function: "COUNT" }, (binding) => unary(binding, binding.distinct ? "the number of " : "the number of values of "))
+        .with({ function: "SUM" }, (binding) => unary(binding, "the total of "))
+        .with({ function: "AVG" }, (binding) => unary(binding, "the average of "))
+        .with({ function: "MIN" }, (binding) => unary(binding, "the lowest of "))
+        .with({ function: "MAX" }, (binding) => unary(binding, "the highest of "))
+        .with({ function: "MUL" }, (binding) => [
+        ...unary(binding, binding.distinct ? "the " : "the values of "),
+        textSegment(" multiplied together"),
+    ])
+        .with({ function: "COUNT_MIN" }, (binding) => countExtreme(binding, "lowest"))
+        .with({ function: "COUNT_MAX" }, (binding) => countExtreme(binding, "highest"))
+        .with({ function: "MIN_ARGMIN" }, (binding) => selection(binding, "lowest", "lowest"))
+        .with({ function: "MAX_ARGMIN" }, (binding) => selection(binding, "lowest", "highest"))
+        .with({ function: "MIN_ARGMAX" }, (binding) => selection(binding, "highest", "lowest"))
+        .with({ function: "MAX_ARGMAX" }, (binding) => selection(binding, "highest", "highest"))
+        .exhaustive();
+}

package/dist/rules/rule-narrative-context.d.ts

@@ -0,0 +1,4 @@
+import { type DatalogRule } from "@manta-eu/datalog-parser";
+import type { NarrativeContext } from "./rule-narrative-format.js";
+export declare function buildNarrativeContext(rule: DatalogRule): NarrativeContext;
+//# sourceMappingURL=rule-narrative-context.d.ts.map

package/dist/rules/rule-narrative-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-narrative-context.d.ts","sourceRoot":"","sources":["../../src/rules/rule-narrative-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,WAAW,EACjB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EAAE,gBAAgB,EAAiB,MAAM,yBAAyB,CAAC;AAE/E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,WAAW,GAAG,gBAAgB,CAyDzE"}

package/dist/rules/rule-narrative-context.js

@@ -0,0 +1,59 @@
+import { classAssertionFromAtom, isDatalogAtom, isVariableTerm, propertyAssertionFromAtom, variableNamesFromAtom, } from "@manta-eu/datalog-parser";
+import { isOwlNothing } from "@manta-eu/rdf-lib/namespaces";
+import { match } from "ts-pattern";
+export function buildNarrativeContext(rule) {
+    const entityVariableNames = new Set();
+    const outputVariableNames = new Set();
+    const skolemVariableNames = new Set();
+    const variableLabels = new Map();
+    const setLabel = (name, label) => {
+        if (!variableLabels.has(name))
+            variableLabels.set(name, label);
+    };
+    const visit = (formula) => {
+        const classAssertion = isDatalogAtom(formula) ? classAssertionFromAtom(formula) : null;
+        if (classAssertion) {
+            const { instance, className, graph } = classAssertion;
+            if (isVariableTerm(instance) && !isOwlNothing(className)) {
+                entityVariableNames.add(instance.name);
+                setLabel(instance.name, { kind: "class", term: className, graph });
+            }
+            return;
+        }
+        const propertyAssertion = isDatalogAtom(formula) ? propertyAssertionFromAtom(formula) : null;
+        if (propertyAssertion) {
+            const { subject, object, predicate, graph } = propertyAssertion;
+            if (isVariableTerm(subject))
+                entityVariableNames.add(subject.name);
+            if (isVariableTerm(object)) {
+                setLabel(object.name, { kind: "predicate", term: predicate, graph });
+            }
+            return;
+        }
+        match(formula)
+            .with({ type: "triple" }, (triple) => {
+            if (isVariableTerm(triple.subject))
+                entityVariableNames.add(triple.subject.name);
+        })
+            .with({ type: "skolem" }, (skolem) => {
+            const lastArg = skolem.args[skolem.args.length - 1];
+            if (lastArg?.type === "term" && isVariableTerm(lastArg.term)) {
+                skolemVariableNames.add(lastArg.term.name);
+            }
+        })
+            .with({ type: "negation" }, (negation) => negation.formulas.forEach(visit))
+            .with({ type: "aggregate" }, (aggregate) => aggregate.atoms.forEach(visit))
+            .otherwise(() => undefined);
+    };
+    rule.body.forEach(visit);
+    rule.head.forEach((atom) => {
+        variableNamesFromAtom(atom).forEach((name) => outputVariableNames.add(name));
+        visit(atom);
+    });
+    return {
+        showEntityVariables: entityVariableNames.size > 1,
+        outputVariableNames,
+        skolemVariableNames,
+        variableLabels,
+    };
+}

package/dist/rules/rule-narrative-filters.d.ts

@@ -0,0 +1,5 @@
+import { type DatalogFilter } from "@manta-eu/datalog-parser";
+import { type NarrativeRow } from "./rule-narrative-format.js";
+import { type RuleNarrativeRenderer } from "./rule-narrative-renderer.js";
+export declare function buildFilterRow(filter: DatalogFilter, renderer: RuleNarrativeRenderer): NarrativeRow;
+//# sourceMappingURL=rule-narrative-filters.d.ts.map

package/dist/rules/rule-narrative-filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-narrative-filters.d.ts","sourceRoot":"","sources":["../../src/rules/rule-narrative-filters.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAe,KAAK,YAAY,EAAyB,MAAM,yBAAyB,CAAC;AAChG,OAAO,EAAsB,KAAK,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAE3F,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,qBAAqB,GAAG,YAAY,CAoBnG"}

package/dist/rules/rule-narrative-filters.js

@@ -0,0 +1,107 @@
+import { isVariableTerm, literalSetComparisonFromExpression, } from "@manta-eu/datalog-parser";
+import { match, P } from "ts-pattern";
+import { textSegment } from "./rule-narrative-format.js";
+import { comparisonSegments } from "./rule-narrative-renderer.js";
+export function buildFilterRow(filter, renderer) {
+    const oneOfRow = buildOneOfFilterRow(filter.expression, renderer);
+    if (oneOfRow)
+        return oneOfRow;
+    const textMatchRow = buildTextMatchFilterRow(filter.expression, renderer);
+    if (textMatchRow)
+        return textMatchRow;
+    const comparison = comparisonSegments(filter.expression, (expression) => expressionValueSegments(expression, renderer));
+    if (comparison)
+        return { segments: comparison };
+    return {
+        segments: [
+            textSegment("Where "),
+            ...renderer.expressionSegments(filter.expression, {
+                labelVariables: true,
+            }),
+        ],
+    };
+}
+function buildOneOfFilterRow(expression, renderer) {
+    const comparison = literalSetComparisonFromExpression(expression);
+    if (!comparison)
+        return null;
+    const subject = comparison.subject;
+    return {
+        segments: [
+            ...(isVariableTerm(subject) ? renderer.variableReferenceSegments(subject.name) : [renderer.termSegment(subject)]),
+            textSegment(comparison.negated ? " is not one of " : " is one of "),
+            ...comparison.literals.flatMap((literal, index) => [
+                ...(index > 0 ? [textSegment(", ")] : []),
+                renderer.literalSegment(literal),
+            ]),
+        ],
+    };
+}
+const textMatchPhrases = {
+    CONTAINS: " contains ",
+    STRSTARTS: " starts with ",
+    STRENDS: " ends with ",
+};
+const caseFoldingFunctions = new Set(["LCASE", "UCASE"]);
+function withoutCaseFolding(expression) {
+    return match(expression)
+        .with({ type: "function", args: [P.any, ...P.array()] }, (call) => caseFoldingFunctions.has(call.name.toUpperCase()), (call) => call.args[0])
+        .otherwise(() => expression);
+}
+function textMatchRow(args) {
+    const { haystack, phrase, needle, ignoresCase, renderer } = args;
+    return {
+        segments: [
+            ...expressionValueSegments(haystack, renderer),
+            textSegment(phrase),
+            ...expressionValueSegments(needle, renderer),
+            ...(ignoresCase ? [textSegment(", ignoring case")] : []),
+        ],
+    };
+}
+function regexFlagsText(flags) {
+    if (!flags)
+        return "";
+    return match(flags)
+        .with({ type: "term", term: { type: "literal", value: "i" } }, () => "i")
+        .otherwise(() => undefined);
+}
+function buildTextMatchFilterRow(expression, renderer) {
+    return match(expression)
+        .returnType()
+        .with({ type: "function", args: [P.any, P.any, ...P.array()] }, (call) => call.name.toUpperCase() === "REGEX", (call) => {
+        const [haystack, pattern, flags] = call.args;
+        const flagsText = regexFlagsText(flags);
+        if (!haystack || !pattern || flagsText === undefined)
+            return null;
+        return textMatchRow({
+            haystack: withoutCaseFolding(haystack),
+            phrase: " matches pattern ",
+            needle: pattern,
+            ignoresCase: flagsText === "i",
+            renderer,
+        });
+    })
+        .with({ type: "function", args: [P.any, P.any] }, (call) => {
+        const phrase = textMatchPhrases[call.name.toUpperCase()];
+        const [haystack, needle] = call.args;
+        if (!phrase || !haystack || !needle)
+            return null;
+        const unwrappedHaystack = withoutCaseFolding(haystack);
+        const unwrappedNeedle = withoutCaseFolding(needle);
+        return textMatchRow({
+            haystack: unwrappedHaystack,
+            phrase,
+            needle: unwrappedNeedle,
+            ignoresCase: unwrappedHaystack !== haystack || unwrappedNeedle !== needle,
+            renderer,
+        });
+    })
+        .otherwise(() => null);
+}
+function expressionValueSegments(expression, renderer) {
+    return renderer.expressionSegments(expression, {
+        labelVariables: true,
+        inline: true,
+    });
+}

package/dist/rules/rule-narrative-format.d.ts

@@ -0,0 +1,74 @@
+import type { ComparisonOperator, DatalogTerm, SourceSpan } from "@manta-eu/datalog-parser";
+export type NarrativeTag = "IF" | "AND" | "DO";
+export type EditableRuleValueKind = "number" | "date" | "dateTime";
+export type EditableRuleValue = {
+    id: string;
+    kind: EditableRuleValueKind;
+    value: string;
+    replacementSpan: SourceSpan;
+};
+export type ValueNarrativeSegment = {
+    kind: "value";
+    text: string;
+    title?: string;
+    edit?: EditableRuleValue;
+};
+export type EditableValueNarrativeSegment = ValueNarrativeSegment & {
+    edit: EditableRuleValue;
+};
+export type NarrativeSegment = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "entity";
+    text: string;
+    title?: string;
+    term?: string;
+    graph?: DatalogTerm;
+    prefix?: "has";
+} | {
+    kind: "variable";
+    name: string;
+} | ValueNarrativeSegment | {
+    kind: "code";
+    text: string;
+};
+export type NarrativeRow = {
+    segments: NarrativeSegment[];
+    editContext?: NarrativeSegment[];
+    graph?: DatalogTerm;
+    muted?: boolean;
+    children?: NarrativeRow[];
+};
+export type TaggedNarrativeRow = NarrativeRow & {
+    tag: NarrativeTag;
+};
+export type VariableLabel = {
+    kind: "class" | "predicate";
+    term: string;
+    graph?: DatalogTerm;
+};
+export type NarrativeContext = {
+    showEntityVariables: boolean;
+    outputVariableNames: ReadonlySet<string>;
+    skolemVariableNames: ReadonlySet<string>;
+    variableLabels: ReadonlyMap<string, VariableLabel>;
+};
+export declare const narrativeDatalogTextOptions: {
+    readonly stripSimpleLiteralDatatypes: true;
+};
+export declare function operatorPhrase(operator: ComparisonOperator): string;
+export declare function classLabel(iriOrPrefixedName: string): string;
+export declare function predicateLabel(iriOrPrefixedName: string): string;
+export declare function predicatePrefix(label: string): string;
+export declare function article(label: string): string;
+export declare function textSegment(text: string): NarrativeSegment;
+export declare function entitySegment(text: string, title?: string, term?: string, graph?: DatalogTerm): NarrativeSegment;
+export declare function labeledEntitySegment(term: string, kind: VariableLabel["kind"], graph?: DatalogTerm): Extract<NarrativeSegment, {
+    kind: "entity";
+}>;
+export declare function variableSegment(name: string): NarrativeSegment;
+export declare function codeSegment(text: string): NarrativeSegment;
+export declare function isEditableValueSegment(segment: NarrativeSegment): segment is EditableValueNarrativeSegment;
+export declare function narrativeSegmentsAroundEdit(segments: readonly NarrativeSegment[], activeEditId: string): readonly NarrativeSegment[];
+//# sourceMappingURL=rule-narrative-format.d.ts.map

package/dist/rules/rule-narrative-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-narrative-format.d.ts","sourceRoot":"","sources":["../../src/rules/rule-narrative-format.ts"],"names":[],"mappings":"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"}

package/dist/rules/rule-narrative-format.js

@@ -0,0 +1,75 @@
+import { compactUri } from "@manta-eu/rdf-lib/namespaces";
+import { match } from "ts-pattern";
+import { formatPropertyLabel } from "../lib/iri-labels.js";
+export const narrativeDatalogTextOptions = { stripSimpleLiteralDatatypes: true };
+export function operatorPhrase(operator) {
+    return match(operator)
+        .with(">", () => "is above")
+        .with(">=", () => "is at least")
+        .with("<", () => "is below")
+        .with("<=", () => "is at most")
+        .with("=", () => "is")
+        .with("!=", () => "is not")
+        .exhaustive();
+}
+export function classLabel(iriOrPrefixedName) {
+    return formatPropertyLabel(iriOrPrefixedName) || iriOrPrefixedName;
+}
+export function predicateLabel(iriOrPrefixedName) {
+    const label = formatPropertyLabel(iriOrPrefixedName);
+    return label ? sentenceLabel(label) : iriOrPrefixedName;
+}
+export function predicatePrefix(label) {
+    return /^\s*has(?:\s|$)/i.test(label) ? "" : "has ";
+}
+export function article(label) {
+    return /^[aeiou]/i.test(label) ? "an" : "a";
+}
+export function textSegment(text) {
+    return { kind: "text", text };
+}
+export function entitySegment(text, title, term, graph) {
+    return { kind: "entity", text, title, term, graph };
+}
+export function labeledEntitySegment(term, kind, graph) {
+    const text = match(kind)
+        .with("class", () => classLabel(term))
+        .with("predicate", () => predicateLabel(term))
+        .exhaustive();
+    return { kind: "entity", text, title: compactUri(term), term, graph };
+}
+export function variableSegment(name) {
+    return { kind: "variable", name };
+}
+export function codeSegment(text) {
+    return { kind: "code", text };
+}
+export function isEditableValueSegment(segment) {
+    return segment.kind === "value" && segment.edit !== undefined;
+}
+export function narrativeSegmentsAroundEdit(segments, activeEditId) {
+    const valueIndexes = segments.flatMap((segment, index) => (segment.kind === "value" ? [index] : []));
+    if (valueIndexes.length <= 2)
+        return segments;
+    const activeSegmentIndex = segments.findIndex((segment) => segment.kind === "value" && segment.edit?.id === activeEditId);
+    const activeValueIndex = valueIndexes.indexOf(activeSegmentIndex);
+    const firstValueSegmentIndex = valueIndexes[0];
+    if (activeValueIndex < 0 || firstValueSegmentIndex === undefined)
+        return segments;
+    const localStart = valueIndexes[Math.max(0, activeValueIndex - 1)];
+    const localEnd = valueIndexes[Math.min(valueIndexes.length - 1, activeValueIndex + 1)];
+    if (localStart === undefined || localEnd === undefined)
+        return segments;
+    return [
+        ...segments.slice(0, firstValueSegmentIndex),
+        ...(localStart > firstValueSegmentIndex ? [textSegment("… ")] : []),
+        ...segments.slice(localStart, localEnd + 1),
+        ...(localEnd < segments.length - 1 ? [textSegment(" …")] : []),
+    ];
+}
+function sentenceLabel(label) {
+    return label
+        .split(" ")
+        .map((word) => (/^[A-Z0-9]+$/.test(word) || /^\d/.test(word) ? word : word.toLowerCase()))
+        .join(" ");
+}

package/dist/rules/rule-narrative-renderer.d.ts

@@ -0,0 +1,25 @@
+import { type DatalogExpression, type DatalogRule, type DatalogTerm, type LiteralTerm } from "@manta-eu/datalog-parser";
+import { type NarrativeSegment, type ValueNarrativeSegment } from "./rule-narrative-format.js";
+type LiteralSegmentOptions = {
+    editable?: boolean;
+};
+export type RuleNarrativeRendererOptions = {
+    plainValues?: boolean;
+};
+type ExpressionSegmentOptions = {
+    labelVariables?: boolean;
+    inline?: boolean;
+};
+export declare function comparisonSegments(expression: DatalogExpression, renderExpression: (expression: DatalogExpression) => NarrativeSegment[]): NarrativeSegment[] | null;
+export declare function createRuleNarrativeRenderer(rule: DatalogRule, rendererOptions?: RuleNarrativeRendererOptions): {
+    context: import("./rule-narrative-format.js").NarrativeContext;
+    literalSegment: (literal: LiteralTerm, options?: LiteralSegmentOptions) => ValueNarrativeSegment;
+    termSegment: (term: DatalogTerm) => NarrativeSegment;
+    graphSegments: (graph: DatalogTerm | undefined) => NarrativeSegment[];
+    expressionSegments: (expression: DatalogExpression, options?: ExpressionSegmentOptions) => NarrativeSegment[];
+    expressionListSegments: (expressions: readonly DatalogExpression[], options?: ExpressionSegmentOptions) => NarrativeSegment[];
+    variableReferenceSegments: (name: string) => NarrativeSegment[];
+};
+export type RuleNarrativeRenderer = ReturnType<typeof createRuleNarrativeRenderer>;
+export {};
+//# sourceMappingURL=rule-narrative-renderer.d.ts.map

package/dist/rules/rule-narrative-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-narrative-renderer.d.ts","sourceRoot":"","sources":["../../src/rules/rule-narrative-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EASL,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC3B,MAAM,yBAAyB,CAAC;AAEjC,KAAK,qBAAqB,GAAG;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AA+BF,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,iBAAiB,EAC7B,gBAAgB,EAAE,CAAC,UAAU,EAAE,iBAAiB,KAAK,gBAAgB,EAAE,GACtE,gBAAgB,EAAE,GAAG,IAAI,CAW3B;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,WAAW,EAAE,eAAe,GAAE,4BAAiC;;8BAI/E,WAAW,YAAY,qBAAqB,KAAG,qBAAqB;wBASzE,WAAW,KAAG,gBAAgB;2BAY3B,WAAW,GAAG,SAAS,KAAG,gBAAgB,EAAE;qCAM5D,iBAAiB,YACpB,wBAAwB,KAChC,gBAAgB,EAAE;0CA+GN,SAAS,iBAAiB,EAAE,YAChC,wBAAwB,KAChC,gBAAgB,EAAE;sCA1IoB,MAAM,KAAG,gBAAgB,EAAE;EA0JrE;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC"}