@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/src/io/ooxml/revision-boundaries.ts

@@ -1,351 +0,0 @@
-export interface XmlElementNode {
-  type: "element";
-  name: string;
-  attributes: Record<string, string>;
-  children: XmlNode[];
-  start: number;
-  end: number;
-  openingTagEnd: number;
-  closingTagStart: number;
-}
-
-export interface XmlTextNode {
-  type: "text";
-  text: string;
-  start: number;
-  end: number;
-}
-
-export type XmlNode = XmlElementNode | XmlTextNode;
-
-export interface RevisionParagraphBoundary {
-  paragraphIndex: number;
-  start: number;
-  end: number;
-  boundaries: Map<number, number>;
-  paragraphStart: number;
-  paragraphStartTagEnd: number;
-  paragraphEndTagStart: number;
-  paragraphEnd: number;
-  paragraphPropertiesStart?: number;
-  paragraphPropertiesEnd?: number;
-  paragraphRunPropertiesStart?: number;
-  paragraphRunPropertiesEnd?: number;
-}
-
-export function mapRevisionBoundaries(
-  documentXml: string,
-): RevisionParagraphBoundary[] {
-  const root = parseXmlWithPositions(documentXml);
-  const documentElement = findRequiredChildElement(root, "document");
-  const bodyElement = findRequiredChildElement(documentElement, "body");
-  const paragraphs: RevisionParagraphBoundary[] = [];
-  let cursor = 0;
-  let paragraphIndex = -1;
-  let previousWasParagraph = false;
-
-  for (const child of bodyElement.children) {
-    if (child.type !== "element") {
-      continue;
-    }
-
-    if (localName(child.name) !== "p") {
-      cursor += 1;
-      previousWasParagraph = false;
-      continue;
-    }
-
-    if (previousWasParagraph) {
-      cursor += 1;
-    }
-    paragraphIndex += 1;
-    const boundaries = new Map<number, number>();
-    boundaries.set(cursor, child.openingTagEnd);
-
-    const paragraphProperties = findChildElement(child, "pPr");
-    const paragraphRunProperties = paragraphProperties
-      ? findChildElement(paragraphProperties, "rPr")
-      : undefined;
-
-    walkStoryNodesForBoundaries(
-      child.children,
-      boundaries,
-      () => cursor,
-      (next) => {
-        cursor = next;
-      },
-    );
-
-    boundaries.set(cursor, child.closingTagStart);
-    paragraphs.push({
-      paragraphIndex,
-      start: Math.min(...boundaries.keys()),
-      end: Math.max(...boundaries.keys()),
-      boundaries,
-      paragraphStart: child.start,
-      paragraphStartTagEnd: child.openingTagEnd,
-      paragraphEndTagStart: child.closingTagStart,
-      paragraphEnd: child.end,
-      ...(paragraphProperties
-        ? {
-            paragraphPropertiesStart: paragraphProperties.start,
-            paragraphPropertiesEnd: paragraphProperties.end,
-          }
-        : {}),
-      ...(paragraphRunProperties
-        ? {
-            paragraphRunPropertiesStart: paragraphRunProperties.start,
-            paragraphRunPropertiesEnd: paragraphRunProperties.end,
-          }
-        : {}),
-    });
-    previousWasParagraph = true;
-  }
-
-  return paragraphs;
-}
-
-function walkStoryNodesForBoundaries(
-  nodes: XmlNode[],
-  boundaries: Map<number, number>,
-  getCursor: () => number,
-  setCursor: (next: number) => void,
-): void {
-  for (const node of nodes) {
-    walkStoryNodeForBoundaries(node, boundaries, getCursor, setCursor);
-  }
-}
-
-function walkStoryNodeForBoundaries(
-  node: XmlNode,
-  boundaries: Map<number, number>,
-  getCursor: () => number,
-  setCursor: (next: number) => void,
-): void {
-  if (node.type !== "element") {
-    return;
-  }
-
-  switch (localName(node.name)) {
-    case "pPr":
-      return;
-    case "r":
-      boundaries.set(getCursor(), node.start);
-      for (const child of node.children) {
-        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
-      }
-      boundaries.set(getCursor(), node.end);
-      return;
-    case "ins":
-    case "del":
-    case "moveFrom":
-    case "moveTo":
-    case "hyperlink":
-    case "smartTag":
-    case "sdtContent":
-    case "customXml":
-      for (const child of node.children) {
-        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
-      }
-      return;
-    case "t":
-    case "delText":
-    case "instrText":
-    case "delInstrText": {
-      const text = node.children
-        .filter((child): child is XmlTextNode => child.type === "text")
-        .map((child) => child.text)
-        .join("");
-      if (text.length === 0) {
-        return;
-      }
-
-      if (!boundaries.has(getCursor())) {
-        boundaries.set(getCursor(), node.start);
-      }
-      setCursor(getCursor() + text.length);
-      boundaries.set(getCursor(), node.end);
-      return;
-    }
-    case "tab":
-    case "br":
-    case "cr":
-      if (!boundaries.has(getCursor())) {
-        boundaries.set(getCursor(), node.start);
-      }
-      setCursor(getCursor() + 1);
-      boundaries.set(getCursor(), node.end);
-      return;
-    default:
-      for (const child of node.children) {
-        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
-      }
-  }
-}
-
-export function parseXmlWithPositions(xml: string): XmlElementNode {
-  const root: XmlElementNode = {
-    type: "element",
-    name: "__root__",
-    attributes: {},
-    children: [],
-    start: 0,
-    end: xml.length,
-    openingTagEnd: 0,
-    closingTagStart: xml.length,
-  };
-  const stack: XmlElementNode[] = [root];
-  let cursor = 0;
-
-  while (cursor < xml.length) {
-    if (xml.startsWith("<!--", cursor)) {
-      const end = xml.indexOf("-->", cursor);
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-
-    if (xml.startsWith("<?", cursor)) {
-      const end = xml.indexOf("?>", cursor);
-      cursor = end >= 0 ? end + 2 : xml.length;
-      continue;
-    }
-
-    if (xml.startsWith("<![CDATA[", cursor)) {
-      const end = xml.indexOf("]]>", cursor);
-      const textEnd = end >= 0 ? end : xml.length;
-      stack[stack.length - 1]?.children.push({
-        type: "text",
-        text: xml.slice(cursor + 9, textEnd),
-        start: cursor,
-        end: textEnd,
-      });
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-
-    if (xml[cursor] !== "<") {
-      const nextTag = xml.indexOf("<", cursor);
-      const end = nextTag >= 0 ? nextTag : xml.length;
-      const text = decodeXmlEntities(xml.slice(cursor, end));
-      if (text.length > 0) {
-        stack[stack.length - 1]?.children.push({
-          type: "text",
-          text,
-          start: cursor,
-          end,
-        });
-      }
-      cursor = end;
-      continue;
-    }
-
-    if (xml[cursor + 1] === "/") {
-      const tagEnd = xml.indexOf(">", cursor);
-      if (tagEnd < 0) {
-        throw new Error("Malformed XML: unterminated closing tag.");
-      }
-
-      const node = stack.pop();
-      if (!node || stack.length === 0) {
-        throw new Error("Malformed XML: unexpected closing tag.");
-      }
-
-      node.closingTagStart = cursor;
-      node.end = tagEnd + 1;
-      cursor = tagEnd + 1;
-      continue;
-    }
-
-    const tagEnd = xml.indexOf(">", cursor);
-    if (tagEnd < 0) {
-      throw new Error("Malformed XML: unterminated opening tag.");
-    }
-
-    const rawTag = xml.slice(cursor + 1, tagEnd);
-    const selfClosing = /\/\s*$/.test(rawTag);
-    const normalizedTag = selfClosing ? rawTag.replace(/\/\s*$/, "") : rawTag;
-    const parts = normalizedTag.trim().split(/\s+/, 1);
-    const name = parts[0];
-    if (!name) {
-      throw new Error("Malformed XML: empty tag name.");
-    }
-
-    const attributes = parseAttributes(normalizedTag.slice(name.length));
-    const node: XmlElementNode = {
-      type: "element",
-      name,
-      attributes,
-      children: [],
-      start: cursor,
-      end: selfClosing ? tagEnd + 1 : xml.length,
-      openingTagEnd: tagEnd + 1,
-      closingTagStart: tagEnd + 1,
-    };
-
-    stack[stack.length - 1]?.children.push(node);
-    cursor = tagEnd + 1;
-
-    if (!selfClosing) {
-      stack.push(node);
-    }
-  }
-
-  if (stack.length !== 1) {
-    throw new Error("Malformed XML: unclosed element.");
-  }
-
-  return root;
-}
-
-export function findRequiredChildElement(
-  node: XmlElementNode,
-  childLocalName: string,
-): XmlElementNode {
-  const child = findChildElement(node, childLocalName);
-  if (!child) {
-    throw new Error(`Expected <${childLocalName}> element.`);
-  }
-
-  return child;
-}
-
-export function findChildElement(
-  node: XmlElementNode,
-  childLocalName: string,
-): XmlElementNode | undefined {
-  return node.children.find(
-    (entry): entry is XmlElementNode =>
-      entry.type === "element" && localName(entry.name) === childLocalName,
-  );
-}
-
-export function localName(name: string): string {
-  const separatorIndex = name.indexOf(":");
-  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
-}
-
-function parseAttributes(source: string): Record<string, string> {
-  const attributes: Record<string, string> = {};
-  const attributePattern = /([A-Za-z_][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
-
-  for (const match of source.matchAll(attributePattern)) {
-    const key = match[1];
-    if (!key) {
-      continue;
-    }
-
-    const rawValue = match[3] ?? match[4] ?? "";
-    attributes[key] = decodeXmlEntities(rawValue);
-  }
-
-  return attributes;
-}
-
-function decodeXmlEntities(value: string): string {
-  return value
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&quot;/g, "\"")
-    .replace(/&apos;/g, "'")
-    .replace(/&amp;/g, "&");
-}

package/src/io/opc/README.md

@@ -1,3 +0,0 @@
-# IO OPC
-
-Open Packaging Conventions package reading, part enumeration, and relationship handling belong here.

package/src/io/opc/corrupt-package.ts

@@ -1,166 +0,0 @@
-import type { EditorError } from "../../api/public-types.ts";
-
-export const CORRUPT_PACKAGE_REASONS = [
-  "zip-structure",
-  "content-types-missing",
-  "main-document-missing",
-  "broken-relationship-graph",
-  "malformed-xml",
-  "unsupported-compression",
-  "unreadable-package",
-] as const;
-
-export type CorruptPackageReason = (typeof CORRUPT_PACKAGE_REASONS)[number];
-
-export interface CorruptPackageIssue {
-  reason: CorruptPackageReason;
-  message: string;
-  partPath?: string;
-  relationshipSourcePath?: string;
-  relationshipId?: string;
-  targetPartPath?: string;
-  details?: Record<string, unknown>;
-}
-
-export interface CorruptPackageErrorDetails extends Record<string, unknown> {
-  stage: "package";
-  reason: CorruptPackageReason;
-  diagnosticsToken: string;
-  partPath?: string;
-  relationshipSourcePath?: string;
-  relationshipId?: string;
-  targetPartPath?: string;
-}
-
-export function createCorruptPackageError(
-  issue: CorruptPackageIssue,
-): EditorError {
-  return {
-    errorId: `error:package_corrupt:${createCorruptPackageDiagnosticsToken(issue)}`,
-    code: "package_corrupt",
-    message: issue.message,
-    isFatal: true,
-    source: "import",
-    details: {
-      stage: "package",
-      reason: issue.reason,
-      diagnosticsToken: createCorruptPackageDiagnosticsToken(issue),
-      ...(issue.partPath ? { partPath: issue.partPath } : {}),
-      ...(issue.relationshipSourcePath
-        ? { relationshipSourcePath: issue.relationshipSourcePath }
-        : {}),
-      ...(issue.relationshipId ? { relationshipId: issue.relationshipId } : {}),
-      ...(issue.targetPartPath ? { targetPartPath: issue.targetPartPath } : {}),
-      ...(issue.details ?? {}),
-    } satisfies CorruptPackageErrorDetails,
-  };
-}
-
-export function createMissingPartIssue(partPath: string): CorruptPackageIssue {
-  return {
-    reason:
-      partPath === "/[Content_Types].xml"
-        ? "content-types-missing"
-        : partPath === "/word/document.xml"
-          ? "main-document-missing"
-          : "unreadable-package",
-    message: `DOCX package is missing required part ${partPath}.`,
-    partPath,
-  };
-}
-
-export function createBrokenRelationshipIssue(input: {
-  relationshipSourcePath: string | null;
-  relationshipId: string;
-  targetPartPath: string;
-}): CorruptPackageIssue {
-  return {
-    reason: "broken-relationship-graph",
-    message:
-      input.relationshipSourcePath === null
-        ? `DOCX package relationship ${input.relationshipId} points to missing part ${input.targetPartPath}.`
-        : `DOCX part ${input.relationshipSourcePath} has unresolved relationship ${input.relationshipId} targeting ${input.targetPartPath}.`,
-    relationshipSourcePath: input.relationshipSourcePath ?? undefined,
-    relationshipId: input.relationshipId,
-    targetPartPath: input.targetPartPath,
-  };
-}
-
-export function classifyCorruptPackageError(error: unknown): CorruptPackageIssue {
-  const message =
-    error instanceof Error
-      ? error.message
-      : typeof error === "string"
-        ? error
-        : "DOCX package could not be read safely.";
-  const normalized = message.toLowerCase();
-
-  if (
-    normalized.includes("end of central directory") ||
-    normalized.includes("zip archive") ||
-    normalized.includes("central directory signature") ||
-    normalized.includes("local file header signature")
-  ) {
-    return {
-      reason: "zip-structure",
-      message,
-    };
-  }
-
-  if (normalized.includes("compression")) {
-    return {
-      reason: "unsupported-compression",
-      message,
-    };
-  }
-
-  if (normalized.includes("relationship")) {
-    return {
-      reason: "broken-relationship-graph",
-      message,
-    };
-  }
-
-  if (normalized.includes("/[content_types].xml")) {
-    return createMissingPartIssue("/[Content_Types].xml");
-  }
-
-  if (normalized.includes("/word/document.xml")) {
-    return createMissingPartIssue("/word/document.xml");
-  }
-
-  if (normalized.includes("xml")) {
-    return {
-      reason: "malformed-xml",
-      message,
-    };
-  }
-
-  return {
-    reason: "unreadable-package",
-    message,
-  };
-}
-
-export function createCorruptPackageDiagnosticsToken(
-  issue: CorruptPackageIssue,
-): string {
-  const fields = [
-    issue.reason,
-    issue.message,
-    issue.partPath ?? "",
-    issue.relationshipSourcePath ?? "",
-    issue.relationshipId ?? "",
-    issue.targetPartPath ?? "",
-  ];
-
-  let hash = 2166136261;
-  for (const field of fields) {
-    for (let index = 0; index < field.length; index += 1) {
-      hash ^= field.charCodeAt(index);
-      hash = Math.imul(hash, 16777619) >>> 0;
-    }
-  }
-
-  return `pkg-${hash.toString(16).padStart(8, "0")}`;
-}

package/src/io/opc/docx-package.ts

@@ -1,74 +0,0 @@
-import {
-  getRelationshipsPartPath,
-  type OpcPackageManifest,
-  type OpcPackagePart,
-} from "../ooxml/part-manifest.ts";
-import { writeOpcPackage } from "./package-writer.ts";
-
-export const DOCX_MIME_TYPE =
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
-export const DOCX_DOCUMENT_CONTENT_TYPE =
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
-export const DOCX_DOCUMENT_RELATIONSHIP_TYPE =
-  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
-
-interface WriteDocxPackageInput {
-  documentXml: string;
-  documentContentType?: string;
-  packageRelationshipType?: string;
-}
-
-export function writeDocxPackage(input: WriteDocxPackageInput): Uint8Array {
-  const documentPath = "/word/document.xml";
-  const contentType = input.documentContentType ?? DOCX_DOCUMENT_CONTENT_TYPE;
-  const relationshipType =
-    input.packageRelationshipType ?? DOCX_DOCUMENT_RELATIONSHIP_TYPE;
-  const documentBytes = new TextEncoder().encode(input.documentXml);
-
-  const documentPart: OpcPackagePart = {
-    path: documentPath,
-    surfaceKind: "content",
-    contentType,
-    relationshipsPartPath: getRelationshipsPartPath(documentPath),
-    relationships: [],
-    compression: "deflate",
-    bytes: documentBytes,
-    crc32: 0,
-  };
-
-  const manifest: OpcPackageManifest = {
-    contentTypes: {
-      defaults: {
-        rels: "application/vnd.openxmlformats-package.relationships+xml",
-        xml: "application/xml",
-      },
-      overrides: {
-        [documentPath]: contentType,
-      },
-    },
-    packageRelationships: [
-      {
-        id: "rId1",
-        type: relationshipType,
-        target: "word/document.xml",
-        targetMode: "internal",
-      },
-    ],
-    parts: [
-      {
-        path: documentPart.path,
-        surfaceKind: documentPart.surfaceKind,
-        contentType: documentPart.contentType,
-        relationshipsPartPath: documentPart.relationshipsPartPath,
-        relationships: documentPart.relationships,
-        compression: documentPart.compression,
-        byteLength: documentPart.bytes.byteLength,
-      },
-    ],
-  };
-
-  return writeOpcPackage({
-    manifest,
-    parts: new Map([[documentPart.path, documentPart]]),
-  });
-}