@beyondwork/docx-react-component 1.0.27 → 1.0.29

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

@@ -1,118 +0,0 @@
-import type { NumberingCatalog, ParagraphNode } from "../../model/canonical-document.ts";
-import {
-  isSyntheticDocxNullAbstractDefinition,
-  isSyntheticDocxNullNumberingInstance,
-} from "../ooxml/numbering-sentinels.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)
-    .filter((definition) => !isSyntheticDocxNullAbstractDefinition(definition))
-    .sort((left, right) =>
-      compareSerializedIds(left.abstractNumberingId, right.abstractNumberingId),
-    );
-  const instances = Object.values(catalog.instances)
-    .filter((instance) => !isSyntheticDocxNullNumberingInstance(instance))
-    .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 hasSerializableNumberingEntries(catalog: NumberingCatalog): boolean {
-  return (
-    Object.values(catalog.abstractDefinitions).some(
-      (definition) => !isSyntheticDocxNullAbstractDefinition(definition),
-    ) ||
-    Object.values(catalog.instances).some(
-      (instance) => !isSyntheticDocxNullNumberingInstance(instance),
-    )
-  );
-}
-
-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)}"/>`
-    : "";
-  const isLegal = level.isLegalNumbering ? "<w:isLgl/>" : "";
-  const suffix = level.suffix ? `<w:suff w:val="${escapeAttribute(level.suffix)}"/>` : "";
-
-  return `<w:lvl w:ilvl="${level.level}">${start}<w:numFmt w:val="${escapeAttribute(
-    level.format,
-  )}"/><w:lvlText w:val="${escapeAttribute(level.text)}"/>${paragraphStyle}${isLegal}${suffix}</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

@@ -1,389 +0,0 @@
-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");
-}