@json-to-office/core-docx 2.3.0 → 2.5.0

package/dist/index.js

@@ -15,8 +15,10 @@ var __export = (target, all) => {
 };
 
 // src/themes/defaults.ts
+import { designColors } from "@json-to-office/shared";
 function ensureThemeDefaults(theme) {
   return {
+    ...theme,
     $schema: theme.$schema,
     name: theme.name || "default",
     displayName: theme.displayName || "Default Theme",
@@ -27,6 +29,7 @@ function ensureThemeDefaults(theme) {
       ...theme.colors || {}
     },
     fonts: {
+      ...theme.fonts || {},
       heading: { ...DEFAULT_FONTS.heading, ...theme.fonts?.heading || {} },
       body: { ...DEFAULT_FONTS.body, ...theme.fonts?.body || {} },
       mono: { ...DEFAULT_FONTS.mono, ...theme.fonts?.mono || {} },
@@ -45,10 +48,13 @@ function ensureThemeDefaults(theme) {
   };
 }
 function getThemeColors(theme) {
-  return {
-    ...DEFAULT_COLORS,
-    ...theme.colors || {}
-  };
+  return designColors(
+    {
+      ...DEFAULT_COLORS,
+      ...theme.colors || {}
+    },
+    theme.palette
+  );
 }
 function getThemeFonts(theme) {
   return {
@@ -186,6 +192,10 @@ var init_defaults = __esm({
 });
 
 // src/styles/utils/colorUtils.ts
+import {
+  DEFAULT_CHART_THEME_COLORS,
+  resolveDesignColor
+} from "@json-to-office/shared";
 function resolveColor(colorValue, theme) {
   if (colorValue.startsWith("#")) {
     const hexValue = colorValue.slice(1);
@@ -199,7 +209,11 @@ function resolveColor(colorValue, theme) {
   const colors = getThemeColors(theme);
   const resolvedColor = colors[colorValue];
   if (typeof resolvedColor === "string") {
-    return resolveColor(resolvedColor, theme);
+    const hex = resolveDesignColor(colorValue, colors);
+    if (hex) return hex.toUpperCase();
+    throw new Error(
+      `Unresolvable theme color: "${colorValue}" (missing reference or cycle).`
+    );
   }
   if (/^[0-9A-Fa-f]{6}$/.test(colorValue)) {
     return colorValue.toUpperCase();
@@ -208,6 +222,15 @@ function resolveColor(colorValue, theme) {
     `Invalid color value: "${colorValue}". Must be a hex color with # prefix (e.g., "#000000") or a valid theme color name.`
   );
 }
+function chartPaletteValues(theme) {
+  const explicit = theme.palette?.chart;
+  if (explicit) return [...explicit];
+  const colors = getThemeColors(theme);
+  return DEFAULT_CHART_THEME_COLORS.flatMap((token) => {
+    const value = colors[token];
+    return typeof value === "string" && value.length > 0 ? [value] : [];
+  });
+}
 var init_colorUtils = __esm({
   "src/styles/utils/colorUtils.ts"() {
     "use strict";
@@ -988,6 +1011,8 @@ function resolveFontProperties(theme, fontRef) {
     size: fontDef.size,
     color: fontDef.color,
     bold: fontDef.bold,
+    fontWeight: fontDef.fontWeight,
+    case: fontDef.case,
     italic: fontDef.italic,
     underline: fontDef.underline,
     alignment: fontDef.alignment,
@@ -2070,6 +2095,9 @@ function runOptions(formatting) {
     options.underline = formatting.underline ? { type: formatting.underline.type } : void 0;
   }
   if (formatting.strike !== void 0) options.strike = formatting.strike;
+  if (formatting.allCaps !== void 0) options.allCaps = formatting.allCaps;
+  if (formatting.smallCaps !== void 0)
+    options.smallCaps = formatting.smallCaps;
   if (formatting.scalePercent !== void 0) {
     options.scale = formatting.scalePercent;
   }
@@ -2760,6 +2788,44 @@ var init_styles2 = __esm({
   }
 });
 
+// src/utils/normalizeTextCase.ts
+function normalizeTextCase(zip) {
+  let changed = false;
+  for (const entry of zip.getEntries()) {
+    if (!WORD_XML.test(entry.entryName)) continue;
+    const xml = entry.getData().toString("utf8");
+    if (!ANY_CASE_FLAG.test(xml)) continue;
+    const normalized = xml.replace(RUN_PROPERTIES, completeCaseFlags);
+    if (normalized === xml) continue;
+    zip.updateFile(entry, Buffer.from(normalized, "utf8"));
+    changed = true;
+  }
+  return changed;
+}
+function completeCaseFlags(runProperties3) {
+  const flag = CASE_FLAG.exec(runProperties3);
+  if (!flag) return runProperties3;
+  const isCaps = flag[1] === "caps";
+  const opposite = `<w:${isCaps ? "smallCaps" : "caps"} w:val="false"/>`;
+  if (runProperties3.includes(`<w:${isCaps ? "smallCaps" : "caps"}`)) {
+    return runProperties3;
+  }
+  return runProperties3.replace(
+    flag[0],
+    isCaps ? `${flag[0]}${opposite}` : `${opposite}${flag[0]}`
+  );
+}
+var WORD_XML, ANY_CASE_FLAG, RUN_PROPERTIES, CASE_FLAG;
+var init_normalizeTextCase = __esm({
+  "src/utils/normalizeTextCase.ts"() {
+    "use strict";
+    WORD_XML = /^word\/.*\.xml$/;
+    ANY_CASE_FLAG = /<w:(?:caps|smallCaps)\b/;
+    RUN_PROPERTIES = /<w:rPr\b[^>]*>[\s\S]*?<\/w:rPr>/g;
+    CASE_FLAG = /<w:(caps|smallCaps)\b[^>]*(?:\/>|>[\s\S]*?<\/w:\1>)/;
+  }
+});
+
 // src/utils/packageDocument.ts
 import AdmZip from "adm-zip";
 function resolveGenerationDate(options) {
@@ -2828,6 +2894,7 @@ function canonicalizeRelationshipIds(zip) {
 }
 function canonicalizeDocxBuffer(buffer, generatedAt = DEFAULT_GENERATION_DATE) {
   const zip = new AdmZip(buffer);
+  normalizeTextCase(zip);
   canonicalizeRelationshipIds(zip);
   const isoTimestamp = generatedAt.toISOString();
   const coreProperties3 = zip.getEntry("docProps/core.xml");
@@ -2844,10 +2911,15 @@ function canonicalizeDocxBuffer(buffer, generatedAt = DEFAULT_GENERATION_DATE) {
   }
   return zip.toBuffer();
 }
+function normalizeDocxCaseBuffer(buffer) {
+  const zip = new AdmZip(buffer);
+  return normalizeTextCase(zip) ? zip.toBuffer() : buffer;
+}
 var DEFAULT_GENERATION_DATE, STABLE_RELATIONSHIP_ID;
 var init_packageDocument = __esm({
   "src/utils/packageDocument.ts"() {
     "use strict";
+    init_normalizeTextCase();
     DEFAULT_GENERATION_DATE = /* @__PURE__ */ new Date("2000-01-01T00:00:00.000Z");
     STABLE_RELATIONSHIP_ID = /^rId\d+$/;
   }
@@ -2906,7 +2978,8 @@ function createDocxJsRenderer() {
       const document = buildDocument(ir, resources);
       const packed = await Packer.toBuffer(document);
       const fixed = fixFloatingImageIdsInBuffer(packed);
-      if (renderOptions?.deterministic === false) return new Uint8Array(fixed);
+      if (renderOptions?.deterministic === false)
+        return new Uint8Array(normalizeDocxCaseBuffer(fixed));
       return new Uint8Array(
         canonicalizeDocxBuffer(
           fixed,
@@ -4185,7 +4258,8 @@ async function createOfficeOpenDocxRenderer() {
         spliceChartParts(zip, charts);
         raw = zip.toBuffer();
       }
-      if (options?.deterministic === false) return new Uint8Array(raw);
+      if (options?.deterministic === false)
+        return new Uint8Array(normalizeDocxCaseBuffer(raw));
       return new Uint8Array(
         canonicalizeDocxBuffer(
           raw,
@@ -5043,7 +5117,6 @@ import {
 
 // src/components/highcharts.ts
 init_colorUtils();
-import { DEFAULT_CHART_THEME_COLORS } from "@json-to-office/shared";
 var DEFAULT_EXPORT_SERVER_URL = "http://localhost:7801";
 async function generateChart(config, servicesConfig) {
   if (!isNodeEnvironment()) {
@@ -5097,11 +5170,10 @@ function toChartColor(value, theme) {
 function withThemeColors(config, theme) {
   const options = config.options;
   if (!options || options.colors || !theme?.colors) return config;
-  const themeColors = theme.colors;
-  const palette = DEFAULT_CHART_THEME_COLORS.map((token) => {
-    const value = themeColors[token];
-    return typeof value === "string" && value.length > 0 ? toChartColor(value, theme) : void 0;
-  }).filter((c) => c !== void 0);
+  const palette = chartPaletteValues(theme).flatMap((value) => {
+    const color = toChartColor(value, theme);
+    return color ? [color] : [];
+  });
   if (palette.length === 0) return config;
   return {
     ...config,
@@ -5347,10 +5419,7 @@ init_colorUtils();
 import {
   FeatureRequirementCollector
 } from "@json-to-office/shared/rendering";
-import {
-  synthesizeFamilyName,
-  DEFAULT_CHART_THEME_COLORS as DEFAULT_CHART_THEME_COLORS2
-} from "@json-to-office/shared";
+import { capsFormatting as capsFormatting2, synthesizeFamilyName as synthesizeFamilyName2 } from "@json-to-office/shared";
 import {
   isNativeVisualProps as isNativeVisualProps4
 } from "@json-to-office/shared-docx";
@@ -5866,6 +5935,7 @@ function resolveColors(entries, at, deps) {
 init_themes();
 init_colorUtils();
 init_styleHelpers();
+import { capsFormatting, synthesizeFamilyName } from "@json-to-office/shared";
 var RIGHT_MARGIN_TAB_TWIPS = 9026 * 2;
 var STATISTIC_NUMBER_STYLE_ID = "StatisticNumber";
 var STATISTIC_DESCRIPTION_STYLE_ID = "StatisticDescription";
@@ -5874,25 +5944,8 @@ var STATISTIC_SIZE_POINTS = {
   medium: 28,
   large: 40
 };
-function isValidStyleName(name) {
-  return [
-    "normal",
-    "heading1",
-    "heading2",
-    "heading3",
-    "heading4",
-    "heading5",
-    "heading6",
-    "title",
-    "subtitle"
-  ].includes(name);
-}
 function getStyleSafe(theme, styleName) {
-  if (!isValidStyleName(styleName)) {
-    console.warn(`Invalid style name: ${styleName}`);
-    return void 0;
-  }
-  return theme.styles?.[styleName];
+  return theme.styles && Object.hasOwn(theme.styles, styleName) ? theme.styles[styleName] : void 0;
 }
 function resolveStyleWithBaseStyle(theme, styleName, visited = /* @__PURE__ */ new Set()) {
   if (visited.has(styleName)) {
@@ -5949,9 +6002,17 @@ function resolveSpacing(spacing) {
     ...spacing?.after ? { afterTwips: pointsToTwips(spacing.after) } : {}
   };
 }
+function weightedFamily(props) {
+  return props.fontWeight === void 0 ? void 0 : synthesizeFamilyName(
+    props.family || "Arial",
+    props.fontWeight,
+    props.italic === true
+  );
+}
 function convertRunProperties(merged, theme, defaultColor, defaultSize) {
+  const weighted = weightedFamily(merged);
   return {
-    fontFamily: merged.family || "Arial",
+    fontFamily: weighted?.family ?? merged.family ?? "Arial",
     sizeHalfPoints: (merged.size || defaultSize || 11) * 2,
     color: {
       hex: resolveColor(
@@ -5961,6 +6022,8 @@ function convertRunProperties(merged, theme, defaultColor, defaultSize) {
     },
     ...merged.bold !== void 0 && { bold: merged.bold },
     ...merged.italic !== void 0 && { italic: merged.italic },
+    ...weighted && { bold: weighted.bold, italic: weighted.italic },
+    ...merged.case !== void 0 && capsFormatting(merged.case),
     ...merged.underline !== void 0 && merged.underline && { underline: { type: "single" } },
     ...merged.characterSpacing && {
       characterSpacingTwentieths: merged.characterSpacing.type === "condensed" ? -merged.characterSpacing.value : merged.characterSpacing.value
@@ -6033,12 +6096,15 @@ function convertBorders(borders3, theme) {
   return Object.keys(converted).length > 0 ? converted : void 0;
 }
 function fallbackRun(fontProps, theme, defaultColor, defaultSize) {
+  const weighted = weightedFamily(fontProps);
   return {
-    fontFamily: fontProps.family || "Arial",
+    fontFamily: weighted?.family ?? fontProps.family ?? "Arial",
     sizeHalfPoints: (fontProps.size || defaultSize) * 2,
     color: { hex: resolveColor(fontProps.color || defaultColor, theme) },
     ...fontProps.bold !== void 0 && { bold: fontProps.bold },
     ...fontProps.italic !== void 0 && { italic: fontProps.italic },
+    ...weighted && { bold: weighted.bold, italic: weighted.italic },
+    ...fontProps.case !== void 0 && capsFormatting(fontProps.case),
     ...fontProps.underline !== void 0 && fontProps.underline && { underline: { type: "single" } }
   };
 }
@@ -6068,6 +6134,8 @@ function createDocumentStyles(themeNameOrObject = "minimal", language) {
           size: normalStyle?.size,
           color: normalStyle?.color,
           bold: normalStyle?.bold,
+          fontWeight: normalStyle?.fontWeight,
+          case: normalStyle?.case,
           italic: normalStyle?.italic,
           underline: normalStyle?.underline,
           characterSpacing: normalStyle?.characterSpacing,
@@ -6107,6 +6175,8 @@ function createDocumentStyles(themeNameOrObject = "minimal", language) {
             size: headingStyle.size,
             color: headingStyle.color,
             bold: headingStyle.bold,
+            fontWeight: headingStyle.fontWeight,
+            case: headingStyle.case,
             italic: headingStyle.italic,
             underline: headingStyle.underline,
             characterSpacing: headingStyle.characterSpacing,
@@ -6167,6 +6237,8 @@ function createDocumentStyles(themeNameOrObject = "minimal", language) {
             size: headingStyle.size,
             color: headingStyle.color,
             bold: headingStyle.bold,
+            fontWeight: headingStyle.fontWeight,
+            case: headingStyle.case,
             italic: headingStyle.italic,
             underline: headingStyle.underline,
             characterSpacing: headingStyle.characterSpacing,
@@ -6228,6 +6300,8 @@ function createDocumentStyles(themeNameOrObject = "minimal", language) {
           size: titleStyle.size,
           color: titleStyle.color,
           bold: titleStyle.bold,
+          fontWeight: titleStyle.fontWeight,
+          case: titleStyle.case,
           italic: titleStyle.italic,
           underline: titleStyle.underline,
           characterSpacing: titleStyle.characterSpacing,
@@ -6283,6 +6357,8 @@ function createDocumentStyles(themeNameOrObject = "minimal", language) {
           size: subtitleStyle.size,
           color: subtitleStyle.color,
           bold: subtitleStyle.bold,
+          fontWeight: subtitleStyle.fontWeight,
+          case: subtitleStyle.case,
           italic: subtitleStyle.italic,
           underline: subtitleStyle.underline,
           characterSpacing: subtitleStyle.characterSpacing,
@@ -6405,6 +6481,8 @@ function createDocumentStyles(themeNameOrObject = "minimal", language) {
             size: customStyle.size,
             color: customStyle.color,
             bold: customStyle.bold,
+            fontWeight: customStyle.fontWeight,
+            case: customStyle.case,
             italic: customStyle.italic,
             underline: customStyle.underline,
             characterSpacing: customStyle.characterSpacing,
@@ -8280,6 +8358,7 @@ function compileChromeParagraph(component, scope) {
       italic: font.italic ?? false,
       ...font.underline !== void 0 ? { underline: font.underline } : {},
       ...font.fontWeight !== void 0 ? { fontWeight: font.fontWeight } : {},
+      ...font.case !== void 0 ? { case: font.case } : {},
       ...font.lineSpacing !== void 0 ? { lineSpacing: font.lineSpacing } : {}
     }
   };
@@ -9583,7 +9662,11 @@ function isoDateTime(date) {
 }
 function runFormatting3(font, props, ctx) {
   const hasWeightRequest = font.fontWeight != null || font.bold === true;
-  const effectiveFamily = font.family ?? (hasWeightRequest ? resolveBodyFamily(ctx.theme) : void 0);
+  const roleName = props.themeStyle;
+  const role = roleName ? ctx.theme.typography?.roles?.[roleName] : void 0;
+  const roleStyles = ctx.theme.styles;
+  const roleFamily = role && roleName ? resolveFontFamily(ctx.theme, roleStyles?.[roleName]?.font ?? role.face) : void 0;
+  const effectiveFamily = font.family ?? (hasWeightRequest ? roleFamily ?? resolveBodyFamily(ctx.theme) : void 0);
   const weighted = applyFontWeightAlias({
     fontFamily: effectiveFamily,
     bold: font.bold,
@@ -9591,7 +9674,7 @@ function runFormatting3(font, props, ctx) {
     fontWeight: font.fontWeight
   });
   const formatting = {};
-  if (font.family || weighted.font && weighted.font !== effectiveFamily) {
+  if (font.family || hasWeightRequest && roleFamily || weighted.font && weighted.font !== effectiveFamily) {
     formatting.fontFamily = weighted.font;
   }
   if (font.size) formatting.sizeHalfPoints = pointsToHalfPoints(font.size);
@@ -9603,6 +9686,8 @@ function runFormatting3(font, props, ctx) {
     formatting.underline = font.underline ? { type: "single" } : void 0;
   }
   if (font.scale) formatting.scalePercent = font.scale;
+  if (font.case !== void 0)
+    Object.assign(formatting, capsFormatting2(font.case));
   if (font.characterSpacing) {
     const { type, value } = font.characterSpacing;
     formatting.characterSpacingTwentieths = type === "condensed" ? -value : value;
@@ -9616,7 +9701,7 @@ function applyFontWeightAlias(opts) {
     return { bold: opts.bold, italic: opts.italic };
   }
   const weight = opts.fontWeight ?? (opts.bold === true ? 700 : void 0);
-  const synth = synthesizeFamilyName(
+  const synth = synthesizeFamilyName2(
     opts.fontFamily,
     weight,
     opts.italic === true
@@ -9955,15 +10040,13 @@ function compileChart(component, scope) {
   }
   const colors = Array.isArray(props.chartColors) ? props.chartColors.map(
     (color) => resolveColor(String(color), ctx.theme)
-  ) : DEFAULT_CHART_THEME_COLORS2.map((token) => {
-    const value = ctx.theme?.colors?.[token];
-    if (typeof value !== "string" || value.length === 0) return void 0;
+  ) : chartPaletteValues(ctx.theme).flatMap((value) => {
     try {
-      return resolveColor(token, ctx.theme);
+      return [resolveColor(value, ctx.theme)];
     } catch {
-      return void 0;
+      return [];
     }
-  }).filter((color) => color !== void 0);
+  });
   const page = getPageSetup(ctx.theme);
   const contentWidthInches = (page.size.width - page.margin.left - page.margin.right) / 1440;
   const widthInches = typeof props.width === "number" ? props.width : contentWidthInches;
@@ -11298,7 +11381,17 @@ function createRenderContext(document, theme, themeName) {
 }
 
 // src/quality/facts.ts
+import {
+  chartEncodingFor,
+  collectColorLiterals,
+  collectFontFamilies,
+  collectPlaceholders,
+  hasUnitMarker,
+  normalizeHex,
+  normalizeHighchartsChart
+} from "@json-to-office/quality";
 import { DEFAULT_DOCX_RENDERER_ID as DEFAULT_DOCX_RENDERER_ID2 } from "@json-to-office/shared-docx";
+import { designColors as designColors2, resolveDesignColor as resolveDesignColor2 } from "@json-to-office/shared";
 
 // src/core/generationContext.ts
 import { applyExportMode } from "@json-to-office/shared";
@@ -11322,6 +11415,7 @@ function resolveBuiltInTheme(themeName, options = {}) {
 }
 
 // src/themes/overrides.ts
+import { mergeWithDefaults as mergeWithDefaults3 } from "@json-to-office/shared";
 function applyThemeOverrides(theme, overrides) {
   if (!overrides) return theme;
   const fonts = { ...theme.fonts };
@@ -11335,12 +11429,87 @@ function applyThemeOverrides(theme, overrides) {
   }
   return {
     ...theme,
+    ...Object.fromEntries(
+      ["palette", "typography", "spacing", "chrome", "motif"].flatMap(
+        (name) => {
+          const key = name;
+          return overrides[key] === void 0 ? [] : [[key, mergeWithDefaults3(overrides[key], theme[key] ?? {})]];
+        }
+      )
+    ),
     colors: { ...theme.colors, ...overrides.colors ?? {} },
     fonts,
     ...Object.keys(styles).length > 0 && { styles }
   };
 }
 
+// src/themes/design-system.ts
+init_defaults();
+import {
+  designCanvas,
+  resolveTypeRoles,
+  validateDesignColors
+} from "@json-to-office/shared";
+function resolveDocxDesignSystem(theme) {
+  validateDesignColors(theme, getThemeColors(theme));
+  if (!theme.typography && !theme.spacing) return theme;
+  const canvas = designCanvas("docx", theme.page.size);
+  const roles = resolveTypeRoles(theme, canvas, theme.fonts.body.size ?? 11);
+  const styles = { ...theme.styles };
+  for (const [name, role] of Object.entries(roles)) {
+    const spacing = {
+      ...role.spaceBefore !== void 0 && { before: role.spaceBefore },
+      ...role.spaceAfter !== void 0 && { after: role.spaceAfter }
+    };
+    styles[name] = {
+      font: role.face ?? "body",
+      size: role.size,
+      ...role.weight !== void 0 && { fontWeight: role.weight },
+      ...role.color !== void 0 && { color: role.color },
+      ...role.case !== void 0 && { case: role.case },
+      ...role.lineHeight !== void 0 && {
+        lineSpacing: { type: "multiple", value: role.lineHeight }
+      },
+      ...role.tracking !== void 0 && {
+        characterSpacing: {
+          type: role.tracking < 0 ? "condensed" : "expanded",
+          value: Math.abs(role.tracking) * role.size / 5
+        }
+      },
+      ...Object.keys(spacing).length && { spacing },
+      ...styles[name]
+    };
+  }
+  const gap = theme.spacing?.blockGap?.normal ?? theme.spacing?.basePt;
+  const scale = theme.typography?.scale?.[canvas];
+  if (scale || gap !== void 0) {
+    styles.normal = {
+      ...scale && { size: scale.base },
+      ...gap !== void 0 && { spacing: { after: gap } },
+      ...styles.normal
+    };
+  }
+  const space = theme.spacing?.canvas?.[canvas];
+  const safe = space?.safeAreaIn;
+  return {
+    ...theme,
+    styles,
+    page: {
+      ...theme.page,
+      margins: {
+        ...theme.page.margins,
+        ...safe !== void 0 && {
+          top: safe * 1440,
+          bottom: safe * 1440,
+          left: safe * 1440,
+          right: safe * 1440
+        },
+        ...space?.gutterIn !== void 0 && { gutter: space.gutterIn * 1440 }
+      }
+    }
+  };
+}
+
 // src/core/generationContext.ts
 function defaultNamedThemeLookup(themeName, customThemes, warnings) {
   if (customThemes) {
@@ -11373,6 +11542,7 @@ function resolveThemeContext(documentIn, options = {}) {
   if (themeOverrides) {
     theme = applyThemeOverrides(theme, themeOverrides);
   }
+  theme = resolveDocxDesignSystem(theme);
   const mode = applyExportMode({ doc: document, theme, fonts });
   for (const w of mode.warnings) {
     if (warnings) {
@@ -11539,6 +11709,164 @@ function tableFact(props, path4, availableWidthTwips) {
     explicitWidths
   };
 }
+var SERIES_COLOR_TOKENS = [
+  "primary",
+  "accent",
+  "secondary",
+  "accent4",
+  "accent5",
+  "accent6"
+];
+function chartFact(node, props, path4, paletteTokens) {
+  const base = {
+    id: `docx:chart:${path4}`,
+    kind: "docx/chart",
+    path: path4,
+    componentName: typeof node.name === "string" ? node.name : "",
+    paletteTokens
+  };
+  if (node.name === "highcharts") {
+    const shape = normalizeHighchartsChart(props.options);
+    return {
+      ...base,
+      chartType: shape.chartType,
+      encoding: shape.encoding,
+      threeD: shape.threeD,
+      seriesCount: shape.seriesCount,
+      categoryCount: shape.categoryCount,
+      seriesColorsStated: shape.seriesColorsStated,
+      seriesColorsPath: `${path4}/props/options`,
+      ...shape.valueAxisMin !== void 0 && {
+        valueAxisMin: shape.valueAxisMin
+      },
+      unitStated: shape.unitStated,
+      annotation: {
+        stated: shape.annotationStated,
+        path: path4,
+        slot: "props.options.caption.text"
+      }
+    };
+  }
+  const chartType = typeof props.type === "string" ? props.type : "";
+  if (chartType === "") return void 0;
+  const series = Array.isArray(props.data) ? props.data : [];
+  const categoryCount = Math.max(
+    0,
+    ...series.map((entry) => {
+      const record = asRecord(entry);
+      const labels = Array.isArray(record?.labels) ? record.labels.length : 0;
+      const values = Array.isArray(record?.values) ? record.values.length : 0;
+      return Math.max(labels, values);
+    })
+  );
+  const caption = typeof props.caption === "string" ? props.caption : "";
+  const title = typeof props.title === "string" ? props.title : "";
+  return {
+    ...base,
+    chartType,
+    encoding: chartEncodingFor(chartType),
+    // No 3D type exists in the DOCX chart schema — `office-open` draws none —
+    // so this is always false here, and stays a field rather than an omission
+    // so both formats answer the same questions.
+    threeD: false,
+    seriesCount: series.length,
+    categoryCount,
+    seriesColorsStated: Array.isArray(props.chartColors) && props.chartColors.length > 0,
+    seriesColorsPath: `${path4}/props/chartColors`,
+    // No `valueAxisMin`: a DOCX chart has no axis-floor property, so the
+    // baseline is always the renderer's, which starts a bar at zero.
+    unitStated: hasUnitMarker(
+      typeof props.valAxisTitle === "string" ? props.valAxisTitle : ""
+    ) || hasUnitMarker(title) || hasUnitMarker(caption),
+    annotation: {
+      stated: caption.trim() !== "",
+      path: path4,
+      slot: "props.caption"
+    }
+  };
+}
+var DOCX_ALIGNMENTS = /* @__PURE__ */ new Set(["left", "center", "right", "justify"]);
+function resolvedCellText(content) {
+  return typeof content === "string" ? content : "[component]";
+}
+function statesOwnBorders(authored) {
+  if (!authored) return false;
+  if (authored.borderSize !== void 0 || authored.borderColor !== void 0 || authored.hideBorders !== void 0) {
+    return true;
+  }
+  const layers = [
+    asRecord(authored.cellDefaults),
+    asRecord(authored.headerCellDefaults)
+  ];
+  if (layers.some(
+    (layer) => layer?.borderSize !== void 0 || layer?.borderColor !== void 0
+  )) {
+    return true;
+  }
+  const columns = Array.isArray(authored.columns) ? authored.columns : [];
+  return columns.some((column) => {
+    const record = asRecord(column);
+    const defaults = asRecord(record?.cellDefaults);
+    return defaults?.borderSize !== void 0 || defaults?.borderColor !== void 0;
+  });
+}
+function tableDesignFact(props, path4, theme, themeName, authored) {
+  const authoredColumns = Array.isArray(props.columns) ? props.columns : [];
+  if (authoredColumns.length === 0) return void 0;
+  const model = resolveTableModel(
+    props,
+    theme,
+    themeName
+  );
+  const bodyRows = model.rows;
+  const drawnRows = bodyRows.length + (model.header ? 1 : 0);
+  if (drawnRows === 0) return void 0;
+  const fullGrid = statesOwnBorders(authored) && [...model.header ? [model.header] : [], ...bodyRows].every(
+    (row) => row.cells.every(
+      (cell) => ["top", "right", "bottom", "left"].every(
+        (side) => !cell.borders[side].hidden && cell.borders[side].size > 0
+      )
+    )
+  );
+  const columns = authoredColumns.map(
+    (column, index) => {
+      const authoredColumn = asRecord(column) ?? {};
+      const cells = Array.isArray(authoredColumn.cells) ? authoredColumn.cells : [];
+      const alignments = /* @__PURE__ */ new Set();
+      const values = [];
+      bodyRows.forEach((row) => {
+        const cell = row.cells[index];
+        if (!cell || cell.missing) return;
+        values.push(resolvedCellText(cell.content));
+        alignments.add(cell.horizontalAlignment);
+      });
+      const header = model.header?.cells[index];
+      return {
+        index,
+        path: `${path4}/props/columns/${index}`,
+        ...header?.content !== void 0 && {
+          header: resolvedCellText(header.content)
+        },
+        values,
+        alignment: alignments.size === 1 ? [...alignments][0] : alignments.size === 0 ? "left" : "mixed",
+        hasCellDefaults: asRecord(authoredColumn.cellDefaults) !== void 0,
+        hasHeader: asRecord(authoredColumn.header) !== void 0,
+        cellsWithOwnAlignment: cells.flatMap((cell, cellIndex) => {
+          const alignment2 = asRecord(cell)?.horizontalAlignment;
+          return typeof alignment2 === "string" && DOCX_ALIGNMENTS.has(alignment2) && alignment2 !== "right" ? [cellIndex] : [];
+        })
+      };
+    }
+  );
+  return {
+    id: `docx:table-design:${path4}`,
+    kind: "docx/table",
+    path: path4,
+    columns,
+    rowCount: drawnRows,
+    fullGrid
+  };
+}
 var TWIPS_PER_POINT3 = 20;
 var SINGLE_LINE_RATIO = 1.2;
 function finiteNumber(value) {
@@ -11567,20 +11895,23 @@ function characterSpacingPt(spacing) {
   if (rule === void 0 || value === void 0) return 0;
   return rule.type === "condensed" ? -value / TWIPS_PER_POINT3 : value / TWIPS_PER_POINT3;
 }
-function pointerExists(root, pointer) {
+function nodeAtPointer(root, pointer) {
   let current = root;
   for (const token of pointer.split("/").slice(1)) {
     if (Array.isArray(current)) {
       const index = Number(token);
-      if (!Number.isInteger(index)) return false;
+      if (!Number.isInteger(index)) return void 0;
       current = current[index];
       continue;
     }
     const record = asRecord(current);
-    if (!record) return false;
+    if (!record) return void 0;
     current = record[token];
   }
-  return current !== void 0;
+  return current;
+}
+function pointerExists(root, pointer) {
+  return nodeAtPointer(root, pointer) !== void 0;
 }
 function styleKey(node, props) {
   if (node.name === "heading") {
@@ -11761,6 +12092,78 @@ function prepareDocxQualityDocument(document, options = {}) {
       ...fact.relatedPaths && { relatedPaths: fact.relatedPaths }
     };
   };
+  const paletteHexes = {};
+  const visualColors = designColors2(
+    resolved.theme.colors,
+    resolved.theme.palette
+  );
+  const entries = {
+    ...visualColors,
+    ...Object.fromEntries(
+      (resolved.theme.palette?.chart ?? []).map((value) => {
+        const hex = resolveDesignColor2(value, visualColors);
+        return [hex ? `#${hex}` : value, value];
+      })
+    )
+  };
+  for (const [token, value] of Object.entries(entries)) {
+    if (typeof value !== "string") continue;
+    const hex = normalizeHex(resolveDesignColor2(value, visualColors) ?? value);
+    if (hex) paletteHexes[token] = hex;
+  }
+  const paletteTokens = resolved.theme.palette?.chart?.map(
+    (value) => `#${resolveDesignColor2(value, visualColors)}`
+  ) ?? SERIES_COLOR_TOKENS.filter((token) => paletteHexes[token] !== void 0);
+  const authoredPropsAt = (pointer) => asRecord(asRecord(nodeAtPointer(context.document, pointer))?.props);
+  addFact({
+    id: "docx:theme",
+    kind: "docx/theme",
+    path: "/props",
+    themeName: context.themeName,
+    paletteHexes,
+    // `heading` and `body` only. A theme also names `mono` and `light`, but
+    // those paint nothing until a component asks for them — counting an
+    // unused `Courier New` against a document's family budget would flag a
+    // report that only ever uses one typeface.
+    fontFamilies: [
+      ...new Set(
+        ["heading", "body"].flatMap((role) => {
+          const family = asRecord(
+            resolved.theme.fonts?.[role]
+          )?.family;
+          return typeof family === "string" && family.trim() !== "" ? [family] : [];
+        })
+      )
+    ]
+  });
+  collectColorLiterals(document).forEach((literal, index) => {
+    addFact({
+      id: `docx:color:${index}:${literal.path}`,
+      kind: "docx/color",
+      path: literal.path,
+      raw: literal.raw,
+      hex: literal.hex
+    });
+  });
+  collectFontFamilies(document).forEach((use, index) => {
+    addFact({
+      id: `docx:font:${index}:${use.path}`,
+      kind: "docx/font-family",
+      path: use.path,
+      family: use.family
+    });
+  });
+  collectPlaceholders(document).forEach((occurrence, index) => {
+    addFact({
+      id: `docx:placeholder:${index}:${occurrence.path}`,
+      kind: "docx/placeholder",
+      path: occurrence.path,
+      text: occurrence.text,
+      placeholderKind: occurrence.match.kind,
+      pattern: occurrence.match.pattern,
+      excerpt: occurrence.match.excerpt
+    });
+  });
   let previousVisitPath;
   let lastFrame;
   let flowIndex = 0;
@@ -11770,6 +12173,18 @@ function prepareDocxQualityDocument(document, options = {}) {
     if (node.name === "table") {
       const fact = tableFact(props, path4, page.availableWidthTwips);
       if (fact) addFact(fact);
+      const design = tableDesignFact(
+        props,
+        path4,
+        resolved.theme,
+        context.themeName,
+        authoredPropsAt(path4)
+      );
+      if (design) addFact(design);
+    }
+    if (node.name === "chart" || node.name === "highcharts") {
+      const fact = chartFact(node, props, path4, paletteTokens);
+      if (fact) addFact(fact);
     }
     if (node.name === "paragraph" || node.name === "text-box") {
       const floating = asRecord(props.floating);
@@ -12193,9 +12608,17 @@ import {
 
 // src/quality/rules.ts
 import {
+  chartInfoDesignFindings,
+  DEFAULT_MAXIMUM_CHART_SERIES,
+  DEFAULT_MAXIMUM_PIE_SLICES,
+  fontCountFinding,
   mergeQualityProfiles,
+  nearestPaletteToken,
+  offPaletteFinding,
+  placeholderFinding,
   QUALITY_CODES,
-  QualityEngine
+  QualityEngine,
+  tableInfoDesignFindings
 } from "@json-to-office/quality";
 
 // src/quality/text-metrics.ts
@@ -12661,6 +13084,179 @@ var docxLineBoxRule = {
     });
   }
 };
+var docxPlaceholderRule = {
+  id: "docx/placeholder-text",
+  code: QUALITY_CODES.PLACEHOLDER_TEXT,
+  category: "integrity",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  evaluate: ({ facts }) => facts.filter(
+    (fact) => fact.kind === "docx/placeholder"
+  ).map(
+    (fact) => placeholderFinding({
+      path: fact.path,
+      kind: fact.placeholderKind,
+      pattern: fact.pattern,
+      excerpt: fact.excerpt
+    })
+  )
+};
+var DEFAULT_MAX_FONT_FAMILIES = 3;
+var docxFontCountRule = {
+  id: "docx/font-count",
+  code: QUALITY_CODES.FONT_COUNT,
+  category: "brand",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultParameters: { maximumFamilies: DEFAULT_MAX_FONT_FAMILIES },
+  evaluate: ({ facts, configuration }) => {
+    const maximum = numberParameter(
+      configuration.parameters,
+      "maximumFamilies",
+      DEFAULT_MAX_FONT_FAMILIES
+    );
+    const theme = facts.find(
+      (fact) => fact.kind === "docx/theme"
+    );
+    const families = new Set(theme?.fontFamilies ?? []);
+    const extraPaths = [];
+    for (const fact of facts) {
+      if (fact.kind !== "docx/font-family") continue;
+      const use = fact;
+      if (!families.has(use.family)) extraPaths.push(use.path);
+      families.add(use.family);
+    }
+    if (families.size <= maximum) return [];
+    return [
+      fontCountFinding({
+        path: theme?.path ?? "/props",
+        families: [...families].sort(),
+        maximum,
+        relatedPaths: [...new Set(extraPaths)]
+      })
+    ];
+  }
+};
+var docxPaletteRule = {
+  id: "docx/palette-adherence",
+  code: QUALITY_CODES.OFF_PALETTE,
+  category: "brand",
+  defaultSeverity: "info",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  evaluate: ({ facts }) => {
+    const theme = facts.find(
+      (fact) => fact.kind === "docx/theme"
+    );
+    const palette = theme?.paletteHexes ?? {};
+    const known = new Set(Object.values(palette));
+    return facts.filter((fact) => fact.kind === "docx/color").filter((fact) => !known.has(fact.hex)).map((fact) => {
+      const nearest = nearestPaletteToken(fact.hex, palette);
+      return offPaletteFinding({
+        path: fact.path,
+        raw: fact.raw,
+        hex: fact.hex,
+        ...nearest && { nearest }
+      });
+    });
+  }
+};
+var DEFAULT_MAX_TABLE_ROWS_PER_PAGE = 25;
+var docxChartRule = {
+  id: "docx/chart-design",
+  code: QUALITY_CODES.CHART_OVERLOADED,
+  category: "information-design",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultParameters: {
+    maximumSeries: DEFAULT_MAXIMUM_CHART_SERIES,
+    maximumSlices: DEFAULT_MAXIMUM_PIE_SLICES
+  },
+  evaluate: ({ facts, configuration }) => {
+    const maximumSeries = numberParameter(
+      configuration.parameters,
+      "maximumSeries",
+      DEFAULT_MAXIMUM_CHART_SERIES
+    );
+    const maximumSlices = numberParameter(
+      configuration.parameters,
+      "maximumSlices",
+      DEFAULT_MAXIMUM_PIE_SLICES
+    );
+    return facts.filter((fact) => fact.kind === "docx/chart").flatMap((fact) => {
+      const fix = seriesColorFix(fact);
+      return chartInfoDesignFindings(fact, {
+        maximumSeries,
+        maximumSlices,
+        ...fix && { seriesColorFix: fix }
+      });
+    });
+  }
+};
+function seriesColorFix(fact) {
+  if (fact.componentName !== "chart") return void 0;
+  if (fact.seriesCount < 1 || fact.paletteTokens.length === 0) return void 0;
+  const tokens = Array.from(
+    { length: fact.seriesCount },
+    (_, index) => fact.paletteTokens[index % fact.paletteTokens.length]
+  );
+  return [{ op: "add", path: fact.seriesColorsPath, value: tokens }];
+}
+var docxTableDesignRule = {
+  id: "docx/table-design",
+  code: QUALITY_CODES.TABLE_NUMERIC_ALIGN,
+  category: "information-design",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultParameters: { maximumRows: DEFAULT_MAX_TABLE_ROWS_PER_PAGE },
+  evaluate: ({ facts, configuration }) => {
+    const maximumRows = numberParameter(
+      configuration.parameters,
+      "maximumRows",
+      DEFAULT_MAX_TABLE_ROWS_PER_PAGE
+    );
+    return facts.filter((fact) => fact.kind === "docx/table").flatMap(
+      (fact) => tableInfoDesignFindings(fact, {
+        maximumRows,
+        rowSurface: "page",
+        rowSeverity: "info",
+        alignFix: alignColumnRight
+      })
+    );
+  }
+};
+function alignColumnRight(column) {
+  const operations = [
+    column.hasCellDefaults ? {
+      op: "add",
+      path: `${column.path}/cellDefaults/horizontalAlignment`,
+      value: "right"
+    } : {
+      op: "add",
+      path: `${column.path}/cellDefaults`,
+      value: { horizontalAlignment: "right" }
+    }
+  ];
+  if (column.hasHeader) {
+    operations.push({
+      op: "add",
+      path: `${column.path}/header/horizontalAlignment`,
+      value: "right"
+    });
+  }
+  for (const index of column.cellsWithOwnAlignment) {
+    operations.push({
+      op: "add",
+      path: `${column.path}/cells/${index}/horizontalAlignment`,
+      value: "right"
+    });
+  }
+  return operations;
+}
 var DOCX_QUALITY_RULES = {
   id: "docx/default",
   rules: [
@@ -12669,7 +13265,12 @@ var DOCX_QUALITY_RULES = {
     docxTextFitRule,
     docxFrameCollisionRule,
     docxSvgTextBoundsRule,
-    docxLineBoxRule
+    docxLineBoxRule,
+    docxPlaceholderRule,
+    docxChartRule,
+    docxTableDesignRule,
+    docxFontCountRule,
+    docxPaletteRule
   ]
 };
 var DOCX_QUALITY_PROFILES = {