@portone/docx-editor 0.2.0 → 0.3.0

package/dist/docx/invariants.js

@@ -0,0 +1,256 @@
+// src/docx/invariants.ts
+import { spanCount } from "../model/format.js";
+import {
+  attributeByLocalName,
+  parseXml,
+  W_NS,
+  withXmlParser
+} from "../ooxml/xml.js";
+import {
+  commentReferencesIn,
+  commentsChanged,
+  commentsRootProblem,
+  extensionsChanged,
+  extensionsRootProblem
+} from "./comments.js";
+import {
+  commentsExtendedPart,
+  commentsPart,
+  peoplePart
+} from "./comments/parts.js";
+import { unrecordedAuthors } from "./comments/people.js";
+import { currentCommentBodies } from "./comments/writing.js";
+import { identityProblems } from "./identities.js";
+import { insertedImageSrcs } from "./media.js";
+import { newNumIds, numberingPartOf } from "./newLists.js";
+import { CONTENT_TYPES_PATH } from "./packageParts.js";
+import { lostOriginal } from "./serializeBlock.js";
+import {
+  originalBlock,
+  sessionOf
+} from "./session.js";
+function markerSourceOf(node, session) {
+  if (node.type.name === "rawInline" || node.type.name === "rawBlock") {
+    return typeof node.attrs.xml === "string" ? node.attrs.xml : null;
+  }
+  if (node.type.isInGroup("preserved")) {
+    return originalBlock(node, session)?.xml ?? null;
+  }
+  return null;
+}
+var bookmarkPairs = {
+  name: "bookmarkPairs",
+  check(doc, session) {
+    const problems = [];
+    const open = /* @__PURE__ */ new Map();
+    const used = /* @__PURE__ */ new Set();
+    doc.descendants((node, pos) => {
+      const source = markerSourceOf(node, session);
+      if (source === null) return true;
+      if (!source.includes("bookmark")) return true;
+      let root;
+      try {
+        root = parseXml(
+          session.documentPrefix + source + session.documentSuffix
+        ).documentElement;
+      } catch {
+        problems.push({
+          code: "malformed-xml",
+          message: "preserved bookmark XML could not be parsed",
+          pos
+        });
+        return true;
+      }
+      for (const marker of Array.from(root.getElementsByTagName("*"))) {
+        if (marker.namespaceURI !== W_NS || marker.localName !== "bookmarkStart" && marker.localName !== "bookmarkEnd")
+          continue;
+        const kind = marker.localName.slice("bookmark".length);
+        const value = attributeByLocalName(marker, "id");
+        if (value === null || value === "") {
+          problems.push({
+            code: "malformed-xml",
+            message: `a bookmark${kind} has no id`,
+            pos
+          });
+        } else if (kind === "Start") {
+          if (used.has(value)) {
+            problems.push({
+              code: "malformed-xml",
+              message: `bookmark ${value} has more than one start marker`,
+              pos
+            });
+          } else {
+            open.set(value, pos);
+            used.add(value);
+          }
+        } else if (!open.delete(value)) {
+          problems.push({
+            code: "malformed-xml",
+            message: `bookmark ${value} ends without an earlier start marker`,
+            pos
+          });
+        }
+      }
+      return true;
+    });
+    for (const [id, pos] of open) {
+      problems.push({
+        code: "malformed-xml",
+        message: `bookmark ${id} has no end marker`,
+        pos
+      });
+    }
+    return problems;
+  }
+};
+function mergeReachesPastLastRow(table) {
+  let overlong = false;
+  table.forEach((row, _offset, at) => {
+    row.forEach((cell) => {
+      if (at + spanCount(cell.attrs.rowspan) > table.childCount) {
+        overlong = true;
+      }
+    });
+  });
+  return overlong;
+}
+var tableGrids = {
+  name: "tableGrids",
+  check(doc) {
+    const problems = [];
+    doc.descendants((node, pos) => {
+      if (node.type.name !== "table") return true;
+      if (mergeReachesPastLastRow(node)) {
+        problems.push({
+          code: "invalid-table",
+          message: "a vertical merge in the table reaches past the last row",
+          pos
+        });
+      }
+      return true;
+    });
+    return problems;
+  }
+};
+function lostOriginalOf(node, session) {
+  if (node.type.name === "rawInline" || node.type.name === "rawBlock") {
+    return typeof node.attrs.xml === "string" ? null : "a preserved element has lost its original XML";
+  }
+  if (node.type.isInGroup("preserved")) {
+    return originalBlock(node, session) ? null : lostOriginal(node, session);
+  }
+  return null;
+}
+var preservedOriginals = {
+  name: "preservedOriginals",
+  check(doc, session) {
+    const problems = [];
+    doc.descendants((node, pos) => {
+      const message = lostOriginalOf(node, session);
+      if (message !== null)
+        problems.push({ code: "lost-original", message, pos });
+      return true;
+    });
+    return problems;
+  }
+};
+var uniqueIdentities = {
+  name: "uniqueIdentities",
+  check(doc) {
+    return identityProblems(doc);
+  }
+};
+var numberingPart = {
+  name: "numberingPart",
+  check(doc, session) {
+    if (numberingPartOf(session) !== null) return [];
+    if (newNumIds(doc, session).length === 0) return [];
+    return [
+      {
+        code: "missing-numbering-part",
+        message: "cannot add a new list to a document that has no numbering.xml"
+      }
+    ];
+  }
+};
+function addsCommentsPart(doc, session) {
+  const bodyChanged = commentsChanged(doc, session);
+  const threadChanged = extensionsChanged(doc, session);
+  if (!bodyChanged && !threadChanged) return false;
+  if (commentsPart.pathIn(session) === null || session.comments.xml === null)
+    return true;
+  const references = commentReferencesIn(doc);
+  if (threadChanged && (references.size > 0 || session.comments.extendedPartPath !== null) && (commentsExtendedPart.pathIn(session) === null || session.comments.extendedXml === null))
+    return true;
+  return bodyChanged && (peoplePart.pathIn(session) === null || session.comments.people.xml === null) && unrecordedAuthors(
+    currentCommentBodies(references).values(),
+    session.comments.people
+  ).size > 0;
+}
+var mediaContentTypes = {
+  name: "mediaContentTypes",
+  check(doc, session) {
+    if (session.parts.has(CONTENT_TYPES_PATH)) return [];
+    const problems = [];
+    if (insertedImageSrcs(doc).length > 0) {
+      problems.push({
+        code: "missing-content-types",
+        message: `cannot add an image to a package that has no ${CONTENT_TYPES_PATH}`
+      });
+    }
+    if (addsCommentsPart(doc, session)) {
+      problems.push({
+        code: "missing-content-types",
+        message: `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`
+      });
+    }
+    return problems;
+  }
+};
+var commentPartRoots = {
+  name: "commentPartRoots",
+  check(doc, session) {
+    const problems = [];
+    const { xml, extendedXml, extendedPartPath } = session.comments;
+    if (xml !== null && commentsChanged(doc, session)) {
+      const problem = commentsRootProblem(xml);
+      if (problem !== null)
+        problems.push({ code: "malformed-xml", message: problem });
+    }
+    if (extendedXml !== null && extensionsChanged(doc, session) && (commentReferencesIn(doc).size > 0 || extendedPartPath !== null)) {
+      const problem = extensionsRootProblem(extendedXml);
+      if (problem !== null)
+        problems.push({ code: "malformed-xml", message: problem });
+    }
+    return problems;
+  }
+};
+var EXPORT_INVARIANTS = [
+  bookmarkPairs,
+  tableGrids,
+  preservedOriginals,
+  uniqueIdentities,
+  numberingPart,
+  mediaContentTypes,
+  commentPartRoots
+];
+var answered = /* @__PURE__ */ new WeakMap();
+function problemsOf(doc, session) {
+  const known = answered.get(doc);
+  if (known && known.session === session) return known.problems;
+  const problems = EXPORT_INVARIANTS.flatMap(
+    (invariant) => invariant.check(doc, session)
+  );
+  answered.set(doc, { session, problems });
+  return problems;
+}
+function exportProblems(doc, session, options) {
+  return withXmlParser(
+    options?.xmlParser,
+    () => problemsOf(doc, sessionOf(session))
+  );
+}
+export {
+  exportProblems,
+  problemsOf
+};

package/dist/docx/media.d.ts

@@ -3,7 +3,7 @@
  * bytes without blob-URL lifetime management; `MAX_IMAGE_BYTES` bounds the memory tradeoff.
  */
 import type { Node as PMNode } from "prosemirror-model";
-import { type RelationshipWriter } from "./relationships";
+import type { PartPlanContext } from "./partPlan";
 import type { SessionStore } from "./session";
 /** The images the body can refer to, as data URLs keyed by relationship id */
 export type ImageSources = ReadonlyMap<string, string>;
@@ -46,10 +46,12 @@ export interface MediaAdditions {
     /** The parts to write into the zip alongside the body */
     parts: ReadonlyMap<string, Uint8Array>;
 }
+/** The srcs of the images that were not in the document when it was opened, in document order */
+export declare function insertedImageSrcs(doc: PMNode): string[];
 /**
  * What the package needs for the images that were inserted during editing: the media parts,
- * the relationships pointing at them, and the content types declaring them.
- * null when every image in the document came out of the document itself.
+ * with the relationships pointing at them and the content types declaring them asked of the
+ * context. null when every image in the document came out of the document itself.
  *
  * The relationships go through the writer the export shares between its writers
  * (`docx/relationships`), so the part is written once with everything in it.
@@ -57,4 +59,4 @@ export interface MediaAdditions {
  * Bytes that are already in the package are not written a second time: an inserted image
  * whose fingerprint matches one that is already there reuses its relationship.
  */
-export declare function planImageMedia(doc: PMNode, session: SessionStore, relationships: RelationshipWriter): MediaAdditions | null;
+export declare function planImageMedia(doc: PMNode, session: SessionStore, context: PartPlanContext): MediaAdditions | null;

package/dist/docx/media.js

@@ -5,7 +5,7 @@ import {
   imageMimeOf,
   toImageSrc
 } from "../ooxml/image.js";
-import { decodeUtf8, encodeUtf8, R_NS } from "../ooxml/xml.js";
+import { R_NS } from "../ooxml/xml.js";
 import {
   directoryOf,
   readRelationships,
@@ -13,7 +13,6 @@ import {
   resolveTarget
 } from "./relationships.js";
 var IMAGE_REL_TYPE = `${R_NS}/image`;
-var CONTENT_TYPES_PATH = "[Content_Types].xml";
 var EXTENSION_BY_MIME = {
   "image/png": "png",
   "image/jpeg": "jpeg",
@@ -114,6 +113,7 @@ function decodeImage(src) {
     const bytes = fromBase64(imageBase64Of(src));
     return {
       bytes,
+      mime,
       extension: EXTENSION_BY_MIME[mime],
       key: contentKey(bytes)
     };
@@ -148,42 +148,14 @@ function maxDocPrId(session) {
   }
   return max;
 }
-var TYPES_OPEN_TAG = /<(?:[\w.-]+:)?Types\b[^>]*>/;
-function withImageContentTypes(parts, extensions) {
-  const original = parts.get(CONTENT_TYPES_PATH);
-  if (!original) {
-    throw new DocxExportError(
-      "missing-content-types",
-      `cannot add an image to a package that has no ${CONTENT_TYPES_PATH}`
-    );
-  }
-  const { text, hadBom } = decodeUtf8(original);
-  const missing = Array.from(extensions).filter(
-    (extension) => !new RegExp(`<Default[^>]+Extension="${extension}"`, "i").test(text)
-  );
-  if (missing.length === 0) return null;
-  const open = TYPES_OPEN_TAG.exec(text);
-  if (!open) {
-    throw new DocxExportError(
-      "malformed-xml",
-      `${CONTENT_TYPES_PATH} has no Types element`
-    );
-  }
-  const declarations = missing.map((extension) => {
-    const mime = MIME_BY_EXTENSION.get(extension);
-    return `<Default Extension="${extension}" ContentType="${mime}"/>`;
-  }).join("");
-  const at = open.index + open[0].length;
-  return encodeUtf8(text.slice(0, at) + declarations + text.slice(at), hadBom);
-}
-function planImageMedia(doc, session, relationships) {
+function planImageMedia(doc, session, context) {
   const srcs = insertedImageSrcs(doc);
   if (srcs.length === 0) return null;
+  const { relationships, contentTypes } = context;
   const relIdByContent = imageRelIdsByContent(session, relationships.opened);
   const directory = directoryOf(session.mainPartPath);
   const relIdBySrc = /* @__PURE__ */ new Map();
   const parts = /* @__PURE__ */ new Map();
-  const extensions = /* @__PURE__ */ new Set();
   for (const src of srcs) {
     const image = decodeImage(src);
     const reused = relIdByContent.get(image.key);
@@ -194,20 +166,17 @@ function planImageMedia(doc, session, relationships) {
     const target = `media/image-${image.key}.${image.extension}`;
     const relId = relationships.add({ type: IMAGE_REL_TYPE, target });
     parts.set(directory + target, image.bytes);
-    extensions.add(image.extension);
+    contentTypes.addDefault(image.extension, image.mime);
     relIdByContent.set(image.key, relId);
     relIdBySrc.set(src, relId);
   }
-  if (extensions.size > 0) {
-    const contentTypes = withImageContentTypes(session.parts, extensions);
-    if (contentTypes) parts.set(CONTENT_TYPES_PATH, contentTypes);
-  }
   return { refs: imageRefs(relIdBySrc, maxDocPrId(session) + 1), parts };
 }
 export {
   MAX_IMAGE_BYTES,
   NO_IMAGES,
   NO_IMAGE_REFS,
+  insertedImageSrcs,
   planImageMedia,
   readImageSources
 };

package/dist/docx/newLists.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The lists that were started during editing, and the part their definitions are written into.
+ *
+ * Both the writer and the export invariants ask these questions, so they stand apart from the
+ * writer rather than being read off it.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { SessionStore } from "./session";
+/**
+ * The numbering ids that appeared during editing and have no definition.
+ *
+ * An id that was already in use without a definition when the document was opened is left alone,
+ * because exporting such a document without editing it must not disturb numbering.xml.
+ */
+export declare function newNumIds(doc: PMNode, session: SessionStore): number[];
+/** The numbering part as it was opened, which a new definition is spliced into. null when the document has none */
+export declare function numberingPartOf(session: SessionStore): {
+    path: string;
+    bytes: Uint8Array;
+} | null;

package/dist/docx/newLists.js

@@ -0,0 +1,36 @@
+// src/docx/newLists.ts
+import { toParagraphFormat } from "../model/format.js";
+import { parseNumbering } from "../numbering/parseNumbering.js";
+function collectNumIds(node, into) {
+  const visit = (candidate) => {
+    if (candidate.type.name !== "paragraph") return true;
+    const numId = toParagraphFormat(candidate.attrs.format)?.numbering?.numId;
+    if (numId !== void 0) into.add(numId);
+    return false;
+  };
+  if (visit(node)) node.descendants(visit);
+}
+function numIdsIn(node) {
+  const used = /* @__PURE__ */ new Set();
+  collectNumIds(node, used);
+  return used;
+}
+function numIdsAtOpen(session) {
+  const used = /* @__PURE__ */ new Set();
+  for (const block of session.blocks) collectNumIds(block.node, used);
+  return used;
+}
+function newNumIds(doc, session) {
+  const defined = parseNumbering(session.numberingXml).lists;
+  const atOpen = numIdsAtOpen(session);
+  return Array.from(numIdsIn(doc)).filter((numId) => !defined.has(numId) && !atOpen.has(numId)).sort((a, b) => a - b);
+}
+function numberingPartOf(session) {
+  const path = session.numberingPartPath;
+  const bytes = path === null ? void 0 : session.parts.get(path);
+  return path === null || bytes === void 0 ? null : { path, bytes };
+}
+export {
+  newNumIds,
+  numberingPartOf
+};

package/dist/docx/notes.js

@@ -1,12 +1,13 @@
 // src/docx/notes.ts
 import {
+  attributeByLocalName,
   decodeUtf8,
   elementChildren,
   parseXml,
   R_NS,
   W_NS
 } from "../ooxml/xml.js";
-import { readRelationships, relsPathOf, resolveTarget } from "./relationships.js";
+import { relatedPartPath } from "./packageParts.js";
 var EMPTY_PART = {
   partPath: null,
   ordered: [],
@@ -16,9 +17,6 @@ var NO_NOTES = {
   footnotes: EMPTY_PART,
   endnotes: EMPTY_PART
 };
-function attribute(el, localName) {
-  return Array.from(el.attributes).find((entry) => entry.localName === localName)?.value ?? null;
-}
 function inlineText(node) {
   if (node.localName === "t") return node.textContent ?? "";
   if (node.localName === "tab") return "	";
@@ -31,20 +29,16 @@ function noteText(el) {
   return Array.from(el.getElementsByTagNameNS(W_NS, "p")).map(inlineText).join("\n");
 }
 function notePart(parts, mainPartPath, kind) {
-  const relationshipType = `${R_NS}/${kind}s`;
-  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
-    (entry) => entry.type === relationshipType && !entry.external
-  );
-  if (!relationship) return EMPTY_PART;
-  const partPath = resolveTarget(mainPartPath, relationship.target);
+  const partPath = relatedPartPath(parts, mainPartPath, `${R_NS}/${kind}s`);
+  if (partPath === null) return EMPTY_PART;
   const bytes = parts.get(partPath);
   if (!bytes) return { ...EMPTY_PART, partPath };
   const root = parseXml(decodeUtf8(bytes).text).documentElement;
   const elements = elementChildren(root).filter((el) => el.localName === kind);
   const ordered = elements.flatMap((el) => {
-    const id = attribute(el, "id");
+    const id = attributeByLocalName(el, "id");
     if (id === null) return [];
-    const type = attribute(el, "type");
+    const type = attributeByLocalName(el, "type");
     const regular = type === null || type === "normal";
     const label = regular ? "?" : "";
     return [{ kind, id, label, text: noteText(el), type }];

package/dist/docx/numberingPlanner.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The numbering part with the definition of every list started during editing spliced in.
+ *
+ * The original text is left as is and only the new definitions go in. Nothing is written when no
+ * list was started.
+ */
+import type { PartPlanner } from "./partPlan";
+export declare const numberingPlanner: PartPlanner;

package/dist/docx/numberingPlanner.js

@@ -0,0 +1,19 @@
+// src/docx/numberingPlanner.ts
+import { addListDefinitions } from "../numbering/writeNumbering.js";
+import { decodeUtf8, encodeUtf8 } from "../ooxml/xml.js";
+import { newNumIds, numberingPartOf } from "./newLists.js";
+var numberingPlanner = {
+  name: "numbering",
+  plan(doc, session) {
+    const added = newNumIds(doc, session);
+    const original = numberingPartOf(session);
+    if (added.length === 0 || original === null) return null;
+    const { text, hadBom } = decodeUtf8(original.bytes);
+    return /* @__PURE__ */ new Map([
+      [original.path, encodeUtf8(addListDefinitions(text, added), hadBom)]
+    ]);
+  }
+};
+export {
+  numberingPlanner
+};

package/dist/docx/packageParts.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Where a part sits in the package, asked one way by every reader and writer, and the content
+ * types part every part the export adds is declared in.
+ *
+ * A part beside the body is found through the relationship the main part declares for it, and a
+ * part the export adds takes the first name beside the main part that nothing has claimed. Each
+ * reader used to find its part with a lookup of its own, so the rule for what counts as the
+ * related part lived in five places.
+ */
+export declare const CONTENT_TYPES_PATH = "[Content_Types].xml";
+/**
+ * Where the part the main part relates under this type sits. null for no such relationship, and
+ * for one that points outside the package, which no part of it can stand behind.
+ */
+export declare function relatedPartPath(parts: ReadonlyMap<string, Uint8Array>, mainPartPath: string, type: string): string | null;
+/** A part as text, and null for a path there is no part at, so a missing relationship reads as a missing part */
+export declare function readPart(parts: ReadonlyMap<string, Uint8Array>, path: string | null): string | null;
+/** `comments.xml`, then `comments2.xml`, and so on beside the main part: the first name no part of the package has taken */
+export declare function availablePartPath(parts: ReadonlyMap<string, Uint8Array>, mainPartPath: string, stem: string): string;
+/**
+ * The content types part as an export leaves it: what the package declared when it was opened,
+ * and every declaration the planners asked for on top, written once at the end.
+ *
+ * Each writer that added a part used to splice its own declaration in and hand the result to the
+ * next, so what the part came to hold depended on the order they were called in, and a writer
+ * called without the last one's result wrote over its declaration.
+ */
+export interface ContentTypeWriter {
+    /** Declares the type of the one part at this path */
+    addOverride(partPath: string, contentType: string): void;
+    /** Declares the type of every part with this extension */
+    addDefault(extension: string, contentType: string): void;
+    /**
+     * The part with everything added, or null when nothing was added or everything asked for was
+     * declared already. The additions go right after the opening tag, the defaults ahead of the
+     * overrides, whichever order they were asked in.
+     */
+    part(): Uint8Array | null;
+}
+/** XML parts named by OPC content types, even when their URI has no .xml suffix. */
+export declare function declaredXmlParts(types: Uint8Array, paths: Iterable<string>): ReadonlySet<string>;
+export declare function contentTypeWriter(parts: ReadonlyMap<string, Uint8Array>): ContentTypeWriter;