@manta-eu/react 0.1.0

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

@@ -0,0 +1,186 @@
+import { binaryOperandNeedsParentheses, invertComparisonOperator, isBareNumericLiteral, isComparisonOperator, isNumericLiteral, isXsdDatatype, literalToDisplayText, unaryOperandNeedsParentheses, variableNameFromTermExpression, } from "@manta-eu/datalog-parser";
+import { compactUri } from "@manta-eu/rdf-lib/namespaces";
+import { match, P } from "ts-pattern";
+import { formatMeasureValue } from "../lib/measure.js";
+import { buildNarrativeContext } from "./rule-narrative-context.js";
+import { classLabel, codeSegment, entitySegment, labeledEntitySegment, operatorPhrase, textSegment, variableSegment, } from "./rule-narrative-format.js";
+function literalSegment(literal, options = {}, plainValues = false) {
+    const kind = editableKind(literal);
+    const replacementSpan = literal.valueSpan ?? literal.termSpan;
+    const displayText = literalToDisplayText(literal);
+    const segment = {
+        kind: "value",
+        text: plainValues && isNumericLiteral(literal) ? formatMeasureValue(displayText) : displayText,
+        title: literal.datatype ? compactUri(literal.datatype) : undefined,
+    };
+    if (plainValues || options.editable === false || !kind || !replacementSpan)
+        return segment;
+    segment.edit = {
+        id: `${kind}:${replacementSpan.start}:${replacementSpan.end}`,
+        kind,
+        value: kind === "number" ? segment.text : literal.value,
+        replacementSpan,
+    };
+    return segment;
+}
+function valuePreservingCast(functionName) {
+    return isXsdDatatype(functionName, "decimal") || isXsdDatatype(functionName, "double");
+}
+export function comparisonSegments(expression, renderExpression) {
+    if (expression.type !== "binary" || !isComparisonOperator(expression.operator))
+        return null;
+    const { left, right, operator } = expression;
+    const invert = !variableNameFromTermExpression(left) && variableNameFromTermExpression(right);
+    return [
+        ...binaryOperandSegments(invert ? right : left, operator, "left", renderExpression),
+        textSegment(` ${operatorPhrase(invert ? invertComparisonOperator(operator) : operator)} `),
+        ...binaryOperandSegments(invert ? left : right, operator, "right", renderExpression),
+    ];
+}
+export function createRuleNarrativeRenderer(rule, rendererOptions = {}) {
+    const context = buildNarrativeContext(rule);
+    const plainValues = rendererOptions.plainValues === true;
+    function renderLiteral(literal, options) {
+        return literalSegment(literal, options, plainValues);
+    }
+    function variableReferenceSegments(name) {
+        const label = context.variableLabels.get(name);
+        return label ? [labeledEntitySegment(label.term, label.kind, label.graph)] : [variableSegment(name)];
+    }
+    function termSegment(term) {
+        return match(term)
+            .returnType()
+            .with({ type: "variable" }, (variable) => variableSegment(variable.name))
+            .with({ type: "literal" }, (literal) => renderLiteral(literal))
+            .with({ type: "iri" }, (iri) => entitySegment(classLabel(iri.value), iri.prefixed ? iri.value : compactUri(iri.value), iri.value))
+            .with({ type: "blank" }, (blank) => codeSegment(`_:${blank.label}`))
+            .exhaustive();
+    }
+    function graphSegments(graph) {
+        if (!graph)
+            return [];
+        return [textSegment(" in "), termSegment(graph)];
+    }
+    function expressionSegments(expression, options = {}) {
+        const visit = (current) => {
+            const conditional = conditionalSegments(current);
+            if (conditional)
+                return parenthesizeSegments(conditional);
+            return match(current)
+                .with({ type: "binary" }, (binary) => [
+                ...binaryOperandSegments(binary.left, binary.operator, "left", visit),
+                codeSegment(` ${binary.operator} `),
+                ...binaryOperandSegments(binary.right, binary.operator, "right", visit),
+            ])
+                .with({ type: "unary" }, (unary) => {
+                if ((unary.operator === "+" || unary.operator === "-") &&
+                    unary.operand.type === "term" &&
+                    unary.operand.term.type === "literal" &&
+                    isBareNumericLiteral(unary.operand.term)) {
+                    return [codeSegment(unary.operator), renderLiteral(unary.operand.term, { editable: false })];
+                }
+                return [codeSegment(unary.operator), ...unaryOperandSegments(unary.operand)];
+            })
+                .with({ type: "term" }, (term) => {
+                if (term.term.type === "literal") {
+                    return [renderLiteral(term.term)];
+                }
+                const variableName = variableNameFromTermExpression(term);
+                if (variableName && options.labelVariables) {
+                    return variableReferenceSegments(variableName);
+                }
+                return [termSegment(term.term)];
+            })
+                .with({ type: "function", args: [P.any] }, (fn) => plainValues && valuePreservingCast(fn.name), (fn) => visit(fn.args[0]))
+                .with({ type: "function" }, (fn) => [
+                codeSegment(`${fn.name}(`),
+                ...interleaveSegments(fn.args.map((argument) => visit(argument)), codeSegment(", ")),
+                codeSegment(")"),
+            ])
+                .with({ type: "in" }, (inExpression) => [
+                ...visit(inExpression.expression),
+                codeSegment(` ${inExpression.negated ? "NOT IN" : "IN"} (`),
+                ...interleaveSegments(inExpression.list.map((item) => visit(item)), codeSegment(", ")),
+                codeSegment(")"),
+            ])
+                .exhaustive();
+        };
+        const conditionalSegments = (current) => {
+            if (current.type !== "function" || current.name !== "IF" || current.args.length !== 3)
+                return null;
+            const [condition, whenTrue, whenFalse] = current.args;
+            if (!condition || !whenTrue || !whenFalse)
+                return null;
+            return [
+                ...visit(whenTrue),
+                textSegment(" when "),
+                ...conditionSegments(condition),
+                textSegment(", otherwise "),
+                ...(conditionalSegments(whenFalse) ?? visit(whenFalse)),
+            ];
+        };
+        const conditionSegments = (current) => {
+            const comparison = comparisonSegments(current, visit);
+            if (comparison)
+                return comparison;
+            if (current.type === "binary" && (current.operator === "&&" || current.operator === "||")) {
+                return [
+                    ...conditionOperandSegments(current.left, current.operator),
+                    textSegment(current.operator === "&&" ? " and " : " or "),
+                    ...conditionOperandSegments(current.right, current.operator),
+                ];
+            }
+            if (current.type === "unary" && current.operator === "!") {
+                return [textSegment("not "), ...unaryOperandSegments(current.operand, conditionSegments)];
+            }
+            return visit(current);
+        };
+        const conditionOperandSegments = (operand, parentOperator) => {
+            const segments = conditionSegments(operand);
+            // Prose should not rely on readers knowing that AND binds more tightly than OR.
+            const mixedOperators = operand.type === "binary" &&
+                (operand.operator === "&&" || operand.operator === "||") &&
+                operand.operator !== parentOperator;
+            return mixedOperators ? parenthesizeSegments(segments) : segments;
+        };
+        const unaryOperandSegments = (operand, render = visit) => {
+            const segments = render(operand);
+            return unaryOperandNeedsParentheses(operand) ? parenthesizeSegments(segments) : segments;
+        };
+        // Only a standalone IF and its otherwise chain can safely omit parentheses.
+        if (options.inline)
+            return visit(expression);
+        return conditionalSegments(expression) ?? visit(expression);
+    }
+    function expressionListSegments(expressions, options = {}) {
+        return interleaveSegments(expressions.map((expression) => expressionSegments(expression, { ...options, inline: true })), codeSegment(", "));
+    }
+    return {
+        context,
+        literalSegment: renderLiteral,
+        termSegment,
+        graphSegments,
+        expressionSegments,
+        expressionListSegments,
+        variableReferenceSegments,
+    };
+}
+function editableKind(literal) {
+    if (isBareNumericLiteral(literal))
+        return "number";
+    if (isXsdDatatype(literal.datatype, "date"))
+        return "date";
+    if (isXsdDatatype(literal.datatype, "dateTime") && literal.value.endsWith("Z"))
+        return "dateTime";
+    return null;
+}
+function interleaveSegments(items, separator) {
+    return items.flatMap((item, index) => (index === 0 ? item : [separator, ...item]));
+}
+function parenthesizeSegments(segments) {
+    return [codeSegment("("), ...segments, codeSegment(")")];
+}
+function binaryOperandSegments(operand, parentOperator, side, render) {
+    const segments = render(operand);
+    return binaryOperandNeedsParentheses(operand, parentOperator, side) ? parenthesizeSegments(segments) : segments;
+}

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

@@ -0,0 +1,15 @@
+import { type DatalogRule } from "@manta-eu/datalog-parser";
+import { type EditableRuleValue, type NarrativeSegment, type TaggedNarrativeRow } from "./rule-narrative-format.js";
+export type { NarrativeContext, NarrativeRow, NarrativeSegment, NarrativeTag, TaggedNarrativeRow, } from "./rule-narrative-format.js";
+export type RuleSetupModel = {
+    ast: DatalogRule;
+    rows: TaggedNarrativeRow[];
+    editableValues: EditableValueEntry[];
+};
+export type EditableValueEntry = {
+    edit: EditableRuleValue;
+    segments: readonly NarrativeSegment[];
+};
+export declare function buildRuleSetupModel(rule: DatalogRule): RuleSetupModel;
+export declare function buildRuleNarrative(rule: DatalogRule): TaggedNarrativeRow[];
+//# sourceMappingURL=rule-narrative.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule-narrative.d.ts","sourceRoot":"","sources":["../../src/rules/rule-narrative.ts"],"names":[],"mappings":"AAAA,OAAO,EAgBL,KAAK,WAAW,EAMjB,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EASL,KAAK,iBAAiB,EAEtB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAC;AAGjC,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,MAAM,cAAc,GAAG;IAC3B,GAAG,EAAE,WAAW,CAAC;IACjB,IAAI,EAAE,kBAAkB,EAAE,CAAC;IAC3B,cAAc,EAAE,kBAAkB,EAAE,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACvC,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,cAAc,CAGrE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,kBAAkB,EAAE,CAa1E"}

package/dist/rules/rule-narrative.js

@@ -0,0 +1,429 @@
+import { atomToDatalogText, classAssertionFromAtom, expressionToDatalogText, isDatalogAtom, isIriTerm, isVariableTerm, propertyAssertionFromAtom, simpleComparisonFromFilter, termToDatalogText, } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { isActionPlanGraphIri, isOwlNothing } from "@manta-eu/rdf-lib/namespaces";
+import { match, P } from "ts-pattern";
+import { aggregateBindingSegments } from "./rule-narrative-aggregates.js";
+import { buildFilterRow } from "./rule-narrative-filters.js";
+import { article, codeSegment, isEditableValueSegment, labeledEntitySegment, narrativeDatalogTextOptions, operatorPhrase, textSegment, variableSegment, } from "./rule-narrative-format.js";
+import { createRuleNarrativeRenderer } from "./rule-narrative-renderer.js";
+export function buildRuleSetupModel(rule) {
+    const rows = buildRuleNarrative(rule);
+    return { ast: rule, rows, editableValues: collectEditableValueEntries(rows) };
+}
+export function buildRuleNarrative(rule) {
+    const renderer = createRuleNarrativeRenderer(rule);
+    const bodyRows = buildFormulaRows(rule.body, renderer);
+    const visibleBodyVariableNames = collectNarrativeVariableNames(bodyRows);
+    const headRows = groupHeadAtomsBySubject(rule.head).map((group) => buildHeadRow(group, visibleBodyVariableNames, renderer));
+    return [
+        ...bodyRows.map((row, index) => ({ ...row, tag: index === 0 ? "IF" : "AND" })),
+        ...groupHeadRowsByGraph(headRows, renderer),
+    ];
+}
+function collectNarrativeVariableNames(rows) {
+    const variableNames = new Set();
+    for (const row of rows) {
+        for (const segment of row.segments) {
+            if (segment.kind === "variable")
+                variableNames.add(segment.name);
+        }
+        if (row.children) {
+            for (const variableName of collectNarrativeVariableNames(row.children))
+                variableNames.add(variableName);
+        }
+    }
+    return variableNames;
+}
+function groupHeadAtomsBySubject(atoms) {
+    const groups = new Map();
+    atoms.forEach((atom, index) => {
+        const deletion = actionPlanDeletionFromAtom(atom);
+        if (deletion) {
+            groups.set(`ungrouped:${index}`, { type: "deletion", deletion });
+            return;
+        }
+        const normalized = normalizeNarrativeAtom(atom);
+        if (normalized.type !== "class" && normalized.type !== "property") {
+            groups.set(`ungrouped:${index}`, normalized);
+            return;
+        }
+        const subject = normalized.type === "class" ? normalized.instance : normalized.subject;
+        const graph = normalized.graph;
+        // Equal literal subjects still refer to independently editable source spans.
+        const key = subject.type !== "literal"
+            ? JSON.stringify([graph ? termToDatalogText(graph) : null, termToDatalogText(subject)])
+            : `ungrouped:${index}`;
+        const group = groups.get(key);
+        if (group?.type === "subject")
+            group.atoms.push(normalized);
+        else
+            groups.set(key, { type: "subject", subject, graph, atoms: [normalized] });
+    });
+    return [...groups.values()];
+}
+function buildSubjectHeadRow(group, renderer) {
+    const { subject, graph, atoms } = group;
+    const classAtom = atoms.find((atom) => atom.type === "class");
+    const segments = classAtom
+        ? classHeadSegments(classAtom, renderer)
+        : [textSegment("For "), renderer.termSegment(subject)];
+    const editContext = [
+        textSegment("For "),
+        renderer.termSegment(subject),
+        ...renderer.graphSegments(graph),
+        textSegment(": "),
+    ];
+    const children = atoms
+        .filter((atom) => atom !== classAtom)
+        .map((atom) => {
+        const segments = match(atom)
+            .with({ type: "class" }, (assertion) => [
+            textSegment("Also classified as "),
+            labeledEntitySegment(assertion.className, "class", assertion.graph),
+        ])
+            .with({ type: "property" }, (assertion) => predicateHeadSegments(assertion, renderer))
+            .exhaustive();
+        return { segments, editContext: [...editContext, ...segments] };
+    });
+    if (!isPresent(children))
+        return { graph, segments };
+    return { graph, segments: [...segments, textSegment(":")], children };
+}
+function groupHeadRowsByGraph(rows, renderer) {
+    const groupedRows = [];
+    const groupsByGraph = new Map();
+    for (const row of rows) {
+        if (!row.graph) {
+            groupedRows.push({ ...row, tag: "DO" });
+            continue;
+        }
+        const graphKey = termToDatalogText(row.graph);
+        const existingGroup = groupsByGraph.get(graphKey);
+        const { graph: _graph, ...child } = row;
+        if (existingGroup) {
+            existingGroup.children?.push(child);
+            continue;
+        }
+        const group = {
+            tag: "DO",
+            graph: row.graph,
+            segments: [textSegment("Within "), renderer.termSegment(row.graph), textSegment(":")],
+            children: [child],
+        };
+        groupsByGraph.set(graphKey, group);
+        groupedRows.push(group);
+    }
+    return groupedRows;
+}
+function collectEditableValueEntries(rows) {
+    const entries = [];
+    for (const row of rows) {
+        for (const segment of row.segments) {
+            if (isEditableValueSegment(segment)) {
+                entries.push({ edit: segment.edit, segments: row.editContext ?? row.segments });
+            }
+        }
+        if (row.children)
+            entries.push(...collectEditableValueEntries(row.children));
+    }
+    return entries;
+}
+function buildFormulaRows(formulas, renderer) {
+    const primary = primaryVariableName(formulas);
+    const comparisonsByVariable = new Map();
+    for (const formula of formulas) {
+        if (formula.type !== "filter")
+            continue;
+        const comparison = simpleComparisonFromFilter(formula);
+        if (!comparison)
+            continue;
+        const existing = comparisonsByVariable.get(comparison.variableName) ?? [];
+        existing.push({
+            filter: formula,
+            phrase: operatorPhrase(comparison.operator),
+            literal: comparison.literal,
+        });
+        comparisonsByVariable.set(comparison.variableName, existing);
+    }
+    const consumedFilters = new Set();
+    const mergedByFormula = new Map();
+    for (const formula of formulas.filter(isDatalogAtom)) {
+        const assertion = propertyAssertionFromAtom(formula);
+        if (!assertion || !isVariableTerm(assertion.object))
+            continue;
+        const objectVariable = assertion.object.name;
+        const available = (comparisonsByVariable.get(objectVariable) ?? []).filter((entry) => !consumedFilters.has(entry.filter));
+        if (!isPresent(available))
+            continue;
+        available.forEach((entry) => consumedFilters.add(entry.filter));
+        mergedByFormula.set(formula, available);
+    }
+    const rows = [];
+    for (const formula of formulas) {
+        if (formula.type === "filter") {
+            if (!consumedFilters.has(formula))
+                rows.push(buildFilterRow(formula, renderer));
+            continue;
+        }
+        rows.push(buildBodyRow(formula, primary, mergedByFormula.get(formula) ?? [], renderer));
+    }
+    return rows;
+}
+function buildBodyRow(formula, primary, merged, renderer) {
+    return match(formula)
+        .with({ type: P.union("class", "property", "triple", "general") }, (atom) => buildBodyAtomRow(normalizeNarrativeAtom(atom), primary, merged, renderer))
+        .with({ type: "negation" }, (negation) => buildNegationRow(negation, renderer))
+        .with({ type: "aggregate" }, (aggregate) => buildAggregateRow(aggregate, renderer))
+        .with({ type: "bind" }, (bind) => {
+        const row = {
+            segments: [
+                textSegment("Calculate "),
+                ...renderer.variableReferenceSegments(bind.variable),
+                textSegment(" as "),
+                ...renderer.expressionSegments(bind.expression),
+            ],
+        };
+        if (!renderer.context.outputVariableNames.has(bind.variable))
+            row.muted = true;
+        return row;
+    })
+        .with({ type: "skolem" }, (skolem) => {
+        const lastArg = skolem.args[skolem.args.length - 1];
+        const inputs = skolem.args.slice(0, -1);
+        if (lastArg?.type === "term" && isVariableTerm(lastArg.term)) {
+            const segments = [textSegment("Create entity "), variableSegment(lastArg.term.name)];
+            if (isPresent(inputs)) {
+                segments.push(textSegment(" from "), ...renderer.expressionListSegments(inputs));
+            }
+            return { muted: true, segments };
+        }
+        return {
+            muted: true,
+            segments: [
+                codeSegment(`SKOLEM(${skolem.args.map((arg) => expressionToDatalogText(arg, narrativeDatalogTextOptions)).join(", ")})`),
+            ],
+        };
+    })
+        .exhaustive();
+}
+function normalizeNarrativeAtom(atom) {
+    const classAssertion = classAssertionFromAtom(atom);
+    if (classAssertion)
+        return { type: "class", ...classAssertion };
+    const propertyAssertion = propertyAssertionFromAtom(atom);
+    return propertyAssertion ? { type: "property", ...propertyAssertion } : atom;
+}
+function buildBodyAtomRow(atom, primary, merged, renderer) {
+    return match(atom)
+        .with({ type: "class" }, (assertion) => buildClassBodyRow(assertion, renderer))
+        .with({ type: "property" }, (assertion) => buildPredicateRow(assertion, primary, merged, renderer))
+        .with({ type: "triple" }, (triple) => ({
+        segments: [...tripleTermSegments(triple, renderer), ...renderer.graphSegments(triple.graph)],
+    }))
+        .with({ type: "general" }, generalAtomRow)
+        .exhaustive();
+}
+function buildAggregateRow(aggregate, renderer) {
+    const children = buildFormulaRows(aggregate.atoms, renderer);
+    for (const binding of aggregate.bindings ?? []) {
+        children.push({
+            segments: [
+                textSegment("Calculate "),
+                variableSegment(binding.variable),
+                textSegment(" as "),
+                ...aggregateBindingSegments(binding, renderer.expressionSegments),
+            ],
+        });
+    }
+    if (isPresent(aggregate.onVars)) {
+        const segments = [textSegment("For each group with the same ")];
+        aggregate.onVars.forEach((name, index, names) => {
+            if (index > 0)
+                segments.push(textSegment(index === names.length - 1 ? " and " : ", "));
+            segments.push(variableSegment(name));
+        });
+        segments.push(textSegment(":"));
+        return { segments, children };
+    }
+    return { segments: [textSegment("Across all matches:")], children };
+}
+function buildNegationRow(negation, renderer) {
+    const anchor = negationAnchor(negation, renderer);
+    const formulas = anchor ? negation.formulas.filter((formula) => formula !== anchor.formula) : negation.formulas;
+    const children = buildFormulaRows(formulas, renderer);
+    const row = {
+        segments: anchor?.segments ?? [textSegment("No matching case exists where:")],
+    };
+    if (isPresent(children)) {
+        if (anchor)
+            row.segments.push(textSegment(" where:"));
+        row.children = children;
+    }
+    return row;
+}
+function negationAnchor(negation, renderer) {
+    const existentialVars = new Set(negation.existentialVars ?? []);
+    if (existentialVars.size === 0)
+        return null;
+    const atoms = negation.formulas.filter(isDatalogAtom);
+    for (const formula of atoms) {
+        const assertion = classAssertionFromAtom(formula);
+        if (!assertion || !isNamedVariable(assertion.instance, existentialVars))
+            continue;
+        return {
+            formula,
+            segments: [
+                textSegment("No matching "),
+                labeledEntitySegment(assertion.className, "class", assertion.graph),
+                textSegment(" exists"),
+                ...renderer.graphSegments(assertion.graph),
+            ],
+        };
+    }
+    for (const formula of atoms) {
+        const assertion = propertyAssertionFromAtom(formula);
+        if (!assertion || !isNamedVariable(assertion.object, existentialVars))
+            continue;
+        return {
+            formula,
+            segments: [
+                textSegment("No "),
+                labeledEntitySegment(assertion.predicate, "predicate", assertion.graph),
+                textSegment(" exists"),
+                ...renderer.graphSegments(assertion.graph),
+            ],
+        };
+    }
+    return null;
+}
+function buildPredicateRow(assertion, primary, merged, renderer) {
+    const { subject, object, graph } = assertion;
+    const predicate = labeledEntitySegment(assertion.predicate, "predicate", graph);
+    const showSubject = !isPrimaryTerm(subject, primary);
+    const segments = [];
+    if (isPresent(merged) && isVariableTerm(object)) {
+        segments.push(predicate);
+        if (showSubject)
+            segments.push(textSegment(" of "), renderer.termSegment(subject));
+        merged.forEach((comparison, index) => {
+            segments.push(textSegment(`${index === 0 ? "" : " and"} ${comparison.phrase} `));
+            segments.push(renderer.literalSegment(comparison.literal));
+        });
+    }
+    else if (isVariableTerm(object)) {
+        if (showSubject)
+            segments.push(renderer.termSegment(subject), textSegment(" "));
+        segments.push({ ...predicate, prefix: "has" }, textSegment(" "), variableSegment(object.name));
+    }
+    else {
+        segments.push(predicate);
+        if (showSubject)
+            segments.push(textSegment(" of "), renderer.termSegment(subject));
+        segments.push(textSegment(" is "), renderer.termSegment(object));
+    }
+    segments.push(...renderer.graphSegments(graph));
+    return { segments };
+}
+function buildClassBodyRow(assertion, renderer) {
+    const { instance, graph } = assertion;
+    const classSegment = labeledEntitySegment(assertion.className, "class", graph);
+    const segments = [textSegment(`There is ${article(classSegment.text)} `), classSegment];
+    if (renderer.context.showEntityVariables && isVariableTerm(instance)) {
+        segments.push(textSegment(" "), variableSegment(instance.name));
+    }
+    else if (!isVariableTerm(instance)) {
+        segments.push(textSegment(" "), renderer.termSegment(instance));
+    }
+    segments.push(...renderer.graphSegments(graph));
+    return { segments };
+}
+function buildHeadRow(group, visibleBodyVariableNames, renderer) {
+    return match(group)
+        .with({ type: "subject" }, (subject) => buildSubjectHeadRow(subject, renderer))
+        .with({ type: "deletion" }, ({ deletion }) => ({
+        graph: deletion.graph,
+        segments: deletionSegments(deletion.subject, visibleBodyVariableNames, renderer),
+    }))
+        .with({ type: "triple" }, (triple) => ({
+        graph: triple.graph,
+        segments: [textSegment("Set "), ...tripleTermSegments(triple, renderer)],
+    }))
+        .with({ type: "general" }, generalAtomRow)
+        .exhaustive();
+}
+function tripleTermSegments(triple, renderer) {
+    return [
+        renderer.termSegment(triple.subject),
+        textSegment(" "),
+        renderer.termSegment(triple.predicate),
+        textSegment(" "),
+        renderer.termSegment(triple.object),
+    ];
+}
+function generalAtomRow(general) {
+    return { segments: [codeSegment(atomToDatalogText(general))] };
+}
+function classHeadSegments(assertion, renderer) {
+    const classSegment = labeledEntitySegment(assertion.className, "class");
+    const { instance } = assertion;
+    if (isVariableTerm(instance) && renderer.context.skolemVariableNames.has(instance.name)) {
+        return [
+            textSegment("Create a new "),
+            classSegment,
+            ...(renderer.context.showEntityVariables ? [textSegment(" "), variableSegment(instance.name)] : []),
+        ];
+    }
+    return [
+        textSegment("Mark "),
+        renderer.termSegment(instance),
+        textSegment(` as ${article(classSegment.text)} `),
+        classSegment,
+    ];
+}
+function predicateHeadSegments(assertion, renderer) {
+    return [
+        textSegment("Set "),
+        labeledEntitySegment(assertion.predicate, "predicate", assertion.graph),
+        textSegment(" to "),
+        renderer.termSegment(assertion.object),
+    ];
+}
+function deletionSegments(subject, visibleBodyVariableNames, renderer) {
+    if (isVariableTerm(subject) &&
+        !visibleBodyVariableNames.has(subject.name) &&
+        renderer.context.variableLabels.has(subject.name)) {
+        return [textSegment("Delete the "), ...renderer.variableReferenceSegments(subject.name)];
+    }
+    return [textSegment("Delete "), renderer.termSegment(subject)];
+}
+function actionPlanDeletionFromAtom(atom) {
+    const assertion = classAssertionFromAtom(atom);
+    if (!assertion ||
+        !isOwlNothing(assertion.className) ||
+        !assertion.graph ||
+        !isIriTerm(assertion.graph) ||
+        !isActionPlanGraphIri(assertion.graph.value)) {
+        return null;
+    }
+    return { subject: assertion.instance, graph: assertion.graph };
+}
+function primaryVariableName(items) {
+    const atoms = items.filter(isDatalogAtom);
+    for (const atom of atoms) {
+        const assertion = classAssertionFromAtom(atom);
+        if (assertion && isVariableTerm(assertion.instance))
+            return assertion.instance.name;
+    }
+    for (const atom of atoms) {
+        const assertion = propertyAssertionFromAtom(atom);
+        if (assertion && isVariableTerm(assertion.subject))
+            return assertion.subject.name;
+    }
+    return null;
+}
+function isPrimaryTerm(term, primary) {
+    return primary !== null && isVariableTerm(term) && term.name === primary;
+}
+function isNamedVariable(term, names) {
+    return isVariableTerm(term) && names.has(term.name);
+}

package/dist/shacl/ShaclForm.d.ts

@@ -0,0 +1,19 @@
+import type { ShaclFormElement } from "@ulb-darmstadt/shacl-form";
+import { type ReactElement, type Ref } from "react";
+import "./shacl-form-types.js";
+export type ShaclFormProps = {
+    shapes: string;
+    /** Picks the root node shape by IRI; without it the first one in the graph wins. */
+    shapeSubject?: string;
+    values?: string;
+    valuesSubject?: string;
+    language?: string;
+    viewMode?: boolean;
+    collapse?: "open" | boolean;
+    onValidityChange?: (isValid: boolean) => void;
+    /** Reads the edited graph back out: the element carries the data, no event does. */
+    formRef?: Ref<ShaclFormElement | null>;
+    className?: string;
+};
+export declare function ShaclForm(props: ShaclFormProps): ReactElement;
+//# sourceMappingURL=ShaclForm.d.ts.map

package/dist/shacl/ShaclForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaclForm.d.ts","sourceRoot":"","sources":["../../src/shacl/ShaclForm.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAwB,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACxF,OAAO,EAAqD,KAAK,YAAY,EAAE,KAAK,GAAG,EAAE,MAAM,OAAO,CAAC;AAGvG,OAAO,oBAAoB,CAAC;AAE5B,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,oFAAoF;IACpF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5B,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC9C,oFAAoF;IACpF,OAAO,CAAC,EAAE,GAAG,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAGF,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,YAAY,CAgF7D"}