docx 8.0.0 → 8.0.2

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

@@ -1,41 +0,0 @@
-import { BaseXmlComponent, IContext } from "./base";
-import { IXmlableObject, IXmlAttribute } from "./xmlable-object";
-
-export type AttributeMap<T> = { readonly [P in keyof T]: string };
-
-export type AttributeData = { readonly [key: string]: boolean | number | string };
-export type AttributePayload<T> = { readonly [P in keyof T]: { readonly key: string; readonly value: T[P] } };
-
-export abstract class XmlAttributeComponent<T extends object> extends BaseXmlComponent {
-    protected readonly xmlKeys?: AttributeMap<T>;
-
-    public constructor(private readonly root: T) {
-        super("_attr");
-    }
-
-    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 };
-    }
-}
-
-export class NextAttributeComponent<T extends AttributeData> extends BaseXmlComponent {
-    public constructor(private readonly root: AttributePayload<T>) {
-        super("_attr");
-    }
-
-    public prepForXml(_: IContext): IXmlableObject {
-        const attrs = Object.values<{ readonly key: string; readonly value: string | boolean | number }>(this.root)
-            .filter(({ value }) => value !== undefined)
-            .reduce((acc, { key, value }) => ({ ...acc, [key]: value }), {} as IXmlAttribute);
-        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({ stack: [] } as unknown 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.spec.ts

@@ -1,41 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { BuilderElement } from "./simple-elements";
-
-describe("BuilderElement", () => {
-    describe("#constructor()", () => {
-        it("should create a simple BuilderElement", () => {
-            const element = new BuilderElement({
-                name: "test",
-            });
-
-            const tree = new Formatter().format(element);
-            expect(tree).to.deep.equal({
-                test: {},
-            });
-        });
-
-        it("should create a simple BuilderElement with attributes", () => {
-            const element = new BuilderElement<{ readonly testAttr: string }>({
-                name: "test",
-                attributes: {
-                    testAttr: {
-                        key: "w:testAttr",
-                        value: "test",
-                    },
-                },
-            });
-
-            const tree = new Formatter().format(element);
-            expect(tree).to.deep.equal({
-                test: {
-                    _attr: {
-                        "w:testAttr": "test",
-                    },
-                },
-            });
-        });
-    });
-});

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

@@ -1,98 +0,0 @@
-import { AttributeData, AttributePayload, Attributes, NextAttributeComponent, XmlComponent } from "@file/xml-components";
-
-import { hpsMeasureValue, PositiveUniversalMeasure } 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>
-
-// <xsd:simpleType name="ST_HpsMeasure">
-//     <xsd:union memberTypes="s:ST_UnsignedDecimalNumber s:ST_PositiveUniversalMeasure" />
-// </xsd:simpleType>
-
-export class HpsMeasureElement extends XmlComponent {
-    public constructor(name: string, val: number | PositiveUniversalMeasure) {
-        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_Empty"/>
-export class EmptyElement extends XmlComponent {}
-
-// This represents element type CT_Empty, which indicate aan empty element.
-//
-// <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);
-    }
-}
-
-export class BuilderElement<T extends AttributeData> extends XmlComponent {
-    public constructor(options: {
-        readonly name: string;
-        readonly attributes?: AttributePayload<T>;
-        readonly children?: readonly XmlComponent[];
-    }) {
-        super(options.name);
-
-        if (options.attributes) {
-            this.root.push(new NextAttributeComponent(options.attributes));
-        }
-
-        // TODO: Children
-    }
-}

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,63 +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>();
-    }
-
-    // This method is called by the formatter to get the XML representation of this component.
-    // It is called recursively for all child components.
-    // It is a serializer to be used in the xml library.
-    // https://www.npmjs.com/package/xml
-    // Child components can override this method to customize the XML representation, or execute side effects.
-    public prepForXml(context: IContext): IXmlableObject | undefined {
-        // Mutating the stack is required for performance reasons
-        // eslint-disable-next-line functional/immutable-data
-        context.stack.push(this);
-        const children = this.root
-            .map((comp) => {
-                if (comp instanceof BaseXmlComponent) {
-                    return comp.prepForXml(context);
-                }
-                return comp;
-            })
-            .filter((comp) => comp !== undefined); // Exclude undefined
-
-        // eslint-disable-next-line functional/immutable-data
-        context.stack.pop();
-        // 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/index.spec.ts

@@ -1,15 +0,0 @@
-import { expect } from "chai";
-
-import { Document } from "./index";
-
-describe("Index", () => {
-    describe("Document", () => {
-        it("should instantiate the Document", () => {
-            expect(
-                new Document({
-                    sections: [],
-                }),
-            ).to.be.ok;
-        });
-    });
-});

package/src/index.ts

@@ -1,7 +0,0 @@
-// Internally, the wrapper is a 'File', but export to the end user as a 'Document'
-// Use of 'File' also works
-export { File as Document } from "./file";
-export * from "./file";
-export * from "./export";
-export * from "./util";
-export * from "./patcher";

package/src/patcher/content-types-manager.spec.ts

@@ -1,51 +0,0 @@
-import { expect } from "chai";
-import { appendContentType } from "./content-types-manager";
-
-describe("content-types-manager", () => {
-    describe("appendContentType", () => {
-        it("should append a content type", () => {
-            const element = {
-                type: "element",
-                name: "xml",
-                elements: [
-                    {
-                        type: "element",
-                        name: "Types",
-                        elements: [
-                            {
-                                type: "element",
-                                name: "Default",
-                            },
-                        ],
-                    },
-                ],
-            };
-            appendContentType(element, "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml", "docx");
-
-            expect(element).to.deep.equal({
-                elements: [
-                    {
-                        elements: [
-                            {
-                                name: "Default",
-                                type: "element",
-                            },
-                            {
-                                attributes: {
-                                    ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",
-                                    Extension: "docx",
-                                },
-                                name: "Default",
-                                type: "element",
-                            },
-                        ],
-                        name: "Types",
-                        type: "element",
-                    },
-                ],
-                name: "xml",
-                type: "element",
-            });
-        });
-    });
-});

package/src/patcher/content-types-manager.ts

@@ -1,16 +0,0 @@
-import { Element } from "xml-js";
-
-import { getFirstLevelElements } from "./util";
-
-export const appendContentType = (element: Element, contentType: string, extension: string): void => {
-    const relationshipElements = getFirstLevelElements(element, "Types");
-    // eslint-disable-next-line functional/immutable-data
-    relationshipElements.push({
-        attributes: {
-            ContentType: contentType,
-            Extension: extension,
-        },
-        name: "Default",
-        type: "element",
-    });
-};