@arbidocs/coedit 0.4.119 → 0.4.121

package/dist/commands.cjs

@@ -10,6 +10,14 @@ var fflate = require('fflate');
 var DEFINED_TERM_STYLE = "DefinedTerm";
 var CROSS_REFERENCE_STYLE = "CrossReference";
 var BROKEN_CROSS_REFERENCE_STYLE = "CrossReferenceBroken";
+function engineOffset(paragraph, offset, pastDeletions = false) {
+  let out = offset;
+  for (const r of paragraph.revisions ?? [])
+    if (r.kind === "delete" && (r.offset < offset || pastDeletions && r.offset === offset))
+      out += r.length;
+  return out;
+}
+var engineLength = (paragraph) => engineOffset(paragraph, paragraph.text.length, true);
 var WATCHED_STYLES = /* @__PURE__ */ new Set([BROKEN_CROSS_REFERENCE_STYLE]);
 var attr = (node, name) => node.attributes?.find((a) => a.localName === name)?.value;
 var FIELD_ATOM = "\uFFFC";
@@ -44,6 +52,7 @@ function readParagraph(node, topLevel, bookmarks) {
   let runStyle;
   const fields = [];
   const notes = [];
+  const revisions = [];
   let current = null;
   const field = (c) => {
     const type = attr(c, "fldCharType");
@@ -85,7 +94,31 @@ function readParagraph(node, topLevel, bookmarks) {
         }
         continue;
       }
-      if (c.localName === "delText" || c.localName === "del" || c.localName === "rPr") continue;
+      if (c.localName === "del") {
+        const deleted = deletedText(c);
+        if (deleted && fieldDepth === 0)
+          revisions.push({
+            kind: "delete",
+            offset: text.length,
+            length: deleted.length,
+            author: attr(c, "author"),
+            text: deleted
+          });
+        continue;
+      }
+      if (c.localName === "ins") {
+        const start = text.length;
+        walk(c, link);
+        if (text.length > start && fieldDepth === 0)
+          revisions.push({
+            kind: "insert",
+            offset: start,
+            length: text.length - start,
+            author: attr(c, "author")
+          });
+        continue;
+      }
+      if (c.localName === "delText" || c.localName === "rPr") continue;
       if (c.localName === "r") {
         const rStyle = c.children?.find((x) => x.localName === "rPr")?.children?.find((x) => x.localName === "rStyle");
         const watched = rStyle && attr(rStyle, "val");
@@ -148,9 +181,20 @@ function readParagraph(node, topLevel, bookmarks) {
     links,
     ...fields.length ? { fields } : {},
     ...marks.length ? { marks } : {},
-    ...notes.length ? { notes } : {}
+    ...notes.length ? { notes } : {},
+    ...revisions.length ? { revisions } : {}
   };
 }
+function deletedText(node) {
+  let out = "";
+  for (const c of node.children ?? []) {
+    if (c.localName === "instrText") continue;
+    if (c.localName === "delText") out += (c.children ?? []).map((t) => t.value ?? "").join("");
+    else if (c.localName === "tab") out += "	";
+    else if (c.localName !== "rPr") out += deletedText(c);
+  }
+  return out;
+}
 function styleNames(root) {
   const names = /* @__PURE__ */ new Map();
   for (const style of root?.children ?? []) {
@@ -1041,7 +1085,7 @@ function insertParagraphs(port, index, body, count, keep) {
     port.setCaret({ paragraphId: before[index].id, offset: 0 });
   } else {
     const last = before[before.length - 1];
-    port.setCaret({ paragraphId: last.id, offset: last.text.length });
+    port.setCaret({ paragraphId: last.id, offset: engineLength(last) });
     port.splitParagraph();
     const opened = port.paragraphs();
     port.setCaret({ paragraphId: opened[opened.length - 1].id, offset: 0 });
@@ -1073,25 +1117,47 @@ function addDefinition(port, definition, keep) {
   );
 }
 var hasBookmark = (paragraphs, name) => paragraphs.some((p) => p.bookmarks.includes(name));
+var paragraphOf = (port, id) => port.paragraphs().find((p) => p.id === id);
+function replaceSpan(port, span, insert, length) {
+  const { paragraphId, from, to } = span;
+  if (from > to) throw new Error("A replacement runs forwards.");
+  const before = paragraphOf(port, paragraphId);
+  if (!before) throw new Error("That paragraph is no longer in the document.");
+  const length0 = engineLength(before);
+  port.setCaret({ paragraphId, offset: to });
+  if (!insert()) return false;
+  if (from < to) {
+    try {
+      port.deleteRange({ paragraphId, offset: from }, { paragraphId, offset: to });
+    } catch (error) {
+      port.deleteRange({ paragraphId, offset: to }, { paragraphId, offset: to + length });
+      throw error;
+    }
+  }
+  const after = paragraphOf(port, paragraphId);
+  const kept = after && engineLength(after) - length0 === length;
+  port.setCaret({ paragraphId, offset: (kept ? to : from) + length });
+  return true;
+}
 function insertDefinedTerm(port, definition, options = {}) {
   const start = port.caret();
   if (!start) throw new Error("Place the cursor where the term should go.");
-  let caret = start;
-  if (options.replace) {
-    caret = { paragraphId: start.paragraphId, offset: Math.max(0, start.offset - options.replace) };
-    port.deleteRange(caret, start);
-  }
   const bookmark = definitionBookmark(definition.id);
   const addedDefinition = !hasBookmark(port.paragraphs(), bookmark);
-  if (addedDefinition) caret = addDefinition(port, definition, caret) ?? caret;
-  port.setCaret(caret);
-  if (!port.paste(
+  const caret = addedDefinition && addDefinition(port, definition, start) || start;
+  const insert = () => port.paste(
     termLinkXml(definition.term, bookmark, definitionTooltip(definition)),
     definition.term,
     false
+  );
+  const from = Math.max(0, caret.offset - (options.replace ?? 0));
+  if (!replaceSpan(
+    port,
+    { paragraphId: caret.paragraphId, from, to: caret.offset },
+    insert,
+    definition.term.length
   ))
     throw new Error("The term could not be inserted.");
-  port.setCaret({ paragraphId: caret.paragraphId, offset: caret.offset + definition.term.length });
   return { addedDefinition };
 }
 function definitionsById(definitions) {
@@ -1102,6 +1168,144 @@ function definitionOfAnchor(anchor, definitions) {
   return id ? definitions.get(id) : void 0;
 }
 
+// src/commands/everywhere.ts
+var WORD = "[\\p{L}\\p{N}_\\-\u2010\u2011]";
+var escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function needlesOf(spec) {
+  const term = spec.term.replace(/\s+/g, " ").trim();
+  const variants = [
+    ...new Set((spec.variants ?? []).map((v) => v.replace(/\s+/g, " ").trim()))
+  ].filter((v) => v && v !== term);
+  const needles = [
+    ...variants.map((text) => ({ text, kind: "variant" })),
+    ...spec.link ? [{ text: term, kind: "term" }] : []
+  ];
+  return needles.map((n) => ({
+    ...n,
+    pattern: new RegExp(
+      `(?<!${WORD})${n.text.split(" ").map(escape).join("\\s+")}(?!${WORD})`,
+      "gu"
+    )
+  }));
+}
+function matchesIn(text, needles) {
+  const found = [];
+  for (const needle of needles)
+    for (const m of text.matchAll(needle.pattern))
+      found.push({ offset: m.index ?? 0, text: m[0], kind: needle.kind });
+  found.sort((a, b) => a.offset - b.offset || b.text.length - a.text.length);
+  const out = [];
+  for (const m of found)
+    if (!out.length || m.offset >= out[out.length - 1].offset + out[out.length - 1].text.length)
+      out.push(m);
+  return out;
+}
+var overlaps = (start, end, from, to) => start < to && from < end;
+function findTermUses(paragraphs, spec, bookmark) {
+  const needles = needlesOf(spec);
+  const defining = new Set([spec.term, ...spec.variants ?? []].map(termKey));
+  const uses = [];
+  const skipped = [];
+  for (const p of paragraphs) {
+    const at = { paragraphId: p.id, ...p.paraId ? { paraId: p.paraId } : {} };
+    const defined = parseDefinition(p.text.split(FIELD_ATOM).join(""));
+    const isDefinition = defined !== null && defining.has(termKey(defined.term));
+    for (const m of matchesIn(p.text, needles)) {
+      const use = { ...at, ...m };
+      const end = m.offset + m.text.length;
+      const link = p.links.find(
+        (l) => l.offset !== void 0 && overlaps(m.offset, end, l.offset, l.offset + l.text.length)
+      );
+      const pending = (p.revisions ?? []).some(
+        (r) => r.kind === "insert" ? overlaps(m.offset, end, r.offset, r.offset + r.length) : r.offset > m.offset && r.offset < end
+      );
+      const reason = isDefinition ? "definition" : link ? link.anchor === bookmark ? "linked" : "link" : pending ? "pending-change" : null;
+      if (reason) skipped.push({ ...use, reason });
+      else uses.push(use);
+    }
+    for (const field of p.fields ?? [])
+      for (const m of matchesIn(field.result, needles))
+        skipped.push({ ...at, offset: field.offset, text: m.text, kind: m.kind, reason: "field" });
+  }
+  return { uses, skipped };
+}
+function replacedText(text, uses, term) {
+  let out = text;
+  for (const use of [...uses].sort((a, b) => b.offset - a.offset))
+    out = out.slice(0, use.offset) + term + out.slice(use.offset + use.text.length);
+  return out;
+}
+var TermEverywhereError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TermEverywhereError";
+  }
+};
+function applyTermEverywhere(port, spec, { accept } = {}) {
+  const term = spec.term.replace(/\s+/g, " ").trim();
+  if (!term) throw new Error("Name the defined term.");
+  let addedDefinition = false;
+  let link;
+  if (spec.link) {
+    if (!spec.definition) throw new Error(`Linking "${term}" needs its definition.`);
+    link = {
+      bookmark: definitionBookmark(spec.definition.id),
+      tooltip: definitionTooltip(spec.definition)
+    };
+    if (!port.paragraphs().some((p) => p.bookmarks.includes(link.bookmark))) {
+      addDefinition(port, spec.definition);
+      addedDefinition = true;
+    }
+  }
+  const paragraphs = port.paragraphs();
+  const { uses, skipped } = findTermUses(paragraphs, { ...spec, term }, link?.bookmark);
+  const changed = [];
+  const insert = link ? () => port.paste(termLinkXml(term, link.bookmark, link.tooltip), term, false) : () => {
+    port.typeText(term);
+    return true;
+  };
+  for (const p of paragraphs) {
+    const mine = uses.filter((u) => u.paragraphId === p.id);
+    if (!mine.length) continue;
+    if (accept && !accept(p)) {
+      skipped.push(...mine.map((u) => ({ ...u, reason: "unsupported-content" })));
+      continue;
+    }
+    const current = () => port.paragraphs().find((x) => p.paraId ? x.paraId === p.paraId : x.id === p.id);
+    const done = [];
+    for (const use of [...mine].sort((a, b) => b.offset - a.offset)) {
+      const now = current();
+      let ok = false;
+      if (now) {
+        const span = {
+          paragraphId: now.id,
+          from: engineOffset(p, use.offset, true),
+          to: engineOffset(p, use.offset + use.text.length)
+        };
+        try {
+          ok = replaceSpan(port, span, insert, term.length);
+        } catch {
+          ok = false;
+        }
+      }
+      if (ok) {
+        done.push(use);
+        changed.push({ ...use, to: term, linked: Boolean(link) });
+      } else skipped.push({ ...use, reason: "refused" });
+    }
+    const want = replacedText(p.text, done, term);
+    const got = current()?.text;
+    if (got !== want)
+      throw new TermEverywhereError(
+        `A paragraph did not read as intended after the changes: expected "${want}", got "${got ?? "(missing)"}".`
+      );
+  }
+  changed.sort(
+    (a, b) => paragraphs.findIndex((p) => p.id === a.paragraphId) - paragraphs.findIndex((p) => p.id === b.paragraphId) || a.offset - b.offset
+  );
+  return { changed, skipped, addedDefinition };
+}
+
 // src/commands/index.ts
 function documentReader(view) {
   const root = () => view.part().root;
@@ -1150,9 +1354,11 @@ exports.DEFINITIONS_HEADING = DEFINITIONS_HEADING;
 exports.DEFINITION_BOOKMARK_PREFIX = DEFINITION_BOOKMARK_PREFIX;
 exports.FIELD_ATOM = FIELD_ATOM;
 exports.REF_BOOKMARK_PREFIX = REF_BOOKMARK_PREFIX;
+exports.TermEverywhereError = TermEverywhereError;
 exports.WATCHED_STYLES = WATCHED_STYLES;
 exports.W_NAMESPACES = W_NAMESPACES;
 exports.addDefinition = addDefinition;
+exports.applyTermEverywhere = applyTermEverywhere;
 exports.brokenCrossReferences = brokenCrossReferences;
 exports.compareTerms = compareTerms;
 exports.crossReferenceXml = crossReferenceXml;
@@ -1170,11 +1376,14 @@ exports.documentReferenceTooltip = documentReferenceTooltip;
 exports.documentStyleIds = documentStyleIds;
 exports.documentXml = documentXml;
 exports.docxPackage = docxPackage;
+exports.engineLength = engineLength;
+exports.engineOffset = engineOffset;
 exports.ensureTargetBookmark = ensureTargetBookmark;
 exports.esc = esc;
 exports.fieldNodeIds = fieldNodeIds;
 exports.filterTargets = filterTargets;
 exports.findDefinitionsSection = findDefinitionsSection;
+exports.findTermUses = findTermUses;
 exports.fragmentPackage = fragmentPackage;
 exports.headingParagraphXml = headingParagraphXml;
 exports.hyperlinkRelationship = hyperlinkRelationship;
@@ -1199,6 +1408,7 @@ exports.refInstruction = refInstruction;
 exports.refResult = refResult;
 exports.refTooltip = refTooltip;
 exports.refreshCrossReferences = refreshCrossReferences;
+exports.replaceSpan = replaceSpan;
 exports.sectionStates = sectionStates;
 exports.staleCrossReferences = staleCrossReferences;
 exports.styleNames = styleNames;