docx-wasm 0.4.18-rc2 → 0.4.18-rc21

package/js/index.ts

@@ -2,7 +2,7 @@ import { Paragraph } from "./paragraph";
 import { LineSpacing, ParagraphProperty } from "./paragraph-property";
 import { Table } from "./table";
 import { TableOfContents } from "./table-of-contents";
-import { RunFonts } from "./run";
+import { RunFonts } from "./run-property";
 import { AbstractNumbering } from "./abstract-numbering";
 import { Numbering } from "./numbering";
 import { BookmarkStart } from "./bookmark-start";
@@ -21,7 +21,7 @@ import {
   PageMargin,
   PageOrientationType,
 } from "./section-property";
-import { DocGridType, DocxJSON } from "./json";
+import { CommentJSON, DocGridType, DocxJSON } from "./json";
 
 import * as wasm from "./pkg";
 import { Level } from "./level";
@@ -290,31 +290,31 @@ export class Docx {
       level = level.suffix(wasm.LevelSuffixType.Tab);
     }
 
-    if (l.runProperty.bold) {
+    if (l.runProperty._bold) {
       level = level.bold();
     }
 
-    if (l.runProperty.italic) {
+    if (l.runProperty._italic) {
       level = level.italic();
     }
 
-    if (l.runProperty.size) {
-      level = level.size(l.runProperty.size);
+    if (l.runProperty._size) {
+      level = level.size(l.runProperty._size);
     }
 
-    if (l.runProperty.fonts) {
+    if (l.runProperty._fonts) {
       let f = wasm.createRunFonts();
-      if (l.runProperty.fonts._ascii) {
-        f = f.ascii(l.runProperty.fonts._ascii);
+      if (l.runProperty._fonts._ascii) {
+        f = f.ascii(l.runProperty._fonts._ascii);
       }
-      if (l.runProperty.fonts._hiAnsi) {
-        f = f.hi_ansi(l.runProperty.fonts._hiAnsi);
+      if (l.runProperty._fonts._hiAnsi) {
+        f = f.hi_ansi(l.runProperty._fonts._hiAnsi);
       }
-      if (l.runProperty.fonts._cs) {
-        f = f.cs(l.runProperty.fonts._cs);
+      if (l.runProperty._fonts._cs) {
+        f = f.cs(l.runProperty._fonts._cs);
       }
-      if (l.runProperty.fonts._eastAsia) {
-        f = f.east_asia(l.runProperty.fonts._eastAsia);
+      if (l.runProperty._fonts._eastAsia) {
+        f = f.east_asia(l.runProperty._fonts._eastAsia);
       }
       level = level.fonts(f);
     }
@@ -548,20 +548,20 @@ export class Docx {
 
     if (this.styles?.docDefaults) {
       if (this.styles.docDefaults.runProperty) {
-        if (this.styles.docDefaults.runProperty.fonts) {
+        if (this.styles.docDefaults.runProperty._fonts) {
           const fonts = this.buildRunFonts(
-            this.styles.docDefaults.runProperty.fonts
+            this.styles.docDefaults.runProperty._fonts
           );
           docx = docx.default_fonts(fonts);
         }
 
-        if (this.styles.docDefaults.runProperty.size) {
-          docx = docx.default_size(this.styles.docDefaults.runProperty.size);
+        if (this.styles.docDefaults.runProperty._size) {
+          docx = docx.default_size(this.styles.docDefaults.runProperty._size);
         }
 
-        if (this.styles.docDefaults.runProperty.characterSpacing) {
+        if (this.styles.docDefaults.runProperty._characterSpacing) {
           docx = docx.default_spacing(
-            this.styles.docDefaults.runProperty.characterSpacing
+            this.styles.docDefaults.runProperty._characterSpacing
           );
         }
       }
@@ -626,6 +626,13 @@ export class Docx {
     return JSON.parse(json) as DocxJSON;
   }
 
+  commentsJson() {
+    const docx = this.createDocx();
+    const json = docx.comments_json();
+    docx.free();
+    return JSON.parse(json) as { comments: CommentJSON[] };
+  }
+
   build() {
     const docx = this.createDocx();
     const buf = docx.build(this.hasNumberings);
@@ -651,6 +658,7 @@ export * from "./table-of-contents";
 export * from "./table-of-contents-item";
 export * from "./table-row";
 export * from "./run";
+export * from "./run-property";
 export * from "./text";
 export * from "./style";
 export * from "./styles";
@@ -672,3 +680,4 @@ export * from "./page-num";
 export * from "./num-pages";
 export * from "./footer";
 export * from "./image";
+export * from "./positional-tab";

package/js/json/bindings/PositionalTab.ts

@@ -0,0 +1,5 @@
+import type { PositionalTabAlignmentType } from "./PositionalTabAlignmentType";
+import type { PositionalTabRelativeTo } from "./PositionalTabRelativeTo";
+import type { TabLeaderType } from "./TabLeaderType";
+
+export interface PositionalTab { alignment: PositionalTabAlignmentType, relativeTo: PositionalTabRelativeTo, leader: TabLeaderType, }

package/js/json/bindings/PositionalTabAlignmentType.ts

@@ -0,0 +1,2 @@
+
+export type PositionalTabAlignmentType = "center" | "left" | "right";

package/js/json/bindings/PositionalTabRelativeTo.ts

@@ -0,0 +1,2 @@
+
+export type PositionalTabRelativeTo = "indent" | "margin";

package/js/json/paragraph.ts

@@ -65,6 +65,7 @@ export type ParagraphPropertyJSON = {
   divId?: string | null;
   keepNext?: boolean;
   keepLines?: boolean;
+  snapToGrid?: boolean;
   pageBreakBefore?: boolean;
   widowControl?: boolean;
   outlineLvl?: number | null;

package/js/json/run.ts

@@ -7,10 +7,13 @@ import {
   DeleteJSONData,
 } from "..";
 import { BorderType } from "../border";
-import { VertAlignType } from "../run";
+import { VertAlignType } from "../run-property";
 import { FieldChar } from "./bindings/FieldChar";
 import { InstrHyperlink } from "./bindings/InstrHyperlink";
 import { InstrToC } from "./bindings/InstrToC";
+import { PositionalTabAlignmentType } from "./bindings/PositionalTabAlignmentType";
+import { PositionalTabRelativeTo } from "./bindings/PositionalTabRelativeTo";
+import { TabLeaderType } from "./bindings/TabLeaderType";
 
 export type TextBorderJSON = {
   borderType: BorderType;
@@ -61,6 +64,7 @@ export type RunChildJSON =
   | TabJSON
   | BreakJSON
   | DrawingJSON
+  | PtabJSON
   | ShapeJSON
   | CommentRangeStartJSON
   | CommentRangeEndJSON
@@ -75,6 +79,15 @@ export type TextJSON = {
   };
 };
 
+export type PtabJSON = {
+  type: "ptab";
+  data: {
+    alignment: PositionalTabAlignmentType;
+    relativeTo: PositionalTabRelativeTo;
+    leader: TabLeaderType;
+  };
+};
+
 export type SymJSON = {
   type: "sym";
   data: {

package/js/level.ts

@@ -4,7 +4,11 @@ import {
   ParagraphProperty,
   SpecialIndentKind,
 } from "./paragraph-property";
-import { RunFonts, RunProperty } from "./run";
+import {
+  createDefaultRunProperty,
+  RunFonts,
+  RunProperty,
+} from "./run-property";
 
 export type LevelSuffixType = "nothing" | "tab" | "space";
 
@@ -15,7 +19,7 @@ export class Level {
   text: string;
   jc: string;
   paragraphProperty: ParagraphProperty = createDefaultParagraphProperty();
-  runProperty: RunProperty = {};
+  runProperty: RunProperty = createDefaultRunProperty();
   levelSuffix: LevelSuffixType;
 
   constructor(
@@ -52,47 +56,47 @@ export class Level {
   }
 
   size(size: number) {
-    this.runProperty = { ...this.runProperty, size };
+    this.runProperty.size(size);
     return this;
   }
 
   color(color: string) {
-    this.runProperty = { ...this.runProperty, color };
+    this.runProperty.color(color);
     return this;
   }
 
   highlight(color: string) {
-    this.runProperty = { ...this.runProperty, highlight: color };
+    this.runProperty.highlight(color);
     return this;
   }
 
   bold() {
-    this.runProperty = { ...this.runProperty, bold: true };
+    this.runProperty.bold();
     return this;
   }
 
   italic() {
-    this.runProperty = { ...this.runProperty, italic: true };
+    this.runProperty.italic();
     return this;
   }
 
   underline(type: string) {
-    this.runProperty = { ...this.runProperty, underline: type };
+    this.runProperty.underline(type);
     return this;
   }
 
   vanish() {
-    this.runProperty = { ...this.runProperty, vanish: true };
+    this.runProperty.vanish();
     return this;
   }
 
   fonts(fonts: RunFonts) {
-    this.runProperty = { ...this.runProperty, fonts };
+    this.runProperty.fonts(fonts);
     return this;
   }
 
   characterSpacing(characterSpacing: number) {
-    this.runProperty = { ...this.runProperty, characterSpacing };
+    this.runProperty.spacing(characterSpacing);
     return this;
   }
 }

package/js/paragraph-property.ts

@@ -1,9 +1,11 @@
-import { RunProperty, createDefaultRunProperty } from "./run";
+import { RunProperty, createDefaultRunProperty } from "./run-property";
 
 import * as wasm from "./pkg";
 import { TextAlignmentType } from "./json/bindings/TextAlignmentType";
 import { Tab } from "./json/bindings/Tab";
 import { AlignmentType } from "./json/bindings/AlignmentType";
+import { TabValueType } from "./json/bindings/TabValueType";
+import { TabLeaderType } from "./json/bindings/TabLeaderType";
 
 export { AlignmentType } from "./json/bindings/AlignmentType";
 
@@ -60,9 +62,9 @@ export class LineSpacing {
   }
 }
 
-export type ParagraphProperty = {
-  align?: AlignmentType;
-  textAlignment?: TextAlignmentType;
+export class ParagraphProperty {
+  _align?: AlignmentType;
+  _textAlignment?: TextAlignmentType;
   styleId?: string;
   indent?: {
     left: number;
@@ -75,26 +77,60 @@ export type ParagraphProperty = {
     level: number;
   };
   lineSpacing?: LineSpacing;
-  runProperty: RunProperty;
+  runProperty: RunProperty = createDefaultRunProperty();
   keepNext: boolean;
   keepLines: boolean;
   pageBreakBefore: boolean;
   widowControl: boolean;
   paragraphPropertyChange?: ParagraphPropertyChange;
   outlineLvl?: number | null;
-  adjustRightInd?: number;
-  tabs?: Tab[];
+  snapToGrid?: boolean;
+  _adjustRightInd?: number;
+  _tabs?: Tab[];
   frameProperty?: FrameProperty;
-};
+
+  constructor() {}
+
+  tabs(
+    tabs: {
+      val: TabValueType | null;
+      leader: TabLeaderType | null;
+      pos: number | null;
+    }[]
+  ) {
+    this._tabs = tabs;
+    return this;
+  }
+
+  align(type: AlignmentType) {
+    this._align = type;
+    return this;
+  }
+
+  textAlignment(type: TextAlignmentType) {
+    this._textAlignment = type;
+    return this;
+  }
+
+  adjustRightInd(v: number) {
+    this._adjustRightInd = v;
+    return this;
+  }
+
+  style(id: string) {
+    this.styleId = id;
+    return this;
+  }
+}
 
 export const createDefaultParagraphProperty = (): ParagraphProperty => {
-  return {
-    runProperty: createDefaultRunProperty(),
-    keepNext: false,
-    keepLines: false,
-    pageBreakBefore: false,
-    widowControl: false,
-  };
+  let p = new ParagraphProperty();
+  p.runProperty = createDefaultRunProperty();
+  p.keepNext = false;
+  p.keepLines = false;
+  p.pageBreakBefore = false;
+  p.widowControl = false;
+  return p;
 };
 
 export const createParagraphAlignment = (
@@ -169,17 +205,17 @@ export class ParagraphPropertyChange {
   }
 
   align(type: AlignmentType) {
-    this._property.align = type;
+    this._property._align = type;
     return this;
   }
 
   textAlignment(type: TextAlignmentType) {
-    this._property.textAlignment = type;
+    this._property._textAlignment = type;
     return this;
   }
 
   adjustRightInd(v: number) {
-    this._property.adjustRightInd = v;
+    this._property._adjustRightInd = v;
     return this;
   }
 
@@ -250,22 +286,23 @@ export const buildLineSpacing = (
   return spacing;
 };
 
+// @deprecated
 export const setParagraphProperty = <T extends wasm.Paragraph | wasm.Style>(
   target: T,
   property: ParagraphProperty
 ): T => {
-  const alignment = createParagraphAlignment(property.align);
+  const alignment = createParagraphAlignment(property._align);
   if (alignment != null) {
     target = target.align(alignment) as T;
   }
 
-  const textAlignment = createParagraphTextAlignment(property.textAlignment);
+  const textAlignment = createParagraphTextAlignment(property._textAlignment);
   if (textAlignment != null) {
     target = target.text_alignment(textAlignment) as T;
   }
 
-  if (property.adjustRightInd != null) {
-    target = target.adjust_right_ind(property.adjustRightInd) as T;
+  if (property._adjustRightInd != null) {
+    target = target.adjust_right_ind(property._adjustRightInd) as T;
   }
 
   if (typeof property.indent !== "undefined") {
@@ -294,10 +331,14 @@ export const setParagraphProperty = <T extends wasm.Paragraph | wasm.Style>(
     target = target.numbering(numbering.id, numbering.level) as T;
   }
 
-  if (property.runProperty.bold) {
+  if (property.runProperty._bold) {
     target = target.bold() as T;
   }
 
+  if (property.runProperty._color) {
+    target = target.color(property.runProperty._color) as T;
+  }
+
   if (typeof property.lineSpacing !== "undefined") {
     const spacing = buildLineSpacing(property);
     if (spacing) {
@@ -305,27 +346,27 @@ export const setParagraphProperty = <T extends wasm.Paragraph | wasm.Style>(
     }
   }
 
-  if (property.runProperty.italic) {
+  if (property.runProperty._italic) {
     target = target.italic() as T;
   }
 
-  if (property.runProperty.size) {
-    target = target.size(property.runProperty.size) as T;
+  if (property.runProperty._size) {
+    target = target.size(property.runProperty._size) as T;
   }
 
-  if (property.runProperty.fonts) {
+  if (property.runProperty._fonts) {
     let f = wasm.createRunFonts();
-    if (property.runProperty.fonts._ascii) {
-      f = f.ascii(property.runProperty.fonts._ascii);
+    if (property.runProperty._fonts._ascii) {
+      f = f.ascii(property.runProperty._fonts._ascii);
     }
-    if (property.runProperty.fonts._hiAnsi) {
-      f = f.hi_ansi(property.runProperty.fonts._hiAnsi);
+    if (property.runProperty._fonts._hiAnsi) {
+      f = f.hi_ansi(property.runProperty._fonts._hiAnsi);
     }
-    if (property.runProperty.fonts._cs) {
-      f = f.cs(property.runProperty.fonts._cs);
+    if (property.runProperty._fonts._cs) {
+      f = f.cs(property.runProperty._fonts._cs);
     }
-    if (property.runProperty.fonts._eastAsia) {
-      f = f.east_asia(property.runProperty.fonts._eastAsia);
+    if (property.runProperty._fonts._eastAsia) {
+      f = f.east_asia(property.runProperty._fonts._eastAsia);
     }
     target = target.fonts(f) as T;
   }
@@ -334,6 +375,10 @@ export const setParagraphProperty = <T extends wasm.Paragraph | wasm.Style>(
     target = target.keep_lines(true) as T;
   }
 
+  if (property.snapToGrid != null) {
+    target = target.snap_to_grid(!!property.snapToGrid) as T;
+  }
+
   if (property.keepNext) {
     target = target.keep_next(true) as T;
   }
@@ -350,8 +395,8 @@ export const setParagraphProperty = <T extends wasm.Paragraph | wasm.Style>(
     target = target.outline_lvl(property.outlineLvl) as T;
   }
 
-  if (property.tabs) {
-    for (const tab of property.tabs) {
+  if (property._tabs) {
+    for (const tab of property._tabs) {
       let val: wasm.TabValueType | undefined;
       let leader: wasm.TabLeaderType | undefined;
       switch (tab.val) {
@@ -452,3 +497,220 @@ export const setParagraphProperty = <T extends wasm.Paragraph | wasm.Style>(
 
   return target;
 };
+
+export const createParagraphProperty = (
+  property: ParagraphProperty
+): wasm.ParagraphProperty => {
+  let p = wasm.createParagraphProperty();
+  const alignment = createParagraphAlignment(property._align);
+  if (alignment != null) {
+    p = p.align(alignment);
+  }
+
+  const textAlignment = createParagraphTextAlignment(property._textAlignment);
+  if (textAlignment != null) {
+    p = p.text_alignment(textAlignment);
+  }
+
+  if (property._adjustRightInd != null) {
+    p = p.adjust_right_ind(property._adjustRightInd);
+  }
+
+  if (typeof property.indent !== "undefined") {
+    const { indent } = property;
+    let kind;
+    switch (property.indent.specialIndentKind) {
+      case "firstLine": {
+        kind = wasm.SpecialIndentKind.FirstLine;
+        break;
+      }
+      case "hanging": {
+        kind = wasm.SpecialIndentKind.Hanging;
+        break;
+      }
+    }
+    p = p.indent(indent.left, kind, indent.specialIndentSize, indent.right);
+  }
+
+  if (typeof property.lineSpacing !== "undefined") {
+    const spacing = buildLineSpacing(property);
+    if (spacing) {
+      p = p.line_spacing(spacing);
+    }
+  }
+
+  if (typeof property.numbering !== "undefined") {
+    const { numbering } = property;
+    p = p.numbering(numbering.id, numbering.level);
+  }
+
+  let runProperty = wasm.createRunProperty();
+  if (property.runProperty._bold) {
+    runProperty = runProperty.bold();
+  }
+
+  if (property.runProperty._color) {
+    runProperty = runProperty.color(property.runProperty._color);
+  }
+
+  if (property.runProperty._italic) {
+    runProperty = runProperty.italic();
+  }
+
+  if (property.runProperty._size) {
+    runProperty = runProperty.size(property.runProperty._size);
+  }
+
+  if (property.runProperty._fonts) {
+    let f = wasm.createRunFonts();
+    if (property.runProperty._fonts._ascii) {
+      f = f.ascii(property.runProperty._fonts._ascii);
+    }
+    if (property.runProperty._fonts._hiAnsi) {
+      f = f.hi_ansi(property.runProperty._fonts._hiAnsi);
+    }
+    if (property.runProperty._fonts._cs) {
+      f = f.cs(property.runProperty._fonts._cs);
+    }
+    if (property.runProperty._fonts._eastAsia) {
+      f = f.east_asia(property.runProperty._fonts._eastAsia);
+    }
+    runProperty = runProperty.fonts(f);
+  }
+
+  if (property.runProperty) {
+    p = p.run_property(runProperty);
+  }
+
+  if (property.keepLines) {
+    p = p.keep_lines(true);
+  }
+
+  if (property.snapToGrid != null) {
+    p = p.snap_to_grid(!!property.snapToGrid);
+  }
+
+  if (property.keepNext) {
+    p = p.keep_next(true);
+  }
+
+  if (property.pageBreakBefore) {
+    p = p.page_break_before(true);
+  }
+
+  if (property.widowControl) {
+    p = p.widow_control(true);
+  }
+
+  if (property.outlineLvl != null) {
+    p = p.outline_lvl(property.outlineLvl);
+  }
+
+  if (property.styleId) {
+    p = p.style(property.styleId);
+  }
+
+  if (property._tabs) {
+    for (const tab of property._tabs) {
+      let val: wasm.TabValueType | undefined;
+      let leader: wasm.TabLeaderType | undefined;
+      switch (tab.val) {
+        case "bar":
+          val = wasm.TabValueType.Bar;
+          break;
+        case "bar":
+          val = wasm.TabValueType.Bar;
+          break;
+        case "center":
+          val = wasm.TabValueType.Center;
+          break;
+        case "clear":
+          val = wasm.TabValueType.Clear;
+          break;
+        case "decimal":
+          val = wasm.TabValueType.Decimal;
+          break;
+        case "end":
+          val = wasm.TabValueType.End;
+          break;
+        case "right":
+          val = wasm.TabValueType.Right;
+          break;
+        case "num":
+          val = wasm.TabValueType.Num;
+          break;
+        case "start":
+          val = wasm.TabValueType.Start;
+          break;
+        case "left":
+          val = wasm.TabValueType.Left;
+          break;
+      }
+
+      switch (tab.leader) {
+        case "dot":
+          leader = wasm.TabLeaderType.Dot;
+          break;
+        case "heavy":
+          leader = wasm.TabLeaderType.Heavy;
+          break;
+        case "hyphen":
+          leader = wasm.TabLeaderType.Hyphen;
+          break;
+        case "middleDot":
+          leader = wasm.TabLeaderType.MiddleDot;
+          break;
+        case "none":
+          leader = wasm.TabLeaderType.None;
+          break;
+        case "underscore":
+          leader = wasm.TabLeaderType.None;
+          break;
+      }
+      p = p.add_tab(val, leader, tab.pos ?? undefined);
+    }
+  }
+
+  if (property.frameProperty) {
+    let frameProperty = wasm.createFrameProperty();
+    if (property.frameProperty?.h != null) {
+      frameProperty = frameProperty.height(property.frameProperty.h);
+    }
+    if (property.frameProperty?.hRule != null) {
+      frameProperty = frameProperty.h_rule(property.frameProperty.hRule);
+    }
+    if (property.frameProperty?.hAnchor != null) {
+      frameProperty = frameProperty.h_anchor(property.frameProperty.hAnchor);
+    }
+    if (property.frameProperty?.hSpace != null) {
+      frameProperty = frameProperty.h_space(property.frameProperty.hSpace);
+    }
+    if (property.frameProperty?.vAnchor != null) {
+      frameProperty = frameProperty.v_anchor(property.frameProperty.vAnchor);
+    }
+    if (property.frameProperty?.vSpace != null) {
+      frameProperty = frameProperty.v_space(property.frameProperty.vSpace);
+    }
+    if (property.frameProperty?.w != null) {
+      frameProperty = frameProperty.width(property.frameProperty.w);
+    }
+    if (property.frameProperty?.wrap != null) {
+      frameProperty = frameProperty.wrap(property.frameProperty.wrap);
+    }
+    if (property.frameProperty?.x != null) {
+      frameProperty = frameProperty.x(property.frameProperty.x);
+    }
+    if (property.frameProperty?.xAlign != null) {
+      frameProperty = frameProperty.x_align(property.frameProperty.xAlign);
+    }
+    if (property.frameProperty?.y != null) {
+      frameProperty = frameProperty.y(property.frameProperty.y);
+    }
+    if (property.frameProperty?.yAlign != null) {
+      frameProperty = frameProperty.y_align(property.frameProperty.yAlign);
+    }
+    p = p.frame_property(frameProperty);
+  }
+
+  return p;
+};