smartyellow/docx-js
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Optimize XML output by properly constructing objects to send to the xml library so that it can produce proper empty elements.

Browse Source 
Rework the way attributes are stored in ImportedXmlComponent to match elsewhere (required allowing for a null xmlKeys in the XmlAttributeComponent interface).
Rework the way paragraphs get added to the end of table cells if needed.
The goal in both reworks is to not mess around with the objects output from `prepForXml` if we can avoid it.
Made the output of RunProperties, ParagraphProperties, TableCellProperties, TableRowProperties, and TableProperties all optional based on whether they contain any attributes or children.  Changed code in PageBorders, TableCellMargin, and TableCellBorders that implemented this same thing by overriding `prepForXml` so that it uses the new XmlComponent subclass instead.
Removed commented out code that attempted to fix-up XML output and make proper empty elements.
Fixed all affected tests.
Turn off `no-null-keyword` in the linter as we need to use null to signal to the `xml` library to create an empty element with no attributes (`undefined` will not work in its place).

Fixes #306
This commit is contained in:
Bruce Duncan
2019-04-09 05:27:18 -04:00
parent 920bd3c175
commit 816cb54b14
63 changed files with 1210 additions and 1605 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/export/formatter.spec.ts
View File

@ -31,7 +31,7 @@ describe("Formatter", () => {
const paragraph = new file.Paragraph(); const paragraph = new file.Paragraph();
paragraph.addRun(new file.TextRun("test").bold()); paragraph.addRun(new file.TextRun("test").bold());
const newJson = formatter.format(paragraph); const newJson = formatter.format(paragraph);
assert.isDefined(newJson["w:p"][1]["w:r"][0]["w:rPr"][0]["w:b"][0]._attr["w:val"]); assert.isDefined(newJson["w:p"][0]["w:r"][0]["w:rPr"][0]["w:b"]._attr["w:val"]);
}); });
it("should format attributes (rsidSect)", () => { it("should format attributes (rsidSect)", () => {

9
src/export/packer/next-compiler.ts
View File

@ -191,13 +191,4 @@ export class Compiler {
}, },
}; };
} }
/* By default docx collapse empty tags. <a></a> -> <a/>. this function mimic it
so comparing (diff) original docx file and the library output is easier
Currently not used, so commenting out */
// private collapseEmptyTags(xmlData: string): string {
// const regEx = /<(([^ <>]+)[^<>]*)><\/\2>/g;
// const collapsed = xmlData.replace(regEx, "<$1/>");
// return collapsed;
// }
} }

146
src/file/content-types/content-types.spec.ts
View File

@ -20,84 +20,70 @@ describe("ContentTypes", () => {
expect(tree["Types"]).to.be.an.instanceof(Array); expect(tree["Types"]).to.be.an.instanceof(Array);
expect(tree["Types"][0]).to.deep.equal({ _attr: { xmlns: "http://schemas.openxmlformats.org/package/2006/content-types" } }); expect(tree["Types"][0]).to.deep.equal({ _attr: { xmlns: "http://schemas.openxmlformats.org/package/2006/content-types" } });
expect(tree["Types"][1]).to.deep.equal({ Default: [{ _attr: { ContentType: "image/png", Extension: "png" } }] }); expect(tree["Types"][1]).to.deep.equal({ Default: { _attr: { ContentType: "image/png", Extension: "png" } } });
expect(tree["Types"][2]).to.deep.equal({ Default: [{ _attr: { ContentType: "image/jpeg", Extension: "jpeg" } }] }); expect(tree["Types"][2]).to.deep.equal({ Default: { _attr: { ContentType: "image/jpeg", Extension: "jpeg" } } });
expect(tree["Types"][3]).to.deep.equal({ Default: [{ _attr: { ContentType: "image/jpeg", Extension: "jpg" } }] }); expect(tree["Types"][3]).to.deep.equal({ Default: { _attr: { ContentType: "image/jpeg", Extension: "jpg" } } });
expect(tree["Types"][4]).to.deep.equal({ Default: [{ _attr: { ContentType: "image/bmp", Extension: "bmp" } }] }); expect(tree["Types"][4]).to.deep.equal({ Default: { _attr: { ContentType: "image/bmp", Extension: "bmp" } } });
expect(tree["Types"][5]).to.deep.equal({ Default: [{ _attr: { ContentType: "image/gif", Extension: "gif" } }] }); expect(tree["Types"][5]).to.deep.equal({ Default: { _attr: { ContentType: "image/gif", Extension: "gif" } } });
expect(tree["Types"][6]).to.deep.equal({ expect(tree["Types"][6]).to.deep.equal({
Default: [{ _attr: { ContentType: "application/vnd.openxmlformats-package.relationships+xml", Extension: "rels" } }], Default: { _attr: { ContentType: "application/vnd.openxmlformats-package.relationships+xml", Extension: "rels" } },
}); });
expect(tree["Types"][7]).to.deep.equal({ Default: [{ _attr: { ContentType: "application/xml", Extension: "xml" } }] }); expect(tree["Types"][7]).to.deep.equal({ Default: { _attr: { ContentType: "application/xml", Extension: "xml" } } });
expect(tree["Types"][8]).to.deep.equal({ expect(tree["Types"][8]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",
ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml", PartName: "/word/document.xml",
PartName: "/word/document.xml",
},
}, },
], },
}); });
expect(tree["Types"][9]).to.deep.equal({ expect(tree["Types"][9]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml",
ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml", PartName: "/word/styles.xml",
PartName: "/word/styles.xml",
},
}, },
], },
}); });
expect(tree["Types"][10]).to.deep.equal({ expect(tree["Types"][10]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-package.core-properties+xml",
ContentType: "application/vnd.openxmlformats-package.core-properties+xml", PartName: "/docProps/core.xml",
PartName: "/docProps/core.xml",
},
}, },
], },
}); });
expect(tree["Types"][11]).to.deep.equal({ expect(tree["Types"][11]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.extended-properties+xml",
ContentType: "application/vnd.openxmlformats-officedocument.extended-properties+xml", PartName: "/docProps/app.xml",
PartName: "/docProps/app.xml",
},
}, },
], },
}); });
expect(tree["Types"][12]).to.deep.equal({ expect(tree["Types"][12]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml",
ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml", PartName: "/word/numbering.xml",
PartName: "/word/numbering.xml",
},
}, },
], },
}); });
expect(tree["Types"][13]).to.deep.equal({ expect(tree["Types"][13]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml", PartName: "/word/footnotes.xml",
PartName: "/word/footnotes.xml",
},
}, },
], },
}); });
expect(tree["Types"][14]).to.deep.equal({ expect(tree["Types"][14]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml",
ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml", PartName: "/word/settings.xml",
PartName: "/word/settings.xml",
},
}, },
], },
}); });
}); });
}); });
@ -109,25 +95,21 @@ describe("ContentTypes", () => {
const tree = new Formatter().format(contentTypes); const tree = new Formatter().format(contentTypes);
expect(tree["Types"][15]).to.deep.equal({ expect(tree["Types"][15]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml",
ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml", PartName: "/word/footer101.xml",
PartName: "/word/footer101.xml",
},
}, },
], },
}); });
expect(tree["Types"][16]).to.deep.equal({ expect(tree["Types"][16]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml",
ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml", PartName: "/word/footer102.xml",
PartName: "/word/footer102.xml",
},
}, },
], },
}); });
}); });
}); });
@ -139,25 +121,21 @@ describe("ContentTypes", () => {
const tree = new Formatter().format(contentTypes); const tree = new Formatter().format(contentTypes);
expect(tree["Types"][15]).to.deep.equal({ expect(tree["Types"][15]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml",
ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml", PartName: "/word/header201.xml",
PartName: "/word/header201.xml",
},
}, },
], },
}); });
expect(tree["Types"][16]).to.deep.equal({ expect(tree["Types"][16]).to.deep.equal({
Override: [ Override: {
{ _attr: {
_attr: { ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml",
ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml", PartName: "/word/header202.xml",
PartName: "/word/header202.xml",
},
}, },
], },
}); });
}); });
}); });

67
src/file/document/body/body.spec.ts
View File

@ -30,14 +30,14 @@ describe("Body", () => {
const formatted = new Formatter().format(body)["w:body"]; const formatted = new Formatter().format(body)["w:body"];
expect(formatted).to.be.an.instanceof(Array); expect(formatted).to.be.an.instanceof(Array);
const defaultSectionPr = formatted[0]["w:p"][1]["w:pPr"][0]["w:sectPr"]; const defaultSectionPr = formatted[0]["w:p"][0]["w:pPr"][0]["w:sectPr"];
// check that this is the default section and added first in paragraph // check that this is the default section and added first in paragraph
expect(defaultSectionPr[0]).to.deep.equal({ "w:pgSz": [{ _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } }] }); expect(defaultSectionPr[0]).to.deep.equal({ "w:pgSz": { _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } } });
// check for new section (since it's the last one, it's direct child of body) // check for new section (since it's the last one, it's direct child of body)
const newSection = formatted[1]["w:sectPr"]; const newSection = formatted[1]["w:sectPr"];
expect(newSection[0]).to.deep.equal({ "w:pgSz": [{ _attr: { "w:h": 10000, "w:w": 10000, "w:orient": "portrait" } }] }); expect(newSection[0]).to.deep.equal({ "w:pgSz": { _attr: { "w:h": 10000, "w:w": 10000, "w:orient": "portrait" } } });
}); });
it("should add section with default parameters", () => { it("should add section with default parameters", () => {
@ -52,30 +52,27 @@ describe("Body", () => {
"w:body": [ "w:body": [
{ {
"w:p": [ "w:p": [
{ "w:pPr": [] },
{ {
"w:pPr": [ "w:pPr": [
{ {
"w:sectPr": [ "w:sectPr": [
{ "w:pgSz": [{ _attr: { "w:w": 11906, "w:h": 16838, "w:orient": "portrait" } }] }, { "w:pgSz": { _attr: { "w:w": 11906, "w:h": 16838, "w:orient": "portrait" } } },
{ {
"w:pgMar": [ "w:pgMar": {
{ _attr: {
_attr: { "w:top": 1440,
"w:top": 1440, "w:right": 1440,
"w:right": 1440, "w:bottom": 1440,
"w:bottom": 1440, "w:left": 1440,
"w:left": 1440, "w:header": 708,
"w:header": 708, "w:footer": 708,
"w:footer": 708, "w:gutter": 0,
"w:gutter": 0, "w:mirrorMargins": false,
"w:mirrorMargins": false,
},
}, },
], },
}, },
{ "w:cols": [{ _attr: { "w:space": 708 } }] }, { "w:cols": { _attr: { "w:space": 708 } } },
{ "w:docGrid": [{ _attr: { "w:linePitch": 360 } }] }, { "w:docGrid": { _attr: { "w:linePitch": 360 } } },
], ],
}, },
], ],
@ -84,25 +81,23 @@ describe("Body", () => {
}, },
{ {
"w:sectPr": [ "w:sectPr": [
{ "w:pgSz": [{ _attr: { "w:w": 10000, "w:h": 10000, "w:orient": "portrait" } }] }, { "w:pgSz": { _attr: { "w:w": 10000, "w:h": 10000, "w:orient": "portrait" } } },
{ {
"w:pgMar": [ "w:pgMar": {
{ _attr: {
_attr: { "w:top": 1440,
"w:top": 1440, "w:right": 1440,
"w:right": 1440, "w:bottom": 1440,
"w:bottom": 1440, "w:left": 1440,
"w:left": 1440, "w:header": 708,
"w:header": 708, "w:footer": 708,
"w:footer": 708, "w:gutter": 0,
"w:gutter": 0, "w:mirrorMargins": false,
"w:mirrorMargins": false,
},
}, },
], },
}, },
{ "w:cols": [{ _attr: { "w:space": 708 } }] }, { "w:cols": { _attr: { "w:space": 708 } } },
{ "w:docGrid": [{ _attr: { "w:linePitch": 360 } }] }, { "w:docGrid": { _attr: { "w:linePitch": 360 } } },
], ],
}, },
], ],

35
src/file/document/body/section-properties/page-border/page-borders.spec.ts
View File

@ -21,8 +21,7 @@ describe("PageBorders", () => {
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["w:pgBorders"]); expect(Object.keys(tree)).to.deep.equal(["w:pgBorders"]);
expect(tree["w:pgBorders"]).to.be.an.instanceof(Array); expect(tree["w:pgBorders"]).to.deep.equal({ _attr: { "w:display": "firstPage" } });
expect(tree["w:pgBorders"][0]).to.deep.equal({ _attr: { "w:display": "firstPage" } });
}); });
it("should create page borders with full configuration", () => { it("should create page borders with full configuration", () => {
@ -58,32 +57,24 @@ describe("PageBorders", () => {
expect(tree["w:pgBorders"]).to.be.an.instanceof(Array); expect(tree["w:pgBorders"]).to.be.an.instanceof(Array);
expect(tree["w:pgBorders"][0]).to.deep.equal({ _attr: { "w:display": "firstPage", "w:zOrder": "back" } }); expect(tree["w:pgBorders"][0]).to.deep.equal({ _attr: { "w:display": "firstPage", "w:zOrder": "back" } });
expect(tree["w:pgBorders"][1]).to.deep.equal({ expect(tree["w:pgBorders"][1]).to.deep.equal({
"w:top": [ "w:top": {
{ _attr: { "w:color": "001122", "w:size": 10, "w:val": "doubleWave" },
_attr: { "w:color": "001122", "w:size": 10, "w:val": "doubleWave" }, },
},
],
}); });
expect(tree["w:pgBorders"][2]).to.deep.equal({ expect(tree["w:pgBorders"][2]).to.deep.equal({
"w:right": [ "w:right": {
{ _attr: { "w:color": "223344", "w:size": 20, "w:val": "double" },
_attr: { "w:color": "223344", "w:size": 20, "w:val": "double" }, },
},
],
}); });
expect(tree["w:pgBorders"][3]).to.deep.equal({ expect(tree["w:pgBorders"][3]).to.deep.equal({
"w:bottom": [ "w:bottom": {
{ _attr: { "w:color": "556677", "w:size": 30, "w:val": "single" },
_attr: { "w:color": "556677", "w:size": 30, "w:val": "single" }, },
},
],
}); });
expect(tree["w:pgBorders"][4]).to.deep.equal({ expect(tree["w:pgBorders"][4]).to.deep.equal({
"w:left": [ "w:left": {
{ _attr: { "w:color": "889900", "w:size": 40, "w:val": "dotted" },
_attr: { "w:color": "889900", "w:size": 40, "w:val": "dotted" }, },
},
],
}); });
}); });
}); });

10
src/file/document/body/section-properties/page-border/page-borders.ts
View File

@ -1,6 +1,6 @@
// http://officeopenxml.com/WPsectionBorders.php // http://officeopenxml.com/WPsectionBorders.php
import { BorderStyle } from "file/styles"; import { BorderStyle } from "file/styles";
import { IXmlableObject, XmlAttributeComponent, XmlComponent } from "file/xml-components"; import { IgnoreIfEmptyXmlComponent, XmlAttributeComponent, XmlComponent } from "file/xml-components";
export enum PageBorderDisplay { export enum PageBorderDisplay {
ALL_PAGES = "allPages", ALL_PAGES = "allPages",
@ -64,7 +64,7 @@ class PageBordersAttributes extends XmlAttributeComponent<IPageBorderAttributes>
}; };
} }
export class PageBorders extends XmlComponent { export class PageBorders extends IgnoreIfEmptyXmlComponent {
constructor(options?: IPageBordersOptions) { constructor(options?: IPageBordersOptions) {
super("w:pgBorders"); super("w:pgBorders");
@ -97,10 +97,4 @@ export class PageBorders extends XmlComponent {
this.root.push(new PageBorder("w:left", options.pageBorderLeft)); this.root.push(new PageBorder("w:left", options.pageBorderLeft));
} }
} }
public prepForXml(): IXmlableObject | undefined {
if (this.root.length > 0) {
return super.prepForXml();
}
}
} }

6
src/file/document/body/section-properties/page-size/page-size.spec.ts
View File

@ -12,8 +12,7 @@ describe("PageSize", () => {
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["w:pgSz"]); expect(Object.keys(tree)).to.deep.equal(["w:pgSz"]);
expect(tree["w:pgSz"]).to.be.an.instanceof(Array); expect(tree["w:pgSz"]).to.deep.equal({ _attr: { "w:h": 200, "w:w": 100, "w:orient": "portrait" } });
expect(tree["w:pgSz"][0]).to.deep.equal({ _attr: { "w:h": 200, "w:w": 100, "w:orient": "portrait" } });
}); });
it("should create page size with horizontal and invert the lengths", () => { it("should create page size with horizontal and invert the lengths", () => {
@ -21,8 +20,7 @@ describe("PageSize", () => {
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["w:pgSz"]); expect(Object.keys(tree)).to.deep.equal(["w:pgSz"]);
expect(tree["w:pgSz"]).to.be.an.instanceof(Array); expect(tree["w:pgSz"]).to.deep.equal({ _attr: { "w:h": 100, "w:w": 200, "w:orient": "landscape" } });
expect(tree["w:pgSz"][0]).to.deep.equal({ _attr: { "w:h": 100, "w:w": 200, "w:orient": "landscape" } });
}); });
}); });
}); });

148
src/file/document/body/section-properties/section-properties.spec.ts
View File

@ -39,29 +39,27 @@ describe("SectionProperties", () => {
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]); expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
expect(tree["w:sectPr"]).to.be.an.instanceof(Array); expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": [{ _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } }] }); expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": { _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } } });
expect(tree["w:sectPr"][1]).to.deep.equal({ expect(tree["w:sectPr"][1]).to.deep.equal({
"w:pgMar": [ "w:pgMar": {
{ _attr: {
_attr: { "w:bottom": 1440,
"w:bottom": 1440, "w:footer": 708,
"w:footer": 708, "w:top": 1440,
"w:top": 1440, "w:right": 1440,
"w:right": 1440, "w:left": 1440,
"w:left": 1440, "w:header": 708,
"w:header": 708, "w:gutter": 0,
"w:gutter": 0, "w:mirrorMargins": false,
"w:mirrorMargins": false,
},
}, },
], },
}); });
expect(tree["w:sectPr"][2]).to.deep.equal({ "w:cols": [{ _attr: { "w:space": 708 } }] }); expect(tree["w:sectPr"][2]).to.deep.equal({ "w:cols": { _attr: { "w:space": 708 } } });
expect(tree["w:sectPr"][3]).to.deep.equal({ "w:docGrid": [{ _attr: { "w:linePitch": 360 } }] }); expect(tree["w:sectPr"][3]).to.deep.equal({ "w:docGrid": { _attr: { "w:linePitch": 360 } } });
expect(tree["w:sectPr"][4]).to.deep.equal({ "w:headerReference": [{ _attr: { "r:id": "rId100", "w:type": "default" } }] }); expect(tree["w:sectPr"][4]).to.deep.equal({ "w:headerReference": { _attr: { "r:id": "rId100", "w:type": "default" } } });
expect(tree["w:sectPr"][5]).to.deep.equal({ "w:footerReference": [{ _attr: { "r:id": "rId200", "w:type": "even" } }] }); expect(tree["w:sectPr"][5]).to.deep.equal({ "w:footerReference": { _attr: { "r:id": "rId200", "w:type": "even" } } });
expect(tree["w:sectPr"][6]).to.deep.equal({ "w:pgNumType": [{ _attr: { "w:fmt": "cardinalText", "w:start": 10 } }] }); expect(tree["w:sectPr"][6]).to.deep.equal({ "w:pgNumType": { _attr: { "w:fmt": "cardinalText", "w:start": 10 } } });
}); });
it("should create section properties with no options", () => { it("should create section properties with no options", () => {
@ -69,25 +67,23 @@ describe("SectionProperties", () => {
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]); expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
expect(tree["w:sectPr"]).to.be.an.instanceof(Array); expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": [{ _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } }] }); expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": { _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } } });
expect(tree["w:sectPr"][1]).to.deep.equal({ expect(tree["w:sectPr"][1]).to.deep.equal({
"w:pgMar": [ "w:pgMar": {
{ _attr: {
_attr: { "w:bottom": 1440,
"w:bottom": 1440, "w:footer": 708,
"w:footer": 708, "w:top": 1440,
"w:top": 1440, "w:right": 1440,
"w:right": 1440, "w:left": 1440,
"w:left": 1440, "w:header": 708,
"w:header": 708, "w:gutter": 0,
"w:gutter": 0, "w:mirrorMargins": false,
"w:mirrorMargins": false,
},
}, },
], },
}); });
expect(tree["w:sectPr"][2]).to.deep.equal({ "w:cols": [{ _attr: { "w:space": 708 } }] }); expect(tree["w:sectPr"][2]).to.deep.equal({ "w:cols": { _attr: { "w:space": 708 } } });
expect(tree["w:sectPr"][3]).to.deep.equal({ "w:docGrid": [{ _attr: { "w:linePitch": 360 } }] }); expect(tree["w:sectPr"][3]).to.deep.equal({ "w:docGrid": { _attr: { "w:linePitch": 360 } } });
}); });
it("should create section properties with changed options", () => { it("should create section properties with changed options", () => {
@ -97,22 +93,20 @@ describe("SectionProperties", () => {
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]); expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
expect(tree["w:sectPr"]).to.be.an.instanceof(Array); expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": [{ _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } }] }); expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": { _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } } });
expect(tree["w:sectPr"][1]).to.deep.equal({ expect(tree["w:sectPr"][1]).to.deep.equal({
"w:pgMar": [ "w:pgMar": {
{ _attr: {
_attr: { "w:bottom": 1440,
"w:bottom": 1440, "w:footer": 708,
"w:footer": 708, "w:top": 0,
"w:top": 0, "w:right": 1440,
"w:right": 1440, "w:left": 1440,
"w:left": 1440, "w:header": 708,
"w:header": 708, "w:gutter": 0,
"w:gutter": 0, "w:mirrorMargins": false,
"w:mirrorMargins": false,
},
}, },
], },
}); });
}); });
@ -123,22 +117,20 @@ describe("SectionProperties", () => {
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]); expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
expect(tree["w:sectPr"]).to.be.an.instanceof(Array); expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": [{ _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } }] }); expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": { _attr: { "w:h": 16838, "w:w": 11906, "w:orient": "portrait" } } });
expect(tree["w:sectPr"][1]).to.deep.equal({ expect(tree["w:sectPr"][1]).to.deep.equal({
"w:pgMar": [ "w:pgMar": {
{ _attr: {
_attr: { "w:bottom": 0,
"w:bottom": 0, "w:footer": 708,
"w:footer": 708, "w:top": 1440,
"w:top": 1440, "w:right": 1440,
"w:right": 1440, "w:left": 1440,
"w:left": 1440, "w:header": 708,
"w:header": 708, "w:gutter": 0,
"w:gutter": 0, "w:mirrorMargins": false,
"w:mirrorMargins": false,
},
}, },
], },
}); });
}); });
@ -150,22 +142,20 @@ describe("SectionProperties", () => {
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]); expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
expect(tree["w:sectPr"]).to.be.an.instanceof(Array); expect(tree["w:sectPr"]).to.be.an.instanceof(Array);
expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": [{ _attr: { "w:h": 0, "w:w": 0, "w:orient": "portrait" } }] }); expect(tree["w:sectPr"][0]).to.deep.equal({ "w:pgSz": { _attr: { "w:h": 0, "w:w": 0, "w:orient": "portrait" } } });
expect(tree["w:sectPr"][1]).to.deep.equal({ expect(tree["w:sectPr"][1]).to.deep.equal({
"w:pgMar": [ "w:pgMar": {
{ _attr: {
_attr: { "w:bottom": 1440,
"w:bottom": 1440, "w:footer": 708,
"w:footer": 708, "w:top": 1440,
"w:top": 1440, "w:right": 1440,
"w:right": 1440, "w:left": 1440,
"w:left": 1440, "w:header": 708,
"w:header": 708, "w:gutter": 0,
"w:gutter": 0, "w:mirrorMargins": false,
"w:mirrorMargins": false,
},
}, },
], },
}); });
}); });
@ -179,7 +169,7 @@ describe("SectionProperties", () => {
expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]); expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
const pgBorders = tree["w:sectPr"].find((item) => item["w:pgBorders"] !== undefined); const pgBorders = tree["w:sectPr"].find((item) => item["w:pgBorders"] !== undefined);
expect(pgBorders).to.deep.equal({ expect(pgBorders).to.deep.equal({
"w:pgBorders": [{ _attr: { "w:offsetFrom": "page" } }], "w:pgBorders": { _attr: { "w:offsetFrom": "page" } },
}); });
}); });
@ -191,7 +181,7 @@ describe("SectionProperties", () => {
expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]); expect(Object.keys(tree)).to.deep.equal(["w:sectPr"]);
const pgNumType = tree["w:sectPr"].find((item) => item["w:pgNumType"] !== undefined); const pgNumType = tree["w:sectPr"].find((item) => item["w:pgNumType"] !== undefined);
expect(pgNumType).to.deep.equal({ expect(pgNumType).to.deep.equal({
"w:pgNumType": [{ _attr: { "w:fmt": "upperRoman" } }], "w:pgNumType": { _attr: { "w:fmt": "upperRoman" } },
}); });
}); });

3
src/file/document/body/section-properties/title-page/title-page.spec.ts
View File

@ -11,8 +11,7 @@ describe("PageSize", () => {
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["w:titlePg"]); expect(Object.keys(tree)).to.deep.equal(["w:titlePg"]);
expect(tree["w:titlePg"]).to.be.an.instanceof(Array); expect(tree["w:titlePg"]).to.deep.equal({ _attr: { "w:val": "1" } });
expect(tree["w:titlePg"][0]).to.deep.equal({ _attr: { "w:val": "1" } });
}); });
}); });
}); });

8
src/file/document/document.spec.ts
View File

@ -52,7 +52,7 @@ describe("Document", () => {
expect(body[0]) expect(body[0])
.to.have.property("w:p") .to.have.property("w:p")
.which.includes({ .which.includes({
"w:r": [{ "w:rPr": [] }, { "w:t": [{ _attr: { "xml:space": "preserve" } }, "sample paragraph text"] }], "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "sample paragraph text"] }],
}); });
}); });
}); });
@ -84,9 +84,9 @@ describe("Document", () => {
.to.have.property("w:tbl") .to.have.property("w:tbl")
.which.includes({ .which.includes({
"w:tblGrid": [ "w:tblGrid": [
{ "w:gridCol": [{ _attr: { "w:w": 100 } }] }, { "w:gridCol": { _attr: { "w:w": 100 } } },
{ "w:gridCol": [{ _attr: { "w:w": 100 } }] }, { "w:gridCol": { _attr: { "w:w": 100 } } },
{ "w:gridCol": [{ _attr: { "w:w": 100 } }] }, { "w:gridCol": { _attr: { "w:w": 100 } } },
], ],
}); });
expect(body[0]["w:tbl"].filter((x) => x["w:tr"])).to.have.length(2); expect(body[0]["w:tbl"].filter((x) => x["w:tr"])).to.have.length(2);

20
src/file/file.spec.ts
View File

@ -25,8 +25,8 @@ describe("File", () => {
const tree = new Formatter().format(doc.Document.Body); const tree = new Formatter().format(doc.Document.Body);
expect(tree["w:body"][1]["w:sectPr"][4]["w:headerReference"][0]._attr["w:type"]).to.equal("default"); expect(tree["w:body"][1]["w:sectPr"][4]["w:headerReference"]._attr["w:type"]).to.equal("default");
expect(tree["w:body"][1]["w:sectPr"][5]["w:footerReference"][0]._attr["w:type"]).to.equal("default"); expect(tree["w:body"][1]["w:sectPr"][5]["w:footerReference"]._attr["w:type"]).to.equal("default");
}); });
it("should create with first headers and footers", () => { it("should create with first headers and footers", () => {
@ -45,8 +45,8 @@ describe("File", () => {
const tree = new Formatter().format(doc.Document.Body); const tree = new Formatter().format(doc.Document.Body);
expect(tree["w:body"][1]["w:sectPr"][4]["w:headerReference"][0]._attr["w:type"]).to.equal("first"); expect(tree["w:body"][1]["w:sectPr"][4]["w:headerReference"]._attr["w:type"]).to.equal("first");
expect(tree["w:body"][1]["w:sectPr"][5]["w:footerReference"][0]._attr["w:type"]).to.equal("first"); expect(tree["w:body"][1]["w:sectPr"][5]["w:footerReference"]._attr["w:type"]).to.equal("first");
}); });
it("should create with correct headers", () => { it("should create with correct headers", () => {
@ -69,13 +69,13 @@ describe("File", () => {
const tree = new Formatter().format(doc.Document.Body); const tree = new Formatter().format(doc.Document.Body);
expect(tree["w:body"][1]["w:sectPr"][4]["w:headerReference"][0]._attr["w:type"]).to.equal("default"); expect(tree["w:body"][1]["w:sectPr"][4]["w:headerReference"]._attr["w:type"]).to.equal("default");
expect(tree["w:body"][1]["w:sectPr"][5]["w:headerReference"][0]._attr["w:type"]).to.equal("first"); expect(tree["w:body"][1]["w:sectPr"][5]["w:headerReference"]._attr["w:type"]).to.equal("first");
expect(tree["w:body"][1]["w:sectPr"][6]["w:headerReference"][0]._attr["w:type"]).to.equal("even"); expect(tree["w:body"][1]["w:sectPr"][6]["w:headerReference"]._attr["w:type"]).to.equal("even");
expect(tree["w:body"][1]["w:sectPr"][7]["w:footerReference"][0]._attr["w:type"]).to.equal("default"); expect(tree["w:body"][1]["w:sectPr"][7]["w:footerReference"]._attr["w:type"]).to.equal("default");
expect(tree["w:body"][1]["w:sectPr"][8]["w:footerReference"][0]._attr["w:type"]).to.equal("first"); expect(tree["w:body"][1]["w:sectPr"][8]["w:footerReference"]._attr["w:type"]).to.equal("first");
expect(tree["w:body"][1]["w:sectPr"][9]["w:footerReference"][0]._attr["w:type"]).to.equal("even"); expect(tree["w:body"][1]["w:sectPr"][9]["w:footerReference"]._attr["w:type"]).to.equal("even");
}); });
}); });

6
src/file/footnotes/footnote/footnote.spec.ts
View File

@ -11,8 +11,7 @@ describe("Footnote", () => {
const tree = new Formatter().format(footnote); const tree = new Formatter().format(footnote);
expect(Object.keys(tree)).to.deep.equal(["w:footnote"]); expect(Object.keys(tree)).to.deep.equal(["w:footnote"]);
expect(tree["w:footnote"]).to.be.an.instanceof(Array); expect(tree["w:footnote"]).to.deep.equal({ _attr: { "w:type": "separator", "w:id": 1 } });
expect(tree["w:footnote"][0]).to.deep.equal({ _attr: { "w:type": "separator", "w:id": 1 } });
}); });
it("should create a footnote without a footnote type", () => { it("should create a footnote without a footnote type", () => {
@ -20,8 +19,7 @@ describe("Footnote", () => {
const tree = new Formatter().format(footnote); const tree = new Formatter().format(footnote);
expect(Object.keys(tree)).to.deep.equal(["w:footnote"]); expect(Object.keys(tree)).to.deep.equal(["w:footnote"]);
expect(tree["w:footnote"]).to.be.an.instanceof(Array); expect(tree["w:footnote"]).to.deep.equal({ _attr: { "w:id": 1 } });
expect(tree["w:footnote"][0]).to.deep.equal({ _attr: { "w:id": 1 } });
}); });
}); });
}); });

8
src/file/media/media.spec.ts
View File

@ -27,10 +27,10 @@ describe("Media", () => {
const file = new File(); const file = new File();
const image1 = Media.addImage(file, "test"); const image1 = Media.addImage(file, "test");
const tree = new Formatter().format(image1.Paragraph); const tree = new Formatter().format(image1.Paragraph);
const inlineElements = tree["w:p"][1]["w:r"][1]["w:drawing"][0]["wp:inline"]; const inlineElements = tree["w:p"][0]["w:r"][0]["w:drawing"][0]["wp:inline"];
const graphicData = inlineElements.find((x) => x["a:graphic"]); const graphicData = inlineElements.find((x) => x["a:graphic"]);
expect(graphicData["a:graphic"][1]["a:graphicData"][1]["pic:pic"][2]["pic:blipFill"][0]["a:blip"][0]).to.deep.equal({ expect(graphicData["a:graphic"][1]["a:graphicData"][1]["pic:pic"][2]["pic:blipFill"][0]["a:blip"]).to.deep.equal({
_attr: { _attr: {
"r:embed": `rId{testId.png}`, "r:embed": `rId{testId.png}`,
cstate: "none", cstate: "none",
@ -39,10 +39,10 @@ describe("Media", () => {
const image2 = Media.addImage(file, "test"); const image2 = Media.addImage(file, "test");
const tree2 = new Formatter().format(image2.Paragraph); const tree2 = new Formatter().format(image2.Paragraph);
const inlineElements2 = tree2["w:p"][1]["w:r"][1]["w:drawing"][0]["wp:inline"]; const inlineElements2 = tree2["w:p"][0]["w:r"][0]["w:drawing"][0]["wp:inline"];
const graphicData2 = inlineElements2.find((x) => x["a:graphic"]); const graphicData2 = inlineElements2.find((x) => x["a:graphic"]);
expect(graphicData2["a:graphic"][1]["a:graphicData"][1]["pic:pic"][2]["pic:blipFill"][0]["a:blip"][0]).to.deep.equal({ expect(graphicData2["a:graphic"][1]["a:graphicData"][1]["pic:pic"][2]["pic:blipFill"][0]["a:blip"]).to.deep.equal({
_attr: { _attr: {
"r:embed": `rId{testId.png}`, "r:embed": `rId{testId.png}`,
cstate: "none", cstate: "none",

138
src/file/numbering/numbering.spec.ts
View File

@ -22,7 +22,7 @@ describe("Numbering", () => {
expect(abstractNums).to.have.lengthOf(1); expect(abstractNums).to.have.lengthOf(1);
expect(abstractNums[0]["w:abstractNum"]).to.deep.include.members([ expect(abstractNums[0]["w:abstractNum"]).to.deep.include.members([
{ _attr: { "w:abstractNumId": 0, "w15:restartNumberingAfterBreak": 0 } }, { _attr: { "w:abstractNumId": 0, "w15:restartNumberingAfterBreak": 0 } },
{ "w:multiLevelType": [{ _attr: { "w:val": "hybridMultilevel" } }] }, { "w:multiLevelType": { _attr: { "w:val": "hybridMultilevel" } } },
]); ]);
abstractNums abstractNums
@ -37,9 +37,9 @@ describe("Numbering", () => {
{ "w:numFmt": [{ _attr: { "w:val": "bullet" } }] }, { "w:numFmt": [{ _attr: { "w:val": "bullet" } }] },
]); ]);
// Once chai 4.0.0 lands and #644 is resolved, we can add the following to the test: // Once chai 4.0.0 lands and #644 is resolved, we can add the following to the test:
// {"w:lvlText": [{"_attr": {"w:val": "•"}}]}, // {"w:lvlText": {"_attr": {"w:val": "•"}}},
// {"w:rPr": [{"w:rFonts": [{"_attr": {"w:ascii": "Symbol", "w:cs": "Symbol", "w:eastAsia": "Symbol", "w:hAnsi": "Symbol", "w:hint": "default"}}]}]}, // {"w:rPr": [{"w:rFonts": {"_attr": {"w:ascii": "Symbol", "w:cs": "Symbol", "w:eastAsia": "Symbol", "w:hAnsi": "Symbol", "w:hint": "default"}}}]},
// {"w:pPr": [{"_attr": {}}, // {"w:pPr": [
// {"w:ind": [{"_attr": {"w:left": 720, "w:hanging": 360}}]}]}, // {"w:ind": [{"_attr": {"w:left": 720, "w:hanging": 360}}]}]},
}); });
}); });
@ -65,7 +65,7 @@ describe("Numbering", () => {
expect(n).to.be.instanceof(Num); expect(n).to.be.instanceof(Num);
const tree = new Formatter().format(numbering); const tree = new Formatter().format(numbering);
const serializedN = tree["w:numbering"].find((obj) => obj["w:num"] && obj["w:num"][0]._attr["w:numId"] === n.id); const serializedN = tree["w:numbering"].find((obj) => obj["w:num"] && obj["w:num"][0]._attr["w:numId"] === n.id);
expect(serializedN["w:num"][1]["w:abstractNumId"][0]._attr["w:val"]).to.equal(a2.id); expect(serializedN["w:num"][1]["w:abstractNumId"]._attr["w:val"]).to.equal(a2.id);
}); });
it("assigns a unique ID to each concrete numbering it creates", () => { it("assigns a unique ID to each concrete numbering it creates", () => {
@ -89,10 +89,10 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(3, "lowerLetter", "%1)", "end"); const level = abstractNumbering.createLevel(3, "lowerLetter", "%1)", "end");
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ _attr: { "w:ilvl": 3, "w15:tentative": 1 } }); expect(tree["w:lvl"]).to.include({ _attr: { "w:ilvl": 3, "w15:tentative": 1 } });
expect(tree["w:lvl"]).to.include({ "w:start": [{ _attr: { "w:val": 1 } }] }); expect(tree["w:lvl"]).to.include({ "w:start": { _attr: { "w:val": 1 } } });
expect(tree["w:lvl"]).to.include({ "w:lvlJc": [{ _attr: { "w:val": "end" } }] }); expect(tree["w:lvl"]).to.include({ "w:lvlJc": { _attr: { "w:val": "end" } } });
expect(tree["w:lvl"]).to.include({ "w:numFmt": [{ _attr: { "w:val": "lowerLetter" } }] }); expect(tree["w:lvl"]).to.include({ "w:numFmt": { _attr: { "w:val": "lowerLetter" } } });
expect(tree["w:lvl"]).to.include({ "w:lvlText": [{ _attr: { "w:val": "%1)" } }] }); expect(tree["w:lvl"]).to.include({ "w:lvlText": { _attr: { "w:val": "%1)" } } });
}); });
it("uses 'start' as the default alignment", () => { it("uses 'start' as the default alignment", () => {
@ -100,10 +100,10 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(3, "lowerLetter", "%1)"); const level = abstractNumbering.createLevel(3, "lowerLetter", "%1)");
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ _attr: { "w:ilvl": 3, "w15:tentative": 1 } }); expect(tree["w:lvl"]).to.include({ _attr: { "w:ilvl": 3, "w15:tentative": 1 } });
expect(tree["w:lvl"]).to.include({ "w:start": [{ _attr: { "w:val": 1 } }] }); expect(tree["w:lvl"]).to.include({ "w:start": { _attr: { "w:val": 1 } } });
expect(tree["w:lvl"]).to.include({ "w:lvlJc": [{ _attr: { "w:val": "start" } }] }); expect(tree["w:lvl"]).to.include({ "w:lvlJc": { _attr: { "w:val": "start" } } });
expect(tree["w:lvl"]).to.include({ "w:numFmt": [{ _attr: { "w:val": "lowerLetter" } }] }); expect(tree["w:lvl"]).to.include({ "w:numFmt": { _attr: { "w:val": "lowerLetter" } } });
expect(tree["w:lvl"]).to.include({ "w:lvlText": [{ _attr: { "w:val": "%1)" } }] }); expect(tree["w:lvl"]).to.include({ "w:lvlText": { _attr: { "w:val": "%1)" } } });
}); });
describe("formatting methods: paragraph properties", () => { describe("formatting methods: paragraph properties", () => {
@ -112,7 +112,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.").indent({ left: 720 }); const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.").indent({ left: 720 });
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [{ "w:ind": [{ _attr: { "w:left": 720 } }] }], "w:pPr": [{ "w:ind": { _attr: { "w:left": 720 } } }],
}); });
}); });
@ -121,7 +121,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.").spacing({ before: 50, after: 150 }); const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.").spacing({ before: 50, after: 150 });
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [{ "w:spacing": [{ _attr: { "w:before": 50, "w:after": 150 } }] }], "w:pPr": [{ "w:spacing": { _attr: { "w:before": 50, "w:after": 150 } } }],
}); });
}); });
@ -130,7 +130,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.").center(); const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.").center();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "center" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "center" } } }],
}); });
}); });
@ -139,7 +139,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.", "left").left(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.", "left").left();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "left" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "left" } } }],
}); });
}); });
@ -148,7 +148,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").right(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").right();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "right" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "right" } } }],
}); });
}); });
@ -157,7 +157,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").justified(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").justified();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "both" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "both" } } }],
}); });
}); });
@ -170,16 +170,14 @@ describe("AbstractNumbering", () => {
{ {
"w:pBdr": [ "w:pBdr": [
{ {
"w:bottom": [ "w:bottom": {
{ _attr: {
_attr: { "w:color": "auto",
"w:color": "auto", "w:space": "1",
"w:space": "1", "w:val": "single",
"w:val": "single", "w:sz": "6",
"w:sz": "6",
},
}, },
], },
}, },
], ],
}, },
@ -194,7 +192,7 @@ describe("AbstractNumbering", () => {
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [ "w:pPr": [
{ {
"w:tabs": [{ "w:tab": [{ _attr: { "w:val": "left", "w:pos": 1200 } }] }], "w:tabs": [{ "w:tab": { _attr: { "w:val": "left", "w:pos": 1200 } } }],
}, },
], ],
}); });
@ -207,7 +205,7 @@ describe("AbstractNumbering", () => {
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [ "w:pPr": [
{ {
"w:tabs": [{ "w:tab": [{ _attr: { "w:val": "right", "w:pos": 9026 } }] }], "w:tabs": [{ "w:tab": { _attr: { "w:val": "right", "w:pos": 9026 } } }],
}, },
], ],
}); });
@ -218,7 +216,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").keepLines(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").keepLines();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [{ "w:keepLines": [] }], "w:pPr": [{ "w:keepLines": null }],
}); });
}); });
@ -227,7 +225,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").keepNext(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").keepNext();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:pPr": [{ "w:keepNext": [] }], "w:pPr": [{ "w:keepNext": null }],
}); });
}); });
}); });
@ -238,7 +236,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").size(24); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").size(24);
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:sz": [{ _attr: { "w:val": 24 } }] }], "w:rPr": [{ "w:sz": { _attr: { "w:val": 24 } } }],
}); });
}); });
@ -247,7 +245,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").smallCaps(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").smallCaps();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:smallCaps": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:smallCaps": { _attr: { "w:val": true } } }],
}); });
}); });
@ -256,7 +254,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").allCaps(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").allCaps();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:caps": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:caps": { _attr: { "w:val": true } } }],
}); });
}); });
@ -265,7 +263,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").strike(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").strike();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:strike": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:strike": { _attr: { "w:val": true } } }],
}); });
}); });
@ -274,7 +272,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").doubleStrike(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").doubleStrike();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:dstrike": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:dstrike": { _attr: { "w:val": true } } }],
}); });
}); });
@ -283,7 +281,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").subScript(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").subScript();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:vertAlign": [{ _attr: { "w:val": "subscript" } }] }], "w:rPr": [{ "w:vertAlign": { _attr: { "w:val": "subscript" } } }],
}); });
}); });
@ -292,7 +290,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").superScript(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").superScript();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:vertAlign": [{ _attr: { "w:val": "superscript" } }] }], "w:rPr": [{ "w:vertAlign": { _attr: { "w:val": "superscript" } } }],
}); });
}); });
@ -302,7 +300,7 @@ describe("AbstractNumbering", () => {
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [ "w:rPr": [
{ "w:rFonts": [{ _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times" } }] }, { "w:rFonts": { _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times" } } },
], ],
}); });
}); });
@ -312,7 +310,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").bold(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").bold();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:b": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:b": { _attr: { "w:val": true } } }],
}); });
}); });
@ -321,7 +319,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").italics(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").italics();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:i": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:i": { _attr: { "w:val": true } } }],
}); });
}); });
@ -331,7 +329,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").underline(); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").underline();
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:u": [{ _attr: { "w:val": "single" } }] }], "w:rPr": [{ "w:u": { _attr: { "w:val": "single" } } }],
}); });
}); });
@ -340,7 +338,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").underline("double"); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").underline("double");
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:u": [{ _attr: { "w:val": "double" } }] }], "w:rPr": [{ "w:u": { _attr: { "w:val": "double" } } }],
}); });
}); });
@ -349,7 +347,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").underline("double", "005599"); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").underline("double", "005599");
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:u": [{ _attr: { "w:val": "double", "w:color": "005599" } }] }], "w:rPr": [{ "w:u": { _attr: { "w:val": "double", "w:color": "005599" } } }],
}); });
}); });
}); });
@ -359,7 +357,7 @@ describe("AbstractNumbering", () => {
const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").color("123456"); const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.").color("123456");
const tree = new Formatter().format(level); const tree = new Formatter().format(level);
expect(tree["w:lvl"]).to.include({ expect(tree["w:lvl"]).to.include({
"w:rPr": [{ "w:color": [{ _attr: { "w:val": "123456" } }] }], "w:rPr": [{ "w:color": { _attr: { "w:val": "123456" } } }],
}); });
}); });
}); });
@ -388,20 +386,12 @@ describe("concrete numbering", () => {
}, },
}, },
{ {
"w:lvl": [ "w:lvl": {
{ _attr: {
_attr: { "w:ilvl": 3,
"w:ilvl": 3, "w15:tentative": 1,
"w15:tentative": 1,
},
}, },
{ },
"w:pPr": [],
},
{
"w:rPr": [],
},
],
}, },
], ],
}); });
@ -418,29 +408,19 @@ describe("concrete numbering", () => {
}, },
}, },
{ {
"w:startOverride": [ "w:startOverride": {
{ _attr: {
_attr: { "w:val": 9,
"w:val": 9,
},
}, },
], },
}, },
{ {
"w:lvl": [ "w:lvl": {
{ _attr: {
_attr: { "w:ilvl": 1,
"w:ilvl": 1, "w15:tentative": 1,
"w15:tentative": 1,
},
}, },
{ },
"w:pPr": [],
},
{
"w:rPr": [],
},
],
}, },
], ],
}); });
@ -454,7 +434,7 @@ describe("concrete numbering", () => {
"w:lvlOverride": [ "w:lvlOverride": [
{ _attr: { "w:ilvl": 1 } }, { _attr: { "w:ilvl": 1 } },
{ {
"w:lvl": [{ _attr: { "w15:tentative": 1, "w:ilvl": 1 } }, { "w:pPr": [] }, { "w:rPr": [] }], "w:lvl": { _attr: { "w15:tentative": 1, "w:ilvl": 1 } },
}, },
], ],
}); });

8
src/file/paragraph/formatting/spacing.spec.ts
View File

@ -10,7 +10,7 @@ describe("Spacing", () => {
const spacing = new Spacing({ before: 100, after: 120, line: 150 }); const spacing = new Spacing({ before: 100, after: 120, line: 150 });
const tree = new Formatter().format(spacing); const tree = new Formatter().format(spacing);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:spacing": [{ _attr: { "w:after": 120, "w:before": 100, "w:line": 150 } }], "w:spacing": { _attr: { "w:after": 120, "w:before": 100, "w:line": 150 } },
}); });
}); });
@ -18,7 +18,7 @@ describe("Spacing", () => {
const spacing = new Spacing({ before: 100 }); const spacing = new Spacing({ before: 100 });
const tree = new Formatter().format(spacing); const tree = new Formatter().format(spacing);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:spacing": [{ _attr: { "w:before": 100 } }], "w:spacing": { _attr: { "w:before": 100 } },
}); });
}); });
}); });
@ -30,7 +30,7 @@ describe("ContextualSpacing", () => {
const spacing = new ContextualSpacing(true); const spacing = new ContextualSpacing(true);
const tree = new Formatter().format(spacing); const tree = new Formatter().format(spacing);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:contextualSpacing": [{ _attr: { "w:val": 1 } }], "w:contextualSpacing": { _attr: { "w:val": 1 } },
}); });
}); });
@ -38,7 +38,7 @@ describe("ContextualSpacing", () => {
const spacing = new ContextualSpacing(false); const spacing = new ContextualSpacing(false);
const tree = new Formatter().format(spacing); const tree = new Formatter().format(spacing);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:contextualSpacing": [{ _attr: { "w:val": 0 } }], "w:contextualSpacing": { _attr: { "w:val": 0 } },
}); });
}); });
}); });

128
src/file/paragraph/image.spec.ts
View File

@ -45,14 +45,8 @@ describe("Image", () => {
const tree = new Formatter().format(image); const tree = new Formatter().format(image);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{
"w:pPr": [],
},
{ {
"w:r": [ "w:r": [
{
"w:rPr": [],
},
{ {
"w:drawing": [ "w:drawing": [
{ {
@ -66,49 +60,41 @@ describe("Image", () => {
}, },
}, },
{ {
"wp:extent": [ "wp:extent": {
{ _attr: {
_attr: { cx: 20,
cx: 20, cy: 20,
cy: 20,
},
}, },
], },
}, },
{ {
"wp:effectExtent": [ "wp:effectExtent": {
{ _attr: {
_attr: { b: 0,
b: 0, l: 0,
l: 0, r: 0,
r: 0, t: 0,
t: 0,
},
}, },
], },
}, },
{ {
"wp:docPr": [ "wp:docPr": {
{ _attr: {
_attr: { descr: "",
descr: "", id: 0,
id: 0, name: "",
name: "",
},
}, },
], },
}, },
{ {
"wp:cNvGraphicFramePr": [ "wp:cNvGraphicFramePr": [
{ {
"a:graphicFrameLocks": [ "a:graphicFrameLocks": {
{ _attr: {
_attr: { noChangeAspect: 1,
noChangeAspect: 1, "xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main",
"xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main",
},
}, },
], },
}, },
], ],
}, },
@ -137,27 +123,23 @@ describe("Image", () => {
{ {
"pic:nvPicPr": [ "pic:nvPicPr": [
{ {
"pic:cNvPr": [ "pic:cNvPr": {
{ _attr: {
_attr: { desc: "",
desc: "", id: 0,
id: 0, name: "",
name: "",
},
}, },
], },
}, },
{ {
"pic:cNvPicPr": [ "pic:cNvPicPr": [
{ {
"a:picLocks": [ "a:picLocks": {
{ _attr: {
_attr: { noChangeArrowheads: 1,
noChangeArrowheads: 1, noChangeAspect: 1,
noChangeAspect: 1,
},
}, },
], },
}, },
], ],
}, },
@ -166,22 +148,20 @@ describe("Image", () => {
{ {
"pic:blipFill": [ "pic:blipFill": [
{ {
"a:blip": [ "a:blip": {
{ _attr: {
_attr: { cstate: "none",
cstate: "none", "r:embed": "rId{test.png}",
"r:embed": "rId{test.png}",
},
}, },
], },
}, },
{ {
"a:srcRect": [], "a:srcRect": null,
}, },
{ {
"a:stretch": [ "a:stretch": [
{ {
"a:fillRect": [], "a:fillRect": null,
}, },
], ],
}, },
@ -197,24 +177,20 @@ describe("Image", () => {
{ {
"a:xfrm": [ "a:xfrm": [
{ {
"a:ext": [ "a:ext": {
{ _attr: {
_attr: { cx: 10,
cx: 10, cy: 10,
cy: 10,
},
}, },
], },
}, },
{ {
"a:off": [ "a:off": {
{ _attr: {
_attr: { x: 0,
x: 0, y: 0,
y: 0,
},
}, },
], },
}, },
], ],
}, },
@ -226,7 +202,7 @@ describe("Image", () => {
}, },
}, },
{ {
"a:avLst": [], "a:avLst": null,
}, },
], ],
}, },

2
src/file/paragraph/links/hyperlink.spec.ts
View File

@ -31,7 +31,7 @@ describe("Hyperlink", () => {
const tree = new Formatter().format(hyperlink); const tree = new Formatter().format(hyperlink);
const runJson = { const runJson = {
"w:r": [ "w:r": [
{ "w:rPr": [{ "w:rStyle": [{ _attr: { "w:val": "Hyperlink" } }] }] }, { "w:rPr": [{ "w:rStyle": { _attr: { "w:val": "Hyperlink" } } }] },
{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "https://example.com"] }, { "w:t": [{ _attr: { "xml:space": "preserve" } }, "https://example.com"] },
], ],
}; };

171
src/file/paragraph/paragraph.spec.ts
View File

@ -40,7 +40,7 @@ describe("Paragraph", () => {
expect(tree) expect(tree)
.to.be.an("array") .to.be.an("array")
.which.includes({ .which.includes({
"w:r": [{ "w:rPr": [] }, { "w:t": [{ _attr: { "xml:space": "preserve" } }, "this is a test run"] }], "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "this is a test run"] }],
}); });
}); });
}); });
@ -52,7 +52,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:pStyle": [{ _attr: { "w:val": "Heading1" } }] }], "w:pPr": [{ "w:pStyle": { _attr: { "w:val": "Heading1" } } }],
}, },
], ],
}); });
@ -66,7 +66,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:pStyle": [{ _attr: { "w:val": "Heading2" } }] }], "w:pPr": [{ "w:pStyle": { _attr: { "w:val": "Heading2" } } }],
}, },
], ],
}); });
@ -80,7 +80,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:pStyle": [{ _attr: { "w:val": "Heading3" } }] }], "w:pPr": [{ "w:pStyle": { _attr: { "w:val": "Heading3" } } }],
}, },
], ],
}); });
@ -94,7 +94,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:pStyle": [{ _attr: { "w:val": "Heading4" } }] }], "w:pPr": [{ "w:pStyle": { _attr: { "w:val": "Heading4" } } }],
}, },
], ],
}); });
@ -108,7 +108,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:pStyle": [{ _attr: { "w:val": "Heading5" } }] }], "w:pPr": [{ "w:pStyle": { _attr: { "w:val": "Heading5" } } }],
}, },
], ],
}); });
@ -122,7 +122,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:pStyle": [{ _attr: { "w:val": "Heading6" } }] }], "w:pPr": [{ "w:pStyle": { _attr: { "w:val": "Heading6" } } }],
}, },
], ],
}); });
@ -136,7 +136,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:pStyle": [{ _attr: { "w:val": "Title" } }] }], "w:pPr": [{ "w:pStyle": { _attr: { "w:val": "Title" } } }],
}, },
], ],
}); });
@ -150,7 +150,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "center" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "center" } } }],
}, },
], ],
}); });
@ -164,7 +164,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "left" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "left" } } }],
}, },
], ],
}); });
@ -178,7 +178,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "right" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "right" } } }],
}, },
], ],
}); });
@ -192,7 +192,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "start" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "start" } } }],
}, },
], ],
}); });
@ -206,7 +206,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "end" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "end" } } }],
}, },
], ],
}); });
@ -220,7 +220,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "distribute" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "distribute" } } }],
}, },
], ],
}); });
@ -234,7 +234,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "both" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "both" } } }],
}, },
], ],
}); });
@ -252,14 +252,12 @@ describe("Paragraph", () => {
{ {
"w:tabs": [ "w:tabs": [
{ {
"w:tab": [ "w:tab": {
{ _attr: {
_attr: { "w:pos": 9026,
"w:pos": 9026, "w:val": "right",
"w:val": "right",
},
}, },
], },
}, },
], ],
}, },
@ -281,15 +279,13 @@ describe("Paragraph", () => {
{ {
"w:tabs": [ "w:tabs": [
{ {
"w:tab": [ "w:tab": {
{ _attr: {
_attr: { "w:pos": 100,
"w:pos": 100, "w:val": "left",
"w:val": "left", "w:leader": "hyphen",
"w:leader": "hyphen",
},
}, },
], },
}, },
], ],
}, },
@ -311,15 +307,13 @@ describe("Paragraph", () => {
{ {
"w:tabs": [ "w:tabs": [
{ {
"w:tab": [ "w:tab": {
{ _attr: {
_attr: { "w:pos": 100,
"w:pos": 100, "w:val": "right",
"w:val": "right", "w:leader": "dot",
"w:leader": "dot",
},
}, },
], },
}, },
], ],
}, },
@ -341,15 +335,13 @@ describe("Paragraph", () => {
{ {
"w:tabs": [ "w:tabs": [
{ {
"w:tab": [ "w:tab": {
{ _attr: {
_attr: { "w:pos": 100,
"w:pos": 100, "w:val": "center",
"w:val": "center", "w:leader": "middleDot",
"w:leader": "middleDot",
},
}, },
], },
}, },
], ],
}, },
@ -367,7 +359,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:contextualSpacing": [{ _attr: { "w:val": 1 } }] }], "w:pPr": [{ "w:contextualSpacing": { _attr: { "w:val": 1 } } }],
}, },
], ],
}); });
@ -379,7 +371,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:contextualSpacing": [{ _attr: { "w:val": 0 } }] }], "w:pPr": [{ "w:contextualSpacing": { _attr: { "w:val": 0 } } }],
}, },
], ],
}); });
@ -397,16 +389,14 @@ describe("Paragraph", () => {
{ {
"w:pBdr": [ "w:pBdr": [
{ {
"w:bottom": [ "w:bottom": {
{ _attr: {
_attr: { "w:val": "single",
"w:val": "single", "w:color": "auto",
"w:color": "auto", "w:space": "1",
"w:space": "1", "w:sz": "6",
"w:sz": "6",
},
}, },
], },
}, },
], ],
}, },
@ -430,28 +420,24 @@ describe("Paragraph", () => {
{ {
"w:pBdr": [ "w:pBdr": [
{ {
"w:left": [ "w:left": {
{ _attr: {
_attr: { "w:color": "auto",
"w:color": "auto", "w:space": "1",
"w:space": "1", "w:sz": "6",
"w:sz": "6", "w:val": "single",
"w:val": "single",
},
}, },
], },
}, },
{ {
"w:right": [ "w:right": {
{ _attr: {
_attr: { "w:color": "auto",
"w:color": "auto", "w:space": "1",
"w:space": "1", "w:sz": "6",
"w:sz": "6", "w:val": "single",
"w:val": "single",
},
}, },
], },
}, },
], ],
}, },
@ -469,10 +455,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [], "w:r": [{ "w:br": { _attr: { "w:type": "page" } } }],
},
{
"w:r": [{ "w:rPr": [] }, { "w:br": [{ _attr: { "w:type": "page" } }] }],
}, },
], ],
}); });
@ -488,7 +471,7 @@ describe("Paragraph", () => {
{ {
"w:pPr": [ "w:pPr": [
{ {
"w:pageBreakBefore": [], "w:pageBreakBefore": null,
}, },
], ],
}, },
@ -510,7 +493,7 @@ describe("Paragraph", () => {
.which.is.an("array") .which.is.an("array")
.which.has.length.at.least(1); .which.has.length.at.least(1);
expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({ expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
"w:pStyle": [{ _attr: { "w:val": "ListParagraph" } }], "w:pStyle": { _attr: { "w:val": "ListParagraph" } },
}); });
}); });
@ -526,7 +509,7 @@ describe("Paragraph", () => {
.which.is.an("array") .which.is.an("array")
.which.has.length.at.least(1); .which.has.length.at.least(1);
expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({ expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
"w:pStyle": [{ _attr: { "w:val": "ListParagraph" } }], "w:pStyle": { _attr: { "w:val": "ListParagraph" } },
}); });
}); });
@ -542,7 +525,7 @@ describe("Paragraph", () => {
.which.is.an("array") .which.is.an("array")
.which.has.length.at.least(2); .which.has.length.at.least(2);
expect(tree["w:p"][0]["w:pPr"][1]).to.deep.equal({ expect(tree["w:p"][0]["w:pPr"][1]).to.deep.equal({
"w:numPr": [{ "w:ilvl": [{ _attr: { "w:val": 1 } }] }, { "w:numId": [{ _attr: { "w:val": 1 } }] }], "w:numPr": [{ "w:ilvl": { _attr: { "w:val": 1 } } }, { "w:numId": { _attr: { "w:val": 1 } } }],
}); });
}); });
}); });
@ -565,7 +548,7 @@ describe("Paragraph", () => {
.which.is.an("array") .which.is.an("array")
.which.has.length.at.least(1); .which.has.length.at.least(1);
expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({ expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
"w:pStyle": [{ _attr: { "w:val": "ListParagraph" } }], "w:pStyle": { _attr: { "w:val": "ListParagraph" } },
}); });
}); });
@ -581,11 +564,11 @@ describe("Paragraph", () => {
"w:p": [ "w:p": [
{ {
"w:pPr": [ "w:pPr": [
{ "w:pStyle": [{ _attr: { "w:val": "ListParagraph" } }] }, { "w:pStyle": { _attr: { "w:val": "ListParagraph" } } },
{ {
"w:numPr": [ "w:numPr": [
{ "w:ilvl": [{ _attr: { "w:val": 0 } }] }, { "w:ilvl": { _attr: { "w:val": 0 } } },
{ "w:numId": [{ _attr: { "w:val": letterNumbering.id } }] }, { "w:numId": { _attr: { "w:val": letterNumbering.id } } },
], ],
}, },
], ],
@ -602,7 +585,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:pStyle": [{ _attr: { "w:val": "myFancyStyle" } }] }], "w:pPr": [{ "w:pStyle": { _attr: { "w:val": "myFancyStyle" } } }],
}, },
], ],
}); });
@ -616,7 +599,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:ind": [{ _attr: { "w:left": 720 } }] }], "w:pPr": [{ "w:ind": { _attr: { "w:left": 720 } } }],
}, },
], ],
}); });
@ -630,7 +613,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:spacing": [{ _attr: { "w:before": 90, "w:line": 50 } }] }], "w:pPr": [{ "w:spacing": { _attr: { "w:before": 90, "w:line": 50 } } }],
}, },
], ],
}); });
@ -642,7 +625,7 @@ describe("Paragraph", () => {
paragraph.keepLines(); paragraph.keepLines();
const tree = new Formatter().format(paragraph); const tree = new Formatter().format(paragraph);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [{ "w:pPr": [{ "w:keepLines": [] }] }], "w:p": [{ "w:pPr": [{ "w:keepLines": null }] }],
}); });
}); });
}); });
@ -652,7 +635,7 @@ describe("Paragraph", () => {
paragraph.keepNext(); paragraph.keepNext();
const tree = new Formatter().format(paragraph); const tree = new Formatter().format(paragraph);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [{ "w:pPr": [{ "w:keepNext": [] }] }], "w:p": [{ "w:pPr": [{ "w:keepNext": null }] }],
}); });
}); });
}); });
@ -662,7 +645,7 @@ describe("Paragraph", () => {
paragraph.bidirectional(); paragraph.bidirectional();
const tree = new Formatter().format(paragraph); const tree = new Formatter().format(paragraph);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [{ "w:pPr": [{ "w:bidi": [] }] }], "w:p": [{ "w:pPr": [{ "w:bidi": null }] }],
}); });
}); });
}); });
@ -674,7 +657,7 @@ describe("Paragraph", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:p": [ "w:p": [
{ {
"w:pPr": [{ "w:outlineLvl": [{ _attr: { "w:val": "0" } }] }], "w:pPr": [{ "w:outlineLvl": { _attr: { "w:val": "0" } } }],
}, },
], ],
}); });

4
src/file/paragraph/properties.ts
View File

@ -1,8 +1,8 @@
// http://officeopenxml.com/WPparagraphProperties.php // http://officeopenxml.com/WPparagraphProperties.php
import { XmlComponent } from "file/xml-components"; import { IgnoreIfEmptyXmlComponent, XmlComponent } from "file/xml-components";
import { Border } from "./formatting/border"; import { Border } from "./formatting/border";
export class ParagraphProperties extends XmlComponent { export class ParagraphProperties extends IgnoreIfEmptyXmlComponent {
public readonly paragraphBorder: Border; public readonly paragraphBorder: Border;
constructor() { constructor() {

4
src/file/paragraph/run/properties.ts
View File

@ -1,6 +1,6 @@
import { XmlComponent } from "file/xml-components"; import { IgnoreIfEmptyXmlComponent, XmlComponent } from "file/xml-components";
export class RunProperties extends XmlComponent { export class RunProperties extends IgnoreIfEmptyXmlComponent {
constructor() { constructor() {
super("w:rPr"); super("w:rPr");
} }

2
src/file/paragraph/run/run-components/text.spec.ts
View File

@ -9,7 +9,7 @@ describe("Text", () => {
it("creates an empty text run if no text is given", () => { it("creates an empty text run if no text is given", () => {
const t = new Text(""); const t = new Text("");
const f = new Formatter().format(t); const f = new Formatter().format(t);
expect(f).to.deep.equal({ "w:t": [{ _attr: { "xml:space": "preserve" } }] }); expect(f).to.deep.equal({ "w:t": { _attr: { "xml:space": "preserve" } } });
}); });
it("adds the passed in text to the component", () => { it("adds the passed in text to the component", () => {

8
src/file/paragraph/run/run-fonts.spec.ts
View File

@ -9,16 +9,16 @@ describe("RunFonts", () => {
it("uses the font name for both ascii and hAnsi", () => { it("uses the font name for both ascii and hAnsi", () => {
const tree = new Formatter().format(new RunFonts("Times")); const tree = new Formatter().format(new RunFonts("Times"));
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:rFonts": [{ _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times" } }], "w:rFonts": { _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times" } },
}); });
}); });
it("uses hint if given", () => { it("uses hint if given", () => {
const tree = new Formatter().format(new RunFonts("Times", "default")); const tree = new Formatter().format(new RunFonts("Times", "default"));
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:rFonts": [ "w:rFonts": {
{ _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times", "w:hint": "default" } }, _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times", "w:hint": "default" },
], },
}); });
}); });
}); });

28
src/file/paragraph/run/run.spec.ts
View File

@ -41,7 +41,7 @@ describe("Run", () => {
run.underline(); run.underline();
const tree = new Formatter().format(run); const tree = new Formatter().format(run);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:r": [{ "w:rPr": [{ "w:u": [{ _attr: { "w:val": "single" } }] }] }], "w:r": [{ "w:rPr": [{ "w:u": { _attr: { "w:val": "single" } } }] }],
}); });
}); });
@ -49,7 +49,7 @@ describe("Run", () => {
run.underline("double", "990011"); run.underline("double", "990011");
const tree = new Formatter().format(run); const tree = new Formatter().format(run);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:r": [{ "w:rPr": [{ "w:u": [{ _attr: { "w:val": "double", "w:color": "990011" } }] }] }], "w:r": [{ "w:rPr": [{ "w:u": { _attr: { "w:val": "double", "w:color": "990011" } } }] }],
}); });
}); });
}); });
@ -114,7 +114,7 @@ describe("Run", () => {
"w:r": [ "w:r": [
{ {
"w:rPr": [ "w:rPr": [
{ "w:rFonts": [{ _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times" } }] }, { "w:rFonts": { _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times" } } },
], ],
}, },
], ],
@ -127,7 +127,7 @@ describe("Run", () => {
run.color("001122"); run.color("001122");
const tree = new Formatter().format(run); const tree = new Formatter().format(run);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:r": [{ "w:rPr": [{ "w:color": [{ _attr: { "w:val": "001122" } }] }] }], "w:r": [{ "w:rPr": [{ "w:color": { _attr: { "w:val": "001122" } } }] }],
}); });
}); });
}); });
@ -139,7 +139,7 @@ describe("Run", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:r": [ "w:r": [
{ {
"w:rPr": [{ "w:sz": [{ _attr: { "w:val": 24 } }] }, { "w:szCs": [{ _attr: { "w:val": 24 } }] }], "w:rPr": [{ "w:sz": { _attr: { "w:val": 24 } } }, { "w:szCs": { _attr: { "w:val": 24 } } }],
}, },
], ],
}); });
@ -151,7 +151,7 @@ describe("Run", () => {
run.rightToLeft(); run.rightToLeft();
const tree = new Formatter().format(run); const tree = new Formatter().format(run);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:r": [{ "w:rPr": [{ "w:rtl": [{ _attr: { "w:val": true } }] }] }], "w:r": [{ "w:rPr": [{ "w:rtl": { _attr: { "w:val": true } } }] }],
}); });
}); });
}); });
@ -162,11 +162,10 @@ describe("Run", () => {
const tree = new Formatter().format(run); const tree = new Formatter().format(run);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:r": [ "w:r": [
{ "w:rPr": [] }, { "w:fldChar": { _attr: { "w:fldCharType": "begin" } } },
{ "w:fldChar": [{ _attr: { "w:fldCharType": "begin" } }] },
{ "w:instrText": [{ _attr: { "xml:space": "preserve" } }, "NUMPAGES"] }, { "w:instrText": [{ _attr: { "xml:space": "preserve" } }, "NUMPAGES"] },
{ "w:fldChar": [{ _attr: { "w:fldCharType": "separate" } }] }, { "w:fldChar": { _attr: { "w:fldCharType": "separate" } } },
{ "w:fldChar": [{ _attr: { "w:fldCharType": "end" } }] }, { "w:fldChar": { _attr: { "w:fldCharType": "end" } } },
], ],
}); });
}); });
@ -178,11 +177,10 @@ describe("Run", () => {
const tree = new Formatter().format(run); const tree = new Formatter().format(run);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:r": [ "w:r": [
{ "w:rPr": [] }, { "w:fldChar": { _attr: { "w:fldCharType": "begin" } } },
{ "w:fldChar": [{ _attr: { "w:fldCharType": "begin" } }] },
{ "w:instrText": [{ _attr: { "xml:space": "preserve" } }, "PAGE"] }, { "w:instrText": [{ _attr: { "xml:space": "preserve" } }, "PAGE"] },
{ "w:fldChar": [{ _attr: { "w:fldCharType": "separate" } }] }, { "w:fldChar": { _attr: { "w:fldCharType": "separate" } } },
{ "w:fldChar": [{ _attr: { "w:fldCharType": "end" } }] }, { "w:fldChar": { _attr: { "w:fldCharType": "end" } } },
], ],
}); });
}); });
@ -193,7 +191,7 @@ describe("Run", () => {
run.style("myRunStyle"); run.style("myRunStyle");
const tree = new Formatter().format(run); const tree = new Formatter().format(run);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:r": [{ "w:rPr": [{ "w:rStyle": [{ _attr: { "w:val": "myRunStyle" } }] }] }], "w:r": [{ "w:rPr": [{ "w:rStyle": { _attr: { "w:val": "myRunStyle" } } }] }],
}); });
}); });
}); });

35
src/file/paragraph/run/sequential-identifier.spec.ts
View File

@ -17,17 +17,12 @@ describe("Sequential Identifier", () => {
const DEFAULT_SEQ = { const DEFAULT_SEQ = {
"w:r": [ "w:r": [
{ {
"w:rPr": [], "w:fldChar": {
}, _attr: {
{ "w:fldCharType": "begin",
"w:fldChar": [ "w:dirty": true,
{
_attr: {
"w:fldCharType": "begin",
"w:dirty": true,
},
}, },
], },
}, },
{ {
"w:instrText": [ "w:instrText": [
@ -40,22 +35,18 @@ const DEFAULT_SEQ = {
], ],
}, },
{ {
"w:fldChar": [ "w:fldChar": {
{ _attr: {
_attr: { "w:fldCharType": "separate",
"w:fldCharType": "separate",
},
}, },
], },
}, },
{ {
"w:fldChar": [ "w:fldChar": {
{ _attr: {
_attr: { "w:fldCharType": "end",
"w:fldCharType": "end",
},
}, },
], },
}, },
], ],
}; };

2
src/file/paragraph/run/text-run.spec.ts
View File

@ -12,7 +12,7 @@ describe("TextRun", () => {
run = new TextRun("test"); run = new TextRun("test");
const f = new Formatter().format(run); const f = new Formatter().format(run);
expect(f).to.deep.equal({ expect(f).to.deep.equal({
"w:r": [{ "w:rPr": [] }, { "w:t": [{ _attr: { "xml:space": "preserve" } }, "test"] }], "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "test"] }],
}); });
}); });
}); });

4
src/file/paragraph/run/underline.spec.ts
View File

@ -17,7 +17,7 @@ describe("Underline", () => {
const underline = new u.Underline(); const underline = new u.Underline();
const tree = new Formatter().format(underline); const tree = new Formatter().format(underline);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:u": [{ _attr: { "w:val": "single" } }], "w:u": { _attr: { "w:val": "single" } },
}); });
}); });
@ -25,7 +25,7 @@ describe("Underline", () => {
const underline = new u.Underline("double", "FF00CC"); const underline = new u.Underline("double", "FF00CC");
const tree = new Formatter().format(underline); const tree = new Formatter().format(underline);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:u": [{ _attr: { "w:val": "double", "w:color": "FF00CC" } }], "w:u": { _attr: { "w:val": "double", "w:color": "FF00CC" } },
}); });
}); });
}); });

3
src/file/relationships/relationships.spec.ts
View File

@ -11,8 +11,7 @@ describe("Relationships", () => {
const properties = new Relationships(); const properties = new Relationships();
const tree = new Formatter().format(properties); const tree = new Formatter().format(properties);
expect(Object.keys(tree)).to.deep.equal(["Relationships"]); expect(Object.keys(tree)).to.deep.equal(["Relationships"]);
expect(tree["Relationships"]).to.be.an.instanceof(Array); expect(tree["Relationships"]).to.deep.equal({
expect(tree["Relationships"][0]).to.deep.equal({
_attr: { xmlns: "http://schemas.openxmlformats.org/package/2006/relationships" }, _attr: { xmlns: "http://schemas.openxmlformats.org/package/2006/relationships" },
}); });
}); });

4
src/file/settings/compatibility.spec.ts
View File

@ -8,7 +8,7 @@ describe("Compatibility", () => {
const compatibility = new Compatibility(); const compatibility = new Compatibility();
const tree = new Formatter().format(compatibility); const tree = new Formatter().format(compatibility);
expect(tree).to.deep.equal({ "w:compat": [] }); expect(tree).to.deep.equal({ "w:compat": null });
}); });
}); });
@ -18,7 +18,7 @@ describe("Compatibility", () => {
compatibility.doNotExpandShiftReturn(); compatibility.doNotExpandShiftReturn();
const tree = new Formatter().format(compatibility); const tree = new Formatter().format(compatibility);
expect(tree).to.deep.equal({ "w:compat": [{ "w:doNotExpandShiftReturn": [] }] }); expect(tree).to.deep.equal({ "w:compat": [{ "w:doNotExpandShiftReturn": null }] });
}); });
}); });
}); });

10
src/file/settings/settings.spec.ts
View File

@ -13,9 +13,7 @@ describe("Settings", () => {
expect(keys).is.an.instanceof(Array); expect(keys).is.an.instanceof(Array);
expect(keys).has.length(1); expect(keys).has.length(1);
expect(keys[0]).to.be.equal("w:settings"); expect(keys[0]).to.be.equal("w:settings");
expect(tree["w:settings"]).is.an.instanceof(Array); keys = Object.keys(tree["w:settings"]);
expect(tree["w:settings"]).has.length(1);
keys = Object.keys(tree["w:settings"][0]);
expect(keys).is.an.instanceof(Array); expect(keys).is.an.instanceof(Array);
expect(keys).has.length(1); expect(keys).has.length(1);
expect(keys[0]).to.be.equal("_attr"); expect(keys[0]).to.be.equal("_attr");
@ -39,12 +37,12 @@ describe("Settings", () => {
expect(keys).is.an.instanceof(Array); expect(keys).is.an.instanceof(Array);
expect(keys).has.length(1); expect(keys).has.length(1);
expect(keys[0]).to.be.equal("w:updateFields"); expect(keys[0]).to.be.equal("w:updateFields");
const updateFieldsArray = rootArray[1]["w:updateFields"]; const updateFields = rootArray[1]["w:updateFields"];
keys = Object.keys(updateFieldsArray[0]); keys = Object.keys(updateFields);
expect(keys).is.an.instanceof(Array); expect(keys).is.an.instanceof(Array);
expect(keys).has.length(1); expect(keys).has.length(1);
expect(keys[0]).to.be.equal("_attr"); expect(keys[0]).to.be.equal("_attr");
const updateFieldsAttr = updateFieldsArray[0]._attr; const updateFieldsAttr = updateFields._attr;
expect(updateFieldsAttr["w:val"]).to.be.equal(true); expect(updateFieldsAttr["w:val"]).to.be.equal(true);
}; };
it("should add a UpdateFields with value true", () => { it("should add a UpdateFields with value true", () => {

20
src/file/settings/update-fields.spec.ts
View File

@ -5,22 +5,18 @@ import { Formatter } from "export/formatter";
import { UpdateFields } from "./update-fields"; import { UpdateFields } from "./update-fields";
const UF_TRUE = { const UF_TRUE = {
"w:updateFields": [ "w:updateFields": {
{ _attr: {
_attr: { "w:val": true,
"w:val": true,
},
}, },
], },
}; };
const UF_FALSE = { const UF_FALSE = {
"w:updateFields": [ "w:updateFields": {
{ _attr: {
_attr: { "w:val": false,
"w:val": false,
},
}, },
], },
}; };
describe("Update Fields", () => { describe("Update Fields", () => {
describe("#constructor", () => { describe("#constructor", () => {

152
src/file/styles/external-styles-factory.spec.ts
View File

@ -71,24 +71,34 @@ describe("External styles factory", () => {
deleted: false, deleted: false,
root: [ root: [
{ {
_attr: {
"w:ascii": "Arial",
"w:cstheme": "minorHAnsi",
"w:eastAsiaTheme": "minorHAnsi",
"w:hAnsi": "Arial",
},
deleted: false, deleted: false,
root: [], root: [
{
deleted: false,
root: {
"w:ascii": "Arial",
"w:cstheme": "minorHAnsi",
"w:eastAsiaTheme": "minorHAnsi",
"w:hAnsi": "Arial",
},
rootKey: "_attr",
},
],
rootKey: "w:rFonts", rootKey: "w:rFonts",
}, },
{ {
_attr: {
"w:bidi": "ar-SA",
"w:eastAsia": "en-US",
"w:val": "en-US",
},
deleted: false, deleted: false,
root: [], root: [
{
deleted: false,
root: {
"w:bidi": "ar-SA",
"w:eastAsia": "en-US",
"w:val": "en-US",
},
rootKey: "_attr",
},
],
rootKey: "w:lang", rootKey: "w:lang",
}, },
], ],
@ -104,13 +114,18 @@ describe("External styles factory", () => {
deleted: false, deleted: false,
root: [ root: [
{ {
_attr: {
"w:after": "160",
"w:line": "259",
"w:lineRule": "auto",
},
deleted: false, deleted: false,
root: [], root: [
{
deleted: false,
root: {
"w:after": "160",
"w:line": "259",
"w:lineRule": "auto",
},
rootKey: "_attr",
},
],
rootKey: "w:spacing", rootKey: "w:spacing",
}, },
], ],
@ -123,12 +138,17 @@ describe("External styles factory", () => {
rootKey: "w:docDefaults", rootKey: "w:docDefaults",
}); });
expect(importedStyle.root[2]).to.deep.equal({ expect(importedStyle.root[2]).to.deep.equal({
_attr: {
"w:defLockedState": "1",
"w:defUIPriority": "99",
},
deleted: false, deleted: false,
root: [], root: [
{
deleted: false,
root: {
"w:defLockedState": "1",
"w:defUIPriority": "99",
},
rootKey: "_attr",
},
],
rootKey: "w:latentStyles", rootKey: "w:latentStyles",
}); });
}); });
@ -139,19 +159,28 @@ describe("External styles factory", () => {
expect(importedStyle.root.length).to.equal(5); expect(importedStyle.root.length).to.equal(5);
expect(importedStyle.root[3]).to.deep.equal({ expect(importedStyle.root[3]).to.deep.equal({
_attr: {
"w:default": "1",
"w:styleId": "Normal",
"w:type": "paragraph",
},
deleted: false, deleted: false,
root: [ root: [
{ {
_attr: {
"w:val": "Normal",
},
deleted: false, deleted: false,
root: [], root: {
"w:default": "1",
"w:styleId": "Normal",
"w:type": "paragraph",
},
rootKey: "_attr",
},
{
deleted: false,
root: [
{
deleted: false,
root: {
"w:val": "Normal",
},
rootKey: "_attr",
},
],
rootKey: "w:name", rootKey: "w:name",
}, },
{ {
@ -164,26 +193,40 @@ describe("External styles factory", () => {
}); });
expect(importedStyle.root[4]).to.deep.equal({ expect(importedStyle.root[4]).to.deep.equal({
_attr: {
"w:styleId": "Heading1",
"w:type": "paragraph",
},
deleted: false, deleted: false,
root: [ root: [
{ {
_attr: {
"w:val": "heading 1",
},
deleted: false, deleted: false,
root: [], root: {
"w:styleId": "Heading1",
"w:type": "paragraph",
},
rootKey: "_attr",
},
{
deleted: false,
root: [
{
deleted: false,
root: {
"w:val": "heading 1",
},
rootKey: "_attr",
},
],
rootKey: "w:name", rootKey: "w:name",
}, },
{ {
_attr: {
"w:val": "Normal",
},
deleted: false, deleted: false,
root: [], root: [
{
deleted: false,
root: {
"w:val": "Normal",
},
rootKey: "_attr",
},
],
rootKey: "w:basedOn", rootKey: "w:basedOn",
}, },
{ {
@ -203,14 +246,19 @@ describe("External styles factory", () => {
deleted: false, deleted: false,
root: [ root: [
{ {
_attr: {
"w:color": "auto",
"w:space": "1",
"w:sz": "4",
"w:val": "single",
},
deleted: false, deleted: false,
root: [], root: [
{
deleted: false,
root: {
"w:color": "auto",
"w:space": "1",
"w:sz": "4",
"w:val": "single",
},
rootKey: "_attr",
},
],
rootKey: "w:bottom", rootKey: "w:bottom",
}, },
], ],

201
src/file/styles/style/character-style.spec.ts
View File

@ -12,18 +12,15 @@ describe("CharacterStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ "w:rPr": [] },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -35,19 +32,16 @@ describe("CharacterStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ "w:name": [{ _attr: { "w:val": "Style Name" } }] }, { "w:name": { _attr: { "w:val": "Style Name" } } },
{ "w:rPr": [] },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -61,20 +55,17 @@ describe("CharacterStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ "w:rPr": [] },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
{ "w:basedOn": [{ _attr: { "w:val": "otherId" } }] }, { "w:basedOn": { _attr: { "w:val": "otherId" } } },
], ],
}); });
}); });
@ -88,19 +79,17 @@ describe("CharacterStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ {
"w:rPr": [{ "w:sz": [{ _attr: { "w:val": 24 } }] }, { "w:szCs": [{ _attr: { "w:val": 24 } }] }], "w:rPr": [{ "w:sz": { _attr: { "w:val": 24 } } }, { "w:szCs": { _attr: { "w:val": 24 } } }],
}, },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -114,19 +103,17 @@ describe("CharacterStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ {
"w:rPr": [{ "w:u": [{ _attr: { "w:val": "single" } }] }], "w:rPr": [{ "w:u": { _attr: { "w:val": "single" } } }],
}, },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -139,19 +126,17 @@ describe("CharacterStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ {
"w:rPr": [{ "w:u": [{ _attr: { "w:val": "double" } }] }], "w:rPr": [{ "w:u": { _attr: { "w:val": "double" } } }],
}, },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -164,19 +149,17 @@ describe("CharacterStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ {
"w:rPr": [{ "w:u": [{ _attr: { "w:val": "double", "w:color": "005599" } }] }], "w:rPr": [{ "w:u": { _attr: { "w:val": "double", "w:color": "005599" } } }],
}, },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -192,27 +175,23 @@ describe("CharacterStyle", () => {
{ {
"w:rPr": [ "w:rPr": [
{ {
"w:vertAlign": [ "w:vertAlign": {
{ _attr: {
_attr: { "w:val": "superscript",
"w:val": "superscript",
},
}, },
],
},
],
},
{
"w:uiPriority": [
{
_attr: {
"w:val": "99",
}, },
}, },
], ],
}, },
{ {
"w:unhideWhenUsed": [], "w:uiPriority": {
_attr: {
"w:val": "99",
},
},
},
{
"w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -225,19 +204,17 @@ describe("CharacterStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ {
"w:rPr": [{ "w:color": [{ _attr: { "w:val": "123456" } }] }], "w:rPr": [{ "w:color": { _attr: { "w:val": "123456" } } }],
}, },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -250,19 +227,17 @@ describe("CharacterStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ {
"w:rPr": [{ "w:b": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:b": { _attr: { "w:val": true } } }],
}, },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -275,19 +250,17 @@ describe("CharacterStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ {
"w:rPr": [{ "w:i": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:i": { _attr: { "w:val": true } } }],
}, },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -300,21 +273,16 @@ describe("CharacterStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ {
"w:rPr": [], "w:uiPriority": {
}, _attr: {
{ "w:val": "99",
"w:uiPriority": [
{
_attr: {
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
{ "w:link": [{ _attr: { "w:val": "MyLink" } }] }, { "w:link": { _attr: { "w:val": "MyLink" } } },
], ],
}); });
}); });
@ -326,19 +294,14 @@ describe("CharacterStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "myStyleId" } },
{ {
"w:rPr": [], "w:uiPriority": {
}, _attr: {
{ "w:val": "99",
"w:uiPriority": [
{
_attr: {
"w:val": "99",
},
}, },
], },
}, },
{ "w:unhideWhenUsed": [] }, { "w:unhideWhenUsed": null },
{ "w:semiHidden": [] }, { "w:semiHidden": null },
], ],
}); });
}); });

16
src/file/styles/style/components.spec.ts
View File

@ -6,48 +6,48 @@ describe("Style components", () => {
it("Name#constructor", () => { it("Name#constructor", () => {
const style = new components.Name("Style Name"); const style = new components.Name("Style Name");
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ "w:name": [{ _attr: { "w:val": "Style Name" } }] }); expect(tree).to.deep.equal({ "w:name": { _attr: { "w:val": "Style Name" } } });
}); });
it("BasedOn#constructor", () => { it("BasedOn#constructor", () => {
const style = new components.BasedOn("otherId"); const style = new components.BasedOn("otherId");
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ "w:basedOn": [{ _attr: { "w:val": "otherId" } }] }); expect(tree).to.deep.equal({ "w:basedOn": { _attr: { "w:val": "otherId" } } });
}); });
it("Next#constructor", () => { it("Next#constructor", () => {
const style = new components.Next("otherId"); const style = new components.Next("otherId");
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ "w:next": [{ _attr: { "w:val": "otherId" } }] }); expect(tree).to.deep.equal({ "w:next": { _attr: { "w:val": "otherId" } } });
}); });
it("Link#constructor", () => { it("Link#constructor", () => {
const style = new components.Link("otherId"); const style = new components.Link("otherId");
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ "w:link": [{ _attr: { "w:val": "otherId" } }] }); expect(tree).to.deep.equal({ "w:link": { _attr: { "w:val": "otherId" } } });
}); });
it("UiPriority#constructor", () => { it("UiPriority#constructor", () => {
const style = new components.UiPriority("123"); const style = new components.UiPriority("123");
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ "w:uiPriority": [{ _attr: { "w:val": "123" } }] }); expect(tree).to.deep.equal({ "w:uiPriority": { _attr: { "w:val": "123" } } });
}); });
it("UnhideWhenUsed#constructor", () => { it("UnhideWhenUsed#constructor", () => {
const style = new components.UnhideWhenUsed(); const style = new components.UnhideWhenUsed();
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ "w:unhideWhenUsed": [] }); expect(tree).to.deep.equal({ "w:unhideWhenUsed": null });
}); });
it("QuickFormat#constructor", () => { it("QuickFormat#constructor", () => {
const style = new components.QuickFormat(); const style = new components.QuickFormat();
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ "w:qFormat": [] }); expect(tree).to.deep.equal({ "w:qFormat": null });
}); });
it("SemiHidden#constructor", () => { it("SemiHidden#constructor", () => {
const style = new components.SemiHidden(); const style = new components.SemiHidden();
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ "w:semiHidden": [] }); expect(tree).to.deep.equal({ "w:semiHidden": null });
}); });
}); });

240
src/file/styles/style/default-styles.spec.ts
View File

@ -9,12 +9,10 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "Heading1" } }, { _attr: { "w:type": "paragraph", "w:styleId": "Heading1" } },
{ "w:name": [{ _attr: { "w:val": "Heading 1" } }] }, { "w:name": { _attr: { "w:val": "Heading 1" } } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:rPr": [] }, { "w:next": { _attr: { "w:val": "Normal" } } },
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] }, { "w:qFormat": null },
{ "w:next": [{ _attr: { "w:val": "Normal" } }] },
{ "w:qFormat": [] },
], ],
}); });
}); });
@ -25,12 +23,10 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "Title" } }, { _attr: { "w:type": "paragraph", "w:styleId": "Title" } },
{ "w:name": [{ _attr: { "w:val": "Title" } }] }, { "w:name": { _attr: { "w:val": "Title" } } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:rPr": [] }, { "w:next": { _attr: { "w:val": "Normal" } } },
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] }, { "w:qFormat": null },
{ "w:next": [{ _attr: { "w:val": "Normal" } }] },
{ "w:qFormat": [] },
], ],
}); });
}); });
@ -41,12 +37,10 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "Heading1" } }, { _attr: { "w:type": "paragraph", "w:styleId": "Heading1" } },
{ "w:name": [{ _attr: { "w:val": "Heading 1" } }] }, { "w:name": { _attr: { "w:val": "Heading 1" } } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:rPr": [] }, { "w:next": { _attr: { "w:val": "Normal" } } },
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] }, { "w:qFormat": null },
{ "w:next": [{ _attr: { "w:val": "Normal" } }] },
{ "w:qFormat": [] },
], ],
}); });
}); });
@ -57,12 +51,10 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "Heading2" } }, { _attr: { "w:type": "paragraph", "w:styleId": "Heading2" } },
{ "w:name": [{ _attr: { "w:val": "Heading 2" } }] }, { "w:name": { _attr: { "w:val": "Heading 2" } } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:rPr": [] }, { "w:next": { _attr: { "w:val": "Normal" } } },
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] }, { "w:qFormat": null },
{ "w:next": [{ _attr: { "w:val": "Normal" } }] },
{ "w:qFormat": [] },
], ],
}); });
}); });
@ -73,12 +65,10 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "Heading3" } }, { _attr: { "w:type": "paragraph", "w:styleId": "Heading3" } },
{ "w:name": [{ _attr: { "w:val": "Heading 3" } }] }, { "w:name": { _attr: { "w:val": "Heading 3" } } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:rPr": [] }, { "w:next": { _attr: { "w:val": "Normal" } } },
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] }, { "w:qFormat": null },
{ "w:next": [{ _attr: { "w:val": "Normal" } }] },
{ "w:qFormat": [] },
], ],
}); });
}); });
@ -89,12 +79,10 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "Heading4" } }, { _attr: { "w:type": "paragraph", "w:styleId": "Heading4" } },
{ "w:name": [{ _attr: { "w:val": "Heading 4" } }] }, { "w:name": { _attr: { "w:val": "Heading 4" } } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:rPr": [] }, { "w:next": { _attr: { "w:val": "Normal" } } },
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] }, { "w:qFormat": null },
{ "w:next": [{ _attr: { "w:val": "Normal" } }] },
{ "w:qFormat": [] },
], ],
}); });
}); });
@ -105,12 +93,10 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "Heading5" } }, { _attr: { "w:type": "paragraph", "w:styleId": "Heading5" } },
{ "w:name": [{ _attr: { "w:val": "Heading 5" } }] }, { "w:name": { _attr: { "w:val": "Heading 5" } } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:rPr": [] }, { "w:next": { _attr: { "w:val": "Normal" } } },
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] }, { "w:qFormat": null },
{ "w:next": [{ _attr: { "w:val": "Normal" } }] },
{ "w:qFormat": [] },
], ],
}); });
}); });
@ -121,12 +107,10 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "Heading6" } }, { _attr: { "w:type": "paragraph", "w:styleId": "Heading6" } },
{ "w:name": [{ _attr: { "w:val": "Heading 6" } }] }, { "w:name": { _attr: { "w:val": "Heading 6" } } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:rPr": [] }, { "w:next": { _attr: { "w:val": "Normal" } } },
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] }, { "w:qFormat": null },
{ "w:next": [{ _attr: { "w:val": "Normal" } }] },
{ "w:qFormat": [] },
], ],
}); });
}); });
@ -137,11 +121,9 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "ListParagraph" } }, { _attr: { "w:type": "paragraph", "w:styleId": "ListParagraph" } },
{ "w:name": [{ _attr: { "w:val": "List Paragraph" } }] }, { "w:name": { _attr: { "w:val": "List Paragraph" } } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:rPr": [] }, { "w:qFormat": null },
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] },
{ "w:qFormat": [] },
], ],
}); });
}); });
@ -152,60 +134,52 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "FootnoteText" } }, { _attr: { "w:type": "paragraph", "w:styleId": "FootnoteText" } },
{ "w:name": [{ _attr: { "w:val": "footnote text" } }] }, { "w:name": { _attr: { "w:val": "footnote text" } } },
{ {
"w:pPr": [ "w:pPr": [
{ {
"w:spacing": [ "w:spacing": {
{ _attr: {
_attr: { "w:after": 0,
"w:after": 0, "w:line": 240,
"w:line": 240, "w:lineRule": "auto",
"w:lineRule": "auto",
},
}, },
], },
}, },
], ],
}, },
{ {
"w:rPr": [ "w:rPr": [
{ {
"w:sz": [ "w:sz": {
{ _attr: {
_attr: { "w:val": 20,
"w:val": 20,
},
}, },
], },
}, },
{ {
"w:szCs": [ "w:szCs": {
{ _attr: {
_attr: { "w:val": 20,
"w:val": 20,
},
}, },
],
},
],
},
{ "w:basedOn": [{ _attr: { "w:val": "Normal" } }] },
{ "w:link": [{ _attr: { "w:val": "FootnoteTextChar" } }] },
{
"w:uiPriority": [
{
_attr: {
"w:val": "99",
}, },
}, },
], ],
}, },
{ "w:basedOn": { _attr: { "w:val": "Normal" } } },
{ "w:link": { _attr: { "w:val": "FootnoteTextChar" } } },
{ {
"w:semiHidden": [], "w:uiPriority": {
_attr: {
"w:val": "99",
},
},
}, },
{ {
"w:unhideWhenUsed": [], "w:semiHidden": null,
},
{
"w:unhideWhenUsed": null,
}, },
], ],
}); });
@ -217,36 +191,32 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "FootnoteReference" } }, { _attr: { "w:type": "character", "w:styleId": "FootnoteReference" } },
{ "w:name": [{ _attr: { "w:val": "footnote reference" } }] }, { "w:name": { _attr: { "w:val": "footnote reference" } } },
{ {
"w:rPr": [ "w:rPr": [
{ {
"w:vertAlign": [ "w:vertAlign": {
{ _attr: {
_attr: { "w:val": "superscript",
"w:val": "superscript",
},
}, },
],
},
],
},
{
"w:uiPriority": [
{
_attr: {
"w:val": "99",
}, },
}, },
], ],
}, },
{ {
"w:unhideWhenUsed": [], "w:uiPriority": {
_attr: {
"w:val": "99",
},
},
}, },
{ "w:basedOn": [{ _attr: { "w:val": "DefaultParagraphFont" } }] }, {
"w:unhideWhenUsed": null,
},
{ "w:basedOn": { _attr: { "w:val": "DefaultParagraphFont" } } },
{ {
"w:semiHidden": [], "w:semiHidden": null,
}, },
], ],
}); });
@ -258,45 +228,39 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "FootnoteTextChar" } }, { _attr: { "w:type": "character", "w:styleId": "FootnoteTextChar" } },
{ "w:name": [{ _attr: { "w:val": "Footnote Text Char" } }] }, { "w:name": { _attr: { "w:val": "Footnote Text Char" } } },
{ {
"w:rPr": [ "w:rPr": [
{ {
"w:sz": [ "w:sz": {
{ _attr: {
_attr: { "w:val": 20,
"w:val": 20,
},
}, },
], },
}, },
{ {
"w:szCs": [ "w:szCs": {
{ _attr: {
_attr: { "w:val": 20,
"w:val": 20,
},
}, },
],
},
],
},
{
"w:uiPriority": [
{
_attr: {
"w:val": "99",
}, },
}, },
], ],
}, },
{ {
"w:unhideWhenUsed": [], "w:uiPriority": {
_attr: {
"w:val": "99",
},
},
}, },
{ "w:basedOn": [{ _attr: { "w:val": "DefaultParagraphFont" } }] },
{ "w:link": [{ _attr: { "w:val": "FootnoteText" } }] },
{ {
"w:semiHidden": [], "w:unhideWhenUsed": null,
},
{ "w:basedOn": { _attr: { "w:val": "DefaultParagraphFont" } } },
{ "w:link": { _attr: { "w:val": "FootnoteText" } } },
{
"w:semiHidden": null,
}, },
], ],
}); });
@ -308,23 +272,21 @@ describe("Default Styles", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "Hyperlink" } }, { _attr: { "w:type": "character", "w:styleId": "Hyperlink" } },
{ "w:name": [{ _attr: { "w:val": "Hyperlink" } }] }, { "w:name": { _attr: { "w:val": "Hyperlink" } } },
{ {
"w:rPr": [{ "w:color": [{ _attr: { "w:val": "0563C1" } }] }, { "w:u": [{ _attr: { "w:val": "single" } }] }], "w:rPr": [{ "w:color": { _attr: { "w:val": "0563C1" } } }, { "w:u": { _attr: { "w:val": "single" } } }],
}, },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
{ "w:basedOn": [{ _attr: { "w:val": "DefaultParagraphFont" } }] }, { "w:basedOn": { _attr: { "w:val": "DefaultParagraphFont" } } },
], ],
}); });
}); });

155
src/file/styles/style/paragraph-style.spec.ts
View File

@ -10,7 +10,7 @@ describe("ParagraphStyle", () => {
const style = new ParagraphStyle("myStyleId"); const style = new ParagraphStyle("myStyleId");
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { "w:pPr": [] }, { "w:rPr": [] }], "w:style": { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
}); });
}); });
@ -20,9 +20,7 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:name": [{ _attr: { "w:val": "Style Name" } }] }, { "w:name": { _attr: { "w:val": "Style Name" } } },
{ "w:pPr": [] },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -35,9 +33,7 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] }, { "w:basedOn": { _attr: { "w:val": "otherId" } } },
{ "w:rPr": [] },
{ "w:basedOn": [{ _attr: { "w:val": "otherId" } }] },
], ],
}); });
}); });
@ -46,12 +42,7 @@ describe("ParagraphStyle", () => {
const style = new ParagraphStyle("myStyleId").quickFormat(); const style = new ParagraphStyle("myStyleId").quickFormat();
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { "w:qFormat": null }],
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ "w:rPr": [] },
{ "w:qFormat": [] },
],
}); });
}); });
@ -61,9 +52,7 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] }, { "w:next": { _attr: { "w:val": "otherId" } } },
{ "w:rPr": [] },
{ "w:next": [{ _attr: { "w:val": "otherId" } }] },
], ],
}); });
}); });
@ -77,9 +66,8 @@ describe("ParagraphStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ {
"w:pPr": [{ "w:ind": [{ _attr: { "w:left": 720 } }] }], "w:pPr": [{ "w:ind": { _attr: { "w:left": 720 } } }],
}, },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -91,9 +79,8 @@ describe("ParagraphStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ {
"w:pPr": [{ "w:spacing": [{ _attr: { "w:before": 50, "w:after": 150 } }] }], "w:pPr": [{ "w:spacing": { _attr: { "w:before": 50, "w:after": 150 } } }],
}, },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -105,9 +92,8 @@ describe("ParagraphStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "center" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "center" } } }],
}, },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -118,9 +104,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:spacing": [{ _attr: { "w:val": 24 } }] }], "w:rPr": [{ "w:spacing": { _attr: { "w:val": 24 } } }],
}, },
], ],
}); });
@ -133,9 +118,8 @@ describe("ParagraphStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "left" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "left" } } }],
}, },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -147,9 +131,8 @@ describe("ParagraphStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "right" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "right" } } }],
}, },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -161,9 +144,8 @@ describe("ParagraphStyle", () => {
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ {
"w:pPr": [{ "w:jc": [{ _attr: { "w:val": "both" } }] }], "w:pPr": [{ "w:jc": { _attr: { "w:val": "both" } } }],
}, },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -179,22 +161,19 @@ describe("ParagraphStyle", () => {
{ {
"w:pBdr": [ "w:pBdr": [
{ {
"w:bottom": [ "w:bottom": {
{ _attr: {
_attr: { "w:color": "auto",
"w:color": "auto", "w:space": "1",
"w:space": "1", "w:val": "single",
"w:val": "single", "w:sz": "6",
"w:sz": "6",
},
}, },
], },
}, },
], ],
}, },
], ],
}, },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -208,11 +187,10 @@ describe("ParagraphStyle", () => {
{ {
"w:pPr": [ "w:pPr": [
{ {
"w:tabs": [{ "w:tab": [{ _attr: { "w:val": "left", "w:pos": 1200 } }] }], "w:tabs": [{ "w:tab": { _attr: { "w:val": "left", "w:pos": 1200 } } }],
}, },
], ],
}, },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -226,11 +204,10 @@ describe("ParagraphStyle", () => {
{ {
"w:pPr": [ "w:pPr": [
{ {
"w:tabs": [{ "w:tab": [{ _attr: { "w:val": "right", "w:pos": 9026 } }] }], "w:tabs": [{ "w:tab": { _attr: { "w:val": "right", "w:pos": 9026 } } }],
}, },
], ],
}, },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -239,11 +216,7 @@ describe("ParagraphStyle", () => {
const style = new ParagraphStyle("myStyleId").keepLines(); const style = new ParagraphStyle("myStyleId").keepLines();
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { "w:pPr": [{ "w:keepLines": null }] }],
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [{ "w:keepLines": [] }] },
{ "w:rPr": [] },
],
}); });
}); });
@ -251,11 +224,7 @@ describe("ParagraphStyle", () => {
const style = new ParagraphStyle("myStyleId").keepNext(); const style = new ParagraphStyle("myStyleId").keepNext();
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { "w:pPr": [{ "w:keepNext": null }] }],
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [{ "w:keepNext": [] }] },
{ "w:rPr": [] },
],
}); });
}); });
@ -265,8 +234,7 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [{ "w:outlineLvl": [{ _attr: { "w:val": "1" } }] }] }, { "w:pPr": [{ "w:outlineLvl": { _attr: { "w:val": "1" } } }] },
{ "w:rPr": [] },
], ],
}); });
}); });
@ -279,9 +247,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:sz": [{ _attr: { "w:val": 24 } }] }, { "w:szCs": [{ _attr: { "w:val": 24 } }] }], "w:rPr": [{ "w:sz": { _attr: { "w:val": 24 } } }, { "w:szCs": { _attr: { "w:val": 24 } } }],
}, },
], ],
}); });
@ -293,9 +260,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:smallCaps": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:smallCaps": { _attr: { "w:val": true } } }],
}, },
], ],
}); });
@ -307,9 +273,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:caps": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:caps": { _attr: { "w:val": true } } }],
}, },
], ],
}); });
@ -321,9 +286,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:strike": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:strike": { _attr: { "w:val": true } } }],
}, },
], ],
}); });
@ -335,9 +299,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:dstrike": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:dstrike": { _attr: { "w:val": true } } }],
}, },
], ],
}); });
@ -349,9 +312,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:vertAlign": [{ _attr: { "w:val": "subscript" } }] }], "w:rPr": [{ "w:vertAlign": { _attr: { "w:val": "subscript" } } }],
}, },
], ],
}); });
@ -363,9 +325,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:vertAlign": [{ _attr: { "w:val": "superscript" } }] }], "w:rPr": [{ "w:vertAlign": { _attr: { "w:val": "superscript" } } }],
}, },
], ],
}); });
@ -377,10 +338,9 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [ "w:rPr": [
{ "w:rFonts": [{ _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times" } }] }, { "w:rFonts": { _attr: { "w:ascii": "Times", "w:cs": "Times", "w:eastAsia": "Times", "w:hAnsi": "Times" } } },
], ],
}, },
], ],
@ -393,9 +353,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:b": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:b": { _attr: { "w:val": true } } }],
}, },
], ],
}); });
@ -407,9 +366,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:i": [{ _attr: { "w:val": true } }] }], "w:rPr": [{ "w:i": { _attr: { "w:val": true } } }],
}, },
], ],
}); });
@ -422,9 +380,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:u": [{ _attr: { "w:val": "single" } }] }], "w:rPr": [{ "w:u": { _attr: { "w:val": "single" } } }],
}, },
], ],
}); });
@ -436,9 +393,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:u": [{ _attr: { "w:val": "double" } }] }], "w:rPr": [{ "w:u": { _attr: { "w:val": "double" } } }],
}, },
], ],
}); });
@ -450,9 +406,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:u": [{ _attr: { "w:val": "double", "w:color": "005599" } }] }], "w:rPr": [{ "w:u": { _attr: { "w:val": "double", "w:color": "005599" } } }],
}, },
], ],
}); });
@ -465,9 +420,8 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ {
"w:rPr": [{ "w:color": [{ _attr: { "w:val": "123456" } }] }], "w:rPr": [{ "w:color": { _attr: { "w:val": "123456" } } }],
}, },
], ],
}); });
@ -477,12 +431,7 @@ describe("ParagraphStyle", () => {
const style = new ParagraphStyle("myStyleId").link("MyLink"); const style = new ParagraphStyle("myStyleId").link("MyLink");
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { "w:link": { _attr: { "w:val": "MyLink" } } }],
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ "w:rPr": [] },
{ "w:link": [{ _attr: { "w:val": "MyLink" } }] },
],
}); });
}); });
@ -490,12 +439,7 @@ describe("ParagraphStyle", () => {
const style = new ParagraphStyle("myStyleId").semiHidden(); const style = new ParagraphStyle("myStyleId").semiHidden();
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { "w:semiHidden": null }],
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ "w:rPr": [] },
{ "w:semiHidden": [] },
],
}); });
}); });
@ -505,16 +449,12 @@ describe("ParagraphStyle", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ "w:rPr": [] },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
], ],
}); });
@ -524,12 +464,7 @@ describe("ParagraphStyle", () => {
const style = new ParagraphStyle("myStyleId").unhideWhenUsed(); const style = new ParagraphStyle("myStyleId").unhideWhenUsed();
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { "w:unhideWhenUsed": null }],
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:pPr": [] },
{ "w:rPr": [] },
{ "w:unhideWhenUsed": [] },
],
}); });
}); });
}); });

4
src/file/styles/style/style.spec.ts
View File

@ -12,7 +12,7 @@ describe("Style", () => {
}); });
const tree = new Formatter().format(style); const tree = new Formatter().format(style);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId", "w:default": true } }], "w:style": { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId", "w:default": true } },
}); });
}); });
@ -28,7 +28,7 @@ describe("Style", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "myStyleId" } },
{ "w:name": [{ _attr: { "w:val": "Style Name" } }] }, { "w:name": { _attr: { "w:val": "Style Name" } } },
], ],
}); });
}); });

34
src/file/styles/styles.spec.ts
View File

@ -27,7 +27,7 @@ describe("Styles", () => {
const tree = new Formatter().format(styles)["w:styles"].filter((x) => !x._attr); const tree = new Formatter().format(styles)["w:styles"].filter((x) => !x._attr);
expect(tree).to.deep.equal([ expect(tree).to.deep.equal([
{ {
"w:style": [{ _attr: { "w:type": "paragraph", "w:styleId": "pStyleId" } }, { "w:pPr": [] }, { "w:rPr": [] }], "w:style": { _attr: { "w:type": "paragraph", "w:styleId": "pStyleId" } },
}, },
]); ]);
}); });
@ -40,9 +40,7 @@ describe("Styles", () => {
{ {
"w:style": [ "w:style": [
{ _attr: { "w:type": "paragraph", "w:styleId": "pStyleId" } }, { _attr: { "w:type": "paragraph", "w:styleId": "pStyleId" } },
{ "w:name": [{ _attr: { "w:val": "Paragraph Style" } }] }, { "w:name": { _attr: { "w:val": "Paragraph Style" } } },
{ "w:pPr": [] },
{ "w:rPr": [] },
], ],
}, },
]); ]);
@ -58,18 +56,15 @@ describe("Styles", () => {
{ {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "pStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "pStyleId" } },
{ "w:rPr": [] },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}, },
@ -84,19 +79,16 @@ describe("Styles", () => {
{ {
"w:style": [ "w:style": [
{ _attr: { "w:type": "character", "w:styleId": "pStyleId" } }, { _attr: { "w:type": "character", "w:styleId": "pStyleId" } },
{ "w:name": [{ _attr: { "w:val": "Character Style" } }] }, { "w:name": { _attr: { "w:val": "Character Style" } } },
{ "w:rPr": [] },
{ {
"w:uiPriority": [ "w:uiPriority": {
{ _attr: {
_attr: { "w:val": "99",
"w:val": "99",
},
}, },
], },
}, },
{ {
"w:unhideWhenUsed": [], "w:unhideWhenUsed": null,
}, },
], ],
}, },

108
src/file/table-of-contents/table-of-contents.spec.ts
View File

@ -49,13 +49,11 @@ const DEFAULT_TOC = {
{ {
"w:sdtPr": [ "w:sdtPr": [
{ {
"w:alias": [ "w:alias": {
{ _attr: {
_attr: { "w:val": "Table of Contents",
"w:val": "Table of Contents",
},
}, },
], },
}, },
], ],
}, },
@ -63,23 +61,15 @@ const DEFAULT_TOC = {
"w:sdtContent": [ "w:sdtContent": [
{ {
"w:p": [ "w:p": [
{
"w:pPr": [],
},
{ {
"w:r": [ "w:r": [
{ {
"w:rPr": [], "w:fldChar": {
}, _attr: {
{ "w:fldCharType": "begin",
"w:fldChar": [ "w:dirty": true,
{
_attr: {
"w:fldCharType": "begin",
"w:dirty": true,
},
}, },
], },
}, },
{ {
"w:instrText": [ "w:instrText": [
@ -92,13 +82,11 @@ const DEFAULT_TOC = {
], ],
}, },
{ {
"w:fldChar": [ "w:fldChar": {
{ _attr: {
_attr: { "w:fldCharType": "separate",
"w:fldCharType": "separate",
},
}, },
], },
}, },
], ],
}, },
@ -106,22 +94,14 @@ const DEFAULT_TOC = {
}, },
{ {
"w:p": [ "w:p": [
{
"w:pPr": [],
},
{ {
"w:r": [ "w:r": [
{ {
"w:rPr": [], "w:fldChar": {
}, _attr: {
{ "w:fldCharType": "end",
"w:fldChar": [
{
_attr: {
"w:fldCharType": "end",
},
}, },
], },
}, },
], ],
}, },
@ -137,13 +117,11 @@ const COMPLETE_TOC = {
{ {
"w:sdtPr": [ "w:sdtPr": [
{ {
"w:alias": [ "w:alias": {
{ _attr: {
_attr: { "w:val": "Summary",
"w:val": "Summary",
},
}, },
], },
}, },
], ],
}, },
@ -151,23 +129,15 @@ const COMPLETE_TOC = {
"w:sdtContent": [ "w:sdtContent": [
{ {
"w:p": [ "w:p": [
{
"w:pPr": [],
},
{ {
"w:r": [ "w:r": [
{ {
"w:rPr": [], "w:fldChar": {
}, _attr: {
{ "w:fldCharType": "begin",
"w:fldChar": [ "w:dirty": true,
{
_attr: {
"w:fldCharType": "begin",
"w:dirty": true,
},
}, },
], },
}, },
{ {
"w:instrText": [ "w:instrText": [
@ -180,13 +150,11 @@ const COMPLETE_TOC = {
], ],
}, },
{ {
"w:fldChar": [ "w:fldChar": {
{ _attr: {
_attr: { "w:fldCharType": "separate",
"w:fldCharType": "separate",
},
}, },
], },
}, },
], ],
}, },
@ -194,22 +162,14 @@ const COMPLETE_TOC = {
}, },
{ {
"w:p": [ "w:p": [
{
"w:pPr": [],
},
{ {
"w:r": [ "w:r": [
{ {
"w:rPr": [], "w:fldChar": {
}, _attr: {
{ "w:fldCharType": "end",
"w:fldChar": [
{
_attr: {
"w:fldCharType": "end",
},
}, },
], },
}, },
], ],
}, },

10
src/file/table/grid.spec.ts
View File

@ -10,14 +10,14 @@ describe("GridCol", () => {
const grid = new GridCol(1234); const grid = new GridCol(1234);
const tree = new Formatter().format(grid); const tree = new Formatter().format(grid);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:gridCol": [{ _attr: { "w:w": 1234 } }], "w:gridCol": { _attr: { "w:w": 1234 } },
}); });
}); });
it("does not set a width attribute if not given", () => { it("does not set a width attribute if not given", () => {
const grid = new GridCol(); const grid = new GridCol();
const tree = new Formatter().format(grid); const tree = new Formatter().format(grid);
expect(tree).to.deep.equal({ "w:gridCol": [] }); expect(tree).to.deep.equal({ "w:gridCol": null });
}); });
}); });
}); });
@ -29,9 +29,9 @@ describe("TableGrid", () => {
const tree = new Formatter().format(grid); const tree = new Formatter().format(grid);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tblGrid": [ "w:tblGrid": [
{ "w:gridCol": [{ _attr: { "w:w": 1234 } }] }, { "w:gridCol": { _attr: { "w:w": 1234 } } },
{ "w:gridCol": [{ _attr: { "w:w": 321 } }] }, { "w:gridCol": { _attr: { "w:w": 321 } } },
{ "w:gridCol": [{ _attr: { "w:w": 123 } }] }, { "w:gridCol": { _attr: { "w:w": 123 } } },
], ],
}); });
}); });

30
src/file/table/shading/shading.spec.ts
View File

@ -7,30 +7,26 @@ import { ShadingType, TableShading } from "./shading";
describe("TableShading", () => { describe("TableShading", () => {
describe("#constructor", () => { describe("#constructor", () => {
it("should create", () => { it("should create", () => {
const cellMargain = new TableShading({}); const shading = new TableShading({});
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(shading);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:shd": [ "w:shd": {
{ _attr: {},
_attr: {}, },
},
],
}); });
}); });
it("should create with params", () => { it("should create with params", () => {
const cellMargain = new TableShading({ val: ShadingType.PERCENT_40, color: "FF0000", fill: "555555" }); const shading = new TableShading({ val: ShadingType.PERCENT_40, color: "FF0000", fill: "555555" });
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(shading);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:shd": [ "w:shd": {
{ _attr: {
_attr: { "w:color": "FF0000",
"w:color": "FF0000", "w:fill": "555555",
"w:fill": "555555", "w:val": "pct40",
"w:val": "pct40",
},
}, },
], },
}); });
}); });
}); });

48
src/file/table/table-cell/cell-margain/cell-margain.spec.ts
View File

@ -10,14 +10,12 @@ describe("TopCellMargain", () => {
const cellMargain = new TopCellMargain(1); const cellMargain = new TopCellMargain(1);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(cellMargain);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:top": [ "w:top": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 1,
"w:w": 1,
},
}, },
], },
}); });
}); });
}); });
@ -29,14 +27,12 @@ describe("BottomCellMargain", () => {
const cellMargain = new BottomCellMargain(1); const cellMargain = new BottomCellMargain(1);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(cellMargain);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:bottom": [ "w:bottom": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 1,
"w:w": 1,
},
}, },
], },
}); });
}); });
}); });
@ -48,14 +44,12 @@ describe("LeftCellMargain", () => {
const cellMargain = new LeftCellMargain(1); const cellMargain = new LeftCellMargain(1);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(cellMargain);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:start": [ "w:start": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 1,
"w:w": 1,
},
}, },
], },
}); });
}); });
}); });
@ -67,14 +61,12 @@ describe("RightCellMargain", () => {
const cellMargain = new RightCellMargain(1); const cellMargain = new RightCellMargain(1);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(cellMargain);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:end": [ "w:end": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 1,
"w:w": 1,
},
}, },
], },
}); });
}); });
}); });

96
src/file/table/table-cell/cell-margain/table-cell-margains.spec.ts
View File

@ -12,44 +12,36 @@ describe("TableCellMargain", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcMar": [ "w:tcMar": [
{ {
"w:top": [ "w:top": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 0,
"w:w": 0,
},
}, },
], },
}, },
{ {
"w:bottom": [ "w:bottom": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 0,
"w:w": 0,
},
}, },
], },
}, },
{ {
"w:end": [ "w:end": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 0,
"w:w": 0,
},
}, },
], },
}, },
{ {
"w:start": [ "w:start": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 0,
"w:w": 0,
},
}, },
], },
}, },
], ],
}); });
@ -66,44 +58,36 @@ describe("TableCellMargain", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcMar": [ "w:tcMar": [
{ {
"w:top": [ "w:top": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 5,
"w:w": 5,
},
}, },
], },
}, },
{ {
"w:bottom": [ "w:bottom": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 5,
"w:w": 5,
},
}, },
], },
}, },
{ {
"w:end": [ "w:end": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 5,
"w:w": 5,
},
}, },
], },
}, },
{ {
"w:start": [ "w:start": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 5,
"w:w": 5,
},
}, },
], },
}, },
], ],
}); });

10
src/file/table/table-cell/table-cell-components.ts
View File

@ -1,5 +1,5 @@
import { BorderStyle } from "file/styles"; import { BorderStyle } from "file/styles";
import { IXmlableObject, XmlAttributeComponent, XmlComponent } from "file/xml-components"; import { IgnoreIfEmptyXmlComponent, XmlAttributeComponent, XmlComponent } from "file/xml-components";
interface ICellBorder { interface ICellBorder {
readonly style: BorderStyle; readonly style: BorderStyle;
@ -24,17 +24,11 @@ class BaseTableCellBorder extends XmlComponent {
} }
} }
export class TableCellBorders extends XmlComponent { export class TableCellBorders extends IgnoreIfEmptyXmlComponent {
constructor() { constructor() {
super("w:tcBorders"); super("w:tcBorders");
} }
public prepForXml(): IXmlableObject | undefined {
if (this.root.length > 0) {
return super.prepForXml();
}
}
public addTopBorder(style: BorderStyle, size: number, color: string): TableCellBorders { public addTopBorder(style: BorderStyle, size: number, color: string): TableCellBorders {
const top = new BaseTableCellBorder("w:top"); const top = new BaseTableCellBorder("w:top");
top.setProperties(style, size, color); top.setProperties(style, size, color);

65
src/file/table/table-cell/table-cell-properties.spec.ts
View File

@ -9,77 +9,80 @@ import { TableCellProperties } from "./table-cell-properties";
describe("TableCellProperties", () => { describe("TableCellProperties", () => {
describe("#constructor", () => { describe("#constructor", () => {
it("creates an initially empty property object", () => { it("creates an initially empty property object", () => {
const cellMargain = new TableCellProperties(); const properties = new TableCellProperties();
const tree = new Formatter().format(cellMargain); // The TableCellProperties is ignorable if there are no attributes,
expect(tree).to.deep.equal({ "w:tcPr": [] }); // which results in prepForXml returning undefined, which causes
// the formatter to throw an error if that is the only object it
// has been asked to format.
expect(() => new Formatter().format(properties)).to.throw("XMLComponent did not format correctly");
}); });
}); });
describe("#addGridSpan", () => { describe("#addGridSpan", () => {
it("adds grid span", () => { it("adds grid span", () => {
const cellMargain = new TableCellProperties(); const properties = new TableCellProperties();
cellMargain.addGridSpan(1); properties.addGridSpan(1);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(properties);
expect(tree).to.deep.equal({ "w:tcPr": [{ "w:gridSpan": [{ _attr: { "w:val": 1 } }] }] }); expect(tree).to.deep.equal({ "w:tcPr": [{ "w:gridSpan": { _attr: { "w:val": 1 } } }] });
}); });
}); });
describe("#addVerticalMerge", () => { describe("#addVerticalMerge", () => {
it("adds vertical merge", () => { it("adds vertical merge", () => {
const cellMargain = new TableCellProperties(); const properties = new TableCellProperties();
cellMargain.addVerticalMerge(VMergeType.CONTINUE); properties.addVerticalMerge(VMergeType.CONTINUE);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(properties);
expect(tree).to.deep.equal({ "w:tcPr": [{ "w:vMerge": [{ _attr: { "w:val": "continue" } }] }] }); expect(tree).to.deep.equal({ "w:tcPr": [{ "w:vMerge": { _attr: { "w:val": "continue" } } }] });
}); });
}); });
describe("#setVerticalAlign", () => { describe("#setVerticalAlign", () => {
it("sets vertical align", () => { it("sets vertical align", () => {
const cellMargain = new TableCellProperties(); const properties = new TableCellProperties();
cellMargain.setVerticalAlign(VerticalAlign.BOTTOM); properties.setVerticalAlign(VerticalAlign.BOTTOM);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(properties);
expect(tree).to.deep.equal({ "w:tcPr": [{ "w:vAlign": [{ _attr: { "w:val": "bottom" } }] }] }); expect(tree).to.deep.equal({ "w:tcPr": [{ "w:vAlign": { _attr: { "w:val": "bottom" } } }] });
}); });
}); });
describe("#setWidth", () => { describe("#setWidth", () => {
it("should set width", () => { it("should set width", () => {
const cellMargain = new TableCellProperties(); const properties = new TableCellProperties();
cellMargain.setWidth(1, WidthType.DXA); properties.setWidth(1, WidthType.DXA);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(properties);
expect(tree).to.deep.equal({ "w:tcPr": [{ "w:tcW": [{ _attr: { "w:type": "dxa", "w:w": 1 } }] }] }); expect(tree).to.deep.equal({ "w:tcPr": [{ "w:tcW": { _attr: { "w:type": "dxa", "w:w": 1 } } }] });
}); });
it("should set width using default of AUTO", () => { it("should set width using default of AUTO", () => {
const cellMargain = new TableCellProperties(); const properties = new TableCellProperties();
cellMargain.setWidth(1); properties.setWidth(1);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(properties);
expect(tree).to.deep.equal({ "w:tcPr": [{ "w:tcW": [{ _attr: { "w:type": "auto", "w:w": 1 } }] }] }); expect(tree).to.deep.equal({ "w:tcPr": [{ "w:tcW": { _attr: { "w:type": "auto", "w:w": 1 } } }] });
}); });
}); });
describe("#setShading", () => { describe("#setShading", () => {
it("sets shading", () => { it("sets shading", () => {
const cellMargain = new TableCellProperties(); const properties = new TableCellProperties();
cellMargain.setShading({ properties.setShading({
fill: "test", fill: "test",
color: "000", color: "000",
}); });
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(properties);
expect(tree).to.deep.equal({ "w:tcPr": [{ "w:shd": [{ _attr: { "w:fill": "test", "w:color": "000" } }] }] }); expect(tree).to.deep.equal({ "w:tcPr": [{ "w:shd": { _attr: { "w:fill": "test", "w:color": "000" } } }] });
}); });
}); });
describe("#Borders", () => { describe("#Borders", () => {
it("should return the TableCellBorders if Border has borders", () => { it("should return the TableCellBorders if Border has borders", () => {
const cellMargain = new TableCellProperties(); const properties = new TableCellProperties();
cellMargain.Borders.addTopBorder(BorderStyle.DASH_DOT_STROKED, 3, "red"); properties.Borders.addTopBorder(BorderStyle.DASH_DOT_STROKED, 3, "red");
const borders = cellMargain.Borders; const borders = properties.Borders;
const tree = new Formatter().format(borders); const tree = new Formatter().format(borders);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcBorders": [{ "w:top": [{ _attr: { "w:val": "dashDotStroked", "w:sz": 3, "w:color": "red" } }] }], "w:tcBorders": [{ "w:top": { _attr: { "w:val": "dashDotStroked", "w:sz": 3, "w:color": "red" } } }],
}); });
}); });
}); });

4
src/file/table/table-cell/table-cell-properties.ts
View File

@ -1,10 +1,10 @@
import { XmlComponent } from "file/xml-components"; import { IgnoreIfEmptyXmlComponent } from "file/xml-components";
import { ITableShadingAttributesProperties, TableShading } from "../shading"; import { ITableShadingAttributesProperties, TableShading } from "../shading";
import { ITableCellMargainOptions, TableCellMargain } from "./cell-margain/table-cell-margains"; import { ITableCellMargainOptions, TableCellMargain } from "./cell-margain/table-cell-margains";
import { GridSpan, TableCellBorders, TableCellWidth, VAlign, VerticalAlign, VMerge, VMergeType, WidthType } from "./table-cell-components"; import { GridSpan, TableCellBorders, TableCellWidth, VAlign, VerticalAlign, VMerge, VMergeType, WidthType } from "./table-cell-components";
export class TableCellProperties extends XmlComponent { export class TableCellProperties extends IgnoreIfEmptyXmlComponent {
private readonly cellBorder: TableCellBorders; private readonly cellBorder: TableCellBorders;
constructor() { constructor() {

180
src/file/table/table-cell/table-cell.spec.ts
View File

@ -22,15 +22,13 @@ describe("TableCellBorders", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcBorders": [ "w:tcBorders": [
{ {
"w:top": [ "w:top": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 1,
"w:sz": 1, "w:val": "dotted",
"w:val": "dotted",
},
}, },
], },
}, },
], ],
}); });
@ -44,15 +42,13 @@ describe("TableCellBorders", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcBorders": [ "w:tcBorders": [
{ {
"w:start": [ "w:start": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 2,
"w:sz": 2, "w:val": "single",
"w:val": "single",
},
}, },
], },
}, },
], ],
}); });
@ -66,15 +62,13 @@ describe("TableCellBorders", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcBorders": [ "w:tcBorders": [
{ {
"w:bottom": [ "w:bottom": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 1,
"w:sz": 1, "w:val": "double",
"w:val": "double",
},
}, },
], },
}, },
], ],
}); });
@ -88,15 +82,13 @@ describe("TableCellBorders", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcBorders": [ "w:tcBorders": [
{ {
"w:end": [ "w:end": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 3,
"w:sz": 3, "w:val": "thick",
"w:val": "thick",
},
}, },
], },
}, },
], ],
}); });
@ -110,15 +102,13 @@ describe("TableCellBorders", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcBorders": [ "w:tcBorders": [
{ {
"w:left": [ "w:left": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 3,
"w:sz": 3, "w:val": "thick",
"w:val": "thick",
},
}, },
], },
}, },
], ],
}); });
@ -132,15 +122,13 @@ describe("TableCellBorders", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcBorders": [ "w:tcBorders": [
{ {
"w:right": [ "w:right": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 3,
"w:sz": 3, "w:val": "thick",
"w:val": "thick",
},
}, },
], },
}, },
], ],
}); });
@ -159,70 +147,58 @@ describe("TableCellBorders", () => {
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcBorders": [ "w:tcBorders": [
{ {
"w:top": [ "w:top": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 1,
"w:sz": 1, "w:val": "dotted",
"w:val": "dotted",
},
}, },
], },
}, },
{ {
"w:end": [ "w:end": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 3,
"w:sz": 3, "w:val": "thick",
"w:val": "thick",
},
}, },
], },
}, },
{ {
"w:bottom": [ "w:bottom": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 1,
"w:sz": 1, "w:val": "double",
"w:val": "double",
},
}, },
], },
}, },
{ {
"w:start": [ "w:start": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 2,
"w:sz": 2, "w:val": "single",
"w:val": "single",
},
}, },
], },
}, },
{ {
"w:left": [ "w:left": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 2,
"w:sz": 2, "w:val": "single",
"w:val": "single",
},
}, },
], },
}, },
{ {
"w:right": [ "w:right": {
{ _attr: {
_attr: { "w:color": "FF00FF",
"w:color": "FF00FF", "w:sz": 2,
"w:sz": 2, "w:val": "single",
"w:val": "single",
},
}, },
], },
}, },
], ],
}); });
@ -236,14 +212,12 @@ describe("TableCellWidth", () => {
const tcWidth = new TableCellWidth(100, WidthType.DXA); const tcWidth = new TableCellWidth(100, WidthType.DXA);
const tree = new Formatter().format(tcWidth); const tree = new Formatter().format(tcWidth);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tcW": [ "w:tcW": {
{ _attr: {
_attr: { "w:type": "dxa",
"w:type": "dxa", "w:w": 100,
"w:w": 100,
},
}, },
], },
}); });
}); });
}); });

12
src/file/table/table-cell/table-cell.ts
View File

@ -30,16 +30,10 @@ export class TableCell extends XmlComponent {
public prepForXml(): IXmlableObject | undefined { public prepForXml(): IXmlableObject | undefined {
// Cells must end with a paragraph // Cells must end with a paragraph
const retval = super.prepForXml(); if (!(this.root[this.root.length - 1] instanceof Paragraph)) {
if (!retval) { this.createParagraph();
return undefined;
} }
return super.prepForXml();
const content = retval["w:tc"];
if (!content[content.length - 1]["w:p"]) {
content.push(new Paragraph().prepForXml());
}
return retval;
} }
public createParagraph(text?: string): Paragraph { public createParagraph(text?: string): Paragraph {

6
src/file/table/table-column.spec.ts
View File

@ -37,15 +37,15 @@ describe("TableColumn", () => {
const tree = new Formatter().format(cells[0]); const tree = new Formatter().format(cells[0]);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tc": [{ "w:tcPr": [{ "w:vMerge": [{ _attr: { "w:val": "restart" } }] }] }, { "w:p": [{ "w:pPr": [] }] }], "w:tc": [{ "w:tcPr": [{ "w:vMerge": { _attr: { "w:val": "restart" } } }] }, { "w:p": null }],
}); });
const tree2 = new Formatter().format(cells[1]); const tree2 = new Formatter().format(cells[1]);
expect(tree2).to.deep.equal({ "w:tc": [{ "w:tcPr": [] }, { "w:p": [{ "w:pPr": [] }] }] }); expect(tree2).to.deep.equal({ "w:tc": [{ "w:p": null }] });
const tree3 = new Formatter().format(cells[2]); const tree3 = new Formatter().format(cells[2]);
expect(tree3).to.deep.equal({ expect(tree3).to.deep.equal({
"w:tc": [{ "w:tcPr": [{ "w:vMerge": [{ _attr: { "w:val": "continue" } }] }] }, { "w:p": [{ "w:pPr": [] }] }], "w:tc": [{ "w:tcPr": [{ "w:vMerge": { _attr: { "w:val": "continue" } } }] }, { "w:p": null }],
}); });
}); });
}); });

8
src/file/table/table-properties/table-cell-margin.spec.ts
View File

@ -18,7 +18,7 @@ describe("TableCellMargin", () => {
const cellMargain = new TableCellMargin(); const cellMargain = new TableCellMargin();
cellMargain.addTopMargin(1234, WidthType.DXA); cellMargain.addTopMargin(1234, WidthType.DXA);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(cellMargain);
expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:top": [{ _attr: { "w:type": "dxa", "w:w": 1234 } }] }] }); expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:top": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
}); });
}); });
@ -27,7 +27,7 @@ describe("TableCellMargin", () => {
const cellMargain = new TableCellMargin(); const cellMargain = new TableCellMargin();
cellMargain.addLeftMargin(1234, WidthType.DXA); cellMargain.addLeftMargin(1234, WidthType.DXA);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(cellMargain);
expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:left": [{ _attr: { "w:type": "dxa", "w:w": 1234 } }] }] }); expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:left": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
}); });
}); });
@ -36,7 +36,7 @@ describe("TableCellMargin", () => {
const cellMargain = new TableCellMargin(); const cellMargain = new TableCellMargin();
cellMargain.addBottomMargin(1234, WidthType.DXA); cellMargain.addBottomMargin(1234, WidthType.DXA);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(cellMargain);
expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:bottom": [{ _attr: { "w:type": "dxa", "w:w": 1234 } }] }] }); expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:bottom": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
}); });
}); });
@ -45,7 +45,7 @@ describe("TableCellMargin", () => {
const cellMargain = new TableCellMargin(); const cellMargain = new TableCellMargin();
cellMargain.addRightMargin(1234, WidthType.DXA); cellMargain.addRightMargin(1234, WidthType.DXA);
const tree = new Formatter().format(cellMargain); const tree = new Formatter().format(cellMargain);
expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:right": [{ _attr: { "w:type": "dxa", "w:w": 1234 } }] }] }); expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:right": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
}); });
}); });
}); });

10
src/file/table/table-properties/table-cell-margin.ts
View File

@ -1,4 +1,4 @@
import { IXmlableObject, XmlAttributeComponent, XmlComponent } from "file/xml-components"; import { IgnoreIfEmptyXmlComponent, XmlAttributeComponent, XmlComponent } from "file/xml-components";
import { WidthType } from "../table-cell"; import { WidthType } from "../table-cell";
@ -17,17 +17,11 @@ class BaseTableCellMargin extends XmlComponent {
} }
} }
export class TableCellMargin extends XmlComponent { export class TableCellMargin extends IgnoreIfEmptyXmlComponent {
constructor() { constructor() {
super("w:tblCellMar"); super("w:tblCellMar");
} }
public prepForXml(): IXmlableObject | undefined {
if (this.root.length > 0) {
return super.prepForXml();
}
}
public addTopMargin(value: number, type: WidthType = WidthType.DXA): void { public addTopMargin(value: number, type: WidthType = WidthType.DXA): void {
const top = new BaseTableCellMargin("w:top"); const top = new BaseTableCellMargin("w:top");

28
src/file/table/table-properties/table-float-properties.spec.ts
View File

@ -26,20 +26,18 @@ describe("Table Float Properties", () => {
}); });
const DEFAULT_TFP = { const DEFAULT_TFP = {
"w:tblpPr": [ "w:tblpPr": {
{ _attr: {
_attr: { "w:horzAnchor": "margin",
"w:horzAnchor": "margin", "w:vertAnchor": "page",
"w:vertAnchor": "page", "w:tblpX": 10,
"w:tblpX": 10, "w:tblpXSpec": "center",
"w:tblpXSpec": "center", "w:tblpY": 20,
"w:tblpY": 20, "w:tblpYSpec": "bottom",
"w:tblpYSpec": "bottom", "w:bottomFromText": 30,
"w:bottomFromText": 30, "w:topFromText": 40,
"w:topFromText": 40, "w:leftFromText": 50,
"w:leftFromText": 50, "w:rightFromText": 60,
"w:rightFromText": 60,
},
}, },
], },
}; };

17
src/file/table/table-properties/table-properties.spec.ts
View File

@ -9,8 +9,11 @@ describe("TableProperties", () => {
describe("#constructor", () => { describe("#constructor", () => {
it("creates an initially empty property object", () => { it("creates an initially empty property object", () => {
const tp = new TableProperties(); const tp = new TableProperties();
const tree = new Formatter().format(tp); // The TableProperties is ignorable if there are no attributes,
expect(tree).to.deep.equal({ "w:tblPr": [] }); // which results in prepForXml returning undefined, which causes
// the formatter to throw an error if that is the only object it
// has been asked to format.
expect(() => new Formatter().format(tp)).to.throw("XMLComponent did not format correctly");
}); });
}); });
@ -19,7 +22,7 @@ describe("TableProperties", () => {
const tp = new TableProperties().setWidth(1234, WidthType.DXA); const tp = new TableProperties().setWidth(1234, WidthType.DXA);
const tree = new Formatter().format(tp); const tree = new Formatter().format(tp);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tblPr": [{ "w:tblW": [{ _attr: { "w:type": "dxa", "w:w": 1234 } }] }], "w:tblPr": [{ "w:tblW": { _attr: { "w:type": "dxa", "w:w": 1234 } } }],
}); });
}); });
@ -27,7 +30,7 @@ describe("TableProperties", () => {
const tp = new TableProperties().setWidth(1234); const tp = new TableProperties().setWidth(1234);
const tree = new Formatter().format(tp); const tree = new Formatter().format(tp);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tblPr": [{ "w:tblW": [{ _attr: { "w:type": "auto", "w:w": 1234 } }] }], "w:tblPr": [{ "w:tblW": { _attr: { "w:type": "auto", "w:w": 1234 } } }],
}); });
}); });
}); });
@ -37,7 +40,7 @@ describe("TableProperties", () => {
const tp = new TableProperties().setFixedWidthLayout(); const tp = new TableProperties().setFixedWidthLayout();
const tree = new Formatter().format(tp); const tree = new Formatter().format(tp);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tblPr": [{ "w:tblLayout": [{ _attr: { "w:type": "fixed" } }] }], "w:tblPr": [{ "w:tblLayout": { _attr: { "w:type": "fixed" } } }],
}); });
}); });
}); });
@ -48,7 +51,7 @@ describe("TableProperties", () => {
tp.CellMargin.addTopMargin(1234, WidthType.DXA); tp.CellMargin.addTopMargin(1234, WidthType.DXA);
const tree = new Formatter().format(tp); const tree = new Formatter().format(tp);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tblPr": [{ "w:tblCellMar": [{ "w:top": [{ _attr: { "w:type": "dxa", "w:w": 1234 } }] }] }], "w:tblPr": [{ "w:tblCellMar": [{ "w:top": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] }],
}); });
}); });
@ -57,7 +60,7 @@ describe("TableProperties", () => {
tp.CellMargin.addLeftMargin(1234, WidthType.DXA); tp.CellMargin.addLeftMargin(1234, WidthType.DXA);
const tree = new Formatter().format(tp); const tree = new Formatter().format(tp);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tblPr": [{ "w:tblCellMar": [{ "w:left": [{ _attr: { "w:type": "dxa", "w:w": 1234 } }] }] }], "w:tblPr": [{ "w:tblCellMar": [{ "w:left": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] }],
}); });
}); });
}); });

4
src/file/table/table-properties/table-properties.ts
View File

@ -1,4 +1,4 @@
import { XmlComponent } from "file/xml-components"; import { IgnoreIfEmptyXmlComponent } from "file/xml-components";
import { ITableShadingAttributesProperties, TableShading } from "../shading"; import { ITableShadingAttributesProperties, TableShading } from "../shading";
import { WidthType } from "../table-cell"; import { WidthType } from "../table-cell";
@ -8,7 +8,7 @@ import { ITableFloatOptions, TableFloatProperties } from "./table-float-properti
import { TableLayout, TableLayoutType } from "./table-layout"; import { TableLayout, TableLayoutType } from "./table-layout";
import { PreferredTableWidth } from "./table-width"; import { PreferredTableWidth } from "./table-width";
export class TableProperties extends XmlComponent { export class TableProperties extends IgnoreIfEmptyXmlComponent {
private readonly cellMargin: TableCellMargin; private readonly cellMargin: TableCellMargin;
constructor() { constructor() {

11
src/file/table/table-row/table-row-properties.spec.ts
View File

@ -6,8 +6,11 @@ describe("TableRowProperties", () => {
describe("#constructor", () => { describe("#constructor", () => {
it("creates an initially empty property object", () => { it("creates an initially empty property object", () => {
const rowProperties = new TableRowProperties(); const rowProperties = new TableRowProperties();
const tree = new Formatter().format(rowProperties); // The TableRowProperties is ignorable if there are no attributes,
expect(tree).to.deep.equal({ "w:trPr": [] }); // which results in prepForXml returning undefined, which causes
// the formatter to throw an error if that is the only object it
// has been asked to format.
expect(() => new Formatter().format(rowProperties)).to.throw("XMLComponent did not format correctly");
}); });
}); });
@ -16,7 +19,7 @@ describe("TableRowProperties", () => {
const rowProperties = new TableRowProperties(); const rowProperties = new TableRowProperties();
rowProperties.setCantSplit(); rowProperties.setCantSplit();
const tree = new Formatter().format(rowProperties); const tree = new Formatter().format(rowProperties);
expect(tree).to.deep.equal({ "w:trPr": [{ "w:cantSplit": [{ _attr: { "w:val": true } }] }] }); expect(tree).to.deep.equal({ "w:trPr": [{ "w:cantSplit": { _attr: { "w:val": true } } }] });
}); });
}); });
@ -25,7 +28,7 @@ describe("TableRowProperties", () => {
const rowProperties = new TableRowProperties(); const rowProperties = new TableRowProperties();
rowProperties.setTableHeader(); rowProperties.setTableHeader();
const tree = new Formatter().format(rowProperties); const tree = new Formatter().format(rowProperties);
expect(tree).to.deep.equal({ "w:trPr": [{ "w:tblHeader": [{ _attr: { "w:val": true } }] }] }); expect(tree).to.deep.equal({ "w:trPr": [{ "w:tblHeader": { _attr: { "w:val": true } } }] });
}); });
}); });
}); });

4
src/file/table/table-row/table-row-properties.ts
View File

@ -1,6 +1,6 @@
import { XmlAttributeComponent, XmlComponent } from "file/xml-components"; import { IgnoreIfEmptyXmlComponent, XmlAttributeComponent, XmlComponent } from "file/xml-components";
export class TableRowProperties extends XmlComponent { export class TableRowProperties extends IgnoreIfEmptyXmlComponent {
constructor() { constructor() {
super("w:trPr"); super("w:trPr");
} }

18
src/file/table/table-row/table-row.spec.ts
View File

@ -11,11 +11,7 @@ describe("TableRow", () => {
const tableRow = new TableRow([]); const tableRow = new TableRow([]);
const tree = new Formatter().format(tableRow); const tree = new Formatter().format(tableRow);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tr": [ "w:tr": null,
{
"w:trPr": [],
},
],
}); });
}); });
@ -24,20 +20,10 @@ describe("TableRow", () => {
const tree = new Formatter().format(tableRow); const tree = new Formatter().format(tableRow);
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tr": [ "w:tr": [
{
"w:trPr": [],
},
{ {
"w:tc": [ "w:tc": [
{ {
"w:tcPr": [], "w:p": null,
},
{
"w:p": [
{
"w:pPr": [],
},
],
}, },
], ],
}, },

202
src/file/table/table.spec.ts
View File

@ -11,68 +11,58 @@ import { RelativeHorizontalPosition, RelativeVerticalPosition, TableAnchorType }
const DEFAULT_TABLE_PROPERTIES = { const DEFAULT_TABLE_PROPERTIES = {
"w:tblCellMar": [ "w:tblCellMar": [
{ {
"w:bottom": [ "w:bottom": {
{ _attr: {
_attr: { "w:type": "auto",
"w:type": "auto", "w:w": 0,
"w:w": 0,
},
}, },
], },
}, },
{ {
"w:top": [ "w:top": {
{ _attr: {
_attr: { "w:type": "auto",
"w:type": "auto", "w:w": 0,
"w:w": 0,
},
}, },
], },
}, },
{ {
"w:left": [ "w:left": {
{ _attr: {
_attr: { "w:type": "auto",
"w:type": "auto", "w:w": 0,
"w:w": 0,
},
}, },
], },
}, },
{ {
"w:right": [ "w:right": {
{ _attr: {
_attr: { "w:type": "auto",
"w:type": "auto", "w:w": 0,
"w:w": 0,
},
}, },
], },
}, },
], ],
}; };
const BORDERS = { const BORDERS = {
"w:tblBorders": [ "w:tblBorders": [
{ "w:top": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, { "w:top": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
{ "w:left": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, { "w:left": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
{ "w:bottom": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, { "w:bottom": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
{ "w:right": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, { "w:right": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
{ "w:insideH": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, { "w:insideH": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
{ "w:insideV": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, { "w:insideV": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
], ],
}; };
const WIDTHS = { const WIDTHS = {
"w:tblW": [ "w:tblW": {
{ _attr: {
_attr: { "w:type": "auto",
"w:type": "auto", "w:w": 100,
"w:w": 100,
},
}, },
], },
}; };
// const f = { // const f = {
@ -81,45 +71,43 @@ const WIDTHS = {
// "w:tblPr": [ // "w:tblPr": [
// { // {
// "w:tblCellMar": [ // "w:tblCellMar": [
// { "w:bottom": [{ _attr: { "w:type": "auto", "w:w": 0 } }] }, // { "w:bottom": { _attr: { "w:type": "auto", "w:w": 0 } } },
// { "w:top": [{ _attr: { "w:type": "auto", "w:w": 0 } }] }, // { "w:top": { _attr: { "w:type": "auto", "w:w": 0 } } },
// { "w:left": [{ _attr: { "w:type": "auto", "w:w": 0 } }] }, // { "w:left": { _attr: { "w:type": "auto", "w:w": 0 } } },
// { "w:right": [{ _attr: { "w:type": "auto", "w:w": 0 } }] }, // { "w:right": { _attr: { "w:type": "auto", "w:w": 0 } } },
// ], // ],
// }, // },
// { // {
// "w:tblBorders": [ // "w:tblBorders": [
// { "w:top": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, // { "w:top": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
// { "w:left": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, // { "w:left": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
// { "w:bottom": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, // { "w:bottom": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
// { "w:right": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, // { "w:right": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
// { "w:insideH": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, // { "w:insideH": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
// { "w:insideV": [{ _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } }] }, // { "w:insideV": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
// ], // ],
// }, // },
// { "w:tblW": [{ _attr: { "w:type": "auto", "w:w": 100 } }] }, // { "w:tblW": { _attr: { "w:type": "auto", "w:w": 100 } } },
// { // {
// "w:tblpPr": [ // "w:tblpPr": {
// { // _attr: {
// _attr: { // "w:horzAnchor": "margin",
// "w:horzAnchor": "margin", // "w:vertAnchor": "page",
// "w:vertAnchor": "page", // "w:tblpX": 10,
// "w:tblpX": 10, // "w:tblpXSpec": "center",
// "w:tblpXSpec": "center", // "w:tblpY": 20,
// "w:tblpY": 20, // "w:tblpYSpec": "bottom",
// "w:tblpYSpec": "bottom", // "w:bottomFromText": 30,
// "w:bottomFromText": 30, // "w:topFromText": 40,
// "w:topFromText": 40, // "w:leftFromText": 50,
// "w:leftFromText": 50, // "w:rightFromText": 60,
// "w:rightFromText": 60,
// },
// }, // },
// ], // },
// }, // },
// ], // ],
// }, // },
// { "w:tblGrid": [{ "w:gridCol": [{ _attr: { "w:w": 100 } }] }] }, // { "w:tblGrid": [{ "w:gridCol": { _attr: { "w:w": 100 } } }] },
// { "w:tr": [{ "w:trPr": [] }, { "w:tc": [{ "w:tcPr": [] }, { "w:p": [{ "w:pPr": [] }] }] }] }, // { "w:tr": [{ "w:tc": [{ "w:p": null }] }] },
// ], // ],
// }; // };
@ -131,16 +119,16 @@ describe("Table", () => {
columns: 2, columns: 2,
}); });
const tree = new Formatter().format(table); const tree = new Formatter().format(table);
const cell = { "w:tc": [{ "w:tcPr": [] }, { "w:p": [{ "w:pPr": [] }] }] }; const cell = { "w:tc": [{ "w:p": null }] };
expect(tree).to.deep.equal({ expect(tree).to.deep.equal({
"w:tbl": [ "w:tbl": [
{ "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS] }, { "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS] },
{ {
"w:tblGrid": [{ "w:gridCol": [{ _attr: { "w:w": 100 } }] }, { "w:gridCol": [{ _attr: { "w:w": 100 } }] }], "w:tblGrid": [{ "w:gridCol": { _attr: { "w:w": 100 } } }, { "w:gridCol": { _attr: { "w:w": 100 } } }],
}, },
{ "w:tr": [{ "w:trPr": [] }, cell, cell] }, { "w:tr": [cell, cell] },
{ "w:tr": [{ "w:trPr": [] }, cell, cell] }, { "w:tr": [cell, cell] },
{ "w:tr": [{ "w:trPr": [] }, cell, cell] }, { "w:tr": [cell, cell] },
], ],
}); });
}); });
@ -172,9 +160,8 @@ describe("Table", () => {
const tree = new Formatter().format(table); const tree = new Formatter().format(table);
const cell = (c) => ({ const cell = (c) => ({
"w:tc": [ "w:tc": [
{ "w:tcPr": [] },
{ {
"w:p": [{ "w:pPr": [] }, { "w:r": [{ "w:rPr": [] }, { "w:t": [{ _attr: { "xml:space": "preserve" } }, c] }] }], "w:p": [{ "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, c] }] }],
}, },
], ],
}); });
@ -182,10 +169,10 @@ describe("Table", () => {
"w:tbl": [ "w:tbl": [
{ "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS] }, { "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS] },
{ {
"w:tblGrid": [{ "w:gridCol": [{ _attr: { "w:w": 100 } }] }, { "w:gridCol": [{ _attr: { "w:w": 100 } }] }], "w:tblGrid": [{ "w:gridCol": { _attr: { "w:w": 100 } } }, { "w:gridCol": { _attr: { "w:w": 100 } } }],
}, },
{ "w:tr": [{ "w:trPr": [] }, cell("A1"), cell("B1")] }, { "w:tr": [cell("A1"), cell("B1")] },
{ "w:tr": [{ "w:trPr": [] }, cell("A2"), cell("B2")] }, { "w:tr": [cell("A2"), cell("B2")] },
], ],
}); });
}); });
@ -222,9 +209,8 @@ describe("Table", () => {
const tree = new Formatter().format(table); const tree = new Formatter().format(table);
const cell = (c) => ({ const cell = (c) => ({
"w:tc": [ "w:tc": [
{ "w:tcPr": [] },
{ {
"w:p": [{ "w:pPr": [] }, { "w:r": [{ "w:rPr": [] }, { "w:t": [{ _attr: { "xml:space": "preserve" } }, c] }] }], "w:p": [{ "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, c] }] }],
}, },
], ],
}); });
@ -232,10 +218,10 @@ describe("Table", () => {
"w:tbl": [ "w:tbl": [
{ "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS] }, { "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS] },
{ {
"w:tblGrid": [{ "w:gridCol": [{ _attr: { "w:w": 100 } }] }, { "w:gridCol": [{ _attr: { "w:w": 100 } }] }], "w:tblGrid": [{ "w:gridCol": { _attr: { "w:w": 100 } } }, { "w:gridCol": { _attr: { "w:w": 100 } } }],
}, },
{ "w:tr": [{ "w:trPr": [] }, cell("A1"), cell("B1")] }, { "w:tr": [cell("A1"), cell("B1")] },
{ "w:tr": [{ "w:trPr": [] }, cell("A2"), cell("B2")] }, { "w:tr": [cell("A2"), cell("B2")] },
], ],
}); });
}); });
@ -250,7 +236,7 @@ describe("Table", () => {
// .which.is.an("array") // .which.is.an("array")
// .with.has.length.at.least(1); // .with.has.length.at.least(1);
// expect(tree["w:tbl"][0]).to.deep.equal({ // expect(tree["w:tbl"][0]).to.deep.equal({
// "w:tblPr": [DEFAULT_TABLE_PROPERTIES, { "w:tblW": [{ _attr: { "w:type": "pct", "w:w": "1000%" } }] }], // "w:tblPr": [DEFAULT_TABLE_PROPERTIES, { "w:tblW": { _attr: { "w:type": "pct", "w:w": "1000%" } } }],
// }); // });
// }); // });
@ -259,7 +245,7 @@ describe("Table", () => {
// const tree = new Formatter().format(table); // const tree = new Formatter().format(table);
// expect(tree["w:tbl"][0]).to.deep.equal({ // expect(tree["w:tbl"][0]).to.deep.equal({
// "w:tblPr": [DEFAULT_TABLE_PROPERTIES, { "w:tblW": [{ _attr: { "w:type": "auto", "w:w": 1000 } }] }], // "w:tblPr": [DEFAULT_TABLE_PROPERTIES, { "w:tblW": { _attr: { "w:type": "auto", "w:w": 1000 } } }],
// }); // });
// }); // });
// }); // });
@ -276,7 +262,7 @@ describe("Table", () => {
.which.is.an("array") .which.is.an("array")
.with.has.length.at.least(1); .with.has.length.at.least(1);
expect(tree["w:tbl"][0]).to.deep.equal({ expect(tree["w:tbl"][0]).to.deep.equal({
"w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS, { "w:tblLayout": [{ _attr: { "w:type": "fixed" } }] }], "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS, { "w:tblLayout": { _attr: { "w:type": "fixed" } } }],
}); });
}); });
}); });
@ -298,7 +284,7 @@ describe("Table", () => {
.to.be.an("array") .to.be.an("array")
.which.has.length.at.least(1); .which.has.length.at.least(1);
expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({ expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
"w:tc": [{ "w:tcPr": [] }, { "w:p": [{ "w:pPr": [] }] }], "w:tc": [{ "w:p": null }],
}); });
}); });
@ -325,7 +311,7 @@ describe("Table", () => {
const cell = row["w:tr"].find((x) => x["w:tc"]); const cell = row["w:tr"].find((x) => x["w:tc"]);
expect(cell).not.to.be.undefined; expect(cell).not.to.be.undefined;
expect(cell["w:tc"][cell["w:tc"].length - 1]).to.deep.equal({ expect(cell["w:tc"][cell["w:tc"].length - 1]).to.deep.equal({
"w:p": [{ "w:pPr": [] }], "w:p": null,
}); });
}); });
@ -346,12 +332,8 @@ describe("Table", () => {
.which.has.length.at.least(1); .which.has.length.at.least(1);
expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({ expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
"w:tc": [ "w:tc": [
{ "w:tcPr": [] },
{ {
"w:p": [ "w:p": [{ "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "Hello"] }] }],
{ "w:pPr": [] },
{ "w:r": [{ "w:rPr": [] }, { "w:t": [{ _attr: { "xml:space": "preserve" } }, "Hello"] }] },
],
}, },
], ],
}); });
@ -377,12 +359,10 @@ describe("Table", () => {
.which.has.length.at.least(1); .which.has.length.at.least(1);
expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({ expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
"w:tc": [ "w:tc": [
{ "w:tcPr": [] },
{ {
"w:p": [ "w:p": [
{ "w:pPr": [] },
{ {
"w:r": [{ "w:rPr": [] }, { "w:t": [{ _attr: { "xml:space": "preserve" } }, "Test paragraph"] }], "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "Test paragraph"] }],
}, },
], ],
}, },
@ -421,22 +401,20 @@ describe("Table", () => {
BORDERS, BORDERS,
WIDTHS, WIDTHS,
{ {
"w:tblpPr": [ "w:tblpPr": {
{ _attr: {
_attr: { "w:horzAnchor": "margin",
"w:horzAnchor": "margin", "w:vertAnchor": "page",
"w:vertAnchor": "page", "w:tblpX": 10,
"w:tblpX": 10, "w:tblpXSpec": "center",
"w:tblpXSpec": "center", "w:tblpY": 20,
"w:tblpY": 20, "w:tblpYSpec": "bottom",
"w:tblpYSpec": "bottom", "w:bottomFromText": 30,
"w:bottomFromText": 30, "w:topFromText": 40,
"w:topFromText": 40, "w:leftFromText": 50,
"w:leftFromText": 50, "w:rightFromText": 60,
"w:rightFromText": 60,
},
}, },
], },
}, },
], ],
}); });

4
src/file/xml-components/default-attributes.ts
View File

@ -6,7 +6,7 @@ export type AttributeMap<T> = { [P in keyof T]: string };
export abstract class XmlAttributeComponent<T> extends BaseXmlComponent { export abstract class XmlAttributeComponent<T> extends BaseXmlComponent {
// tslint:disable-next-line:readonly-keyword // tslint:disable-next-line:readonly-keyword
protected root: T; protected root: T;
protected readonly xmlKeys: AttributeMap<T>; protected readonly xmlKeys?: AttributeMap<T>;
constructor(properties: T) { constructor(properties: T) {
super("_attr"); super("_attr");
@ -18,7 +18,7 @@ export abstract class XmlAttributeComponent<T> extends BaseXmlComponent {
Object.keys(this.root).forEach((key) => { Object.keys(this.root).forEach((key) => {
const value = this.root[key]; const value = this.root[key];
if (value !== undefined) { if (value !== undefined) {
const newKey = this.xmlKeys[key]; const newKey = (this.xmlKeys && this.xmlKeys[key]) || key;
attrs[newKey] = value; attrs[newKey] = value;
} }
}); });

22
src/file/xml-components/imported-xml-component.spec.ts
View File

@ -25,11 +25,25 @@ const convertedXmlElement = {
deleted: false, deleted: false,
rootKey: "w:p", rootKey: "w:p",
root: [ root: [
{ deleted: false, rootKey: "_attr", root: { "w:one": "value 1", "w:two": "value 2" } },
{ deleted: false, rootKey: "w:rPr", root: [{ deleted: false, rootKey: "w:noProof", root: ["some value"] }] }, { deleted: false, rootKey: "w:rPr", root: [{ deleted: false, rootKey: "w:noProof", root: ["some value"] }] },
{ deleted: false, rootKey: "w:r", root: [{ deleted: false, rootKey: "w:t", root: ["Text 1"] }], _attr: { active: "true" } }, {
{ deleted: false, rootKey: "w:r", root: [{ deleted: false, rootKey: "w:t", root: ["Text 2"] }], _attr: { active: "true" } }, deleted: false,
rootKey: "w:r",
root: [
{ deleted: false, rootKey: "_attr", root: { active: "true" } },
{ deleted: false, rootKey: "w:t", root: ["Text 1"] },
],
},
{
deleted: false,
rootKey: "w:r",
root: [
{ deleted: false, rootKey: "_attr", root: { active: "true" } },
{ deleted: false, rootKey: "w:t", root: ["Text 2"] },
],
},
], ],
_attr: { "w:one": "value 1", "w:two": "value 2" },
}, },
], ],
rootKey: undefined, rootKey: undefined,
@ -59,7 +73,7 @@ describe("ImportedXmlComponent", () => {
}, },
}, },
{ {
"w:child": [], "w:child": null,
}, },
], ],
}); });

52
src/file/xml-components/imported-xml-component.ts
View File

@ -1,6 +1,6 @@
// tslint:disable:no-any // tslint:disable:no-any
import { Element as XmlElement, xml2js } from "xml-js"; import { Element as XmlElement, xml2js } from "xml-js";
import { IXmlableObject, XmlComponent } from "."; import { IXmlableObject, XmlAttributeComponent, XmlComponent } from ".";
/** /**
* Converts the given xml element (in json format) into XmlComponent. * Converts the given xml element (in json format) into XmlComponent.
@ -27,6 +27,10 @@ export function convertToXmlComponent(element: XmlElement): ImportedXmlComponent
} }
} }
class ImportedXmlComponentAttributes extends XmlAttributeComponent<any> {
// noop
}
/** /**
* Represents imported xml component from xml file. * Represents imported xml component from xml file.
*/ */
@ -46,58 +50,14 @@ export class ImportedXmlComponent extends XmlComponent {
* @param importedContent xml content of the imported component * @param importedContent xml content of the imported component
*/ */
// tslint:disable-next-line:variable-name
private readonly _attr: any;
// tslint:disable-next-line:variable-name // tslint:disable-next-line:variable-name
constructor(rootKey: string, _attr?: any) { constructor(rootKey: string, _attr?: any) {
super(rootKey); super(rootKey);
if (_attr) { if (_attr) {
this._attr = _attr; this.root.push(new ImportedXmlComponentAttributes(_attr));
} }
} }
/**
* Transforms the object so it can be converted to xml. Example:
* <w:someKey someAttr="1" otherAttr="11">
* <w:child childAttr="2">
* </w:child>
* </w:someKey>
* {
* 'w:someKey': [
* {
* _attr: {
* someAttr: "1",
* otherAttr: "11"
* }
* },
* {
* 'w:child': [
* {
* _attr: {
* childAttr: "2"
* }
* }
* ]
* }
* ]
* }
*/
public prepForXml(): IXmlableObject | undefined {
const result = super.prepForXml();
if (!result) {
return undefined;
}
if (!!this._attr) {
if (!Array.isArray(result[this.rootKey])) {
result[this.rootKey] = [result[this.rootKey]];
}
result[this.rootKey].unshift({ _attr: this._attr });
}
return result;
}
public push(xmlComponent: XmlComponent | string): void { public push(xmlComponent: XmlComponent | string): void {
this.root.push(xmlComponent); this.root.push(xmlComponent);
} }

2
src/file/xml-components/xml-component.spec.ts
View File

@ -31,7 +31,7 @@ describe("XmlComponent", () => {
return; return;
} }
assert.equal(xml["w:test"].length, 0); assert.isNull(xml["w:test"]);
}); });
}); });
}); });

20
src/file/xml-components/xml-component.ts
View File

@ -17,7 +17,7 @@ export abstract class XmlComponent extends BaseXmlComponent {
if (c instanceof BaseXmlComponent) { if (c instanceof BaseXmlComponent) {
return !c.IsDeleted; return !c.IsDeleted;
} }
return true; return c !== undefined;
}) })
.map((comp) => { .map((comp) => {
if (comp instanceof BaseXmlComponent) { if (comp instanceof BaseXmlComponent) {
@ -26,8 +26,15 @@ export abstract class XmlComponent extends BaseXmlComponent {
return comp; return comp;
}) })
.filter((comp) => comp !== undefined); // Exclude undefined .filter((comp) => comp !== undefined); // Exclude undefined
// If we only have a single IXmlableObject in our children array and it
// represents our attributes, use the object itself as our children to
// avoid an unneeded XML close element. (Note: We have to use this
// function to get typescript to allow our check.)
// Additionally, if the array is empty, use null as our children to
// get an empty XML element generated.
const onlyAttrs = (c) => typeof c === "object" && c._attr;
return { return {
[this.rootKey]: children, [this.rootKey]: children.length ? (children.length === 1 && onlyAttrs(children[0]) ? children[0] : children) : null,
}; };
} }
@ -41,3 +48,12 @@ export abstract class XmlComponent extends BaseXmlComponent {
this.deleted = true; this.deleted = true;
} }
} }
export abstract class IgnoreIfEmptyXmlComponent extends XmlComponent {
public prepForXml(): IXmlableObject | undefined {
const result = super.prepForXml();
if (result && result[this.rootKey]) {
return result;
}
}
}

3
tslint.json
View File

@ -15,7 +15,8 @@
"max-classes-per-file": [false], "max-classes-per-file": [false],
"no-implicit-dependencies": false, "no-implicit-dependencies": false,
"no-submodule-imports": false, "no-submodule-imports": false,
"no-null-keyword": true, // We need null in order to get empty elements from the xml library
"no-null-keyword": false,
"return-undefined": true, "return-undefined": true,
"prefer-readonly": true, "prefer-readonly": true,
"no-duplicate-imports": true, "no-duplicate-imports": true,