@bnsights/bbsf-utilities 1.0.40 → 1.0.42

package/esm2020/lib/shared/config/word/docx-document.mjs

@@ -0,0 +1,348 @@
+import { create, fragment } from 'xmlbuilder2';
+import { nanoid } from 'nanoid';
+import { generateCoreXML, generateStylesXML, generateNumberingXMLTemplate, generateThemeXML, documentRelsXML as documentRelsXMLString, settingsXML as settingsXMLString, webSettingsXML as webSettingsXMLString, contentTypesXML as contentTypesXMLString, fontTableXML as fontTableXMLString, genericRelsXML as genericRelsXMLString, generateDocumentTemplate, } from './schemas';
+import { convertVTreeToXML } from './helpers';
+import namespaces from './namespaces';
+import { footerType as footerFileType, headerType as headerFileType, themeType as themeFileType, landscapeMargins, portraitMargins, defaultOrientation, landscapeWidth, landscapeHeight, applicationName, defaultFont, defaultFontSize, hyperlinkType, documentFileName, imageType, defaultDocumentOptions, } from './constants';
+import { ListStyleBuilder } from './utils/list';
+function generateContentTypesFragments(contentTypesXML, type, objects) {
+    if (objects && Array.isArray(objects)) {
+        objects.forEach((object) => {
+            const contentTypesFragment = fragment({ defaultNamespace: { ele: namespaces.contentTypes } })
+                .ele('Override')
+                .att('PartName', `/word/${type}${object[`${type}Id`]}.xml`)
+                .att('ContentType', `application/vnd.openxmlformats-officedocument.wordprocessingml.${type}+xml`)
+                .up();
+            contentTypesXML.root().import(contentTypesFragment);
+        });
+    }
+}
+function generateSectionReferenceXML(documentXML, documentSectionType, objects, isEnabled) {
+    if (isEnabled && objects && Array.isArray(objects) && objects.length) {
+        const xmlFragment = fragment();
+        objects.forEach(({ relationshipId, type }) => {
+            const objectFragment = fragment({ namespaceAlias: { w: namespaces.w, r: namespaces.r } })
+                .ele('@w', `${documentSectionType}Reference`)
+                .att('@r', 'id', `rId${relationshipId}`)
+                .att('@w', 'type', type)
+                .up();
+            xmlFragment.import(objectFragment);
+        });
+        documentXML.root().first().first().import(xmlFragment);
+    }
+}
+function generateXMLString(xmlString) {
+    const xmlDocumentString = create({ encoding: 'UTF-8', standalone: true }, xmlString);
+    return xmlDocumentString.toString({ prettyPrint: true });
+}
+async function generateSectionXML(vTree, type = 'header') {
+    debugger;
+    const sectionXML = create({
+        encoding: 'UTF-8',
+        standalone: true,
+        namespaceAlias: {
+            a: namespaces.a,
+            cdr: namespaces.cdr,
+            o: namespaces.o,
+            pic: namespaces.pic,
+            r: namespaces.r,
+            v: namespaces.v,
+            ve: namespaces.ve,
+            vt: namespaces.vt,
+            w: namespaces.w,
+            w10: namespaces.w10,
+            wp: namespaces.wp,
+            wne: namespaces.wne
+        },
+    }).ele('@w', type === 'header' ? 'hdr' : 'ftr');
+    const XMLFragment = fragment();
+    await convertVTreeToXML(this, vTree, XMLFragment);
+    if (type === 'footer' && XMLFragment.first().node.tagName === 'p' && this.pageNumber) {
+        XMLFragment.first().import(fragment({ namespaceAlias: { w: namespaces.w } })
+            .ele('@w', 'fldSimple')
+            .att('@w', 'instr', 'PAGE')
+            .ele('@w', 'r')
+            .up()
+            .up());
+    }
+    sectionXML.root().import(XMLFragment);
+    const referenceName = type === 'header' ? 'Header' : 'Footer';
+    this[`last${referenceName}Id`] += 1;
+    return { [`${type}Id`]: this[`last${referenceName}Id`], [`${type}XML`]: sectionXML };
+}
+export class DocxDocument {
+    constructor(properties) {
+        this.zip = properties.zip;
+        this.htmlString = properties.htmlString;
+        this.orientation = properties.orientation;
+        this.pageSize = properties.pageSize || defaultDocumentOptions.pageSize;
+        const isPortraitOrientation = this.orientation === defaultOrientation;
+        const height = this.pageSize.height ? this.pageSize.height : landscapeHeight;
+        const width = this.pageSize.width ? this.pageSize.width : landscapeWidth;
+        this.width = isPortraitOrientation ? width : height;
+        this.height = isPortraitOrientation ? height : width;
+        const marginsObject = properties.margins;
+        this.margins =
+            // eslint-disable-next-line no-nested-ternary
+            marginsObject && Object.keys(marginsObject).length
+                ? marginsObject
+                : isPortraitOrientation
+                    ? portraitMargins
+                    : landscapeMargins;
+        this.availableDocumentSpace = this.width - this.margins.left - this.margins.right;
+        this.title = properties.title || '';
+        this.subject = properties.subject || '';
+        this.creator = properties.creator || applicationName;
+        this.keywords = properties.keywords || [applicationName];
+        this.description = properties.description || '';
+        this.lastModifiedBy = properties.lastModifiedBy || applicationName;
+        this.revision = properties.revision || 1;
+        this.createdAt = properties.createdAt || new Date();
+        this.modifiedAt = properties.modifiedAt || new Date();
+        this.headerType = properties.headerType || 'default';
+        this.header = properties.header || false;
+        this.footerType = properties.footerType || 'default';
+        this.footer = properties.footer || false;
+        this.font = properties.font || defaultFont;
+        this.fontSize = properties.fontSize || defaultFontSize;
+        this.complexScriptFontSize = properties.complexScriptFontSize || defaultFontSize;
+        this.tableRowCantSplit =
+            (properties.table && properties.table.row && properties.table.row.cantSplit) || false;
+        this.pageNumber = properties.pageNumber || false;
+        this.skipFirstHeaderFooter = properties.skipFirstHeaderFooter || false;
+        this.lineNumber = properties.lineNumber ? properties.lineNumberOptions : null;
+        this.lastNumberingId = 0;
+        this.lastMediaId = 0;
+        this.lastHeaderId = 0;
+        this.lastFooterId = 0;
+        this.stylesObjects = [];
+        this.numberingObjects = [];
+        this.relationshipFilename = documentFileName;
+        this.relationships = [{ fileName: documentFileName, lastRelsId: 4, rels: [] }];
+        this.mediaFiles = [];
+        this.headerObjects = [];
+        this.footerObjects = [];
+        this.documentXML = null;
+        this.generateContentTypesXML = this.generateContentTypesXML.bind(this);
+        this.generateDocumentXML = this.generateDocumentXML.bind(this);
+        this.generateCoreXML = this.generateCoreXML.bind(this);
+        this.generateSettingsXML = this.generateSettingsXML.bind(this);
+        this.generateWebSettingsXML = this.generateWebSettingsXML.bind(this);
+        this.generateStylesXML = this.generateStylesXML.bind(this);
+        this.generateFontTableXML = this.generateFontTableXML.bind(this);
+        this.generateThemeXML = this.generateThemeXML.bind(this);
+        this.generateNumberingXML = this.generateNumberingXML.bind(this);
+        this.generateRelsXML = this.generateRelsXML.bind(this);
+        this.createMediaFile = this.createMediaFile.bind(this);
+        this.createDocumentRelationships = this.createDocumentRelationships.bind(this);
+        this.generateHeaderXML = this.generateHeaderXML.bind(this);
+        this.generateFooterXML = this.generateFooterXML.bind(this);
+        this.generateSectionXML = generateSectionXML.bind(this);
+        this.ListStyleBuilder = new ListStyleBuilder(properties.numbering);
+    }
+    generateContentTypesXML() {
+        const contentTypesXML = create({ encoding: 'UTF-8', standalone: true }, contentTypesXMLString);
+        generateContentTypesFragments(contentTypesXML, 'header', this.headerObjects);
+        generateContentTypesFragments(contentTypesXML, 'footer', this.footerObjects);
+        return contentTypesXML.toString({ prettyPrint: true });
+    }
+    generateDocumentXML() {
+        const documentXML = create({ encoding: 'UTF-8', standalone: true }, generateDocumentTemplate(this.width, this.height, this.orientation, this.margins));
+        // documentXML.root().first().import(this.documentXML);
+        generateSectionReferenceXML(documentXML, 'header', this.headerObjects, this.header);
+        generateSectionReferenceXML(documentXML, 'footer', this.footerObjects, this.footer);
+        if ((this.header || this.footer) && this.skipFirstHeaderFooter) {
+            documentXML
+                .root()
+                .first()
+                .first()
+                .import(fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'titlePg'));
+        }
+        if (this.lineNumber) {
+            const { countBy, start, restart } = this.lineNumber;
+            documentXML
+                .root()
+                .first()
+                .first()
+                .import(fragment({ namespaceAlias: { w: namespaces.w } })
+                .ele('@w', 'lnNumType')
+                .att('@w', 'countBy', countBy)
+                .att('@w', 'start', start)
+                .att('@w', 'restart', restart));
+        }
+        return documentXML.toString({ prettyPrint: true });
+    }
+    generateCoreXML() {
+        return generateXMLString(generateCoreXML(this.title, this.subject, this.creator, this.keywords, this.description, this.lastModifiedBy, this.revision, this.createdAt, this.modifiedAt));
+    }
+    // eslint-disable-next-line class-methods-use-this
+    generateSettingsXML() {
+        return generateXMLString(settingsXMLString);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    generateWebSettingsXML() {
+        return generateXMLString(webSettingsXMLString);
+    }
+    generateStylesXML() {
+        return generateXMLString(generateStylesXML(this.font, this.fontSize, this.complexScriptFontSize));
+    }
+    // eslint-disable-next-line class-methods-use-this
+    generateFontTableXML() {
+        return generateXMLString(fontTableXMLString);
+    }
+    generateThemeXML() {
+        return generateXMLString(generateThemeXML(this.font));
+    }
+    generateNumberingXML() {
+        const numberingXML = create({ encoding: 'UTF-8', standalone: true }, generateNumberingXMLTemplate());
+        const abstractNumberingFragments = fragment();
+        const numberingFragments = fragment();
+        this.numberingObjects.forEach(({ numberingId, type, properties }) => {
+            const abstractNumberingFragment = fragment({ namespaceAlias: { w: namespaces.w } })
+                .ele('@w', 'abstractNum')
+                .att('@w', 'abstractNumId', String(numberingId));
+            [...Array(8).keys()].forEach((level) => {
+                const levelFragment = fragment({ namespaceAlias: { w: namespaces.w } })
+                    .ele('@w', 'lvl')
+                    .att('@w', 'ilvl', level)
+                    .ele('@w', 'start')
+                    .att('@w', 'val', type === 'ol'
+                    ? (properties.attributes && properties.attributes['data-start']) || 1
+                    : '1')
+                    .up()
+                    .ele('@w', 'numFmt')
+                    .att('@w', 'val', type === 'ol'
+                    ? this.ListStyleBuilder.getListStyleType(properties.style && properties.style['list-style-type'])
+                    : 'bullet')
+                    .up()
+                    .ele('@w', 'lvlText')
+                    .att('@w', 'val', type === 'ol' ? this.ListStyleBuilder.getListPrefixSuffix(properties.style, level) : '')
+                    .up()
+                    .ele('@w', 'lvlJc')
+                    .att('@w', 'val', 'left')
+                    .up()
+                    .ele('@w', 'pPr')
+                    .ele('@w', 'tabs')
+                    .ele('@w', 'tab')
+                    .att('@w', 'val', 'num')
+                    .att('@w', 'pos', (level + 1) * 720)
+                    .up()
+                    .up()
+                    .ele('@w', 'ind')
+                    .att('@w', 'left', (level + 1) * 720)
+                    .att('@w', 'hanging', 360)
+                    .up()
+                    .up()
+                    .up();
+                if (type === 'ul') {
+                    levelFragment.last().import(fragment({ namespaceAlias: { w: namespaces.w } })
+                        .ele('@w', 'rPr')
+                        .ele('@w', 'rFonts')
+                        .att('@w', 'ascii', 'Symbol')
+                        .att('@w', 'hAnsi', 'Symbol')
+                        .att('@w', 'hint', 'default')
+                        .up()
+                        .up());
+                }
+                abstractNumberingFragment.import(levelFragment);
+            });
+            abstractNumberingFragment.up();
+            abstractNumberingFragments.import(abstractNumberingFragment);
+            numberingFragments.import(fragment({ namespaceAlias: { w: namespaces.w } })
+                .ele('@w', 'num')
+                .att('@w', 'numId', String(numberingId))
+                .ele('@w', 'abstractNumId')
+                .att('@w', 'val', String(numberingId))
+                .up()
+                .up());
+        });
+        numberingXML.root().import(abstractNumberingFragments);
+        numberingXML.root().import(numberingFragments);
+        return numberingXML.toString({ prettyPrint: true });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    appendRelationships(xmlFragment, relationships) {
+        relationships.forEach(({ relationshipId, type, target, targetMode }) => {
+            xmlFragment.import(fragment({ defaultNamespace: { ele: namespaces.relationship } })
+                .ele('Relationship')
+                .att('Id', `rId${relationshipId}`)
+                .att('Type', type)
+                .att('Target', target)
+                .att('TargetMode', targetMode)
+                .up());
+        });
+    }
+    generateRelsXML() {
+        const relationshipXMLStrings = this.relationships.map(({ fileName, rels }) => {
+            const xmlFragment = create({ encoding: 'UTF-8', standalone: true }, fileName === documentFileName ? documentRelsXMLString : genericRelsXMLString);
+            this.appendRelationships(xmlFragment.root(), rels);
+            return { fileName, xmlString: xmlFragment.toString({ prettyPrint: true }) };
+        });
+        return relationshipXMLStrings;
+    }
+    createNumbering(type, properties) {
+        this.lastNumberingId += 1;
+        this.numberingObjects.push({ numberingId: this.lastNumberingId, type, properties });
+        return this.lastNumberingId;
+    }
+    createMediaFile(base64String) {
+        // eslint-disable-next-line no-useless-escape
+        const matches = base64String.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/);
+        if (matches.length !== 3) {
+            throw new Error('Invalid base64 string');
+        }
+        const base64FileContent = matches[2];
+        // matches array contains file type in base64 format - image/jpeg and base64 stringified data
+        const fileExtension = matches[1].match(/\/(.*?)$/)[1] === 'octet-stream' ? 'png' : matches[1].match(/\/(.*?)$/)[1];
+        const fileNameWithExtension = `image-${nanoid()}.${fileExtension}`;
+        this.lastMediaId += 1;
+        return { id: this.lastMediaId, fileContent: base64FileContent, fileNameWithExtension };
+    }
+    createDocumentRelationships(fileName = 'document', type, target, targetMode = 'External') {
+        debugger;
+        let relationshipObject = this.relationships.find((relationship) => relationship.fileName === fileName);
+        let lastRelsId = 1;
+        if (relationshipObject) {
+            lastRelsId = relationshipObject.lastRelsId + 1;
+            relationshipObject.lastRelsId = lastRelsId;
+        }
+        else {
+            relationshipObject = { fileName, lastRelsId, rels: [] };
+            this.relationships.push(relationshipObject);
+        }
+        let relationshipType;
+        switch (type) {
+            case hyperlinkType:
+                relationshipType = namespaces.hyperlinks;
+                break;
+            case imageType:
+                relationshipType = namespaces.images;
+                break;
+            case headerFileType:
+                relationshipType = namespaces.headers;
+                break;
+            case footerFileType:
+                relationshipType = namespaces.footers;
+                break;
+            case themeFileType:
+                relationshipType = namespaces.themes;
+                break;
+        }
+        relationshipObject.rels.push({
+            relationshipId: lastRelsId,
+            type: relationshipType,
+            target,
+            targetMode,
+        });
+        console.log(fileName);
+        console.log(relationshipObject.rels);
+        return lastRelsId;
+    }
+    generateHeaderXML(vTree) {
+        return this.generateSectionXML(vTree, 'header');
+    }
+    generateFooterXML(vTree) {
+        return this.generateSectionXML(vTree, 'footer');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"docx-document.js","sourceRoot":"","sources":["../../../../../../../projects/bbsf-utilities/src/lib/shared/config/word/docx-document.js"],"names":[],"mappings":"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","sourcesContent":["import { create, fragment } from 'xmlbuilder2';\r\nimport { nanoid } from 'nanoid';\r\n\r\nimport {\r\n  generateCoreXML,\r\n  generateStylesXML,\r\n  generateNumberingXMLTemplate,\r\n  generateThemeXML,\r\n  documentRelsXML as documentRelsXMLString,\r\n  settingsXML as settingsXMLString,\r\n  webSettingsXML as webSettingsXMLString,\r\n  contentTypesXML as contentTypesXMLString,\r\n  fontTableXML as fontTableXMLString,\r\n  genericRelsXML as genericRelsXMLString,\r\n  generateDocumentTemplate,\r\n} from './schemas';\r\nimport { convertVTreeToXML } from './helpers';\r\nimport namespaces from './namespaces';\r\nimport {\r\n  footerType as footerFileType,\r\n  headerType as headerFileType,\r\n  themeType as themeFileType,\r\n  landscapeMargins,\r\n  portraitMargins,\r\n  defaultOrientation,\r\n  landscapeWidth,\r\n  landscapeHeight,\r\n  applicationName,\r\n  defaultFont,\r\n  defaultFontSize,\r\n  hyperlinkType,\r\n  documentFileName,\r\n  imageType,\r\n  defaultDocumentOptions,\r\n} from './constants';\r\nimport { ListStyleBuilder } from './utils/list';\r\n\r\nfunction generateContentTypesFragments(contentTypesXML, type, objects) {\r\n  if (objects && Array.isArray(objects)) {\r\n    objects.forEach((object) => {\r\n      const contentTypesFragment = fragment({ defaultNamespace: { ele: namespaces.contentTypes } })\r\n        .ele('Override')\r\n        .att('PartName', `/word/${type}${object[`${type}Id`]}.xml`)\r\n        .att(\r\n          'ContentType',\r\n          `application/vnd.openxmlformats-officedocument.wordprocessingml.${type}+xml`\r\n        )\r\n        .up();\r\n\r\n      contentTypesXML.root().import(contentTypesFragment);\r\n    });\r\n  }\r\n}\r\n\r\nfunction generateSectionReferenceXML(documentXML, documentSectionType, objects, isEnabled) {\r\n  if (isEnabled && objects && Array.isArray(objects) && objects.length) {\r\n    const xmlFragment = fragment();\r\n    objects.forEach(({ relationshipId, type }) => {\r\n      const objectFragment = fragment({ namespaceAlias: { w: namespaces.w, r: namespaces.r } })\r\n        .ele('@w', `${documentSectionType}Reference`)\r\n        .att('@r', 'id', `rId${relationshipId}`)\r\n        .att('@w', 'type', type)\r\n        .up();\r\n      xmlFragment.import(objectFragment);\r\n    });\r\n\r\n    documentXML.root().first().first().import(xmlFragment);\r\n  }\r\n}\r\n\r\nfunction generateXMLString(xmlString) {\r\n  const xmlDocumentString = create({ encoding: 'UTF-8', standalone: true }, xmlString);\r\n  return xmlDocumentString.toString({ prettyPrint: true });\r\n}\r\n\r\nasync function generateSectionXML(vTree, type = 'header') {\r\n  debugger;\r\n  const sectionXML = create({\r\n    encoding: 'UTF-8',\r\n    standalone: true,\r\n    namespaceAlias: {\r\n      a: namespaces.a,\r\n      cdr: namespaces.cdr,\r\n      o: namespaces.o,\r\n      pic: namespaces.pic,\r\n      r: namespaces.r,\r\n      v: namespaces.v,\r\n      ve: namespaces.ve,\r\n      vt: namespaces.vt,\r\n      w: namespaces.w,\r\n      w10: namespaces.w10,\r\n      wp: namespaces.wp,\r\n      wne: namespaces.wne\r\n    },\r\n  }).ele('@w', type === 'header' ? 'hdr' : 'ftr');\r\n\r\n  const XMLFragment = fragment();\r\n  await convertVTreeToXML(this, vTree, XMLFragment);\r\n  if (type === 'footer' && XMLFragment.first().node.tagName === 'p' && this.pageNumber) {\r\n    XMLFragment.first().import(\r\n      fragment({ namespaceAlias: { w: namespaces.w } })\r\n        .ele('@w', 'fldSimple')\r\n        .att('@w', 'instr', 'PAGE')\r\n        .ele('@w', 'r')\r\n        .up()\r\n        .up()\r\n    );\r\n  }\r\n  sectionXML.root().import(XMLFragment);\r\n\r\n  const referenceName = type === 'header' ? 'Header' : 'Footer';\r\n  this[`last${referenceName}Id`] += 1;\r\n\r\n  return { [`${type}Id`]: this[`last${referenceName}Id`], [`${type}XML`]: sectionXML };\r\n}\r\n\r\nexport class DocxDocument {\r\n  constructor(properties) {\r\n    this.zip = properties.zip;\r\n    this.htmlString = properties.htmlString;\r\n    this.orientation = properties.orientation;\r\n    this.pageSize = properties.pageSize || defaultDocumentOptions.pageSize;\r\n\r\n    const isPortraitOrientation = this.orientation === defaultOrientation;\r\n    const height = this.pageSize.height ? this.pageSize.height : landscapeHeight;\r\n    const width = this.pageSize.width ? this.pageSize.width : landscapeWidth;\r\n\r\n    this.width = isPortraitOrientation ? width : height;\r\n    this.height = isPortraitOrientation ? height : width;\r\n\r\n    const marginsObject = properties.margins;\r\n    this.margins =\r\n      // eslint-disable-next-line no-nested-ternary\r\n      marginsObject && Object.keys(marginsObject).length\r\n        ? marginsObject\r\n        : isPortraitOrientation\r\n          ? portraitMargins\r\n          : landscapeMargins;\r\n\r\n    this.availableDocumentSpace = this.width - this.margins.left - this.margins.right;\r\n    this.title = properties.title || '';\r\n    this.subject = properties.subject || '';\r\n    this.creator = properties.creator || applicationName;\r\n    this.keywords = properties.keywords || [applicationName];\r\n    this.description = properties.description || '';\r\n    this.lastModifiedBy = properties.lastModifiedBy || applicationName;\r\n    this.revision = properties.revision || 1;\r\n    this.createdAt = properties.createdAt || new Date();\r\n    this.modifiedAt = properties.modifiedAt || new Date();\r\n    this.headerType = properties.headerType || 'default';\r\n    this.header = properties.header || false;\r\n    this.footerType = properties.footerType || 'default';\r\n    this.footer = properties.footer || false;\r\n    this.font = properties.font || defaultFont;\r\n    this.fontSize = properties.fontSize || defaultFontSize;\r\n    this.complexScriptFontSize = properties.complexScriptFontSize || defaultFontSize;\r\n    this.tableRowCantSplit =\r\n      (properties.table && properties.table.row && properties.table.row.cantSplit) || false;\r\n    this.pageNumber = properties.pageNumber || false;\r\n    this.skipFirstHeaderFooter = properties.skipFirstHeaderFooter || false;\r\n    this.lineNumber = properties.lineNumber ? properties.lineNumberOptions : null;\r\n\r\n    this.lastNumberingId = 0;\r\n    this.lastMediaId = 0;\r\n    this.lastHeaderId = 0;\r\n    this.lastFooterId = 0;\r\n    this.stylesObjects = [];\r\n    this.numberingObjects = [];\r\n    this.relationshipFilename = documentFileName;\r\n    this.relationships = [{ fileName: documentFileName, lastRelsId: 4, rels: [] }];\r\n    this.mediaFiles = [];\r\n    this.headerObjects = [];\r\n    this.footerObjects = [];\r\n    this.documentXML = null;\r\n\r\n    this.generateContentTypesXML = this.generateContentTypesXML.bind(this);\r\n    this.generateDocumentXML = this.generateDocumentXML.bind(this);\r\n    this.generateCoreXML = this.generateCoreXML.bind(this);\r\n    this.generateSettingsXML = this.generateSettingsXML.bind(this);\r\n    this.generateWebSettingsXML = this.generateWebSettingsXML.bind(this);\r\n    this.generateStylesXML = this.generateStylesXML.bind(this);\r\n    this.generateFontTableXML = this.generateFontTableXML.bind(this);\r\n    this.generateThemeXML = this.generateThemeXML.bind(this);\r\n    this.generateNumberingXML = this.generateNumberingXML.bind(this);\r\n    this.generateRelsXML = this.generateRelsXML.bind(this);\r\n    this.createMediaFile = this.createMediaFile.bind(this);\r\n    this.createDocumentRelationships = this.createDocumentRelationships.bind(this);\r\n    this.generateHeaderXML = this.generateHeaderXML.bind(this);\r\n    this.generateFooterXML = this.generateFooterXML.bind(this);\r\n    this.generateSectionXML = generateSectionXML.bind(this);\r\n\r\n    this.ListStyleBuilder = new ListStyleBuilder(properties.numbering);\r\n  }\r\n\r\n  generateContentTypesXML() {\r\n    const contentTypesXML = create({ encoding: 'UTF-8', standalone: true }, contentTypesXMLString);\r\n\r\n    generateContentTypesFragments(contentTypesXML, 'header', this.headerObjects);\r\n    generateContentTypesFragments(contentTypesXML, 'footer', this.footerObjects);\r\n\r\n    return contentTypesXML.toString({ prettyPrint: true });\r\n  }\r\n\r\n  generateDocumentXML() {\r\n    const documentXML = create(\r\n      { encoding: 'UTF-8', standalone: true },\r\n      generateDocumentTemplate(this.width, this.height, this.orientation, this.margins)\r\n    );\r\n    // documentXML.root().first().import(this.documentXML);\r\n\r\n    generateSectionReferenceXML(documentXML, 'header', this.headerObjects, this.header);\r\n    generateSectionReferenceXML(documentXML, 'footer', this.footerObjects, this.footer);\r\n\r\n    if ((this.header || this.footer) && this.skipFirstHeaderFooter) {\r\n      documentXML\r\n        .root()\r\n        .first()\r\n        .first()\r\n        .import(fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'titlePg'));\r\n    }\r\n    if (this.lineNumber) {\r\n      const { countBy, start, restart } = this.lineNumber;\r\n      documentXML\r\n        .root()\r\n        .first()\r\n        .first()\r\n        .import(\r\n          fragment({ namespaceAlias: { w: namespaces.w } })\r\n            .ele('@w', 'lnNumType')\r\n            .att('@w', 'countBy', countBy)\r\n            .att('@w', 'start', start)\r\n            .att('@w', 'restart', restart)\r\n        );\r\n    }\r\n\r\n    return documentXML.toString({ prettyPrint: true });\r\n  }\r\n\r\n  generateCoreXML() {\r\n    return generateXMLString(\r\n      generateCoreXML(\r\n        this.title,\r\n        this.subject,\r\n        this.creator,\r\n        this.keywords,\r\n        this.description,\r\n        this.lastModifiedBy,\r\n        this.revision,\r\n        this.createdAt,\r\n        this.modifiedAt\r\n      )\r\n    );\r\n  }\r\n\r\n  // eslint-disable-next-line class-methods-use-this\r\n  generateSettingsXML() {\r\n    return generateXMLString(settingsXMLString);\r\n  }\r\n\r\n  // eslint-disable-next-line class-methods-use-this\r\n  generateWebSettingsXML() {\r\n    return generateXMLString(webSettingsXMLString);\r\n  }\r\n\r\n  generateStylesXML() {\r\n    return generateXMLString(\r\n      generateStylesXML(this.font, this.fontSize, this.complexScriptFontSize)\r\n    );\r\n  }\r\n\r\n  // eslint-disable-next-line class-methods-use-this\r\n  generateFontTableXML() {\r\n    return generateXMLString(fontTableXMLString);\r\n  }\r\n\r\n  generateThemeXML() {\r\n    return generateXMLString(generateThemeXML(this.font));\r\n  }\r\n\r\n  generateNumberingXML() {\r\n    const numberingXML = create(\r\n      { encoding: 'UTF-8', standalone: true },\r\n      generateNumberingXMLTemplate()\r\n    );\r\n\r\n    const abstractNumberingFragments = fragment();\r\n    const numberingFragments = fragment();\r\n\r\n    this.numberingObjects.forEach(({ numberingId, type, properties }) => {\r\n      const abstractNumberingFragment = fragment({ namespaceAlias: { w: namespaces.w } })\r\n        .ele('@w', 'abstractNum')\r\n        .att('@w', 'abstractNumId', String(numberingId));\r\n\r\n      [...Array(8).keys()].forEach((level) => {\r\n        const levelFragment = fragment({ namespaceAlias: { w: namespaces.w } })\r\n          .ele('@w', 'lvl')\r\n          .att('@w', 'ilvl', level)\r\n          .ele('@w', 'start')\r\n          .att(\r\n            '@w',\r\n            'val',\r\n            type === 'ol'\r\n              ? (properties.attributes && properties.attributes['data-start']) || 1\r\n              : '1'\r\n          )\r\n          .up()\r\n          .ele('@w', 'numFmt')\r\n          .att(\r\n            '@w',\r\n            'val',\r\n            type === 'ol'\r\n              ? this.ListStyleBuilder.getListStyleType(\r\n                properties.style && properties.style['list-style-type']\r\n              )\r\n              : 'bullet'\r\n          )\r\n          .up()\r\n          .ele('@w', 'lvlText')\r\n          .att(\r\n            '@w',\r\n            'val',\r\n            type === 'ol' ? this.ListStyleBuilder.getListPrefixSuffix(properties.style, level) : ''\r\n          )\r\n          .up()\r\n          .ele('@w', 'lvlJc')\r\n          .att('@w', 'val', 'left')\r\n          .up()\r\n          .ele('@w', 'pPr')\r\n          .ele('@w', 'tabs')\r\n          .ele('@w', 'tab')\r\n          .att('@w', 'val', 'num')\r\n          .att('@w', 'pos', (level + 1) * 720)\r\n          .up()\r\n          .up()\r\n          .ele('@w', 'ind')\r\n          .att('@w', 'left', (level + 1) * 720)\r\n          .att('@w', 'hanging', 360)\r\n          .up()\r\n          .up()\r\n          .up();\r\n\r\n        if (type === 'ul') {\r\n          levelFragment.last().import(\r\n            fragment({ namespaceAlias: { w: namespaces.w } })\r\n              .ele('@w', 'rPr')\r\n              .ele('@w', 'rFonts')\r\n              .att('@w', 'ascii', 'Symbol')\r\n              .att('@w', 'hAnsi', 'Symbol')\r\n              .att('@w', 'hint', 'default')\r\n              .up()\r\n              .up()\r\n          );\r\n        }\r\n        abstractNumberingFragment.import(levelFragment);\r\n      });\r\n      abstractNumberingFragment.up();\r\n      abstractNumberingFragments.import(abstractNumberingFragment);\r\n\r\n      numberingFragments.import(\r\n        fragment({ namespaceAlias: { w: namespaces.w } })\r\n          .ele('@w', 'num')\r\n          .att('@w', 'numId', String(numberingId))\r\n          .ele('@w', 'abstractNumId')\r\n          .att('@w', 'val', String(numberingId))\r\n          .up()\r\n          .up()\r\n      );\r\n    });\r\n\r\n    numberingXML.root().import(abstractNumberingFragments);\r\n    numberingXML.root().import(numberingFragments);\r\n\r\n    return numberingXML.toString({ prettyPrint: true });\r\n  }\r\n\r\n  // eslint-disable-next-line class-methods-use-this\r\n  appendRelationships(xmlFragment, relationships) {\r\n    relationships.forEach(({ relationshipId, type, target, targetMode }) => {\r\n      xmlFragment.import(\r\n        fragment({ defaultNamespace: { ele: namespaces.relationship } })\r\n          .ele('Relationship')\r\n          .att('Id', `rId${relationshipId}`)\r\n          .att('Type', type)\r\n          .att('Target', target)\r\n          .att('TargetMode', targetMode)\r\n          .up()\r\n      );\r\n    });\r\n  }\r\n\r\n  generateRelsXML() {\r\n    const relationshipXMLStrings = this.relationships.map(({ fileName, rels }) => {\r\n      const xmlFragment = create(\r\n        { encoding: 'UTF-8', standalone: true },\r\n        fileName === documentFileName ? documentRelsXMLString : genericRelsXMLString\r\n      );\r\n      this.appendRelationships(xmlFragment.root(), rels);\r\n\r\n      return { fileName, xmlString: xmlFragment.toString({ prettyPrint: true }) };\r\n    });\r\n    return relationshipXMLStrings;\r\n  }\r\n\r\n  createNumbering(type, properties) {\r\n    this.lastNumberingId += 1;\r\n    this.numberingObjects.push({ numberingId: this.lastNumberingId, type, properties });\r\n\r\n    return this.lastNumberingId;\r\n  }\r\n\r\n  createMediaFile(base64String) {\r\n    // eslint-disable-next-line no-useless-escape\r\n    const matches = base64String.match(/^data:([A-Za-z-+\\/]+);base64,(.+)$/);\r\n    if (matches.length !== 3) {\r\n      throw new Error('Invalid base64 string');\r\n    }\r\n\r\n    const base64FileContent = matches[2];\r\n    // matches array contains file type in base64 format - image/jpeg and base64 stringified data\r\n    const fileExtension =\r\n      matches[1].match(/\\/(.*?)$/)[1] === 'octet-stream' ? 'png' : matches[1].match(/\\/(.*?)$/)[1];\r\n\r\n    const fileNameWithExtension = `image-${nanoid()}.${fileExtension}`;\r\n\r\n    this.lastMediaId += 1;\r\n\r\n    return { id: this.lastMediaId, fileContent: base64FileContent, fileNameWithExtension };\r\n  }\r\n\r\n  createDocumentRelationships(fileName = 'document', type, target, targetMode = 'External') {\r\n    debugger;\r\n    let relationshipObject = this.relationships.find(\r\n      (relationship) => relationship.fileName === fileName\r\n    );\r\n    let lastRelsId = 1;\r\n    if (relationshipObject) {\r\n      lastRelsId = relationshipObject.lastRelsId + 1;\r\n      relationshipObject.lastRelsId = lastRelsId;\r\n    } else {\r\n      relationshipObject = { fileName, lastRelsId, rels: [] };\r\n      this.relationships.push(relationshipObject);\r\n    }\r\n    let relationshipType;\r\n    switch (type) {\r\n      case hyperlinkType:\r\n        relationshipType = namespaces.hyperlinks;\r\n        break;\r\n      case imageType:\r\n        relationshipType = namespaces.images;\r\n        break;\r\n      case headerFileType:\r\n        relationshipType = namespaces.headers;\r\n        break;\r\n      case footerFileType:\r\n        relationshipType = namespaces.footers;\r\n        break;\r\n      case themeFileType:\r\n        relationshipType = namespaces.themes;\r\n        break;\r\n    }\r\n\r\n    relationshipObject.rels.push({\r\n      relationshipId: lastRelsId,\r\n      type: relationshipType,\r\n      target,\r\n      targetMode,\r\n    });\r\n\r\n    console.log(fileName)\r\n    console.log(relationshipObject.rels)\r\n    return lastRelsId;\r\n  }\r\n\r\n  generateHeaderXML(vTree) {\r\n    return this.generateSectionXML(vTree, 'header');\r\n  }\r\n\r\n  generateFooterXML(vTree) {\r\n    return this.generateSectionXML(vTree, 'footer');\r\n  }\r\n}\r\n\r\n"]}

package/esm2020/lib/shared/config/word/helpers/render-document-file.mjs

@@ -0,0 +1,154 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-case-declarations */
+import { fragment } from 'xmlbuilder2';
+import VNode from 'virtual-dom/vnode/vnode';
+import VText from 'virtual-dom/vnode/vtext';
+import isVNode from 'virtual-dom/vnode/is-vnode';
+import isVText from 'virtual-dom/vnode/is-vtext';
+// eslint-disable-next-line import/no-named-default
+import { default as HTMLToVDOM } from 'html-to-vdom';
+import escape from 'escape-html';
+// FIXME: remove the cyclic dependency
+// eslint-disable-next-line import/no-cycle
+import * as xmlBuilder from './xml-builder';
+import namespaces from '../namespaces';
+import { vNodeHasChildren } from '../utils/vnode';
+const convertHTML = HTMLToVDOM({
+    VNode,
+    VText,
+});
+async function findXMLEquivalent(docxDocumentInstance, vNode, xmlFragment) {
+    if (vNode.tagName === 'div' &&
+        (vNode.properties.attributes.class === 'page-break' ||
+            (vNode.properties.style && vNode.properties.style['page-break-after']))) {
+        const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })
+            .ele('@w', 'p')
+            .ele('@w', 'r')
+            .ele('@w', 'br')
+            .att('@w', 'type', 'page')
+            .up()
+            .up()
+            .up();
+        xmlFragment.import(paragraphFragment);
+        return;
+    }
+    switch (vNode.tagName) {
+        case 'h1':
+        case 'h2':
+        case 'h3':
+        case 'h4':
+        case 'h5':
+        case 'h6':
+            const headingFragment = await xmlBuilder.buildParagraph(vNode, {
+                paragraphStyle: `Heading${vNode.tagName[1]}`,
+            }, docxDocumentInstance);
+            xmlFragment.import(headingFragment);
+            return;
+        case 'span':
+        case 'strong':
+        case 'b':
+        case 'em':
+        case 'i':
+        case 'u':
+        case 'ins':
+        case 'strike':
+        case 'del':
+        case 's':
+        case 'sub':
+        case 'sup':
+        case 'mark':
+        case 'p':
+        case 'a':
+        case 'blockquote':
+        case 'code':
+        case 'pre':
+            const paragraphFragment = await xmlBuilder.buildParagraph(vNode, {}, docxDocumentInstance);
+            xmlFragment.import(paragraphFragment);
+            return;
+        case 'figure':
+            if (vNodeHasChildren(vNode)) {
+                // eslint-disable-next-line no-plusplus
+                for (let index = 0; index < vNode.children.length; index++) {
+                    const childVNode = vNode.children[index];
+                    if (childVNode.tagName === 'table') {
+                        const tableFragment = await xmlBuilder.buildTable(childVNode, {
+                            maximumWidth: docxDocumentInstance.availableDocumentSpace,
+                            rowCantSplit: docxDocumentInstance.tableRowCantSplit,
+                        }, docxDocumentInstance);
+                        xmlFragment.import(tableFragment);
+                        // Adding empty paragraph for space after table
+                        const emptyParagraphFragment = await xmlBuilder.buildParagraph(null, {});
+                        xmlFragment.import(emptyParagraphFragment);
+                    }
+                    else if (childVNode.tagName === 'img') {
+                        const imageFragment = await xmlBuilder.buildImage(docxDocumentInstance, childVNode);
+                        if (imageFragment) {
+                            xmlFragment.import(imageFragment);
+                        }
+                    }
+                }
+            }
+            return;
+        case 'table':
+            const tableFragment = await xmlBuilder.buildTable(vNode, {
+                maximumWidth: docxDocumentInstance.availableDocumentSpace,
+                rowCantSplit: docxDocumentInstance.tableRowCantSplit,
+            }, docxDocumentInstance);
+            xmlFragment.import(tableFragment);
+            // Adding empty paragraph for space after table
+            const emptyParagraphFragment = await xmlBuilder.buildParagraph(null, {});
+            xmlFragment.import(emptyParagraphFragment);
+            return;
+        case 'ol':
+        case 'ul':
+            await xmlBuilder.buildList(vNode, docxDocumentInstance, xmlFragment);
+            return;
+        case 'img':
+            const imageFragment = await xmlBuilder.buildImage(docxDocumentInstance, vNode);
+            if (imageFragment) {
+                xmlFragment.import(imageFragment);
+            }
+            return;
+        case 'br':
+            const linebreakFragment = await xmlBuilder.buildParagraph(null, {});
+            xmlFragment.import(linebreakFragment);
+            return;
+    }
+    if (vNodeHasChildren(vNode)) {
+        // eslint-disable-next-line no-plusplus
+        for (let index = 0; index < vNode.children.length; index++) {
+            const childVNode = vNode.children[index];
+            // eslint-disable-next-line no-use-before-define
+            await convertVTreeToXML(docxDocumentInstance, childVNode, xmlFragment);
+        }
+    }
+}
+// eslint-disable-next-line consistent-return
+export async function convertVTreeToXML(docxDocumentInstance, vTree, xmlFragment) {
+    if (!vTree) {
+        // eslint-disable-next-line no-useless-return
+        return '';
+    }
+    if (Array.isArray(vTree) && vTree.length) {
+        // eslint-disable-next-line no-plusplus
+        for (let index = 0; index < vTree.length; index++) {
+            const vNode = vTree[index];
+            await convertVTreeToXML(docxDocumentInstance, vNode, xmlFragment);
+        }
+    }
+    else if (isVNode(vTree)) {
+        await findXMLEquivalent(docxDocumentInstance, vTree, xmlFragment);
+    }
+    else if (isVText(vTree)) {
+        xmlBuilder.buildTextElement(xmlFragment, escape(String(vTree.text)));
+    }
+    return xmlFragment;
+}
+async function renderDocumentFile(docxDocumentInstance) {
+    const vTree = convertHTML(docxDocumentInstance.htmlString);
+    const xmlFragment = fragment({ namespaceAlias: { w: namespaces.w } });
+    const populatedXmlFragment = await convertVTreeToXML(docxDocumentInstance, vTree, xmlFragment);
+    return populatedXmlFragment;
+}
+export { renderDocumentFile };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render-document-file.js","sourceRoot":"","sources":["../../../../../../../../projects/bbsf-utilities/src/lib/shared/config/word/helpers/render-document-file.js"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-await-in-loop */\r\n/* eslint-disable no-case-declarations */\r\nimport { fragment } from 'xmlbuilder2';\r\nimport VNode from 'virtual-dom/vnode/vnode';\r\nimport VText from 'virtual-dom/vnode/vtext';\r\nimport isVNode from 'virtual-dom/vnode/is-vnode';\r\nimport isVText from 'virtual-dom/vnode/is-vtext';\r\n// eslint-disable-next-line import/no-named-default\r\nimport { default as HTMLToVDOM } from 'html-to-vdom';\r\nimport escape from 'escape-html';\r\n\r\n// FIXME: remove the cyclic dependency\r\n// eslint-disable-next-line import/no-cycle\r\nimport * as xmlBuilder from './xml-builder';\r\nimport namespaces from '../namespaces';\r\nimport { vNodeHasChildren } from '../utils/vnode';\r\n\r\nconst convertHTML = HTMLToVDOM({\r\n  VNode,\r\n  VText,\r\n});\r\n\r\nasync function findXMLEquivalent(docxDocumentInstance, vNode, xmlFragment) {\r\n  if (\r\n    vNode.tagName === 'div' &&\r\n    (vNode.properties.attributes.class === 'page-break' ||\r\n      (vNode.properties.style && vNode.properties.style['page-break-after']))\r\n  ) {\r\n    const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })\r\n      .ele('@w', 'p')\r\n      .ele('@w', 'r')\r\n      .ele('@w', 'br')\r\n      .att('@w', 'type', 'page')\r\n      .up()\r\n      .up()\r\n      .up();\r\n\r\n    xmlFragment.import(paragraphFragment);\r\n    return;\r\n  }\r\n\r\n  switch (vNode.tagName) {\r\n    case 'h1':\r\n    case 'h2':\r\n    case 'h3':\r\n    case 'h4':\r\n    case 'h5':\r\n    case 'h6':\r\n      const headingFragment = await xmlBuilder.buildParagraph(\r\n        vNode,\r\n        {\r\n          paragraphStyle: `Heading${vNode.tagName[1]}`,\r\n        },\r\n        docxDocumentInstance\r\n      );\r\n      xmlFragment.import(headingFragment);\r\n      return;\r\n    case 'span':\r\n    case 'strong':\r\n    case 'b':\r\n    case 'em':\r\n    case 'i':\r\n    case 'u':\r\n    case 'ins':\r\n    case 'strike':\r\n    case 'del':\r\n    case 's':\r\n    case 'sub':\r\n    case 'sup':\r\n    case 'mark':\r\n    case 'p':\r\n    case 'a':\r\n    case 'blockquote':\r\n    case 'code':\r\n    case 'pre':\r\n      const paragraphFragment = await xmlBuilder.buildParagraph(vNode, {}, docxDocumentInstance);\r\n      xmlFragment.import(paragraphFragment);\r\n      return;\r\n    case 'figure':\r\n      if (vNodeHasChildren(vNode)) {\r\n        // eslint-disable-next-line no-plusplus\r\n        for (let index = 0; index < vNode.children.length; index++) {\r\n          const childVNode = vNode.children[index];\r\n          if (childVNode.tagName === 'table') {\r\n            const tableFragment = await xmlBuilder.buildTable(\r\n              childVNode,\r\n              {\r\n                maximumWidth: docxDocumentInstance.availableDocumentSpace,\r\n                rowCantSplit: docxDocumentInstance.tableRowCantSplit,\r\n              },\r\n              docxDocumentInstance\r\n            );\r\n            xmlFragment.import(tableFragment);\r\n            // Adding empty paragraph for space after table\r\n            const emptyParagraphFragment = await xmlBuilder.buildParagraph(null, {});\r\n            xmlFragment.import(emptyParagraphFragment);\r\n          } else if (childVNode.tagName === 'img') {\r\n            const imageFragment = await xmlBuilder.buildImage(docxDocumentInstance, childVNode);\r\n            if (imageFragment) {\r\n              xmlFragment.import(imageFragment);\r\n            }\r\n          }\r\n        }\r\n      }\r\n      return;\r\n    case 'table':\r\n      const tableFragment = await xmlBuilder.buildTable(\r\n        vNode,\r\n        {\r\n          maximumWidth: docxDocumentInstance.availableDocumentSpace,\r\n          rowCantSplit: docxDocumentInstance.tableRowCantSplit,\r\n        },\r\n        docxDocumentInstance\r\n      );\r\n      xmlFragment.import(tableFragment);\r\n      // Adding empty paragraph for space after table\r\n      const emptyParagraphFragment = await xmlBuilder.buildParagraph(null, {});\r\n      xmlFragment.import(emptyParagraphFragment);\r\n      return;\r\n    case 'ol':\r\n    case 'ul':\r\n      await xmlBuilder.buildList(vNode, docxDocumentInstance, xmlFragment);\r\n      return;\r\n    case 'img':\r\n      const imageFragment = await xmlBuilder.buildImage(docxDocumentInstance, vNode);\r\n      if (imageFragment) {\r\n        xmlFragment.import(imageFragment);\r\n      }\r\n      return;\r\n    case 'br':\r\n      const linebreakFragment = await xmlBuilder.buildParagraph(null, {});\r\n      xmlFragment.import(linebreakFragment);\r\n      return;\r\n  }\r\n  if (vNodeHasChildren(vNode)) {\r\n    // eslint-disable-next-line no-plusplus\r\n    for (let index = 0; index < vNode.children.length; index++) {\r\n      const childVNode = vNode.children[index];\r\n      // eslint-disable-next-line no-use-before-define\r\n      await convertVTreeToXML(docxDocumentInstance, childVNode, xmlFragment);\r\n    }\r\n  }\r\n}\r\n\r\n// eslint-disable-next-line consistent-return\r\nexport async function convertVTreeToXML(docxDocumentInstance, vTree, xmlFragment) {\r\n  if (!vTree) {\r\n    // eslint-disable-next-line no-useless-return\r\n    return '';\r\n  }\r\n  if (Array.isArray(vTree) && vTree.length) {\r\n    // eslint-disable-next-line no-plusplus\r\n    for (let index = 0; index < vTree.length; index++) {\r\n      const vNode = vTree[index];\r\n      await convertVTreeToXML(docxDocumentInstance, vNode, xmlFragment);\r\n    }\r\n  } else if (isVNode(vTree)) {\r\n    await findXMLEquivalent(docxDocumentInstance, vTree, xmlFragment);\r\n  } else if (isVText(vTree)) {\r\n    xmlBuilder.buildTextElement(xmlFragment, escape(String(vTree.text)));\r\n  }\r\n  return xmlFragment;\r\n}\r\n\r\nasync function renderDocumentFile(docxDocumentInstance) {\r\n  const vTree = convertHTML(docxDocumentInstance.htmlString);\r\n\r\n  const xmlFragment = fragment({ namespaceAlias: { w: namespaces.w } });\r\n\r\n  const populatedXmlFragment = await convertVTreeToXML(docxDocumentInstance, vTree, xmlFragment);\r\n\r\n  return populatedXmlFragment;\r\n}\r\n\r\nexport { renderDocumentFile };\r\n"]}