docx 7.8.2 → 8.0.1

package/src/file/xml-components/default-attributes.ts

@@ -1,28 +0,0 @@
-import { BaseXmlComponent, IContext } from "./base";
-import { IXmlableObject } from "./xmlable-object";
-
-export type AttributeMap<T> = { readonly [P in keyof T]: string };
-
-export abstract class XmlAttributeComponent<T extends object> extends BaseXmlComponent {
-    // tslint:disable-next-line:readonly-keyword
-    protected readonly root: T;
-    protected readonly xmlKeys?: AttributeMap<T>;
-
-    public constructor(properties: T) {
-        super("_attr");
-        this.root = properties;
-    }
-
-    public prepForXml(_: IContext): IXmlableObject {
-        const attrs = {};
-        Object.keys(this.root).forEach((key) => {
-            const value = this.root[key];
-            if (value !== undefined) {
-                const newKey = (this.xmlKeys && this.xmlKeys[key]) || key;
-                // eslint-disable-next-line functional/immutable-data
-                attrs[newKey] = value;
-            }
-        });
-        return { _attr: attrs };
-    }
-}

package/src/file/xml-components/imported-xml-component.spec.ts

@@ -1,118 +0,0 @@
-import { expect } from "chai";
-import { Element, xml2js } from "xml-js";
-
-import { EMPTY_OBJECT } from "@file/xml-components";
-
-import { convertToXmlComponent, ImportedRootElementAttributes, ImportedXmlComponent } from "./imported-xml-component";
-import { IContext } from "./base";
-
-const xmlString = `
-        <w:p w:one="value 1" w:two="value 2">
-            <w:rPr>
-                <w:noProof>some value</w:noProof>
-            </w:rPr>
-            <w:r active="true">
-                <w:t>Text 1</w:t>
-            </w:r>
-            <w:r active="true">
-                <w:t>Text 2</w:t>
-            </w:r>
-        </w:p>
-    `;
-
-const convertedXmlElement = {
-    root: [
-        {
-            rootKey: "w:p",
-            root: [
-                { rootKey: "_attr", root: { "w:one": "value 1", "w:two": "value 2" } },
-                { rootKey: "w:rPr", root: [{ rootKey: "w:noProof", root: ["some value"] }] },
-                {
-                    rootKey: "w:r",
-                    root: [
-                        { rootKey: "_attr", root: { active: "true" } },
-                        { rootKey: "w:t", root: ["Text 1"] },
-                    ],
-                },
-                {
-                    rootKey: "w:r",
-                    root: [
-                        { rootKey: "_attr", root: { active: "true" } },
-                        { rootKey: "w:t", root: ["Text 2"] },
-                    ],
-                },
-            ],
-        },
-    ],
-    rootKey: undefined,
-};
-
-describe("ImportedXmlComponent", () => {
-    let importedXmlComponent: ImportedXmlComponent;
-
-    beforeEach(() => {
-        const attributes = {
-            someAttr: "1",
-            otherAttr: "2",
-        };
-        importedXmlComponent = new ImportedXmlComponent("w:test", attributes);
-        importedXmlComponent.push(new ImportedXmlComponent("w:child"));
-    });
-
-    describe("#prepForXml()", () => {
-        it("should transform for xml", () => {
-            // tslint:disable-next-line: no-object-literal-type-assertion
-            const converted = importedXmlComponent.prepForXml({} as IContext);
-            expect(converted).to.deep.equal({
-                "w:test": [
-                    {
-                        _attr: {
-                            someAttr: "1",
-                            otherAttr: "2",
-                        },
-                    },
-                    {
-                        "w:child": EMPTY_OBJECT,
-                    },
-                ],
-            });
-        });
-    });
-
-    it("should create XmlComponent from xml string", () => {
-        const converted = ImportedXmlComponent.fromXmlString(xmlString);
-        expect(converted).to.deep.equal(convertedXmlElement);
-    });
-
-    describe("convertToXmlComponent", () => {
-        it("should convert to xml component", () => {
-            const xmlObj = xml2js(xmlString, { compact: false }) as Element;
-            const converted = convertToXmlComponent(xmlObj);
-            expect(converted).to.deep.equal(convertedXmlElement);
-        });
-
-        it("should return undefined if xml type is invalid", () => {
-            const xmlObj = { type: "invalid" } as Element;
-            const converted = convertToXmlComponent(xmlObj);
-            expect(converted).to.equal(undefined);
-        });
-    });
-});
-
-describe("ImportedRootElementAttributes", () => {
-    let attributes: ImportedRootElementAttributes;
-
-    beforeEach(() => {
-        attributes = new ImportedRootElementAttributes({});
-    });
-
-    describe("#prepForXml()", () => {
-        it("should work", () => {
-            // tslint:disable-next-line: no-object-literal-type-assertion
-            const converted = attributes.prepForXml({} as IContext);
-            expect(converted).to.deep.equal({
-                _attr: {},
-            });
-        });
-    });
-});

package/src/file/xml-components/imported-xml-component.ts

@@ -1,86 +0,0 @@
-import { Element as XmlElement, xml2js } from "xml-js";
-
-import { IXmlableObject, XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-
-import { IContext } from "./base";
-
-/**
- * Converts the given xml element (in json format) into XmlComponent.
- *
- * @param element the xml element in json presentation
- */
-
-export const convertToXmlComponent = (element: XmlElement): ImportedXmlComponent | string | undefined => {
-    switch (element.type) {
-        case undefined:
-        case "element":
-            // eslint-disable-next-line no-case-declarations
-            const xmlComponent = new ImportedXmlComponent(element.name as string, element.attributes);
-            // eslint-disable-next-line no-case-declarations
-            const childElements = element.elements || [];
-            for (const childElm of childElements) {
-                const child = convertToXmlComponent(childElm);
-                if (child !== undefined) {
-                    xmlComponent.push(child);
-                }
-            }
-            return xmlComponent;
-        case "text":
-            return element.text as string;
-        default:
-            return undefined;
-    }
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-class ImportedXmlComponentAttributes extends XmlAttributeComponent<any> {
-    // noop
-}
-
-/**
- * Represents imported xml component from xml file.
- */
-export class ImportedXmlComponent extends XmlComponent {
-    /**
-     * Converts the xml string to a XmlComponent tree.
-     *
-     * @param importedContent xml content of the imported component
-     */
-    public static fromXmlString(importedContent: string): ImportedXmlComponent {
-        const xmlObj = xml2js(importedContent, { compact: false }) as XmlElement;
-        return convertToXmlComponent(xmlObj) as ImportedXmlComponent;
-    }
-    /**
-     * Converts the xml string to a XmlComponent tree.
-     *
-     * @param importedContent xml content of the imported component
-     */
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    public constructor(rootKey: string, _attr?: any) {
-        super(rootKey);
-        if (_attr) {
-            this.root.push(new ImportedXmlComponentAttributes(_attr));
-        }
-    }
-
-    public push(xmlComponent: XmlComponent | string): void {
-        this.root.push(xmlComponent);
-    }
-}
-
-/**
- * Used for the attributes of root element that is being imported.
- */
-export class ImportedRootElementAttributes extends XmlComponent {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    public constructor(private readonly _attr: any) {
-        super("");
-    }
-
-    public prepForXml(_: IContext): IXmlableObject {
-        return {
-            _attr: this._attr,
-        };
-    }
-}

package/src/file/xml-components/index.ts

@@ -1,8 +0,0 @@
-export * from "./xml-component";
-export * from "./attributes";
-export * from "./default-attributes";
-export * from "./imported-xml-component";
-export * from "./xmlable-object";
-export * from "./initializable-xml-component";
-export * from "./simple-elements";
-export * from "./base";

package/src/file/xml-components/initializable-xml-component.ts

@@ -1,11 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-
-export abstract class InitializableXmlComponent extends XmlComponent {
-    public constructor(rootKey: string, initComponent?: InitializableXmlComponent) {
-        super(rootKey);
-
-        if (initComponent) {
-            this.root = initComponent.root;
-        }
-    }
-}

package/src/file/xml-components/simple-elements.ts

@@ -1,72 +0,0 @@
-import { Attributes, XmlComponent } from "@file/xml-components";
-
-import { hpsMeasureValue } from "@util/values";
-
-// This represents element type CT_OnOff, which indicate a boolean value.
-//
-// A value of 1 or true specifies that the property shall be explicitly applied.
-// This is the default value for this attribute, and is implied when the parent
-// element is present, but  this attribute is omitted.
-// A value of 0 or false specifies that the property shall be explicitly turned off.
-//
-// <xsd:complexType name="CT_OnOff">
-//     <xsd:attribute name="val" type="s:ST_OnOff"/>
-// </xsd:complexType>
-export class OnOffElement extends XmlComponent {
-    public constructor(name: string, val: boolean | undefined = true) {
-        super(name);
-        if (val !== true) {
-            this.root.push(new Attributes({ val }));
-        }
-    }
-}
-
-// This represents element type CT_HpsMeasure, which indicate an unsigned int or a measurement with unit.
-//
-// <xsd:complexType name="CT_HpsMeasure">
-//     <xsd:attribute name="val" type="ST_HpsMeasure" use="required"/>
-// </xsd:complexType>
-export class HpsMeasureElement extends XmlComponent {
-    public constructor(name: string, val: number | string) {
-        super(name);
-        this.root.push(new Attributes({ val: hpsMeasureValue(val) }));
-    }
-}
-
-// This represents element type CT_String, which indicate a string value.
-//
-// <xsd:complexType name="CT_String">
-//     <xsd:attribute name="val" type="s:ST_String" use="required"/>
-// </xsd:complexType>
-export class StringValueElement extends XmlComponent {
-    public constructor(name: string, val: string) {
-        super(name);
-        this.root.push(new Attributes({ val }));
-    }
-}
-
-// This represents various number element types.
-export class NumberValueElement extends XmlComponent {
-    public constructor(name: string, val: number) {
-        super(name);
-        this.root.push(new Attributes({ val }));
-    }
-}
-
-export class StringEnumValueElement<T extends string> extends XmlComponent {
-    public constructor(name: string, val: T) {
-        super(name);
-        this.root.push(new Attributes({ val }));
-    }
-}
-
-// Simple nodes containing text.
-//
-// new StringContainer("hello", "world")
-// <hello>world</hello>
-export class StringContainer extends XmlComponent {
-    public constructor(name: string, val: string) {
-        super(name);
-        this.root.push(val);
-    }
-}

package/src/file/xml-components/xml-component.spec.ts

@@ -1,62 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-import { Attributes, BaseXmlComponent, XmlComponent } from "./";
-
-class TestComponent extends XmlComponent {
-    public push(el: BaseXmlComponent): void {
-        this.root.push(el);
-    }
-}
-
-describe("XmlComponent", () => {
-    describe("#constructor()", () => {
-        it("should create an Xml Component which has the correct rootKey", () => {
-            const xmlComponent = new TestComponent("w:test");
-            const tree = new Formatter().format(xmlComponent);
-            expect(tree).to.deep.equal({
-                "w:test": {},
-            });
-        });
-        it("should handle children elements", () => {
-            const xmlComponent = new TestComponent("w:test");
-            xmlComponent.push(
-                new Attributes({
-                    val: "test",
-                }),
-            );
-            xmlComponent.push(new TestComponent("innerTest"));
-
-            const tree = new Formatter().format(xmlComponent);
-            expect(tree).to.deep.equal({
-                "w:test": [
-                    {
-                        _attr: {
-                            "w:val": "test",
-                        },
-                    },
-                    {
-                        innerTest: {},
-                    },
-                ],
-            });
-        });
-        it("should hoist attrs if only attrs are present", () => {
-            const xmlComponent = new TestComponent("w:test");
-            xmlComponent.push(
-                new Attributes({
-                    val: "test",
-                }),
-            );
-
-            const tree = new Formatter().format(xmlComponent);
-            expect(tree).to.deep.equal({
-                "w:test": {
-                    _attr: {
-                        "w:val": "test",
-                    },
-                },
-            });
-        });
-    });
-});

package/src/file/xml-components/xml-component.ts

@@ -1,52 +0,0 @@
-import { BaseXmlComponent, IContext } from "./base";
-import { IXmlableObject } from "./xmlable-object";
-
-export const EMPTY_OBJECT = Object.seal({});
-
-export abstract class XmlComponent extends BaseXmlComponent {
-    // eslint-disable-next-line functional/prefer-readonly-type, @typescript-eslint/no-explicit-any
-    protected root: (BaseXmlComponent | string | any)[];
-
-    public constructor(rootKey: string) {
-        super(rootKey);
-        this.root = new Array<BaseXmlComponent | string>();
-    }
-
-    public prepForXml(context: IContext): IXmlableObject | undefined {
-        const children = this.root
-            .map((comp) => {
-                if (comp instanceof BaseXmlComponent) {
-                    return comp.prepForXml(context);
-                }
-                return comp;
-            })
-            .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.
-        // Additionally, if the array is empty, use an empty object as our
-        // children in order to get an empty XML element generated.
-        return {
-            [this.rootKey]: children.length ? (children.length === 1 && children[0]?._attr ? children[0] : children) : EMPTY_OBJECT,
-        };
-    }
-
-    public addChildElement(child: XmlComponent | string): XmlComponent {
-        this.root.push(child);
-
-        return this;
-    }
-}
-
-export abstract class IgnoreIfEmptyXmlComponent extends XmlComponent {
-    public prepForXml(context: IContext): IXmlableObject | undefined {
-        const result = super.prepForXml(context);
-        // Ignore the object if its falsey or is an empty object (would produce
-        // an empty XML element if allowed to be included in the output).
-        if (result && (typeof result[this.rootKey] !== "object" || Object.keys(result[this.rootKey]).length)) {
-            return result;
-        }
-
-        return undefined;
-    }
-}

package/src/file/xml-components/xmlable-object.ts

@@ -1,12 +0,0 @@
-export interface IXmlAttribute {
-    readonly [key: string]: string | number | boolean;
-}
-export interface IXmlableObject extends Object {
-    readonly _attr?: IXmlAttribute;
-}
-
-// Needed because of: https://github.com/s-panferov/awesome-typescript-loader/issues/432
-/**
- * @ignore
- */
-export const WORKAROUND3 = "";

package/src/import-dotx/import-dotx.spec.ts

@@ -1,26 +0,0 @@
-import { expect } from "chai";
-
-import { ImportDotx } from "./import-dotx";
-
-describe("ImportDotx", () => {
-    describe("#constructor", () => {
-        it("should create", () => {
-            const file = new ImportDotx();
-
-            expect(file).to.deep.equal({});
-        });
-    });
-
-    // describe("#extract", () => {
-    //     it("should create", async () => {
-    //         const file = new ImportDotx();
-    //         const filePath = "./demo/dotx/template.dotx";
-
-    //         const templateDocument = await file.extract(data);
-
-    //         await file.extract(data);
-
-    //         expect(templateDocument).to.be.equal({ currentRelationshipId: 1 });
-    //     });
-    // });
-});