@portone/docx-editor 0.2.0 → 0.3.0

package/dist/schema/displayDerivation.js

@@ -0,0 +1,130 @@
+// src/schema/displayDerivation.ts
+import {
+  Mark
+} from "prosemirror-model";
+import { PluginKey } from "prosemirror-state";
+import {
+  AddMarkStep,
+  AttrStep,
+  ReplaceAroundStep
+} from "prosemirror-transform";
+import { attrRole } from "./attrRoles.js";
+function ownersByType(schema, derivers) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const deriver of derivers) {
+    for (const name of deriver.nodeTypes) {
+      const type = schema.nodes[name];
+      if (type === void 0 || type.isInline) {
+        throw new Error(
+          `${deriver.name} answers for ${name}, which the walk over the blocks never reaches`
+        );
+      }
+      const owning = owners.get(name) ?? [];
+      owning.push(deriver);
+      owners.set(name, owning);
+    }
+  }
+  return owners;
+}
+function displayLaidOver(standing, derived) {
+  const attrs = { ...standing.attrs };
+  for (const [name, value] of Object.entries(derived)) {
+    if (attrRole(standing.type, name) === "display") attrs[name] = value;
+  }
+  return attrs;
+}
+function nodeStanding(doc, pos) {
+  const node = doc.nodeAt(pos);
+  if (node === null) throw new Error(`no node stands at ${pos}`);
+  return node;
+}
+function deriveDisplay(transform, context, derivers, previousOf) {
+  const owners = ownersByType(transform.doc.type.schema, derivers);
+  const spots = [];
+  transform.doc.descendants((node, pos) => {
+    const owning = owners.get(node.type.name);
+    if (owning !== void 0) spots.push({ pos, owners: owning });
+    return !node.isTextblock;
+  });
+  for (const spot of spots) {
+    for (const deriver of spot.owners) {
+      const node = nodeStanding(transform.doc, spot.pos);
+      const derived = deriver.derive(
+        node,
+        spot.pos,
+        transform.doc,
+        context,
+        previousOf(node, spot.pos)
+      );
+      for (const { pos, attrs, mark: target } of derived) {
+        const standing = nodeStanding(transform.doc, pos);
+        if (target !== void 0) {
+          const mark = target.type.isInSet(standing.marks);
+          if (!standing.isInline || mark === void 0) continue;
+          const end = pos + standing.nodeSize - transform.doc.resolve(pos).textOffset;
+          if (target.to <= pos || target.to > end) {
+            throw new Error(
+              "a display mark update must stay within its inline node"
+            );
+          }
+          const next2 = target.type.create(displayLaidOver(mark, attrs));
+          if (!mark.eq(next2)) {
+            transform.step(new AddMarkStep(pos, target.to, next2));
+          }
+          continue;
+        }
+        const next = displayLaidOver(standing, attrs);
+        if (!standing.hasMarkup(standing.type, next, standing.marks)) {
+          transform.setNodeMarkup(pos, null, next);
+        }
+      }
+    }
+  }
+}
+var displayOnly = new PluginKey("docxEditorDisplayOnly");
+function sameOutsideDisplay(type, was, now) {
+  const names = /* @__PURE__ */ new Set([...Object.keys(was), ...Object.keys(now)]);
+  for (const name of names) {
+    if (attrRole(type, name) === "display") continue;
+    if (was[name] !== now[name]) return false;
+  }
+  return true;
+}
+function rewrittenNode(step, doc) {
+  const was = doc.nodeAt(step.from);
+  const now = step.slice.content.firstChild;
+  if (was === null || now === null || step.slice.content.childCount !== 1 || step.slice.openStart !== 0 || step.slice.openEnd !== 0 || now.content.size !== 0 || step.insert !== 1 || step.gapFrom !== step.from + 1 || step.to !== step.from + was.nodeSize || step.gapTo !== step.to - 1) {
+    return null;
+  }
+  return { was, now };
+}
+function changesOnlyDisplayAttrs(step, doc) {
+  if (step instanceof AddMarkStep) {
+    let touched = false;
+    let allowed = true;
+    doc.nodesBetween(step.from, step.to, (node, _pos, parent) => {
+      if (!node.isInline) return true;
+      if (!parent?.type.allowsMarkType(step.mark.type)) return false;
+      touched = true;
+      const previous = step.mark.type.isInSet(node.marks);
+      if (!previous || !sameOutsideDisplay(step.mark.type, previous.attrs, step.mark.attrs))
+        allowed = false;
+      return false;
+    });
+    return touched && allowed;
+  }
+  if (step instanceof AttrStep) {
+    const node = doc.nodeAt(step.pos);
+    return node !== null && attrRole(node.type, step.attr) === "display";
+  }
+  if (!(step instanceof ReplaceAroundStep)) return false;
+  const rewritten = rewrittenNode(step, doc);
+  if (rewritten === null) return false;
+  const { was, now } = rewritten;
+  return was.type === now.type && Mark.sameSet(was.marks, now.marks) && sameOutsideDisplay(was.type, was.attrs, now.attrs);
+}
+export {
+  changesOnlyDisplayAttrs,
+  deriveDisplay,
+  displayOnly
+};

package/dist/schema/docxSchema.d.ts

@@ -1,6 +1,15 @@
 /**
  * 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.
+ *
+ * `./attrRoles` declares each attr's provenance and comparison role; `attrClasses.test.ts`
+ * checks coverage. The plugin guide defines the supported public surface.
  */
 import { Schema } from "prosemirror-model";
 export { imageNodeSpec, runMarkSpec } from "./rendering";