@beyondwork/docx-react-component 1.0.1 → 1.0.2

package/src/io/export/serialize-numbering.ts

@@ -0,0 +1,97 @@
+import type { NumberingCatalog, ParagraphNode } from "../../model/canonical-document.ts";
+
+export const WORD_NUMBERING_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
+
+export function serializeNumberingXml(catalog: NumberingCatalog): string {
+  const abstractDefinitions = Object.values(catalog.abstractDefinitions).sort((left, right) =>
+    compareSerializedIds(left.abstractNumberingId, right.abstractNumberingId),
+  );
+  const instances = Object.values(catalog.instances).sort((left, right) =>
+    compareSerializedIds(left.numberingInstanceId, right.numberingInstanceId),
+  );
+
+  const body = [
+    ...abstractDefinitions.map((definition) => serializeAbstractDefinition(definition)),
+    ...instances.map((instance) => serializeInstance(instance)),
+  ].join("");
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">${body}</w:numbering>`,
+  ].join("\n");
+}
+
+export function serializeParagraphNumberingProperties(
+  numbering: ParagraphNode["numbering"],
+): string {
+  if (!numbering) {
+    return "";
+  }
+
+  return `<w:numPr><w:ilvl w:val="${numbering.level}"/><w:numId w:val="${escapeAttribute(
+    stripCanonicalPrefix(numbering.numberingInstanceId, "num:"),
+  )}"/></w:numPr>`;
+}
+
+function serializeAbstractDefinition(definition: NumberingCatalog["abstractDefinitions"][string]): string {
+  const abstractNumId = escapeAttribute(
+    stripCanonicalPrefix(definition.abstractNumberingId, "abstract-num:"),
+  );
+  const levels = [...definition.levels]
+    .sort((left, right) => left.level - right.level)
+    .map((level) => serializeLevel(level))
+    .join("");
+
+  return `<w:abstractNum w:abstractNumId="${abstractNumId}">${levels}</w:abstractNum>`;
+}
+
+function serializeLevel(level: NumberingCatalog["abstractDefinitions"][string]["levels"][number]): string {
+  const start = level.startAt !== undefined ? `<w:start w:val="${level.startAt}"/>` : "";
+  const paragraphStyle = level.paragraphStyleId
+    ? `<w:pStyle w:val="${escapeAttribute(level.paragraphStyleId)}"/>`
+    : "";
+
+  return `<w:lvl w:ilvl="${level.level}">${start}<w:numFmt w:val="${escapeAttribute(
+    level.format,
+  )}"/><w:lvlText w:val="${escapeAttribute(level.text)}"/>${paragraphStyle}</w:lvl>`;
+}
+
+function serializeInstance(instance: NumberingCatalog["instances"][string]): string {
+  const numId = escapeAttribute(stripCanonicalPrefix(instance.numberingInstanceId, "num:"));
+  const abstractNumId = escapeAttribute(
+    stripCanonicalPrefix(instance.abstractNumberingId, "abstract-num:"),
+  );
+  const overrides = [...instance.overrides]
+    .sort((left, right) => left.level - right.level)
+    .map((override) => serializeOverride(override))
+    .join("");
+
+  return `<w:num w:numId="${numId}"><w:abstractNumId w:val="${abstractNumId}"/>${overrides}</w:num>`;
+}
+
+function serializeOverride(override: NumberingCatalog["instances"][string]["overrides"][number]): string {
+  const startOverride =
+    override.startAt !== undefined ? `<w:startOverride w:val="${override.startAt}"/>` : "";
+  return `<w:lvlOverride w:ilvl="${override.level}">${startOverride}</w:lvlOverride>`;
+}
+
+function compareSerializedIds(left: string, right: string): number {
+  return stripKnownPrefix(left).localeCompare(stripKnownPrefix(right), "en", { numeric: true });
+}
+
+function stripKnownPrefix(value: string): string {
+  return value.replace(/^abstract-num:|^num:/, "");
+}
+
+function stripCanonicalPrefix(value: string, prefix: "abstract-num:" | "num:"): string {
+  return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+}
+
+function escapeAttribute(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}

package/src/io/export/serialize-revisions.ts

@@ -0,0 +1,389 @@
+import type { RevisionRecord } from "../../review/store/revision-types.ts";
+import type {
+  ParsedRevisionsResult,
+  PreservedRevisionMarkup,
+} from "../ooxml/parse-revisions.ts";
+import {
+  mapRevisionBoundaries,
+  type RevisionParagraphBoundary,
+} from "../ooxml/revision-boundaries.ts";
+
+export interface SerializeRevisionsOptions {
+  revisions: readonly RevisionRecord[];
+  preservedMarkup: readonly PreservedRevisionMarkup[];
+  boundaries?: readonly RevisionParagraphBoundary[];
+}
+
+interface XmlReplacement {
+  start: number;
+  end: number;
+  replacement: string;
+}
+
+interface ParagraphMarkupDecision {
+  revisionId: string;
+  paragraphIndex: number;
+  rawMarkup: string;
+  mergeFromParagraphIndex?: number;
+  mergeToParagraphIndex?: number;
+}
+
+export function serializeRevisionsIntoDocumentXml(
+  documentXml: string,
+  options: SerializeRevisionsOptions | ParsedRevisionsResult,
+): string {
+  const revisions = options.revisions;
+  const preservedMarkup = options.preservedMarkup
+    .slice()
+    .sort((left, right) => left.xmlStart - right.xmlStart);
+  const revisionById = new Map(revisions.map((revision) => [revision.revisionId, revision]));
+  const boundaries = options.boundaries ?? mapRevisionBoundaries(documentXml);
+  const replacements: XmlReplacement[] = [];
+  const consumedRevisionIds = new Set<string>();
+  const paragraphDecisions = collectParagraphMarkupDecisions(
+    preservedMarkup,
+    revisionById,
+    boundaries,
+  );
+
+  replacements.push(
+    ...createParagraphStructuralReplacements(
+      documentXml,
+      boundaries,
+      paragraphDecisions,
+      consumedRevisionIds,
+    ),
+  );
+
+  for (const markup of preservedMarkup) {
+    if (consumedRevisionIds.has(markup.revisionId)) {
+      continue;
+    }
+
+    const revision = revisionById.get(markup.revisionId);
+
+    if (
+      revision?.kind === "property-change" &&
+      revision.status === "rejected" &&
+      markup.containerXmlStart !== undefined &&
+      markup.containerXmlEnd !== undefined &&
+      markup.beforeContainerXml !== undefined
+    ) {
+      replacements.push({
+        start: markup.containerXmlStart,
+        end: markup.containerXmlEnd,
+        replacement: markup.beforeContainerXml,
+      });
+      continue;
+    }
+
+    replacements.push({
+      start: markup.xmlStart,
+      end: markup.xmlEnd,
+      replacement: serializeMarkup(markup, revision),
+    });
+  }
+
+  return applyReplacements(documentXml, replacements);
+}
+
+function serializeMarkup(
+  markup: PreservedRevisionMarkup,
+  revision: RevisionRecord | undefined,
+): string {
+  if (!revision) {
+    return markup.rawXml;
+  }
+
+  switch (revision.kind) {
+    case "move":
+    case "formatting":
+      return markup.rawXml;
+    case "property-change":
+      return serializePropertyChangeMarkup(markup.rawXml, revision.status);
+    case "insertion":
+      return serializeInsertionMarkup(markup.rawXml, revision.status);
+    case "deletion":
+      return serializeDeletionMarkup(markup.rawXml, revision.status);
+  }
+}
+
+function collectParagraphMarkupDecisions(
+  preservedMarkup: readonly PreservedRevisionMarkup[],
+  revisionById: ReadonlyMap<string, RevisionRecord>,
+  boundaries: readonly RevisionParagraphBoundary[],
+): ParagraphMarkupDecision[] {
+  const decisions: ParagraphMarkupDecision[] = [];
+
+  for (const markup of preservedMarkup) {
+    if (!markup.originalRevisionType.startsWith("paragraph-")) {
+      continue;
+    }
+
+    const revision = revisionById.get(markup.revisionId);
+    const paragraphIndex = markup.paragraphIndex;
+    if (!revision || paragraphIndex === undefined) {
+      continue;
+    }
+
+    if (revision.status === "active" || revision.status === "detached") {
+      continue;
+    }
+
+    if (markup.originalRevisionType === "paragraph-del") {
+      decisions.push({
+        revisionId: markup.revisionId,
+        paragraphIndex,
+        rawMarkup: markup.rawXml,
+        ...(revision.status === "accepted" && boundaries[paragraphIndex + 1]
+          ? { mergeFromParagraphIndex: paragraphIndex, mergeToParagraphIndex: paragraphIndex + 1 }
+          : {}),
+      });
+      continue;
+    }
+
+    if (markup.originalRevisionType === "paragraph-ins") {
+      decisions.push({
+        revisionId: markup.revisionId,
+        paragraphIndex,
+        rawMarkup: markup.rawXml,
+        ...(revision.status === "rejected" && boundaries[paragraphIndex - 1]
+          ? { mergeFromParagraphIndex: paragraphIndex - 1, mergeToParagraphIndex: paragraphIndex }
+          : {}),
+      });
+    }
+  }
+
+  return decisions;
+}
+
+function createParagraphStructuralReplacements(
+  documentXml: string,
+  boundaries: readonly RevisionParagraphBoundary[],
+  decisions: readonly ParagraphMarkupDecision[],
+  consumedRevisionIds: Set<string>,
+): XmlReplacement[] {
+  const replacements: XmlReplacement[] = [];
+  const removedMarkupByParagraph = new Map<number, string[]>();
+  const mergeEdgeStarts = new Set<number>();
+
+  for (const decision of decisions) {
+    consumedRevisionIds.add(decision.revisionId);
+    const existing = removedMarkupByParagraph.get(decision.paragraphIndex) ?? [];
+    existing.push(decision.rawMarkup);
+    removedMarkupByParagraph.set(decision.paragraphIndex, existing);
+
+    if (
+      decision.mergeFromParagraphIndex !== undefined &&
+      decision.mergeToParagraphIndex !== undefined
+    ) {
+      mergeEdgeStarts.add(decision.mergeFromParagraphIndex);
+    }
+  }
+
+  const mergedParagraphIndices = new Set<number>();
+
+  for (let paragraphIndex = 0; paragraphIndex < boundaries.length; paragraphIndex += 1) {
+    if (mergedParagraphIndices.has(paragraphIndex) || !mergeEdgeStarts.has(paragraphIndex)) {
+      continue;
+    }
+
+    let groupEnd = paragraphIndex;
+    while (mergeEdgeStarts.has(groupEnd)) {
+      groupEnd += 1;
+    }
+
+    const startBoundary = boundaries[paragraphIndex];
+    const endBoundary = boundaries[groupEnd];
+    if (!startBoundary || !endBoundary) {
+      continue;
+    }
+
+    let targetInnerXml = removeParagraphRevisionMarkup(
+      getParagraphInnerXml(documentXml, startBoundary),
+      removedMarkupByParagraph.get(paragraphIndex) ?? [],
+    );
+    let appendedStoryXml = "";
+
+    for (let sourceIndex = paragraphIndex + 1; sourceIndex <= groupEnd; sourceIndex += 1) {
+      const sourceBoundary = boundaries[sourceIndex];
+      if (!sourceBoundary) {
+        continue;
+      }
+
+      appendedStoryXml += getParagraphStoryXml(documentXml, sourceBoundary);
+      mergedParagraphIndices.add(sourceIndex);
+    }
+
+    replacements.push({
+      start: startBoundary.paragraphStart,
+      end: endBoundary.paragraphEnd,
+      replacement: serializeMergedParagraph(
+        documentXml,
+        startBoundary,
+        targetInnerXml,
+        appendedStoryXml,
+      ),
+    });
+    mergedParagraphIndices.add(paragraphIndex);
+  }
+
+  for (const [paragraphIndex, rawMarkup] of removedMarkupByParagraph.entries()) {
+    if (mergedParagraphIndices.has(paragraphIndex)) {
+      continue;
+    }
+
+    const boundary = boundaries[paragraphIndex];
+    if (!boundary) {
+      continue;
+    }
+
+    replacements.push({
+      start: boundary.paragraphStart,
+      end: boundary.paragraphEnd,
+      replacement: serializeMergedParagraph(
+        documentXml,
+        boundary,
+        removeParagraphRevisionMarkup(getParagraphInnerXml(documentXml, boundary), rawMarkup),
+        "",
+      ),
+    });
+  }
+
+  return replacements;
+}
+
+function serializeMergedParagraph(
+  documentXml: string,
+  targetBoundary: RevisionParagraphBoundary,
+  targetInnerXml: string,
+  appendedStoryXml: string,
+): string {
+  return [
+    documentXml.slice(targetBoundary.paragraphStart, targetBoundary.paragraphStartTagEnd),
+    targetInnerXml,
+    appendedStoryXml,
+    documentXml.slice(targetBoundary.paragraphEndTagStart, targetBoundary.paragraphEnd),
+  ].join("");
+}
+
+function getParagraphInnerXml(
+  documentXml: string,
+  boundary: RevisionParagraphBoundary,
+): string {
+  return documentXml.slice(boundary.paragraphStartTagEnd, boundary.paragraphEndTagStart);
+}
+
+function getParagraphStoryXml(
+  documentXml: string,
+  boundary: RevisionParagraphBoundary,
+): string {
+  const innerXml = getParagraphInnerXml(documentXml, boundary);
+  if (
+    boundary.paragraphPropertiesStart === undefined ||
+    boundary.paragraphPropertiesEnd === undefined
+  ) {
+    return innerXml;
+  }
+
+  const relativeStart = boundary.paragraphPropertiesStart - boundary.paragraphStartTagEnd;
+  const relativeEnd = boundary.paragraphPropertiesEnd - boundary.paragraphStartTagEnd;
+
+  return innerXml.slice(0, relativeStart) + innerXml.slice(relativeEnd);
+}
+
+function removeParagraphRevisionMarkup(
+  innerXml: string,
+  rawMarkup: string | readonly string[],
+): string {
+  const markups = Array.isArray(rawMarkup) ? rawMarkup : [rawMarkup];
+  return cleanupEmptyParagraphPropertyContainers(
+    markups.reduce((result, markup) => result.replace(markup, ""), innerXml),
+  );
+}
+
+function cleanupEmptyParagraphPropertyContainers(xml: string): string {
+  let next = xml;
+  let previous = "";
+
+  while (next !== previous) {
+    previous = next;
+    next = next
+      .replace(/<w:rPr>\s*<\/w:rPr>/g, "")
+      .replace(/<w:pPr>\s*<\/w:pPr>/g, "");
+  }
+
+  return next;
+}
+
+function applyReplacements(documentXml: string, replacements: XmlReplacement[]): string {
+  const sorted = replacements
+    .slice()
+    .sort((left, right) => right.start - left.start || right.end - left.end);
+  let output = documentXml;
+
+  for (const replacement of sorted) {
+    output =
+      output.slice(0, replacement.start) +
+      replacement.replacement +
+      output.slice(replacement.end);
+  }
+
+  return output;
+}
+
+function serializePropertyChangeMarkup(
+  rawXml: string,
+  status: RevisionRecord["status"],
+): string {
+  switch (status) {
+    case "accepted":
+      return "";
+    case "rejected":
+    case "active":
+    case "detached":
+      return rawXml;
+  }
+}
+
+function serializeInsertionMarkup(
+  rawXml: string,
+  status: RevisionRecord["status"],
+): string {
+  switch (status) {
+    case "accepted":
+      return unwrapRevisionContainer(rawXml);
+    case "rejected":
+      return "";
+    case "active":
+    case "detached":
+      return rawXml;
+  }
+}
+
+function serializeDeletionMarkup(
+  rawXml: string,
+  status: RevisionRecord["status"],
+): string {
+  switch (status) {
+    case "accepted":
+      return "";
+    case "rejected":
+      return convertDeletedContentToRuns(unwrapRevisionContainer(rawXml));
+    case "active":
+    case "detached":
+      return rawXml;
+  }
+}
+
+function unwrapRevisionContainer(rawXml: string): string {
+  return rawXml
+    .replace(/^<[^>]+>/, "")
+    .replace(/<\/[^>]+>\s*$/, "");
+}
+
+function convertDeletedContentToRuns(xml: string): string {
+  return xml
+    .replace(/<(\/?)w:delText\b/g, "<$1w:t")
+    .replace(/<(\/?)w:delInstrText\b/g, "<$1w:instrText");
+}