@things-factory/integration-headless 7.0.49 → 7.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-headless",
-  "version": "7.0.49",
+  "version": "7.0.53",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
@@ -29,5 +29,5 @@
     "ejs": "^3.1.10",
     "pdf-lib": "^1.17.1"
   },
-  "gitHead": "3fdc2d9c86f8ebf1470fa5d2155b7b3019df6c0d"
+  "gitHead": "96b4308aff1d312343c647a80823658e78b03824"
 }

package/server/engine/task/headless-pdf-capture-board.ts

@@ -1,9 +1,7 @@
-import * as ejs from 'ejs'
 import { TaskRegistry } from '@things-factory/integration-base'
-import { ConnectionManager } from '@things-factory/integration-base'
-import { access } from '@things-factory/utils'
+
+import { PDFCaptureUtil, getCommonParameterSpec } from './pdf-capture-util'
 import { BoardFunc } from '@things-factory/board-service'
-import { PDFDocument } from 'pdf-lib'
 
 const PAGE_FORMATS = {
   A4: { width: 595.28, height: 841.89 },
@@ -12,250 +10,86 @@ const PAGE_FORMATS = {
   Legal: { width: 612, height: 1008 }
 }
 
-async function HeadlessPDFCaptureBoard(step, context) {
-  var { connection: connectionName, params: stepOptions } = step
-  var {
-    accessor,
-    board,
-    draft,
-    format = 'A4', // Set default value to A4
-    width,
-    height,
-    marginTop = 0,
-    marginBottom = 0,
-    marginLeft = 0,
-    marginRight = 0,
-    scale,
-    printBackground,
-    landscape,
-    preferCSSPageSize
-  } = stepOptions || {}
-  var { domain, data, user, logger, __headless_pdf } = context
-
-  if (!__headless_pdf) {
-    throw new Error('It requires headless-pdf-open to be performed first')
-  }
-
-  if (!board || !board.id) {
-    throw new Error('The board property must be set')
-  }
+type PageFormat = keyof typeof PAGE_FORMATS
 
-  var { pdfDoc, header, footer, watermark } = __headless_pdf
-
-  var headlessPool = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-  let browser
+export async function HeadlessPDFCaptureBoard(step, context) {
+  const pdfUtil = new PDFCaptureUtil(context)
+  await pdfUtil.initBrowser(step.connection)
 
   try {
-    browser = await headlessPool.acquire()
-    const page = await browser.newPage()
+    const { board, draft, format = 'A4', landscape, preferCSSPageSize } = step.params
 
-    const boardInput = access(accessor, data)
+    if (!board || !board.id) {
+      throw new Error('The board property must be set')
+    }
 
-    var { model, base } = await BoardFunc.headlessModel({ domain, id: board.id, model }, draft)
-    const [fontsToUse, fontStyles] = await BoardFunc.fonts(domain)
+    const { model, base } = await BoardFunc.headlessModel({ domain: context.domain, id: board.id }, draft)
+    const [fontsToUse, fontStyles] = await BoardFunc.fonts(context.domain)
 
     model.fonts = fontsToUse
     model.fontStyles = fontStyles
 
-    var { width: boardWidthPx, height: boardHeightPx } = model
+    let width: number | undefined = PAGE_FORMATS[format as PageFormat]?.width
+    let height: number | undefined = PAGE_FORMATS[format as PageFormat]?.height
 
     if (preferCSSPageSize) {
       width = undefined
       height = undefined
-    } else if (PAGE_FORMATS[format]) {
-      const pageDimensions = PAGE_FORMATS[format]
-      width = pageDimensions.width
-      height = pageDimensions.height
     }
 
-    if (landscape) {
+    if (landscape && width && height) {
       ;[width, height] = [height, width]
     }
 
-    const contentWidth = width - marginLeft - marginRight
-    const contentHeight = height - marginTop - marginBottom
-
-    const boardWidthPt = (boardWidthPx * 72) / 96
-    const boardHeightPt = (boardHeightPx * 72) / 96
-
-    const widthRatio = contentWidth / boardWidthPt
-    const heightRatio = contentHeight / boardHeightPt
-    const ratio = Math.min(widthRatio, heightRatio)
-
-    const scaledBoardWidthPt = boardWidthPt * ratio
-    const scaledBoardHeightPt = boardHeightPt * ratio
-
-    const offsetX = (contentWidth - scaledBoardWidthPt) / 2 + marginLeft
-    const offsetY = (contentHeight - scaledBoardHeightPt) / 2 + marginBottom
-
-    await page.setViewport({ width: Math.round(boardWidthPx * ratio), height: Math.round(boardHeightPx * ratio) })
-    await page.setRequestInterception(true)
-    await page.setDefaultTimeout(10000)
-
-    page.on('console', async msg => {
-      console.log(`[browser ${msg.type()}] ${msg.text()}`)
-    })
-
-    page.on('requestfailed', request => {
-      console.log('Request failed:', request.url())
-    })
-
     const protocol = 'http'
     const host = 'localhost'
     const port = process.env.PORT ? `:${process.env.PORT}` : ''
     const path = '/internal-board-service-view'
     const url = `${protocol}://${host}${port}${path}`
 
-    const token = await user?.sign()
+    const page = await pdfUtil.browser!.newPage()
 
-    page.on('request', request => {
-      if (request.url() === url) {
-        request.continue({
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'x-things-factory-domain': domain?.subdomain,
-            Authorization: 'Bearer ' + token
-          },
-          postData: JSON.stringify({
-            model,
-            base
-          })
-        })
-      } else if (request.url().startsWith(`${protocol}://${host}${port}`)) {
-        request.continue({
-          headers: {
-            ...request.headers(),
-            'x-things-factory-domain': domain?.subdomain,
-            Authorization: 'Bearer ' + token
-          }
-        })
-      } else {
-        request.continue()
-      }
+    await page.setViewport({
+      width: Math.round(width || 800), // Fallback for width if not defined
+      height: Math.round(height || 600) // Fallback for height if not defined
     })
 
     await page.goto(url)
 
-    await page.evaluate(data => {
-      //@ts-ignore
-      s.data = data
-      return new Promise(resolve => {
-        requestAnimationFrame(() => resolve(0))
-      })
-    }, boardInput)
-
-    const renderTemplateSafely = (template, data) => {
-      try {
-        return ejs.render(template, data)
-      } catch (error) {
-        logger.warn(`Template rendering error: ${error.message}`)
-        return template
-      }
-    }
-
-    header = renderTemplateSafely(header, __headless_pdf)
-    footer = renderTemplateSafely(footer, __headless_pdf)
-
-    // Apply header, footer, and watermark using Puppeteer
-    // Apply header, footer, and watermark using Puppeteer
-    if (header || footer || watermark) {
-      await page.evaluate(
-        ({ header, footer, watermark, isLandscape }) => {
-          const setPositioning = (element, position) => {
-            element.style.position = 'fixed'
-            element.style.left = '0'
-            element.style.width = '100%'
-            element.style.textAlign = 'center'
-            element.style.fontSize = '12px'
-            element.style.margin = '0'
-            element.style.padding = '0'
-            if (position === 'header') {
-              element.style.top = '0'
-            } else if (position === 'footer') {
-              element.style.bottom = '0'
-            }
-          }
-
-          if (header) {
-            const headerElement = document.createElement('div')
-            headerElement.innerHTML = header
-            setPositioning(headerElement, 'header')
-            document.body.appendChild(headerElement)
-          }
-
-          if (footer) {
-            const footerElement = document.createElement('div')
-            footerElement.innerHTML = footer
-            setPositioning(footerElement, 'footer')
-            document.body.appendChild(footerElement)
-          }
-
-          if (watermark) {
-            const watermarkElement = document.createElement('div')
-            watermarkElement.innerHTML = watermark
-            watermarkElement.style.position = 'fixed'
-            watermarkElement.style.top = isLandscape ? '40%' : '50%'
-            watermarkElement.style.left = '50%'
-            watermarkElement.style.transform = 'translate(-50%, -50%) rotate(-45deg)'
-            watermarkElement.style.opacity = '0.2'
-            watermarkElement.style.fontSize = '50px'
-            watermarkElement.style.color = 'red'
-            watermarkElement.style.pointerEvents = 'none'
-            watermarkElement.style.zIndex = '9999'
-            document.body.appendChild(watermarkElement)
-          }
-        },
-        { header, footer, watermark, isLandscape: landscape }
-      )
-    }
-
-    const pageOptions = {
-      format,
-      width: `${scaledBoardWidthPt}px`,
-      height: `${scaledBoardHeightPt}px`,
-      margin: {
-        top: `${offsetY}px`,
-        right: `${offsetX}px`,
-        bottom: `${offsetY}px`,
-        left: `${offsetX}px`
+    await page.evaluate(
+      data => {
+        //@ts-ignore
+        s.data = data
+        return new Promise(resolve => {
+          requestAnimationFrame(() => resolve(0))
+        })
       },
-      scale,
-      printBackground,
-      landscape,
-      displayHeaderFooter: false, // Handled via Puppeteer directly
-      preferCSSPageSize
-    }
-
-    const contentBuffer = await page.pdf(pageOptions)
-    const contentPdfDoc = await PDFDocument.load(contentBuffer)
-    const copiedPages = await pdfDoc.copyPages(contentPdfDoc, contentPdfDoc.getPageIndices())
-
-    copiedPages.forEach(page => pdfDoc.addPage(page))
-
-    __headless_pdf.pageCount += copiedPages.length
+      { model, base }
+    )
+
+    // 페이지 옵션 설정
+    const pageOptions = pdfUtil.buildPageOptions({
+      ...step.params,
+      width: width ? `${width}px` : undefined,
+      height: height ? `${height}px` : undefined
+    })
 
-    await page.close()
-    headlessPool.release(browser)
+    // PDF 생성 및 추가
+    const htmlContent = '' // 보드에서 직접 렌더링되므로 HTML 컨텐츠가 비어있음
+    await pdfUtil.processPageAndGeneratePDF({ ...step.params, width, height }, htmlContent)
 
     return {
-      data: __headless_pdf
+      data: context.__headless_pdf
     }
   } catch (error) {
-    if (browser) {
-      await browser.close()
-    }
-
     throw error
+  } finally {
+    await pdfUtil.closeBrowser()
   }
 }
 
 HeadlessPDFCaptureBoard.parameterSpec = [
-  {
-    type: 'scenario-step-input',
-    name: 'accessor',
-    label: 'accessor'
-  },
+  ...getCommonParameterSpec(),
   {
     type: 'resource-object',
     name: 'board',
@@ -270,91 +104,6 @@ HeadlessPDFCaptureBoard.parameterSpec = [
     label: 'board-draft',
     defaultValue: false,
     description: 'Set whether to get the current working version or the last released version'
-  },
-  {
-    type: 'select',
-    name: 'format',
-    label: 'page-format',
-    property: {
-      options: [
-        { display: '', value: '' },
-        { display: 'A4', value: 'A4' },
-        { display: 'A3', value: 'A3' },
-        { display: 'Letter', value: 'Letter' },
-        { display: 'Legal', value: 'Legal' }
-      ]
-    },
-    description: 'Select the paper format for the PDF'
-  },
-  {
-    type: 'string',
-    name: 'width',
-    label: 'page-width',
-    placeholder: '(e.g., "8.5in", "21cm", "600px")',
-    description: 'Specify the width of the page (e.g., "8.5in", "21cm", "600px")'
-  },
-  {
-    type: 'string',
-    name: 'height',
-    label: 'page-height',
-    placeholder: '(e.g., "11in", "29.7cm", "800px")',
-    description: 'Specify the height of the page (e.g., "11in", "29.7cm", "800px")'
-  },
-  {
-    type: 'string',
-    name: 'marginTop',
-    label: 'page-margin-top',
-    placeholder: '(e.g., "0.5in", "1cm", "100px")',
-    description: 'Set the top margin for the page'
-  },
-  {
-    type: 'string',
-    name: 'marginBottom',
-    label: 'page-margin-bottom',
-    placeholder: '(e.g., "0.5in", "1cm", "100px")',
-    description: 'Set the bottom margin for the page'
-  },
-  {
-    type: 'string',
-    name: 'marginLeft',
-    label: 'page-margin-left',
-    placeholder: '(e.g., "0.5in", "1cm", "100px")',
-    description: 'Set the left margin for the page'
-  },
-  {
-    type: 'string',
-    name: 'marginRight',
-    label: 'page-margin-right',
-    placeholder: '(e.g., "0.5in", "1cm", "100px")',
-    description: 'Set the right margin for the page'
-  },
-  {
-    type: 'number',
-    name: 'scale',
-    label: 'page-scale',
-    defaultValue: 1,
-    description: 'Set the scale of the page content (default is 1)'
-  },
-  {
-    type: 'boolean',
-    name: 'printBackground',
-    label: 'print-background',
-    defaultValue: true,
-    description: 'Include background graphics when printing the page'
-  },
-  {
-    type: 'boolean',
-    name: 'landscape',
-    label: 'landscape',
-    defaultValue: false,
-    description: 'Print the PDF in landscape orientation'
-  },
-  {
-    type: 'boolean',
-    name: 'preferCSSPageSize',
-    label: 'prefer-css-page-size',
-    defaultValue: false,
-    description: 'Whether to prefer the CSS-defined page size over the given width and height'
   }
 ]
 

package/server/engine/task/headless-pdf-capture-markdown.ts

@@ -0,0 +1,41 @@
+import { TaskRegistry } from '@things-factory/integration-base'
+import { access } from '@things-factory/utils'
+import { marked } from 'marked'
+
+import { PDFCaptureUtil, getCommonParameterSpec } from './pdf-capture-util'
+
+export async function HeadlessPDFCaptureMarkdown(step, context) {
+  const pdfUtil = new PDFCaptureUtil(context)
+  await pdfUtil.initBrowser(step.connection)
+
+  try {
+    const { accessor, markdownContent } = step.params
+    const templateInput = access(accessor, context.data)
+
+    const renderedMarkdown = pdfUtil.renderTemplate(markdownContent, templateInput)
+    const htmlContent = marked(renderedMarkdown)
+
+    await pdfUtil.processPageAndGeneratePDF(step.params, htmlContent)
+
+    return {
+      data: context.__headless_pdf
+    }
+  } catch (error) {
+    throw error
+  } finally {
+    await pdfUtil.closeBrowser()
+  }
+}
+
+HeadlessPDFCaptureMarkdown.parameterSpec = [
+  ...getCommonParameterSpec(),
+  {
+    type: 'textarea',
+    name: 'markdownContent',
+    label: 'markdown-content'
+  }
+]
+
+HeadlessPDFCaptureMarkdown.help = 'integration/task/headless-pdf-capture-markdown'
+
+TaskRegistry.registerTaskHandler('headless-pdf-capture-markdown', HeadlessPDFCaptureMarkdown)