@json-to-office/core-docx 0.18.0 → 0.20.0

package/dist/plugin/example/index.js

@@ -2195,12 +2195,17 @@ function resolveComponentTree(components, theme) {
 async function processDocument(document, theme, themeName) {
   const metadata = createDocumentMetadata(document.props);
   const docDefaults = document.props.componentDefaults;
-  const effectiveTheme = docDefaults ? {
+  const mergedComponentDefaults = docDefaults ? mergeWithDefaults2(docDefaults, theme.componentDefaults || {}) : void 0;
+  const docNoProofWords = document.props.noProofWords;
+  const mergedNoProofWords = docNoProofWords || theme.noProofWords ? Array.from(
+    /* @__PURE__ */ new Set([...theme.noProofWords || [], ...docNoProofWords || []])
+  ) : void 0;
+  const effectiveTheme = mergedComponentDefaults || mergedNoProofWords ? {
     ...theme,
-    componentDefaults: mergeWithDefaults2(
-      docDefaults,
-      theme.componentDefaults || {}
-    )
+    ...mergedComponentDefaults && {
+      componentDefaults: mergedComponentDefaults
+    },
+    ...mergedNoProofWords && { noProofWords: mergedNoProofWords }
   } : theme;
   const context = createRenderContext(
     {
@@ -2222,7 +2227,8 @@ async function processDocument(document, theme, themeName) {
     sections,
     theme: effectiveTheme,
     themeName,
-    trackRevisions: document.props.trackRevisions
+    trackRevisions: document.props.trackRevisions,
+    language: document.props.language
   };
 }
 function createDocumentMetadata(props) {
@@ -3086,7 +3092,7 @@ function convertBorders(borders, theme) {
     ...right && { right }
   } : void 0;
 }
-function createWordStyles(themeNameOrObject = "minimal") {
+function createWordStyles(themeNameOrObject = "minimal", language) {
   const theme = typeof themeNameOrObject === "string" ? getTheme(themeNameOrObject) || getTheme("minimal") : themeNameOrObject;
   const paragraphStyles = [
     // Normal body text style
@@ -3544,8 +3550,20 @@ function createWordStyles(themeNameOrObject = "minimal") {
     });
   }
   return {
-    paragraphStyles
+    paragraphStyles,
     // Cast needed due to docx typing
+    // Document-default proofing language (w:docDefaults/w:rPrDefault). Runs that
+    // don't set their own w:lang inherit this, so Word spell-checks the whole
+    // document in the requested language unless a component overrides it.
+    ...language && {
+      default: {
+        document: {
+          run: {
+            language: { value: language }
+          }
+        }
+      }
+    }
   };
 }
 function getStyleIdForLevel(level) {
@@ -3667,6 +3685,37 @@ import {
 
 // src/utils/textParser.ts
 import { TextRun, ExternalHyperlink, InternalHyperlink } from "docx";
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildNoProofWordsRegex(noProofWords) {
+  const words = (noProofWords || []).filter((w) => w && w.trim().length > 0);
+  if (words.length === 0) return null;
+  const escaped = words.slice().sort((a, b) => b.length - a.length).map(escapeRegExp);
+  return new RegExp(
+    `(?<![\\p{L}\\p{N}])(?:${escaped.join("|")})(?![\\p{L}\\p{N}])`,
+    "giu"
+  );
+}
+function splitByNoProofWords(text, makeRun, noProofWords) {
+  const regex = buildNoProofWordsRegex(noProofWords);
+  if (!regex || !text) return [makeRun(text, false)];
+  const runs = [];
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      runs.push(makeRun(text.slice(lastIndex, match.index), false));
+    }
+    runs.push(makeRun(match[0], true));
+    lastIndex = match.index + match[0].length;
+    if (regex.lastIndex === match.index) regex.lastIndex++;
+  }
+  if (lastIndex < text.length) {
+    runs.push(makeRun(text.slice(lastIndex), false));
+  }
+  return runs.length > 0 ? runs : [makeRun(text, false)];
+}
 function parseTextWithDecorators(text, baseStyle = {}, options = {}) {
   if (!text) {
     return [new TextRun({ text: "", ...baseStyle })];
@@ -3677,7 +3726,8 @@ function parseTextWithDecorators(text, baseStyle = {}, options = {}) {
     return processTextWithPlaceholders(
       normalizedText,
       baseStyle,
-      options.placeholderContext || {}
+      options.placeholderContext || {},
+      options.noProofWords
     );
   }
   if (options.enableHyperlinks) {
@@ -3748,20 +3798,38 @@ function createTextRunsWithNewlines(text, baseStyle, options, overrideStyle) {
         bold: overrideStyle?.bold ?? baseStyle.bold,
         italics: overrideStyle?.italics ?? baseStyle.italics
       };
-      runs.push(
-        new TextRun({
-          text: line,
-          ...baseStyle.font && { font: baseStyle.font },
-          ...baseStyle.size && { size: baseStyle.size },
-          ...baseStyle.color && {
-            color: runStyle.bold && options.boldColor ? options.boldColor : baseStyle.color
-          },
-          ...runStyle.bold !== void 0 && { bold: runStyle.bold },
-          ...runStyle.italics !== void 0 && { italics: runStyle.italics },
-          ...baseStyle.underline && { underline: baseStyle.underline },
-          ...needsLineBreak && { break: 1 }
-        })
+      const commonProps = {
+        ...baseStyle.font && { font: baseStyle.font },
+        ...baseStyle.size && { size: baseStyle.size },
+        ...baseStyle.color && {
+          color: runStyle.bold && options.boldColor ? options.boldColor : baseStyle.color
+        },
+        ...runStyle.bold !== void 0 && { bold: runStyle.bold },
+        ...runStyle.italics !== void 0 && { italics: runStyle.italics },
+        ...baseStyle.underline && { underline: baseStyle.underline },
+        ...baseStyle.language && { language: baseStyle.language }
+      };
+      const wholeRunNoProof = baseStyle.noProof === true;
+      const wordsForLine = wholeRunNoProof ? void 0 : options.noProofWords;
+      let firstSegment = true;
+      const lineRuns = splitByNoProofWords(
+        line,
+        (segment, matched) => {
+          const segNoProof = matched || wholeRunNoProof;
+          const run = new TextRun({
+            text: segment,
+            ...commonProps,
+            ...(matched || baseStyle.noProof !== void 0) && {
+              noProof: segNoProof
+            },
+            ...needsLineBreak && firstSegment && { break: 1 }
+          });
+          firstSegment = false;
+          return run;
+        },
+        wordsForLine
       );
+      runs.push(...lineRuns);
     }
   }
   return runs;
@@ -3866,7 +3934,7 @@ var PlaceholderRegistry = class {
     this.handlers.clear();
   }
 };
-function processTextWithPlaceholders(text, baseStyle = {}, context = {}) {
+function processTextWithPlaceholders(text, baseStyle = {}, context = {}, noProofWords) {
   const normalizedText = normalizeUnicodeText(text);
   const combinedRegex = /(\*\*\*|___)([\s\S]*?)\1|(\*\*|__)([\s\S]*?)\3|(\*|_)([\s\S]*?)\5|\{([^}]+)\}/g;
   const result = [];
@@ -3876,7 +3944,9 @@ function processTextWithPlaceholders(text, baseStyle = {}, context = {}) {
     if (match.index > lastIndex) {
       const beforeText = normalizedText.substring(lastIndex, match.index);
       if (beforeText) {
-        result.push(...createTextRunsWithNewlines2(beforeText, baseStyle));
+        result.push(
+          ...createTextRunsWithNewlines2(beforeText, baseStyle, noProofWords)
+        );
       }
     }
     if (match[7]) {
@@ -3890,11 +3960,17 @@ function processTextWithPlaceholders(text, baseStyle = {}, context = {}) {
           result.push(placeholderResult);
         } else if (typeof placeholderResult === "string") {
           result.push(
-            ...createTextRunsWithNewlines2(placeholderResult, baseStyle)
+            ...createTextRunsWithNewlines2(
+              placeholderResult,
+              baseStyle,
+              noProofWords
+            )
           );
         }
       } else {
-        result.push(...createTextRunsWithNewlines2(match[0], baseStyle));
+        result.push(
+          ...createTextRunsWithNewlines2(match[0], baseStyle, noProofWords)
+        );
       }
     } else {
       let decoratedText;
@@ -3929,33 +4005,54 @@ function processTextWithPlaceholders(text, baseStyle = {}, context = {}) {
   if (lastIndex < normalizedText.length) {
     const remainingText = normalizedText.substring(lastIndex);
     if (remainingText) {
-      result.push(...createTextRunsWithNewlines2(remainingText, baseStyle));
+      result.push(
+        ...createTextRunsWithNewlines2(remainingText, baseStyle, noProofWords)
+      );
     }
   }
   if (result.length === 0 && normalizedText) {
-    result.push(...createTextRunsWithNewlines2(normalizedText, baseStyle));
+    result.push(
+      ...createTextRunsWithNewlines2(normalizedText, baseStyle, noProofWords)
+    );
   }
   return result;
 }
-function createTextRunsWithNewlines2(text, baseStyle) {
+function createTextRunsWithNewlines2(text, baseStyle, noProofWords) {
   const runs = [];
   const lines = text.split("\n");
   for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
     const line = lines[lineIndex];
     const needsLineBreak = lineIndex > 0;
     if (line || needsLineBreak) {
-      runs.push(
-        new TextRun2({
-          text: line,
-          font: baseStyle.font,
-          size: baseStyle.size,
-          color: baseStyle.color,
-          bold: baseStyle.bold,
-          italics: baseStyle.italics,
-          underline: baseStyle.underline,
-          break: needsLineBreak ? 1 : void 0
-        })
+      const commonProps = {
+        font: baseStyle.font,
+        size: baseStyle.size,
+        color: baseStyle.color,
+        bold: baseStyle.bold,
+        italics: baseStyle.italics,
+        underline: baseStyle.underline,
+        ...baseStyle.language && { language: baseStyle.language }
+      };
+      const wholeRunNoProof = baseStyle.noProof === true;
+      const wordsForLine = wholeRunNoProof ? void 0 : noProofWords;
+      let firstSegment = true;
+      const lineRuns = splitByNoProofWords(
+        line,
+        (segment, matched) => {
+          const run = new TextRun2({
+            text: segment,
+            ...commonProps,
+            ...(matched || baseStyle.noProof !== void 0) && {
+              noProof: matched || wholeRunNoProof
+            },
+            break: needsLineBreak && firstSegment ? 1 : void 0
+          });
+          firstSegment = false;
+          return run;
+        },
+        wordsForLine
       );
+      runs.push(...lineRuns);
     }
   }
   return runs;
@@ -4300,6 +4397,11 @@ function applyFontWeightAlias(opts) {
   );
   return { font: synth.family, bold: synth.bold, italics: synth.italic };
 }
+function resolveNoProofWords(theme, optionWords) {
+  const themeWords = theme.noProofWords;
+  const merged = [...themeWords || [], ...optionWords || []];
+  return merged.length > 0 ? Array.from(new Set(merged)) : void 0;
+}
 function createText(content, theme, themeName, options = {}) {
   const normalizedContent = normalizeUnicodeText(content);
   const style = options.style || "Normal";
@@ -4342,7 +4444,11 @@ function createText(content, theme, themeName, options = {}) {
     ...weighted.italics !== void 0 && { italics: weighted.italics },
     ...options.underline !== void 0 && {
       underline: options.underline ? { type: "single" } : void 0
-    }
+    },
+    // Proofing: per-run language and/or no-proof. Omitting language lets the
+    // run inherit the document default set on docDefaults.
+    ...options.language && { language: { value: options.language } },
+    ...options.noProof !== void 0 && { noProof: options.noProof }
   };
   if (options.revision) {
     const revisionRuns = createRevisionRuns(options.revision, baseTextStyle);
@@ -4364,7 +4470,8 @@ function createText(content, theme, themeName, options = {}) {
   } else {
     const textRuns = parseTextWithDecorators(normalizedContent, baseTextStyle, {
       boldColor: options.boldColor,
-      enableHyperlinks: true
+      enableHyperlinks: true,
+      noProofWords: resolveNoProofWords(theme, options.noProofWords)
     });
     if (options.bookmarkId) {
       globalBookmarkRegistry.register(
@@ -4499,8 +4606,21 @@ function createHeading(text, level, theme, _themeName, options = {}) {
     },
     ...options.underline !== void 0 && {
       underline: options.underline ? { type: "single" } : void 0
-    }
+    },
+    // Proofing: per-run language and/or no-proof (see createText).
+    ...options.language && { language: { value: options.language } },
+    ...options.noProof !== void 0 && { noProof: options.noProof }
   };
+  const headingNoProofWords = resolveNoProofWords(theme, options.noProofWords);
+  const makeHeadingRuns = (value) => splitByNoProofWords(
+    value,
+    (segment, matched) => new TextRun4({
+      text: segment,
+      ...baseTextStyle,
+      ...matched && { noProof: true }
+    }),
+    headingNoProofWords
+  );
   if (options.revision) {
     const revisionRuns = createRevisionRuns(options.revision, baseTextStyle);
     if (options.bookmarkId) {
@@ -4528,13 +4648,12 @@ function createHeading(text, level, theme, _themeName, options = {}) {
     if (hasDecorators) {
       const textRuns = parseTextWithDecorators(normalizedText, baseTextStyle, {
         boldColor: options.boldColor,
-        enableHyperlinks: true
+        enableHyperlinks: true,
+        noProofWords: headingNoProofWords
       });
       headingTextChildren.push(...textRuns);
     } else {
-      headingTextChildren.push(
-        new TextRun4({ text: normalizedText, ...baseTextStyle })
-      );
+      headingTextChildren.push(...makeHeadingRuns(normalizedText));
     }
     children.push(
       new Bookmark({
@@ -4546,11 +4665,12 @@ function createHeading(text, level, theme, _themeName, options = {}) {
     if (hasDecorators) {
       const textRuns = parseTextWithDecorators(normalizedText, baseTextStyle, {
         boldColor: options.boldColor,
-        enableHyperlinks: true
+        enableHyperlinks: true,
+        noProofWords: headingNoProofWords
       });
       children.push(...textRuns);
     } else {
-      children.push(new TextRun4({ text: normalizedText, ...baseTextStyle }));
+      children.push(...makeHeadingRuns(normalizedText));
     }
   }
   return new Paragraph({
@@ -5513,6 +5633,10 @@ function renderHeadingComponent(component, theme, themeName) {
       fontWeight: config.font?.fontWeight,
       italic: config.font?.italic,
       underline: config.font?.underline,
+      // Proofing: local language override + no-proof toggle + known-words list
+      language: config.language,
+      noProof: config.noProof,
+      noProofWords: config.noProofWords,
       // Pagination control
       keepNext: config.keepNext,
       keepLines: config.keepLines,
@@ -5631,6 +5755,10 @@ function renderParagraphComponent(component, theme, themeName) {
     fontWeight: resolvedConfig.font?.fontWeight,
     italic: resolvedConfig.font?.italic,
     underline: resolvedConfig.font?.underline,
+    // Proofing: local language override + no-proof toggle + known-words list
+    language: resolvedConfig.language,
+    noProof: resolvedConfig.noProof,
+    noProofWords: resolvedConfig.noProofWords,
     // Pass outline level for TOC support
     outlineLevel,
     // Pass floating positioning properties
@@ -6491,9 +6619,23 @@ Cause: ${cause}`
     height
   };
 }
+function withThemeColors(config, theme) {
+  const options = config.options;
+  if (!options || options.colors || !theme?.colors) return config;
+  const palette = [
+    theme.colors.primary,
+    theme.colors.secondary,
+    theme.colors.accent
+  ].filter((c) => typeof c === "string" && c.length > 0).map((c) => c.startsWith("#") ? c : `#${c}`);
+  if (palette.length === 0) return config;
+  return {
+    ...config,
+    options: { ...config.options, colors: palette }
+  };
+}
 async function renderHighchartsComponent(component, theme, themeName, context) {
   if (!isHighchartsComponent(component)) return [];
-  const config = component.props;
+  const config = withThemeColors(component.props, theme);
   const chartResult = await generateChart(
     config,
     context?.services?.highcharts
@@ -6757,7 +6899,7 @@ async function renderDocument(structure, layout, options) {
   }
   const numberingConfigs = globalNumberingRegistry2.getAll();
   return new Document({
-    styles: createWordStyles(structure.theme),
+    styles: createWordStyles(structure.theme, structure.language),
     sections,
     features: {
       updateFields: true,