@broadpaper/core 0.2.0 → 0.3.0

package/dist/index.js

@@ -879,22 +879,22 @@ var Scope = class _Scope {
   }
 };
 var FUNCTIONS = {
-  sum: ([list]) => numbers(list).reduce((a, b) => a + b, 0),
-  count: ([list]) => Array.isArray(list) ? list.length : isEmptyValue(list) ? 0 : 1,
-  avg: ([list]) => {
-    const ns = numbers(list);
+  sum: ([list2]) => numbers(list2).reduce((a, b) => a + b, 0),
+  count: ([list2]) => Array.isArray(list2) ? list2.length : isEmptyValue(list2) ? 0 : 1,
+  avg: ([list2]) => {
+    const ns = numbers(list2);
     return ns.length ? ns.reduce((a, b) => a + b, 0) / ns.length : null;
   },
-  min: ([list, ...rest]) => {
-    const ns = rest.length ? numbers([list, ...rest]) : numbers(list);
+  min: ([list2, ...rest]) => {
+    const ns = rest.length ? numbers([list2, ...rest]) : numbers(list2);
     return ns.length ? Math.min(...ns) : null;
   },
-  max: ([list, ...rest]) => {
-    const ns = rest.length ? numbers([list, ...rest]) : numbers(list);
+  max: ([list2, ...rest]) => {
+    const ns = rest.length ? numbers([list2, ...rest]) : numbers(list2);
     return ns.length ? Math.max(...ns) : null;
   },
-  first: ([list]) => Array.isArray(list) ? list[0] : list,
-  last: ([list]) => Array.isArray(list) ? list[list.length - 1] : list,
+  first: ([list2]) => Array.isArray(list2) ? list2[0] : list2,
+  last: ([list2]) => Array.isArray(list2) ? list2[list2.length - 1] : list2,
   length: ([v]) => Array.isArray(v) ? v.length : toDisplayString(v).length,
   coalesce: (args) => args.find((a) => !isEmptyValue(a)) ?? null,
   isEmpty: ([v]) => isEmptyValue(v),
@@ -933,13 +933,13 @@ function dateOf(v) {
   }
   return null;
 }
-function numbers(list) {
-  if (!Array.isArray(list)) {
-    const n = toNumber(list);
+function numbers(list2) {
+  if (!Array.isArray(list2)) {
+    const n = toNumber(list2);
     return n === null ? [] : [n];
   }
   const out = [];
-  for (const v of list) {
+  for (const v of list2) {
     const n = toNumber(v);
     if (n !== null) out.push(n);
   }
@@ -1442,8 +1442,8 @@ function defaultDocumentStyles() {
 function isTokenRef(value) {
   return typeof value === "string" && value.startsWith("$") && value.length > 1;
 }
-function resolveToken(token, theme) {
-  const path = token.slice(1).split(".");
+function resolveToken(token2, theme) {
+  const path = token2.slice(1).split(".");
   const fromTheme = walk(theme, path);
   if (typeof fromTheme === "string") return fromTheme;
   const fromDefault = walk(DEFAULT_THEME, path);
@@ -2204,6 +2204,169 @@ function humanizeKey(key) {
   return key.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
 }
 
+// src/data/pipes.ts
+function defaultPipeFor(schema) {
+  if (!schema) return null;
+  switch (schema.type) {
+    case "currency": {
+      const code = schema.currency?.trim().toUpperCase();
+      return code ? `currency:'${code}'` : "currency";
+    }
+    case "percent":
+      return "percent";
+    case "number":
+      return "number";
+    case "date":
+      return schema.format ? `date:'${escapePattern(schema.format)}'` : "date";
+    case "datetime":
+      return schema.format ? `datetime:'${escapePattern(schema.format)}'` : "datetime";
+    default:
+      return null;
+  }
+}
+function withDefaultPipe(expr, schema) {
+  const trimmed = expr.trim();
+  if (!trimmed || hasPipe(trimmed)) return trimmed;
+  if (!isPlainPath(trimmed)) return trimmed;
+  const pipe = defaultPipeFor(schema);
+  return pipe ? `${trimmed} | ${pipe}` : trimmed;
+}
+function hasPipe(expr) {
+  for (let i = 0; i < expr.length; i++) {
+    if (expr[i] !== "|") continue;
+    if (expr[i + 1] === "|") {
+      i++;
+      continue;
+    }
+    if (expr[i - 1] === "|") continue;
+    return true;
+  }
+  return false;
+}
+function isPlainPath(expr) {
+  return /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[\d+\])*$/.test(expr.trim());
+}
+function escapePattern(pattern) {
+  return pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
+// src/data/calculation.ts
+function calcPaths(calc) {
+  const out = [];
+  const add = (term) => {
+    if (term.kind === "field" || term.kind === "aggregate") out.push(term.path);
+  };
+  add(calc.start);
+  for (const step of calc.steps) add(step.term);
+  return out;
+}
+function termAst(term) {
+  if (term.kind === "number") return { kind: "literal", value: term.value };
+  const path = { kind: "path", segments: term.path.split(".").map((name) => ({ kind: "prop", name })) };
+  return term.kind === "aggregate" ? { kind: "call", name: term.fn, args: [path] } : path;
+}
+function safe(term) {
+  if (term.kind === "number") return termAst(term);
+  return { kind: "call", name: "coalesce", args: [termAst(term), { kind: "literal", value: 0 }] };
+}
+function applyStep(left, step) {
+  switch (step.op) {
+    case "add":
+      return { kind: "binary", op: "+", left, right: termAst(step.term) };
+    case "subtract":
+      return { kind: "binary", op: "-", left, right: termAst(step.term) };
+    case "multiply":
+      return { kind: "binary", op: "*", left, right: termAst(step.term) };
+    case "divide":
+      return { kind: "binary", op: "/", left, right: termAst(step.term) };
+    case "addPercent":
+      return { kind: "binary", op: "*", left, right: { kind: "binary", op: "+", left: { kind: "literal", value: 1 }, right: safe(step.term) } };
+    case "subtractPercent":
+      return { kind: "binary", op: "*", left, right: { kind: "binary", op: "-", left: { kind: "literal", value: 1 }, right: safe(step.term) } };
+  }
+}
+function calcToAst(calc) {
+  let ast = termAst(calc.start);
+  for (const step of calc.steps) ast = applyStep(ast, step);
+  if (!calc.format) return ast;
+  const piped = parseExpression(`__x__ | ${calc.format}`);
+  return graft(piped, ast);
+}
+function graft(piped, input) {
+  if (piped.kind === "pipe") return { ...piped, input: graft(piped.input, input) };
+  return input;
+}
+function toExpression(calc) {
+  return exprToString(calcToAst(calc));
+}
+var AGGREGATES = ["sum", "avg", "count", "min", "max"];
+function asTerm(e) {
+  if (e.kind === "literal" && typeof e.value === "number") return { kind: "number", value: e.value };
+  if (e.kind === "path" && e.segments.every((s) => s.kind === "prop")) {
+    return { kind: "field", path: e.segments.map((s) => s.kind === "prop" ? s.name : "").join(".") };
+  }
+  if (e.kind === "call" && AGGREGATES.includes(e.name) && e.args.length === 1) {
+    const inner = asTerm(e.args[0]);
+    if (inner?.kind === "field") return { kind: "aggregate", fn: e.name, path: inner.path };
+  }
+  return null;
+}
+function asSafeTerm(e) {
+  if (e.kind === "call" && e.name === "coalesce" && e.args.length === 2) {
+    const fallback = e.args[1];
+    if (fallback.kind === "literal" && fallback.value === 0) return asTerm(e.args[0]);
+    return null;
+  }
+  return asTerm(e);
+}
+function asPercent(e) {
+  if (e.kind !== "binary" || e.op !== "+" && e.op !== "-") return null;
+  if (e.left.kind !== "literal" || e.left.value !== 1) return null;
+  const term = asSafeTerm(e.right);
+  if (!term) return null;
+  return { op: e.op === "+" ? "addPercent" : "subtractPercent", term };
+}
+var OPS = { "+": "add", "-": "subtract", "*": "multiply", "/": "divide" };
+function fromExpression(expr) {
+  let ast;
+  try {
+    ast = parseExpression(expr);
+  } catch {
+    return null;
+  }
+  const formats = [];
+  while (ast.kind === "pipe") {
+    formats.unshift(`${ast.name}${ast.args.length ? ":" + ast.args.map(exprToString).join(":") : ""}`);
+    ast = ast.input;
+  }
+  const format = formats.length ? formats.join(" | ") : void 0;
+  const steps = [];
+  let cursor = ast;
+  while (cursor.kind === "binary") {
+    const op = OPS[cursor.op];
+    if (!op) return null;
+    if (op === "multiply") {
+      const percent = asPercent(cursor.right);
+      if (percent) {
+        steps.unshift(percent);
+        cursor = cursor.left;
+        continue;
+      }
+    }
+    const term = asTerm(cursor.right);
+    if (!term) return null;
+    steps.unshift({ op, term });
+    cursor = cursor.left;
+  }
+  const start = asTerm(cursor);
+  if (!start) return null;
+  const calc = { start, steps, ...format ? { format } : {} };
+  return toExpression(calc) === expr.trim() ? calc : null;
+}
+function isCalculation(calc) {
+  return calc.steps.length > 0 || calc.start.kind === "aggregate";
+}
+
 // src/resolve/describe.ts
 function describeExpression(expr, scope) {
   try {
@@ -2232,6 +2395,522 @@ function humaniseLabel(text, scope) {
   });
 }
 
+// src/diff/template-diff.ts
+var DISPLAY_LIMIT = 80;
+var SUMMARY_LIMIT = 120;
+var AREA_RANK = { document: 0, page: 1, styles: 2, header: 3, body: 4, footer: 5 };
+function diffTemplates(before, after, options = {}) {
+  const ctx = {
+    registry: options.registry,
+    scope: createSchemaScope(options.dataSources ?? [])
+  };
+  const placed = [
+    ...documentChanges(before, after, ctx),
+    ...pageChanges(before.page, after.page),
+    ...styleChanges(before, after, ctx),
+    ...nodeChanges(before, after, ctx)
+  ];
+  const ordered = placed.map((c, i) => ({ c, i })).sort((a, b) => AREA_RANK[a.c.area] - AREA_RANK[b.c.area] || a.c.rank - b.c.rank || a.i - b.i).map(({ c }) => strip(c));
+  const counts = { added: 0, removed: 0, changed: 0, moved: 0 };
+  for (const change of ordered) counts[change.kind]++;
+  const max = Math.max(0, options.maxChanges ?? 200);
+  return {
+    changes: ordered.slice(0, max),
+    counts,
+    truncated: Math.max(0, ordered.length - max),
+    identical: ordered.length === 0
+  };
+}
+function summariseDiff(diff) {
+  const total = diff.counts.added + diff.counts.removed + diff.counts.changed + diff.counts.moved;
+  if (total === 0) return "No changes";
+  if (total === 1) {
+    const only = diff.changes[0];
+    return clip(only ? `1 change: ${only.summary}` : "1 change", SUMMARY_LIMIT);
+  }
+  const parts = ["added", "changed", "moved", "removed"].filter((k) => diff.counts[k] > 0).map((k) => `${diff.counts[k]} ${k}`);
+  return clip(`${total} changes: ${parts.join(", ")}`, SUMMARY_LIMIT);
+}
+function strip(change) {
+  const { rank, ...rest } = change;
+  void rank;
+  const out = { kind: rest.kind, area: rest.area, subject: rest.subject, summary: rest.summary };
+  if (rest.nodeId !== void 0) out.nodeId = rest.nodeId;
+  if (rest.before !== void 0) out.before = clip(rest.before, DISPLAY_LIMIT);
+  if (rest.after !== void 0) out.after = clip(rest.after, DISPLAY_LIMIT);
+  return out;
+}
+function documentChanges(before, after, ctx) {
+  void ctx;
+  const out = [];
+  if (before.name !== after.name) {
+    out.push({ kind: "changed", area: "document", subject: "Design name", summary: "Renamed the design", before: before.name, after: after.name, rank: 0 });
+  }
+  const settings = [
+    ["locale", "Language and region", "Changed the language and region"],
+    ["currency", "Currency", "Changed the currency"],
+    ["timeZone", "Time zone", "Changed the time zone"]
+  ];
+  settings.forEach(([key, subject, summary], i) => {
+    const a = before.settings?.[key];
+    const b = after.settings?.[key];
+    if (a === b) return;
+    out.push({ kind: "changed", area: "document", subject, summary, before: a === void 0 ? "Default" : String(a), after: b === void 0 ? "Default" : String(b), rank: i + 1 });
+  });
+  return out;
+}
+function pageChanges(before, after) {
+  const out = [];
+  let rank = 0;
+  const push = (subject, summary, a, b) => {
+    out.push({ kind: "changed", area: "page", subject, summary, ...a !== void 0 ? { before: a } : {}, ...b !== void 0 ? { after: b } : {}, rank: rank++ });
+  };
+  if (!same(before.size, after.size)) push("Page size", "Changed the page size", pageSize(before.size), pageSize(after.size));
+  if (before.orientation !== after.orientation) push("Page orientation", "Changed the page orientation", humanize(before.orientation), humanize(after.orientation));
+  if (!same(before.margins, after.margins)) push("Page margins", "Changed the page margins", margins(before.margins), margins(after.margins));
+  for (const region of ["header", "footer"]) {
+    const a = before[region];
+    const b = after[region];
+    const name = region === "header" ? "Header" : "Footer";
+    if (a?.height !== b?.height) push(`${name} height`, `Changed the ${region} height`, regionHeight(a?.height), regionHeight(b?.height));
+    if (Boolean(a?.differentFirstPage) !== Boolean(b?.differentFirstPage)) {
+      push(
+        `Different first-page ${region}`,
+        b?.differentFirstPage ? `Turned on a different ${region} for the first page` : `Turned off the different ${region} for the first page`,
+        onOff(a?.differentFirstPage),
+        onOff(b?.differentFirstPage)
+      );
+    }
+  }
+  if (before.background !== after.background) push("Page background", "Changed the page background", colour(before.background), colour(after.background));
+  if (before.minPages !== after.minPages) {
+    push("Empty pages shown", "Changed how many pages an empty document shows", String(before.minPages ?? 1), String(after.minPages ?? 1));
+  }
+  const known = /* @__PURE__ */ new Set(["size", "orientation", "margins", "header", "footer", "background", "minPages"]);
+  const extra = keysOf(before, after).filter((k) => !known.has(k) && !same(before[k], after[k]));
+  if (extra.length) push("Page settings", "Changed the page settings");
+  return out;
+}
+function pageSize(size) {
+  return typeof size === "string" ? size : `${size.width} \xD7 ${size.height} mm`;
+}
+function margins(m) {
+  return [m.top, m.right, m.bottom, m.left].map((v) => `${v} mm`).join(" \xB7 ");
+}
+function regionHeight(height) {
+  return !height ? "None" : `${height} mm`;
+}
+var TEXT_STYLE_WORDS = {
+  fontFamily: "font",
+  fontSize: "size",
+  fontWeight: "weight",
+  fontStyle: "slant",
+  lineHeight: "line height",
+  letterSpacing: "letter spacing",
+  textTransform: "capitalisation",
+  color: "colour",
+  marginTop: "space above",
+  marginBottom: "space below",
+  keepWithNext: "keep with next"
+};
+var TABLE_WORDS = {
+  fontSize: "text size",
+  headerBackground: "header background",
+  headerColor: "header text colour",
+  headerFontWeight: "header weight",
+  borderColor: "border colour",
+  borderWidth: "border width",
+  borders: "lines",
+  zebraBackground: "stripe colour",
+  cellPaddingX: "cell padding",
+  cellPaddingY: "cell padding"
+};
+var CARD_WORDS = {
+  background: "background",
+  borderColor: "border colour",
+  borderWidth: "border width",
+  borderRadius: "corner radius",
+  padding: "padding",
+  shadow: "shadow"
+};
+var LINK_WORDS = { color: "colour", underline: "underline" };
+var SPACING_WORDS = {
+  blockGap: "space between blocks",
+  sectionPadding: "section padding",
+  columnGap: "space between columns"
+};
+function styleChanges(before, after, ctx) {
+  void ctx;
+  const out = [];
+  let rank = 0;
+  const a = before.styles ?? {};
+  const b = after.styles ?? {};
+  const beforeText = a.text ?? {};
+  const afterText = b.text ?? {};
+  const ids = [...Object.keys(afterText), ...Object.keys(beforeText).filter((id) => !(id in afterText))];
+  for (const id of ids) {
+    const label = textStyleLabel(id);
+    const subject = `${label} style`;
+    if (!(id in beforeText)) {
+      out.push({ kind: "added", area: "styles", subject, summary: `Added the ${label} style`, rank: rank++ });
+    } else if (!(id in afterText)) {
+      out.push({ kind: "removed", area: "styles", subject, summary: `Removed the ${label} style`, rank: rank++ });
+    } else {
+      const change = groupChange(beforeText[id], afterText[id], TEXT_STYLE_WORDS, (words) => `Changed the ${words} of the ${label} style`, subject);
+      if (change) out.push({ ...change, rank: rank++ });
+    }
+  }
+  const groups = [
+    ["table", TABLE_WORDS, "Table style", (w) => `Changed the ${w} of tables`],
+    ["card", CARD_WORDS, "Card style", (w) => `Changed the ${w} of cards`],
+    ["link", LINK_WORDS, "Link style", (w) => `Changed the ${w} of links`],
+    ["spacing", SPACING_WORDS, "Spacing", (w) => `Changed the ${w}`]
+  ];
+  for (const [key, words, subject, sentence] of groups) {
+    const change = groupChange(
+      a[key] ?? {},
+      b[key] ?? {},
+      words,
+      sentence,
+      subject
+    );
+    if (change) out.push({ ...change, rank: rank++ });
+  }
+  const known = /* @__PURE__ */ new Set(["text", "table", "card", "link", "spacing"]);
+  const extra = keysOf(a, b).filter((k) => !known.has(k) && !same(a[k], b[k]));
+  if (extra.length) out.push({ kind: "changed", area: "styles", subject: "Document styles", summary: "Changed the document styles", rank: rank++ });
+  return out;
+}
+function groupChange(before, after, words, sentence, subject) {
+  const changed = keysOf(before, after).filter((k) => !same(before[k], after[k]));
+  if (!changed.length) return null;
+  const names = unique(changed.map((k) => words[k] ?? lowerFirst(humanize(k))));
+  const change = { kind: "changed", area: "styles", subject, summary: sentence(list(names)) };
+  if (changed.length === 1) {
+    const key = changed[0];
+    change.before = styleValue(key, before[key]);
+    change.after = styleValue(key, after[key]);
+  }
+  return change;
+}
+function styleValue(key, value) {
+  if (value === void 0 || value === null) return "Default";
+  if (typeof value === "boolean") return onOff(value);
+  if (typeof value === "number") return /line|weight/i.test(key) ? String(value) : `${value} px`;
+  if (typeof value === "string") return /colou?r|background/i.test(key) ? colour(value) : value.startsWith("$") ? token(value) : humanize(value);
+  return "Custom";
+}
+function indexTemplate(template) {
+  const byId = /* @__PURE__ */ new Map();
+  const ordered = [];
+  const children = /* @__PURE__ */ new Map();
+  const lists = [
+    ["header", "header:default", template.header?.default],
+    ["header", "header:firstPage", template.header?.firstPage],
+    ["body", "body", template.body],
+    ["footer", "footer:default", template.footer?.default],
+    ["footer", "footer:firstPage", template.footer?.firstPage]
+  ];
+  const walk2 = (nodes, area, parentKey, parentId) => {
+    const ids = [];
+    for (const node of nodes) {
+      if (byId.has(node.id)) continue;
+      const entry = { node, parentId, parentKey, area, order: ordered.length };
+      byId.set(node.id, entry);
+      ordered.push(entry);
+      ids.push(node.id);
+      if (node.children?.length) walk2(node.children, area, node.id, node.id);
+    }
+    children.set(parentKey, ids);
+  };
+  for (const [area, key, nodes] of lists) if (nodes) walk2(nodes, area, key, null);
+  return { byId, ordered, children };
+}
+function nodeChanges(before, after, ctx) {
+  const a = indexTemplate(before);
+  const b = indexTemplate(after);
+  const out = [];
+  const removedRank = (entry) => {
+    for (let i = entry.order - 1; i >= 0; i--) {
+      const survivor = b.byId.get(a.ordered[i].node.id);
+      if (survivor) return survivor.order + 0.5;
+    }
+    return -0.5;
+  };
+  for (const entry of a.ordered) {
+    const id = entry.node.id;
+    if (b.byId.has(id)) continue;
+    if (entry.parentId && !b.byId.has(entry.parentId)) continue;
+    out.push({
+      kind: "removed",
+      area: entry.area,
+      nodeId: id,
+      subject: subjectOf(entry, a, ctx),
+      summary: `Removed ${refOf(entry, a, ctx, "definite")}${place(entry, a, "from", ctx)}`,
+      rank: removedRank(entry)
+    });
+  }
+  const reordered = /* @__PURE__ */ new Set();
+  for (const [key, afterIds] of b.children) {
+    const beforeIds = a.children.get(key);
+    if (!beforeIds) continue;
+    const shared = beforeIds.filter((id) => afterIds.includes(id));
+    if (shared.length < 2) continue;
+    const positions = shared.map((id) => afterIds.indexOf(id));
+    const keep = longestIncreasing(positions);
+    shared.forEach((id, i) => {
+      if (!keep.has(i)) reordered.add(id);
+    });
+  }
+  for (const entry of b.ordered) {
+    const id = entry.node.id;
+    const was = a.byId.get(id);
+    if (!was) {
+      if (entry.parentId && !a.byId.has(entry.parentId)) continue;
+      out.push({
+        kind: "added",
+        area: entry.area,
+        nodeId: id,
+        subject: subjectOf(entry, b, ctx),
+        summary: `Added ${refOf(entry, b, ctx, "indefinite")}${place(entry, b, "to", ctx)}`,
+        rank: entry.order
+      });
+      continue;
+    }
+    if (was.parentKey !== entry.parentKey) {
+      const from = place(was, a, "from", ctx);
+      const to = place(entry, b, "to", ctx);
+      const within = place(entry, b, "within", ctx);
+      out.push({
+        kind: "moved",
+        area: entry.area,
+        nodeId: id,
+        subject: subjectOf(entry, b, ctx),
+        // Between two columns of the same section is still "within" it: naming the
+        // same section twice would read as a mistake.
+        summary: `Moved ${refOf(entry, b, ctx, "definite")}${from.replace(/^ from /, "") === to.replace(/^ to /, "") ? within : `${from}${to}`}`,
+        rank: entry.order
+      });
+    } else if (reordered.has(id)) {
+      out.push({
+        kind: "moved",
+        area: entry.area,
+        nodeId: id,
+        subject: subjectOf(entry, b, ctx),
+        summary: `Moved ${refOf(entry, b, ctx, "definite")}${place(entry, b, "within", ctx)}`,
+        rank: entry.order
+      });
+    }
+    const changed = nodeEdit(was, a, entry, b, ctx);
+    if (changed) out.push({ ...changed, rank: entry.order + 0.25 });
+  }
+  return out;
+}
+function nodeEdit(was, wasIndex, now, nowIndex, ctx) {
+  const x = was.node;
+  const y = now.node;
+  const propKeys = keysOf(x.props ?? {}, y.props ?? {}).filter((k) => !same(x.props?.[k], y.props?.[k]));
+  const typeChanged = x.type !== y.type;
+  const styleChanged = !same(x.style, y.style);
+  const visibilityChanged = !same(x.visibleWhen, y.visibleWhen);
+  const flowChanged = !same(x.flow, y.flow);
+  const nameChanged = (x.name ?? "") !== (y.name ?? "");
+  if (!propKeys.length && !typeChanged && !styleChanged && !visibilityChanged && !flowChanged && !nameChanged) return null;
+  const ref = refOf(now, nowIndex, ctx, "definite");
+  const where = place(now, nowIndex, "in", ctx);
+  const base = { kind: "changed", area: now.area, nodeId: y.id, subject: subjectOf(now, nowIndex, ctx), rank: 0 };
+  const aspects = propKeys.length + Number(styleChanged) + Number(visibilityChanged) + Number(flowChanged) + Number(nameChanged) + Number(typeChanged);
+  if (aspects === 1 && nameChanged) {
+    return { ...base, summary: `Renamed ${refOf(was, wasIndex, ctx, "definite")}${place(was, wasIndex, "in", ctx)}`, before: x.name ?? "", after: y.name ?? "" };
+  }
+  if (aspects === 1 && styleChanged) return { ...base, summary: `Changed the look of ${ref}${where}` };
+  if (aspects === 1 && visibilityChanged) return { ...base, summary: `Changed when ${ref}${where} appears` };
+  if (aspects === 1 && flowChanged) return { ...base, summary: `Changed how ${ref}${where} breaks across pages` };
+  const names = unique([
+    ...typeChanged ? ["type"] : [],
+    ...propKeys.map((k) => propLabel(y.type, k, ctx)),
+    ...styleChanged ? ["look"] : [],
+    ...visibilityChanged ? ["visibility"] : [],
+    ...flowChanged ? ["page breaks"] : [],
+    ...nameChanged ? ["name"] : []
+  ]);
+  const summary = names.length > 3 ? `Changed ${names.length} settings of ${ref}${where}` : `Changed the ${list(names)} of ${ref}${where}`;
+  const change = { ...base, summary };
+  if (aspects === 1 && propKeys.length === 1) {
+    const key = propKeys[0];
+    const from = simpleValue(x.type, key, x.props?.[key], ctx);
+    const to = simpleValue(y.type, key, y.props?.[key], ctx);
+    if (from !== null && to !== null) {
+      change.before = from;
+      change.after = to;
+    }
+  }
+  return change;
+}
+var STRUCTURE_NOUNS = { section: "section", row: "row of columns", column: "column" };
+function blockName(type, ctx) {
+  if (STRUCTURE_NOUNS[type]) return humanize(STRUCTURE_NOUNS[type]);
+  const name = ctx.registry?.get(type)?.name;
+  return name && name.trim() ? name.trim() : humanize(type.replace(/[-_.]+/g, " "));
+}
+function subjectOf(entry, index, ctx) {
+  const node = entry.node;
+  if (node.name?.trim()) return node.name.trim();
+  if (node.type === "section") {
+    const label = sectionLabel(entry, index, ctx);
+    return label.quoted ? `Section \u201C${label.text}\u201D` : humanize(label.text);
+  }
+  return blockName(node.type, ctx);
+}
+function refOf(entry, index, ctx, form) {
+  const node = entry.node;
+  if (node.type === "section") {
+    const label = sectionLabel(entry, index, ctx);
+    return label.quoted ? `the section \u201C${label.text}\u201D` : label.text;
+  }
+  if (node.name?.trim()) return `\u201C${node.name.trim()}\u201D`;
+  const noun = lowerFirst(blockName(node.type, ctx));
+  if (form === "definite") return `the ${noun}`;
+  return `${/^[aeiou]/i.test(noun) ? "an" : "a"} ${noun}`;
+}
+function sectionLabel(entry, index, ctx) {
+  const node = entry.node;
+  if (node.name?.trim()) return { text: node.name.trim(), quoted: true };
+  const heading = firstHeading(node, ctx);
+  if (heading) return { text: heading, quoted: true };
+  const siblings = index.children.get(entry.parentKey) ?? [];
+  const sections = siblings.filter((id) => index.byId.get(id)?.node.type === "section");
+  return { text: `section ${sections.indexOf(node.id) + 1}`, quoted: false };
+}
+function firstHeading(node, ctx) {
+  for (const child of node.children ?? []) {
+    if (child.type === "heading") {
+      const text = child.props?.text;
+      if (typeof text === "string" && text.trim()) return clip(readableText(text, ctx).trim(), 60);
+      if (isRichTextDoc(text)) return clip(richTextToPlain(text, (e) => expressionLabel(e, ctx)).trim(), 60);
+    }
+    const nested = firstHeading(child, ctx);
+    if (nested) return nested;
+  }
+  return null;
+}
+function place(entry, index, preposition, ctx) {
+  let cursor = entry.parentId ? index.byId.get(entry.parentId) : void 0;
+  while (cursor) {
+    if (cursor.node.type === "section") {
+      const label = sectionLabel(cursor, index, ctx);
+      return ` ${preposition} ${label.quoted ? `\u201C${label.text}\u201D` : label.text}`;
+    }
+    cursor = cursor.parentId ? index.byId.get(cursor.parentId) : void 0;
+  }
+  if (entry.area === "header") return ` ${preposition} the header`;
+  if (entry.area === "footer") return ` ${preposition} the footer`;
+  return preposition === "within" ? " within the document" : "";
+}
+function propLabel(type, prop, ctx) {
+  const def = ctx.registry?.get(type);
+  const find = (fields) => {
+    for (const field of fields) if (field.prop === prop || field.prop.startsWith(`${prop}.`)) return field.label;
+    return null;
+  };
+  for (const section of def?.inspector ?? []) {
+    const label = find(section.fields);
+    if (label) return lowerFirst(label);
+  }
+  return lowerFirst(humanize(prop));
+}
+function simpleValue(type, prop, value, ctx) {
+  if (value === void 0 || value === null) return "None";
+  if (typeof value === "boolean") return onOff(value);
+  if (typeof value === "number") return String(value);
+  if (isRichTextDoc(value)) return oneLine(richTextToPlain(value, (e) => expressionLabel(e, ctx)));
+  if (typeof value !== "string") return null;
+  const kind = ctx.registry?.bindingsOf(type).find((b) => b.prop === prop)?.kind;
+  if (kind === "value" || kind === "collection") return expressionLabel(value, ctx);
+  if (kind === "condition" || kind === "list") return null;
+  if (!kind && looksLikeExpression(value)) return expressionLabel(value, ctx);
+  return oneLine(readableText(value, ctx));
+}
+function readableText(text, ctx) {
+  return text.replace(/\{\{([^}]*)\}\}/g, (_, expr) => expressionLabel(expr.trim(), ctx));
+}
+function looksLikeExpression(value) {
+  return /\|\s*[A-Za-z_]\w*/.test(value) || /^\s*[A-Za-z_]\w*\s*\(/.test(value);
+}
+function expressionLabel(expr, ctx) {
+  if (!expr.trim()) return "nothing";
+  const { label } = describeExpression(expr, ctx.scope);
+  if (label === expr && /[^\w\s'’-]/.test(expr)) return "a calculated value";
+  return label;
+}
+function colour(value) {
+  if (!value) return "None";
+  return value.startsWith("$") ? token(value) : value;
+}
+function token(value) {
+  const last = value.slice(1).split(".").pop() ?? value;
+  return `Theme ${lowerFirst(humanize(last))}`;
+}
+function onOff(value) {
+  return value ? "On" : "Off";
+}
+function list(words) {
+  if (words.length <= 1) return words[0] ?? "";
+  return `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}`;
+}
+function lowerFirst(text) {
+  if (text.length > 1 && text[1] === text[1].toUpperCase() && /[A-Z]/.test(text[1])) return text;
+  return text.charAt(0).toLowerCase() + text.slice(1);
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function clip(text, limit) {
+  return text.length <= limit ? text : `${text.slice(0, limit - 1).trimEnd()}\u2026`;
+}
+function unique(items) {
+  return [...new Set(items)];
+}
+function keysOf(a, b) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const o of [a, b]) if (o && typeof o === "object") for (const k of Object.keys(o)) keys.add(k);
+  return [...keys];
+}
+function same(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const other = b;
+    return a.length === other.length && a.every((v, i) => same(v, other[i]));
+  }
+  const x = a;
+  const y = b;
+  return keysOf(x, y).every((k) => same(x[k], y[k]));
+}
+function longestIncreasing(values) {
+  const tails = [];
+  const previous = new Array(values.length).fill(-1);
+  for (let i = 0; i < values.length; i++) {
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (values[tails[mid]] < values[i]) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo > 0) previous[i] = tails[lo - 1];
+    tails[lo] = i;
+  }
+  const keep = /* @__PURE__ */ new Set();
+  let cursor = tails.length ? tails[tails.length - 1] : -1;
+  while (cursor >= 0) {
+    keep.add(cursor);
+    cursor = previous[cursor];
+  }
+  return keep;
+}
+
 // src/resolve/resolve.ts
 var display = toDisplayString;
 function resolveTemplate(opts) {
@@ -2495,8 +3174,8 @@ function resolveNode(ctx, node, scope, schemaScope, keyPrefix, _parentRole) {
   for (const spec of bindingSpecsFor(def)) {
     if (spec.perItem) continue;
     if (spec.items) {
-      const list = getPath(props, spec.prop);
-      if (Array.isArray(list)) list.forEach((item, i) => item && typeof item === "object" && spec.items.forEach((s) => !s.perItem && applySpec(s, item, `${spec.prop}.${i}.`)));
+      const list2 = getPath(props, spec.prop);
+      if (Array.isArray(list2)) list2.forEach((item, i) => item && typeof item === "object" && spec.items.forEach((s) => !s.perItem && applySpec(s, item, `${spec.prop}.${i}.`)));
       continue;
     }
     applySpec(spec, props, "");
@@ -2684,7 +3363,7 @@ function computePageGeometry(page) {
   const portrait = page.orientation !== "landscape";
   const width = mmToPx(portrait ? size.width : size.height);
   const height = mmToPx(portrait ? size.height : size.width);
-  const margins = {
+  const margins2 = {
     top: mmToPx(page.margins.top),
     right: mmToPx(page.margins.right),
     bottom: mmToPx(page.margins.bottom),
@@ -2692,18 +3371,18 @@ function computePageGeometry(page) {
   };
   const headerHeight = mmToPx(Math.max(0, page.header.height));
   const footerHeight = mmToPx(Math.max(0, page.footer.height));
-  const contentTop = margins.top + headerHeight;
-  const footerTop = height - margins.bottom - footerHeight;
+  const contentTop = margins2.top + headerHeight;
+  const footerTop = height - margins2.bottom - footerHeight;
   return {
     width,
     height,
-    margins,
+    margins: margins2,
     headerHeight,
     footerHeight,
-    contentWidth: Math.max(0, width - margins.left - margins.right),
+    contentWidth: Math.max(0, width - margins2.left - margins2.right),
     contentHeight: Math.max(0, footerTop - contentTop),
     contentTop,
-    headerTop: margins.top,
+    headerTop: margins2.top,
     footerTop
   };
 }
@@ -2713,16 +3392,16 @@ function g(ctx, node) {
   return ctx.geom.nodes[node.key] ?? { top: 0, height: 0, left: 0, width: 0 };
 }
 var EPS = 0.01;
-function bestBreak(ctx, list, limit, minY) {
+function bestBreak(ctx, list2, limit, minY) {
   const visible = (from, step) => {
-    for (let j = from; j >= 0 && j < list.length; j += step) {
-      const s = list[j];
+    for (let j = from; j >= 0 && j < list2.length; j += step) {
+      const s = list2[j];
       if (g(ctx, s).height > EPS) return s;
     }
     return void 0;
   };
-  for (let i = list.length - 1; i >= 0; i--) {
-    const child = list[i];
+  for (let i = list2.length - 1; i >= 0; i--) {
+    const child = list2[i];
     const cg = g(ctx, child);
     const top = cg.top;
     const bottom = cg.top + cg.height;
@@ -3044,10 +3723,10 @@ function validateTemplate(opts) {
       }
       if (kind === "collection" && r.issues.length === 0 && r.type !== "array" && r.type !== "any" && r.type !== "unknown") out.push(issue("error", "missing-collection", `"${expr}" is a ${r.type}, not a list`, { ...where, prop }));
       if (expected && r.issues.length === 0 && r.type !== "unknown" && r.type !== "any" && r.type !== "null") {
-        const list = Array.isArray(expected) ? expected : [expected];
+        const list2 = Array.isArray(expected) ? expected : [expected];
         const numeric = ["number", "currency", "percent"];
-        const compatible = list.includes(r.type) || list.some((t) => numeric.includes(t)) && numeric.includes(r.type) || list.includes("string") && r.type !== "array" && r.type !== "object";
-        if (!compatible) out.push(issue("warning", "type-mismatch", `"${expr}" is a ${r.type}; expected ${list.join(" or ")}`, { ...where, prop }));
+        const compatible = list2.includes(r.type) || list2.some((t) => numeric.includes(t)) && numeric.includes(r.type) || list2.includes("string") && r.type !== "array" && r.type !== "object";
+        if (!compatible) out.push(issue("warning", "type-mismatch", `"${expr}" is a ${r.type}; expected ${list2.join(" or ")}`, { ...where, prop }));
       }
       issues.push(...out);
       return out;
@@ -3106,8 +3785,8 @@ function validateTemplate(opts) {
         continue;
       }
       if (spec.items) {
-        const list = getPath2(props, spec.prop);
-        if (Array.isArray(list)) list.forEach((item, i) => item && typeof item === "object" && spec.items.forEach((sub) => runSpec(sub, item, `${spec.prop}.${i}.`, sub.perItem ? itemScope : scope)));
+        const list2 = getPath2(props, spec.prop);
+        if (Array.isArray(list2)) list2.forEach((item, i) => item && typeof item === "object" && spec.items.forEach((sub) => runSpec(sub, item, `${spec.prop}.${i}.`, sub.perItem ? itemScope : scope)));
         continue;
       }
       runSpec(spec, props, "", scope);
@@ -3401,7 +4080,7 @@ function readRegion(template, region) {
       return template.footer.firstPage ?? [];
   }
 }
-function indexTemplate(template) {
+function indexTemplate2(template) {
   const index = /* @__PURE__ */ new Map();
   const visit = (nodes, parent, region, path) => {
     nodes.forEach((node, i) => {
@@ -3414,21 +4093,21 @@ function indexTemplate(template) {
   return index;
 }
 function findNode(template, id) {
-  return indexTemplate(template).get(id);
+  return indexTemplate2(template).get(id);
 }
 function listAt(template, location) {
-  let list = getRegion(template, location.region);
+  let list2 = getRegion(template, location.region);
   for (let i = 0; i < location.path.length - 1; i++) {
-    const n = list[location.path[i]];
+    const n = list2[location.path[i]];
     if (!n) throw new Error("Invalid node path");
     n.children ??= [];
-    list = n.children;
+    list2 = n.children;
   }
-  return { list, index: location.path[location.path.length - 1] ?? 0 };
+  return { list: list2, index: location.path[location.path.length - 1] ?? 0 };
 }
 function nodeAt(template, location) {
-  const { list, index } = listAt(template, location);
-  return list[index];
+  const { list: list2, index } = listAt(template, location);
+  return list2[index];
 }
 function ancestors(index, id) {
   const chain = [];
@@ -3496,28 +4175,28 @@ function applyCommand(draft, cmd) {
   const t = draft;
   switch (cmd.type) {
     case "insertNode": {
-      const { list, index } = listAt(t, cmd.at);
-      list.splice(Math.min(index, list.length), 0, cmd.node);
+      const { list: list2, index } = listAt(t, cmd.at);
+      list2.splice(Math.min(index, list2.length), 0, cmd.node);
       return;
     }
     case "insertNodes": {
-      const { list, index } = listAt(t, cmd.at);
-      list.splice(Math.min(index, list.length), 0, ...cmd.nodes);
+      const { list: list2, index } = listAt(t, cmd.at);
+      list2.splice(Math.min(index, list2.length), 0, ...cmd.nodes);
       return;
     }
     case "removeNodes": {
-      const index = indexTemplate(t);
+      const index = indexTemplate2(t);
       const entries = cmd.ids.map((id) => index.get(id)).filter((e) => !!e);
       entries.sort((a, b) => b.depth - a.depth || b.index - a.index);
       for (const e of entries) {
-        const list = e.parent ? e.parent.children ??= [] : getRegion(t, e.region);
-        const i = list.findIndex((n) => n.id === e.node.id);
-        if (i >= 0) list.splice(i, 1);
+        const list2 = e.parent ? e.parent.children ??= [] : getRegion(t, e.region);
+        const i = list2.findIndex((n) => n.id === e.node.id);
+        if (i >= 0) list2.splice(i, 1);
       }
       return;
     }
     case "moveNode": {
-      const index = indexTemplate(t);
+      const index = indexTemplate2(t);
       const entry = index.get(cmd.id);
       if (!entry) throw new CommandError(`Node ${cmd.id} not found`);
       const target = listAt(t, cmd.to);
@@ -3542,13 +4221,13 @@ function applyCommand(draft, cmd) {
       return;
     }
     case "duplicateNode": {
-      const index = indexTemplate(t);
+      const index = indexTemplate2(t);
       const entry = index.get(cmd.id);
       if (!entry) throw new CommandError(`Node ${cmd.id} not found`);
-      const list = entry.parent ? entry.parent.children ??= [] : getRegion(t, entry.region);
+      const list2 = entry.parent ? entry.parent.children ??= [] : getRegion(t, entry.region);
       const copy = cloneWithNewIds(isDraft(entry.node) ? current(entry.node) : entry.node);
       if (cmd.newId) copy.id = cmd.newId;
-      list.splice(entry.index + 1, 0, copy);
+      list2.splice(entry.index + 1, 0, copy);
       return;
     }
     case "setProps": {
@@ -3621,27 +4300,27 @@ function applyCommand(draft, cmd) {
       return;
     }
     case "wrapNodes": {
-      const index = indexTemplate(t);
+      const index = indexTemplate2(t);
       const entries = cmd.ids.map((id) => index.get(id)).filter((e) => !!e);
       if (entries.length === 0) return;
       const first = entries[0];
-      const list = first.parent ? first.parent.children ??= [] : getRegion(t, first.region);
+      const list2 = first.parent ? first.parent.children ??= [] : getRegion(t, first.region);
       const nodes = entries.map((e) => e.node);
-      const startIndex = list.indexOf(first.node);
+      const startIndex = list2.indexOf(first.node);
       for (const n of nodes) {
-        const i = list.indexOf(n);
-        if (i >= 0) list.splice(i, 1);
+        const i = list2.indexOf(n);
+        if (i >= 0) list2.splice(i, 1);
       }
       const wrapper = { ...cmd.wrapper, children: [...cmd.wrapper.children ?? [], ...nodes.map((n) => isDraft(n) ? current(n) : n)] };
-      list.splice(Math.min(startIndex, list.length), 0, wrapper);
+      list2.splice(Math.min(startIndex, list2.length), 0, wrapper);
       return;
     }
     case "replaceNode": {
-      const index = indexTemplate(t);
+      const index = indexTemplate2(t);
       const entry = index.get(cmd.id);
       if (!entry) throw new CommandError(`Node ${cmd.id} not found`);
-      const list = entry.parent ? entry.parent.children ??= [] : getRegion(t, entry.region);
-      list[entry.index] = cmd.node;
+      const list2 = entry.parent ? entry.parent.children ??= [] : getRegion(t, entry.region);
+      list2[entry.index] = cmd.node;
       return;
     }
     case "setPage": {
@@ -3701,7 +4380,7 @@ function applyCommand(draft, cmd) {
   }
 }
 function requireNode(t, id) {
-  const e = indexTemplate(t).get(id);
+  const e = indexTemplate2(t).get(id);
   if (!e) throw new CommandError(`Node ${id} not found`);
   return e.node;
 }
@@ -3774,7 +4453,7 @@ var EditorStore = class {
   /** Cached id → node index for the current document version. */
   index() {
     if (!this.indexCache || this.indexCache.version !== this.state.version) {
-      this.indexCache = { version: this.state.version, index: indexTemplate(this.state.template) };
+      this.indexCache = { version: this.state.version, index: indexTemplate2(this.state.template) };
     }
     return this.indexCache.index;
   }
@@ -3968,7 +4647,7 @@ var EditorStore = class {
   }
 };
 function findIn(template, id) {
-  return indexTemplate(template).get(id)?.node;
+  return indexTemplate2(template).get(id)?.node;
 }
 function sameIds(a, b) {
   return a.length === b.length && a.every((x, i) => x === b[i]);
@@ -4061,9 +4740,9 @@ function markWrap(children, marks, opts) {
   if (marks.color) out = h("span", { style: { color: resolveValue(marks.color, opts.theme, "inherit") } }, out);
   if (marks.link) {
     const href = marks.link;
-    const safe = isSafeUrl(href);
+    const safe2 = isSafeUrl(href);
     const linkColor = resolveValue(opts.styles.link.color, opts.theme, opts.theme.colors.secondary);
-    out = h("a", { class: "bp-link", href: safe ? href : void 0, rel: "noopener", style: { color: linkColor, "text-decoration": opts.styles.link.underline === false ? "none" : "underline" } }, out);
+    out = h("a", { class: "bp-link", href: safe2 ? href : void 0, rel: "noopener", style: { color: linkColor, "text-decoration": opts.styles.link.underline === false ? "none" : "underline" } }, out);
   }
   return out;
 }
@@ -4223,6 +4902,8 @@ export {
   bestBreak,
   bindingSpecsFor,
   blockStyleSchema,
+  calcPaths,
+  calcToAst,
   checkExpressionSyntax,
   checkOutput,
   classNames,
@@ -4246,8 +4927,10 @@ export {
   dataSourceSchemas,
   defaultDocumentStyles,
   defaultPageSettings,
+  defaultPipeFor,
   defineBlock,
   describeExpression,
+  diffTemplates,
   documentStylesSchema,
   escapeHtml,
   evaluate,
@@ -4263,19 +4946,23 @@ export {
   formatDatePattern,
   formatNumber,
   formatPercent,
+  fromExpression,
   getField,
   getRegion,
   h,
+  hasPipe,
   humaniseLabel,
   humanize,
   humanizeKey,
-  indexTemplate,
+  indexTemplate2 as indexTemplate,
   inlineFromTemplate,
   inlineToPlain,
   interpolate,
+  isCalculation,
   isDarkColor,
   isDescendant,
   isEmptyValue,
+  isPlainPath,
   isRichTextDoc,
   isSafeUrl,
   isTokenRef,
@@ -4322,12 +5009,14 @@ export {
   splitTemplate,
   styleString,
   styleToCss,
+  summariseDiff,
   synthesizeSampleData,
   synthesizeValue,
   templateSchema,
   textStyleLabel,
   toDate,
   toDisplayString,
+  toExpression,
   toHtml,
   toNumber,
   tokenChip,
@@ -4338,6 +5027,7 @@ export {
   usedBlockTypes,
   validateTemplate,
   walkTemplate,
-  walkVNodes
+  walkVNodes,
+  withDefaultPipe
 };
 //# sourceMappingURL=index.js.map