docx 7.8.1 → 8.0.0

package/src/file/file.ts

@@ -4,22 +4,19 @@ import { CoreProperties, IPropertiesOptions } from "./core-properties";
 import { CustomProperties } from "./custom-properties";
 import { DocumentWrapper } from "./document-wrapper";
 import { HeaderFooterReferenceType, ISectionPropertiesOptions } from "./document/body/section-properties";
-import { IFileProperties } from "./file-properties";
 import { FooterWrapper, IDocumentFooter } from "./footer-wrapper";
 import { FootnotesWrapper } from "./footnotes-wrapper";
 import { Footer, Header } from "./header";
 import { HeaderWrapper, IDocumentHeader } from "./header-wrapper";
 import { Media } from "./media";
 import { Numbering } from "./numbering";
-import { Paragraph } from "./paragraph";
 import { Comments } from "./paragraph/run/comment-run";
 import { Relationships } from "./relationships";
 import { Settings } from "./settings";
 import { Styles } from "./styles";
 import { ExternalStylesFactory } from "./styles/external-styles-factory";
 import { DefaultStylesFactory } from "./styles/factory";
-import { Table } from "./table";
-import { TableOfContents } from "./table-of-contents";
+import { FileChild } from "./file-child";
 
 export interface ISectionOptions {
     readonly headers?: {
@@ -33,7 +30,7 @@ export interface ISectionOptions {
         readonly even?: Footer;
     };
     readonly properties?: ISectionPropertiesOptions;
-    readonly children: readonly (Paragraph | Table | TableOfContents)[];
+    readonly children: readonly FileChild[];
 }
 
 export class File {
@@ -57,7 +54,7 @@ export class File {
     private readonly styles: Styles;
     private readonly comments: Comments;
 
-    public constructor(options: IPropertiesOptions, fileProperties: IFileProperties = {}) {
+    public constructor(options: IPropertiesOptions) {
         this.coreProperties = new CoreProperties({
             ...options,
             creator: options.creator ?? "Un-named",
@@ -82,20 +79,9 @@ export class File {
             updateFields: options.features?.updateFields,
         });
 
-        this.media = fileProperties.template && fileProperties.template.media ? fileProperties.template.media : new Media();
+        this.media = new Media();
 
-        if (fileProperties.template) {
-            this.currentRelationshipId = fileProperties.template.currentRelationshipId + 1;
-        }
-
-        // set up styles
-        if (fileProperties.template && options.externalStyles) {
-            throw Error("can not use both template and external styles");
-        }
-        if (fileProperties.template && fileProperties.template.styles) {
-            const stylesFactory = new ExternalStylesFactory();
-            this.styles = stylesFactory.newInstance(fileProperties.template.styles);
-        } else if (options.externalStyles) {
+        if (options.externalStyles) {
             const stylesFactory = new ExternalStylesFactory();
             this.styles = stylesFactory.newInstance(options.externalStyles);
         } else if (options.styles) {
@@ -112,18 +98,6 @@ export class File {
 
         this.addDefaultRelationships();
 
-        if (fileProperties.template && fileProperties.template.headers) {
-            for (const templateHeader of fileProperties.template.headers) {
-                this.addHeaderToDocument(templateHeader.header, templateHeader.type);
-            }
-        }
-
-        if (fileProperties.template && fileProperties.template.footers) {
-            for (const templateFooter of fileProperties.template.footers) {
-                this.addFooterToDocument(templateFooter.footer, templateFooter.type);
-            }
-        }
-
         for (const section of options.sections) {
             this.addSection(section);
         }

package/src/file/index.ts

@@ -1,7 +1,6 @@
 export * from "./paragraph";
 export * from "./table";
 export * from "./file";
-export * from "./file-properties";
 export * from "./numbering";
 export * from "./media";
 export * from "./drawing";

package/src/file/media/media.spec.ts

@@ -15,96 +15,30 @@ describe("Media", () => {
         (convenienceFunctions.uniqueId as SinonStub).restore();
     });
 
-    describe("#addMedia", () => {
-        it("should add media", () => {
-            const image = new Media().addMedia("", {
-                width: 100,
-                height: 100,
-            });
-            expect(image.fileName).to.equal("test.png");
-            expect(image.transformation).to.deep.equal({
-                pixels: {
-                    x: 100,
-                    y: 100,
-                },
-                flip: undefined,
-                emus: {
-                    x: 952500,
-                    y: 952500,
-                },
-                rotation: undefined,
-            });
-        });
-
-        it("should return UInt8Array if atob is present", () => {
-            // eslint-disable-next-line functional/immutable-data
-            global.atob = () => "atob result";
-
-            const image = new Media().addMedia("", {
-                width: 100,
-                height: 100,
-            });
-            expect(image.stream).to.be.an.instanceof(Uint8Array);
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, functional/immutable-data
-            (global as any).atob = undefined;
-        });
-
-        it("should use data as is if its not a string", () => {
-            // eslint-disable-next-line  functional/immutable-data
-            global.atob = () => "atob result";
-
-            const image = new Media().addMedia(Buffer.from(""), {
-                width: 100,
-                height: 100,
-            });
-            expect(image.stream).to.be.an.instanceof(Uint8Array);
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, functional/immutable-data
-            (global as any).atob = undefined;
-        });
-    });
-
-    describe("#addImage", () => {
-        it("should add media", () => {
+    describe("#Array", () => {
+        it("Get images as array", () => {
             const media = new Media();
-            media.addMedia("", {
-                width: 100,
-                height: 100,
-            });
 
             media.addImage("test2.png", {
                 stream: Buffer.from(""),
-                fileName: "",
+                fileName: "test.png",
                 transformation: {
                     pixels: {
-                        x: Math.round(1),
-                        y: Math.round(1),
+                        x: Math.round(100),
+                        y: Math.round(100),
+                    },
+                    flip: {
+                        vertical: true,
+                        horizontal: true,
                     },
                     emus: {
                         x: Math.round(1 * 9525),
                         y: Math.round(1 * 9525),
                     },
+                    rotation: 90,
                 },
             });
 
-            expect(media.Array).to.be.lengthOf(2);
-        });
-    });
-
-    describe("#Array", () => {
-        it("Get images as array", () => {
-            const media = new Media();
-            media.addMedia("", {
-                width: 100,
-                height: 100,
-                flip: {
-                    vertical: true,
-                    horizontal: true,
-                },
-                rotation: 90,
-            });
-
             const array = media.Array;
             expect(array).to.be.an.instanceof(Array);
             expect(array.length).to.equal(1);
@@ -121,10 +55,10 @@ describe("Media", () => {
                     horizontal: true,
                 },
                 emus: {
-                    x: 952500,
-                    y: 952500,
+                    x: 9525,
+                    y: 9525,
                 },
-                rotation: 5400000,
+                rotation: 90,
             });
         });
     });

package/src/file/media/media.ts

@@ -1,5 +1,3 @@
-import { uniqueId } from "@util/convenience-functions";
-
 import { IMediaData } from "./data";
 
 export interface IMediaTransformation {
@@ -20,33 +18,6 @@ export class Media {
         this.map = new Map<string, IMediaData>();
     }
 
-    public addMedia(data: Buffer | string | Uint8Array | ArrayBuffer, transformation: IMediaTransformation): IMediaData {
-        const key = `${uniqueId()}.png`;
-
-        const newData = typeof data === "string" ? this.convertDataURIToBinary(data) : data;
-
-        const imageData: IMediaData = {
-            stream: newData,
-            fileName: key,
-            transformation: {
-                pixels: {
-                    x: Math.round(transformation.width),
-                    y: Math.round(transformation.height),
-                },
-                emus: {
-                    x: Math.round(transformation.width * 9525),
-                    y: Math.round(transformation.height * 9525),
-                },
-                flip: transformation.flip,
-                rotation: transformation.rotation ? transformation.rotation * 60000 : undefined,
-            },
-        };
-
-        this.map.set(key, imageData);
-
-        return imageData;
-    }
-
     public addImage(key: string, mediaData: IMediaData): void {
         this.map.set(key, mediaData);
     }
@@ -54,24 +25,4 @@ export class Media {
     public get Array(): readonly IMediaData[] {
         return Array.from(this.map.values());
     }
-
-    private convertDataURIToBinary(dataURI: string): Uint8Array {
-        // https://gist.github.com/borismus/1032746
-        // https://github.com/mafintosh/base64-to-uint8array
-        const BASE64_MARKER = ";base64,";
-
-        const base64Index = dataURI.indexOf(BASE64_MARKER) + BASE64_MARKER.length;
-
-        if (typeof atob === "function") {
-            return new Uint8Array(
-                atob(dataURI.substring(base64Index))
-                    .split("")
-                    .map((c) => c.charCodeAt(0)),
-            );
-        } else {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
-            const b = require("buf" + "fer");
-            return new b.Buffer(dataURI, "base64");
-        }
-    }
 }

package/src/file/numbering/concrete-numbering.spec.ts

@@ -12,9 +12,11 @@ describe("ConcreteNumbering", () => {
                 abstractNumId: 1,
                 reference: "1",
                 instance: 0,
-                overrideLevel: {
-                    num: 3,
-                },
+                overrideLevels: [
+                    {
+                        num: 3,
+                    },
+                ],
             });
 
             const tree = new Formatter().format(concreteNumbering);
@@ -44,16 +46,113 @@ describe("ConcreteNumbering", () => {
             });
         });
 
+        it("sets a new override level for two different level numbers", () => {
+            const concreteNumbering = new ConcreteNumbering({
+                numId: 0,
+                abstractNumId: 1,
+                reference: "1",
+                instance: 0,
+                overrideLevels: [{ num: 3 }, { num: 5 }],
+            });
+
+            const tree = new Formatter().format(concreteNumbering);
+
+            expect(tree).to.deep.equal({
+                "w:num": [
+                    {
+                        _attr: {
+                            "w:numId": 0,
+                        },
+                    },
+                    {
+                        "w:abstractNumId": {
+                            _attr: {
+                                "w:val": 1,
+                            },
+                        },
+                    },
+                    {
+                        "w:lvlOverride": {
+                            _attr: {
+                                "w:ilvl": 3,
+                            },
+                        },
+                    },
+                    {
+                        "w:lvlOverride": {
+                            _attr: {
+                                "w:ilvl": 5,
+                            },
+                        },
+                    },
+                ],
+            });
+        });
+
         it("sets the startOverride element if start is given", () => {
             const concreteNumbering = new ConcreteNumbering({
                 numId: 0,
                 abstractNumId: 1,
                 reference: "1",
                 instance: 0,
-                overrideLevel: {
-                    num: 1,
-                    start: 9,
-                },
+                overrideLevels: [
+                    {
+                        num: 1,
+                        start: 9,
+                    },
+                ],
+            });
+            const tree = new Formatter().format(concreteNumbering);
+            expect(tree).to.deep.equal({
+                "w:num": [
+                    {
+                        _attr: {
+                            "w:numId": 0,
+                        },
+                    },
+                    {
+                        "w:abstractNumId": {
+                            _attr: {
+                                "w:val": 1,
+                            },
+                        },
+                    },
+                    {
+                        "w:lvlOverride": [
+                            {
+                                _attr: {
+                                    "w:ilvl": 1,
+                                },
+                            },
+                            {
+                                "w:startOverride": {
+                                    _attr: {
+                                        "w:val": 9,
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+
+        it("sets the startOverride element for several levels if start is given", () => {
+            const concreteNumbering = new ConcreteNumbering({
+                numId: 0,
+                abstractNumId: 1,
+                reference: "1",
+                instance: 0,
+                overrideLevels: [
+                    {
+                        num: 1,
+                        start: 9,
+                    },
+                    {
+                        num: 3,
+                        start: 10,
+                    },
+                ],
             });
             const tree = new Formatter().format(concreteNumbering);
             expect(tree).to.deep.equal({
@@ -86,6 +185,80 @@ describe("ConcreteNumbering", () => {
                             },
                         ],
                     },
+                    {
+                        "w:lvlOverride": [
+                            {
+                                _attr: {
+                                    "w:ilvl": 3,
+                                },
+                            },
+                            {
+                                "w:startOverride": {
+                                    _attr: {
+                                        "w:val": 10,
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+
+        it("Mix of overrideLevels with start and without", () => {
+            const concreteNumbering = new ConcreteNumbering({
+                numId: 0,
+                abstractNumId: 1,
+                reference: "1",
+                instance: 0,
+                overrideLevels: [
+                    {
+                        num: 1,
+                        start: 9,
+                    },
+                    {
+                        num: 3,
+                    },
+                ],
+            });
+            const tree = new Formatter().format(concreteNumbering);
+            expect(tree).to.deep.equal({
+                "w:num": [
+                    {
+                        _attr: {
+                            "w:numId": 0,
+                        },
+                    },
+                    {
+                        "w:abstractNumId": {
+                            _attr: {
+                                "w:val": 1,
+                            },
+                        },
+                    },
+                    {
+                        "w:lvlOverride": [
+                            {
+                                _attr: {
+                                    "w:ilvl": 1,
+                                },
+                            },
+                            {
+                                "w:startOverride": {
+                                    _attr: {
+                                        "w:val": 9,
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        "w:lvlOverride": {
+                            _attr: {
+                                "w:ilvl": 3,
+                            },
+                        },
+                    },
                 ],
             });
         });
@@ -96,9 +269,11 @@ describe("ConcreteNumbering", () => {
                 abstractNumId: 1,
                 reference: "1",
                 instance: 0,
-                overrideLevel: {
-                    num: 1,
-                },
+                overrideLevels: [
+                    {
+                        num: 1,
+                    },
+                ],
             });
             const tree = new Formatter().format(concreteNumbering);
             expect(tree).to.deep.equal({

package/src/file/numbering/num.ts

@@ -18,15 +18,17 @@ class NumAttributes extends XmlAttributeComponent<{
     protected readonly xmlKeys = { numId: "w:numId" };
 }
 
+interface IOverrideLevel {
+    readonly num: number;
+    readonly start?: number;
+}
+
 export interface IConcreteNumberingOptions {
     readonly numId: number;
     readonly abstractNumId: number;
     readonly reference: string;
     readonly instance: number;
-    readonly overrideLevel?: {
-        readonly num: number;
-        readonly start?: number;
-    };
+    readonly overrideLevels?: readonly IOverrideLevel[];
 }
 
 // <xsd:complexType name="CT_Numbering">
@@ -60,8 +62,10 @@ export class ConcreteNumbering extends XmlComponent {
 
         this.root.push(new AbstractNumId(decimalNumber(options.abstractNumId)));
 
-        if (options.overrideLevel) {
-            this.root.push(new LevelOverride(options.overrideLevel.num, options.overrideLevel.start));
+        if (options.overrideLevels && options.overrideLevels.length) {
+            for (const level of options.overrideLevels) {
+                this.root.push(new LevelOverride(level.num, level.start));
+            }
         }
     }
 }

package/src/file/numbering/numbering.ts

@@ -164,10 +164,12 @@ export class Numbering extends XmlComponent {
                 abstractNumId: abstractNumbering.id,
                 reference: "default-bullet-numbering",
                 instance: 0,
-                overrideLevel: {
-                    num: 0,
-                    start: 1,
-                },
+                overrideLevels: [
+                    {
+                        num: 0,
+                        start: 1,
+                    },
+                ],
             }),
         );
 

package/src/file/paragraph/formatting/indent.ts

@@ -1,39 +1,14 @@
 // http://officeopenxml.com/WPindentation.php
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-import { signedTwipsMeasureValue, twipsMeasureValue } from "@util/values";
+import { NextAttributeComponent, XmlComponent } from "@file/xml-components";
+import { PositiveUniversalMeasure, signedTwipsMeasureValue, twipsMeasureValue, UniversalMeasure } from "@util/values";
 
 export interface IIndentAttributesProperties {
-    readonly start?: number | string;
-    readonly end?: number | string;
-    readonly left?: number | string;
-    readonly right?: number | string;
-    readonly hanging?: number | string;
-    readonly firstLine?: number | string;
-}
-
-// <xsd:complexType name="CT_Ind">
-//     <xsd:attribute name="start" type="ST_SignedTwipsMeasure" use="optional"/>
-//     <xsd:attribute name="startChars" type="ST_DecimalNumber" use="optional"/>
-//     <xsd:attribute name="end" type="ST_SignedTwipsMeasure" use="optional"/>
-//     <xsd:attribute name="endChars" type="ST_DecimalNumber" use="optional"/>
-//     <xsd:attribute name="left" type="ST_SignedTwipsMeasure" use="optional"/>
-//     <xsd:attribute name="leftChars" type="ST_DecimalNumber" use="optional"/>
-//     <xsd:attribute name="right" type="ST_SignedTwipsMeasure" use="optional"/>
-//     <xsd:attribute name="rightChars" type="ST_DecimalNumber" use="optional"/>
-//     <xsd:attribute name="hanging" type="s:ST_TwipsMeasure" use="optional"/>
-//     <xsd:attribute name="hangingChars" type="ST_DecimalNumber" use="optional"/>
-//     <xsd:attribute name="firstLine" type="s:ST_TwipsMeasure" use="optional"/>
-//     <xsd:attribute name="firstLineChars" type="ST_DecimalNumber" use="optional"/>
-// </xsd:complexType>
-class IndentAttributes extends XmlAttributeComponent<IIndentAttributesProperties> {
-    protected readonly xmlKeys = {
-        start: "w:start",
-        end: "w:end",
-        left: "w:left",
-        right: "w:right",
-        hanging: "w:hanging",
-        firstLine: "w:firstLine",
-    };
+    readonly start?: number | UniversalMeasure;
+    readonly end?: number | UniversalMeasure;
+    readonly left?: number | UniversalMeasure;
+    readonly right?: number | UniversalMeasure;
+    readonly hanging?: number | PositiveUniversalMeasure;
+    readonly firstLine?: number | PositiveUniversalMeasure;
 }
 
 // <xsd:complexType name="CT_PPrBase">
@@ -43,14 +18,53 @@ class IndentAttributes extends XmlAttributeComponent<IIndentAttributesProperties
 export class Indent extends XmlComponent {
     public constructor({ start, end, left, right, hanging, firstLine }: IIndentAttributesProperties) {
         super("w:ind");
+        // <xsd:complexType name="CT_Ind">
+        //     <xsd:attribute name="start" type="ST_SignedTwipsMeasure" use="optional"/>
+        //     <xsd:attribute name="startChars" type="ST_DecimalNumber" use="optional"/>
+        //     <xsd:attribute name="end" type="ST_SignedTwipsMeasure" use="optional"/>
+        //     <xsd:attribute name="endChars" type="ST_DecimalNumber" use="optional"/>
+        //     <xsd:attribute name="left" type="ST_SignedTwipsMeasure" use="optional"/>
+        //     <xsd:attribute name="leftChars" type="ST_DecimalNumber" use="optional"/>
+        //     <xsd:attribute name="right" type="ST_SignedTwipsMeasure" use="optional"/>
+        //     <xsd:attribute name="rightChars" type="ST_DecimalNumber" use="optional"/>
+        //     <xsd:attribute name="hanging" type="s:ST_TwipsMeasure" use="optional"/>
+        //     <xsd:attribute name="hangingChars" type="ST_DecimalNumber" use="optional"/>
+        //     <xsd:attribute name="firstLine" type="s:ST_TwipsMeasure" use="optional"/>
+        //     <xsd:attribute name="firstLineChars" type="ST_DecimalNumber" use="optional"/>
+        // </xsd:complexType>
         this.root.push(
-            new IndentAttributes({
-                start: start === undefined ? undefined : signedTwipsMeasureValue(start),
-                end: end === undefined ? undefined : signedTwipsMeasureValue(end),
-                left: left === undefined ? undefined : signedTwipsMeasureValue(left),
-                right: right === undefined ? undefined : signedTwipsMeasureValue(right),
-                hanging: hanging === undefined ? undefined : twipsMeasureValue(hanging),
-                firstLine: firstLine === undefined ? undefined : twipsMeasureValue(firstLine),
+            new NextAttributeComponent<{
+                readonly start?: number | UniversalMeasure;
+                readonly end?: number | UniversalMeasure;
+                readonly left?: number | UniversalMeasure;
+                readonly right?: number | UniversalMeasure;
+                readonly hanging?: number | PositiveUniversalMeasure;
+                readonly firstLine?: number | PositiveUniversalMeasure;
+            }>({
+                start: {
+                    key: "w:start",
+                    value: start === undefined ? undefined : signedTwipsMeasureValue(start),
+                },
+                end: {
+                    key: "w:end",
+                    value: end === undefined ? undefined : signedTwipsMeasureValue(end),
+                },
+                left: {
+                    key: "w:left",
+                    value: left === undefined ? undefined : signedTwipsMeasureValue(left),
+                },
+                right: {
+                    key: "w:right",
+                    value: right === undefined ? undefined : signedTwipsMeasureValue(right),
+                },
+                hanging: {
+                    key: "w:hanging",
+                    value: hanging === undefined ? undefined : twipsMeasureValue(hanging),
+                },
+                firstLine: {
+                    key: "w:firstLine",
+                    value: firstLine === undefined ? undefined : twipsMeasureValue(firstLine),
+                },
             }),
         );
     }

package/src/file/paragraph/paragraph.spec.ts

@@ -954,6 +954,7 @@ describe("Paragraph", () => {
             paragraph.prepForXml({
                 viewWrapper: viewWrapperMock,
                 file: file,
+                stack: [],
             });
             const tree = new Formatter().format(paragraph);
             expect(tree).to.deep.equal({