Declarative styles

src/file/styles/style/character-style.ts

@@ -1,69 +1,128 @@
 import * as formatting from "file/paragraph/run/formatting";
 import { RunProperties } from "file/paragraph/run/properties";
-import { XmlComponent } from "file/xml-components";
+import { UnderlineType } from "file/paragraph/run/underline";
+
 import { BasedOn, Link, SemiHidden, UiPriority, UnhideWhenUsed } from "./components";
 import { Style } from "./style";
 
+export interface IBaseCharacterStyleOptions {
+    readonly basedOn?: string;
+    readonly link?: string;
+    readonly semiHidden?: boolean;
+    readonly run?: {
+        readonly size?: number;
+        readonly bold?: boolean;
+        readonly italics?: boolean;
+        readonly smallCaps?: boolean;
+        readonly allCaps?: boolean;
+        readonly strike?: boolean;
+        readonly doubleStrike?: boolean;
+        readonly subScript?: boolean;
+        readonly superScript?: boolean;
+        readonly underline?: {
+            readonly type?: UnderlineType;
+            readonly color?: string;
+        };
+        readonly color?: string;
+        readonly font?: string;
+        readonly characterSpacing?: number;
+        readonly highlight?: string;
+        readonly shadow?: {
+            readonly type: string;
+            readonly fill: string;
+            readonly color: string;
+        };
+    };
+}
+
+export interface ICharacterStyleOptions extends IBaseCharacterStyleOptions {
+    readonly id: string;
+    readonly name?: string;
+}
+
 export class CharacterStyle extends Style {
     private readonly runProperties: RunProperties;
 
-    constructor(styleId: string, name?: string) {
-        super({ type: "character", styleId: styleId }, name);
+    constructor(options: ICharacterStyleOptions) {
+        super({ type: "character", styleId: options.id }, options.name);
         this.runProperties = new RunProperties();
         this.root.push(this.runProperties);
-        this.root.push(new UiPriority("99"));
+        this.root.push(new UiPriority(99));
         this.root.push(new UnhideWhenUsed());
-    }
 
-    public basedOn(parentId: string): CharacterStyle {
-        this.root.push(new BasedOn(parentId));
-        return this;
-    }
+        if (options.basedOn) {
+            this.root.push(new BasedOn(options.basedOn));
+        }
 
-    public addRunProperty(property: XmlComponent): CharacterStyle {
-        this.runProperties.push(property);
-        return this;
-    }
+        if (options.link) {
+            this.root.push(new Link(options.link));
+        }
 
-    public color(color: string): CharacterStyle {
-        return this.addRunProperty(new formatting.Color(color));
-    }
+        if (options.semiHidden) {
+            this.root.push(new SemiHidden());
+        }
 
-    public bold(): CharacterStyle {
-        return this.addRunProperty(new formatting.Bold());
-    }
+        if (options.run) {
+            if (options.run.size) {
+                this.runProperties.push(new formatting.Size(options.run.size));
+                this.runProperties.push(new formatting.SizeComplexScript(options.run.size));
+            }
 
-    public italics(): CharacterStyle {
-        return this.addRunProperty(new formatting.Italics());
-    }
+            if (options.run.bold) {
+                this.runProperties.push(new formatting.Bold());
+            }
 
-    public underline(underlineType?: string, color?: string): CharacterStyle {
-        return this.addRunProperty(new formatting.Underline(underlineType, color));
-    }
+            if (options.run.italics) {
+                this.runProperties.push(new formatting.Italics());
+            }
 
-    public superScript(): CharacterStyle {
-        return this.addRunProperty(new formatting.SuperScript());
-    }
+            if (options.run.smallCaps) {
+                this.runProperties.push(new formatting.SmallCaps());
+            }
 
-    public size(twips: number): CharacterStyle {
-        return this.addRunProperty(new formatting.Size(twips)).addRunProperty(new formatting.SizeComplexScript(twips));
-    }
+            if (options.run.allCaps) {
+                this.runProperties.push(new formatting.Caps());
+            }
 
-    public link(link: string): CharacterStyle {
-        this.root.push(new Link(link));
-        return this;
-    }
+            if (options.run.strike) {
+                this.runProperties.push(new formatting.Strike());
+            }
 
-    public semiHidden(): CharacterStyle {
-        this.root.push(new SemiHidden());
-        return this;
-    }
+            if (options.run.doubleStrike) {
+                this.runProperties.push(new formatting.DoubleStrike());
+            }
 
-    public highlight(color: string): CharacterStyle {
-        return this.addRunProperty(new formatting.Highlight(color));
-    }
+            if (options.run.subScript) {
+                this.runProperties.push(new formatting.SubScript());
+            }
 
-    public shadow(value: string, fill: string, color: string): CharacterStyle {
-        return this.addRunProperty(new formatting.Shading(value, fill, color));
+            if (options.run.superScript) {
+                this.runProperties.push(new formatting.SuperScript());
+            }
+
+            if (options.run.underline) {
+                this.runProperties.push(new formatting.Underline(options.run.underline.type, options.run.underline.color));
+            }
+
+            if (options.run.color) {
+                this.runProperties.push(new formatting.Color(options.run.color));
+            }
+
+            if (options.run.font) {
+                this.runProperties.push(new formatting.RunFonts(options.run.font));
+            }
+
+            if (options.run.characterSpacing) {
+                this.runProperties.push(new formatting.CharacterSpacing(options.run.characterSpacing));
+            }
+
+            if (options.run.highlight) {
+                this.runProperties.push(new formatting.Highlight(options.run.highlight));
+            }
+
+            if (options.run.shadow) {
+                this.runProperties.push(new formatting.Shading(options.run.shadow.type, options.run.shadow.fill, options.run.shadow.color));
+            }
+        }
     }
 }