@ind-rcg/plugins-printengine 260.1004.0 → 262.1003.0-beta.4

package/dist/dev/src/fs-shim.js

@@ -0,0 +1,58 @@
+/*
+ * FILE_HEADER
+ */
+'use strict';
+
+/**
+ * @module fs-shim
+ * Browser filesystem shim for pdfmake font loading
+ * 
+ * **Source**: Custom implementation for pdfmake 0.3.x compatibility (not third-party)
+ * 
+ * This module provides a minimal fs-like API that bridges pdfkit's filesystem
+ * dependencies with pdfmake's virtual filesystem. Required because pdfkit attempts
+ * to use fs.readFileSync for font loading, which is not available in browsers.
+ * 
+ * The virtual filesystem is populated with font data from pdfmake's vfs_fonts.js
+ * on module initialization.
+ */
+
+const virtualFs = require('pdfmake/js/virtual-fs.js').default;
+const BrowserFontsVfs = require('pdfmake/build/vfs_fonts.js');
+const LogClass = require('./logClass');
+const __log = new LogClass();
+
+// Load font data into virtual file system on module load
+// BrowserFontsVfs has fonts directly as properties, not under .vfs
+if (BrowserFontsVfs) {
+    for (let key in BrowserFontsVfs) {
+        if (Object.prototype.hasOwnProperty.call(BrowserFontsVfs, key)) {
+            try {
+                let data;
+                let encoding;
+                if (typeof BrowserFontsVfs[key] === 'object') {
+                    data = BrowserFontsVfs[key].data;
+                    encoding = BrowserFontsVfs[key].encoding || 'base64';
+                } else {
+                    data = BrowserFontsVfs[key];
+                    encoding = 'base64';
+                }
+                virtualFs.writeFileSync(key, data, encoding);
+            } catch (e) {
+                __log.error('Failed to load font into virtual filesystem:', key, e);
+            }
+        }
+    }
+}
+
+module.exports = {
+    readFileSync: function(filename, options) {
+        return virtualFs.readFileSync(filename, options);
+    },
+    existsSync: function(filename) {
+        return virtualFs.existsSync(filename);
+    },
+    writeFileSync: function(filename, content, options) {
+        return virtualFs.writeFileSync(filename, content, options);
+    }
+};

package/dist/dev/src/pdfConverterClass.js

@@ -4,12 +4,13 @@
 'use strict';
 
 const _ = require('lodash');
-const PdfPrinter = require('pdfmake');
+const PdfPrinter = require('pdfmake/js/Printer').default;
 const Format = require('./formatClass');
 const TableCellIdentifier = require('./tableCellIdentifier');
 
 // required for webpack include (browser impl), used in conjunction with BrowserFonts definition
-const BrowserFontsVfs = require('pdfmake/build/vfs_fonts.js');
+// BrowserFontsVfs now loaded by fs-shim.js to avoid circular dependency and integrate with virtual filesystem
+// const BrowserFontsVfs = require('pdfmake/build/vfs_fonts.js');
 const classLog = require("./logClass");
 
 // => use 'Roboto' font (pdfMake default) due to licensing (Apache 2.0)
@@ -38,6 +39,12 @@ const BrowserFonts = {
     }
 };
 
+// pdfmake browser components for PDF generation
+const PdfMakeBase = require('pdfmake/js/base.js').default;
+const OutputDocumentBrowser = require('pdfmake/js/browser-extensions/OutputDocumentBrowser.js').default;
+const URLResolver = require('pdfmake/js/URLResolver.js').default;
+const virtualFs = require('pdfmake/js/virtual-fs.js').default;
+
 const TableLayouts = {
     lightHorizontalLinesMainItemsOnly: {
         hLineWidth: function (i, node) {
@@ -100,10 +107,33 @@ Object.freeze(EXPORT_TYPE);
 class PdfConverter {
     constructor() {
         this.__pdfMake = null;
-        if(typeof pdfMake !== "undefined")
+        
+        // First try to use global pdfMake (for tests or when pdfmake is loaded separately)
+        if(typeof global !== "undefined" && global.pdfMake)
+        {
+            this.__pdfMake = global.pdfMake;
+        }
+        else if(typeof pdfMake !== "undefined")
         {
             this.__pdfMake = pdfMake;
         }
+        // Fall back to creating browser pdfmake instance (for webpack bundled builds)
+        else if (PdfMakeBase && OutputDocumentBrowser && URLResolver) {
+            // Create browser-specific pdfmake instance
+            class BrowserPdfMake extends PdfMakeBase {
+                constructor() {
+                    super();
+                    this.urlResolver = () => new URLResolver(this.virtualfs);
+                    this.fonts = BrowserFonts;
+                    this.tableLayouts = TableLayouts;
+                    // Note: Font data is loaded into virtualfs by fs-shim.js
+                }
+                _transformToDocument(doc) {
+                    return new OutputDocumentBrowser(doc);
+                }
+            }
+            this.__pdfMake = new BrowserPdfMake();
+        }
 
         this.__format = new Format();
         this.__pdfHeight = null;
@@ -1006,8 +1036,15 @@ class PdfConverter {
         return doPageBreak;
     }
 
-    __calculatePageBreakBefore(currentNode, followingNodesOnPage, nodesOnNextPage, previousNodesOnPage) {
+    __calculatePageBreakBefore(currentNode, nodeGetters) {
         let doPageBreak = false;
+        
+        // pdfmake 0.3.x API: nodeGetters contains getter functions - validate availability
+        if (!nodeGetters || typeof nodeGetters.getNodesOnNextPage !== 'function') {
+            return false;
+        }
+        
+        const nodesOnNextPage = nodeGetters.getNodesOnNextPage();
       
         // looking for potential pageBreaks only makes sense if there are elements to be placed there (=> might require adaption for subtotals)
         if (!_.isNil(nodesOnNextPage) && _.isArray(nodesOnNextPage) && nodesOnNextPage.length > 0) {
@@ -1016,6 +1053,10 @@ class PdfConverter {
             let tcidCurrentNode = TableCellIdentifier.fromString(currentNode.id);
             if (!_.isNil(tcidCurrentNode) && tcidCurrentNode.isKnown()) {
 
+                // pdfmake 0.3.x: get the node arrays via getter functions
+                const followingNodesOnPage = nodeGetters.getFollowingNodesOnPage();
+                const previousNodesOnPage = nodeGetters.getPreviousNodesOnPage();
+
                 // check for dynamic pageBreak of parent-child rows
                 doPageBreak = this.__calculatePageBreakForParentChildRows(currentNode, followingNodesOnPage, nodesOnNextPage, previousNodesOnPage, tcidCurrentNode);                          
                 if (!doPageBreak) {                                  
@@ -1038,7 +1079,7 @@ class PdfConverter {
         return doPageBreak;
     }
 
-    __createPdfDocument(pdfDefinition, pdfCreationFunction) {
+    async __createPdfDocument(pdfDefinition, pdfCreationFunction) {
         // clone pdf definition if applicable ...
         let pdfDefinitionCopy = null;
         if (!_.isNil(pdfDefinition) && !_.isUndefined(pdfDefinition.dynamicPageBreak) && pdfDefinition.dynamicPageBreak &&
@@ -1072,12 +1113,12 @@ class PdfConverter {
         this.__definition = pdfDefinition;
 
         // exec pdfCreation function ...
-        pdfCreationFunction.apply(this, [pdfDefinition]);
+        await pdfCreationFunction.apply(this, [pdfDefinition]);
 
         return pdfDefinitionCopy;
     }
 
-    __createFinalPdfDocument(pdfDefinition, pdfDefinitionCopy, pdfCreationFunction) {
+    async __createFinalPdfDocument(pdfDefinition, pdfDefinitionCopy, pdfCreationFunction) {
         // perform pageBreak magic ...
         if (!_.isNil(pdfDefinition) && !_.isUndefined(pdfDefinition.dynamicPageBreak) && pdfDefinition.dynamicPageBreak &&
             !_.isUndefined(pdfDefinition.dynamicPageBreakData) && _.isArray(pdfDefinition.dynamicPageBreakData) &&
@@ -1093,7 +1134,7 @@ class PdfConverter {
             this.__definition = pdfDefinitionCopy;
 
             // exec pdfCreation function ...
-            pdfCreationFunction.apply(this, [pdfDefinitionCopy]);
+            await pdfCreationFunction.apply(this, [pdfDefinitionCopy]);
         }
     }
 
@@ -1111,22 +1152,22 @@ class PdfConverter {
         return this.__definition;
     }
 
-    writeToStream(pdfDefinition, stream) {
+    async writeToStream(pdfDefinition, stream) {
         // setup pdf creator ...
         let printer = new PdfPrinter(ServerFonts);
         let pdfDoc = null; 
-        let pdfCreatorFunction = (definition) => {
+        let pdfCreatorFunction = async (definition) => {
             printer = new PdfPrinter(ServerFonts);
-            pdfDoc = printer.createPdfKitDocument(definition, {
+            pdfDoc = await printer.createPdfKitDocument(definition, {
                 tableLayouts: TableLayouts
             });
         };
 
         // create pdf and prepare for recreation if applicable ...
-        let pdfDefinitionCopy = this.__createPdfDocument(pdfDefinition, pdfCreatorFunction);
+        let pdfDefinitionCopy = await this.__createPdfDocument(pdfDefinition, pdfCreatorFunction);
 
         // recreate pdf if applicable ...
-        this.__createFinalPdfDocument(pdfDefinition, pdfDefinitionCopy, pdfCreatorFunction);
+        await this.__createFinalPdfDocument(pdfDefinition, pdfDefinitionCopy, pdfCreatorFunction);
 
         pdfDoc.pipe(stream);
         pdfDoc.end();
@@ -1199,48 +1240,66 @@ class PdfConverter {
         });     
     }
 
-    async __getPdfDataAsync(type, pdfDefinition, previousResult = null) {
-        return new Promise((resolve, reject) => {
-            try {
-                if (_.isNil(pdfDefinition) && !_.isNil(previousResult)) {
-                    resolve(previousResult);
-                } else {
-                    let pdfDocGenerator = null;
-                    if (pdfDefinition.defaultStyle.font !== "PrintFont") {
-                        pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, TableLayouts, BrowserFonts, BrowserFontsVfs.vfs);
-                    }
-                    else {
-                        pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, TableLayouts, BrowserFonts, pdfDefinition.printFont);
-                    }
-                    
-                    switch (type) {
-                    case EXPORT_TYPE.BASE_64:
-                        pdfDocGenerator.getBase64((data) => {
-                            resolve(data);
-                        });
-                        break;
-
-                    case EXPORT_TYPE.BLOB:
-                        pdfDocGenerator.getBlob((blob) => {
-                            resolve(blob);
-                        });
-                        break;
-
-                    case EXPORT_TYPE.DATA_URL:
-                        pdfDocGenerator.getDataUrl((dataUrl) => {
-                            resolve(dataUrl);
-                        });
-                        break;
-
-                    default:                        
-                        throw new Error('Unknown export type: ' + type );                       
-                    }
+    /**
+     * Load custom printFont data into pdfmake's virtual file system.
+     * Required for pdfmake 0.3.x where fonts must be in VFS before use.
+     * 
+     * @param {Object} printFont - Object with Regular, Bold, Italic, BoldItalic keys containing base64 font data
+     */
+    __loadCustomFontsToVfs(printFont) {
+        if (!_.isObject(printFont)) {
+            return;
+        }
+        
+        const fontKeys = ['Regular', 'Bold', 'Italic', 'BoldItalic'];
+        for (const key of fontKeys) {
+            if (key in printFont && printFont[key]) {
+                try {
+                    // Font data is already base64 encoded
+                    virtualFs.writeFileSync(key, printFont[key], 'base64');
+                } catch (e) {
+                    __log.error('Failed to load custom font into virtual filesystem:', key, e);
                 }
+            }
+        }
+    }
 
-            } catch (error) {
-                reject(error);
+    async __getPdfDataAsync(type, pdfDefinition, previousResult = null) {
+        if (_.isNil(pdfDefinition) && !_.isNil(previousResult)) {
+            return previousResult;
+        }
+        
+        try {
+            // Load custom fonts into VFS if present (required for pdfmake 0.3.x)
+            if (pdfDefinition.printFont) {
+                this.__loadCustomFontsToVfs(pdfDefinition.printFont);
             }
-        });
+            
+            // pdfmake 0.3.x API: createPdf(docDefinition, options)
+            // fonts and tableLayouts are set on the pdfmake instance - validate initialization
+            if (!this.__pdfMake || typeof this.__pdfMake.createPdf !== 'function') {
+                throw new Error('pdfMake instance not properly initialized');
+            }
+            
+            let pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, {});
+            
+            // pdfmake 0.3.x returns Promises, not callbacks
+            switch (type) {
+            case EXPORT_TYPE.BASE_64: {
+                return await pdfDocGenerator.getBase64();
+            }
+            case EXPORT_TYPE.BLOB: {
+                return await pdfDocGenerator.getBlob();
+            }
+            case EXPORT_TYPE.DATA_URL: {
+                return await pdfDocGenerator.getDataUrl();
+            }
+            default:                        
+                throw new Error('Unknown export type: ' + type);                       
+            }
+        } catch (error) {
+            throw new Error(`PDF ${type} export failed: ${error.message}`);
+        }
     }
 
     async toBase64(pdfDefinition) {