@portone/docx-editor 0.5.1 → 0.6.1

package/dist/editor/plugins/commentRestoration.js

@@ -0,0 +1,168 @@
+// src/editor/plugins/commentRestoration.ts
+import {
+  Plugin,
+  TextSelection
+} from "prosemirror-state";
+import { storyKey, storyOf } from "../../docx/story.js";
+import { docxSchema } from "../../schema/index.js";
+import { editShut, transactionTouchesComments } from "../../schema/guards.js";
+import { stringAttr } from "../commands/comments/model.js";
+var NODE_FIELD = {
+  commentStart: "start",
+  commentEnd: "end",
+  commentReference: "reference"
+};
+var NODE_FIELDS = ["start", "end", "reference"];
+var MAPPING_SIDE = {
+  start: 1,
+  end: -1,
+  reference: -1
+};
+var NO_NODES = { start: null, end: null, reference: null };
+function commentNodesIn(doc) {
+  const found = /* @__PURE__ */ new Map();
+  doc.descendants((node, pos) => {
+    const field = NODE_FIELD[node.type.name];
+    if (field === void 0) return true;
+    const id = stringAttr(node.attrs.id);
+    if (id === null) return true;
+    const nodes = found.get(id) ?? { ...NO_NODES };
+    found.set(id, nodes);
+    if (nodes[field] === null) nodes[field] = { node, pos };
+    return true;
+  });
+  return found;
+}
+function inlineRanges(doc) {
+  const type = docxSchema.nodes.commentReference;
+  const ranges = [];
+  doc.descendants((node, pos) => {
+    if (!node.isTextblock) return true;
+    if (node.type.contentMatch.matchType(type) !== null) {
+      ranges.push({ from: pos + 1, to: pos + 1 + node.content.size });
+    }
+    return false;
+  });
+  return ranges;
+}
+function within(ranges, pos) {
+  return ranges.some((range) => pos >= range.from && pos <= range.to);
+}
+function* homes(ranges, wanted, caret) {
+  if (within(ranges, wanted)) yield wanted;
+  if (caret !== wanted && within(ranges, caret)) yield caret;
+  for (let index = ranges.length - 1; index >= 0; index -= 1) {
+    const range = ranges[index];
+    if (range !== void 0 && range.to < wanted) yield range.to;
+  }
+  for (const range of ranges) {
+    if (range.from > wanted) yield range.from;
+  }
+}
+function allowedHome(state, ranges, wanted, caret) {
+  for (const at of homes(ranges, wanted, caret)) {
+    if (!editShut(state, { kind: "insert", at })) return at;
+  }
+  return null;
+}
+function mappedThrough(transactions, pos, side) {
+  return transactions.reduce((at, tr) => tr.mapping.map(at, side), pos);
+}
+function restorable(node) {
+  return node.type.create(
+    node.attrs,
+    null,
+    node.marks.filter((mark) => mark.type === docxSchema.marks.run)
+  );
+}
+function planRestoration(transactions, oldState, newState) {
+  const before = commentNodesIn(oldState.doc);
+  const after = commentNodesIn(newState.doc);
+  const ranges = inlineRanges(newState.doc);
+  const caret = newState.selection.from;
+  const plan = { insertions: [], removals: [] };
+  for (const [id, was] of before) {
+    if (storyOf(newState.doc, storyKey("comment", id)) === null) continue;
+    const now = after.get(id) ?? NO_NODES;
+    for (const field of NODE_FIELDS) {
+      const lost = was[field];
+      if (lost === null || now[field] !== null) continue;
+      const counterpart = field === "start" ? now.end : field === "end" ? now.start : null;
+      if (field !== "reference" && counterpart === null) continue;
+      const at = allowedHome(
+        newState,
+        ranges,
+        mappedThrough(transactions, lost.pos, MAPPING_SIDE[field]),
+        caret
+      );
+      if (at !== null) {
+        plan.insertions.push({
+          node: restorable(lost.node),
+          at,
+          was: lost.pos
+        });
+      } else if (counterpart !== null && !markerShut(newState, counterpart)) {
+        plan.removals.push(counterpart);
+      }
+    }
+  }
+  return plan;
+}
+function markerShut(state, marker) {
+  return editShut(state, {
+    kind: "replace",
+    from: marker.pos,
+    to: marker.pos + marker.node.nodeSize
+  });
+}
+function pastCommentNodes(doc, pos, direction) {
+  let at = pos;
+  for (; ; ) {
+    const resolved = doc.resolve(at);
+    const next = direction < 0 ? resolved.nodeBefore : resolved.nodeAfter;
+    if (next === null || NODE_FIELD[next.type.name] === void 0) return at;
+    at += direction * next.nodeSize;
+  }
+}
+function withCaretPastMarkers(tr, oldState, newState) {
+  const { selection } = newState;
+  if (!(selection instanceof TextSelection) || !selection.empty) return tr;
+  if (!tr.doc.eq(oldState.doc)) return tr;
+  const direction = selection.from < oldState.selection.from ? -1 : 1;
+  return tr.setSelection(
+    TextSelection.create(
+      tr.doc,
+      pastCommentNodes(tr.doc, tr.selection.from, direction)
+    )
+  );
+}
+function restoration(transactions, oldState, newState) {
+  const plan = planRestoration(transactions, oldState, newState);
+  if (plan.insertions.length === 0 && plan.removals.length === 0) return null;
+  const tr = newState.tr;
+  for (const marker of [...plan.removals].sort(
+    (left, right) => right.pos - left.pos
+  )) {
+    tr.delete(marker.pos, marker.pos + marker.node.nodeSize);
+  }
+  const ordered = [...plan.insertions].sort(
+    (left, right) => left.at - right.at || left.was - right.was
+  );
+  for (const { node, at } of ordered) {
+    tr.insert(tr.mapping.map(at), node);
+  }
+  if (!tr.docChanged) return null;
+  return withCaretPastMarkers(tr, oldState, newState);
+}
+function commentRestoration() {
+  return new Plugin({
+    appendTransaction(transactions, oldState, newState) {
+      if (!transactions.some((tr) => tr.docChanged)) return null;
+      if (!transactions.some(transactionTouchesComments)) return null;
+      return restoration(transactions, oldState, newState);
+    }
+  });
+}
+export {
+  commentRestoration
+};

package/dist/editor/plugins/compositionSelection.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Takes the selected text away before a composition opens over it.
+ *
+ * A composition normally replaces what is selected because the browser does the replacing and
+ * ProseMirror reads the result back. Chrome will not touch a selection that begins at an element
+ * it may not edit - the number a note is drawn by, a note reference - and does not say so: the
+ * composition lands beside the words it was meant to replace, or nothing happens at all. A note
+ * meets it every time, since its first paragraph opens with its number and selecting the whole of
+ * a note to write it again is an ordinary thing to do.
+ *
+ * So the selection is deleted here, in the frame the composition opens in and before ProseMirror
+ * marks the view as composing, which leaves the composition starting from a caret with nothing
+ * for the browser to refuse. ProseMirror does the same for a selection spanning whole blocks
+ * (`endComposition`).
+ *
+ * The deletion is an edit like any other, so the guards judge it: across a bookmark marker it is
+ * refused, and the composition is left to the browser where it stood.
+ */
+import { Plugin } from "prosemirror-state";
+export declare function compositionSelection(): Plugin;

package/dist/editor/plugins/compositionSelection.js

@@ -0,0 +1,19 @@
+// src/editor/plugins/compositionSelection.ts
+import { deleteSelection } from "prosemirror-commands";
+import { Plugin } from "prosemirror-state";
+function compositionSelection() {
+  return new Plugin({
+    props: {
+      handleDOMEvents: {
+        compositionstart(view) {
+          if (view.state.selection.empty) return false;
+          deleteSelection(view.state, (tr) => view.dispatch(tr));
+          return false;
+        }
+      }
+    }
+  });
+}
+export {
+  compositionSelection
+};

package/dist/editor/plugins/keymap.d.ts

@@ -2,6 +2,7 @@
  * Keys not handled here are taken by ProseMirror's base keymap.
  */
 import { type Command, Plugin } from "prosemirror-state";
+import type { NoteKind } from "../../schema/stories";
 /**
  * Keeps undo and redo on their keys where the keymap above cannot reach them.
  *
@@ -12,4 +13,17 @@ import { type Command, Plugin } from "prosemirror-state";
  * second time.
  */
 export declare function historyKeys(): Plugin;
+/**
+ * Whether the editor is running on a Mac, which decides the Mod key and what the system takes
+ * before a page sees it.
+ */
+export declare function onMac(): boolean;
+/**
+ * The key each kind of note is put in on.
+ *
+ * They are Word's own, except that Word for Windows' endnote key is the system's on a Mac:
+ * Cmd+Option+D hides the Dock, so the editor is never asked about it, and Word for Mac puts an
+ * endnote on Cmd+Option+E. The footnote key is the same on both, which is Google Docs' as well.
+ */
+export declare const NOTE_KEYS: Readonly<Record<NoteKind, string>>;
 export declare const docxKeymap: Record<string, Command>;

package/dist/editor/plugins/keymap.js

@@ -22,6 +22,7 @@ import {
   increaseListLevel,
   leaveEmptyListItem
 } from "../commands/listCommands.js";
+import { insertEndnote, insertFootnote } from "../commands/noteCommands.js";
 import { insertTab, moveAcrossTab } from "../commands/tabCommands.js";
 import { openLinkPanel } from "./linkPanel.js";
 var insertTabFromKeyboard = (state, dispatch, view) => {
@@ -91,6 +92,13 @@ function historyKeys() {
     }
   });
 }
+function onMac() {
+  return typeof navigator !== "undefined" && navigator.platform.includes("Mac");
+}
+var NOTE_KEYS = {
+  footnote: "Mod-Alt-f",
+  endnote: onMac() ? "Mod-Alt-e" : "Mod-Alt-d"
+};
 var docxKeymap = {
   Enter: chainCommands(leaveEmptyListItem, splitParagraph),
   "Shift-Enter": insertLineBreak,
@@ -107,6 +115,8 @@ var docxKeymap = {
   // The link key Word and Google Docs share. It opens the panel over the selection, and with
   // nothing there to link it reports that it did nothing, so the browser keeps its own Cmd+K
   "Mod-k": openLinkPanel,
+  [NOTE_KEYS.footnote]: insertFootnote,
+  [NOTE_KEYS.endnote]: insertEndnote,
   // Inside a table, moving between cells comes first (Word does the same).
   // In a list paragraph outside a table it shifts the level; an ordinary paragraph gets a document tab.
   Tab: chainCommands(
@@ -124,6 +134,8 @@ var docxKeymap = {
   "Shift-ArrowRight": moveAcrossTab("right", true)
 };
 export {
+  NOTE_KEYS,
   docxKeymap,
-  historyKeys
+  historyKeys,
+  onMac
 };

package/dist/editor/plugins/noteLifecycle.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Keeps each note of an editable kind in step with the references that call it.
+ *
+ * A note is written once and called from the text by its id, so what an edit does to the text
+ * decides what becomes of the note. An edit that takes away the last reference to a note takes the
+ * note away with it. An edit that copies a reference gives the copy a new id and a copy of the
+ * note, since two references naming one id are one note drawn with one number where the reader
+ * made two. A reference moved whole keeps its id and its note. Either change goes in a transaction
+ * appended to the edit, so it lands in the edit's history event and one undo takes both back.
+ *
+ * Only what the edit did is read. An entry the file arrived with and no reference to is never
+ * reached, a reference naming no note is left naming none, and the separators a notes part lays
+ * the page out with are left as they are. The notes part writer relies on the first of these: a
+ * note disappears only together with its last reference (`docx/storyParts`).
+ */
+import { Plugin } from "prosemirror-state";
+import { type NoteKind } from "../../schema/stories";
+export declare function noteLifecycle(kinds?: readonly NoteKind[]): Plugin;

package/dist/editor/plugins/noteLifecycle.js

@@ -0,0 +1,117 @@
+// src/editor/plugins/noteLifecycle.ts
+import { Plugin } from "prosemirror-state";
+import { DocAttrStep, Mapping } from "prosemirror-transform";
+import {
+  copiedNoteStory,
+  nextNoteId,
+  takenNoteIds
+} from "../../docx/notes/newNote.js";
+import { setStory, withoutStories } from "../../docx/story.js";
+import { displayOnly } from "../../schema/displayDerivation.js";
+import { stepReaches } from "../../schema/guards.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  storyKey,
+  storyNodeOf
+} from "../../schema/stories.js";
+import { documentOf } from "../editorDocument.js";
+function kindOf(node, kinds) {
+  if (node.type.name !== "noteReference") return null;
+  return kinds.find((kind) => kind === node.attrs.kind) ?? null;
+}
+function referencesIn(doc, kinds) {
+  const found = [];
+  doc.descendants((node, pos) => {
+    const kind = kindOf(node, kinds);
+    const id = node.attrs.id;
+    if (kind !== null && typeof id === "string") {
+      found.push({ kind, key: storyKey(kind, id), pos });
+    }
+    return true;
+  });
+  return found;
+}
+function countsOf(references) {
+  return references.reduce(
+    (counts, { key }) => counts.set(key, (counts.get(key) ?? 0) + 1),
+    /* @__PURE__ */ new Map()
+  );
+}
+function reachesReferences(tr, kinds) {
+  if (!tr.docChanged || tr.getMeta(displayOnly) === true) return false;
+  return tr.steps.some(
+    (step, index) => !(step instanceof DocAttrStep) && stepReaches(
+      step,
+      tr.docs[index],
+      tr.docs[index + 1] ?? tr.doc,
+      (node) => kindOf(node, kinds) !== null
+    )
+  );
+}
+function copiedReferences(transactions, before, after) {
+  const found = countsOf(before);
+  const left = countsOf(after);
+  const mapping = new Mapping(transactions.flatMap((tr) => tr.mapping.maps));
+  const carried = new Set(
+    before.flatMap(({ key, pos }) => {
+      const mapped = mapping.mapResult(pos, 1);
+      return mapped.deletedAfter ? [] : [`${key}@${mapped.pos}`];
+    })
+  );
+  const wasCarried = ({ key, pos }) => carried.has(`${key}@${pos}`);
+  return [...left].flatMap(([key, count]) => {
+    const kept = found.get(key) ?? 0;
+    if (kept === 0 || count <= kept) return [];
+    const standing = after.filter((reference) => reference.key === key);
+    return [
+      ...standing.filter(wasCarried),
+      ...standing.filter((reference) => !wasCarried(reference))
+    ].slice(kept);
+  });
+}
+function settled(transactions, oldState, newState, kinds) {
+  const document = documentOf(newState);
+  const isNote = (key) => !document.specialNotes.has(key) && storyNodeOf(newState.doc, key) !== null;
+  const before = referencesIn(oldState.doc, kinds);
+  const after = referencesIn(newState.doc, kinds);
+  const left = countsOf(after);
+  const gone = [...countsOf(before).keys()].filter(
+    (key) => !left.has(key) && isNote(key)
+  );
+  const copies = copiedReferences(transactions, before, after).filter(({ key }) => isNote(key)).sort((a, b) => a.pos - b.pos);
+  if (gone.length === 0 && copies.length === 0) return null;
+  const tr = withoutStories(newState.tr, gone);
+  const taken = /* @__PURE__ */ new Map();
+  for (const copy of copies) {
+    const story = storyNodeOf(newState.doc, copy.key);
+    if (story === null) continue;
+    const ids = taken.get(copy.kind) ?? takenNoteIds(newState.doc, copy.kind, document.reservedNoteKeys);
+    taken.set(copy.kind, ids);
+    const id = nextNoteId(ids);
+    ids.add(id);
+    tr.setNodeAttribute(copy.pos, "id", id).setNodeAttribute(
+      copy.pos,
+      "referenceXml",
+      null
+    );
+    setStory(
+      tr,
+      storyKey(copy.kind, id),
+      copiedNoteStory(story, document.session)
+    );
+  }
+  return tr;
+}
+function noteLifecycle(kinds = EDITABLE_NOTE_KINDS) {
+  return new Plugin({
+    appendTransaction(transactions, oldState, newState) {
+      if (!transactions.some((tr) => reachesReferences(tr, kinds))) {
+        return null;
+      }
+      return settled(transactions, oldState, newState, kinds);
+    }
+  });
+}
+export {
+  noteLifecycle
+};

package/dist/editor/plugins/noteNavigation.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Getting into a note and asking for one to be opened.
+ *
+ * A press on a note's number or a command asks for a note, and neither can mount anything itself,
+ * since what draws the notes is the surface around the editor; so the request is held in the state
+ * and the surface reads it back (`requestedNote`). The nonce is what makes a second request for
+ * the note already open reach the surface at all.
+ *
+ * The request moves the caret to just after the reference as it goes in, which is where Escape
+ * hands it back to (`editor/notes/noteSurface`), so leaving a note needs nothing remembered.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type Command, type EditorState, Plugin, type Transaction } from "prosemirror-state";
+import { type NoteKind, type StoryKey } from "../../schema/stories";
+/** Which note the reader asked for, and which asking it was */
+export interface RequestedNote {
+    readonly key: StoryKey;
+    /** Rises with every request, so asking twice for one note is two requests */
+    readonly nonce: number;
+}
+/** One reference to a note, as the document holds it */
+export interface PlacedNoteReference {
+    readonly pos: number;
+    readonly node: PMNode;
+}
+/** Where the first reference to this note stands, and null where the document holds none */
+export declare function noteReferenceAt(doc: PMNode, kind: NoteKind, id: string): PlacedNoteReference | null;
+/** The transaction with the note it opens recorded on it, which `insertFootnote` also carries */
+export declare function requestNote<T extends Transaction>(tr: T, key: StoryKey): T;
+/** The note last asked for, and null where none was. Null for a state built without the plugin */
+export declare function requestedNote(state: EditorState): RequestedNote | null;
+/**
+ * Puts the caret just after the note's reference and asks for the note to be opened. It applies
+ * under every mode, since opening a note is reading it; what a reader may do once it stands open
+ * is the story view's question (`editor/stories`).
+ */
+export declare function openNoteCommand(kind: NoteKind, id: string): Command;
+/**
+ * Holds the note last asked for, and turns a press on a note's number into that asking.
+ *
+ * One press is what opens a note, which is what Google Docs does: the number is a small
+ * superscript, and a press on one is far more often a reader going to the note than a caret being
+ * placed on the digit. A reference to a kind no writer puts back opens nothing.
+ */
+export declare function noteNavigation(kinds?: readonly NoteKind[]): Plugin<RequestedNote | null>;

package/dist/editor/plugins/noteNavigation.js

@@ -0,0 +1,86 @@
+// src/editor/plugins/noteNavigation.ts
+import {
+  Plugin,
+  PluginKey,
+  TextSelection
+} from "prosemirror-state";
+import { docxSchema } from "../../schema/index.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  storyKey,
+  storyNodeOf
+} from "../../schema/stories.js";
+import { documentOf } from "../editorDocument.js";
+var navigationKey = new PluginKey(
+  "docxEditorNoteNavigation"
+);
+function noteReferenceAt(doc, kind, id) {
+  let found = null;
+  doc.descendants((node, pos) => {
+    if (found !== null) return false;
+    if (node.type === docxSchema.nodes.noteReference && node.attrs.kind === kind && node.attrs.id === id) {
+      found = { pos, node };
+    }
+    return found === null;
+  });
+  return found;
+}
+function isRequest(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return typeof Reflect.get(value, "key") === "string" && typeof Reflect.get(value, "nonce") === "number";
+}
+var asked = 0;
+function requestNote(tr, key) {
+  asked += 1;
+  return tr.setMeta(navigationKey, { key, nonce: asked });
+}
+function requestedNote(state) {
+  return navigationKey.getState(state) ?? null;
+}
+function openNoteCommand(kind, id) {
+  return (state, dispatch) => {
+    const key = storyKey(kind, id);
+    if (documentOf(state).specialNotes.has(key)) return false;
+    if (storyNodeOf(state.doc, key) === null) return false;
+    const found = noteReferenceAt(state.doc, kind, id);
+    if (found === null) return false;
+    if (dispatch) {
+      const after = found.pos + found.node.nodeSize;
+      const tr = state.tr.setSelection(
+        TextSelection.near(state.doc.resolve(after))
+      );
+      dispatch(requestNote(tr, key).scrollIntoView());
+    }
+    return true;
+  };
+}
+function noteNavigation(kinds = EDITABLE_NOTE_KINDS) {
+  return new Plugin({
+    key: navigationKey,
+    state: {
+      init: () => null,
+      apply: (tr, held) => {
+        const next = tr.getMeta(navigationKey);
+        return isRequest(next) ? next : held;
+      }
+    },
+    props: {
+      handleClickOn(view, _pos, node, _nodePos, _event, direct) {
+        if (!direct || node.type !== docxSchema.nodes.noteReference) {
+          return false;
+        }
+        const kind = kinds.find((named) => named === node.attrs.kind);
+        const id = node.attrs.id;
+        if (kind === void 0 || typeof id !== "string") return false;
+        return openNoteCommand(kind, id)(view.state, view.dispatch);
+      }
+    }
+  });
+}
+export {
+  noteNavigation,
+  noteReferenceAt,
+  openNoteCommand,
+  requestNote,
+  requestedNote
+};

package/dist/editor/plugins/noteNumbering.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from "prosemirror-state";
+import { noteLabelsIn } from "../../docx/notes/numbering";
+export type NoteLabeller = typeof noteLabelsIn;
+/**
+ * Labels the note references again after a change that moves one, moves a section break, or
+ * replaces the numbering the snapshot holds.
+ *
+ * A label is a display value of an inline node, which the display derivation walk does not reach,
+ * so it is written here under the same pass: a relabel goes through a lock around the reference,
+ * and one undo takes it back with the edit that caused it. The relabel after a snapshot change
+ * follows no edit and goes to the history not at all.
+ */
+export declare function noteNumbering(labelsIn?: NoteLabeller): Plugin;

package/dist/editor/plugins/noteNumbering.js

@@ -0,0 +1,58 @@
+// src/editor/plugins/noteNumbering.ts
+import { Plugin } from "prosemirror-state";
+import { DocAttrStep } from "prosemirror-transform";
+import { noteLabelSignature, noteLabelsIn } from "../../docx/notes/numbering.js";
+import { sectionBreakOf } from "../../docx/sections.js";
+import { displayOnly } from "../../schema/displayDerivation.js";
+import { stepReaches } from "../../schema/guards.js";
+import { documentOf } from "../editorDocument.js";
+function countsNotes(node) {
+  if (node.type.name === "noteReference") return true;
+  const pPr = node.attrs.pPr;
+  return node.type.name === "paragraph" && typeof pPr === "string" && sectionBreakOf(pPr) !== null;
+}
+function reachesLabels(tr) {
+  return tr.steps.some(
+    (step, index) => step instanceof DocAttrStep ? step.attr === "sectPr" : stepReaches(
+      step,
+      tr.docs[index],
+      tr.docs[index + 1] ?? tr.doc,
+      countsNotes
+    )
+  );
+}
+function labelsMayHaveMoved(transactions, oldState, newState) {
+  return transactions.some(reachesLabels) && noteLabelSignature(oldState.doc) !== noteLabelSignature(newState.doc);
+}
+function numberingReplaced(before, after) {
+  return before.noteNumbering !== after.noteNumbering || before.specialNotes !== after.specialNotes;
+}
+function noteNumbering(labelsIn = noteLabelsIn) {
+  return new Plugin({
+    appendTransaction(transactions, oldState, newState) {
+      const document = documentOf(newState);
+      const replaced = numberingReplaced(documentOf(oldState), document);
+      if (!replaced && !labelsMayHaveMoved(transactions, oldState, newState)) {
+        return null;
+      }
+      const labels = labelsIn(
+        newState.doc,
+        document.noteNumbering,
+        document.specialNotes
+      );
+      const tr = newState.tr;
+      for (const [pos, label] of labels) {
+        if (tr.doc.nodeAt(pos)?.attrs.label !== label) {
+          tr.setNodeAttribute(pos, "label", label);
+        }
+      }
+      if (!tr.docChanged) return null;
+      tr.setMeta(displayOnly, true);
+      if (replaced) tr.setMeta("addToHistory", false);
+      return tr;
+    }
+  });
+}
+export {
+  noteNumbering
+};

package/dist/editor/plugins/rowResize.js

@@ -4,6 +4,7 @@ import { TableMap } from "prosemirror-tables";
 import { Decoration, DecorationSet } from "prosemirror-view";
 import { isLockedCell } from "../../schema/locks.js";
 import { editorClassNames } from "../../styles/classNames.js";
+import { pageScaleAround } from "../../styles/visualScale.js";
 import {
   buildResizeRowTransaction,
   resizedRowHeight,
@@ -52,12 +53,6 @@ function edgeUnder(view, event) {
   if (!(rowDom instanceof HTMLTableRowElement)) return null;
   return { ...spot, ...hit, tableDom, rowDom, rowPos };
 }
-function visualScale(view) {
-  const layer = view.dom.closest(`.${editorClassNames.pageLayer}`);
-  const raw = layer instanceof HTMLElement ? getComputedStyle(layer).zoom : "";
-  const parsed = Number.parseFloat(raw);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
-}
 function previewDecorations(doc, preview) {
   const row = doc.nodeAt(preview.rowPos);
   if (row?.type.spec.tableRole !== "row") return DecorationSet.empty;
@@ -137,7 +132,7 @@ function rowResize() {
   function start(view, event) {
     const target = edgeUnder(view, event);
     if (!target) return false;
-    const scale = visualScale(view);
+    const scale = pageScaleAround(view.dom);
     const startHeightPt = target.rowDom.getBoundingClientRect().height / scale * (72 / 96);
     drag = {
       view,

package/dist/editor/plugins/tabLayout.js

@@ -5,6 +5,7 @@ import { PX_PER_PT } from "../../docx/pageGeometry.js";
 import { toParagraphFormat } from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
 import { editorClassNames, editorCssVariables } from "../../styles/classNames.js";
+import { pageScaleAround } from "../../styles/visualScale.js";
 import { documentDefaultTabStopPt } from "../documentStyles.js";
 import { setTabWidths, tabWidths } from "./tabDecorations.js";
 var POSITION_EPSILON_PT = 0.01;
@@ -46,11 +47,6 @@ function numeric(value) {
 function computedStyle(element) {
   return element.ownerDocument.defaultView?.getComputedStyle(element) ?? getComputedStyle(element);
 }
-function scaleOf(view) {
-  const layer = view.dom.closest(`.${editorClassNames.pageLayer}`);
-  const parsed = Number.parseFloat(layer ? computedStyle(layer).zoom : "");
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
-}
 function paragraphLayoutContext(view, slot) {
   const $pos = view.state.doc.resolve(view.posAtDOM(slot, 0));
   for (let depth = $pos.depth; depth > 0; depth -= 1) {
@@ -84,7 +80,6 @@ function cloneParagraph(paragraph, widthPx, resetTabs) {
   clone.style.textAlign = "start";
   clone.style.visibility = "hidden";
   clone.style.pointerEvents = "none";
-  clone.style.zoom = "1";
   clone.setAttribute("aria-hidden", "true");
   if (resetTabs) {
     for (const slot of clone.querySelectorAll(
@@ -221,7 +216,7 @@ function sameWidths(left, right) {
   return true;
 }
 function measureTabs(view, cache, generation) {
-  const scale = scaleOf(view);
+  const scale = pageScaleAround(view.dom);
   const defaultStopPt = documentDefaultTabStopPt(view.state);
   const widths = new Map(tabWidths(view.state));
   const paragraphs = /* @__PURE__ */ new Map();