@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/src/model/snapshot.ts

@@ -1,649 +0,0 @@
-import {
-  CDS_SCHEMA_VERSION,
-  COMPATIBILITY_REPORT_VERSION,
-  LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION,
-  PERSISTED_EDITOR_SNAPSHOT_VERSION,
-  type CompatibilityReportVersion,
-  type Base64,
-  type ISO8601DateTime,
-  type ModelValidationIssue,
-  type PersistedEditorSnapshotVersion,
-  asPlainObject,
-  assertValid,
-  expectExactString,
-  expectIso8601UtcTimestamp,
-  expectString,
-  stableStringify,
-} from "./cds-1.0.0.ts";
-import {
-  type CanonicalDocument,
-  assertCanonicalDocument,
-  validateCanonicalDocument,
-} from "./canonical-document.ts";
-
-export type EditorWarningCode =
-  | "unsupported_ooxml_preserved"
-  | "unsupported_ooxml_locked"
-  | "import_normalized"
-  | "export_roundtrip_risk"
-  | "comment_anchor_detached"
-  | "revision_anchor_detached"
-  | "large_document_degraded"
-  | "font_substitution"
-  | "image_missing";
-
-export interface EditorWarning {
-  warningId: string;
-  code: EditorWarningCode;
-  severity: "info" | "warning";
-  message: string;
-  source:
-    | "import"
-    | "runtime"
-    | "review"
-    | "preservation"
-    | "validation"
-    | "export";
-  affectedAnchor?: Record<string, unknown>;
-  featureEntryId?: string;
-  details?: Record<string, unknown>;
-}
-
-export type EditorErrorCode =
-  | "import_failed"
-  | "export_failed"
-  | "package_corrupt"
-  | "validation_failed"
-  | "datastore_failed"
-  | "internal_invariant";
-
-export interface EditorError {
-  errorId: string;
-  code: EditorErrorCode;
-  message: string;
-  isFatal: boolean;
-  source: "import" | "runtime" | "validation" | "datastore" | "host" | "export";
-  details?: Record<string, unknown>;
-}
-
-export type CompatibilityFeatureClass =
-  | "supported-roundtrip"
-  | "preserve-only"
-  | "unsupported-fatal";
-
-export interface CompatibilityFeatureEntry {
-  featureEntryId: string;
-  featureKey: string;
-  featureClass: CompatibilityFeatureClass;
-  message: string;
-  affectedAnchor?: Record<string, unknown>;
-  details?: Record<string, unknown>;
-}
-
-export interface CompatibilityReport {
-  reportVersion: CompatibilityReportVersion;
-  generatedAt: ISO8601DateTime;
-  blockExport: boolean;
-  featureEntries: CompatibilityFeatureEntry[];
-  warnings: EditorWarning[];
-  errors: EditorError[];
-}
-
-export interface PersistedSourcePackage {
-  format: "docx";
-  storage: "embedded-base64";
-  mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
-  sourceLabel?: string;
-  sha256Hex: string;
-  bytesBase64: Base64;
-}
-
-export interface PersistedEditorSnapshot {
-  snapshotVersion: PersistedEditorSnapshotVersion;
-  schemaVersion: typeof CDS_SCHEMA_VERSION;
-  documentId: string;
-  docId: string;
-  createdAt: ISO8601DateTime;
-  updatedAt: ISO8601DateTime;
-  savedAt: ISO8601DateTime;
-  editorBuild: string;
-  canonicalDocument: CanonicalDocument;
-  compatibility: CompatibilityReport;
-  warningLog: EditorWarning[];
-  protectionSnapshot?: ProtectionSnapshotRecord;
-  sourcePackage?: PersistedSourcePackage;
-}
-
-const SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS = [
-  "snapshotVersion",
-  "schemaVersion",
-  "documentId",
-  "docId",
-  "createdAt",
-  "updatedAt",
-  "savedAt",
-  "editorBuild",
-  "canonicalDocument",
-  "compatibility",
-  "warningLog",
-] as const;
-
-const SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS = ["sourcePackage", "protectionSnapshot"] as const;
-
-export interface ProtectionRangeRecord {
-  rangeId: string;
-  start?: number;
-  end?: number;
-  editorGroup?: string;
-  editor?: string;
-  enforced: boolean;
-  enforcementReason: string;
-}
-
-export interface ProtectionSnapshotRecord {
-  hasDocumentProtection: boolean;
-  editType?: string;
-  enforcementActive: boolean;
-  ranges: ProtectionRangeRecord[];
-  enforcedRangeCount: number;
-  preservedRangeCount: number;
-}
-
-const PERSISTED_EDITOR_SNAPSHOT_VERSIONS = new Set<PersistedEditorSnapshotVersion>([
-  LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION,
-  PERSISTED_EDITOR_SNAPSHOT_VERSION,
-]);
-
-const DOCX_SOURCE_PACKAGE_MIME_TYPE =
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
-const COMPATIBILITY_FEATURE_CLASSES = new Set<CompatibilityFeatureClass>([
-  "supported-roundtrip",
-  "preserve-only",
-  "unsupported-fatal",
-]);
-const EDITOR_WARNING_CODES = new Set<EditorWarningCode>([
-  "unsupported_ooxml_preserved",
-  "unsupported_ooxml_locked",
-  "import_normalized",
-  "export_roundtrip_risk",
-  "comment_anchor_detached",
-  "revision_anchor_detached",
-  "large_document_degraded",
-  "font_substitution",
-  "image_missing",
-]);
-const EDITOR_WARNING_SEVERITIES = new Set<EditorWarning["severity"]>(["info", "warning"]);
-const EDITOR_WARNING_SOURCES = new Set<EditorWarning["source"]>([
-  "import",
-  "runtime",
-  "review",
-  "preservation",
-  "validation",
-  "export",
-]);
-const EDITOR_ERROR_CODES = new Set<EditorErrorCode>([
-  "import_failed",
-  "export_failed",
-  "package_corrupt",
-  "validation_failed",
-  "datastore_failed",
-  "internal_invariant",
-]);
-const EDITOR_ERROR_SOURCES = new Set<EditorError["source"]>([
-  "import",
-  "runtime",
-  "validation",
-  "datastore",
-  "host",
-  "export",
-]);
-
-export function serializePersistedEditorSnapshot(
-  snapshot: PersistedEditorSnapshot,
-): string {
-  assertPersistedEditorSnapshot(snapshot);
-  return stableStringify(snapshot);
-}
-
-export function parsePersistedEditorSnapshot(
-  json: string,
-): PersistedEditorSnapshot {
-  const parsed = JSON.parse(json) as unknown;
-  assertPersistedEditorSnapshot(parsed);
-  return parsed;
-}
-
-export function assertPersistedEditorSnapshot(
-  snapshot: unknown,
-): asserts snapshot is PersistedEditorSnapshot {
-  const issues = validatePersistedEditorSnapshot(snapshot);
-  assertValid(issues, "Invalid persisted editor snapshot.");
-}
-
-export function validatePersistedEditorSnapshot(
-  snapshot: unknown,
-): ModelValidationIssue[] {
-  const issues: ModelValidationIssue[] = [];
-  const record = asPlainObject(snapshot, "$", issues);
-  if (!record) {
-    return issues;
-  }
-
-  validateExactObjectKeys(
-    record,
-    SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS,
-    SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS,
-    "$",
-    issues,
-  );
-
-  validateSnapshotVersion(record.snapshotVersion, "$.snapshotVersion", issues);
-  expectExactString(
-    record.schemaVersion,
-    CDS_SCHEMA_VERSION,
-    "$.schemaVersion",
-    issues,
-  );
-  expectString(record.documentId, "$.documentId", issues);
-  expectString(record.docId, "$.docId", issues);
-  expectIso8601UtcTimestamp(record.createdAt, "$.createdAt", issues);
-  expectIso8601UtcTimestamp(record.updatedAt, "$.updatedAt", issues);
-  expectIso8601UtcTimestamp(record.savedAt, "$.savedAt", issues);
-  expectString(record.editorBuild, "$.editorBuild", issues);
-
-  const canonicalDocumentIssues = validateCanonicalDocument(record.canonicalDocument);
-  issues.push(...canonicalDocumentIssues.map(prefixIssue("$.canonicalDocument")));
-
-  if (
-    asPlainObject(record.canonicalDocument, "$.canonicalDocument", [])?.docId !==
-    record.docId
-  ) {
-    issues.push({
-      path: "$.docId",
-      message: "Snapshot docId must match canonicalDocument.docId.",
-    });
-  }
-
-  validateCompatibilityReport(record.compatibility, "$.compatibility", issues);
-
-  if (!Array.isArray(record.warningLog)) {
-    issues.push({
-      path: "$.warningLog",
-      message: "warningLog must be an array.",
-    });
-  } else {
-    record.warningLog.forEach((warning, index) => {
-      validateEditorWarning(warning, `$.warningLog[${index}]`, issues);
-    });
-  }
-
-  if (record.sourcePackage !== undefined) {
-    validatePersistedSourcePackage(record.sourcePackage, "$.sourcePackage", issues);
-  }
-  if (record.protectionSnapshot !== undefined) {
-    validateProtectionSnapshot(record.protectionSnapshot, "$.protectionSnapshot", issues);
-  }
-
-  return issues;
-}
-
-export function assertCompatibilityReport(
-  report: unknown,
-): asserts report is CompatibilityReport {
-  const issues = validateCompatibilityReport(report);
-  assertValid(issues, "Invalid compatibility report.");
-}
-
-export function validateCompatibilityReport(
-  report: unknown,
-  path = "$",
-  issues: ModelValidationIssue[] = [],
-): ModelValidationIssue[] {
-  const record = asPlainObject(report, path, issues);
-  if (!record) {
-    return issues;
-  }
-
-  expectExactString(
-    record.reportVersion,
-    COMPATIBILITY_REPORT_VERSION,
-    `${path}.reportVersion`,
-    issues,
-  );
-  expectIso8601UtcTimestamp(record.generatedAt, `${path}.generatedAt`, issues);
-
-  if (typeof record.blockExport !== "boolean") {
-    issues.push({
-      path: `${path}.blockExport`,
-      message: "blockExport must be a boolean.",
-    });
-  }
-
-  if (!Array.isArray(record.featureEntries)) {
-    issues.push({
-      path: `${path}.featureEntries`,
-      message: "featureEntries must be an array.",
-    });
-  } else {
-    record.featureEntries.forEach((featureEntry, index) => {
-      validateCompatibilityFeatureEntry(
-        featureEntry,
-        `${path}.featureEntries[${index}]`,
-        issues,
-      );
-    });
-  }
-
-  if (!Array.isArray(record.warnings)) {
-    issues.push({
-      path: `${path}.warnings`,
-      message: "warnings must be an array.",
-    });
-  } else {
-    record.warnings.forEach((warning, index) => {
-      validateEditorWarning(warning, `${path}.warnings[${index}]`, issues);
-    });
-  }
-
-  if (!Array.isArray(record.errors)) {
-    issues.push({
-      path: `${path}.errors`,
-      message: "errors must be an array.",
-    });
-  } else {
-    record.errors.forEach((error, index) => {
-      validateEditorError(error, `${path}.errors[${index}]`, issues);
-    });
-  }
-
-  return issues;
-}
-
-function validateCompatibilityFeatureEntry(
-  featureEntry: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(featureEntry, path, issues);
-  if (!record) {
-    return;
-  }
-
-  expectString(record.featureEntryId, `${path}.featureEntryId`, issues);
-  expectString(record.featureKey, `${path}.featureKey`, issues);
-  if (
-    typeof record.featureClass !== "string" ||
-    !COMPATIBILITY_FEATURE_CLASSES.has(record.featureClass as CompatibilityFeatureClass)
-  ) {
-    issues.push({
-      path: `${path}.featureClass`,
-      message: "featureClass must be supported-roundtrip, preserve-only, or unsupported-fatal.",
-    });
-  }
-  expectString(record.message, `${path}.message`, issues);
-}
-
-function validateEditorWarning(
-  warning: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(warning, path, issues);
-  if (!record) {
-    return;
-  }
-
-  expectString(record.warningId, `${path}.warningId`, issues);
-  if (typeof record.code !== "string" || !EDITOR_WARNING_CODES.has(record.code as EditorWarningCode)) {
-    issues.push({
-      path: `${path}.code`,
-      message: `code must be one of ${JSON.stringify([...EDITOR_WARNING_CODES])}.`,
-    });
-  }
-  if (
-    typeof record.severity !== "string" ||
-    !EDITOR_WARNING_SEVERITIES.has(record.severity as EditorWarning["severity"])
-  ) {
-    issues.push({
-      path: `${path}.severity`,
-      message: "severity must be info or warning.",
-    });
-  }
-  expectString(record.message, `${path}.message`, issues);
-  if (
-    typeof record.source !== "string" ||
-    !EDITOR_WARNING_SOURCES.has(record.source as EditorWarning["source"])
-  ) {
-    issues.push({
-      path: `${path}.source`,
-      message: `source must be one of ${JSON.stringify([...EDITOR_WARNING_SOURCES])}.`,
-    });
-  }
-}
-
-function validateEditorError(
-  error: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(error, path, issues);
-  if (!record) {
-    return;
-  }
-
-  expectString(record.errorId, `${path}.errorId`, issues);
-  if (typeof record.code !== "string" || !EDITOR_ERROR_CODES.has(record.code as EditorErrorCode)) {
-    issues.push({
-      path: `${path}.code`,
-      message: `code must be one of ${JSON.stringify([...EDITOR_ERROR_CODES])}.`,
-    });
-  }
-  expectString(record.message, `${path}.message`, issues);
-  if (
-    typeof record.source !== "string" ||
-    !EDITOR_ERROR_SOURCES.has(record.source as EditorError["source"])
-  ) {
-    issues.push({
-      path: `${path}.source`,
-      message: `source must be one of ${JSON.stringify([...EDITOR_ERROR_SOURCES])}.`,
-    });
-  }
-
-  if (typeof record.isFatal !== "boolean") {
-    issues.push({
-      path: `${path}.isFatal`,
-      message: "isFatal must be a boolean.",
-    });
-  }
-}
-
-function validateExactObjectKeys(
-  record: Record<string, unknown>,
-  requiredKeys: readonly string[],
-  optionalKeys: readonly string[],
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const actualKeys = new Set(Object.keys(record));
-  const allowedKeys = new Set([...requiredKeys, ...optionalKeys]);
-
-  for (const requiredKey of requiredKeys) {
-    if (!actualKeys.has(requiredKey)) {
-      issues.push({
-        path,
-        message: `Missing required key ${JSON.stringify(requiredKey)}.`,
-      });
-    }
-  }
-
-  for (const actualKey of actualKeys) {
-    if (!allowedKeys.has(actualKey)) {
-      issues.push({
-        path: `${path}.${actualKey}`,
-        message:
-          "Unexpected persisted snapshot key. Render/UI state is not part of the persistence contract.",
-      });
-    }
-  }
-}
-
-function prefixIssue(basePath: string) {
-  return (issue: ModelValidationIssue): ModelValidationIssue => ({
-    path: `${basePath}${issue.path === "$" ? "" : issue.path.slice(1)}`,
-    message: issue.message,
-  });
-}
-
-function validateSnapshotVersion(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): PersistedEditorSnapshotVersion | null {
-  if (typeof value !== "string" || !PERSISTED_EDITOR_SNAPSHOT_VERSIONS.has(value as never)) {
-    issues.push({
-      path,
-      message: `Expected one of ${JSON.stringify([...PERSISTED_EDITOR_SNAPSHOT_VERSIONS])}.`,
-    });
-    return null;
-  }
-
-  return value as PersistedEditorSnapshotVersion;
-}
-
-function validatePersistedSourcePackage(
-  sourcePackage: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(sourcePackage, path, issues);
-  if (!record) {
-    return;
-  }
-
-  validateExactObjectKeys(
-    record,
-    ["format", "storage", "mimeType", "sha256Hex", "bytesBase64"],
-    ["sourceLabel"],
-    path,
-    issues,
-  );
-  expectExactString(record.format, "docx", `${path}.format`, issues);
-  expectExactString(record.storage, "embedded-base64", `${path}.storage`, issues);
-  expectExactString(
-    record.mimeType,
-    DOCX_SOURCE_PACKAGE_MIME_TYPE,
-    `${path}.mimeType`,
-    issues,
-  );
-  expectString(record.sha256Hex, `${path}.sha256Hex`, issues);
-  expectString(record.bytesBase64, `${path}.bytesBase64`, issues);
-
-  if (
-    typeof record.sha256Hex === "string" &&
-    !/^[0-9a-f]{64}$/u.test(record.sha256Hex)
-  ) {
-    issues.push({
-      path: `${path}.sha256Hex`,
-      message: "Expected a lowercase SHA-256 hex digest.",
-    });
-  }
-
-  if (record.sourceLabel !== undefined) {
-    expectString(record.sourceLabel, `${path}.sourceLabel`, issues);
-  }
-}
-
-export function createPersistedEditorSnapshot(params: {
-  documentId: string;
-  savedAt: ISO8601DateTime;
-  editorBuild: string;
-  canonicalDocument: CanonicalDocument;
-  compatibility: CompatibilityReport;
-  warningLog?: EditorWarning[];
-  protectionSnapshot?: ProtectionSnapshotRecord;
-  sourcePackage?: PersistedSourcePackage;
-}): PersistedEditorSnapshot {
-  assertCanonicalDocument(params.canonicalDocument);
-  assertCompatibilityReport(params.compatibility);
-
-  return {
-    snapshotVersion: PERSISTED_EDITOR_SNAPSHOT_VERSION,
-    schemaVersion: CDS_SCHEMA_VERSION,
-    documentId: params.documentId,
-    docId: params.canonicalDocument.docId,
-    createdAt: params.canonicalDocument.createdAt,
-    updatedAt: params.canonicalDocument.updatedAt,
-    savedAt: params.savedAt,
-    editorBuild: params.editorBuild,
-    canonicalDocument: params.canonicalDocument,
-    compatibility: params.compatibility,
-    warningLog: params.warningLog ?? params.compatibility.warnings,
-    protectionSnapshot: params.protectionSnapshot,
-    sourcePackage: params.sourcePackage,
-  };
-}
-
-function validateProtectionSnapshot(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-  if (typeof record.hasDocumentProtection !== "boolean") {
-    issues.push({ path: `${path}.hasDocumentProtection`, message: "hasDocumentProtection must be a boolean." });
-  }
-  if (record.editType !== undefined) {
-    expectString(record.editType, `${path}.editType`, issues);
-  }
-  if (typeof record.enforcementActive !== "boolean") {
-    issues.push({ path: `${path}.enforcementActive`, message: "enforcementActive must be a boolean." });
-  }
-  if (!Array.isArray(record.ranges)) {
-    issues.push({ path: `${path}.ranges`, message: "ranges must be an array." });
-  } else {
-    record.ranges.forEach((range, index) => validateProtectionRange(range, `${path}.ranges[${index}]`, issues));
-  }
-  if (!Number.isInteger(record.enforcedRangeCount)) {
-    issues.push({ path: `${path}.enforcedRangeCount`, message: "enforcedRangeCount must be an integer." });
-  }
-  if (!Number.isInteger(record.preservedRangeCount)) {
-    issues.push({ path: `${path}.preservedRangeCount`, message: "preservedRangeCount must be an integer." });
-  }
-}
-
-function validateProtectionRange(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-  expectString(record.rangeId, `${path}.rangeId`, issues);
-  if (record.start !== undefined && !Number.isInteger(record.start)) {
-    issues.push({ path: `${path}.start`, message: "start must be an integer." });
-  }
-  if (record.end !== undefined && !Number.isInteger(record.end)) {
-    issues.push({ path: `${path}.end`, message: "end must be an integer." });
-  }
-  if (record.editorGroup !== undefined) {
-    expectString(record.editorGroup, `${path}.editorGroup`, issues);
-  }
-  if (record.editor !== undefined) {
-    expectString(record.editor, `${path}.editor`, issues);
-  }
-  if (typeof record.enforced !== "boolean") {
-    issues.push({ path: `${path}.enforced`, message: "enforced must be a boolean." });
-  }
-  expectString(record.enforcementReason, `${path}.enforcementReason`, issues);
-}
-
-export function projectAnchorToSnapshot(
-  anchor: Record<string, unknown>,
-): Record<string, unknown> {
-  return JSON.parse(JSON.stringify(anchor)) as Record<string, unknown>;
-}

package/src/preservation/README.md

@@ -1,3 +0,0 @@
-# Preservation
-
-Unsupported OOXML capture, retention, untouched package-part preservation, and export reattachment logic belong here.

package/src/preservation/markup-compatibility.ts

@@ -1,48 +0,0 @@
-export function extractDocumentRootAttributes(documentXml: string): Record<string, string> {
-  const match = documentXml.match(
-    /<(?:[A-Za-z_][A-Za-z0-9:._-]*:)?document\b([^>]*)>/u,
-  );
-  if (!match) {
-    return {};
-  }
-
-  const attributes: Record<string, string> = {};
-  const pattern = /([A-Za-z_][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/gu;
-  for (const attributeMatch of (match[1] ?? "").matchAll(pattern)) {
-    const name = attributeMatch[1];
-    const value = attributeMatch[3] ?? attributeMatch[4] ?? "";
-    if (!name) {
-      continue;
-    }
-
-    attributes[name] = value;
-  }
-
-  return attributes;
-}
-
-export function extractMarkupCompatibilityAttributes(
-  documentXml: string,
-): Record<string, string> {
-  return filterMarkupCompatibilityAttributes(extractDocumentRootAttributes(documentXml));
-}
-
-export function filterMarkupCompatibilityAttributes(
-  attributes: Record<string, string>,
-): Record<string, string> {
-  return Object.fromEntries(
-    Object.entries(attributes).filter(([name]) =>
-      name.startsWith("xmlns:mc") ||
-      name === "mc:Ignorable" ||
-      name === "mc:ProcessContent" ||
-      name === "mc:PreserveAttributes" ||
-      name === "mc:PreserveElements" ||
-      name.startsWith("xmlns:w1") ||
-      name.startsWith("xmlns:wsp") ||
-      name.startsWith("xmlns:wpg") ||
-      name.startsWith("xmlns:wpi") ||
-      name.startsWith("xmlns:wne") ||
-      name.startsWith("xmlns:wps"),
-    ),
-  );
-}