@portone/docx-editor 0.1.1 → 0.2.1

package/dist/page/usePageLayout.js

@@ -9,6 +9,7 @@ import {
 import { editorCssVariables } from "../styles/classNames.js";
 import { measureSheet } from "./measureBlocks.js";
 import {
+  pageBreaksIn,
   setPageBreakSpaces,
   setPagePushes,
   setTableContinuations
@@ -52,6 +53,27 @@ function useFrameThrottle(run, hold) {
 function sameOverlay(a, b) {
   return a !== null && a.left === b.left && a.top === b.top && a.width === b.width && a.sheetHeight === b.sheetHeight && JSON.stringify(a.marks) === JSON.stringify(b.marks) && JSON.stringify(a.badges) === JSON.stringify(b.badges) && JSON.stringify(a.pages) === JSON.stringify(b.pages);
 }
+function cutsToLegacyMarks(cuts, tables, doc) {
+  const spaces = [];
+  const tableContinuations = [];
+  for (const cut of cuts) {
+    const pos = doc.resolve(cut.at).before(1);
+    const block = doc.nodeAt(pos);
+    if (!block) continue;
+    const index = pageBreaksIn(block, pos).findIndex(
+      (found) => found.at === cut.at
+    );
+    if (index >= 0) {
+      spaces.push({ pos, index, height: cut.height });
+      continue;
+    }
+    const headers = tables.get(pos);
+    if (headers) {
+      tableContinuations.push({ pos: cut.at, height: cut.height, ...headers });
+    }
+  }
+  return { spaces, tableContinuations };
+}
 function usePageLayout({
   view,
   layer,
@@ -74,9 +96,14 @@ function usePageLayout({
         pageBodyHeight: page.bodyHeight,
         pageStep: page.pageStep
       });
+      const marks = cutsToLegacyMarks(
+        layout.cuts,
+        measured.tables,
+        view.state.doc
+      );
       setPagePushes(view, layout.pushes);
-      setPageBreakSpaces(view, layout.spaces);
-      setTableContinuations(view, layout.tableContinuations);
+      setPageBreakSpaces(view, marks.spaces);
+      setTableContinuations(view, marks.tableContinuations);
       const sheetHeight = measured.contentTop + layout.bodyHeight + measured.contentBottom;
       box.style.setProperty(editorCssVariables.sheetHeight, `${sheetHeight}px`);
       const next = {
@@ -137,5 +164,6 @@ function usePageLayout({
   return enabled ? overlay : null;
 }
 export {
+  cutsToLegacyMarks,
   usePageLayout
 };

package/dist/schema/attrRoles.d.ts

@@ -0,0 +1,35 @@
+/**
+ * What each attr of the schema is for, so that a judgement about a node can say which of them it
+ * is judging.
+ *
+ * An attr is one of three things. A `source` attr is what the exporter writes from: the XML the
+ * file arrived as, or a value the model owns that replaces part of it. A `display` attr is worked
+ * out from the source and the formatting around it, is never written, and is free to change the
+ * moment the surroundings do. A `session` attr says which block, control or link of the open
+ * document this is, and is never written either.
+ *
+ * The split exists because a display value changing is not the document changing. Opening a file
+ * in the editor re-derives a table's cell borders (`table/gridBorders`), and a comparison that
+ * counted that as an edit would rewrite a table nobody touched, losing the markup the writer does
+ * not model. `./sourceEquality` leaves display attrs out for that reason, and keeps session attrs
+ * in: two blocks that came from different places in the file are different blocks.
+ *
+ * `attrRoles.test.ts` holds this table against the schema in both directions, so an attr added
+ * without a role fails there before it can reach a judgement that does not know what to do with it.
+ */
+import { type MarkType, NodeType } from "prosemirror-model";
+export type AttrRole = "source" | "display" | "session";
+type AttrRoles = Readonly<Record<string, Readonly<Record<string, AttrRole>>>>;
+export declare const NODE_ATTR_ROLES: AttrRoles;
+export declare const MARK_ATTR_ROLES: AttrRoles;
+/**
+ * What this attr of this node or mark is for.
+ *
+ * An attr with no role declared is read as `source`: a judgement then compares it, which is the
+ * answer that reports a change rather than hiding one. `attrRoles.test.ts` is what keeps the case
+ * from arising.
+ */
+export declare function attrRole(type: NodeType | MarkType, name: string): AttrRole;
+/** The attrs of this node or mark that are worked out rather than written */
+export declare function displayAttrsOf(type: NodeType | MarkType): readonly string[];
+export {};

package/dist/schema/attrRoles.js

@@ -0,0 +1,106 @@
+// src/schema/attrRoles.ts
+import { NodeType } from "prosemirror-model";
+var NODE_ATTR_ROLES = {
+  paragraph: {
+    srcId: "session",
+    pAttrs: "source",
+    pPr: "source",
+    format: "display",
+    styleRun: "display"
+  },
+  table: {
+    srcId: "session",
+    tblAttrs: "source",
+    tblPr: "source",
+    tblW: "source",
+    gridCols: "source",
+    format: "display",
+    styleInside: "display",
+    styleCellMargins: "display"
+  },
+  tableRow: {
+    trAttrs: "source",
+    tblPrEx: "source",
+    trPr: "source",
+    format: "display"
+  },
+  tableCell: {
+    colspan: "source",
+    rowspan: "source",
+    // prosemirror-tables' own attr. Import writes null, the writer never reads it, and the table
+    // commands only carry it from one cell to another; a real column resize moves `gridCols`
+    colwidth: "display",
+    tcAttrs: "source",
+    tcPr: "source",
+    tcW: "source",
+    format: "display",
+    // Read from `sdtPrefix` rather than from the file, but a lock is not a display value: leaving
+    // it out of the comparison would let a step that unlocks a cell pass as a re-derivation
+    sdtPrefix: "source",
+    sdtContentsLocked: "source",
+    sdtDeletionLocked: "source"
+  },
+  rawBlock: { xml: "source", name: "source" },
+  docxRaw: { srcId: "session", name: "session" },
+  bookmarkBlock: { srcId: "session", name: "session" },
+  hardBreak: { brAttrs: "source" },
+  image: { src: "source", extent: "source", alt: "source", xml: "source" },
+  commentStart: { id: "source", xml: "source" },
+  commentEnd: { id: "source", xml: "source" },
+  commentReference: {
+    id: "source",
+    referenceXml: "source",
+    author: "source",
+    authorId: "source",
+    initials: "source",
+    date: "source",
+    text: "source",
+    commentXml: "source",
+    paraId: "source",
+    resolved: "source",
+    extensionXml: "source",
+    replies: "source",
+    // Read to decide whether the comment parts are rewritten at all; neither is written
+    imported: "session",
+    threadImported: "session"
+  },
+  noteReference: {
+    kind: "source",
+    id: "source",
+    customMarkFollows: "source",
+    referenceXml: "source",
+    // Both come from the notes part as the document was opened, and the writer puts back the
+    // reference alone: a note renumbered around an edit is the same reference it was
+    label: "display",
+    text: "display"
+  },
+  rawInline: { xml: "source" }
+};
+var MARK_ATTR_ROLES = {
+  run: { rPr: "source", rAttrs: "source", format: "display" },
+  sdt: {
+    sdtPrefix: "source",
+    // Counted through the document as it was opened, to tell one control from the next
+    sdtKey: "session",
+    contentsLocked: "source",
+    deletionLocked: "source"
+  },
+  link: { linkPrefix: "source", href: "source", linkKey: "session" },
+  tab: { tabAttrs: "source" }
+};
+function rolesOf(type) {
+  const roles = type instanceof NodeType ? NODE_ATTR_ROLES[type.name] : MARK_ATTR_ROLES[type.name];
+  return roles ?? {};
+}
+function attrRole(type, name) {
+  return rolesOf(type)[name] ?? "source";
+}
+function displayAttrsOf(type) {
+  return Object.entries(rolesOf(type)).filter(([, role]) => role === "display").map(([name]) => name);
+}
+export {
+  MARK_ATTR_ROLES,
+  NODE_ATTR_ROLES,
+  attrRole,
+  displayAttrsOf
+};

package/dist/schema/docxSchema.d.ts

@@ -1,6 +1,12 @@
 /**
  * ProseMirror schema joining preserved DOCX fragments with validated display values. Original XML
  * remains on nodes and marks so untouched content can round-trip verbatim.
+ *
+ * Every block sits in one of two groups beside `block`. A `modelled` block is one the editor
+ * takes apart and writes back out itself, so the writer decides what it says; a `preserved` one
+ * goes back out as the XML it arrived as. Which of the two a block is decides how it is written
+ * (`docx/serializeBlock`) and how a submitted file is compared against the original
+ * (`docx/storyProjection`), so a new block node has to name one of them.
  */
 import { Schema } from "prosemirror-model";
 export { imageNodeSpec, runMarkSpec } from "./rendering";