add support for floating drawings

- added need elements and test for them

src/file/drawing/floating/align.spec.ts

@@ -0,0 +1,15 @@
+import { assert } from "chai";
+
+import { Align } from "./align";
+import { Utility } from "../../../tests/utility";
+import { VerticalPositionAlign } from ".";
+
+describe("Align", () => {
+    describe("#constructor()", () => {
+        it("should create a element with correct root key", () => {
+            const newJson = Utility.jsonify(new Align(VerticalPositionAlign.CENTER));
+            assert.equal(newJson.rootKey, "wp:align");
+            assert.include(newJson.root[0], VerticalPositionAlign.CENTER);
+        });
+    });
+});

src/file/drawing/floating/align.ts

@@ -0,0 +1,10 @@
+// http://officeopenxml.com/drwPicFloating-position.php
+import { XmlComponent } from "file/xml-components";
+import { HorizontalPositionAlign, VerticalPositionAlign } from "./floating-position";
+
+export class Align extends XmlComponent {
+    constructor(value: HorizontalPositionAlign | VerticalPositionAlign) {
+        super("wp:align");
+        this.root.push(value);
+    }
+}

src/file/drawing/floating/floating-position.ts

@@ -0,0 +1,60 @@
+// http://officeopenxml.com/drwPicFloating-position.php
+
+export enum HorizontalPositionRelativeFrom {
+    CHARACTER = "character",
+    COLUMN = "column",
+    INSIDE_MARGIN = "insideMargin",
+    LEFT_MARGIN = "leftMargin",
+    MARGIN = "margin",
+    OUTSIDE_MARGIN = "outsideMargin",
+    PAGE = "page",
+    RIGHT_MARGIN = "rightMargin",
+}
+
+export enum VerticalPositionRelativeFrom {
+    BOTTOM_MARGIN = "bottomMargin",
+    INSIDE_MARGIN = "insideMargin",
+    LINE = "line",
+    MARGIN = "margin",
+    OUTSIDE_MARGIN = "outsideMargin",
+    PAGE = "page",
+    PARAGRAPH = "paragraph",
+    TOP_MARGIN = "topMargin",
+}
+
+export enum HorizontalPositionAlign {
+    CENTER = "center",
+    INSIDE = "inside",
+    LEFT = "left",
+    OUTSIDE = "outside",
+    RIGHT = "right",
+}
+
+export enum VerticalPositionAlign {
+    BOTTOM = "bottom",
+    CENTER = "center",
+    INSIDE = "inside",
+    OUTSIDE = "outside",
+    TOP = "top",
+}
+
+export interface HorizontalPositionOptions {
+    relative: HorizontalPositionRelativeFrom;
+    align?: HorizontalPositionAlign;
+    offset?: number;
+}
+
+export interface VerticalPositionOptions {
+    relative: VerticalPositionRelativeFrom;
+    align?: VerticalPositionAlign;
+    offset?: number;
+}
+
+export interface Floating {
+    horizontalPosition: HorizontalPositionOptions;
+    verticalPosition: VerticalPositionOptions;
+    allowOverlap?: boolean;
+    lockAnchor?: boolean;
+    behindDocument?: boolean;
+    layoutInCell?: boolean;
+}

src/file/drawing/floating/horizontal-position.spec.ts

@@ -0,0 +1,41 @@
+import { assert } from "chai";
+
+import { HorizontalPosition } from "./horizontal-position";
+import { Utility } from "../../../tests/utility";
+import { HorizontalPositionRelativeFrom, HorizontalPositionAlign } from ".";
+
+describe("HorizontalPosition", () => {
+    describe("#constructor()", () => {
+        it("should create a element with position align", () => {
+            const newJson = Utility.jsonify(
+                new HorizontalPosition({
+                    relative: HorizontalPositionRelativeFrom.MARGIN,
+                    align: HorizontalPositionAlign.CENTER,
+                }),
+            );
+            assert.equal(newJson.rootKey, "wp:positionH");
+            assert.include(newJson.root[0].root, {
+                relativeFrom: "margin",
+            });
+
+            assert.equal(newJson.root[1].rootKey, "wp:align");
+            assert.include(newJson.root[1].root, "center");
+        });
+
+        it("should create a element with offset", () => {
+            const newJson = Utility.jsonify(
+                new HorizontalPosition({
+                    relative: HorizontalPositionRelativeFrom.MARGIN,
+                    offset: 40,
+                }),
+            );
+            assert.equal(newJson.rootKey, "wp:positionH");
+            assert.include(newJson.root[0].root, {
+                relativeFrom: "margin",
+            });
+
+            assert.equal(newJson.root[1].rootKey, "wp:posOffset");
+            assert.include(newJson.root[1].root[0], 40);
+        });
+    });
+});

src/file/drawing/floating/horizontal-position.ts

@@ -0,0 +1,35 @@
+// http://officeopenxml.com/drwPicFloating-position.php
+import { XmlComponent, XmlAttributeComponent } from "file/xml-components";
+import { HorizontalPositionRelativeFrom, HorizontalPositionOptions } from "./floating-position";
+import { Align } from "./align";
+import { PositionOffset } from "./position-offset";
+
+interface IHorizontalPositionAttributes {
+    relativeFrom: HorizontalPositionRelativeFrom;
+}
+
+class HorizontalPositionAttributes extends XmlAttributeComponent<IHorizontalPositionAttributes> {
+    protected xmlKeys = {
+        relativeFrom: "relativeFrom",
+    };
+}
+
+export class HorizontalPosition extends XmlComponent {
+    constructor(horizontalPosition: HorizontalPositionOptions) {
+        super("wp:positionH");
+
+        this.root.push(
+            new HorizontalPositionAttributes({
+                relativeFrom: horizontalPosition.relative,
+            }),
+        );
+
+        if (horizontalPosition.align) {
+            this.root.push(new Align(horizontalPosition.align));
+        } else if (horizontalPosition.offset !== undefined) {
+            this.root.push(new PositionOffset(horizontalPosition.offset));
+        } else {
+            throw new Error("There is no configuration provided for floating position (Align or offset)");
+        }
+    }
+}

src/file/drawing/floating/index.ts

@@ -0,0 +1,4 @@
+export * from "./floating-position";
+export * from "./simple-pos";
+export * from "./horizontal-position";
+export * from "./vertical-position";

src/file/drawing/floating/position-offset.spec.ts

@@ -0,0 +1,14 @@
+import { assert } from "chai";
+
+import { PositionOffset } from "./position-offset";
+import { Utility } from "../../../tests/utility";
+
+describe("PositionOffset", () => {
+    describe("#constructor()", () => {
+        it("should create a element with correct root key", () => {
+            const newJson = Utility.jsonify(new PositionOffset(50));
+            assert.equal(newJson.rootKey, "wp:posOffset");
+            assert.equal(newJson.root[0], 50);
+        });
+    });
+});

src/file/drawing/floating/position-offset.ts

@@ -0,0 +1,9 @@
+// http://officeopenxml.com/drwPicFloating-position.php
+import { XmlComponent } from "file/xml-components";
+
+export class PositionOffset extends XmlComponent {
+    constructor(offsetValue: number) {
+        super("wp:posOffset");
+        this.root.push(offsetValue.toString());
+    }
+}

src/file/drawing/floating/simple-pos.spec.ts

@@ -0,0 +1,17 @@
+import { assert } from "chai";
+
+import { SimplePos } from "./simple-pos";
+import { Utility } from "../../../tests/utility";
+
+describe("SimplePos", () => {
+    describe("#constructor()", () => {
+        it("should create a element with correct root key", () => {
+            const newJson = Utility.jsonify(new SimplePos());
+            assert.equal(newJson.rootKey, "wp:simplePos");
+            assert.include(newJson.root[0].root, {
+                x: 0,
+                y: 0,
+            });
+        });
+    });
+});

src/file/drawing/floating/simple-pos.ts

@@ -0,0 +1,28 @@
+// http://officeopenxml.com/drwPicFloating-position.php
+import { XmlComponent, XmlAttributeComponent } from "file/xml-components";
+
+interface ISimplePosAttributes {
+    x: number;
+    y: number;
+}
+
+class SimplePosAttributes extends XmlAttributeComponent<ISimplePosAttributes> {
+    protected xmlKeys = {
+        x: "x",
+        y: "y",
+    };
+}
+
+export class SimplePos extends XmlComponent {
+    constructor() {
+        super("wp:simplePos");
+
+        // NOTE: It's not fully supported in Microsoft Word, but this element is needed anyway
+        this.root.push(
+            new SimplePosAttributes({
+                x: 0,
+                y: 0,
+            }),
+        );
+    }
+}

src/file/drawing/floating/vertical-position.spec.ts

@@ -0,0 +1,41 @@
+import { assert } from "chai";
+
+import { VerticalPosition } from "./vertical-position";
+import { Utility } from "../../../tests/utility";
+import { VerticalPositionRelativeFrom, VerticalPositionAlign } from ".";
+
+describe("VerticalPosition", () => {
+    describe("#constructor()", () => {
+        it("should create a element with position align", () => {
+            const newJson = Utility.jsonify(
+                new VerticalPosition({
+                    relative: VerticalPositionRelativeFrom.MARGIN,
+                    align: VerticalPositionAlign.INSIDE,
+                }),
+            );
+            assert.equal(newJson.rootKey, "wp:positionV");
+            assert.include(newJson.root[0].root, {
+                relativeFrom: "margin",
+            });
+
+            assert.equal(newJson.root[1].rootKey, "wp:align");
+            assert.include(newJson.root[1].root, "inside");
+        });
+
+        it("should create a element with offset", () => {
+            const newJson = Utility.jsonify(
+                new VerticalPosition({
+                    relative: VerticalPositionRelativeFrom.MARGIN,
+                    offset: 40,
+                }),
+            );
+            assert.equal(newJson.rootKey, "wp:positionV");
+            assert.include(newJson.root[0].root, {
+                relativeFrom: "margin",
+            });
+
+            assert.equal(newJson.root[1].rootKey, "wp:posOffset");
+            assert.include(newJson.root[1].root[0], 40);
+        });
+    });
+});

src/file/drawing/floating/vertical-position.ts

@@ -0,0 +1,35 @@
+// http://officeopenxml.com/drwPicFloating-position.php
+import { XmlComponent, XmlAttributeComponent } from "file/xml-components";
+import { VerticalPositionRelativeFrom, VerticalPositionOptions } from "./floating-position";
+import { Align } from "./align";
+import { PositionOffset } from "./position-offset";
+
+interface IVerticalPositionAttributes {
+    relativeFrom: VerticalPositionRelativeFrom;
+}
+
+class VerticalPositionAttributes extends XmlAttributeComponent<IVerticalPositionAttributes> {
+    protected xmlKeys = {
+        relativeFrom: "relativeFrom",
+    };
+}
+
+export class VerticalPosition extends XmlComponent {
+    constructor(verticalPosition: VerticalPositionOptions) {
+        super("wp:positionV");
+
+        this.root.push(
+            new VerticalPositionAttributes({
+                relativeFrom: verticalPosition.relative,
+            }),
+        );
+
+        if (verticalPosition.align) {
+            this.root.push(new Align(verticalPosition.align));
+        } else if (verticalPosition.offset !== undefined) {
+            this.root.push(new PositionOffset(verticalPosition.offset));
+        } else {
+            throw new Error("There is no configuration provided for floating position (Align or offset)");
+        }
+    }
+}