@portone/docx-editor 0.1.0

package/dist/docx/importTable.js

@@ -0,0 +1,275 @@
+// src/docx/importTable.ts
+import {
+  toCellMargins,
+  toInsideBorders
+} from "../model/format.js";
+import { childValue, wAttr } from "../ooxml/units.js";
+import {
+  attrString,
+  childByLocalName,
+  elementChildren,
+  serializeXml
+} from "../ooxml/xml.js";
+import { docxSchema } from "../schema/index.js";
+import {
+  layerTableFormat,
+  NO_STYLES
+} from "./formatting.js";
+import {
+  buildParagraph,
+  NO_IMPORT_SOURCES
+} from "./importParagraph.js";
+import { readSdtWrapper } from "./sdt.js";
+import {
+  cellBorderDefaults,
+  gridEdgesOf,
+  layerCellMargins,
+  layerInsideBorders,
+  NO_CELL_MARGINS,
+  NO_INSIDE_BORDERS,
+  readCellFormat,
+  readCellMarginsOf,
+  readGridCols,
+  readInsideBorders,
+  readRowFormat,
+  readTableFormat,
+  readTableWidth,
+  tblStyleIdOf
+} from "./tableFormatting.js";
+function readGridSpan(tcPr) {
+  const value = tcPr ? childValue(tcPr, "gridSpan") : null;
+  const parsed = value === null ? null : Number.parseInt(value, 10);
+  return parsed !== null && Number.isInteger(parsed) && parsed > 0 ? parsed : 1;
+}
+function readVerticalMerge(tcPr) {
+  const vMerge = tcPr ? childByLocalName(tcPr, "vMerge") : null;
+  if (!vMerge) return null;
+  return wAttr(vMerge, "val") === "restart" ? "restart" : "continue";
+}
+function readSdtCell(el) {
+  const wrapper = readSdtWrapper(el);
+  if (!wrapper) return null;
+  const inner = elementChildren(wrapper.content);
+  const tc = inner[0];
+  if (inner.length !== 1 || tc.localName !== "tc") return null;
+  if (readVerticalMerge(childByLocalName(tc, "tcPr")) === "continue") {
+    return null;
+  }
+  return {
+    el: tc,
+    control: {
+      prefix: wrapper.prefix,
+      contentsLocked: wrapper.contentsLocked,
+      deletionLocked: wrapper.deletionLocked
+    }
+  };
+}
+function readRow(el) {
+  const cells = [];
+  let tblPrEx = null;
+  for (const child of elementChildren(el)) {
+    if (child.localName === "trPr") continue;
+    if (child.localName === "tblPrEx") {
+      tblPrEx = child;
+      continue;
+    }
+    const sdt = child.localName === "sdt" ? readSdtCell(child) : null;
+    if (!sdt && child.localName !== "tc") return null;
+    const tc = sdt ? sdt.el : child;
+    const tcPr = childByLocalName(tc, "tcPr");
+    cells.push({
+      el: tc,
+      gridSpan: readGridSpan(tcPr),
+      vMerge: readVerticalMerge(tcPr),
+      control: sdt ? sdt.control : null
+    });
+  }
+  return cells.length > 0 ? { el, tblPrEx, cells } : null;
+}
+function readTableParts(el) {
+  let tblPr = null;
+  let tblGrid = null;
+  const rows = [];
+  for (const child of elementChildren(el)) {
+    if (child.localName === "tblPr") {
+      tblPr = child;
+      continue;
+    }
+    if (child.localName === "tblGrid") {
+      tblGrid = child;
+      continue;
+    }
+    if (child.localName !== "tr") return null;
+    const row = readRow(child);
+    if (!row) return null;
+    rows.push(row);
+  }
+  return rows.length > 0 ? { tblPr, tblGrid, rows } : null;
+}
+function resolveVerticalMerges(rows, width) {
+  const drafts = [];
+  let open = /* @__PURE__ */ new Map();
+  for (const [index, row] of rows.entries()) {
+    const rowDrafts = [];
+    const next = /* @__PURE__ */ new Map();
+    let col = 0;
+    for (const cell of row.cells) {
+      if (cell.vMerge === "continue") {
+        const chain = open.get(col);
+        if (!chain || chain.colspan !== cell.gridSpan) return null;
+        chain.rowspan += 1;
+        next.set(col, chain);
+      } else {
+        const draft = {
+          el: cell.el,
+          row: index,
+          col,
+          colspan: cell.gridSpan,
+          rowspan: 1,
+          control: cell.control
+        };
+        rowDrafts.push(draft);
+        if (cell.vMerge === "restart") next.set(col, draft);
+      }
+      col += cell.gridSpan;
+    }
+    if (col !== width) return null;
+    if (rowDrafts.length === 0) return null;
+    drafts.push(rowDrafts);
+    open = next;
+  }
+  return drafts;
+}
+function gridWidthOf(rows) {
+  const widths = rows.map(
+    (row) => row.cells.reduce((sum, cell) => sum + cell.gridSpan, 0)
+  );
+  const first = widths[0];
+  return widths.every((width) => width === first) ? first : null;
+}
+function buildCellBlock(el, sources) {
+  if (el.localName === "p") {
+    const paragraph = buildParagraph(el, null, sources);
+    if (paragraph) return paragraph;
+  }
+  return docxSchema.nodes.rawBlock.create({
+    xml: serializeXml(el),
+    name: el.nodeName
+  });
+}
+function cellBorderDefaultsFor(draft, lines) {
+  return cellBorderDefaults(
+    gridEdgesOf(
+      {
+        top: draft.row,
+        bottom: draft.row + draft.rowspan,
+        left: draft.col,
+        right: draft.col + draft.colspan
+      },
+      lines
+    ),
+    lines.outer,
+    lines.inside
+  );
+}
+function buildCell(draft, lines, sources) {
+  const tcPr = childByLocalName(draft.el, "tcPr");
+  const blocks = [];
+  for (const child of elementChildren(draft.el)) {
+    if (child.localName === "tcPr") continue;
+    blocks.push(buildCellBlock(child, sources));
+  }
+  if (blocks.length === 0) return null;
+  return docxSchema.nodes.tableCell.create(
+    {
+      colspan: draft.colspan,
+      rowspan: draft.rowspan,
+      colwidth: null,
+      tcAttrs: attrString(draft.el),
+      tcPr: tcPr ? serializeXml(tcPr) : null,
+      tcW: readTableWidth(tcPr, "tcW"),
+      format: readCellFormat(
+        tcPr,
+        cellBorderDefaultsFor(draft, lines),
+        lines.margins
+      ),
+      sdtPrefix: draft.control?.prefix ?? null,
+      sdtContentsLocked: draft.control?.contentsLocked ?? false,
+      sdtDeletionLocked: draft.control?.deletionLocked ?? false
+    },
+    blocks
+  );
+}
+function buildRow(row, drafts, lines, sources) {
+  const cells = [];
+  for (const draft of drafts) {
+    const cell = buildCell(draft, lines, sources);
+    if (!cell) return null;
+    cells.push(cell);
+  }
+  const trPr = childByLocalName(row.el, "trPr");
+  return docxSchema.nodes.tableRow.create(
+    {
+      trAttrs: attrString(row.el),
+      tblPrEx: row.tblPrEx ? serializeXml(row.tblPrEx) : null,
+      trPr: trPr ? serializeXml(trPr) : null,
+      format: readRowFormat(trPr)
+    },
+    cells
+  );
+}
+function tableStyleOf(tblPr, styles, defaultTableStyleId) {
+  const styleId = tblStyleIdOf(tblPr);
+  return (styleId !== null ? styles.get(styleId) : void 0) ?? (defaultTableStyleId !== null ? styles.get(defaultTableStyleId) : void 0);
+}
+function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, styles = NO_STYLES, defaultTableStyleId = null) {
+  const parts = readTableParts(el);
+  if (!parts) return null;
+  const gridCols = readGridCols(parts.tblGrid);
+  const width = gridWidthOf(parts.rows);
+  if (width === null || width === 0) return null;
+  if (gridCols.length > 0 && gridCols.length !== width) return null;
+  const drafts = resolveVerticalMerges(parts.rows, width);
+  if (!drafts) return null;
+  const style = tableStyleOf(parts.tblPr, styles, defaultTableStyleId);
+  const tableFormat = layerTableFormat(
+    style?.table ?? {},
+    readTableFormat(parts.tblPr)
+  );
+  const lines = {
+    rows: parts.rows.length,
+    cols: width,
+    outer: tableFormat,
+    inside: layerInsideBorders(
+      style?.tableInside ?? NO_INSIDE_BORDERS,
+      readInsideBorders(parts.tblPr)
+    ),
+    margins: layerCellMargins(
+      style?.tableCellMargins ?? NO_CELL_MARGINS,
+      readCellMarginsOf(parts.tblPr, "tblCellMar")
+    )
+  };
+  const rows = [];
+  for (const [index, row] of parts.rows.entries()) {
+    const built = buildRow(row, drafts[index], lines, sources);
+    if (!built) return null;
+    rows.push(built);
+  }
+  return docxSchema.nodes.table.create(
+    {
+      srcId,
+      tblAttrs: attrString(el),
+      tblPr: parts.tblPr ? serializeXml(parts.tblPr) : null,
+      tblW: readTableWidth(parts.tblPr, "tblW"),
+      gridCols,
+      format: tableFormat,
+      // The cells need these again whenever an edit derives their display values afresh
+      styleInside: toInsideBorders(style?.tableInside),
+      styleCellMargins: toCellMargins(style?.tableCellMargins)
+    },
+    rows
+  );
+}
+export {
+  buildTable
+};

package/dist/docx/media.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Reads and writes package image parts. Nodes keep data URLs so undoable document states own their
+ * 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 { SessionStore } from "./session";
+/** The images the body can refer to, as data URLs keyed by relationship id */
+export type ImageSources = ReadonlyMap<string, string>;
+export declare const NO_IMAGES: ImageSources;
+/**
+ * The most one image may weigh before it is left undrawn.
+ *
+ * The document state holds every image as base64 for as long as the editor is open, and
+ * base64 costs a third more than the bytes, so an untrusted document would otherwise
+ * decide by itself how much memory the session takes. An image past the cap takes the same
+ * road as one no browser can draw rather than the document being refused: nothing is lost,
+ * since the drawing and its media part still ride back out untouched.
+ * No photograph a contract carries comes near this.
+ */
+export declare const MAX_IMAGE_BYTES: number;
+/**
+ * Every image the body part has a relationship to.
+ *
+ * A relationship we cannot follow (a linked file, a missing part, a kind no browser
+ * draws, an image past `MAX_IMAGE_BYTES`) is simply left out, and the drawing that points
+ * at it stays on the preservation path.
+ */
+export declare function readImageSources(parts: Map<string, Uint8Array>, mainPartPath: string): ImageSources;
+/**
+ * What the body needs to know while it is being written out: which relationship each
+ * inserted image ended up on, and a drawing id no other drawing in the document holds.
+ *
+ * The ids are handed out one at a time rather than planned per image, because the same
+ * image inserted twice shares one media part but is still two drawings, and Word expects
+ * every drawing in a document to have an id of its own.
+ */
+export interface ImageRefs {
+    relIdOf(src: string): string | undefined;
+    takeDocPrId(): number;
+}
+/** What a serializer called on its own, outside an export, has to work with */
+export declare const NO_IMAGE_REFS: ImageRefs;
+export interface MediaAdditions {
+    refs: ImageRefs;
+    /** The parts to write into the zip alongside the body */
+    parts: ReadonlyMap<string, Uint8Array>;
+}
+/**
+ * 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.
+ *
+ * The relationships go through the writer the export shares between its writers
+ * (`docx/relationships`), so the part is written once with everything in it.
+ *
+ * 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;

package/dist/docx/media.js

@@ -0,0 +1,213 @@
+// src/docx/media.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import {
+  imageBase64Of,
+  imageMimeOf,
+  toImageSrc
+} from "../ooxml/image.js";
+import { decodeUtf8, encodeUtf8, R_NS } from "../ooxml/xml.js";
+import {
+  directoryOf,
+  readRelationships,
+  relsPathOf,
+  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",
+  "image/gif": "gif",
+  "image/bmp": "bmp"
+};
+var MIME_BY_EXTENSION = /* @__PURE__ */ new Map([
+  ["png", "image/png"],
+  ["jpeg", "image/jpeg"],
+  ["jpg", "image/jpeg"],
+  ["jpe", "image/jpeg"],
+  ["gif", "image/gif"],
+  ["bmp", "image/bmp"]
+]);
+function toBase64(bytes) {
+  const CHUNK = 32768;
+  let binary = "";
+  for (let at = 0; at < bytes.length; at += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(at, at + CHUNK));
+  }
+  return btoa(binary);
+}
+function fromBase64(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let at = 0; at < binary.length; at += 1) {
+    bytes[at] = binary.charCodeAt(at);
+  }
+  return bytes;
+}
+function dataUrl(bytes, mime) {
+  return `data:${mime};base64,${toBase64(bytes)}`;
+}
+function mimeOfPath(path) {
+  const dot = path.lastIndexOf(".");
+  return dot === -1 ? void 0 : MIME_BY_EXTENSION.get(path.slice(dot + 1).toLowerCase());
+}
+var NO_IMAGES = /* @__PURE__ */ new Map();
+var MAX_IMAGE_BYTES = 16 * 1024 * 1024;
+function readImageSources(parts, mainPartPath) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const rel of readRelationships(parts, relsPathOf(mainPartPath))) {
+    if (rel.type !== IMAGE_REL_TYPE || rel.external) continue;
+    const mime = mimeOfPath(rel.target);
+    const bytes = parts.get(resolveTarget(mainPartPath, rel.target));
+    if (!mime || !bytes || bytes.length > MAX_IMAGE_BYTES) continue;
+    sources.set(rel.id, dataUrl(bytes, mime));
+  }
+  return sources;
+}
+function contentKey(bytes) {
+  let a = 2166136261;
+  let b = 3266489909;
+  for (const byte of bytes) {
+    a = Math.imul(a ^ byte, 16777619) >>> 0;
+    b = Math.imul(b ^ byte, 2246822507) >>> 0;
+  }
+  const hex = (value) => value.toString(16).padStart(8, "0");
+  return `${bytes.length.toString(36)}${hex(a)}${hex(b)}`;
+}
+function imageRefs(relIdBySrc, firstDocPrId) {
+  let nextDocPrId = firstDocPrId;
+  return {
+    relIdOf: (src) => relIdBySrc.get(src),
+    takeDocPrId: () => {
+      const id = nextDocPrId;
+      nextDocPrId += 1;
+      return id;
+    }
+  };
+}
+var NO_IMAGE_REFS = {
+  relIdOf: () => void 0,
+  // Never reached: an image with no relationship to point at is refused before it is drawn
+  takeDocPrId: () => 1
+};
+function insertedImageSrcs(doc) {
+  const srcs = [];
+  doc.descendants((node) => {
+    if (node.type.name !== "image" || typeof node.attrs.xml === "string") {
+      return true;
+    }
+    const src = toImageSrc(node.attrs.src);
+    if (src !== null && !srcs.includes(src)) srcs.push(src);
+    return true;
+  });
+  return srcs;
+}
+function decodeImage(src) {
+  const mime = imageMimeOf(src);
+  if (mime === null) {
+    throw new DocxExportError(
+      "unsupported-content",
+      "an inserted image is of a kind we cannot write"
+    );
+  }
+  try {
+    const bytes = fromBase64(imageBase64Of(src));
+    return {
+      bytes,
+      extension: EXTENSION_BY_MIME[mime],
+      key: contentKey(bytes)
+    };
+  } catch (error) {
+    throw new DocxExportError(
+      "unsupported-content",
+      "an inserted image's bytes could not be decoded",
+      { cause: error }
+    );
+  }
+}
+function imageRelIdsByContent(session, rels) {
+  const byContent = /* @__PURE__ */ new Map();
+  for (const rel of rels) {
+    if (rel.type !== IMAGE_REL_TYPE || rel.external) continue;
+    const bytes = session.parts.get(
+      resolveTarget(session.mainPartPath, rel.target)
+    );
+    if (!bytes) continue;
+    const key = contentKey(bytes);
+    if (!byContent.has(key)) byContent.set(key, rel.id);
+  }
+  return byContent;
+}
+var DOC_PR_ID = /<(?:[\w.-]+:)?docPr\b[^>]*\bid="(\d+)"/g;
+function maxDocPrId(session) {
+  let max = 0;
+  for (const block of session.blocks) {
+    for (const match of block.xml.matchAll(DOC_PR_ID)) {
+      max = Math.max(max, Number.parseInt(match[1], 10));
+    }
+  }
+  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) {
+  const srcs = insertedImageSrcs(doc);
+  if (srcs.length === 0) return null;
+  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);
+    if (reused !== void 0) {
+      relIdBySrc.set(src, reused);
+      continue;
+    }
+    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);
+    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,
+  planImageMedia,
+  readImageSources
+};

package/dist/docx/notes.d.ts

@@ -0,0 +1,22 @@
+/** Reads footnote and endnote bodies related from the main document story. */
+export type NoteKind = "footnote" | "endnote";
+export interface ImportedNote {
+    kind: NoteKind;
+    id: string;
+    label: string;
+    text: string;
+    type: string | null;
+}
+export interface ImportedNotePart {
+    partPath: string | null;
+    ordered: readonly ImportedNote[];
+    byId: ReadonlyMap<string, ImportedNote>;
+}
+export interface ImportedNotes {
+    footnotes: ImportedNotePart;
+    endnotes: ImportedNotePart;
+}
+export declare const NO_NOTES: ImportedNotes;
+/** Reads both note parts without modifying their original package bytes. */
+export declare function readNotes(parts: Map<string, Uint8Array>, mainPartPath: string): ImportedNotes;
+export declare function noteById(notes: ImportedNotes, kind: NoteKind, id: string): ImportedNote | undefined;

package/dist/docx/notes.js

@@ -0,0 +1,71 @@
+// src/docx/notes.ts
+import {
+  decodeUtf8,
+  elementChildren,
+  parseXml,
+  R_NS,
+  W_NS
+} from "../ooxml/xml.js";
+import { readRelationships, relsPathOf, resolveTarget } from "./relationships.js";
+var EMPTY_PART = {
+  partPath: null,
+  ordered: [],
+  byId: /* @__PURE__ */ new Map()
+};
+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 "	";
+  if (node.localName === "br" || node.localName === "cr") return "\n";
+  if (node.localName === "noBreakHyphen") return "\u2011";
+  if (node.localName === "softHyphen") return "\xAD";
+  return elementChildren(node).map(inlineText).join("");
+}
+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 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");
+    if (id === null) return [];
+    const type = attribute(el, "type");
+    const regular = type === null || type === "normal";
+    const label = regular ? "?" : "";
+    return [{ kind, id, label, text: noteText(el), type }];
+  });
+  const byId = /* @__PURE__ */ new Map();
+  for (const note of ordered) {
+    if (!byId.has(note.id)) byId.set(note.id, note);
+  }
+  return { partPath, ordered, byId };
+}
+function readNotes(parts, mainPartPath) {
+  return {
+    footnotes: notePart(parts, mainPartPath, "footnote"),
+    endnotes: notePart(parts, mainPartPath, "endnote")
+  };
+}
+function noteById(notes, kind, id) {
+  return notes[`${kind}s`].byId.get(id);
+}
+export {
+  NO_NOTES,
+  noteById,
+  readNotes
+};