@manta-eu/react 0.1.9 → 0.1.10

package/src/rules/datalog-ast/DatalogTermComponent.tsx

@@ -0,0 +1,85 @@
+/* eslint-disable @manta-eu/no-theme-primitive-colors */
+
+import type { DatalogTerm } from "@manta-eu/datalog-parser";
+import { compactUri } from "@manta-eu/rdf-lib/namespaces";
+import { match } from "ts-pattern";
+import type { HoverState, VariableColors } from "./types";
+import { OntologyTermText } from "#ontology/OntologyTermText";
+import { cn } from "#style";
+
+type DatalogTermComponentProps = {
+  term: DatalogTerm;
+  variableColors?: VariableColors;
+  hoverState?: HoverState;
+  onVariableHover?: (varName: string | null) => void;
+};
+
+export function DatalogTermComponent(props: DatalogTermComponentProps) {
+  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 (
+          <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)}
+          >
+            ?{variable.name}
+          </span>
+        );
+      }
+      return <span className="text-[#3dd68c] font-mono whitespace-nowrap">?{variable.name}</span>;
+    })
+    .with({ type: "iri" }, (iri) => {
+      const displayValue = iri.prefixed ? compactUri(iri.value) : `<${iri.value}>`;
+      return <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 <span className="text-orange-500 font-mono">{lit.value}</span>;
+        }
+        if (isBoolean) {
+          return <span className="text-pink-500 font-mono">{lit.value}</span>;
+        }
+
+        // For other datatypes, show full form with datatype annotation
+        const compactDatatype = compactUri(lit.datatype);
+        return (
+          <span className="text-orange-500 font-mono">
+            "{lit.value}"<span className="text-gray-500 typography-tiny">^^{compactDatatype}</span>
+          </span>
+        );
+      }
+
+      // Show language-tagged literals
+      if (lit.language) {
+        return (
+          <span className="text-orange-500 font-mono">
+            "{lit.value}"<span className="text-gray-500">@{lit.language}</span>
+          </span>
+        );
+      }
+
+      // Plain string literals
+      return <span className="text-orange-500 font-mono">"{lit.value}"</span>;
+    })
+    .with({ type: "blank" }, (blank) => <span className="text-gray-500 font-mono">_:{blank.label}</span>)
+    .exhaustive();
+}

package/src/rules/datalog-ast/index.ts

@@ -0,0 +1,6 @@
+export { DatalogAtomComponent } from "./DatalogAtomComponent";
+export { DatalogBodyFormulaComponent } from "./DatalogBodyFormulaComponent";
+export { DatalogTermComponent } from "./DatalogTermComponent";
+export { renderExpressionWithVariables } from "./DatalogExpressionRenderer";
+export { extractVariables, assignVariableColors, getRelatedVariables } from "./utils";
+export type { VariableColors, HoverState } from "./types";

package/src/rules/datalog-ast/types.ts

@@ -0,0 +1,6 @@
+export type VariableColors = Record<string, string>;
+
+export type HoverState = {
+  hoveredVar: string | null;
+  relatedVars: Set<string>;
+};

package/src/rules/datalog-ast/utils.ts

@@ -0,0 +1,21 @@
+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",
+] as const;
+
+export function assignVariableColors(variables: string[]): Record<string, string> {
+  const colors: Record<string, string> = {};
+  variables.filter(isPresent).forEach((varName, index) => {
+    colors[varName] = variableColors[index % variableColors.length] || "text-default-foreground";
+  });
+  return colors;
+}

package/src/rules/datalog-cache.ts

@@ -0,0 +1,67 @@
+import { parseDatalogRule, parseGroundedDatalogRule, type DatalogRule } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { createStore } from "zustand/vanilla";
+
+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;
+
+const maxEntries = 500;
+
+export type RuleParser = (rule: string) => DatalogRule;
+
+function parseRule(parse: RuleParser, rule: string): ParseResult {
+  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: RuleParser = parseDatalogRule) {
+  return createStore<DatalogCacheStore>()((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: string) {
+  return datalogCacheStore.getState().parse(rule);
+}
+
+export function parseGroundedDatalogRuleCached(rule: string) {
+  return groundedDatalogCacheStore.getState().parse(rule);
+}

package/src/rules/index.ts

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

package/src/rules/rule-narrative-aggregates.ts

@@ -0,0 +1,95 @@
+import type {
+  AggregateBinding,
+  BinaryAggregateBinding,
+  DatalogExpression,
+  ExpressionAggregateBinding,
+  PercentileAggregateBinding,
+  UnaryAggregateBinding,
+} from "@manta-eu/datalog-parser";
+import { match, P } from "ts-pattern";
+import { codeSegment, textSegment, type NarrativeSegment } from "./rule-narrative-format";
+
+const ordinalSuffixes = { one: "st", two: "nd", few: "rd", other: "th" } as const;
+const ordinalRules = new Intl.PluralRules("en-US", { type: "ordinal" });
+
+export function percentileLabel(percentile: string): string {
+  const percent = Number((Number(percentile) * 100).toPrecision(12));
+  if (!Number.isInteger(percent)) return `${percent}th percentile`;
+  const category = ordinalRules.select(percent);
+  return `${percent}${category in ordinalSuffixes ? ordinalSuffixes[category as keyof typeof ordinalSuffixes] : "th"} percentile`;
+}
+
+export function aggregateBindingSegments(
+  binding: AggregateBinding,
+  expressionSegments: (expression: DatalogExpression) => NarrativeSegment[],
+): NarrativeSegment[] {
+  const operand = (expression: AggregateBinding["expression"]): NarrativeSegment[] => {
+    if (expression === "*") return [codeSegment("*")];
+    const segments = expressionSegments(expression);
+    return expression.type === "term" ? segments : [codeSegment("("), ...segments, codeSegment(")")];
+  };
+
+  const unary = (binding: UnaryAggregateBinding | PercentileAggregateBinding, phrase: string): NarrativeSegment[] => [
+    textSegment(phrase),
+    ...(binding.distinct ? [textSegment("distinct values of ")] : []),
+    ...operand(binding.expression),
+  ];
+
+  const countExtreme = (binding: UnaryAggregateBinding, order: "lowest" | "highest"): NarrativeSegment[] => [
+    textSegment("the number of matches where "),
+    ...operand(binding.expression),
+    textSegment(` is ${order}${binding.distinct ? " (ignoring duplicate values)" : ""}`),
+  ];
+
+  const selection = (
+    binding: BinaryAggregateBinding,
+    order: "lowest" | "highest",
+    tieOrder: "lowest" | "highest",
+  ): NarrativeSegment[] => [
+    ...operand(binding.expression),
+    textSegment(" where "),
+    ...operand(binding.secondExpression),
+    textSegment(` is ${order} (ties choose the ${tieOrder} result)`),
+    ...(binding.distinct ? [textSegment(" (ignoring duplicate pairs)")] : []),
+  ];
+
+  const percentile = (binding: PercentileAggregateBinding, phrase: string): NarrativeSegment[] =>
+    unary(binding, `${phrase}${percentileLabel(binding.percentile)} of `);
+
+  return match(binding)
+    .returnType<NarrativeSegment[]>()
+    .with({ function: P.optional(undefined) }, (binding: ExpressionAggregateBinding) =>
+      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: "VAR_POP" }, (binding) => unary(binding, "the population variance of "))
+    .with({ function: "VAR_SAMP" }, (binding) => unary(binding, "the sample variance of "))
+    .with({ function: "STDDEV_POP" }, (binding) => unary(binding, "the population standard deviation of "))
+    .with({ function: "STDDEV_SAMP" }, (binding) => unary(binding, "the sample standard deviation of "))
+    .with({ function: "MODE" }, (binding) => [
+      ...unary(binding, "the most common of "),
+      textSegment(" (ties choose the lowest value)"),
+    ])
+    .with({ function: "PERCENTILE_CONT" }, (binding) => percentile(binding, "the interpolated "))
+    .with({ function: "PERCENTILE_DISC" }, (binding) => percentile(binding, "the nearest value to the "))
+    .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/src/rules/rule-narrative-context.ts

@@ -0,0 +1,66 @@
+import {
+  classAssertionFromAtom,
+  isDatalogAtom,
+  isVariableTerm,
+  mintedVariableNames as ruleMintedVariableNames,
+  propertyAssertionFromAtom,
+  variableNamesFromAtom,
+  type DatalogBodyFormula,
+  type DatalogRule,
+} from "@manta-eu/datalog-parser";
+import { isOwlNothing } from "@manta-eu/rdf-lib/namespaces";
+import { match } from "ts-pattern";
+import type { NarrativeContext, VariableLabel } from "./rule-narrative-format";
+
+export function buildNarrativeContext(rule: DatalogRule): NarrativeContext {
+  const entityVariableNames = new Set<string>();
+  const outputVariableNames = new Set<string>();
+  const mintedVariableNames = ruleMintedVariableNames(rule);
+  const variableLabels = new Map<string, VariableLabel>();
+  const setLabel = (name: string, label: VariableLabel): void => {
+    if (!variableLabels.has(name)) variableLabels.set(name, label);
+  };
+
+  const visit = (formula: DatalogBodyFormula): void => {
+    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: "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,
+    mintedVariableNames,
+    variableLabels,
+  };
+}

package/src/rules/rule-narrative-filters.ts

@@ -0,0 +1,142 @@
+import {
+  isVariableTerm,
+  literalSetComparisonFromExpression,
+  type DatalogExpression,
+  type DatalogFilter,
+} from "@manta-eu/datalog-parser";
+import { match, P } from "ts-pattern";
+import { textSegment, type NarrativeRow, type NarrativeSegment } from "./rule-narrative-format";
+import { comparisonSegments, type RuleNarrativeRenderer } from "./rule-narrative-renderer";
+
+export function buildFilterRow(filter: DatalogFilter, renderer: RuleNarrativeRenderer): NarrativeRow {
+  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: DatalogExpression, renderer: RuleNarrativeRenderer): NarrativeRow | null {
+  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): NarrativeSegment[] => [
+        ...(index > 0 ? [textSegment(", ")] : []),
+        renderer.literalSegment(literal),
+      ]),
+    ],
+  };
+}
+
+const textMatchPhrases: Record<string, string> = {
+  CONTAINS: " contains ",
+  STRSTARTS: " starts with ",
+  STRENDS: " ends with ",
+};
+
+const caseFoldingFunctions = new Set(["LCASE", "UCASE"]);
+
+function withoutCaseFolding(expression: DatalogExpression): DatalogExpression {
+  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: {
+  haystack: DatalogExpression;
+  phrase: string;
+  needle: DatalogExpression;
+  ignoresCase: boolean;
+  renderer: RuleNarrativeRenderer;
+}): NarrativeRow {
+  const { haystack, phrase, needle, ignoresCase, renderer } = args;
+
+  return {
+    segments: [
+      ...expressionValueSegments(haystack, renderer),
+      textSegment(phrase),
+      ...expressionValueSegments(needle, renderer),
+      ...(ignoresCase ? [textSegment(", ignoring case")] : []),
+    ],
+  };
+}
+
+function regexFlagsText(flags: DatalogExpression | undefined): string | undefined {
+  if (!flags) return "";
+
+  return match(flags)
+    .with({ type: "term", term: { type: "literal", value: "i" } }, () => "i")
+    .otherwise(() => undefined);
+}
+
+function buildTextMatchFilterRow(expression: DatalogExpression, renderer: RuleNarrativeRenderer): NarrativeRow | null {
+  return match(expression)
+    .returnType<NarrativeRow | null>()
+    .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: DatalogExpression, renderer: RuleNarrativeRenderer): NarrativeSegment[] {
+  return renderer.expressionSegments(expression, {
+    labelVariables: true,
+    inline: true,
+  });
+}

package/src/rules/rule-narrative-format.ts

@@ -0,0 +1,153 @@
+import type { ComparisonOperator, DatalogTerm, SourceSpan } from "@manta-eu/datalog-parser";
+import { compactUri } from "@manta-eu/rdf-lib/namespaces";
+import { match } from "ts-pattern";
+import { formatPropertyLabel } from "../lib/iri-labels";
+
+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>;
+  mintedVariableNames: ReadonlySet<string>;
+  variableLabels: ReadonlyMap<string, VariableLabel>;
+};
+
+export const narrativeDatalogTextOptions = { stripSimpleLiteralDatatypes: true } as const;
+
+export function operatorPhrase(operator: ComparisonOperator): string {
+  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: string): string {
+  return formatPropertyLabel(iriOrPrefixedName) || iriOrPrefixedName;
+}
+
+export function predicateLabel(iriOrPrefixedName: string): string {
+  const label = formatPropertyLabel(iriOrPrefixedName);
+  return label ? sentenceLabel(label) : iriOrPrefixedName;
+}
+
+export function predicatePrefix(label: string): string {
+  return /^\s*has(?:\s|$)/i.test(label) ? "" : "has ";
+}
+
+export function article(label: string): string {
+  return /^[aeiou]/i.test(label) ? "an" : "a";
+}
+
+export function textSegment(text: string): NarrativeSegment {
+  return { kind: "text", text };
+}
+
+export function entitySegment(text: string, title?: string, term?: string, graph?: DatalogTerm): NarrativeSegment {
+  return { kind: "entity", text, title, term, graph };
+}
+
+export function labeledEntitySegment(
+  term: string,
+  kind: VariableLabel["kind"],
+  graph?: DatalogTerm,
+): Extract<NarrativeSegment, { kind: "entity" }> {
+  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: string): NarrativeSegment {
+  return { kind: "variable", name };
+}
+
+export function codeSegment(text: string): NarrativeSegment {
+  return { kind: "code", text };
+}
+
+export function isEditableValueSegment(segment: NarrativeSegment): segment is EditableValueNarrativeSegment {
+  return segment.kind === "value" && segment.edit !== undefined;
+}
+
+export function narrativeSegmentsAroundEdit(
+  segments: readonly NarrativeSegment[],
+  activeEditId: string,
+): readonly NarrativeSegment[] {
+  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: string): string {
+  return label
+    .split(" ")
+    .map((word) => (/^[A-Z0-9]+$/.test(word) || /^\d/.test(word) ? word : word.toLowerCase()))
+    .join(" ");
+}