@contrail/document-generation 1.0.15 → 1.0.16

package/lib/components/component-generator.d.ts

@@ -0,0 +1,11 @@
+import { DocumentElement } from "@contrail/documents";
+import { ComponentPropertyTemplate, ComponentTemplate } from "../interfaces";
+export declare class ComponentGenerator {
+    static generateComponent(data: any, options: DocumentElement, template: ComponentTemplate): any;
+    static generatedModelBindings(data: any): {
+        item: string;
+        projectItem: string;
+        viewable: string;
+    };
+    static generateComponentFromPropertyTemplate(data: any, options: DocumentElement, template: ComponentPropertyTemplate): DocumentElement;
+}

package/lib/components/component-generator.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentGenerator = void 0;
+const documents_1 = require("@contrail/documents");
+const nanoid_1 = require("nanoid");
+const util_1 = require("@contrail/util");
+const document_property_util_1 = require("../util/document-property-util");
+class ComponentGenerator {
+    static generateComponent(data, options, template) {
+        let component;
+        if (template.propertyTemplate) {
+            component = this.generateComponentFromPropertyTemplate(data, options, template.propertyTemplate);
+        }
+        else {
+            throw Error("No component property template defined");
+        }
+        return component;
+    }
+    static generatedModelBindings(data) {
+        return {
+            item: `item:${data.item.id}`,
+            projectItem: `project-item:${data.projectItem.id}`,
+            viewable: `item:${data.item.id}`,
+        };
+    }
+    static generateComponentFromPropertyTemplate(data, options, template) {
+        var _a;
+        let componentElement = documents_1.DocumentElementFactory.initNewElement('component');
+        if (options) {
+            componentElement = Object.assign(componentElement, options);
+        }
+        let yPosition = 0;
+        const imageDimension = template.imageDimension || {};
+        const imageHeight = imageDimension.height || imageDimension.width || 125;
+        const imageWidth = imageDimension.width || 125;
+        const imageUrl = util_1.ObjectUtil.getByPath(data, `viewable.mediumViewableDownloadUrl`);
+        const elements = [{
+                type: "image",
+                size: { width: imageWidth, height: imageHeight },
+                propertyBindings: { url: 'viewable.mediumViewableDownloadUrl' },
+                url: imageUrl,
+            }];
+        yPosition += imageHeight;
+        const textOptions = {
+            style: {
+                text: {
+                    align: template.textHorizontalAlignment
+                }
+            },
+            size: {
+                width: imageWidth
+            }
+        };
+        elements.push(...document_property_util_1.DocumentPropertyUtil.generatePropertyTextElements(data, template.properties, textOptions, { y: yPosition }, true));
+        const modelBindings = this.generatedModelBindings(data);
+        componentElement.elements = elements;
+        componentElement.modelBindings = modelBindings;
+        if (((_a = componentElement === null || componentElement === void 0 ? void 0 : componentElement.elements) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            componentElement.elements = componentElement.elements.map((e) => {
+                e.id = (0, nanoid_1.nanoid)(16);
+                return e;
+            });
+        }
+        return componentElement;
+    }
+}
+exports.ComponentGenerator = ComponentGenerator;

package/lib/components/component-grid-generator.d.ts

@@ -0,0 +1,7 @@
+import { DocumentElement, PositionDefinition, SizeDefinition } from "@contrail/documents";
+import { ComponentGridTemplate } from "../interfaces";
+export declare class ComponentGridGenerator {
+    static generateComponentGrid(data: any, startingPosition: PositionDefinition, template: ComponentGridTemplate, idealSize: SizeDefinition): Array<DocumentElement>;
+    private static getComponentSize;
+    private static adjustComponentTemplate;
+}

package/lib/components/component-grid-generator.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentGridGenerator = void 0;
+const util_1 = require("@contrail/util");
+const component_generator_1 = require("./component-generator");
+const component_util_1 = require("./component-util");
+class ComponentGridGenerator {
+    static generateComponentGrid(data, startingPosition = { x: 0, y: 0 }, template, idealSize) {
+        if (!data) {
+            console.warn("WARN: data null in generateComponentGrid");
+            return [];
+        }
+        if (!template) {
+            console.warn("WARN: template null in generateComponentGrid");
+            return [];
+        }
+        if (!template.componentTemplate) {
+            console.warn("WARN: component template is null generateComponentGrid");
+            return [];
+        }
+        const elements = [];
+        let dataIndex = 0;
+        let gridTemplate = template;
+        const optimizeTemplate = true;
+        if (optimizeTemplate) {
+            gridTemplate = this.adjustComponentTemplate(data, idealSize, template);
+        }
+        const componentTemplate = gridTemplate.componentTemplate;
+        const componentPosition = util_1.ObjectUtil.cloneDeep(startingPosition);
+        const componentSize = this.getComponentSize(data, gridTemplate);
+        if (componentSize.width < 120) {
+            componentSize.width = 120;
+        }
+        const componentPadding = gridTemplate.componentPadding || 20;
+        componentPosition.x += componentPadding;
+        componentPosition.y += componentPadding;
+        for (let row = 0; row < gridTemplate.gridDimensions.rows; row++) {
+            for (let col = 0; col < gridTemplate.gridDimensions.cols; col++) {
+                if (dataIndex >= data.length) {
+                    continue;
+                }
+                let dataObj = data[dataIndex];
+                dataObj.viewable = dataObj.item;
+                const position = util_1.ObjectUtil.cloneDeep(componentPosition);
+                let component = component_generator_1.ComponentGenerator.generateComponent(dataObj, { position }, componentTemplate);
+                elements.push(component);
+                dataIndex++;
+                componentPosition.x += componentSize.width + (componentPadding * 2);
+            }
+            componentPosition.y += componentSize.height + (componentPadding * 2);
+            componentPosition.x = startingPosition.x + componentPadding;
+        }
+        return elements;
+    }
+    static getComponentSize(data, template) {
+        if (!(data === null || data === void 0 ? void 0 : data.length)) {
+            return null;
+        }
+        const firstData = data[0];
+        const element = component_generator_1.ComponentGenerator.generateComponent(firstData, {}, template.componentTemplate);
+        return component_util_1.ComponentUtil.getComponentSize(element);
+    }
+    static adjustComponentTemplate(data, idealSize, template) {
+        const componentSize = this.getComponentSize(data, template);
+        const adjustedTemplate = util_1.ObjectUtil.cloneDeep(template);
+        const requiredSize = {
+            width: componentSize.width * template.gridDimensions.cols + ((template.gridDimensions.cols * 2) * template.componentPadding || 20),
+            height: componentSize.height * template.gridDimensions.rows + ((template.gridDimensions.rows * 2) * template.componentPadding || 20)
+        };
+        const requiredHeightAdjustment = (idealSize.height - requiredSize.height) / template.gridDimensions.rows;
+        const requiredWidthAdjustment = (idealSize.width - requiredSize.width) / template.gridDimensions.cols;
+        if (requiredHeightAdjustment < 0 && requiredHeightAdjustment < requiredWidthAdjustment) {
+            adjustedTemplate.componentTemplate.propertyTemplate.imageDimension.width += requiredHeightAdjustment;
+        }
+        if (requiredWidthAdjustment < 0 && requiredWidthAdjustment < requiredHeightAdjustment) {
+            adjustedTemplate.componentTemplate.propertyTemplate.imageDimension.width += requiredWidthAdjustment;
+        }
+        return adjustedTemplate;
+    }
+}
+exports.ComponentGridGenerator = ComponentGridGenerator;

package/lib/components/component-util.d.ts

@@ -0,0 +1,4 @@
+import { DocumentElement, SizeDefinition } from "@contrail/documents";
+export declare class ComponentUtil {
+    static getComponentSize(element: DocumentElement): SizeDefinition;
+}

package/lib/components/component-util.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentUtil = void 0;
+class ComponentUtil {
+    static getComponentSize(element) {
+        var _a, _b, _c, _d, _e;
+        const sizeDefinition = {
+            width: 0,
+            height: 0,
+        };
+        const imageElement = ((_a = element.elements) === null || _a === void 0 ? void 0 : _a.find(el => el.type === 'image')) || {};
+        sizeDefinition.width = (_b = imageElement.size) === null || _b === void 0 ? void 0 : _b.width;
+        const LINE_PADDING = 8;
+        const textElements = (_c = element.elements) === null || _c === void 0 ? void 0 : _c.filter(el => el.type === 'text');
+        let textHeight = 0;
+        textElements.forEach(el => {
+            var _a, _b;
+            let fontSize = ((_b = (_a = el.style) === null || _a === void 0 ? void 0 : _a.font) === null || _b === void 0 ? void 0 : _b.size) || 12;
+            textHeight += fontSize + LINE_PADDING;
+        });
+        const imageHeight = (((_d = imageElement.size) === null || _d === void 0 ? void 0 : _d.height) || ((_e = imageElement.size) === null || _e === void 0 ? void 0 : _e.width) || 150);
+        sizeDefinition.height = imageHeight + textHeight;
+        return sizeDefinition;
+    }
+}
+exports.ComponentUtil = ComponentUtil;

package/lib/document-generator.d.ts

@@ -0,0 +1,11 @@
+import { DocumentElement, PositionDefinition } from "@contrail/documents";
+import { DocumentGenerationOptions, DocumentTemplate } from "./interfaces";
+import { DataGroup } from "@contrail/data-grouping";
+export declare class DocumentGenerator {
+    constructor();
+    static generateDocumentElements(options: DocumentGenerationOptions): Array<DocumentElement>;
+    static generateGroup(group: DataGroup, template: any, startingPosition: any, totalDepth: any, currentDepth: any): any[];
+    static getGroupSpan(group: DataGroup, totalDepth: any, currentDepth: any): number;
+    static generateFrameGroup(dataGroup: DataGroup, template: DocumentTemplate, position: PositionDefinition): Array<DocumentElement>;
+    static generateGroupHeading(dataGroup: DataGroup, template: DocumentTemplate, position: PositionDefinition, span: any): any[];
+}

package/lib/document-generator.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentGenerator = void 0;
+const documents_1 = require("@contrail/documents");
+const interfaces_1 = require("./interfaces");
+const util_1 = require("@contrail/util");
+const frame_generator_1 = require("./frame-generator");
+class DocumentGenerator {
+    constructor() {
+    }
+    static generateDocumentElements(options) {
+        const elements = [];
+        const structure = options.data.dataGroup;
+        const template = options.documentTemplateDefinition;
+        console.log("generateDocumentElements: ", structure.depth, structure.groupingProperties.length);
+        let position = options.startingCoordinates || { x: 0, y: 0 };
+        const group = structure.rootGroup;
+        elements.push(...this.generateGroup(group, template, position, structure.depth, 0));
+        return elements;
+    }
+    static generateGroup(group, template, startingPosition, totalDepth, currentDepth) {
+        const elements = [];
+        let position = util_1.ObjectUtil.cloneDeep(startingPosition);
+        if (currentDepth > 0) {
+            let groupHeaderPosition = { x: position.x + template.framePadding, y: position.y + template.framePadding };
+            let span = this.getGroupSpan(group, totalDepth, currentDepth);
+            elements.push(...this.generateGroupHeading(group, template, groupHeaderPosition, span));
+            let groupHeaderDimensions = { width: template.frameSize.width, height: template.frameGroupHeaderTemplate.size.height };
+            if (template.frameOrientation === interfaces_1.Orientation.HORIZONTAL) {
+                position = { x: position.x + groupHeaderDimensions.height + template.framePadding, y: position.y };
+            }
+            else {
+                position = { x: position.x, y: position.y + groupHeaderDimensions.height + template.framePadding };
+            }
+        }
+        if (currentDepth === totalDepth) {
+            elements.push(...this.generateFrameGroup(group, template, position));
+        }
+        if (currentDepth < totalDepth) {
+            for (let subGroup of group.subGroups) {
+                elements.push(...this.generateGroup(subGroup, template, position, totalDepth, currentDepth + 1));
+                let frameSetMultiple = this.getGroupSpan(subGroup, totalDepth, currentDepth + 1);
+                let paddingMultiple = 1;
+                if (currentDepth < totalDepth) {
+                    paddingMultiple = frameSetMultiple;
+                }
+                if (template.frameOrientation === interfaces_1.Orientation.HORIZONTAL) {
+                    position = { x: position.x, y: position.y + (template.frameSize.height * frameSetMultiple) + (template.framePadding * paddingMultiple) };
+                }
+                else {
+                    position = { x: position.x + (template.frameSize.width * frameSetMultiple) + (template.framePadding * paddingMultiple), y: position.y };
+                }
+            }
+        }
+        return elements;
+    }
+    static getGroupSpan(group, totalDepth, currentDepth) {
+        let span = 1;
+        if (currentDepth !== totalDepth) {
+            span = group.subGroups.length;
+        }
+        return span;
+    }
+    static generateFrameGroup(dataGroup, template, position) {
+        const elements = [];
+        let framePosition = { x: position.x + template.framePadding, y: position.y + template.framePadding };
+        for (let group of dataGroup.subGroups) {
+            elements.push(...frame_generator_1.FrameGenerator.generateFrameForDataGroup(group, framePosition, template));
+            if (template.frameOrientation === interfaces_1.Orientation.HORIZONTAL) {
+                framePosition.x = framePosition.x + template.frameSize.width + template.framePadding || 10;
+            }
+            else {
+                framePosition.y = framePosition.y + template.frameSize.height + template.framePadding || 10;
+            }
+        }
+        return elements;
+    }
+    static generateGroupHeading(dataGroup, template, position, span) {
+        const elements = [];
+        const heading = documents_1.DocumentElementFactory.createTextElement("Placeholder", {});
+        heading.style = { border: { width: 1, color: "rgba(0,0,0,0)" }, color: "#000000", backgroundColor: template.frameGroupHeaderTemplate.style.backgroundColor || 'black' };
+        heading.text = `<p><span style=\"font-size: ${template.frameGroupHeaderTemplate.style.font.size}pt;\"><strong><span style=\"color: ${template.frameGroupHeaderTemplate.style.color};\">${dataGroup.name}</span></strong></span></p>`;
+        heading.position = position;
+        if (template.frameOrientation === interfaces_1.Orientation.HORIZONTAL) {
+            let sizeDim = template.frameSize.height * span;
+            if (span > 1) {
+                sizeDim += (span - 1) * template.framePadding;
+            }
+            heading.size = { width: sizeDim, height: template.frameGroupHeaderTemplate.size.height };
+            heading.rotate = { angle: 270 };
+            heading.position.x = heading.position.x - (heading.size.width / 2) + (heading.size.height / 2);
+            heading.position.y = heading.position.y + (heading.size.width / 2) - (heading.size.height / 2);
+        }
+        else {
+            let sizeDim = template.frameSize.width * span;
+            if (span > 1) {
+                sizeDim += (span - 1) * template.framePadding;
+            }
+            heading.rotate = { angle: 0 };
+            heading.size = { width: sizeDim, height: template.frameGroupHeaderTemplate.size.height };
+        }
+        elements.push(heading);
+        return elements;
+    }
+}
+exports.DocumentGenerator = DocumentGenerator;

package/lib/frame-generator.d.ts

@@ -0,0 +1,9 @@
+import { DocumentElement, PositionDefinition, SizeDefinition } from "@contrail/documents";
+import { DataGroup } from "@contrail/data-grouping";
+import { DocumentTemplate } from "./interfaces";
+export declare class FrameGenerator {
+    static generateFrameForDataGroup(dataGroup: DataGroup, framePosition: PositionDefinition, template: DocumentTemplate): any[];
+    static generateFrameHeaderForDataGroup(dataGroup: DataGroup, position: PositionDefinition, template: DocumentTemplate, headerSize: SizeDefinition): DocumentElement[];
+    static generateFrameInfoPanelForDataGroup(dataGroup: DataGroup, position: PositionDefinition, template: DocumentTemplate, panelSize: SizeDefinition): DocumentElement[];
+    static generateFrame(options: DocumentElement): DocumentElement;
+}

package/lib/frame-generator.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameGenerator = void 0;
+const documents_1 = require("@contrail/documents");
+const component_grid_generator_1 = require("./components/component-grid-generator");
+const util_1 = require("@contrail/util");
+const document_util_1 = require("./util/document-util");
+const info_panel_generator_1 = require("./info-panel/info-panel-generator");
+class FrameGenerator {
+    static generateFrameForDataGroup(dataGroup, framePosition, template) {
+        var _a, _b;
+        const elements = [];
+        const frame = this.generateFrame({
+            position: util_1.ObjectUtil.cloneDeep(framePosition),
+            size: template.frameSize,
+            style: { backgroundColor: "#fff", border: { width: 1, color: "#616161" } }
+        });
+        frame.name = dataGroup.name;
+        const FRAME_PADDING = 20;
+        const headerPosition = util_1.ObjectUtil.cloneDeep(framePosition);
+        headerPosition.y = headerPosition.y + FRAME_PADDING;
+        headerPosition.x = headerPosition.x + FRAME_PADDING;
+        const panelPosition = util_1.ObjectUtil.cloneDeep(framePosition);
+        panelPosition.y = panelPosition.y + FRAME_PADDING;
+        panelPosition.x = panelPosition.x + FRAME_PADDING;
+        let frameHeaderDimensions = { height: 0, width: 0 };
+        let framePanelDimensions = { height: 0, width: 0 };
+        let hasPanel = false;
+        let hasHeader = false;
+        elements.push(util_1.ObjectUtil.cloneDeep(frame));
+        if (template.frameHeaderTemplate) {
+            hasHeader = true;
+            frameHeaderDimensions = { height: 50, width: template.frameSize.width - 50 };
+            elements.push(...this.generateFrameHeaderForDataGroup(dataGroup, headerPosition, template, frameHeaderDimensions));
+        }
+        if (template.frameInfoPanelTemplate) {
+            hasPanel = true;
+            framePanelDimensions = { width: ((_b = (_a = template.frameInfoPanelTemplate.panelDocumentTemplate) === null || _a === void 0 ? void 0 : _a.size) === null || _b === void 0 ? void 0 : _b.width) || 300 };
+            framePanelDimensions.height = template.frameSize.height - (2 * FRAME_PADDING);
+            elements.push(...this.generateFrameInfoPanelForDataGroup(dataGroup, panelPosition, template, framePanelDimensions));
+        }
+        const GRID_MARGIN = 20;
+        let gridPosition = util_1.ObjectUtil.cloneDeep(framePosition);
+        if (hasHeader) {
+            gridPosition = util_1.ObjectUtil.cloneDeep(headerPosition);
+            gridPosition.y = gridPosition.y + frameHeaderDimensions.height + GRID_MARGIN;
+        }
+        if (hasPanel) {
+            gridPosition = util_1.ObjectUtil.cloneDeep(panelPosition);
+            gridPosition.x = gridPosition.x + framePanelDimensions.width + GRID_MARGIN;
+        }
+        const relativeGridPosition = document_util_1.DocumentUtil.getRelativePosition(framePosition, gridPosition);
+        const frameSize = template.frameSize;
+        const idealGridSize = {
+            width: frameSize.width - relativeGridPosition.x - FRAME_PADDING,
+            height: frameSize.height - relativeGridPosition.y - FRAME_PADDING
+        };
+        elements.push(...component_grid_generator_1.ComponentGridGenerator.generateComponentGrid(dataGroup.data, gridPosition, template.componentGridTemplate, idealGridSize));
+        return elements;
+    }
+    static generateFrameHeaderForDataGroup(dataGroup, position, template, headerSize) {
+        const heading = documents_1.DocumentElementFactory.createTextElement(dataGroup.name, template.frameHeaderTemplate);
+        heading.style = { border: { width: 1, color: "rgba(0,0,0,0)" }, color: "#000000", backgroundColor: template.frameHeaderTemplate.style.backgroundColor || 'black' };
+        heading.text = `<p><span style=\"font-size: ${template.frameHeaderTemplate.style.font.size}pt;\"><strong><span style=\"color: ${template.frameHeaderTemplate.style.color};\">${dataGroup.name}</span></strong></span></p>`;
+        heading.size = util_1.ObjectUtil.cloneDeep(headerSize);
+        heading.position = util_1.ObjectUtil.cloneDeep(position);
+        return [heading];
+    }
+    static generateFrameInfoPanelForDataGroup(dataGroup, position, template, panelSize) {
+        return info_panel_generator_1.InfoPanelGenerator.generatePanelFromTemplate(dataGroup.propertyValues, template.frameInfoPanelTemplate, position, panelSize);
+    }
+    static generateFrame(options) {
+        const frame = documents_1.DocumentElementFactory.createFrameElement(options);
+        return frame;
+    }
+}
+exports.FrameGenerator = FrameGenerator;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './document-generator';
+export * from './interfaces';

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./document-generator"), exports);
+__exportStar(require("./interfaces"), exports);

package/lib/info-panel/info-panel-generator.d.ts

@@ -0,0 +1,5 @@
+import { DocumentElement, PositionDefinition, SizeDefinition } from "@contrail/documents";
+import { FrameInfoPanelTemplate } from "../interfaces";
+export declare class InfoPanelGenerator {
+    static generatePanelFromTemplate(data: any, template: FrameInfoPanelTemplate, position: PositionDefinition, panelSize: SizeDefinition): Array<DocumentElement>;
+}

package/lib/info-panel/info-panel-generator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoPanelGenerator = void 0;
+const documents_1 = require("@contrail/documents");
+const util_1 = require("@contrail/util");
+const document_property_util_1 = require("../util/document-property-util");
+class InfoPanelGenerator {
+    static generatePanelFromTemplate(data, template, position, panelSize) {
+        var _a;
+        if (!template.propertyTemplate) {
+            throw Error("No panel property template defined");
+        }
+        const elements = [];
+        const panel = documents_1.DocumentElementFactory.createShapeElement('rectangle', {});
+        panel.style = ((_a = template.panelDocumentTemplate) === null || _a === void 0 ? void 0 : _a.style) || {};
+        panel.size = util_1.ObjectUtil.cloneDeep(panelSize) || {};
+        panel.position = util_1.ObjectUtil.cloneDeep(position);
+        elements.push(panel);
+        const textOptions = {
+            style: {
+                text: {
+                    align: template.propertyTemplate.textHorizontalAlignment
+                }
+            },
+            size: {
+                width: panelSize.width - 10
+            }
+        };
+        const textElements = document_property_util_1.DocumentPropertyUtil.generatePropertyTextElements(data, template.propertyTemplate.properties, textOptions, { x: panel.position.x, y: panel.position.y }, false);
+        elements.push(...textElements);
+        return elements;
+    }
+}
+exports.InfoPanelGenerator = InfoPanelGenerator;

package/lib/interfaces.d.ts

@@ -0,0 +1,56 @@
+import { DataGroupStructure } from "@contrail/data-grouping";
+import { PositionDefinition, SizeDefinition, DocumentElement, StyleDefinition } from "@contrail/documents";
+import { TypeProperty } from "@contrail/types";
+export declare enum Orientation {
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+export interface DocumentGenerationDataDefinition {
+    dataGroup: DataGroupStructure;
+}
+export interface DocumentGenerationOptions {
+    startingCoordinates: PositionDefinition;
+    data: DocumentGenerationDataDefinition;
+    documentTemplateDefinition: DocumentTemplate;
+}
+export interface DocumentTemplate {
+    frameOrientation: Orientation;
+    frameSize: SizeDefinition;
+    framePadding?: number;
+    frameGroupHeaderTemplate: DocumentElement;
+    frameHeaderTemplate?: DocumentElement;
+    frameInfoPanelTemplate?: FrameInfoPanelTemplate;
+    componentGridTemplate: ComponentGridTemplate;
+}
+export interface FrameInfoPanelTemplate {
+    panelDocumentTemplate: DocumentElement;
+    propertyTemplate: PanelPropertyTemplate;
+}
+export interface PanelPropertyTemplate {
+    textHorizontalAlignment?: 'center' | 'right' | 'left';
+    properties: Array<DocumentPropertyDefinition>;
+}
+export interface ComponentGridTemplate {
+    componentTemplate: ComponentTemplate;
+    componentPadding?: number;
+    gridDimensions: {
+        rows: number;
+        cols: number;
+    };
+}
+export interface ComponentTemplate {
+    propertyTemplate?: ComponentPropertyTemplate;
+}
+export interface ComponentPropertyTemplate {
+    imageDimension?: SizeDefinition;
+    imageLocation?: 'top' | 'right' | 'left' | 'bottom';
+    textHorizontalAlignment?: 'center' | 'right' | 'left';
+    properties: Array<DocumentPropertyDefinition>;
+}
+export interface DocumentPropertyDefinition {
+    style?: StyleDefinition;
+    propertyDefinition: TypeProperty;
+    slug: string;
+    typeRootSlug: string;
+    includeLabel?: boolean;
+}

package/lib/interfaces.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orientation = void 0;
+var Orientation;
+(function (Orientation) {
+    Orientation["HORIZONTAL"] = "horizontal";
+    Orientation["VERTICAL"] = "vertical";
+})(Orientation = exports.Orientation || (exports.Orientation = {}));

package/lib/scripts/test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/scripts/test.js

@@ -0,0 +1,270 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const document_generator_1 = require("../document-generator");
+const interfaces_1 = require("../interfaces");
+const sdk_1 = require("@contrail/sdk");
+const fs = require("fs");
+const nanoid_1 = require("nanoid");
+const data_grouping_1 = require("@contrail/data-grouping");
+function run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const orgSlug = 'converse-prod';
+        yield loginSDK(orgSlug);
+        const assortmentId = 'Z7nTOauGtuuiU9UC';
+        const itemType = yield new sdk_1.Types().getType({ path: 'item' });
+        const projectItemType = yield new sdk_1.Types().getType({ path: 'project-item' });
+        const PROPERTY_COMPONENT_TEMPLATE = {
+            imageDimension: { width: 600 },
+            imageLocation: 'top',
+            textHorizontalAlignment: 'center',
+            properties: [{
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'name'),
+                    typeRootSlug: 'item',
+                    slug: "name",
+                    style: {
+                        font: {
+                            size: 14,
+                            weight: 'bold',
+                        },
+                        color: 'rgba(0,0,0,.5)',
+                    }
+                }, {
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'optionName'),
+                    typeRootSlug: 'item',
+                    slug: "optionName",
+                    style: {
+                        font: {
+                            size: 10,
+                            weight: 'bold',
+                        },
+                        color: 'green',
+                    }
+                }, {
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'category'),
+                    typeRootSlug: 'item',
+                    slug: "category",
+                    includeLabel: true,
+                }, {
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'designTheme'),
+                    typeRootSlug: 'item',
+                    slug: "designTheme",
+                    includeLabel: true,
+                }, {
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'baseStyleNumber'),
+                    typeRootSlug: 'item',
+                    slug: "baseStyleNumber",
+                }]
+        };
+        const PANEL_PROPERTY_TEMPLATE = {
+            properties: [{
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'name'),
+                    typeRootSlug: 'item',
+                    slug: "name",
+                    includeLabel: false,
+                    style: {
+                        font: {
+                            size: 25,
+                            weight: 'bold'
+                        },
+                        color: 'white',
+                    }
+                }, {
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'segment'),
+                    typeRootSlug: 'item',
+                    slug: "segment",
+                    includeLabel: true,
+                    style: {
+                        font: {
+                            size: 14,
+                        },
+                        color: 'white',
+                    }
+                }, {
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'familyName'),
+                    typeRootSlug: 'item',
+                    slug: "familyName",
+                    includeLabel: true,
+                    style: {
+                        font: {
+                            size: 14,
+                        },
+                        color: 'white',
+                    }
+                }, {
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'ageGroup'),
+                    typeRootSlug: 'item',
+                    slug: "ageGroup",
+                    includeLabel: true,
+                    style: {
+                        font: {
+                            size: 14,
+                        },
+                        color: 'white',
+                    }
+                }, {
+                    propertyDefinition: itemType.typeProperties.find(p => p.slug === 'planningLevel1'),
+                    typeRootSlug: 'item',
+                    slug: "planningLevel1",
+                    includeLabel: true,
+                    style: {
+                        font: {
+                            size: 14,
+                        },
+                        color: 'white',
+                    }
+                }]
+        };
+        const documentTemplateDefinition = {
+            frameOrientation: interfaces_1.Orientation.VERTICAL,
+            frameSize: { width: 1200, height: 675 },
+            framePadding: 30,
+            frameGroupHeaderTemplate: {
+                style: {
+                    color: '#ffffff',
+                    font: {
+                        size: 20
+                    },
+                    backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                },
+                size: {
+                    height: 60,
+                }
+            },
+            frameInfoPanelTemplate: {
+                panelDocumentTemplate: {
+                    style: {
+                        color: '#ffffff',
+                        font: {
+                            size: 20
+                        },
+                        backgroundColor: 'rgba(0, 0, 0, 0.8)',
+                        border: {
+                            radius: 4,
+                        }
+                    },
+                    size: {
+                        width: 250,
+                        height: 400,
+                    }
+                },
+                propertyTemplate: PANEL_PROPERTY_TEMPLATE
+            },
+            componentGridTemplate: {
+                gridDimensions: { cols: 4, rows: 2 },
+                componentPadding: 5,
+                componentTemplate: {
+                    propertyTemplate: PROPERTY_COMPONENT_TEMPLATE
+                }
+            }
+        };
+        const groupingProperties = [
+            {
+                property: itemType.typeProperties.find(p => p.slug === 'category'),
+                scope: 'item',
+                sort: sdk_1.SortOrderOptions.ASC,
+                values: null,
+            }, {
+                property: itemType.typeProperties.find(p => p.slug === 'name'),
+                scope: 'item',
+                sort: sdk_1.SortOrderOptions.ASC,
+                values: null,
+            },
+        ];
+        documentTemplateDefinition.componentGridTemplate.componentTemplate.propertyTemplate = PROPERTY_COMPONENT_TEMPLATE;
+        const dataGroup = yield getDataGroupStructure(assortmentId, groupingProperties, documentTemplateDefinition);
+        const params = {
+            startingCoordinates: { x: 500, y: 500 },
+            data: {
+                dataGroup
+            },
+            documentTemplateDefinition,
+        };
+        const elements = document_generator_1.DocumentGenerator.generateDocumentElements(params);
+        const documentId = (0, nanoid_1.nanoid)(16);
+        elements.forEach(el => {
+            el.id = (0, nanoid_1.nanoid)(16);
+        });
+        const document = {
+            size: { width: 1600, height: 900 },
+            elements,
+            id: documentId,
+        };
+        yield uploadAndOpen(orgSlug, document);
+    });
+}
+function loginSDK(orgSlug) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = {
+            email: 'brian@vibeiq.com',
+            password: process.env.CONTRAIL_PW,
+            orgSlug: orgSlug,
+        };
+        yield (0, sdk_1.login)(config);
+    });
+}
+function getAssortmentItems(assortmentId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const assortment = yield new sdk_1.Entities().get({
+            entityName: 'assortment',
+            id: assortmentId,
+            relations: ['assortmentItems', 'assortmentItems.item', 'assortmentItems.projectItem']
+        });
+        let assortmentItems = assortment.assortmentItems;
+        if (assortment.itemsDownloadURL) {
+            const response = yield fetch(assortment.itemsDownloadURL);
+            assortmentItems = yield response.json();
+        }
+        return assortmentItems;
+    });
+}
+function getDataGroupStructure(assortmentId, groupingProperties, template) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const assortmentItems = yield getAssortmentItems(assortmentId);
+        const data = fromAssortmentModelToItemModel(assortmentItems);
+        const leafNodeDataCount = template.componentGridTemplate.gridDimensions.cols * template.componentGridTemplate.gridDimensions.rows;
+        return data_grouping_1.DataGroupGenerator.buildDataGroupStructure(data, groupingProperties, leafNodeDataCount);
+    });
+}
+function fromAssortmentModelToItemModel(data) {
+    const results = [];
+    data.forEach(ai => {
+        results.push({
+            item: ai.item,
+            projectItem: ai.projectItem,
+            viewable: ai.item,
+            assortmentItem: ai,
+        });
+    });
+    return results;
+}
+function uploadAndOpen(orgSlug, document) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let config = (0, sdk_1.getConfig)();
+        var writeStream = fs.createWriteStream("testdocument.json");
+        writeStream.write(JSON.stringify(document));
+        writeStream.end();
+        const file = fs.createReadStream("testdocument.json");
+        const fileEntity = yield new sdk_1.Files().createAndUploadFileFromBuffer(file, 'application/json', 'testdocument.json', null, 300);
+        const domain = "http://preview.vibeiq.com";
+        const authToken = config.apiUserToken;
+        const documentType = 'board';
+        let url = domain +
+            '?url=' + encodeURIComponent(fileEntity.downloadUrl) +
+            '&orgSlug=' + encodeURIComponent(orgSlug) +
+            '&apiToken=' + encodeURIComponent(authToken) +
+            '&documentType=' + encodeURIComponent(documentType);
+        var start = (process.platform == 'darwin' ? 'open' : process.platform == 'win32' ? 'start' : 'xdg-open');
+        const encodedUrl = url.replace(/&/g, '^&');
+        require('child_process').exec(start + ' ' + encodedUrl);
+    });
+}
+run();

package/lib/test-data.d.ts

@@ -0,0 +1,72 @@
+import { DataGroupStructure } from "@contrail/data-grouping";
+import { ComponentGridTemplate, DocumentTemplate } from "./interfaces";
+export declare const TEST_ITEM_MODEL: {
+    item: {
+        id: string;
+        name: string;
+        optionName: string;
+        gender: string;
+        mediumViewableDownloadUrl: string;
+    };
+    projectItem: {
+        id: string;
+        retailPrice: number;
+    };
+    assortmentItem: {
+        id: string;
+        targetVolume: number;
+    };
+};
+export declare const TEST_GROUP: {
+    name: string;
+    data: {
+        item: {
+            id: string;
+            name: string;
+            optionName: string;
+            gender: string;
+            mediumViewableDownloadUrl: string;
+        };
+        projectItem: {
+            id: string;
+            retailPrice: number;
+        };
+        assortmentItem: {
+            id: string;
+            targetVolume: number;
+        };
+    }[];
+    propertyValues: {
+        gender: string;
+    };
+    subGroups: any[];
+};
+export declare const TEST_GROUP_2: {
+    name: string;
+    data: {
+        item: {
+            id: string;
+            name: string;
+            optionName: string;
+            gender: string;
+            mediumViewableDownloadUrl: string;
+        };
+        projectItem: {
+            id: string;
+            retailPrice: number;
+        };
+        assortmentItem: {
+            id: string;
+            targetVolume: number;
+        };
+    }[];
+    propertyValues: {
+        gender: string;
+    };
+    subGroups: any[];
+};
+export declare const TEST_ROOT_GROUP: DataGroupStructure;
+export declare const TEST_TWO_LEVEL_ROOT_GROUP: DataGroupStructure;
+export declare const COMPONENT_GRID_TEMPLATE: ComponentGridTemplate;
+export declare const HORIZONTAL_DOCUMENT_TEMPLATE: DocumentTemplate;
+export declare const VERTICAL_DOCUMENT_TEMPLATE: DocumentTemplate;

package/lib/test-data.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERTICAL_DOCUMENT_TEMPLATE = exports.HORIZONTAL_DOCUMENT_TEMPLATE = exports.COMPONENT_GRID_TEMPLATE = exports.TEST_TWO_LEVEL_ROOT_GROUP = exports.TEST_ROOT_GROUP = exports.TEST_GROUP_2 = exports.TEST_GROUP = exports.TEST_ITEM_MODEL = void 0;
+const types_1 = require("@contrail/types");
+const interfaces_1 = require("./interfaces");
+const sdk_1 = require("@contrail/sdk");
+exports.TEST_ITEM_MODEL = {
+    item: {
+        id: 'item-1001',
+        name: 'Shirt 1',
+        optionName: 'Red',
+        gender: 'mens',
+        mediumViewableDownloadUrl: 'https://api.vibeiq.com/dev/api/files/downloadUrl/-VMrLJrt3clDKPi0%2Fcontent:m3Bd4u-QLci1XiOl%2F2b72d48a-6b19-4ba8-9d54-813745fb8dd4.png',
+    },
+    projectItem: {
+        id: 'projectItem-1001',
+        retailPrice: 45.00
+    },
+    assortmentItem: {
+        id: 'assortmentItem-1001',
+        targetVolume: 1000
+    },
+};
+exports.TEST_GROUP = {
+    name: "Mens",
+    data: [exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL],
+    propertyValues: {
+        gender: 'mens'
+    },
+    subGroups: [],
+};
+exports.TEST_GROUP_2 = {
+    name: "Womens",
+    data: [exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL,
+        exports.TEST_ITEM_MODEL],
+    propertyValues: {
+        gender: 'womens'
+    },
+    subGroups: [],
+};
+exports.TEST_ROOT_GROUP = {
+    depth: 1,
+    groupingProperties: [{
+            property: {
+                slug: 'gender',
+                propertyType: types_1.PropertyType.SingleSelect,
+                label: "Gender",
+            },
+            sort: sdk_1.SortOrderOptions.ASC,
+            scope: 'item',
+            values: null,
+        }],
+    rootGroup: {
+        data: [],
+        subGroups: [exports.TEST_GROUP, exports.TEST_GROUP, exports.TEST_GROUP],
+        name: "Root",
+        propertyValues: {},
+    }
+};
+exports.TEST_TWO_LEVEL_ROOT_GROUP = {
+    depth: 2,
+    groupingProperties: [{
+            property: {
+                slug: 'gender',
+                propertyType: types_1.PropertyType.SingleSelect,
+                label: "Gender",
+            },
+            sort: sdk_1.SortOrderOptions.ASC,
+            scope: 'item',
+            values: null,
+        }],
+    rootGroup: {
+        data: [],
+        subGroups: [{
+                name: 'Mens',
+                subGroups: [exports.TEST_GROUP, exports.TEST_GROUP],
+                propertyValues: {
+                    gender: 'mens'
+                },
+                data: [],
+            }, {
+                name: 'Womens',
+                subGroups: [exports.TEST_GROUP_2, exports.TEST_GROUP_2, exports.TEST_GROUP_2, exports.TEST_GROUP_2],
+                propertyValues: {
+                    gender: 'mens'
+                },
+                data: [],
+            }],
+        name: "Root",
+        propertyValues: {},
+    }
+};
+exports.COMPONENT_GRID_TEMPLATE = {
+    gridDimensions: { cols: 7, rows: 3 },
+    componentTemplate: {
+        propertyTemplate: {
+            properties: [],
+            imageLocation: 'top',
+        }
+    },
+    componentPadding: 20
+};
+exports.HORIZONTAL_DOCUMENT_TEMPLATE = {
+    frameOrientation: interfaces_1.Orientation.HORIZONTAL,
+    frameSize: { width: 1200, height: 675 },
+    framePadding: 30,
+    frameHeaderTemplate: {
+        style: {
+            color: '#000000',
+            font: {
+                size: 20
+            },
+            backgroundColor: '#FFFFFF',
+        },
+        size: {
+            height: 60,
+        }
+    },
+    frameGroupHeaderTemplate: {
+        style: {
+            color: '#ffffff',
+            font: {
+                size: 20
+            },
+            backgroundColor: 'black',
+        },
+        size: {
+            height: 60,
+        }
+    },
+    componentGridTemplate: exports.COMPONENT_GRID_TEMPLATE,
+};
+exports.VERTICAL_DOCUMENT_TEMPLATE = {
+    frameOrientation: interfaces_1.Orientation.VERTICAL,
+    frameSize: { width: 1200, height: 675 },
+    framePadding: 30,
+    frameHeaderTemplate: {
+        style: {
+            color: '#000000',
+            font: {
+                size: 20
+            },
+            backgroundColor: '#FFFFFF',
+        },
+        size: {
+            height: 60,
+        }
+    },
+    frameGroupHeaderTemplate: {
+        style: {
+            color: '#ffffff',
+            font: {
+                size: 20
+            },
+            backgroundColor: 'black',
+        },
+        size: {
+            height: 60,
+        }
+    },
+    componentGridTemplate: exports.COMPONENT_GRID_TEMPLATE,
+};

package/lib/util/document-property-util.d.ts

@@ -0,0 +1,7 @@
+import { DocumentPropertyDefinition } from "../interfaces";
+import { DocumentElement, PositionDefinition } from "@contrail/documents";
+import { PropertyValueFormatter } from "@contrail/types";
+export declare class DocumentPropertyUtil {
+    static generatePropertyTextElements(data: any, properties: Array<DocumentPropertyDefinition>, options: DocumentElement, startingPosition: PositionDefinition, isComponent?: boolean): Array<DocumentElement>;
+    static generatePropertyTextElement(model: any, property: DocumentPropertyDefinition, options: DocumentElement, formatter: PropertyValueFormatter, position: PositionDefinition, isComponent?: boolean): DocumentElement;
+}

package/lib/util/document-property-util.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentPropertyUtil = void 0;
+const util_1 = require("@contrail/util");
+const types_1 = require("@contrail/types");
+const document_text_element_util_1 = require("./document-text-element-util");
+class DocumentPropertyUtil {
+    static generatePropertyTextElements(data, properties, options, startingPosition, isComponent = false) {
+        var _a, _b;
+        let yPosition = startingPosition.y || 0;
+        const xPosition = startingPosition.x || 0;
+        const elements = [];
+        const formatter = new types_1.PropertyValueFormatter();
+        for (let property of properties) {
+            const fontSize = ((_b = (_a = property.style) === null || _a === void 0 ? void 0 : _a.font) === null || _b === void 0 ? void 0 : _b.size) || 12;
+            let height = fontSize + 12;
+            options.size = options.size || {};
+            options.size.height = height;
+            let element = DocumentPropertyUtil.generatePropertyTextElement(data, property, options, formatter, { x: xPosition, y: yPosition }, isComponent);
+            yPosition += height;
+            elements.push(element);
+        }
+        return elements;
+    }
+    static generatePropertyTextElement(model, property, options, formatter, position, isComponent = false) {
+        var _a;
+        const modelKey = `${util_1.StringUtil.convertToCamelCase(property.typeRootSlug)}.${property.propertyDefinition.slug}`;
+        const value = util_1.ObjectUtil.getByPath(model, modelKey);
+        let display = formatter.formatValueForProperty(value, property.propertyDefinition);
+        const mergedOptions = util_1.ObjectUtil.mergeDeep(util_1.ObjectUtil.cloneDeep(options), { style: property.style || {} });
+        mergedOptions.position = position;
+        const useInlineFormatting = isComponent === false;
+        let element = document_text_element_util_1.DocumentTextElementUtil.generateTextElement(display, mergedOptions, useInlineFormatting);
+        if (isComponent && property.includeLabel) {
+            element.label = (_a = property.propertyDefinition) === null || _a === void 0 ? void 0 : _a.label;
+        }
+        else if (!isComponent && property.includeLabel) {
+            display = property.propertyDefinition.label + ': ' + display;
+        }
+        element.text = display;
+        element.propertyBindings = { text: modelKey };
+        return element;
+    }
+}
+exports.DocumentPropertyUtil = DocumentPropertyUtil;

package/lib/util/document-text-element-util.d.ts

@@ -0,0 +1,6 @@
+import { DocumentElement, StyleDefinition } from "@contrail/documents";
+export declare class DocumentTextElementUtil {
+    static generateTextElement(textValue: any, options: any, applyInlineFormatting?: boolean): DocumentElement;
+    static applyInLineStyling(text: any, style: StyleDefinition): any;
+    static applyBold(text: any): void;
+}

package/lib/util/document-text-element-util.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentTextElementUtil = void 0;
+const documents_1 = require("@contrail/documents");
+const util_1 = require("@contrail/util");
+class DocumentTextElementUtil {
+    static generateTextElement(textValue, options, applyInlineFormatting = true) {
+        var _a;
+        const defaultStyle = {
+            font: {
+                size: 8,
+            },
+            color: 'rgba(0,0,0,.5)',
+        };
+        let style = util_1.ObjectUtil.mergeDeep(defaultStyle, options.style || {});
+        if ((_a = options === null || options === void 0 ? void 0 : options.style) === null || _a === void 0 ? void 0 : _a.text) {
+            style.text = options.style.text;
+        }
+        let position = options.position || { y: 0, x: 0 };
+        position.x = position.x || 0;
+        position.y = position.y || 0;
+        let size = options.size || { height: 25, width: 125 };
+        size.height = size.height || 25;
+        size.width = size.width || 125;
+        const defaultedOptions = util_1.ObjectUtil.mergeDeep(util_1.ObjectUtil.cloneDeep(options), { position, size, style });
+        let element = documents_1.DocumentElementFactory.createTextElement(textValue);
+        element = Object.assign(element, defaultedOptions);
+        if (applyInlineFormatting) {
+            element.text = this.applyInLineStyling(element.text, element.style);
+        }
+        return element;
+    }
+    static applyInLineStyling(text, style) {
+        var _a, _b;
+        let formattedText = text;
+        if ((style === null || style === void 0 ? void 0 : style.font.weight) === 'bold') {
+            formattedText = `<strong>${formattedText}</strong>`;
+        }
+        if (((_a = style === null || style === void 0 ? void 0 : style.text) === null || _a === void 0 ? void 0 : _a.decoration) === 'underline') {
+            formattedText = `<span style="text-decoration: underline;">${formattedText}</span>`;
+        }
+        if ((_b = style === null || style === void 0 ? void 0 : style.font) === null || _b === void 0 ? void 0 : _b.size) {
+            formattedText = `<span style="font-size: ${style.font.size}pt;">${formattedText}</span>`;
+        }
+        formattedText = `<p>${formattedText}</p>`;
+        return formattedText;
+    }
+    static applyBold(text) {
+        return;
+    }
+}
+exports.DocumentTextElementUtil = DocumentTextElementUtil;

package/lib/util/document-util.d.ts

@@ -0,0 +1,7 @@
+import { PositionDefinition } from "@contrail/documents";
+export declare class DocumentUtil {
+    static getRelativePosition(position1: PositionDefinition, position2: PositionDefinition): {
+        x: number;
+        y: number;
+    };
+}

package/lib/util/document-util.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentUtil = void 0;
+class DocumentUtil {
+    static getRelativePosition(position1, position2) {
+        const relativePosition = {
+            x: position2.x - position1.x,
+            y: position2.y - position1.y,
+        };
+        return relativePosition;
+    }
+}
+exports.DocumentUtil = DocumentUtil;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/document-generation",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "Utilities for automatic generation of documents.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",