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

Merge branch 'importxmljs' into importDotx

Browse Source
This commit is contained in:
amitm02
2018-10-17 09:17:42 +03:00
parent a5bedf9a5b c849d5f3e5
commit 5532f91423
6 changed files with 178 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
package.json
View File

@ -49,10 +49,11 @@
"dependencies": { "dependencies": {
"@types/image-size": "0.0.29", "@types/image-size": "0.0.29",
"@types/jszip": "^3.1.4", "@types/jszip": "^3.1.4",
"fast-xml-parser": "^3.3.6",
"image-size": "^0.6.2", "image-size": "^0.6.2",
"jszip": "^3.1.5", "jszip": "^3.1.5",
"xml": "^1.0.1" "npm": "^6.4.1",
"xml": "^1.0.1",
"xml-js": "^1.6.8"
}, },
"author": "Dolan Miu", "author": "Dolan Miu",
"license": "MIT", "license": "MIT",

35
src/file/styles/external-styles-factory.ts
View File

@ -1,5 +1,5 @@
import * as fastXmlParser from "fast-xml-parser"; import { convertToXmlComponent, ImportedRootElementAttributes, ImportedXmlComponent } from "file/xml-components";
import { convertToXmlComponent, ImportedRootElementAttributes, parseOptions } from "file/xml-components"; import { Element as XMLElement, xml2js } from "xml-js";
import { Styles } from "./"; import { Styles } from "./";
export class ExternalStylesFactory { export class ExternalStylesFactory {
@ -25,25 +25,24 @@ export class ExternalStylesFactory {
* </w:styles> * </w:styles>
* @param externalStyles context from styles.xml * @param externalStyles context from styles.xml
*/ */
public newInstance(externalStyles: string): Styles { public newInstance(xmlData: string): Styles {
const xmlStyles = fastXmlParser.parse(externalStyles, parseOptions)["w:styles"]; const xmlObj = xml2js(xmlData, { compact: false }) as XMLElement;
// create styles with attributes from the parsed xml
const importedStyle = new Styles(new ImportedRootElementAttributes(xmlStyles._attr));
// convert other elements (not styles definitions, but default styles and so on ...) let stylesXmlElement: XMLElement | undefined;
Object.keys(xmlStyles) for (const xmlElm of xmlObj.elements || []) {
.filter((element) => element !== "_attr" && element !== "w:style") if (xmlElm.name === "w:styles") {
.forEach((element) => { stylesXmlElement = xmlElm;
const converted = convertToXmlComponent(element, xmlStyles[element]); }
if (Array.isArray(converted)) { }
converted.forEach((c) => importedStyle.push(c)); if (stylesXmlElement === undefined) {
} else { throw new Error("can not find styles element");
importedStyle.push(converted);
} }
});
// convert the styles one by one const importedStyle = new Styles(new ImportedRootElementAttributes(stylesXmlElement.attributes));
xmlStyles["w:style"].map((style) => convertToXmlComponent("w:style", style)).forEach(importedStyle.push.bind(importedStyle)); const stylesElements = stylesXmlElement.elements || [];
for (const childElm of stylesElements) {
importedStyle.push(convertToXmlComponent(childElm) as ImportedXmlComponent);
}
return importedStyle; return importedStyle;
} }
} }

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

@ -1,95 +1,95 @@
import { expect } from "chai"; // import { expect } from "chai";
import { convertToXmlComponent, ImportedXmlComponent } from "./"; // import { convertToXmlComponent, ImportedXmlComponent } from "./";
const xmlString = ` // const xmlString = `
<w:p w:one="value 1" w:two="value 2"> // <w:p w:one="value 1" w:two="value 2">
<w:rPr> // <w:rPr>
<w:noProof>some value</w:noProof> // <w:noProof>some value</w:noProof>
</w:rPr> // </w:rPr>
<w:r active="true"> // <w:r active="true">
<w:t>Text 1</w:t> // <w:t>Text 1</w:t>
</w:r> // </w:r>
<w:r active="true"> // <w:r active="true">
<w:t>Text 2</w:t> // <w:t>Text 2</w:t>
</w:r> // </w:r>
</w:p> // </w:p>
`; // `;
// tslint:disable:object-literal-key-quotes // // tslint:disable:object-literal-key-quotes
const importedXmlElement = { // const importedXmlElement = {
"w:p": { // "w:p": {
_attr: { "w:one": "value 1", "w:two": "value 2" }, // _attr: { "w:one": "value 1", "w:two": "value 2" },
"w:rPr": { "w:noProof": "some value" }, // "w:rPr": { "w:noProof": "some value" },
"w:r": [{ _attr: { active: "true" }, "w:t": "Text 1" }, { _attr: { active: "true" }, "w:t": "Text 2" }], // "w:r": [{ _attr: { active: "true" }, "w:t": "Text 1" }, { _attr: { active: "true" }, "w:t": "Text 2" }],
}, // },
}; // };
// tslint:enable:object-literal-key-quotes // // tslint:enable:object-literal-key-quotes
const convertedXmlElement = { // const convertedXmlElement = {
deleted: false, // deleted: false,
rootKey: "w:p", // rootKey: "w:p",
root: [ // root: [
{ // {
deleted: false, // deleted: false,
rootKey: "w:rPr", // rootKey: "w:rPr",
root: [{ deleted: false, rootKey: "w:noProof", root: ["some value"] }], // root: [{ deleted: false, rootKey: "w:noProof", root: ["some value"] }],
}, // },
{ // {
deleted: false, // deleted: false,
rootKey: "w:r", // rootKey: "w:r",
root: [{ deleted: false, rootKey: "w:t", root: ["Text 1"] }], // root: [{ deleted: false, rootKey: "w:t", root: ["Text 1"] }],
_attr: { active: "true" }, // _attr: { active: "true" },
}, // },
{ // {
deleted: false, // deleted: false,
rootKey: "w:r", // rootKey: "w:r",
root: [{ deleted: false, rootKey: "w:t", root: ["Text 2"] }], // root: [{ deleted: false, rootKey: "w:t", root: ["Text 2"] }],
_attr: { active: "true" }, // _attr: { active: "true" },
}, // },
], // ],
_attr: { "w:one": "value 1", "w:two": "value 2" }, // _attr: { "w:one": "value 1", "w:two": "value 2" },
}; // };
describe("ImportedXmlComponent", () => { // describe("ImportedXmlComponent", () => {
let importedXmlComponent: ImportedXmlComponent; // let importedXmlComponent: ImportedXmlComponent;
beforeEach(() => { // beforeEach(() => {
const attributes = { // const attributes = {
someAttr: "1", // someAttr: "1",
otherAttr: "2", // otherAttr: "2",
}; // };
importedXmlComponent = new ImportedXmlComponent("w:test", attributes); // importedXmlComponent = new ImportedXmlComponent("w:test", attributes);
importedXmlComponent.push(new ImportedXmlComponent("w:child")); // importedXmlComponent.push(new ImportedXmlComponent("w:child"));
}); // });
describe("#prepForXml()", () => { // describe("#prepForXml()", () => {
it("should transform for xml", () => { // it("should transform for xml", () => {
const converted = importedXmlComponent.prepForXml(); // const converted = importedXmlComponent.prepForXml();
expect(converted).to.eql({ // expect(converted).to.eql({
"w:test": [ // "w:test": [
{ // {
_attr: { // _attr: {
someAttr: "1", // someAttr: "1",
otherAttr: "2", // otherAttr: "2",
}, // },
}, // },
{ // {
"w:child": [], // "w:child": [],
}, // },
], // ],
}); // });
}); // });
}); // });
it("should create XmlComponent from xml string", () => { // it("should create XmlComponent from xml string", () => {
const converted = ImportedXmlComponent.fromXmlString(xmlString); // const converted = ImportedXmlComponent.fromXmlString(xmlString);
expect(converted).to.eql(convertedXmlElement); // expect(converted).to.eql(convertedXmlElement);
}); // });
describe("convertToXmlComponent", () => { // describe("convertToXmlComponent", () => {
it("should convert to xml component", () => { // it("should convert to xml component", () => {
const converted = convertToXmlComponent("w:p", importedXmlElement["w:p"]); // const converted = convertToXmlComponent("w:p", importedXmlElement["w:p"]);
expect(converted).to.eql(convertedXmlElement); // expect(converted).to.eql(convertedXmlElement);
}); // });
}); // });
}); // });

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

@ -1,53 +1,29 @@
// tslint:disable:no-any // tslint:disable:no-any
import * as fastXmlParser from "fast-xml-parser"; import { Element as XmlElement } from "xml-js";
import { flatMap } from "lodash";
import { IXmlableObject, XmlComponent } from "."; import { IXmlableObject, XmlComponent } from ".";
export const parseOptions = {
ignoreAttributes: false,
attributeNamePrefix: "",
attrNodeName: "_attr",
};
/** /**
* Converts the given xml element (in json format) into XmlComponent. * Converts the given xml element (in json format) into XmlComponent.
* Note: If element is array, them it will return ImportedXmlComponent[]. Example for given:
* element = [
* { w:t: "val 1"},
* { w:t: "val 2"}
* ]
* will return
* [
* ImportedXmlComponent { rootKey: "w:t", root: [ "val 1" ]},
* ImportedXmlComponent { rootKey: "w:t", root: [ "val 2" ]}
* ]
*
* @param elementName name (rootKey) of the XmlComponent
* @param element the xml element in json presentation * @param element the xml element in json presentation
*/ */
export function convertToXmlComponent(elementName: string, element: any): ImportedXmlComponent | ImportedXmlComponent[] {
const xmlElement = new ImportedXmlComponent(elementName, element._attr); export function convertToXmlComponent(element: XmlElement): ImportedXmlComponent | string | undefined {
if (Array.isArray(element)) { switch (element.type) {
const out: any[] = []; case "element":
element.forEach((itemInArray) => { const xmlComponent = new ImportedXmlComponent(element.name as string, element.attributes);
out.push(convertToXmlComponent(elementName, itemInArray)); const childElments = element.elements || [];
}); for (const childElm of childElments) {
return flatMap(out); const child = convertToXmlComponent(childElm);
} else if (typeof element === "object") { if (child !== undefined) {
Object.keys(element) xmlComponent.push(child);
.filter((key) => key !== "_attr")
.map((item) => convertToXmlComponent(item, element[item]))
.forEach((converted) => {
if (Array.isArray(converted)) {
converted.forEach(xmlElement.push.bind(xmlElement));
} else {
xmlElement.push(converted);
} }
});
} else if (element !== "") {
xmlElement.push(element);
} }
return xmlElement; return xmlComponent;
case "text":
return element.text as string;
default:
return undefined;
}
} }
/** /**
@ -59,17 +35,6 @@ export class ImportedXmlComponent extends XmlComponent {
* *
* @param importedContent xml content of the imported component * @param importedContent xml content of the imported component
*/ */
public static fromXmlString(importedContent: string): ImportedXmlComponent {
const imported = fastXmlParser.parse(importedContent, parseOptions);
const elementName = Object.keys(imported)[0];
const converted = convertToXmlComponent(elementName, imported[elementName]);
if (Array.isArray(converted) && converted.length > 1) {
throw new Error("Invalid conversion, input must be one element.");
}
return Array.isArray(converted) ? converted[0] : converted;
}
// tslint:disable-next-line:variable-name // tslint:disable-next-line:variable-name
private readonly _attr: any; private readonly _attr: any;
@ -123,7 +88,7 @@ export class ImportedXmlComponent extends XmlComponent {
return result; return result;
} }
public push(xmlComponent: XmlComponent): void { public push(xmlComponent: XmlComponent | string): void {
this.root.push(xmlComponent); this.root.push(xmlComponent);
} }
} }

5
src/file/xml-components/xmlable-object.ts
View File

@ -1,5 +1,8 @@
export interface IXmlAttribute {
[key: string]: string | number | boolean;
}
export interface IXmlableObject extends Object { export interface IXmlableObject extends Object {
_attr?: { [key: string]: string | number | boolean }; _attr?: IXmlAttribute;
} }
// Needed because of: https://github.com/s-panferov/awesome-typescript-loader/issues/432 // Needed because of: https://github.com/s-panferov/awesome-typescript-loader/issues/432

83
src/import-dotx/import-dotx.ts
View File

@ -1,21 +1,15 @@
import * as fastXmlParser from "fast-xml-parser";
import * as JSZip from "jszip"; import * as JSZip from "jszip";
import { Element as XMLElement, ElementCompact as XMLElementCompact, xml2js } from "xml-js";
import { FooterReferenceType } from "file/document/body/section-properties/footer-reference"; import { FooterReferenceType } from "file/document/body/section-properties/footer-reference";
import { HeaderReferenceType } from "file/document/body/section-properties/header-reference"; import { HeaderReferenceType } from "file/document/body/section-properties/header-reference";
import { FooterWrapper, IDocumentFooter } from "file/footer-wrapper"; import { FooterWrapper, IDocumentFooter } from "file/footer-wrapper";
import { HeaderWrapper, IDocumentHeader } from "file/header-wrapper"; import { HeaderWrapper, IDocumentHeader } from "file/header-wrapper";
import { convertToXmlComponent, ImportedXmlComponent, parseOptions } from "file/xml-components"; import { convertToXmlComponent, ImportedXmlComponent } from "file/xml-components";
import { Styles } from "file/styles"; import { Styles } from "file/styles";
import { ExternalStylesFactory } from "file/styles/external-styles-factory"; import { ExternalStylesFactory } from "file/styles/external-styles-factory";
const importParseOptions = {
...parseOptions,
textNodeName: "",
trimValues: false,
};
const schemeToType = { const schemeToType = {
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/header": "header", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header": "header",
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer": "footer", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer": "footer",
@ -67,17 +61,23 @@ export class ImportDotx {
const headers: IDocumentHeader[] = []; const headers: IDocumentHeader[] = [];
for (const headerRef of documentRefs.headers) { for (const headerRef of documentRefs.headers) {
const headerKey = "w:hdr";
const relationFileInfo = documentRelationships.find((rel) => rel.id === headerRef.id); const relationFileInfo = documentRelationships.find((rel) => rel.id === headerRef.id);
if (relationFileInfo === null || !relationFileInfo) { if (relationFileInfo === null || !relationFileInfo) {
throw new Error(`Can not find target file for id ${headerRef.id}`); throw new Error(`Can not find target file for id ${headerRef.id}`);
} }
const xmlData = await zipContent.files[`word/${relationFileInfo.target}`].async("text"); const xmlData = await zipContent.files[`word/${relationFileInfo.target}`].async("text");
const xmlObj = fastXmlParser.parse(xmlData, importParseOptions); const xmlObj = xml2js(xmlData, { compact: false, captureSpacesBetweenElements: true }) as XMLElement;
let headerXmlElement: XMLElement | undefined;
const importedComp = convertToXmlComponent(headerKey, xmlObj[headerKey]) as ImportedXmlComponent; for (const xmlElm of xmlObj.elements || []) {
if (xmlElm.name === "w:hdr") {
headerXmlElement = xmlElm;
}
}
if (headerXmlElement === undefined) {
continue;
}
const importedComp = convertToXmlComponent(headerXmlElement) as ImportedXmlComponent;
const header = new HeaderWrapper(this.currentRelationshipId++, importedComp); const header = new HeaderWrapper(this.currentRelationshipId++, importedComp);
await this.addRelationToWrapper(relationFileInfo, zipContent, header); await this.addRelationToWrapper(relationFileInfo, zipContent, header);
headers.push({ type: headerRef.type, header }); headers.push({ type: headerRef.type, header });
@ -85,15 +85,22 @@ export class ImportDotx {
const footers: IDocumentFooter[] = []; const footers: IDocumentFooter[] = [];
for (const footerRef of documentRefs.footers) { for (const footerRef of documentRefs.footers) {
const footerKey = "w:ftr";
const relationFileInfo = documentRelationships.find((rel) => rel.id === footerRef.id); const relationFileInfo = documentRelationships.find((rel) => rel.id === footerRef.id);
if (relationFileInfo === null || !relationFileInfo) { if (relationFileInfo === null || !relationFileInfo) {
throw new Error(`Can not find target file for id ${footerRef.id}`); throw new Error(`Can not find target file for id ${footerRef.id}`);
} }
const xmlData = await zipContent.files[`word/${relationFileInfo.target}`].async("text"); const xmlData = await zipContent.files[`word/${relationFileInfo.target}`].async("text");
const xmlObj = fastXmlParser.parse(xmlData, importParseOptions); const xmlObj = xml2js(xmlData, { compact: false, captureSpacesBetweenElements: true }) as XMLElement;
const importedComp = convertToXmlComponent(footerKey, xmlObj[footerKey]) as ImportedXmlComponent; let footerXmlElement: XMLElement | undefined;
for (const xmlElm of xmlObj.elements || []) {
if (xmlElm.name === "w:ftr") {
footerXmlElement = xmlElm;
}
}
if (footerXmlElement === undefined) {
continue;
}
const importedComp = convertToXmlComponent(footerXmlElement) as ImportedXmlComponent;
const footer = new FooterWrapper(this.currentRelationshipId++, importedComp); const footer = new FooterWrapper(this.currentRelationshipId++, importedComp);
await this.addRelationToWrapper(relationFileInfo, zipContent, footer); await this.addRelationToWrapper(relationFileInfo, zipContent, footer);
footers.push({ type: footerRef.type, footer }); footers.push({ type: footerRef.type, footer });
@ -132,16 +139,19 @@ export class ImportDotx {
} }
public findReferenceFiles(xmlData: string): IRelationshipFileInfo[] { public findReferenceFiles(xmlData: string): IRelationshipFileInfo[] {
const xmlObj = fastXmlParser.parse(xmlData, importParseOptions); const xmlObj = xml2js(xmlData, { compact: true }) as XMLElementCompact;
const relationXmlArray = Array.isArray(xmlObj.Relationships.Relationship) const relationXmlArray = Array.isArray(xmlObj.Relationships.Relationship)
? xmlObj.Relationships.Relationship ? xmlObj.Relationships.Relationship
: [xmlObj.Relationships.Relationship]; : [xmlObj.Relationships.Relationship];
const relations: IRelationshipFileInfo[] = relationXmlArray const relations: IRelationshipFileInfo[] = relationXmlArray
.map((item) => { .map((item: XMLElementCompact) => {
if (item._attributes === undefined) {
throw Error("relationship element has no attributes");
}
return { return {
id: this.parseRefId(item._attr.Id), id: this.parseRefId(item._attributes.Id as string),
type: schemeToType[item._attr.Type], type: schemeToType[item._attributes.Type as string],
target: item._attr.Target, target: item._attributes.Target as string,
}; };
}) })
.filter((item) => item.type !== null); .filter((item) => item.type !== null);
@ -149,14 +159,11 @@ export class ImportDotx {
} }
public extractDocumentRefs(xmlData: string): IDocumentRefs { public extractDocumentRefs(xmlData: string): IDocumentRefs {
interface IAttributedXML { const xmlObj = xml2js(xmlData, { compact: true }) as XMLElementCompact;
_attr: object;
}
const xmlObj = fastXmlParser.parse(xmlData, importParseOptions);
const sectionProp = xmlObj["w:document"]["w:body"]["w:sectPr"]; const sectionProp = xmlObj["w:document"]["w:body"]["w:sectPr"];
const headerProps: undefined | IAttributedXML | IAttributedXML[] = sectionProp["w:headerReference"]; const headerProps: XMLElementCompact = sectionProp["w:headerReference"];
let headersXmlArray: IAttributedXML[]; let headersXmlArray: XMLElementCompact[];
if (headerProps === undefined) { if (headerProps === undefined) {
headersXmlArray = []; headersXmlArray = [];
} else if (Array.isArray(headerProps)) { } else if (Array.isArray(headerProps)) {
@ -165,14 +172,17 @@ export class ImportDotx {
headersXmlArray = [headerProps]; headersXmlArray = [headerProps];
} }
const headers = headersXmlArray.map((item) => { const headers = headersXmlArray.map((item) => {
if (item._attributes === undefined) {
throw Error("header referecne element has no attributes");
}
return { return {
type: item._attr["w:type"], type: item._attributes["w:type"] as HeaderReferenceType,
id: this.parseRefId(item._attr["r:id"]), id: this.parseRefId(item._attributes["r:id"] as string),
}; };
}); });
const footerProps: undefined | IAttributedXML | IAttributedXML[] = sectionProp["w:footerReference"]; const footerProps: XMLElementCompact = sectionProp["w:footerReference"];
let footersXmlArray: IAttributedXML[]; let footersXmlArray: XMLElementCompact[];
if (footerProps === undefined) { if (footerProps === undefined) {
footersXmlArray = []; footersXmlArray = [];
} else if (Array.isArray(footerProps)) { } else if (Array.isArray(footerProps)) {
@ -182,9 +192,12 @@ export class ImportDotx {
} }
const footers = footersXmlArray.map((item) => { const footers = footersXmlArray.map((item) => {
if (item._attributes === undefined) {
throw Error("footer referecne element has no attributes");
}
return { return {
type: item._attr["w:type"], type: item._attributes["w:type"] as FooterReferenceType,
id: this.parseRefId(item._attr["r:id"]), id: this.parseRefId(item._attributes["r:id"] as string),
}; };
}); });
@ -192,7 +205,7 @@ export class ImportDotx {
} }
public titlePageIsDefined(xmlData: string): boolean { public titlePageIsDefined(xmlData: string): boolean {
const xmlObj = fastXmlParser.parse(xmlData, importParseOptions); const xmlObj = xml2js(xmlData, { compact: true }) as XMLElementCompact;
const sectionProp = xmlObj["w:document"]["w:body"]["w:sectPr"]; const sectionProp = xmlObj["w:document"]["w:body"]["w:sectPr"];
return sectionProp["w:titlePg"] !== undefined; return sectionProp["w:titlePg"] !== undefined;
} }