@contrail/document-generation 2.1.20 → 2.1.22

package/lib/frames/frame-generator.js

@@ -0,0 +1,160 @@
+"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");
+const frame_1 = require("./frame");
+const document_dynamic_text_element_util_1 = require("../util/document-dynamic-text-element-util");
+const document_table_1 = require("@contrail/document-table");
+class FrameGenerator {
+    static generateBoardFrameForDataGroup(dataGroup, framePosition, template, frameTemplate, frameTitle) {
+        let style = { backgroundColor: '#fff', border: { width: 1, color: '#616161' } };
+        let frameSize = template.frameSize;
+        let clipContent = false;
+        if (frameTemplate) {
+            if (frameTemplate.document.style) {
+                style = frameTemplate.document.style;
+            }
+            frameSize = frameTemplate.document.size;
+            if (frameTemplate.document.clipContent) {
+                clipContent = frameTemplate.document.clipContent;
+            }
+        }
+        let frame = new frame_1.BoardFrame(frameTitle || dataGroup.name, { x: framePosition.x, y: framePosition.y }, frameSize, style, clipContent);
+        frame = this.generateFrameContentForGroup(frame, dataGroup, template, frameTemplate, frameTitle);
+        return frame;
+    }
+    static generateFrameContentForGroup(frame, dataGroup, template, frameTemplate = null, frameTitle = null) {
+        var _a, _b;
+        const FRAME_PADDING = 20;
+        const headerPosition = {
+            x: FRAME_PADDING,
+            y: FRAME_PADDING,
+        };
+        const panelPosition = {
+            x: FRAME_PADDING,
+            y: FRAME_PADDING,
+        };
+        let frameHeaderDimensions = { height: 0, width: 0 };
+        let framePanelDimensions = { height: 0, width: 0 };
+        let hasPanel = false;
+        let hasHeader = false;
+        if (frameTemplate) {
+            const elements = this.generateFrameTemplateElements(frameTemplate, dataGroup, frameTitle);
+            frame.addDocumentElements(elements);
+        }
+        else {
+            if (template.frameHeaderTemplate) {
+                hasHeader = true;
+                frameHeaderDimensions = { height: 50, width: template.frameSize.width - 50 };
+                const headerElements = this.generateFrameHeaderForDataGroup(dataGroup, headerPosition, template, frameHeaderDimensions, frameTitle);
+                frame.addDocumentElements(headerElements);
+            }
+            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;
+                const panelElements = this.generateFrameInfoPanelForDataGroup(dataGroup, panelPosition, template, framePanelDimensions);
+                frame.addDocumentElements(panelElements);
+            }
+        }
+        const GRID_MARGIN = 20;
+        let gridPosition = { x: 0, y: 0 };
+        let idealGridSize = { width: 0, height: 0 };
+        if (frameTemplate) {
+            gridPosition = frameTemplate.gridSpaceDefinition.position;
+            idealGridSize = frameTemplate.gridSpaceDefinition.size;
+        }
+        else {
+            if (hasHeader) {
+                gridPosition = {
+                    x: headerPosition.x,
+                    y: headerPosition.y,
+                };
+                gridPosition.y = gridPosition.y + frameHeaderDimensions.height + GRID_MARGIN;
+            }
+            if (hasPanel) {
+                gridPosition = {
+                    x: panelPosition.x,
+                    y: panelPosition.y,
+                };
+                gridPosition.x = gridPosition.x + framePanelDimensions.width + GRID_MARGIN;
+            }
+            const frameSize = template.frameSize;
+            idealGridSize = {
+                width: frameSize.width - gridPosition.x - FRAME_PADDING,
+                height: frameSize.height - gridPosition.y - FRAME_PADDING,
+            };
+        }
+        const gridElements = component_grid_generator_1.ComponentGridGenerator.generateComponentGrid(dataGroup.data, gridPosition, template.componentGridTemplate, idealGridSize);
+        frame.addDocumentElements(gridElements);
+        return frame;
+    }
+    static generateFrameHeaderForDataGroup(dataGroup, position, template, headerSize, frameTitle = null) {
+        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};\">${document_util_1.DocumentUtil.sanitizeHTML(frameTitle || dataGroup.name)}</span></strong></span></p>`;
+        heading.size = { width: headerSize.width, height: headerSize.height };
+        heading.position = { x: position.x, y: position.y };
+        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;
+    }
+    static generateFrameTemplateElements(frameTemplate, dataGroup, frameTitle = null) {
+        const templateElements = util_1.ObjectUtil.cloneDeep(frameTemplate.document.elements);
+        const elementMapping = {};
+        const createdElements = [];
+        for (let element of templateElements) {
+            if (['row', 'column', 'cell'].indexOf(element.type) !== -1)
+                continue;
+            const origElementId = element.id;
+            delete element.id;
+            delete element.updatedOn;
+            delete element.updatedById;
+            delete element.createdOn;
+            delete element.createdById;
+            let documentElement = documents_1.DocumentElementFactory.createElement(element.type, element);
+            let childDocumentElements = [];
+            elementMapping[origElementId] = documentElement.id;
+            if (documentElement.type === 'text') {
+                documentElement.text = documentElement.text.replace('{{dataGroup.name}}', dataGroup.name);
+            }
+            if (document_dynamic_text_element_util_1.DocumentDynamicTextElementUtil.isDynamicText(documentElement)) {
+                document_dynamic_text_element_util_1.DocumentDynamicTextElementUtil.handleDynamicText(documentElement, dataGroup, frameTitle);
+            }
+            if (documentElement.elementIds) {
+                documentElement.elementIds = [elementMapping[documentElement.elementIds[0]]];
+            }
+            if (documentElement.type === 'table') {
+                const oldChildElements = templateElements.filter((e) => e.tableId === origElementId && ['cell', 'column', 'row'].indexOf(e.type) !== -1);
+                let newTableElement, newChildElements = [];
+                try {
+                    [newTableElement, ...newChildElements] = document_table_1.TableCopyService.copy(documentElement, oldChildElements);
+                }
+                catch (e) { }
+                if (oldChildElements.length !== newChildElements.length || oldChildElements.length === 0) {
+                    console.log(`Invalid table element to copy`, documentElement, oldChildElements, newChildElements);
+                    continue;
+                }
+                documentElement = newTableElement;
+                childDocumentElements = newChildElements;
+            }
+            createdElements.push(documentElement);
+            createdElements.push(...childDocumentElements);
+        }
+        return createdElements;
+    }
+}
+exports.FrameGenerator = FrameGenerator;

package/lib/frames/frame.d.ts

@@ -0,0 +1,18 @@
+import { DocumentElement, PositionDefinition, SizeDefinition, StyleDefinition } from '@contrail/documents';
+export declare abstract class DocumentFrame {
+    frameContentElements: Array<DocumentElement>;
+    constructor();
+    addDocumentElements(elements: Array<DocumentElement>): void;
+    toDocumentElements(): Array<DocumentElement>;
+}
+export declare class ShowcaseFrame extends DocumentFrame {
+    name?: string;
+    documentGenerationConfigId?: string;
+    constructor(name?: string);
+}
+export declare class BoardFrame extends DocumentFrame {
+    private frameElement;
+    name: string;
+    constructor(name: string, position: PositionDefinition, size: SizeDefinition, style: StyleDefinition, clipContent?: boolean);
+    toDocumentElements(): Array<DocumentElement>;
+}

package/lib/frames/frame.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoardFrame = exports.ShowcaseFrame = exports.DocumentFrame = void 0;
+const documents_1 = require("@contrail/documents");
+const util_1 = require("@contrail/util");
+class DocumentFrame {
+    constructor() {
+        this.frameContentElements = [];
+    }
+    addDocumentElements(elements) {
+        this.frameContentElements.push(...elements);
+    }
+    toDocumentElements() {
+        const elements = [];
+        elements.push(...this.frameContentElements);
+        return elements;
+    }
+}
+exports.DocumentFrame = DocumentFrame;
+class ShowcaseFrame extends DocumentFrame {
+    constructor(name = '') {
+        super();
+        this.name = name;
+    }
+}
+exports.ShowcaseFrame = ShowcaseFrame;
+class BoardFrame extends DocumentFrame {
+    constructor(name, position, size, style, clipContent = false) {
+        super();
+        if (!position) {
+            position = { x: 0, y: 0 };
+        }
+        if (!size) {
+            size = { width: 1200, height: 675 };
+        }
+        if (!style) {
+            style = {};
+        }
+        this.frameElement = documents_1.DocumentElementFactory.createFrameElement({ size, position, style, clipContent });
+        this.frameElement.name = name;
+    }
+    toDocumentElements() {
+        const elements = [];
+        elements.push(this.frameElement);
+        const repositionedElements = [];
+        for (let element of util_1.ObjectUtil.cloneDeep(this.frameContentElements)) {
+            if (this.frameElement.position.x !== 0) {
+                if (element.type === 'line') {
+                    element.lineDefinition.x1 += this.frameElement.position.x;
+                    element.lineDefinition.x2 += this.frameElement.position.x;
+                }
+                else {
+                    element.position.x += this.frameElement.position.x;
+                }
+            }
+            if (this.frameElement.position.y !== 0) {
+                if (element.type === 'line') {
+                    element.lineDefinition.y1 += this.frameElement.position.y;
+                    element.lineDefinition.y2 += this.frameElement.position.y;
+                }
+                else {
+                    element.position.y += this.frameElement.position.y;
+                }
+            }
+            repositionedElements.push(element);
+        }
+        elements.push(...repositionedElements);
+        return elements;
+    }
+}
+exports.BoardFrame = BoardFrame;

package/lib/frames/index.d.ts

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

package/lib/frames/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("./frame"), exports);
+__exportStar(require("./frame-generator"), exports);

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './document-generator';
+export * from './board-document-generator';
+export * from './showcase-frame-generator';
+export * from './interfaces';
+export * from './frames';
+export * from './util';

package/lib/index.js

@@ -0,0 +1,22 @@
+"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("./board-document-generator"), exports);
+__exportStar(require("./showcase-frame-generator"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./frames"), exports);
+__exportStar(require("./util"), exports);

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoPanelGenerator = void 0;
+const documents_1 = require("@contrail/documents");
+const document_property_util_1 = require("../util/document-property-util");
+class InfoPanelGenerator {
+    static generatedModelBindings(data) {
+        const model = {};
+        if (data.item) {
+            model.item = `item:${data.item.id}`;
+        }
+        if (data.projectItem) {
+            model.projectItem = `project-item:${data.projectItem.id}`;
+        }
+        if (data.assortmentItem) {
+            model.assortmentItem = `assortment-item:${data.assortmentItem.id}`;
+        }
+        if (data.assortment) {
+            model.assortment = `assortment:${data.assortment.id}`;
+        }
+        return model;
+    }
+    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 = panelSize
+            ? {
+                width: panelSize.width,
+                height: panelSize.height,
+            }
+            : {};
+        panel.position = { x: position.x, y: position.y };
+        elements.push(panel);
+        const modelBindings = this.generatedModelBindings(data);
+        const textOptions = {
+            style: {
+                text: {
+                    align: template.propertyTemplate.textHorizontalAlignment,
+                },
+            },
+            size: {
+                width: panelSize.width - 10,
+            },
+            modelBindings,
+        };
+        const textElements = document_property_util_1.DocumentPropertyUtil.generatePropertyElements(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,73 @@
+import { DataGroupStructure } from '@contrail/data-grouping';
+import { PositionDefinition, SizeDefinition, Document, 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;
+    frameTemplate?: FrameDocumentTemplate;
+}
+export interface DocumentTemplate {
+    frameOrientation: Orientation;
+    frameSize: SizeDefinition;
+    framePadding?: number;
+    frameGroupHeaderTemplate: DocumentElement;
+    secondaryFrameGroupHeaderTemplate?: DocumentElement;
+    frameHeaderTemplate?: DocumentElement;
+    frameInfoPanelTemplate?: FrameInfoPanelTemplate;
+    componentGridTemplate: ComponentGridTemplate;
+}
+export interface GridSpaceDefinition {
+    size: SizeDefinition;
+    position: PositionDefinition;
+}
+export interface FrameDocumentTemplate {
+    id: string;
+    templateType: 'FRAME' | 'BOARD';
+    document: Document;
+    gridSpaceDefinition: GridSpaceDefinition;
+    name: string;
+    clipContent: boolean;
+}
+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;
+    };
+    alignment?: 'left' | 'center' | 'right';
+}
+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;
+    isHidden?: boolean;
+    size?: SizeDefinition;
+}

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/showcase-frame-generator.d.ts

@@ -0,0 +1,8 @@
+import { DocumentGenerationOptions } from './interfaces';
+import { DocumentFrame } from './frames/frame';
+export declare class ShowcaseFrameGenerator {
+    constructor();
+    static generateFrames(options: DocumentGenerationOptions): Array<DocumentFrame>;
+    private static getFrameGroups;
+    private static getLeafGroupsFromGroups;
+}

package/lib/showcase-frame-generator.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowcaseFrameGenerator = void 0;
+const frame_1 = require("./frames/frame");
+const frame_generator_1 = require("./frames/frame-generator");
+class ShowcaseFrameGenerator {
+    constructor() { }
+    static generateFrames(options) {
+        const frames = [];
+        const structure = options.data.dataGroup;
+        const template = options.documentTemplateDefinition;
+        const frameTemplate = options.frameTemplate;
+        const groups = this.getFrameGroups(structure);
+        for (let group of groups) {
+            const showcaseFrame = frame_generator_1.FrameGenerator.generateFrameContentForGroup(new frame_1.ShowcaseFrame((group === null || group === void 0 ? void 0 : group.name) || ''), group, template, frameTemplate);
+            console.log('showcaseFrame: ', showcaseFrame);
+            frames.push(showcaseFrame);
+        }
+        return frames;
+    }
+    static getFrameGroups(groupStructure) {
+        return this.getLeafGroupsFromGroups(groupStructure.rootGroup.subGroups, groupStructure.depth, 0);
+    }
+    static getLeafGroupsFromGroups(groups, totalDepth, currentDepth, groupName = null) {
+        const currentGroupName = groupName;
+        const leafGroups = [];
+        for (let group of groups) {
+            if (currentDepth === 0) {
+                groupName = null;
+            }
+            if (currentDepth === totalDepth) {
+                group.name = !groupName ? group.name : groupName + ' / ' + group.name;
+                leafGroups.push(group);
+            }
+            else {
+                if (currentDepth < totalDepth - 1)
+                    groupName = !currentGroupName ? group.name : currentGroupName + ' / ' + group.name;
+                leafGroups.push(...this.getLeafGroupsFromGroups(group.subGroups, totalDepth, currentDepth + 1, groupName));
+            }
+        }
+        return leafGroups;
+    }
+}
+exports.ShowcaseFrameGenerator = ShowcaseFrameGenerator;

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

@@ -0,0 +1,9 @@
+import { DataGroup } from '@contrail/data-grouping';
+import { DocumentElement } from '@contrail/documents';
+export declare class DocumentDynamicTextElementUtil {
+    static typeMap: any;
+    static propertyMapByType: any;
+    static isDynamicText(element: any): any;
+    static handleDynamicText(element: DocumentElement, dataGroup: DataGroup, frameTitle?: any): void;
+    static setTypeMap(typeMap: any): void;
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentDynamicTextElementUtil = void 0;
+const documents_1 = require("@contrail/documents");
+const types_1 = require("@contrail/types");
+const document_text_element_util_1 = require("./document-text-element-util");
+class DocumentDynamicTextElementUtil {
+    static isDynamicText(element) {
+        return element.type === 'text' && element.propertyBindings && element.propertyBindingsMetaData;
+    }
+    static handleDynamicText(element, dataGroup, frameTitle = null) {
+        var _a, _b, _c;
+        const propertyBindingsText = element.propertyBindings.text;
+        let propertyLevel = (_a = element.propertyBindingsMetaData) === null || _a === void 0 ? void 0 : _a.propertyLevel;
+        let property = null;
+        let componentModels = dataGroup.data;
+        const frame = {
+            name: frameTitle || dataGroup.name,
+        };
+        if (propertyBindingsText) {
+            const [entityType, propertySlug] = propertyBindingsText === null || propertyBindingsText === void 0 ? void 0 : propertyBindingsText.split('.');
+            property = (_b = this.propertyMapByType[entityType]) === null || _b === void 0 ? void 0 : _b.properties[propertySlug];
+            if (!propertyLevel &&
+                (property === null || property === void 0 ? void 0 : property.propertyLevel) &&
+                [types_1.PropertyLevel.OPTION, types_1.PropertyLevel.FAMILY].includes(property.propertyLevel)) {
+                propertyLevel = property.propertyLevel;
+            }
+            if (propertyLevel && propertyLevel === types_1.PropertyLevel.FAMILY) {
+                componentModels = JSON.parse(JSON.stringify(dataGroup.data));
+                componentModels.forEach((componentModel) => {
+                    var _a;
+                    const entity = componentModel[entityType];
+                    const isOption = (_a = entity === null || entity === void 0 ? void 0 : entity.roles) === null || _a === void 0 ? void 0 : _a.includes('option');
+                    if (isOption && entityType === 'item' && entity.itemFamily) {
+                        componentModel[entityType] = entity.itemFamily;
+                    }
+                    if (isOption && entityType === 'project-item' && entity.familyProjectItem) {
+                        componentModel[entityType] = entity.familyProjectItem;
+                    }
+                });
+            }
+        }
+        let text = documents_1.DynamicTextUtil.getDynamicTextValue(element, property, propertyLevel, frame, componentModels);
+        if (((_c = element.text) === null || _c === void 0 ? void 0 : _c.toString().indexOf('</')) > -1) {
+            const styleDefinition = document_text_element_util_1.DocumentTextElementUtil.extractStyleFromInline(element.text);
+            text = document_text_element_util_1.DocumentTextElementUtil.applyInLineStyling(text, styleDefinition);
+        }
+        element.text = text;
+    }
+    static setTypeMap(typeMap) {
+        DocumentDynamicTextElementUtil.typeMap = typeMap;
+        Object.keys(DocumentDynamicTextElementUtil.typeMap).forEach((type) => {
+            DocumentDynamicTextElementUtil.propertyMapByType[type] = { properties: {} };
+            typeMap[type].typeProperties.forEach((p) => {
+                DocumentDynamicTextElementUtil.propertyMapByType[type].properties[p.slug] = p;
+            });
+        });
+    }
+}
+exports.DocumentDynamicTextElementUtil = DocumentDynamicTextElementUtil;
+DocumentDynamicTextElementUtil.propertyMapByType = {};

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

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