@things-factory/integration-headless 8.0.0-beta.0 → 8.0.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-headless",
-  "version": "8.0.0-beta.0",
+  "version": "8.0.0-beta.4",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
@@ -22,12 +22,12 @@
     "clean": "npm run clean:server"
   },
   "dependencies": {
-    "@things-factory/attachment-base": "^8.0.0-beta.0",
-    "@things-factory/board-service": "^8.0.0-beta.0",
-    "@things-factory/integration-base": "^8.0.0-beta.0",
-    "@things-factory/shell": "^8.0.0-beta.0",
+    "@things-factory/attachment-base": "^8.0.0-beta.4",
+    "@things-factory/board-service": "^8.0.0-beta.4",
+    "@things-factory/integration-base": "^8.0.0-beta.4",
+    "@things-factory/shell": "^8.0.0-beta.4",
     "ejs": "^3.1.10",
     "pdf-lib": "^1.17.1"
   },
-  "gitHead": "add6fb8224b2cb19cbea47bed6a5ecb0424c9a28"
+  "gitHead": "d83d12ed4ba07177dff1dac26e37be347d156b43"
 }

package/server/engine/index.ts

@@ -1 +0,0 @@
-import './task'

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

@@ -1,182 +0,0 @@
-import { TaskRegistry } from '@things-factory/integration-base'
-import { PDFCaptureUtil, getCommonParameterSpec } from './pdf-capture-util'
-import { BoardFunc } from '@things-factory/board-service'
-import { access } from '@things-factory/utils'
-
-const PAGE_FORMATS = {
-  A4: { width: 595.28, height: 841.89 },
-  A3: { width: 841.89, height: 1190.55 },
-  Letter: { width: 612, height: 792 },
-  Legal: { width: 612, height: 1008 }
-}
-
-function convertToPixels(value: string): number {
-  const dpi = 96 // PDF에서 기본적으로 사용하는 DPI
-
-  if (value.endsWith('px')) {
-    return parseFloat(value)
-  } else if (value.endsWith('in')) {
-    const inches = parseFloat(value)
-    return inches * dpi
-  } else if (value.endsWith('cm')) {
-    const cm = parseFloat(value)
-    return cm * (dpi / 2.54)
-  }
-
-  return 0
-}
-
-export async function HeadlessPDFCaptureBoard(step, context) {
-  const pdfUtil = new PDFCaptureUtil(context)
-  await pdfUtil.initBrowser(step.connection)
-
-  try {
-    var {
-      board: boardObject,
-      accessor,
-      boardAccessor,
-      draft,
-      format = 'A4',
-      width,
-      height,
-      landscape,
-      marginLeft = 0,
-      marginRight = 0,
-      marginTop = 0,
-      marginBottom = 0
-    } = step.params
-    var { domain, data, user, logger } = context
-
-    const boardId = boardAccessor ? access(boardAccessor, data) : boardObject?.id
-
-    if (!boardId) {
-      throw new Error('The board property must be set')
-    }
-
-    const boardInput = access(accessor, data)
-
-    const { model, base } = await BoardFunc.headlessModel({ domain, id: boardId }, draft)
-    const [fontsToUse, fontStyles] = await BoardFunc.fonts(domain)
-
-    model.fonts = fontsToUse
-    model.fontStyles = fontStyles
-
-    var widthN = width ? convertToPixels(width) : 0
-    var heightN = height ? convertToPixels(height) : 0
-
-    if (!widthN && !heightN && PAGE_FORMATS[format]) {
-      const pageDimensions = PAGE_FORMATS[format]
-      widthN = pageDimensions.width * (96 / 72)
-      heightN = pageDimensions.height * (96 / 72)
-    }
-
-    if (landscape && widthN && heightN) {
-      ;[widthN, heightN] = [heightN, widthN]
-    }
-
-    marginLeft = convertToPixels(marginLeft)
-    marginTop = convertToPixels(marginTop)
-    marginBottom = convertToPixels(marginBottom)
-    marginRight = convertToPixels(marginRight)
-
-    const contentWidth = widthN - marginLeft - marginRight
-    const contentHeight = heightN - marginTop - marginBottom
-
-    const page = await pdfUtil.browser!.newPage()
-
-    await page.setViewport({ width: Math.round(contentWidth), height: Math.round(contentHeight) })
-    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()
-
-    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.goto(url)
-
-    await page.evaluate(data => {
-      //@ts-ignore
-      s.data = data
-      return new Promise(resolve => {
-        requestAnimationFrame(() => resolve(0))
-      })
-    }, boardInput)
-
-    await pdfUtil.processPageAndGeneratePDF(step.params, null, page)
-
-    return {
-      data: context.__headless_pdf
-    }
-  } catch (error) {
-    throw error
-  } finally {
-    await pdfUtil.closeBrowser()
-  }
-}
-
-HeadlessPDFCaptureBoard.parameterSpec = [
-  ...getCommonParameterSpec(),
-  {
-    type: 'string',
-    name: 'boardAccessor',
-    label: 'board-accessor'
-  },
-  {
-    type: 'resource-object',
-    name: 'board',
-    label: 'board',
-    property: {
-      queryName: 'boards'
-    }
-  },
-  {
-    type: 'boolean',
-    name: 'draft',
-    label: 'board-draft',
-    defaultValue: false,
-    description: 'Set whether to get the current working version or the last released version'
-  }
-]
-
-HeadlessPDFCaptureBoard.help = 'integration/task/headless-pdf-capture-board'
-
-TaskRegistry.registerTaskHandler('headless-pdf-capture-board', HeadlessPDFCaptureBoard)

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

@@ -1,47 +0,0 @@
-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, markdownContentAccessor } = step.params
-    const templateInput = access(accessor, context.data)
-    const markdownTemplate = markdownContentAccessor ? access(markdownContentAccessor, context.data) : markdownContent
-
-    const renderedMarkdown = pdfUtil.renderTemplate(markdownTemplate, 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: 'scenario-step-input',
-    name: 'markdownContentAccessor',
-    label: 'markdown-content-accessor'
-  },
-  {
-    type: 'textarea',
-    name: 'markdownContent',
-    label: 'markdown-content'
-  }
-]
-
-HeadlessPDFCaptureMarkdown.help = 'integration/task/headless-pdf-capture-markdown'
-
-TaskRegistry.registerTaskHandler('headless-pdf-capture-markdown', HeadlessPDFCaptureMarkdown)

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

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

package/server/engine/task/headless-pdf-open.ts

@@ -1,98 +0,0 @@
-import { PDFDocument } from 'pdf-lib'
-import { TaskRegistry } from '@things-factory/integration-base'
-import { access } from '@things-factory/utils'
-import { PDFCaptureUtil, getCommonParameterSpec } from './pdf-capture-util'
-
-async function HeadlessPDFOpen(step, context) {
-  const { connection: connectionName, params: stepOptions } = step
-  const { accessor, coverPage, lastPage, header, footer, watermark, fileName } = stepOptions || {}
-
-  const { data } = context
-
-  // Create a new PDF document using pdf-lib
-  const pdfDoc = await PDFDocument.create()
-
-  try {
-    const fileNameEncoded = fileName ? new TextEncoder().encode(access(fileName, data)) : undefined
-
-    const pdfInfo = {
-      pdfDoc,
-      watermark,
-      fileName: fileNameEncoded,
-      pageCount: 0
-    } as any
-    context.__headless_pdf = pdfInfo
-
-    var pdfUtil = new PDFCaptureUtil(context)
-    await pdfUtil.initBrowser(connectionName)
-
-    const templateInput = access(accessor, data)
-
-    // Convert Cover Page to PDF and add it to the document (if provided)
-    if (coverPage) {
-      const renderedCoverPage = pdfUtil.renderTemplate(coverPage, templateInput)
-      await pdfUtil.processPageAndGeneratePDF(stepOptions, renderedCoverPage)
-    }
-
-    var lastPageBuffer
-
-    // Process Last Page (if provided) but add it later in the save task
-    if (lastPage) {
-      const renderedLastPage = pdfUtil.renderTemplate(lastPage, templateInput)
-      lastPageBuffer = await pdfUtil.generateLastPageBuffer(stepOptions, renderedLastPage)
-    }
-
-    pdfInfo.lastPageBuffer = lastPageBuffer
-    pdfInfo.pageCount = pdfDoc.getPageCount()
-    pdfInfo.header = header
-    pdfInfo.footer = footer
-
-    return {
-      data: pdfInfo
-    }
-  } catch (error) {
-    throw error
-  } finally {
-    await pdfUtil?.closeBrowser()
-  }
-}
-
-HeadlessPDFOpen.parameterSpec = [
-  ...getCommonParameterSpec(),
-  {
-    type: 'textarea',
-    name: 'coverPage',
-    label: 'pdf-cover-page'
-  },
-  {
-    type: 'textarea',
-    name: 'lastPage',
-    label: 'pdf-last-page'
-  },
-  {
-    type: 'string',
-    name: 'header',
-    label: 'header',
-    placeholder: 'Page <%= pageNumber %> of <%= totalPages %>'
-  },
-  {
-    type: 'string',
-    name: 'footer',
-    label: 'footer',
-    placeholder: 'Page <%= pageNumber %> of <%= totalPages %>'
-  },
-  {
-    type: 'string',
-    name: 'watermark',
-    label: 'watermark'
-  },
-  {
-    type: 'string',
-    name: 'fileName',
-    label: 'filename'
-  }
-]
-
-HeadlessPDFOpen.help = 'integration/task/headless-pdf-open'
-
-TaskRegistry.registerTaskHandler('headless-pdf-open', HeadlessPDFOpen)

package/server/engine/task/headless-pdf-save.ts

@@ -1,88 +0,0 @@
-import { PDFDocument } from 'pdf-lib'
-import { Readable } from 'stream'
-import { TaskRegistry } from '@things-factory/integration-base'
-import { Attachment, createAttachment } from '@things-factory/attachment-base'
-import { getRepository } from '@things-factory/shell'
-
-async function HeadlessPDFSave(step, context) {
-  const { domain, user, __headless_pdf } = context
-
-  if (!__headless_pdf || !__headless_pdf.pdfDoc) {
-    throw new Error(
-      'No PDF document found. Ensure that headless-pdf-open and headless-pdf-capture tasks are executed before saving.'
-    )
-  }
-
-  const pdfDoc = __headless_pdf.pdfDoc
-
-  // Add last page if it exists
-  if (__headless_pdf.lastPageBuffer) {
-    await appendLastPageToPDF(pdfDoc, __headless_pdf.lastPageBuffer)
-  }
-
-  const pdfBytes = await pdfDoc.save()
-  const finalFileName = generateFileName(__headless_pdf.fileName)
-
-  const savedAttachment = await savePDFToFile(pdfBytes, finalFileName, domain, user)
-  const attachment = await getAttachmentDetails(savedAttachment.id)
-
-  return {
-    data: {
-      id: attachment.id,
-      name: attachment.name,
-      path: attachment.path,
-      mimetype: attachment.mimetype,
-      refBy: attachment.refBy,
-      fullpath: attachment.fullpath
-    }
-  }
-}
-
-async function appendLastPageToPDF(pdfDoc, lastPageBuffer) {
-  const lastPageDoc = await PDFDocument.load(lastPageBuffer)
-  const copiedLastPages = await pdfDoc.copyPages(lastPageDoc, lastPageDoc.getPageIndices())
-  copiedLastPages.forEach(page => pdfDoc.addPage(page))
-}
-
-function generateFileName(fileName) {
-  return fileName || `document-${Date.now()}.pdf`
-}
-
-async function savePDFToFile(pdfBytes, finalFileName, domain, user) {
-  return await createAttachment(
-    null,
-    {
-      attachment: {
-        file: {
-          createReadStream: () =>
-            new Readable({
-              read() {
-                this.push(pdfBytes)
-                this.push(null)
-              }
-            }),
-          filename: finalFileName,
-          mimetype: 'application/pdf',
-          encoding: 'binary'
-        },
-        refType: 'headless-pdf-save',
-        refBy: 'pdf-published'
-      }
-    },
-    {
-      state: { domain, user }
-    }
-  )
-}
-
-async function getAttachmentDetails(attachmentId) {
-  return await getRepository(Attachment).findOne({
-    where: { id: attachmentId }
-  })
-}
-
-HeadlessPDFSave.parameterSpec = []
-
-HeadlessPDFSave.help = 'integration/task/headless-pdf-save'
-
-TaskRegistry.registerTaskHandler('headless-pdf-save', HeadlessPDFSave)

package/server/engine/task/index.ts

@@ -1,9 +0,0 @@
-import './headless-pdf-capture'
-import './headless-pdf-capture-markdown'
-import './headless-pdf-capture-board'
-import './headless-pdf-open'
-import './headless-pdf-save'
-import './pdf-capture-util'
-
-export * from './pdf-capture-util'
-export * from './headless-pdf-capture-board'

package/server/engine/task/pdf-capture-util.ts

@@ -1,336 +0,0 @@
-import * as ejs from 'ejs'
-import { ConnectionManager } from '@things-factory/integration-base'
-import { PDFDocument } from 'pdf-lib'
-import { Browser, Page } from 'puppeteer'
-import { Logger } from 'winston'
-
-interface StepOptions {
-  format?: string
-  width?: string
-  height?: string
-  marginTop?: string
-  marginBottom?: string
-  marginLeft?: string
-  marginRight?: string
-  scale?: number
-  printBackground?: boolean
-  landscape?: boolean
-  preferCSSPageSize?: boolean
-}
-
-interface PDFContext {
-  domain: any
-  data: any
-  logger: Logger
-  __headless_pdf: any
-}
-
-export class PDFCaptureUtil {
-  private context: PDFContext
-  private headlessConnection: {
-    acquireSessionPage: () => Promise<Page>
-    releasePage: (page: Page) => Promise<void>
-    acquireBrowser: () => Promise<Browser>
-    releaseBrowser: (browser: Browser) => Promise<void>
-  }
-
-  public browser: Browser | null = null
-
-  constructor(context: PDFContext) {
-    this.context = context
-  }
-
-  async initBrowser(connectionName: string) {
-    const { domain } = this.context
-    this.headlessConnection = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
-    this.browser = await this.headlessConnection.acquireBrowser()
-  }
-
-  async closeBrowser() {
-    if (this.browser) {
-      await this.browser.close()
-      this.headlessConnection.releaseBrowser(this.browser)
-    }
-  }
-
-  renderTemplate(template: string, data: any): string {
-    const { logger } = this.context
-    try {
-      return ejs.render(template, data)
-    } catch (error) {
-      logger.warn(`Template rendering error: ${error.message}`)
-      return template
-    }
-  }
-
-  async generatePDFContent(page: Page, pageOptions: any): Promise<PDFDocument> {
-    const contentBuffer = await page.pdf(pageOptions)
-    const contentPdfDoc = await PDFDocument.load(contentBuffer)
-    return contentPdfDoc
-  }
-
-  async appendPDFContentToDocument(pdfDoc: PDFDocument, contentPdfDoc: PDFDocument) {
-    const copiedPages = await pdfDoc.copyPages(contentPdfDoc, contentPdfDoc.getPageIndices())
-    copiedPages.forEach(page => pdfDoc.addPage(page))
-    this.context.__headless_pdf.pageCount += copiedPages.length
-  }
-
-  async processPageAndGeneratePDF(stepOptions: StepOptions, htmlContent: string, page?: Page) {
-    if (!this.browser) throw new Error('Browser not initialized. Call initBrowser() first.')
-
-    if (!page) {
-      page = page || (await this.browser.newPage())
-    }
-
-    if (htmlContent) {
-      // 페이지 컨텐츠 설정
-      await page.setContent(htmlContent, { waitUntil: 'networkidle0' }) // HTML 컨텐츠가 완전히 로드될 때까지 대기
-    }
-
-    // 페이지가 완전히 로드된 후에 워터마크와 머릿글 적용
-    const { __headless_pdf } = this.context
-    const { header, footer, watermark, landscape } = __headless_pdf
-
-    if (header || footer || watermark) {
-      await this.applyHeaderFooterWatermark(page, { header, footer, watermark, landscape, data: __headless_pdf })
-    }
-
-    const pageOptions = this.buildPageOptions(stepOptions)
-    const contentPdfDoc = await this.generatePDFContent(page, pageOptions)
-    await this.appendPDFContentToDocument(__headless_pdf.pdfDoc, contentPdfDoc)
-    await page.close()
-  }
-
-  buildPageOptions({
-    format,
-    width,
-    height,
-    marginTop,
-    marginBottom,
-    marginLeft,
-    marginRight,
-    scale,
-    printBackground,
-    landscape,
-    preferCSSPageSize
-  }: StepOptions): any {
-    if (preferCSSPageSize) {
-      width = undefined
-      height = undefined
-    }
-
-    return {
-      format,
-      width,
-      height,
-      margin: {
-        top: marginTop,
-        right: marginRight,
-        bottom: marginBottom,
-        left: marginLeft
-      },
-      scale,
-      printBackground,
-      landscape,
-      displayHeaderFooter: false,
-      preferCSSPageSize
-    }
-  }
-
-  async applyHeaderFooterWatermark(
-    page: Page,
-    {
-      header,
-      footer,
-      watermark,
-      landscape,
-      data
-    }: { header: string; footer: string; watermark: string; landscape: boolean; data: any }
-  ) {
-    await page.evaluate(
-      ({ header, footer, watermark, landscape, data }) => {
-        const setPositioning = (element: HTMLElement, position: 'header' | 'footer') => {
-          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'
-          element.style.zIndex = '1000'
-
-          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 = landscape ? '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: header && this.renderTemplate(header, data),
-        footer: footer && this.renderTemplate(footer, data),
-        watermark: watermark && this.renderTemplate(watermark, data),
-        landscape,
-        data
-      }
-    )
-  }
-
-  /**
-   * Generates a PDF buffer for the last page.
-   * @param stepOptions - Options used for generating the PDF.
-   * @param htmlContent - HTML content to be converted to PDF.
-   * @returns {Promise<Uint8Array>} - The generated PDF as a buffer.
-   */
-  async generateLastPageBuffer(stepOptions: StepOptions, htmlContent: string): Promise<Uint8Array> {
-    if (!this.browser) throw new Error('Browser not initialized. Call initBrowser() first.')
-
-    const page = await this.browser.newPage()
-
-    // 페이지에 HTML 콘텐츠를 설정합니다.
-    await page.setContent(htmlContent, { waitUntil: 'networkidle0' })
-
-    // 페이지가 완전히 로드된 후에 워터마크와 머릿글 적용
-    const { __headless_pdf } = this.context
-    const { header, footer, watermark, landscape } = __headless_pdf
-
-    if (header || footer || watermark) {
-      await this.applyHeaderFooterWatermark(page, { header, footer, watermark, landscape, data: __headless_pdf })
-    }
-
-    // 페이지 옵션 설정
-    const pageOptions = this.buildPageOptions(stepOptions)
-
-    // PDF를 생성하고 버퍼를 반환합니다.
-    const lastPageBuffer = await page.pdf(pageOptions)
-
-    // 페이지 닫기
-    await page.close()
-
-    return lastPageBuffer
-  }
-}
-
-export function getCommonParameterSpec() {
-  return [
-    {
-      type: 'scenario-step-input',
-      name: 'accessor',
-      label: 'accessor'
-    },
-    {
-      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/index.ts

@@ -1,3 +0,0 @@
-import './engine'
-
-export * from './engine/task'

package/server/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig-base.json",
-  "compilerOptions": {
-    "strict": false,
-    "module": "commonjs",
-    "outDir": "../dist-server",
-    "baseUrl": "./"
-  },
-  "include": ["./**/*"]
-}