@beyondwork/docx-react-component 1.0.10 → 1.0.12

package/src/model/canonical-document.ts

@@ -494,7 +494,12 @@ export type TextMark =
   | { type: "imprint" }
   | { type: "shadow" }
   | { type: "position"; val: number }
-  | { type: "textFill"; xml: string };
+  | { type: "textFill"; xml: string }
+  | { type: "fontFamily"; val: string }
+  | { type: "fontSize"; val: number }
+  | { type: "textColor"; color: string }
+  | { type: "smallCaps" }
+  | { type: "allCaps" };
 
 export interface HardBreakNode {
   type: "hard_break";
@@ -847,6 +852,7 @@ export function validateCanonicalDocument(
   if (record.subParts !== undefined) {
     validateSubPartsCatalog(record.subParts, "$.subParts", issues);
   }
+  validateDocumentReferences(record, issues);
 
   return issues;
 }
@@ -1091,6 +1097,9 @@ function validateDocumentNode(
           validateDocumentNode(child, `${path}.children[${index}]`, issues),
         );
       }
+      if (type === "paragraph" && record.styleId !== undefined) {
+        expectDomainString(record.styleId, "styleId", `${path}.styleId`, issues);
+      }
       if (type === "paragraph" && record.numbering !== undefined) {
         const numbering = asPlainObject(record.numbering, `${path}.numbering`, issues);
         if (numbering) {
@@ -1100,8 +1109,17 @@ function validateDocumentNode(
             `${path}.numbering.numberingInstanceId`,
             issues,
           );
+          if (typeof numbering.level !== "number") {
+            issues.push({
+              path: `${path}.numbering.level`,
+              message: "level must be a number.",
+            });
+          }
         }
       }
+      if (type === "hyperlink") {
+        expectString(record.href, `${path}.href`, issues);
+      }
       return;
     case "alt_chunk":
       expectDomainString(record.relationshipId, "relationshipId", `${path}.relationshipId`, issues);
@@ -1160,6 +1178,8 @@ function validateDocumentNode(
       }
       return;
     case "field":
+      expectString(record.fieldType, `${path}.fieldType`, issues);
+      expectString(record.instruction, `${path}.instruction`, issues);
       if (!Array.isArray(record.children)) {
         issues.push({ path: `${path}.children`, message: "children must be an array." });
       } else {
@@ -1178,6 +1198,13 @@ function validateDocumentNode(
     case "section_break":
       return;
     case "text":
+      if (typeof record.text !== "string") {
+        issues.push({
+          path: `${path}.text`,
+          message: "text must be a string.",
+        });
+      }
+      return;
     case "hard_break":
     case "column_break":
     case "tab":
@@ -1190,7 +1217,12 @@ function validateDocumentNode(
       return;
     case "footnote_ref":
       expectString(record.noteId, `${path}.noteId`, issues);
-      expectString(record.noteKind, `${path}.noteKind`, issues);
+      if (record.noteKind !== "footnote" && record.noteKind !== "endnote") {
+        issues.push({
+          path: `${path}.noteKind`,
+          message: "noteKind must be 'footnote' or 'endnote'.",
+        });
+      }
       return;
     case "chart_preview":
     case "smartart_preview":
@@ -1798,11 +1830,363 @@ function validateAnchor(
 
   if (kind === "range") {
     validateRange(record.range, `${path}.range`, issues);
+    validateBoundaryAssoc(record.assoc, `${path}.assoc`, issues);
+  } else if (kind === "node") {
+    if (typeof record.at !== "number") {
+      issues.push({
+        path: `${path}.at`,
+        message: "node anchors must contain a numeric at value.",
+      });
+    }
+    if (record.assoc !== -1 && record.assoc !== 1) {
+      issues.push({
+        path: `${path}.assoc`,
+        message: "node anchor assoc must be -1 or 1.",
+      });
+    }
   } else if (kind === "detached") {
     validateRange(record.lastKnownRange, `${path}.lastKnownRange`, issues);
+    if (
+      record.reason !== "deleted" &&
+      record.reason !== "invalidatedByStructureChange" &&
+      record.reason !== "importAmbiguity"
+    ) {
+      issues.push({
+        path: `${path}.reason`,
+        message: "detached anchor reason must be deleted, invalidatedByStructureChange, or importAmbiguity.",
+      });
+    }
+  } else {
+    issues.push({
+      path: `${path}.kind`,
+      message: "anchor kind must be range, node, or detached.",
+    });
+  }
+}
+
+function validateBoundaryAssoc(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+
+  if (record.start !== -1 && record.start !== 1) {
+    issues.push({
+      path: `${path}.start`,
+      message: "assoc.start must be -1 or 1.",
+    });
+  }
+  if (record.end !== -1 && record.end !== 1) {
+    issues.push({
+      path: `${path}.end`,
+      message: "assoc.end must be -1 or 1.",
+    });
+  }
+}
+
+function validateDocumentReferences(
+  record: Record<string, unknown>,
+  issues: ModelValidationIssue[],
+): void {
+  const paragraphStyleIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.styles, "$.styles", [])?.paragraphs, "$.styles.paragraphs", []) ?? {}),
+  );
+  const numberingInstanceIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.numbering, "$.numbering", [])?.instances, "$.numbering.instances", []) ?? {}),
+  );
+  const abstractNumberingIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.numbering, "$.numbering", [])?.abstractDefinitions, "$.numbering.abstractDefinitions", []) ?? {}),
+  );
+  const mediaIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.media, "$.media", [])?.items, "$.media.items", []) ?? {}),
+  );
+  const warningIds = new Set(
+    (Array.isArray(asPlainObject(record.diagnostics, "$.diagnostics", [])?.warnings)
+      ? (asPlainObject(record.diagnostics, "$.diagnostics", [])?.warnings as Array<Record<string, unknown>>)
+      : []
+    ).flatMap((warning) => typeof warning.warningId === "string" ? [warning.warningId] : []),
+  );
+  const fragmentIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.preservation, "$.preservation", [])?.opaqueFragments, "$.preservation.opaqueFragments", []) ?? {}),
+  );
+  const noteIds = collectNoteIds(record);
+
+  const numberingInstances = asPlainObject(
+    asPlainObject(record.numbering, "$.numbering", [])?.instances,
+    "$.numbering.instances",
+    [],
+  );
+  if (numberingInstances) {
+    for (const [instanceId, instance] of Object.entries(numberingInstances)) {
+      const instanceRecord = asPlainObject(instance, `$.numbering.instances.${instanceId}`, []);
+      if (
+        instanceRecord &&
+        typeof instanceRecord.abstractNumberingId === "string" &&
+        !abstractNumberingIds.has(instanceRecord.abstractNumberingId)
+      ) {
+        issues.push({
+          path: `$.numbering.instances.${instanceId}.abstractNumberingId`,
+          message: "abstractNumberingId must reference an existing abstract numbering definition.",
+        });
+      }
+    }
+  }
+
+  validateDocumentNodeReferences(record.content, "$.content", issues, {
+    paragraphStyleIds,
+    numberingInstanceIds,
+    mediaIds,
+    warningIds,
+    fragmentIds,
+    noteIds,
+  });
+  validateSubPartReferences(record.subParts, "$.subParts", issues, {
+    paragraphStyleIds,
+    numberingInstanceIds,
+    mediaIds,
+    warningIds,
+    fragmentIds,
+    noteIds,
+  });
+  validateReviewReferences(record.review, "$.review", issues, warningIds);
+}
+
+function validateDocumentNodeReferences(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+  references: {
+    paragraphStyleIds: ReadonlySet<string>;
+    numberingInstanceIds: ReadonlySet<string>;
+    mediaIds: ReadonlySet<string>;
+    warningIds: ReadonlySet<string>;
+    fragmentIds: ReadonlySet<string>;
+    noteIds: ReadonlySet<string>;
+  },
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+
+  const type = typeof record.type === "string" ? record.type : undefined;
+  if (type === "paragraph") {
+    if (
+      typeof record.styleId === "string" &&
+      !references.paragraphStyleIds.has(record.styleId)
+    ) {
+      issues.push({
+        path: `${path}.styleId`,
+        message: "styleId must reference an existing paragraph style definition.",
+      });
+    }
+    const numbering = asPlainObject(record.numbering, `${path}.numbering`, []);
+    if (
+      numbering &&
+      typeof numbering.numberingInstanceId === "string" &&
+      !references.numberingInstanceIds.has(numbering.numberingInstanceId)
+    ) {
+      issues.push({
+        path: `${path}.numbering.numberingInstanceId`,
+        message: "numberingInstanceId must reference an existing numbering instance.",
+      });
+    }
+  } else if (type === "image") {
+    if (typeof record.mediaId === "string" && !references.mediaIds.has(record.mediaId)) {
+      issues.push({
+        path: `${path}.mediaId`,
+        message: "mediaId must reference an existing media catalog item.",
+      });
+    }
+  } else if (type === "opaque_inline" || type === "opaque_block") {
+    if (typeof record.fragmentId === "string" && !references.fragmentIds.has(record.fragmentId)) {
+      issues.push({
+        path: `${path}.fragmentId`,
+        message: "fragmentId must reference an existing opaque fragment.",
+      });
+    }
+    if (typeof record.warningId === "string" && !references.warningIds.has(record.warningId)) {
+      issues.push({
+        path: `${path}.warningId`,
+        message: "warningId must reference an existing diagnostic warning.",
+      });
+    }
+  } else if (type === "footnote_ref") {
+    if (typeof record.noteId === "string" && !references.noteIds.has(`${record.noteKind}:${record.noteId}`)) {
+      issues.push({
+        path: `${path}.noteId`,
+        message: "noteId must reference an existing footnote or endnote definition.",
+      });
+    }
+  }
+
+  if (Array.isArray(record.children)) {
+    record.children.forEach((child, index) =>
+      validateDocumentNodeReferences(child, `${path}.children[${index}]`, issues, references),
+    );
+  }
+  if (Array.isArray(record.rows)) {
+    record.rows.forEach((row, index) =>
+      validateDocumentNodeReferences(row, `${path}.rows[${index}]`, issues, references),
+    );
+  }
+  if (Array.isArray(record.cells)) {
+    record.cells.forEach((cell, index) =>
+      validateDocumentNodeReferences(cell, `${path}.cells[${index}]`, issues, references),
+    );
+  }
+}
+
+function validateReviewReferences(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+  warningIds: ReadonlySet<string>,
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+
+  const comments = asPlainObject(record.comments, `${path}.comments`, []);
+  if (comments) {
+    for (const [commentId, thread] of Object.entries(comments)) {
+      const threadRecord = asPlainObject(thread, `${path}.comments.${commentId}`, []);
+      if (!threadRecord || !Array.isArray(threadRecord.warningIds)) {
+        continue;
+      }
+      threadRecord.warningIds.forEach((warningId, index) => {
+        if (typeof warningId === "string" && !warningIds.has(warningId)) {
+          issues.push({
+            path: `${path}.comments.${commentId}.warningIds[${index}]`,
+            message: "warningIds must reference existing diagnostic warnings.",
+          });
+        }
+      });
+    }
+  }
+
+  const revisions = asPlainObject(record.revisions, `${path}.revisions`, []);
+  if (revisions) {
+    for (const [revisionId, revision] of Object.entries(revisions)) {
+      const revisionRecord = asPlainObject(revision, `${path}.revisions.${revisionId}`, []);
+      if (!revisionRecord || !Array.isArray(revisionRecord.warningIds)) {
+        continue;
+      }
+      revisionRecord.warningIds.forEach((warningId, index) => {
+        if (typeof warningId === "string" && !warningIds.has(warningId)) {
+          issues.push({
+            path: `${path}.revisions.${revisionId}.warningIds[${index}]`,
+            message: "warningIds must reference existing diagnostic warnings.",
+          });
+        }
+      });
+    }
+  }
+}
+
+function validateSubPartReferences(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+  references: {
+    paragraphStyleIds: ReadonlySet<string>;
+    numberingInstanceIds: ReadonlySet<string>;
+    mediaIds: ReadonlySet<string>;
+    warningIds: ReadonlySet<string>;
+    fragmentIds: ReadonlySet<string>;
+    noteIds: ReadonlySet<string>;
+  },
+): void {
+  if (value === undefined) {
+    return;
+  }
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+
+  const headers = Array.isArray(record.headers) ? record.headers : [];
+  headers.forEach((header, index) => {
+    const headerRecord = asPlainObject(header, `${path}.headers[${index}]`, []);
+    if (!headerRecord || !Array.isArray(headerRecord.blocks)) {
+      return;
+    }
+    headerRecord.blocks.forEach((block, blockIndex) =>
+      validateDocumentNodeReferences(block, `${path}.headers[${index}].blocks[${blockIndex}]`, issues, references),
+    );
+  });
+
+  const footers = Array.isArray(record.footers) ? record.footers : [];
+  footers.forEach((footer, index) => {
+    const footerRecord = asPlainObject(footer, `${path}.footers[${index}]`, []);
+    if (!footerRecord || !Array.isArray(footerRecord.blocks)) {
+      return;
+    }
+    footerRecord.blocks.forEach((block, blockIndex) =>
+      validateDocumentNodeReferences(block, `${path}.footers[${index}].blocks[${blockIndex}]`, issues, references),
+    );
+  });
+
+  if (record.footnoteCollection !== undefined) {
+    const footnoteCollection = asPlainObject(record.footnoteCollection, `${path}.footnoteCollection`, []);
+    const footnotes = asPlainObject(footnoteCollection?.footnotes, `${path}.footnoteCollection.footnotes`, []);
+    if (footnotes) {
+      for (const [noteId, note] of Object.entries(footnotes)) {
+        const noteRecord = asPlainObject(note, `${path}.footnoteCollection.footnotes.${noteId}`, []);
+        if (!noteRecord || !Array.isArray(noteRecord.blocks)) {
+          continue;
+        }
+        noteRecord.blocks.forEach((block, blockIndex) =>
+          validateDocumentNodeReferences(
+            block,
+            `${path}.footnoteCollection.footnotes.${noteId}.blocks[${blockIndex}]`,
+            issues,
+            references,
+          ),
+        );
+      }
+    }
+
+    const endnotes = asPlainObject(footnoteCollection?.endnotes, `${path}.footnoteCollection.endnotes`, []);
+    if (endnotes) {
+      for (const [noteId, note] of Object.entries(endnotes)) {
+        const noteRecord = asPlainObject(note, `${path}.footnoteCollection.endnotes.${noteId}`, []);
+        if (!noteRecord || !Array.isArray(noteRecord.blocks)) {
+          continue;
+        }
+        noteRecord.blocks.forEach((block, blockIndex) =>
+          validateDocumentNodeReferences(
+            block,
+            `${path}.footnoteCollection.endnotes.${noteId}.blocks[${blockIndex}]`,
+            issues,
+            references,
+          ),
+        );
+      }
+    }
   }
 }
 
+function collectNoteIds(record: Record<string, unknown>): Set<string> {
+  const noteIds = new Set<string>();
+  const subParts = asPlainObject(record.subParts, "$.subParts", []);
+  const footnoteCollection = asPlainObject(subParts?.footnoteCollection, "$.subParts.footnoteCollection", []);
+  const footnotes = asPlainObject(footnoteCollection?.footnotes, "$.subParts.footnoteCollection.footnotes", []);
+  if (footnotes) {
+    Object.keys(footnotes).forEach((noteId) => noteIds.add(`footnote:${noteId}`));
+  }
+  const endnotes = asPlainObject(footnoteCollection?.endnotes, "$.subParts.footnoteCollection.endnotes", []);
+  if (endnotes) {
+    Object.keys(endnotes).forEach((noteId) => noteIds.add(`endnote:${noteId}`));
+  }
+  return noteIds;
+}
+
 function validateRange(
   value: unknown,
   path: string,
@@ -1857,6 +2241,9 @@ function validateSubPartsCatalog(
   path: string,
   issues: ModelValidationIssue[],
 ): void {
+  if (value === undefined) {
+    return;
+  }
   const record = asPlainObject(value, path, issues);
   if (!record) {
     return;
@@ -1872,6 +2259,13 @@ function validateSubPartsCatalog(
           expectString(headerRecord.variant, `${path}.headers[${index}].variant`, issues);
           expectString(headerRecord.partPath, `${path}.headers[${index}].partPath`, issues);
           expectString(headerRecord.relationshipId, `${path}.headers[${index}].relationshipId`, issues);
+          if (!Array.isArray(headerRecord.blocks)) {
+            issues.push({ path: `${path}.headers[${index}].blocks`, message: "blocks must be an array." });
+          } else {
+            headerRecord.blocks.forEach((block, blockIndex) =>
+              validateDocumentNode(block, `${path}.headers[${index}].blocks[${blockIndex}]`, issues),
+            );
+          }
         }
       });
     }
@@ -1887,10 +2281,64 @@ function validateSubPartsCatalog(
           expectString(footerRecord.variant, `${path}.footers[${index}].variant`, issues);
           expectString(footerRecord.partPath, `${path}.footers[${index}].partPath`, issues);
           expectString(footerRecord.relationshipId, `${path}.footers[${index}].relationshipId`, issues);
+          if (!Array.isArray(footerRecord.blocks)) {
+            issues.push({ path: `${path}.footers[${index}].blocks`, message: "blocks must be an array." });
+          } else {
+            footerRecord.blocks.forEach((block, blockIndex) =>
+              validateDocumentNode(block, `${path}.footers[${index}].blocks[${blockIndex}]`, issues),
+            );
+          }
         }
       });
     }
   }
+
+  if (record.footnoteCollection !== undefined) {
+    const footnoteCollection = asPlainObject(record.footnoteCollection, `${path}.footnoteCollection`, issues);
+    if (footnoteCollection) {
+      validateSubPartNoteMap(footnoteCollection.footnotes, "footnote", `${path}.footnoteCollection.footnotes`, issues);
+      validateSubPartNoteMap(footnoteCollection.endnotes, "endnote", `${path}.footnoteCollection.endnotes`, issues);
+    }
+  }
+}
+
+function validateSubPartNoteMap(
+  value: unknown,
+  expectedKind: "footnote" | "endnote",
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+
+  for (const [noteId, note] of Object.entries(record)) {
+    const noteRecord = asPlainObject(note, `${path}.${noteId}`, issues);
+    if (!noteRecord) {
+      continue;
+    }
+    expectString(noteRecord.noteId, `${path}.${noteId}.noteId`, issues);
+    if (noteRecord.noteId !== noteId) {
+      issues.push({
+        path: `${path}.${noteId}.noteId`,
+        message: "noteId must match the map key.",
+      });
+    }
+    if (noteRecord.kind !== expectedKind) {
+      issues.push({
+        path: `${path}.${noteId}.kind`,
+        message: `kind must be ${expectedKind}.`,
+      });
+    }
+    if (!Array.isArray(noteRecord.blocks)) {
+      issues.push({ path: `${path}.${noteId}.blocks`, message: "blocks must be an array." });
+    } else {
+      noteRecord.blocks.forEach((block, blockIndex) =>
+        validateDocumentNode(block, `${path}.${noteId}.blocks[${blockIndex}]`, issues),
+      );
+    }
+  }
 }
 
 function expectDomainString(

package/src/model/cds-1.0.0.ts

@@ -1,11 +1,14 @@
 export const CDS_SCHEMA_VERSION = "cds/1.0.0" as const;
-export const PERSISTED_EDITOR_SNAPSHOT_VERSION =
+export const LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION =
   "persisted-editor-snapshot/1" as const;
+export const PERSISTED_EDITOR_SNAPSHOT_VERSION =
+  "persisted-editor-snapshot/2" as const;
 export const COMPATIBILITY_REPORT_VERSION = "compatibility-report/1" as const;
 
 export type CDS_SchemaVersion = typeof CDS_SCHEMA_VERSION;
 export type PersistedEditorSnapshotVersion =
-  typeof PERSISTED_EDITOR_SNAPSHOT_VERSION;
+  | typeof LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION
+  | typeof PERSISTED_EDITOR_SNAPSHOT_VERSION;
 export type CompatibilityReportVersion = typeof COMPATIBILITY_REPORT_VERSION;
 
 export type Id = string;