@jsreport/jsreport-libreoffice 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 jsreport
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @jsreport/jsreport-libreoffice
+
+**jsreport extension using LibreOffice to convert outputs to the supported formats like pdf**
+
+See https://jsreport.net/learn/libreoffice
+
+## Installation
+
+> **npm install @jsreport/jsreport-libreoffice**
+
+## Changelog
+
+### 1.0.0
+
+- initial release

package/index.js

@@ -0,0 +1,7 @@
+const config = require('./jsreport.config.js')
+
+module.exports = function (options) {
+  config.options = options
+  config.directory = __dirname
+  return config
+}

package/jsreport.config.js

@@ -0,0 +1,24 @@
+
+module.exports = {
+  name: 'libreoffice',
+  main: 'lib/main.js',
+  worker: 'lib/worker.js',
+  dependencies: ['templates', 'assets'],
+  requires: {
+    core: '4.7.x',
+    studio: '4.x.x'
+  },
+  optionsSchema: {
+    extensions: {
+      libreoffice: {
+        type: 'object',
+        properties: {
+          sofficePath: {
+            type: ['string'],
+            description: 'Specify path to soffice binary. The default is to search for soffice in default paths.'
+          }
+        }
+      }
+    }
+  }
+}

package/lib/main.js

@@ -0,0 +1,72 @@
+module.exports = function (reporter, definition) {
+  reporter.documentStore.registerComplexType('LibreOfficeType', {
+    format: { type: 'Edm.String' },
+    enabled: { type: 'Edm.Boolean' },
+    print: { type: 'Edm.String' },
+    /* general */
+    pdfExportPageRange: { type: 'Edm.String' },
+    pdfExportUseLosslessCompression: { type: 'Edm.Boolean' },
+    pdfExportQuality: { type: 'Edm.Decimal' },
+    pdfExportReduceImageResolution: { type: 'Edm.Boolean' },
+    pdfExportMaxImageResolution: { type: 'Edm.Decimal' },
+    pdfExportSelectPdfVersion: { type: 'Edm.Decimal' },
+    pdfExportPDFUACompliance: { type: 'Edm.Boolean' },
+    pdfExportUseTaggedPDF: { type: 'Edm.Boolean' },
+    pdfExportExportFormFields: { type: 'Edm.Boolean' },
+    pdfExportFormsType: { type: 'Edm.Decimal' },
+    pdfExportAllowDuplicateFieldNames: { type: 'Edm.Boolean' },
+    pdfExportExportBookmarks: { type: 'Edm.Boolean' },
+    pdfExportExportPlaceholders: { type: 'Edm.Boolean' },
+    pdfExportExportNotes: { type: 'Edm.Boolean' },
+    pdfExportExportNotesPages: { type: 'Edm.Boolean' },
+    pdfExportExportOnlyNotesPages: { type: 'Edm.Boolean' },
+    pdfExportExportNotesInMargin: { type: 'Edm.Boolean' },
+    pdfExportExportHiddenSlides: { type: 'Edm.Boolean' },
+    pdfExportIsSkipEmptyPages: { type: 'Edm.Boolean' },
+    pdfExportEmbedStandardFonts: { type: 'Edm.Boolean' },
+    pdfExportIsAddStream: { type: 'Edm.Boolean' },
+    pdfExportWatermark: { type: 'Edm.String' },
+    pdfExportWatermarkColor: { type: 'Edm.Decimal' },
+    pdfExportWatermarkFontHeight: { type: 'Edm.Decimal' },
+    pdfExportWatermarkRotateAngle: { type: 'Edm.Decimal' },
+    pdfExportWatermarkFontName: { type: 'Edm.String' },
+    pdfExportTiledWatermark: { type: 'Edm.String' },
+    pdfExportUseReferenceXObject: { type: 'Edm.Boolean' },
+    pdfExportIsRedactMode: { type: 'Edm.Boolean' },
+    pdfExportSinglePageSheets: { type: 'Edm.Boolean' },
+    /* initial view */
+    pdfExportResizeWindowToInitialPage: { type: 'Edm.Boolean' },
+    pdfExportCenterWindow: { type: 'Edm.Boolean' },
+    pdfExportOpenInFullScreenMode: { type: 'Edm.Boolean' },
+    pdfExportDisplayPDFDocumentTitle: { type: 'Edm.Boolean' },
+    pdfExportHideViewerMenubar: { type: 'Edm.Boolean' },
+    pdfExportHideViewerToolbar: { type: 'Edm.Boolean' },
+    pdfExportHideViewerWindowControls: { type: 'Edm.Boolean' },
+    pdfExportUseTransitionEffects: { type: 'Edm.Boolean' },
+    pdfExportOpenBookmarkLevels: { type: 'Edm.Decimal' },
+    /* links */
+    pdfExportExportBookmarksToPDFDestination: { type: 'Edm.Boolean' },
+    pdfExportConvertOOoTargetToPDFTarget: { type: 'Edm.Boolean' },
+    pdfExportExportLinksRelativeFsys: { type: 'Edm.Boolean' },
+    pdfExportPDFViewSelection: { type: 'Edm.Decimal' },
+    /* security */
+    pdfExportEncryptFile: { type: 'Edm.Boolean' },
+    pdfExportDocumentOpenPassword: { type: 'Edm.String' },
+    pdfExportRestrictPermissions: { type: 'Edm.Boolean' },
+    pdfExportPermissionPassword: { type: 'Edm.String' },
+    pdfExportPrinting: { type: 'Edm.Decimal' },
+    pdfExportChanges: { type: 'Edm.Decimal' },
+    pdfExportEnableCopyingOfContent: { type: 'Edm.Boolean' },
+    pdfExportEnableTextAccessForAccessibilityTools: { type: 'Edm.Boolean' },
+    /* digital signatures */
+    pdfExportSignPDF: { type: 'Edm.Boolean' },
+    pdfExportSignatureLocation: { type: 'Edm.String' },
+    pdfExportSignatureReason: { type: 'Edm.String' },
+    pdfExportSignatureContactInfo: { type: 'Edm.String' },
+    pdfExportSignaturePassword: { type: 'Edm.String' },
+    pdfExportSignCertificateSubjectName: { type: 'Edm.String' },
+    pdfExportSignatureTSA: { type: 'Edm.String' }
+  })
+
+  reporter.documentStore.model.entityTypes.TemplateType.libreOffice = { type: 'jsreport.LibreOfficeType' }
+}

package/lib/worker.js

@@ -0,0 +1,427 @@
+const path = require('path')
+const mime = require('mime')
+const util = require('util')
+const { spawn, exec } = require('child_process')
+const execAsync = util.promisify(exec)
+const url = require('url')
+const fs = require('fs').promises
+
+module.exports = function (reporter, definition) {
+  reporter.beforeRenderListeners.insert(0, 'libreoffice', (req, res) => {
+    // otherwise the output is html for office online
+    if (req.template.libreOffice && req.template.libreOffice.enabled !== false && req.template.libreOffice.format) {
+      req.options.preview = false
+    }
+  })
+
+  let sofficePath
+  let libreOfficeProfile
+
+  reporter.afterRenderListeners.insert({ before: 'scripts' }, 'libreoffice', async (req, res) => {
+    if (!req.template.libreOffice || req.template.libreOffice.enabled === false || (!req.template.libreOffice.format && !req.template.libreOffice.print) || req.context.isChildRequest) {
+      return
+    }
+
+    await sofficeCommand({
+      libreOfficeOptions: req.template.libreOffice,
+      source: { res }
+    }, req)
+  })
+
+  reporter.extendProxy((proxy, req, { sandboxRequire }) => {
+    proxy.libreOffice = {
+      async convert (content, format, options) {
+        if (!content) {
+          throw reporter.createError('jsreport.libreOffice.convert expect content buffer as the first parameter ', {
+            weak: true
+          })
+        }
+
+        if (!format) {
+          throw reporter.createError('jsreport.libreOffice.convert expect format as the second parameter ', {
+            weak: true
+          })
+        }
+
+        return sofficeCommand({
+          libreOfficeOptions: {
+            format,
+            ...options
+          },
+          source: {
+            content
+          }
+        }, req)
+      },
+      async print (content, printer, options) {
+        if (!content) {
+          throw reporter.createError('jsreport.libreOffice.print expect content buffer as the first parameter ', {
+            weak: true
+          })
+        }
+
+        if (!printer) {
+          throw reporter.createError('jsreport.libreOffice.print expect printer name as the second parameter ', {
+            weak: true
+          })
+        }
+
+        return sofficeCommand({
+          libreOfficeOptions: {
+            printer,
+            ...options
+          },
+          source: {
+            content
+          }
+        }, req)
+      }
+    }
+  })
+
+  async function sofficeCommand ({
+    libreOfficeOptions,
+    source
+  }, req) {
+    const profilerEvent = reporter.profiler.emit({
+      type: 'operationStart',
+      subtype: 'libreoffice',
+      name: 'libreoffice ' + (libreOfficeOptions.printer ? `print ${libreOfficeOptions.printer}` : `convert ${libreOfficeOptions.format}`),
+      doDiffs: false
+    }, req)
+
+    if (sofficePath == null) {
+      if (definition.options.sofficePath) {
+        sofficePath = definition.options.sofficePath
+      } else {
+        reporter.logger.debug('Searching for soffice path', req)
+        sofficePath = await getSofficePath()
+      }
+    }
+
+    if (libreOfficeProfile == null) {
+      libreOfficeProfile = path.join(reporter.options.tempDirectory, 'libreoffice', `profile-${reporter.workerId}`)
+      try {
+        reporter.logger.debug('Creating libreoffice profile at ' + libreOfficeProfile, req)
+        await execAsync(`"${sofficePath}" --convert-to pdf ${reporter.options.tempDirectory} --headless -env:UserInstallation=${url.pathToFileURL(libreOfficeProfile)} --outdir ${reporter.options.tempDirectory}`)
+      } catch (e) {
+        // the first render always fail because of missing profile for some reason
+      }
+    }
+
+    try {
+      let outputFilename
+      let pathToFile
+      if (source.res) {
+        pathToFile = (await source.res.output.writeToTempFile((uuid) => {
+          outputFilename = uuid + '.' + libreOfficeOptions.format
+          return `${uuid}.bin`
+        })).pathToFile
+      } else {
+        pathToFile = (await reporter.writeTempFile((uuid) => {
+          outputFilename = uuid + '.' + libreOfficeOptions.format
+          return `${uuid}.bin}`
+        }, source.content)).pathToFile
+      }
+
+      await new Promise((resolve, reject) => {
+        const stdout = []
+        const stderr = []
+        let failed = false
+
+        const args = []
+
+        if (libreOfficeOptions.printer) {
+          args.push('--pt', libreOfficeOptions.printer)
+        } else {
+          args.push('--convert-to', libreOfficeOptions.format !== 'pdf' ? libreOfficeOptions.format : pdfExportString(libreOfficeOptions))
+        }
+
+        args.push(`${pathToFile}`)
+        args.push('--headless')
+        args.push(`-env:UserInstallation=${url.pathToFileURL(libreOfficeProfile)}`)
+
+        if (!libreOfficeOptions.printer) {
+          args.push('--outdir', path.dirname(pathToFile))
+        }
+
+        reporter.logger.debug(`libreoffice command ${sofficePath} ${args.join(' ')}`, req)
+        const childProcess = spawn(sofficePath, args)
+
+        childProcess.stdout.on('data', (data) => {
+          stdout.push(data)
+        })
+
+        childProcess.stderr.on('data', (data) => {
+          stderr.push(data)
+        })
+
+        childProcess.on('close', async (code) => {
+          if (!failed) {
+            if (stderr.length) {
+              return reject(new Error(Buffer.concat(stderr).toString('utf8')))
+            }
+            resolve()
+          }
+        })
+
+        childProcess.on('error', (err) => {
+          failed = true
+          reject(err)
+        })
+
+        return childProcess
+      })
+
+      reporter.profiler.emit({
+        type: 'operationEnd',
+        operationId: profilerEvent.operationId,
+        doDiffs: false
+      }, req)
+
+      if (!libreOfficeOptions.printer) {
+        if (source.res) {
+          await source.res.output.update(path.join(path.dirname(pathToFile), outputFilename))
+
+          source.res.meta.fileExtension = libreOfficeOptions.format
+          source.res.meta.contentType = mime.getType(libreOfficeOptions.format)
+        } else {
+          return {
+            content: await fs.readFile(path.join(path.dirname(pathToFile), outputFilename)),
+            fileExtension: libreOfficeOptions.format
+          }
+        }
+      }
+    } catch (e) {
+      throw reporter.createError('Error while executing LibreOffice', {
+        original: e,
+        weak: true
+      })
+    }
+  }
+
+  const getSofficePath = async () => {
+    const getEnvVarKey = (key) => {
+      const upperKey = key.toUpperCase()
+      return Object.keys(process.env).find(k => k.toUpperCase() === upperKey)
+    }
+
+    const paths = (() => {
+      switch (process.platform) {
+        case 'darwin':
+          return ['/Applications/LibreOffice.app/Contents/MacOS/soffice']
+        case 'linux':
+          return [
+            '/usr/bin/libreoffice',
+            '/usr/bin/soffice',
+            '/snap/bin/libreoffice',
+            '/opt/libreoffice/program/soffice',
+            '/opt/libreoffice7.6/program/soffice'
+          ]
+        case 'win32': {
+          const programFilesEnvKey = getEnvVarKey('ProgramFiles')
+          const programFilesX86EnvKey = getEnvVarKey('ProgramFiles(x86)')
+          return [
+            programFilesEnvKey ? path.join(process.env[programFilesEnvKey], 'LibreOffice/program/soffice.exe') : null,
+            programFilesX86EnvKey ? path.join(process.env[programFilesX86EnvKey], 'LIBREO~1/program/soffice.exe') : null,
+            programFilesX86EnvKey ? path.join(process.env[programFilesX86EnvKey], 'LibreOffice/program/soffice.exe') : null
+          ]
+        }
+      }
+    }
+    )().filter(p => p)
+
+    for (const p of paths) {
+      try {
+        await fs.access(p)
+        return p
+      } catch (e) {
+
+      }
+    }
+
+    throw reporter.createError('Could not find soffice binary on paths ' + paths.join(', '), {
+      weak: true
+    })
+  }
+
+  const pdfExportString = (libreOfficeOptions) => {
+    const exportOptions = {}
+    if (libreOfficeOptions.pdfExportWatermark) {
+      exportOptions.Watermark = { type: 'string', value: libreOfficeOptions.pdfExportWatermark }
+    }
+    if (libreOfficeOptions.pdfExportPageRange) {
+      exportOptions.PageRange = { type: 'string', value: libreOfficeOptions.pdfExportPageRange }
+    }
+    if (libreOfficeOptions.pdfExportUseLosslessCompression != null) {
+      exportOptions.UseLosslessCompression = { type: 'boolean', value: libreOfficeOptions.pdfExportUseLosslessCompression }
+    }
+    if (libreOfficeOptions.pdfExportQuality) {
+      exportOptions.Quality = { type: 'long', value: libreOfficeOptions.pdfExportQuality }
+    }
+    if (libreOfficeOptions.pdfExportReduceImageResolution != null) {
+      exportOptions.ReduceImageResolution = { type: 'boolean', value: libreOfficeOptions.pdfExportReduceImageResolution }
+    }
+    if (libreOfficeOptions.pdfExportSelectPdfVersion) {
+      exportOptions.SelectPdfVersion = { type: 'long', value: libreOfficeOptions.pdfExportSelectPdfVersion }
+    }
+    if (libreOfficeOptions.pdfExportMaxImageResolution) {
+      exportOptions.MaxImageResolution = { type: 'long', value: libreOfficeOptions.pdfExportMaxImageResolution }
+    }
+    if (libreOfficeOptions.pdfExportPDFUACompliance != null) {
+      exportOptions.PDFUACompliance = { type: 'boolean', value: libreOfficeOptions.pdfExportPDFUACompliance }
+    }
+    if (libreOfficeOptions.pdfExportUseTaggedPDF != null) {
+      exportOptions.PDFUseTaggedPDF = { type: 'boolean', value: libreOfficeOptions.pdfExportUseTaggedPDF }
+    }
+    if (libreOfficeOptions.pdfExportExportFormFields != null) {
+      exportOptions.ExportFormFields = { type: 'boolean', value: libreOfficeOptions.pdfExportExportFormFields }
+    }
+    if (libreOfficeOptions.pdfExportFormsType) {
+      exportOptions.FormsType = { type: 'long', value: libreOfficeOptions.pdfExportFormsType }
+    }
+    if (libreOfficeOptions.pdfExportAllowDuplicateFieldNames != null) {
+      exportOptions.AllowDuplicateFieldNames = { type: 'boolean', value: libreOfficeOptions.pdfExportAllowDuplicateFieldNames }
+    }
+    if (libreOfficeOptions.pdfExportExportBookmarks != null) {
+      exportOptions.ExportBookmarks = { type: 'boolean', value: libreOfficeOptions.pdfExportExportBookmarks }
+    }
+    if (libreOfficeOptions.pdfExportExportPlaceholders != null) {
+      exportOptions.ExportPlaceholders = { type: 'boolean', value: libreOfficeOptions.pdfExportExportPlaceholders }
+    }
+    if (libreOfficeOptions.pdfExportExportNotes != null) {
+      exportOptions.ExportNotes = { type: 'boolean', value: libreOfficeOptions.pdfExportExportNotes }
+    }
+    if (libreOfficeOptions.pdfExportExportNotesPages != null) {
+      exportOptions.ExportNotesPages = { type: 'boolean', value: libreOfficeOptions.pdfExportExportNotesPages }
+    }
+    if (libreOfficeOptions.pdfExportExportOnlyNotesPages != null) {
+      exportOptions.ExportOnlyNotesPages = { type: 'boolean', value: libreOfficeOptions.pdfExportExportOnlyNotesPages }
+    }
+    if (libreOfficeOptions.pdfExportExportNotesInMargin != null) {
+      exportOptions.ExportNotesInMargin = { type: 'boolean', value: libreOfficeOptions.pdfExportExportNotesInMargin }
+    }
+    if (libreOfficeOptions.pdfExportExportHiddenSlides != null) {
+      exportOptions.ExportHiddenSlides = { type: 'boolean', value: libreOfficeOptions.pdfExportExportHiddenSlides }
+    }
+    if (libreOfficeOptions.pdfExportIsSkipEmptyPages != null) {
+      exportOptions.IsSkipEmptyPages = { type: 'boolean', value: libreOfficeOptions.pdfExportIsSkipEmpty }
+    }
+    if (libreOfficeOptions.pdfExportEmbedStandardFonts != null) {
+      exportOptions.EmbedStandardFonts = { type: 'boolean', value: libreOfficeOptions.pdfExportEmbedStandardFonts }
+    }
+    if (libreOfficeOptions.pdfExportIsAddStream != null) {
+      exportOptions.IsAddStream = { type: 'boolean', value: libreOfficeOptions.pdfExportIsAddStream }
+    }
+    if (libreOfficeOptions.pdfExportWatermarkColor) {
+      exportOptions.WatermarkColor = { type: 'long', value: libreOfficeOptions.pdfExportWatermarkColor }
+    }
+    if (libreOfficeOptions.pdfExportWatermarkFontHeight) {
+      exportOptions.WatermarkFontHeight = { type: 'long', value: libreOfficeOptions.pdfExportWatermarkFontHeight }
+    }
+    if (libreOfficeOptions.pdfExportWatermarkRotateAngle) {
+      exportOptions.WatermarkRotateAngle = { type: 'long', value: libreOfficeOptions.pdfExportWatermarkRotate }
+    }
+    if (libreOfficeOptions.pdfExportWatermarkFontName) {
+      exportOptions.WatermarkFontName = { type: 'string', value: libreOfficeOptions.pdfExportWatermarkFontName }
+    }
+    if (libreOfficeOptions.pdfExportTiledWatermark) {
+      exportOptions.TiledWatermark = { type: 'string', value: libreOfficeOptions.pdfExportTiledWatermark }
+    }
+    if (libreOfficeOptions.pdfExportUseReferenceXObject != null) {
+      exportOptions.UseReferenceXObject = { type: 'boolean', value: libreOfficeOptions.pdfExportUseReferenceXObject }
+    }
+    if (libreOfficeOptions.pdfExportIsRedactMode != null) {
+      exportOptions.IsRedactMode = { type: 'boolean', value: libreOfficeOptions.pdfExportIsRedactMode }
+    }
+    if (libreOfficeOptions.pdfExportSinglePageSheets != null) {
+      exportOptions.SinglePageSheets = { type: 'boolean', value: libreOfficeOptions.pdfExportSinglePageSheets }
+    }
+    if (libreOfficeOptions.pdfExportResizeWindowToInitialPage != null) {
+      exportOptions.ResizeWindowToInitialPage = { type: 'boolean', value: libreOfficeOptions.pdfExportResizeWindowToInitialPage }
+    }
+    if (libreOfficeOptions.pdfExportCenterWindow != null) {
+      exportOptions.CenterWindow = { type: 'boolean', value: libreOfficeOptions.pdfExportCenterWindow }
+    }
+    if (libreOfficeOptions.pdfExportOpenInFullScreenMode != null) {
+      exportOptions.OpenInFullScreenMode = { type: 'boolean', value: libreOfficeOptions.pdfExportOpenInFullScreenMode }
+    }
+    if (libreOfficeOptions.pdfExportDisplayPDFDocumentTitle != null) {
+      exportOptions.DisplayPDFDocumentTitle = { type: 'boolean', value: libreOfficeOptions.pdfExportDisplayPDFDocumentTitle }
+    }
+    if (libreOfficeOptions.pdfExportHideViewerMenubar != null) {
+      exportOptions.HideViewerMenubar = { type: 'boolean', value: libreOfficeOptions.pdfExportHideViewerMenubar }
+    }
+    if (libreOfficeOptions.pdfExportHideViewerToolbar != null) {
+      exportOptions.HideViewerToolbar = { type: 'boolean', value: libreOfficeOptions.pdfExportHideViewerToolbar }
+    }
+    if (libreOfficeOptions.pdfExportHideViewerWindowControls != null) {
+      exportOptions.HideViewerWindowControls = { type: 'boolean', value: libreOfficeOptions.pdfExportHideViewerWindowControls }
+    }
+    if (libreOfficeOptions.pdfExportUseTransitionEffects != null) {
+      exportOptions.UseTransitionEffects = { type: 'boolean', value: libreOfficeOptions.pdfExportUseTransitionEffects }
+    }
+    if (libreOfficeOptions.pdfExportOpenBookmarkLevels) {
+      exportOptions.OpenBookmarkLevels = { type: 'long', value: libreOfficeOptions.pdfExportOpenBookmarkLevels }
+    }
+    if (libreOfficeOptions.pdfExportExportBookmarksToPDFDestination != null) {
+      exportOptions.ExportBookmarksToPDFDestination = { type: 'boolean', value: libreOfficeOptions.pdfExportExportBookmarksToPDFDestination }
+    }
+    if (libreOfficeOptions.pdfExportConvertOOoTargetToPDFTarget != null) {
+      exportOptions.ConvertOOoTargetToPDFTarget = { type: 'boolean', value: libreOfficeOptions.pdfExportConvertOOoTargetToPDFTarget }
+    }
+    if (libreOfficeOptions.pdfExportExportLinksRelativeFsys != null) {
+      exportOptions.ExportLinksRelativeFsys = { type: 'boolean', value: libreOfficeOptions.pdfExportExportLinksRelativeFsys }
+    }
+    if (libreOfficeOptions.pdfExportPDFViewSelection) {
+      exportOptions.PDFViewSelection = { type: 'long', value: libreOfficeOptions.pdfExportPDFViewSelection }
+    }
+    if (libreOfficeOptions.pdfExportEncryptFile != null) {
+      exportOptions.EncryptFile = { type: 'boolean', value: libreOfficeOptions.pdfExportEncryptFile }
+    }
+    if (libreOfficeOptions.pdfExportDocumentOpenPassword) {
+      exportOptions.DocumentOpenPassword = { type: 'string', value: libreOfficeOptions.pdfExportDocumentOpenPassword }
+    }
+    if (libreOfficeOptions.pdfExportRestrictPermissions != null) {
+      exportOptions.RestrictPermissions = { type: 'boolean', value: libreOfficeOptions.pdfExportRestrictPermissions }
+    }
+    if (libreOfficeOptions.pdfExportPermissionPassword) {
+      exportOptions.PermissionPassword = { type: 'string', value: libreOfficeOptions.pdfExportPermissionPassword }
+    }
+    if (libreOfficeOptions.pdfExportPrinting) {
+      exportOptions.Printing = { type: 'long', value: libreOfficeOptions.pdfExportPrinting }
+    }
+    if (libreOfficeOptions.pdfExportChanges) {
+      exportOptions.Changes = { type: 'long', value: libreOfficeOptions.pdfExportChanges }
+    }
+    if (libreOfficeOptions.pdfExportEnableCopyingOfContent != null) {
+      exportOptions.EnableCopyingOfContent = { type: 'boolean', value: libreOfficeOptions.pdfExportEnableCopyingOfContent }
+    }
+    if (libreOfficeOptions.pdfExportEnableTextAccessForAccessibilityTools != null) {
+      exportOptions.EnableTextAccessForAccessibilityTools = { type: 'boolean', value: libreOfficeOptions.pdfExportEnableTextAccessForAccessibilityTools }
+    }
+    if (libreOfficeOptions.pdfExportSignPDF != null) {
+      exportOptions.SignPDF = { type: 'boolean', value: libreOfficeOptions.pdfExportSignPDF }
+    }
+    if (libreOfficeOptions.pdfExportSignatureLocation) {
+      exportOptions.SignatureLocation = { type: 'string', value: libreOfficeOptions.pdfExportSignatureLocation }
+    }
+    if (libreOfficeOptions.pdfExportSignatureReason) {
+      exportOptions.SignatureReason = { type: 'string', value: libreOfficeOptions.pdfExportSignatureReason }
+    }
+    if (libreOfficeOptions.pdfExportSignatureContactInfo) {
+      exportOptions.SignatureContactInfo = { type: 'string', value: libreOfficeOptions.pdfExportSignatureContactInfo }
+    }
+    if (libreOfficeOptions.pdfExportSignaturePassword) {
+      exportOptions.SignaturePassword = { type: 'string', value: libreOfficeOptions.pdfExportSignaturePassword }
+    }
+    if (libreOfficeOptions.pdfExportSignCertificateSubjectName) {
+      exportOptions.SignCertificateSubjectName = { type: 'string', value: libreOfficeOptions.pdfExportSignCertificateSubjectName }
+    }
+    if (libreOfficeOptions.pdfExportSignatureTSA) {
+      exportOptions.SignatureTSA = { type: 'string', value: libreOfficeOptions.pdfExportSignatureTSA }
+    }
+
+    return 'pdf:writer_pdf_Export:' + JSON.stringify(exportOptions)
+  }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@jsreport/jsreport-libreoffice",
+  "version": "1.0.0",
+  "description": "jsreport extension for converting office documents",
+  "keywords": [
+    "jsreport",
+    "office"
+  ],
+  "homepage": "https://github.com/jsreport/jsreport/tree/master/packages//jsreport-libreoffice",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:jsreport/jsreport.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Jan Blaha",
+    "email": "jan.blaha@hotmail.com"
+  },
+  "contributors": [
+    "BJR Matos <bjrmatos@gmail.com> (https://github.com/bjrmatos)"
+  ],
+  "files": [
+    "lib",
+    "studio",
+    "index.js",
+    "jsreport.config.js"
+  ],
+  "scripts": {
+    "build": "jsreport-studio-build",
+    "prepublishOnly": "jsreport-studio-build",
+    "test": "mocha test --timeout 15000 && standard"
+  },
+  "dependencies": {
+    "mime": "2.4.4"
+  },
+  "devDependencies": {
+    "@jsreport/jsreport-core": "4.7.0",
+    "@jsreport/jsreport-html-to-xlsx": "4.2.1",
+    "@jsreport/jsreport-scripts": "4.2.0",
+    "@jsreport/studio-dev": "4.0.0",
+    "mocha": "10.1.0",
+    "should": "13.2.3",
+    "standard": "16.0.4"
+  },
+  "engines": {
+    "node": ">=18.15"
+  },
+  "standard": {
+    "ignore": [
+      "studio/main.js"
+    ],
+    "env": {
+      "node": true,
+      "mocha": true,
+      "browser": true
+    }
+  }
+}