docx 8.0.0 → 8.0.2

package/src/file/document/body/section-properties/section-properties.spec.ts

@@ -1,279 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-import { FooterWrapper } from "@file/footer-wrapper";
-import { HeaderWrapper } from "@file/header-wrapper";
-import { Media } from "@file/media";
-import { NumberFormat } from "@file/shared/number-format";
-import { VerticalAlign } from "@file/vertical-align";
-import { convertInchesToTwip } from "@util/convenience-functions";
-
-import { PageOrientation } from "./properties";
-import { DocumentGridType } from "./properties/doc-grid";
-import { LineNumberRestartFormat } from "./properties/line-number";
-import { PageBorderOffsetFrom } from "./properties/page-borders";
-import { PageTextDirectionType } from "./properties/page-text-direction";
-import { SectionType } from "./properties/section-type";
-import { sectionMarginDefaults, sectionPageSizeDefaults, SectionProperties } from "./section-properties";
-
-const DEFAULT_MARGINS = {
-    "w:bottom": sectionMarginDefaults.BOTTOM,
-    "w:footer": sectionMarginDefaults.FOOTER,
-    "w:top": sectionMarginDefaults.TOP,
-    "w:right": sectionMarginDefaults.RIGHT,
-    "w:left": sectionMarginDefaults.LEFT,
-    "w:header": sectionMarginDefaults.HEADER,
-    "w:gutter": sectionMarginDefaults.GUTTER,
-};
-
-const PAGE_SIZE_DEFAULTS = {
-    "w:h": sectionPageSizeDefaults.HEIGHT,
-    "w:orient": sectionPageSizeDefaults.ORIENTATION,
-    "w:w": sectionPageSizeDefaults.WIDTH,
-};
-
-describe("SectionProperties", () => {
-    describe("#constructor()", () => {
-        it("should create section properties with options", () => {
-            const media = new Media();
-
-            const properties = new SectionProperties({
-                page: {
-                    size: {
-                        width: 1190,
-                        height: 1680,
-                        orientation: PageOrientation.PORTRAIT,
-                    },
-                    margin: {
-                        top: "2in",
-                        right: "2in",
-                        bottom: "2in",
-                        left: "2in",
-                        header: 808,
-                        footer: 808,
-                        gutter: 10,
-                    },
-                    pageNumbers: {
-                        start: 10,
-                        formatType: NumberFormat.CARDINAL_TEXT,
-                    },
-                },
-                column: {
-                    space: 208,
-                    count: 2,
-                    separate: true,
-                },
-                grid: {
-                    linePitch: convertInchesToTwip(0.25),
-                    type: DocumentGridType.LINES,
-                },
-                headerWrapperGroup: {
-                    default: new HeaderWrapper(media, 100),
-                },
-                footerWrapperGroup: {
-                    even: new FooterWrapper(media, 200),
-                },
-                titlePage: true,
-                verticalAlign: VerticalAlign.TOP,
-            });
-
-            const tree = new Formatter().format(properties);
-
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
-            expect(tree["w:sectPr"][0]).to.deep.equal({ "w:headerReference": { _attr: { "r:id": "rId100", "w:type": "default" } } });
-            expect(tree["w:sectPr"][1]).to.deep.equal({ "w:footerReference": { _attr: { "r:id": "rId200", "w:type": "even" } } });
-            expect(tree["w:sectPr"][2]).to.deep.equal({ "w:pgSz": { _attr: { "w:h": 1680, "w:w": 1190, "w:orient": "portrait" } } });
-            expect(tree["w:sectPr"][3]).to.deep.equal({
-                "w:pgMar": {
-                    _attr: {
-                        "w:bottom": "2in",
-                        "w:footer": 808,
-                        "w:top": "2in",
-                        "w:right": "2in",
-                        "w:left": "2in",
-                        "w:header": 808,
-                        "w:gutter": 10,
-                    },
-                },
-            });
-
-            expect(tree["w:sectPr"][4]).to.deep.equal({ "w:pgNumType": { _attr: { "w:fmt": "cardinalText", "w:start": 10 } } });
-            expect(tree["w:sectPr"][5]).to.deep.equal({ "w:cols": { _attr: { "w:space": 208, "w:sep": true, "w:num": 2 } } });
-            expect(tree["w:sectPr"][6]).to.deep.equal({ "w:vAlign": { _attr: { "w:val": "top" } } });
-            expect(tree["w:sectPr"][7]).to.deep.equal({ "w:titlePg": {} });
-            expect(tree["w:sectPr"][8]).to.deep.equal({ "w:docGrid": { _attr: { "w:linePitch": 360, "w:type": "lines" } } });
-        });
-
-        it("should create section properties with no options", () => {
-            const properties = new SectionProperties();
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
-            expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": { _attr: PAGE_SIZE_DEFAULTS } });
-            expect(tree["w:sectPr"][1]).to.deep.equal({
-                "w:pgMar": { _attr: DEFAULT_MARGINS },
-            });
-            // expect(tree["w:sectPr"][3]).to.deep.equal({ "w:cols": { _attr: { "w:space": 708, "w:sep": false, "w:num": 1 } } });
-            expect(tree["w:sectPr"][3]).to.deep.equal({ "w:docGrid": { _attr: { "w:linePitch": 360 } } });
-        });
-
-        it("should create section properties with changed options", () => {
-            const properties = new SectionProperties({
-                page: {
-                    margin: {
-                        top: 0,
-                    },
-                },
-            });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
-            expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": { _attr: PAGE_SIZE_DEFAULTS } });
-            expect(tree["w:sectPr"][1]).to.deep.equal({
-                "w:pgMar": {
-                    _attr: {
-                        ...DEFAULT_MARGINS,
-                        "w:top": 0,
-                    },
-                },
-            });
-        });
-
-        it("should create section properties with changed options", () => {
-            const properties = new SectionProperties({
-                page: {
-                    margin: {
-                        bottom: 0,
-                    },
-                },
-            });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
-            expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": { _attr: PAGE_SIZE_DEFAULTS } });
-            expect(tree["w:sectPr"][1]).to.deep.equal({
-                "w:pgMar": {
-                    _attr: {
-                        ...DEFAULT_MARGINS,
-                        "w:bottom": 0,
-                    },
-                },
-            });
-        });
-
-        it("should create section properties with changed options", () => {
-            const properties = new SectionProperties({
-                page: {
-                    size: {
-                        width: 0,
-                        height: 0,
-                        orientation: PageOrientation.LANDSCAPE,
-                    },
-                },
-            });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
-            expect(tree["w:sectPr"][0]).to.deep.equal({
-                "w:pgSz": {
-                    _attr: {
-                        "w:h": 0,
-                        "w:orient": PageOrientation.LANDSCAPE,
-                        "w:w": 0,
-                    },
-                },
-            });
-            expect(tree["w:sectPr"][1]).to.deep.equal({
-                "w:pgMar": {
-                    _attr: DEFAULT_MARGINS,
-                },
-            });
-        });
-
-        it("should create section properties with page borders", () => {
-            const properties = new SectionProperties({
-                page: {
-                    borders: {
-                        pageBorders: {
-                            offsetFrom: PageBorderOffsetFrom.PAGE,
-                        },
-                    },
-                },
-            });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            const pgBorders = tree["w:sectPr"].find((item) => item["w:pgBorders"] !== undefined);
-            expect(pgBorders).to.deep.equal({
-                "w:pgBorders": { _attr: { "w:offsetFrom": "page" } },
-            });
-        });
-
-        it("should create section properties with page number type, but without start attribute", () => {
-            const properties = new SectionProperties({
-                page: {
-                    pageNumbers: {
-                        formatType: NumberFormat.UPPER_ROMAN,
-                    },
-                },
-            });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            const pgNumType = tree["w:sectPr"].find((item) => item["w:pgNumType"] !== undefined);
-            expect(pgNumType).to.deep.equal({
-                "w:pgNumType": { _attr: { "w:fmt": "upperRoman" } },
-            });
-        });
-
-        it("should create section properties with a page number type by default", () => {
-            const properties = new SectionProperties({});
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            const pgNumType = tree["w:sectPr"].find((item) => item["w:pgNumType"] !== undefined);
-            expect(pgNumType).to.deep.equal({ "w:pgNumType": { _attr: {} } });
-        });
-
-        it("should create section properties with section type", () => {
-            const properties = new SectionProperties({
-                type: SectionType.CONTINUOUS,
-            });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            const type = tree["w:sectPr"].find((item) => item["w:type"] !== undefined);
-            expect(type).to.deep.equal({
-                "w:type": { _attr: { "w:val": "continuous" } },
-            });
-        });
-
-        it("should create section properties line number type", () => {
-            const properties = new SectionProperties({
-                lineNumbers: {
-                    countBy: 2,
-                    start: 2,
-                    restart: LineNumberRestartFormat.CONTINUOUS,
-                    distance: 4,
-                },
-            });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            const type = tree["w:sectPr"].find((item) => item["w:lnNumType"] !== undefined);
-            expect(type).to.deep.equal({
-                "w:lnNumType": { _attr: { "w:countBy": 2, "w:distance": 4, "w:restart": "continuous", "w:start": 2 } },
-            });
-        });
-
-        it("should create section properties with text flow direction", () => {
-            const properties = new SectionProperties({
-                page: {
-                    textDirection: PageTextDirectionType.TOP_TO_BOTTOM_RIGHT_TO_LEFT,
-                },
-            });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
-            const type = tree["w:sectPr"].find((item) => item["w:textDirection"] !== undefined);
-            expect(type).to.deep.equal({
-                "w:textDirection": { _attr: { "w:val": "tbRl" } },
-            });
-        });
-    });
-});

package/src/file/document/body/section-properties/section-properties.ts

@@ -1,196 +0,0 @@
-// http://officeopenxml.com/WPsection.php
-// tslint:disable: no-unnecessary-initializer
-
-import { FooterWrapper } from "@file/footer-wrapper";
-import { HeaderWrapper } from "@file/header-wrapper";
-import { VerticalAlign, VerticalAlignElement } from "@file/vertical-align";
-import { OnOffElement, XmlComponent } from "@file/xml-components";
-import { PositiveUniversalMeasure, UniversalMeasure } from "@util/values";
-
-import { HeaderFooterReference, HeaderFooterReferenceType, HeaderFooterType } from "./properties/header-footer-reference";
-import { Columns, IColumnsAttributes } from "./properties/columns";
-import { DocumentGrid, IDocGridAttributesProperties } from "./properties/doc-grid";
-import { ILineNumberAttributes, LineNumberType } from "./properties/line-number";
-import { IPageBordersOptions, PageBorders } from "./properties/page-borders";
-import { IPageMarginAttributes, PageMargin } from "./properties/page-margin";
-import { IPageNumberTypeAttributes, PageNumberType } from "./properties/page-number";
-import { IPageSizeAttributes, PageOrientation, PageSize } from "./properties/page-size";
-import { PageTextDirection, PageTextDirectionType } from "./properties/page-text-direction";
-import { SectionType, Type } from "./properties/section-type";
-
-export interface IHeaderFooterGroup<T> {
-    readonly default?: T;
-    readonly first?: T;
-    readonly even?: T;
-}
-
-export interface ISectionPropertiesOptions {
-    readonly page?: {
-        readonly size?: IPageSizeAttributes;
-        readonly margin?: IPageMarginAttributes;
-        readonly pageNumbers?: IPageNumberTypeAttributes;
-        readonly borders?: IPageBordersOptions;
-        readonly textDirection?: PageTextDirectionType;
-    };
-    readonly grid?: IDocGridAttributesProperties;
-    readonly headerWrapperGroup?: IHeaderFooterGroup<HeaderWrapper>;
-    readonly footerWrapperGroup?: IHeaderFooterGroup<FooterWrapper>;
-    readonly lineNumbers?: ILineNumberAttributes;
-    readonly titlePage?: boolean;
-    readonly verticalAlign?: VerticalAlign;
-    readonly column?: IColumnsAttributes;
-    readonly type?: SectionType;
-}
-
-// <xsd:complexType name="CT_SectPr">
-//     <xsd:sequence>
-//         <xsd:group ref="EG_HdrFtrReferences" minOccurs="0" maxOccurs="6"/>
-//         <xsd:group ref="EG_SectPrContents" minOccurs="0"/>
-//         <xsd:element name="sectPrChange" type="CT_SectPrChange" minOccurs="0"/>
-//     </xsd:sequence>
-//     <xsd:attributeGroup ref="AG_SectPrAttributes"/>
-// </xsd:complexType>
-
-// <xsd:group name="EG_SectPrContents">
-// <xsd:sequence>
-//   <xsd:element name="footnotePr" type="CT_FtnProps" minOccurs="0"/>
-//   <xsd:element name="endnotePr" type="CT_EdnProps" minOccurs="0"/>
-//   <xsd:element name="type" type="CT_SectType" minOccurs="0"/>
-//   <xsd:element name="pgSz" type="CT_PageSz" minOccurs="0"/>
-//   <xsd:element name="pgMar" type="CT_PageMar" minOccurs="0"/>
-//   <xsd:element name="paperSrc" type="CT_PaperSource" minOccurs="0"/>
-//   <xsd:element name="pgBorders" type="CT_PageBorders" minOccurs="0"/>
-//   <xsd:element name="lnNumType" type="CT_LineNumber" minOccurs="0"/>
-//   <xsd:element name="pgNumType" type="CT_PageNumber" minOccurs="0"/>
-//   <xsd:element name="cols" type="CT_Columns" minOccurs="0"/>
-//   <xsd:element name="formProt" type="CT_OnOff" minOccurs="0"/>
-//   <xsd:element name="vAlign" type="CT_VerticalJc" minOccurs="0"/>
-//   <xsd:element name="noEndnote" type="CT_OnOff" minOccurs="0"/>
-//   <xsd:element name="titlePg" type="CT_OnOff" minOccurs="0"/>
-//   <xsd:element name="textDirection" type="CT_TextDirection" minOccurs="0"/>
-//   <xsd:element name="bidi" type="CT_OnOff" minOccurs="0"/>
-//   <xsd:element name="rtlGutter" type="CT_OnOff" minOccurs="0"/>
-//   <xsd:element name="docGrid" type="CT_DocGrid" minOccurs="0"/>
-//   <xsd:element name="printerSettings" type="CT_Rel" minOccurs="0"/>
-// </xsd:sequence>
-// </xsd:group>
-
-export const sectionMarginDefaults = {
-    TOP: "1in" as UniversalMeasure,
-    RIGHT: "1in" as PositiveUniversalMeasure,
-    BOTTOM: "1in" as UniversalMeasure,
-    LEFT: "1in" as PositiveUniversalMeasure,
-    HEADER: 708,
-    FOOTER: 708,
-    GUTTER: 0,
-};
-
-export const sectionPageSizeDefaults = {
-    WIDTH: 11906,
-    HEIGHT: 16838,
-    ORIENTATION: PageOrientation.PORTRAIT,
-};
-
-export class SectionProperties extends XmlComponent {
-    public constructor({
-        page: {
-            size: {
-                width = sectionPageSizeDefaults.WIDTH,
-                height = sectionPageSizeDefaults.HEIGHT,
-                orientation = sectionPageSizeDefaults.ORIENTATION,
-            } = {},
-            margin: {
-                top = sectionMarginDefaults.TOP,
-                right = sectionMarginDefaults.RIGHT,
-                bottom = sectionMarginDefaults.BOTTOM,
-                left = sectionMarginDefaults.LEFT,
-                header = sectionMarginDefaults.HEADER,
-                footer = sectionMarginDefaults.FOOTER,
-                gutter = sectionMarginDefaults.GUTTER,
-            } = {},
-            pageNumbers = {},
-            borders,
-            textDirection,
-        } = {},
-        grid: { linePitch = 360, charSpace, type: gridType } = {},
-        headerWrapperGroup = {},
-        footerWrapperGroup = {},
-        lineNumbers,
-        titlePage,
-        verticalAlign,
-        column,
-        type,
-    }: ISectionPropertiesOptions = {}) {
-        super("w:sectPr");
-
-        this.addHeaderFooterGroup(HeaderFooterType.HEADER, headerWrapperGroup);
-        this.addHeaderFooterGroup(HeaderFooterType.FOOTER, footerWrapperGroup);
-
-        if (type) {
-            this.root.push(new Type(type));
-        }
-
-        this.root.push(new PageSize(width, height, orientation));
-        this.root.push(new PageMargin(top, right, bottom, left, header, footer, gutter));
-
-        if (borders) {
-            this.root.push(new PageBorders(borders));
-        }
-
-        if (lineNumbers) {
-            this.root.push(new LineNumberType(lineNumbers));
-        }
-
-        this.root.push(new PageNumberType(pageNumbers));
-
-        if (column) {
-            this.root.push(new Columns(column));
-        }
-
-        if (verticalAlign) {
-            this.root.push(new VerticalAlignElement(verticalAlign));
-        }
-
-        if (titlePage !== undefined) {
-            this.root.push(new OnOffElement("w:titlePg", titlePage));
-        }
-
-        if (textDirection) {
-            this.root.push(new PageTextDirection(textDirection));
-        }
-
-        this.root.push(new DocumentGrid(linePitch, charSpace, gridType));
-    }
-
-    private addHeaderFooterGroup(
-        type: HeaderFooterType,
-        group: IHeaderFooterGroup<HeaderWrapper> | IHeaderFooterGroup<FooterWrapper>,
-    ): void {
-        if (group.default) {
-            this.root.push(
-                new HeaderFooterReference(type, {
-                    type: HeaderFooterReferenceType.DEFAULT,
-                    id: group.default.View.ReferenceId,
-                }),
-            );
-        }
-
-        if (group.first) {
-            this.root.push(
-                new HeaderFooterReference(type, {
-                    type: HeaderFooterReferenceType.FIRST,
-                    id: group.first.View.ReferenceId,
-                }),
-            );
-        }
-
-        if (group.even) {
-            this.root.push(
-                new HeaderFooterReference(type, {
-                    type: HeaderFooterReferenceType.EVEN,
-                    id: group.even.View.ReferenceId,
-                }),
-            );
-        }
-    }
-}

package/src/file/document/document-attributes.ts

@@ -1,89 +0,0 @@
-import { XmlAttributeComponent } from "@file/xml-components";
-
-/* cSpell:disable */
-export interface IDocumentAttributesProperties {
-    readonly wpc?: string;
-    readonly mc?: string;
-    readonly o?: string;
-    readonly r?: string;
-    readonly m?: string;
-    readonly v?: string;
-    readonly wp14?: string;
-    readonly wp?: string;
-    readonly w10?: string;
-    readonly w?: string;
-    readonly w14?: string;
-    readonly w15?: string;
-    readonly wpg?: string;
-    readonly wpi?: string;
-    readonly wne?: string;
-    readonly wps?: string;
-    readonly Ignorable?: string;
-    readonly cp?: string;
-    readonly dc?: string;
-    readonly dcterms?: string;
-    readonly dcmitype?: string;
-    readonly xsi?: string;
-    readonly type?: string;
-    readonly cx?: string;
-    readonly cx1?: string;
-    readonly cx2?: string;
-    readonly cx3?: string;
-    readonly cx4?: string;
-    readonly cx5?: string;
-    readonly cx6?: string;
-    readonly cx7?: string;
-    readonly cx8?: string;
-    readonly aink?: string;
-    readonly am3d?: string;
-    readonly w16cex?: string;
-    readonly w16cid?: string;
-    readonly w16?: string;
-    readonly w16sdtdh?: string;
-    readonly w16se?: string;
-}
-/* cSpell:enable */
-
-export class DocumentAttributes extends XmlAttributeComponent<IDocumentAttributesProperties> {
-    protected readonly xmlKeys = {
-        wpc: "xmlns:wpc",
-        mc: "xmlns:mc",
-        o: "xmlns:o",
-        r: "xmlns:r",
-        m: "xmlns:m",
-        v: "xmlns:v",
-        wp14: "xmlns:wp14",
-        wp: "xmlns:wp",
-        w10: "xmlns:w10",
-        w: "xmlns:w",
-        w14: "xmlns:w14",
-        w15: "xmlns:w15",
-        wpg: "xmlns:wpg",
-        wpi: "xmlns:wpi",
-        wne: "xmlns:wne",
-        wps: "xmlns:wps",
-        Ignorable: "mc:Ignorable",
-        cp: "xmlns:cp",
-        dc: "xmlns:dc",
-        dcterms: "xmlns:dcterms",
-        dcmitype: "xmlns:dcmitype",
-        xsi: "xmlns:xsi",
-        type: "xsi:type",
-        cx: "xmlns:cx",
-        cx1: "xmlns:cx1",
-        cx2: "xmlns:cx2",
-        cx3: "xmlns:cx3",
-        cx4: "xmlns:cx4",
-        cx5: "xmlns:cx5",
-        cx6: "xmlns:cx6",
-        cx7: "xmlns:cx7",
-        cx8: "xmlns:cx8",
-        aink: "xmlns:aink",
-        am3d: "xmlns:am3d",
-        w16cex: "xmlns:w16cex",
-        w16cid: "xmlns:w16cid",
-        w16: "xmlns:w16",
-        w16sdtdh: "xmlns:w16sdtdh",
-        w16se: "xmlns:w16se",
-    };
-}

package/src/file/document/document-background/document-background.spec.ts

@@ -1,51 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { DocumentBackground } from "./document-background";
-
-describe("DocumentBackground", () => {
-    describe("#constructor()", () => {
-        it("should create a DocumentBackground with no options", () => {
-            const documentBackground = new DocumentBackground({});
-            const tree = new Formatter().format(documentBackground);
-            expect(tree).to.deep.equal({
-                "w:background": {
-                    _attr: {},
-                },
-            });
-        });
-
-        it("should create a DocumentBackground with no options and set color to value", () => {
-            const documentBackground = new DocumentBackground({ color: "ffff00" });
-            const tree = new Formatter().format(documentBackground);
-            expect(tree).to.deep.equal({
-                "w:background": {
-                    _attr: {
-                        "w:color": "ffff00",
-                    },
-                },
-            });
-        });
-
-        it("should create a DocumentBackground with no options and set other values", () => {
-            const documentBackground = new DocumentBackground({
-                color: "ffff00",
-                themeColor: "test",
-                themeShade: "0A",
-                themeTint: "0B",
-            });
-            const tree = new Formatter().format(documentBackground);
-            expect(tree).to.deep.equal({
-                "w:background": {
-                    _attr: {
-                        "w:color": "ffff00",
-                        "w:themeColor": "test",
-                        "w:themeShade": "0A",
-                        "w:themeTint": "0B",
-                    },
-                },
-            });
-        });
-    });
-});