@contrail/document-generation 2.0.17 → 2.0.19

package/lib/board-document-generator.d.ts

@@ -1,5 +1,5 @@
 import { DocumentElement, PositionDefinition } from "@contrail/documents";
-import { DocumentGenerationOptions, DocumentTemplate } from "./interfaces";
+import { DocumentGenerationOptions, DocumentTemplate, FrameDocumentTemplate } from "./interfaces";
 import { DataGroup } from "@contrail/data-grouping";
 export declare class BoardDocumentGenerator {
     constructor();
@@ -13,9 +13,9 @@ export declare class BoardDocumentGenerator {
         y: number;
     };
     static generateBoardGroupHeaders(group: DataGroup, template: DocumentTemplate, startingPosition: PositionDefinition, totalDepth: number, currentDepth: number): any[];
-    static generateBoardFrames(group: DataGroup, template: DocumentTemplate, startingPosition: PositionDefinition, totalDepth: number, currentDepth: number): any[];
+    static generateBoardFrames(group: DataGroup, template: DocumentTemplate, frameTemplate: FrameDocumentTemplate, startingPosition: PositionDefinition, totalDepth: number, currentDepth: number): any[];
     static getGroupSpan(group: DataGroup, totalDepth: any, currentDepth: any): number;
     private static findDeepestSubgroups;
-    static generateFrameGroup(dataGroup: DataGroup, template: DocumentTemplate, position: PositionDefinition): Array<DocumentElement>;
+    static generateFrameGroup(dataGroup: DataGroup, template: DocumentTemplate, frameTemplate: any, position: PositionDefinition): Array<DocumentElement>;
     static generateBoardGroupHeader(dataGroup: DataGroup, template: DocumentTemplate, position: PositionDefinition, span: any): any[];
 }

package/lib/board-document-generator.js

@@ -13,11 +13,15 @@ class BoardDocumentGenerator {
         const elements = [];
         const structure = options.data.dataGroup;
         const template = options.documentTemplateDefinition;
+        const frameTemplate = options.frameTemplate;
+        if (frameTemplate) {
+            template.frameSize = frameTemplate.document.size;
+        }
         console.log("generateDocumentElements: ", structure.depth, structure.groupingProperties.length);
         let position = options.startingCoordinates || { x: 0, y: 0 };
         const group = structure.rootGroup;
         elements.push(...this.generateBoardGroupHeaders(group, template, position, structure.depth, 0));
-        elements.push(...this.generateBoardFrames(group, template, position, structure.depth, 0));
+        elements.push(...this.generateBoardFrames(group, template, frameTemplate, position, structure.depth, 0));
         return elements;
     }
     static adjustPositionBasedGroupHeaderSpan(currentPosition, template, subGroup, totalDepth, currentDepth) {
@@ -59,18 +63,18 @@ class BoardDocumentGenerator {
         }
         return elements;
     }
-    static generateBoardFrames(group, template, startingPosition, totalDepth, currentDepth) {
+    static generateBoardFrames(group, template, frameTemplate, startingPosition, totalDepth, currentDepth) {
         const elements = [];
         let position = util_1.ObjectUtil.cloneDeep(startingPosition);
         if (currentDepth > 0) {
             position = this.adjustPositionBasedOnGroupHeaderSize(position, template);
         }
         if (currentDepth === totalDepth) {
-            elements.push(...this.generateFrameGroup(group, template, position));
+            elements.push(...this.generateFrameGroup(group, template, frameTemplate, position));
         }
         if (currentDepth < totalDepth) {
             for (let subGroup of group.subGroups) {
-                elements.push(...this.generateBoardFrames(subGroup, template, position, totalDepth, currentDepth + 1));
+                elements.push(...this.generateBoardFrames(subGroup, template, frameTemplate, position, totalDepth, currentDepth + 1));
                 position = util_1.ObjectUtil.cloneDeep(this.adjustPositionBasedGroupHeaderSpan(position, template, subGroup, totalDepth, currentDepth));
             }
         }
@@ -94,11 +98,11 @@ class BoardDocumentGenerator {
             this.findDeepestSubgroups(group.subGroups[i], subgroups, totalDepth, currentDepth + 1);
         }
     }
-    static generateFrameGroup(dataGroup, template, position) {
+    static generateFrameGroup(dataGroup, template, frameTemplate, position) {
         const elements = [];
         let framePosition = { x: position.x + template.framePadding, y: position.y + template.framePadding };
         for (let group of dataGroup.subGroups) {
-            let frame = frame_generator_1.FrameGenerator.generateBoardFrameForDataGroup(group, framePosition, template);
+            let frame = frame_generator_1.FrameGenerator.generateBoardFrameForDataGroup(group, framePosition, template, frameTemplate);
             elements.push(...frame.toDocumentElements());
             if (template.frameOrientation === interfaces_1.Orientation.HORIZONTAL) {
                 framePosition.x = framePosition.x + template.frameSize.width + template.framePadding || 10;

package/lib/frames/frame-generator.d.ts

@@ -1,11 +1,12 @@
 import { DocumentElement, PositionDefinition, SizeDefinition } from "@contrail/documents";
 import { DataGroup } from "@contrail/data-grouping";
-import { DocumentTemplate } from "../interfaces";
+import { DocumentTemplate, FrameDocumentTemplate } from "../interfaces";
 import { DocumentFrame } from "./frame";
 export declare class FrameGenerator {
-    static generateBoardFrameForDataGroup(dataGroup: DataGroup, framePosition: PositionDefinition, template: DocumentTemplate): DocumentFrame;
-    static generateFrameContentForGroup(frame: DocumentFrame, dataGroup: DataGroup, template: DocumentTemplate): DocumentFrame;
+    static generateBoardFrameForDataGroup(dataGroup: DataGroup, framePosition: PositionDefinition, template: DocumentTemplate, frameTemplate: FrameDocumentTemplate): DocumentFrame;
+    static generateFrameContentForGroup(frame: DocumentFrame, dataGroup: DataGroup, template: DocumentTemplate, frameTemplate?: FrameDocumentTemplate): DocumentFrame;
     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;
+    static generateFrameTemplateElements(frameTemplate: FrameDocumentTemplate, dataGroup: DataGroup): DocumentElement[];
 }

package/lib/frames/frame-generator.js

@@ -8,13 +8,20 @@ const document_util_1 = require("../util/document-util");
 const info_panel_generator_1 = require("../info-panel/info-panel-generator");
 const frame_1 = require("./frame");
 class FrameGenerator {
-    static generateBoardFrameForDataGroup(dataGroup, framePosition, template) {
-        const style = { backgroundColor: "#fff", border: { width: 1, color: "#616161" } };
-        let frame = new frame_1.BoardFrame(dataGroup.name, util_1.ObjectUtil.cloneDeep(framePosition), template.frameSize, style);
-        frame = this.generateFrameContentForGroup(frame, dataGroup, template);
+    static generateBoardFrameForDataGroup(dataGroup, framePosition, template, frameTemplate) {
+        let style = { backgroundColor: "#fff", border: { width: 1, color: "#616161" } };
+        let frameSize = template.frameSize;
+        if (frameTemplate) {
+            if (frameTemplate.document.style) {
+                style = frameTemplate.document.style;
+            }
+            frameSize = frameTemplate.document.size;
+        }
+        let frame = new frame_1.BoardFrame(dataGroup.name, util_1.ObjectUtil.cloneDeep(framePosition), frameSize, style);
+        frame = this.generateFrameContentForGroup(frame, dataGroup, template, frameTemplate);
         return frame;
     }
-    static generateFrameContentForGroup(frame, dataGroup, template) {
+    static generateFrameContentForGroup(frame, dataGroup, template, frameTemplate = null) {
         var _a, _b;
         const FRAME_PADDING = 20;
         const headerPosition = {
@@ -29,34 +36,47 @@ class FrameGenerator {
         let framePanelDimensions = { height: 0, width: 0 };
         let hasPanel = false;
         let hasHeader = false;
-        if (template.frameHeaderTemplate) {
-            hasHeader = true;
-            frameHeaderDimensions = { height: 50, width: template.frameSize.width - 50 };
-            const headerElements = this.generateFrameHeaderForDataGroup(dataGroup, headerPosition, template, frameHeaderDimensions);
-            frame.addDocumentElements(headerElements);
+        if (frameTemplate) {
+            const elements = this.generateFrameTemplateElements(frameTemplate, dataGroup);
+            frame.addDocumentElements(elements);
         }
-        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);
+        else {
+            if (template.frameHeaderTemplate) {
+                hasHeader = true;
+                frameHeaderDimensions = { height: 50, width: template.frameSize.width - 50 };
+                const headerElements = this.generateFrameHeaderForDataGroup(dataGroup, headerPosition, template, frameHeaderDimensions);
+                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 };
-        if (hasHeader) {
-            gridPosition = util_1.ObjectUtil.cloneDeep(headerPosition);
-            gridPosition.y = gridPosition.y + frameHeaderDimensions.height + GRID_MARGIN;
+        let idealGridSize = { width: 0, height: 0 };
+        if (frameTemplate) {
+            gridPosition = frameTemplate.gridSpaceDefinition.position;
+            idealGridSize = frameTemplate.gridSpaceDefinition.size;
         }
-        if (hasPanel) {
-            gridPosition = util_1.ObjectUtil.cloneDeep(panelPosition);
-            gridPosition.x = gridPosition.x + framePanelDimensions.width + GRID_MARGIN;
+        else {
+            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 frameSize = template.frameSize;
+            idealGridSize = {
+                width: frameSize.width - gridPosition.x - FRAME_PADDING,
+                height: frameSize.height - gridPosition.y - FRAME_PADDING
+            };
         }
-        const frameSize = template.frameSize;
-        const 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;
@@ -76,5 +96,23 @@ class FrameGenerator {
         const frame = documents_1.DocumentElementFactory.createFrameElement(options);
         return frame;
     }
+    static generateFrameTemplateElements(frameTemplate, dataGroup) {
+        const templateElements = util_1.ObjectUtil.cloneDeep(frameTemplate.document.elements);
+        const createdElements = [];
+        for (let element of templateElements) {
+            delete element.id;
+            delete element.updatedOn;
+            delete element.updatedById;
+            delete element.createdOn;
+            delete element.createdById;
+            const documentElement = documents_1.DocumentElementFactory.createElement(element.type, element);
+            if (documentElement.type === 'text') {
+                documentElement.text = documentElement.text.replace('{{dataGroup.name}}', dataGroup.name);
+            }
+            createdElements.push(documentElement);
+        }
+        ;
+        return createdElements;
+    }
 }
 exports.FrameGenerator = FrameGenerator;

package/lib/frames/frame.js

@@ -41,10 +41,22 @@ class BoardFrame extends DocumentFrame {
         const repositionedElements = [];
         for (let element of util_1.ObjectUtil.cloneDeep(this.frameContentElements)) {
             if (this.frameElement.position.x !== 0) {
-                element.position.x += this.frameElement.position.x;
+                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) {
-                element.position.y += this.frameElement.position.y;
+                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);
         }

package/lib/interfaces.d.ts

@@ -1,5 +1,5 @@
 import { DataGroupStructure } from "@contrail/data-grouping";
-import { PositionDefinition, SizeDefinition, DocumentElement, StyleDefinition } from "@contrail/documents";
+import { PositionDefinition, SizeDefinition, Document, DocumentElement, StyleDefinition } from "@contrail/documents";
 import { TypeProperty } from "@contrail/types";
 export declare enum Orientation {
     HORIZONTAL = "horizontal",
@@ -12,6 +12,7 @@ export interface DocumentGenerationOptions {
     startingCoordinates: PositionDefinition;
     data: DocumentGenerationDataDefinition;
     documentTemplateDefinition: DocumentTemplate;
+    frameTemplate?: FrameDocumentTemplate;
 }
 export interface DocumentTemplate {
     frameOrientation: Orientation;
@@ -22,6 +23,16 @@ export interface DocumentTemplate {
     frameInfoPanelTemplate?: FrameInfoPanelTemplate;
     componentGridTemplate: ComponentGridTemplate;
 }
+export interface GridSpaceDefinition {
+    size: SizeDefinition;
+    position: PositionDefinition;
+}
+export interface FrameDocumentTemplate {
+    templateType: 'FRAME' | 'BOARD';
+    document: Document;
+    gridSpaceDefinition: GridSpaceDefinition;
+    name: string;
+}
 export interface FrameInfoPanelTemplate {
     panelDocumentTemplate: DocumentElement;
     propertyTemplate: PanelPropertyTemplate;

package/lib/showcase-frame-generator.js

@@ -10,9 +10,10 @@ class ShowcaseFrameGenerator {
         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, template);
+            const showcaseFrame = frame_generator_1.FrameGenerator.generateFrameContentForGroup(new frame_1.ShowcaseFrame(), group, template, frameTemplate);
             console.log("showcaseFrame: ", showcaseFrame);
             frames.push(showcaseFrame);
         }

package/package.json

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