docx-wasm 0.4.18-rc2 → 0.4.18-rc21

package/js/run.ts

@@ -6,172 +6,20 @@ import { Tab } from "./tab";
 import { Break, BreakType } from "./break";
 import { BorderType } from "./border";
 import { Image } from "./image";
+import { PositionalTab } from "./positional-tab";
+import {
+  createDefaultRunProperty,
+  RunFonts,
+  RunProperty,
+  setRunProperty,
+  VertAlignType,
+} from "./run-property";
 
-export type RunChild = Text | DeleteText | Tab | Break | Image;
-
-export type TextBorder = {
-  borderType: BorderType;
-  color: string;
-  space: number;
-  size: number;
-};
-
-export type VertAlignType = "baseline" | "superscript" | "subscript";
-
-export type RunPropertyDel = {
-  author: string;
-  date: string;
-};
-
-export type RunPropertyIns = {
-  author: string;
-  date: string;
-};
-
-export type RunProperty = {
-  style?: string;
-  size?: number;
-  color?: string;
-  highlight?: string;
-  vertAlign?: VertAlignType;
-  bold?: boolean;
-  italic?: boolean;
-  strike?: boolean;
-  underline?: string;
-  vanish?: boolean;
-  fonts?: RunFonts;
-  characterSpacing?: number;
-  textBorder?: TextBorder;
-  ins?: RunPropertyIns;
-  del?: RunPropertyDel;
-};
-
-export const convertBorderType = (t: BorderType) => {
-  switch (t) {
-    case "nil":
-      return wasm.BorderType.Nil;
-    case "none":
-      return wasm.BorderType.None;
-    case "single":
-      return wasm.BorderType.Single;
-    case "thick":
-      return wasm.BorderType.Thick;
-    case "double":
-      return wasm.BorderType.Double;
-    case "dotted":
-      return wasm.BorderType.Dotted;
-    case "dashed":
-      return wasm.BorderType.Dashed;
-    case "dotDash":
-      return wasm.BorderType.DotDash;
-    case "dotDotDash":
-      return wasm.BorderType.DotDotDash;
-    case "triple":
-      return wasm.BorderType.Triple;
-    default:
-      return wasm.BorderType.Single;
-  }
-};
-
-export const createDefaultRunProperty = (): RunProperty => {
-  return {};
-};
-
-export class RunFonts {
-  _ascii?: string;
-  _hiAnsi?: string;
-  _eastAsia?: string;
-  _cs?: string;
-  _asciiTheme?: string;
-  _hiAnsiTheme?: string;
-  _eastAsiaTheme?: string;
-  _csTheme?: string;
-  _hint?: string;
-
-  ascii(f: string) {
-    this._ascii = f;
-    return this;
-  }
-
-  hiAnsi(f: string) {
-    this._hiAnsi = f;
-    return this;
-  }
-
-  cs(f: string) {
-    this._cs = f;
-    return this;
-  }
-
-  eastAsia(f: string) {
-    this._eastAsia = f;
-    return this;
-  }
-
-  asciiTheme(f: string) {
-    this._asciiTheme = f;
-    return this;
-  }
-
-  hiAnsiTheme(f: string) {
-    this._hiAnsiTheme = f;
-    return this;
-  }
-
-  csTheme(f: string) {
-    this._csTheme = f;
-    return this;
-  }
-
-  eastAsiaTheme(f: string) {
-    this._eastAsia = f;
-    return this;
-  }
-
-  hint(f: string) {
-    this._hint = f;
-    return this;
-  }
-
-  buildWasmObject = () => {
-    let f = wasm.createRunFonts();
-    if (this?._ascii) {
-      f = f.ascii(this._ascii);
-    }
-    if (this?._hiAnsi) {
-      f = f.hi_ansi(this._hiAnsi);
-    }
-    if (this?._cs) {
-      f = f.cs(this._cs);
-    }
-    if (this?._eastAsia) {
-      f = f.east_asia(this._eastAsia);
-    }
-
-    // theme
-    if (this?._asciiTheme) {
-      f = f.ascii_theme(this._asciiTheme);
-    }
-    if (this?._hiAnsiTheme) {
-      f = f.hi_ansi_theme(this._hiAnsiTheme);
-    }
-    if (this?._csTheme) {
-      f = f.cs_theme(this._csTheme);
-    }
-    if (this?._eastAsiaTheme) {
-      f = f.east_asia_theme(this._eastAsiaTheme);
-    }
-
-    if (this?._hint) {
-      f = f.hint(this._hint);
-    }
-    return f;
-  };
-}
+export type RunChild = Text | DeleteText | Tab | Break | Image | PositionalTab;
 
 export class Run {
   children: RunChild[] = [];
-  property: RunProperty = {};
+  property: RunProperty;
 
   addText(text: string) {
     this.children.push(new Text(text));
@@ -193,91 +41,103 @@ export class Run {
     return this;
   }
 
+  addPositionalTab(ptab: PositionalTab) {
+    this.children.push(ptab);
+    return this;
+  }
+
   addBreak(type: BreakType) {
     this.children.push(new Break(type));
     return this;
   }
 
   style(style: string) {
-    this.property = { ...this.property, style };
+    this.property ??= createDefaultRunProperty();
+    this.property.style(style);
     return this;
   }
 
   size(size: number) {
-    this.property = { ...this.property, size };
+    this.property ??= createDefaultRunProperty();
+    this.property.size(size);
     return this;
   }
 
   color(color: string) {
-    this.property = { ...this.property, color };
+    this.property ??= createDefaultRunProperty();
+    this.property.color(color);
     return this;
   }
 
   highlight(color: string) {
-    this.property = { ...this.property, highlight: color };
+    this.property ??= createDefaultRunProperty();
+    this.property.highlight(color);
     return this;
   }
 
   vertAlign(vertAlign: VertAlignType) {
-    this.property = { ...this.property, vertAlign };
+    this.property ??= createDefaultRunProperty();
+    this.property.vertAlign(vertAlign);
     return this;
   }
 
   bold() {
-    this.property = { ...this.property, bold: true };
+    this.property ??= createDefaultRunProperty();
+    this.property.bold();
     return this;
   }
 
   strike() {
-    this.property = { ...this.property, strike: true };
+    this.property ??= createDefaultRunProperty();
+    this.property.strike();
     return this;
   }
 
   italic() {
-    this.property = { ...this.property, italic: true };
+    this.property ??= createDefaultRunProperty();
+    this.property.italic();
     return this;
   }
 
   underline(type: string) {
-    this.property = { ...this.property, underline: type };
+    this.property ??= createDefaultRunProperty();
+    this.property.underline(type);
     return this;
   }
 
   vanish() {
-    this.property = { ...this.property, vanish: true };
+    this.property ??= createDefaultRunProperty();
+    this.property.vanish();
     return this;
   }
 
   fonts(fonts: RunFonts) {
-    this.property = { ...this.property, fonts };
+    this.property ??= createDefaultRunProperty();
+    this.property.fonts(fonts);
     return this;
   }
 
   spacing(characterSpacing: number) {
-    this.property = { ...this.property, characterSpacing };
+    this.property ??= createDefaultRunProperty();
+    this.property.spacing(characterSpacing);
     return this;
   }
 
   delete(author: string, date: string) {
-    this.property = { ...this.property, del: { author, date } };
+    this.property ??= createDefaultRunProperty();
+    this.property.delete(author, date);
     return this;
   }
 
   insert(author: string, date: string) {
-    this.property = { ...this.property, ins: { author, date } };
+    this.property ??= createDefaultRunProperty();
+    this.property.delete(author, date);
     return this;
   }
 
   textBorder(type: BorderType, size: number, space: number, color: string) {
-    this.property = {
-      ...this.property,
-      textBorder: {
-        borderType: type,
-        size,
-        space,
-        color,
-      },
-    };
+    this.property ??= createDefaultRunProperty();
+    this.property.textBorder(type, size, space, color);
     return this;
   }
 
@@ -290,6 +150,8 @@ export class Run {
         run = run.add_delete_text(child.text);
       } else if (child instanceof Tab) {
         run = run.add_tab();
+      } else if (child instanceof PositionalTab) {
+        run = run.add_ptab(child.buildWasmObject());
       } else if (child instanceof Break) {
         if (child.type === "column") {
           run = run.add_break(wasm.BreakType.Column);
@@ -319,78 +181,10 @@ export class Run {
       }
     });
 
-    run = setRunProperty(run, this.property) as wasm.Run;
+    if (this.property) {
+      run = setRunProperty(run, this.property) as wasm.Run;
+    }
 
     return run;
   }
 }
-
-export const setRunProperty = <T extends wasm.Run | wasm.Style>(
-  target: T,
-  property: RunProperty
-): T => {
-  if (property.style && target instanceof wasm.Run) {
-    target = target.style(property.style) as T;
-  }
-
-  if (typeof property.size !== "undefined") {
-    target = target.size(property.size) as T;
-  }
-
-  if (property.color) {
-    target = target.color(property.color) as T;
-  }
-
-  if (property.highlight) {
-    target = target.highlight(property.highlight) as T;
-  }
-
-  if (property.vertAlign) {
-    if (property.vertAlign === "superscript") {
-      target = target.vert_align(wasm.VertAlignType.SuperScript) as T;
-    } else if (property.vertAlign === "subscript") {
-      target = target.vert_align(wasm.VertAlignType.SubScript) as T;
-    }
-  }
-
-  if (property.bold) {
-    target = target.bold() as T;
-  }
-
-  if (property.italic) {
-    target = target.italic() as T;
-  }
-
-  if (property.strike) {
-    target = target.strike() as T;
-  }
-
-  if (property.underline) {
-    target = target.underline(property.underline) as T;
-  }
-
-  if (property.vanish) {
-    target = target.vanish() as T;
-  }
-
-  if (property.characterSpacing != null) {
-    target = target.character_spacing(property.characterSpacing) as T;
-  }
-
-  if (property.textBorder) {
-    const { borderType, color, space, size } = property.textBorder;
-    target = target.text_border(
-      convertBorderType(borderType),
-      size,
-      space,
-      color
-    ) as T;
-  }
-
-  if (property.fonts) {
-    const fonts = property.fonts.buildWasmObject();
-    target = target.fonts(fonts) as T;
-  }
-
-  return target;
-};

package/js/style.ts

@@ -13,13 +13,13 @@ import {
   VertAlignType,
   RunFonts,
   setRunProperty,
-} from "./run";
+} from "./run-property";
 import {
   AlignmentType,
   createDefaultParagraphProperty,
+  createParagraphProperty,
   LineSpacing,
   ParagraphProperty,
-  setParagraphProperty,
   SpecialIndentKind,
 } from "./paragraph-property";
 import { BorderType } from "./border";
@@ -41,7 +41,7 @@ export class Style {
     this._styleId = id;
     this._styleType = type;
     this._name = "";
-    this._runProperty = {};
+    this._runProperty;
     this._tableProperty = { cellMargins: createDefaultTableCellMargins() };
     this._runProperty = createDefaultRunProperty();
     this._paragraphProperty = createDefaultParagraphProperty();
@@ -64,105 +64,95 @@ export class Style {
     return this;
   };
 
-  // TODO:
-  // runProperty = (n: RunProperty) => {
-  //   this._runProperty = n;
-  //   return this;
-  // };
-
   // run property
   style(style: string) {
-    this._runProperty = { ...this._runProperty, style };
+    this._runProperty.style(style);
     return this;
   }
 
   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;
   }
 
   vertAlign(vertAlign: VertAlignType) {
-    this._runProperty = { ...this._runProperty, vertAlign };
+    this._runProperty.vertAlign(vertAlign);
     return this;
   }
 
   bold() {
-    this._runProperty = { ...this._runProperty, bold: true };
+    this._runProperty.bold();
     return this;
   }
 
   strike() {
-    this._runProperty = { ...this._runProperty, strike: true };
+    this._runProperty.strike();
     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;
   }
 
   delete(author: string, date: string) {
-    this._runProperty = { ...this._runProperty, del: { author, date } };
+    this._runProperty.delete(author, date);
     return this;
   }
 
   insert(author: string, date: string) {
-    this._runProperty = { ...this._runProperty, ins: { author, date } };
+    this._runProperty.insert(author, date);
     return this;
   }
 
   textBorder(type: BorderType, size: number, space: number, color: string) {
-    this._runProperty = {
-      ...this._runProperty,
-      textBorder: {
-        borderType: type,
-        size,
-        space,
-        color,
-      },
-    };
+    this._runProperty.textBorder(type, size, space, color);
     return this;
   }
 
-  // TODO:
-  // paragraphProperty = (n: ParagraphProperty) => {
-  //   this._paragraphProperty = n;
-  //   return this;
-  // };
+  paragraphProperty = (p: ParagraphProperty) => {
+    this._paragraphProperty = p;
+    return this;
+  };
+
+  runProperty = (p: RunProperty) => {
+    this._runProperty = p;
+    return this;
+  };
 
   // paragraph property
   align(type: AlignmentType) {
-    this._paragraphProperty.align = type;
+    this._paragraphProperty._align = type;
     return this;
   }
 
@@ -190,33 +180,31 @@ export class Style {
   }
 
   keepNext(v: boolean) {
-    this._paragraphProperty = { ...this._paragraphProperty, keepNext: v };
+    this._paragraphProperty.keepNext = v;
     return this;
   }
 
   keepLines(v: boolean) {
-    this._paragraphProperty = { ...this._paragraphProperty, keepLines: v };
+    this._paragraphProperty.keepLines = v;
     return this;
   }
 
   pageBreakBefore(v: boolean) {
-    this._paragraphProperty = {
-      ...this._paragraphProperty,
-      pageBreakBefore: v,
-    };
+    this._paragraphProperty.pageBreakBefore = v;
     return this;
   }
 
   widowControl(v: boolean) {
-    this._paragraphProperty = { ...this._paragraphProperty, widowControl: v };
+    this._paragraphProperty.widowControl = v;
     return this;
   }
 
   outlineLevel(v: number) {
-    this._paragraphProperty = { ...this._paragraphProperty, outlineLvl: v };
+    this._paragraphProperty.outlineLvl = v;
     return this;
   }
 
+  // TODO:
   // tableProperty = (n: TableProperty) => {
   //   this._tableProperty = n;
   //   return this;
@@ -304,11 +292,19 @@ export class Style {
       s = s.link(this._link);
     }
 
-    s = setRunProperty(s, this._runProperty);
+    if (this._runProperty) {
+      s = setRunProperty(s, this._runProperty);
+    }
 
-    s = setParagraphProperty(s, this._paragraphProperty);
+    if (this._paragraphProperty) {
+      s = s.paragraph_property(
+        createParagraphProperty(this._paragraphProperty)
+      );
+    }
 
-    s = setTableProperty(s, this._tableProperty);
+    if (this._tableProperty) {
+      s = setTableProperty(s, this._tableProperty);
+    }
 
     return s;
   };

package/js/styles.ts

@@ -1,6 +1,6 @@
 import { Style } from "./style";
 import { DocDefaults } from "./doc-defaults";
-import { RunFonts } from "./run";
+import { RunFonts } from "./run-property";
 import { LineSpacing } from "./paragraph-property";
 
 export class Styles {

package/js/tab-leader.ts

@@ -0,0 +1,22 @@
+import * as wasm from "./pkg";
+import { TabLeaderType } from "./json/bindings/TabLeaderType";
+
+export const convertTabLeader = (leader: TabLeaderType) => {
+  switch (leader) {
+    case "dot":
+      return wasm.TabLeaderType.Dot;
+      break;
+    case "heavy":
+      return wasm.TabLeaderType.Heavy;
+    case "hyphen":
+      return wasm.TabLeaderType.Hyphen;
+    case "middleDot":
+      return wasm.TabLeaderType.MiddleDot;
+    case "none":
+      return wasm.TabLeaderType.None;
+    case "underscore":
+      return wasm.TabLeaderType.Underscore;
+    default:
+      return wasm.TabLeaderType.None;
+  }
+};

package/js/table-cell.ts

@@ -4,7 +4,7 @@ import { Shading } from "./shading";
 import { TableCellBorders, PositionKeys } from "./table-cell-borders";
 import { TableCellBorderPosition, TableCellBorder } from "./table-cell-border";
 import * as wasm from "./pkg";
-import { convertBorderType } from "./run";
+import { convertBorderType } from "./run-property";
 import { TableOfContents } from "./table-of-contents";
 import { build } from "./builder";
 import { WidthType } from ".";

package/js/table-of-contents.ts

@@ -3,6 +3,10 @@ import * as wasm from "./pkg";
 import { Table } from "./table";
 import { TableOfContentsItem } from "./table-of-contents-item";
 import { build } from "./builder";
+import {
+  createParagraphProperty,
+  ParagraphProperty,
+} from "./paragraph-property";
 
 export class TableOfContents {
   _instrText?: string;
@@ -18,6 +22,7 @@ export class TableOfContents {
   _beforeContents: (Paragraph | Table)[] = [];
   _afterContents: (Paragraph | Table)[] = [];
   _delete: { author: string; date: string } | null = null;
+  _paragraphProperty: ParagraphProperty | null = null;
 
   constructor(instrText?: string) {
     this._instrText = instrText;
@@ -93,6 +98,11 @@ export class TableOfContents {
     return this;
   };
 
+  paragraphProperty(p: ParagraphProperty) {
+    this._paragraphProperty = p;
+    return this;
+  }
+
   buildWasmObject = () => {
     let toc = this._instrText
       ? wasm.createTableOfContentsWithInstrText(this._instrText)
@@ -156,6 +166,12 @@ export class TableOfContents {
       }
     }
 
+    if (this._paragraphProperty) {
+      toc = toc.paragraph_property(
+        createParagraphProperty(this._paragraphProperty)
+      );
+    }
+
     return toc;
   };
 }