@thegetty/quire-cli 1.0.0-rc.44 → 1.0.0-rc.46

package/src/lib/pdf/index.js

@@ -1,145 +1,42 @@
 import { dynamicImport } from '#helpers/os-utils.js'
-import which from '#helpers/which.js'
 import { fileURLToPath } from 'node:url'
 import path from 'node:path'
-import fs from 'fs-extra'
-import paths, { loadProjectConfig } from '#lib/project/index.js'
-import reporter from '#lib/reporter/index.js'
-import { InvalidPdfLibraryError, MissingBuildOutputError } from '#src/errors/index.js'
-import ENGINE_METADATA from './engines.js'
-import createDebug from '#debug'
-import { ENGINES } from './schema.js'
-
-export { ENGINES }
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
-const debug = createDebug('lib:pdf')
-
 /**
- * Resolve the PDF library implementation
- *
- * @param {string} name - Library name to resolve
- * @returns {Object} Resolved engine with absolute module path
- * @throws {InvalidPdfLibraryError} When library name is not recognized
+ * A façade delegation module for PDF generation libraries
  */
-function resolveLibrary(name) {
+export default async (name = 'pagedjs', options = {}) => {
+  const lib = { name, options, path }
+
   const normalizedName = name.replace(/[-_.\s]/g, '').toLowerCase()
 
   switch (normalizedName) {
     case 'paged':
-    case 'pagedjs':
-      return { ...ENGINE_METADATA.pagedjs, path: path.join(__dirname, ENGINE_METADATA.pagedjs.module) }
+    case 'pagedjs': {
+      lib.name = 'Paged.js'
+      lib.options = options
+      lib.path = path.join(__dirname, 'paged.js')
+      break
+    }
     case 'prince':
-    case 'princexml':
-      return { ...ENGINE_METADATA.prince, path: path.join(__dirname, ENGINE_METADATA.prince.module) }
+    case 'princexml': {
+      lib.name = 'Prince'
+      lib.options = options
+      lib.path = path.join(__dirname, 'prince.js')
+      break
+    }
     default:
-      throw new InvalidPdfLibraryError(name)
-  }
-}
-
-/**
- * Check if the required binary for an engine is available
- *
- * @param {Object} engine - Engine definition from ENGINES
- * @throws {ToolNotFoundError} When required binary is not in PATH
- */
-function checkEngineAvailable(engine) {
-  if (!engine.requiresBinary) {
-    return // No binary required (e.g., pagedjs uses Node.js)
-  }
-
-  const result = which(engine.requiresBinary, engine.toolInfo)
-  debug('found %s at %s', engine.requiresBinary, result)
-}
-
-/**
- * Construct the default output path for the PDF from project config
- *
- * @param {string} projectRoot - Project root directory
- * @param {string} outputDir - Build output directory
- * @param {Object} [pdfConfig] - PDF configuration from project config
- * @param {string} libName - Library name for fallback filename
- * @returns {string} Default output path
- */
-function getDefaultOutputPath(projectRoot, outputDir, pdfConfig, libName) {
-  if (pdfConfig) {
-    return path.join(projectRoot, outputDir, pdfConfig.outputDir, `${pdfConfig.filename}.pdf`)
-  }
-  return path.join(projectRoot, `${libName}.pdf`)
-}
-
-/**
- * Resolve the final output path, allowing CLI override
- *
- * @param {string} [userOutput] - User-specified output path from --output option
- * @param {string} defaultPath - Default path from project config
- * @param {string} projectRoot - Project root for resolving relative paths
- * @returns {string} Resolved absolute output path
- */
-function resolveOutputPath(userOutput, defaultPath, projectRoot) {
-  if (!userOutput) {
-    return defaultPath
-  }
-
-  // Resolve relative paths against project root
-  if (path.isAbsolute(userOutput)) {
-    return userOutput
-  }
-
-  return path.join(projectRoot, userOutput)
-}
-
-/**
- * Generate a PDF from the built publication
- *
- * @param {Object} options - Generation options
- * @param {string} [options.lib='pagedjs'] - PDF library to use ('pagedjs' or 'prince')
- * @param {string} [options.output] - Custom output path (overrides project config)
- * @param {boolean} [options.debug] - Enable debug output
- * @returns {Promise<string>} Absolute path to the generated PDF file
- */
-export default async function generatePdf(options = {}) {
-  const libName = options.lib || 'pagedjs'
-  const lib = resolveLibrary(libName)
-
-  debug('resolved library: %s → %s', libName, lib.name)
-
-  // Check engine availability BEFORE starting reporter (fail fast with clean error)
-  checkEngineAvailable(lib)
-
-  const projectRoot = paths.getProjectRoot()
-  const buildOutputDir = paths.getOutputDir()
-  const config = await loadProjectConfig(projectRoot)
-
-  const publicationInput = path.join(projectRoot, buildOutputDir, 'pdf.html')
-  const coversInput = path.join(projectRoot, buildOutputDir, 'pdf-covers.html')
-
-  debug('input: %s', publicationInput)
-  debug('covers: %s', coversInput)
-
-  if (!fs.existsSync(publicationInput)) {
-    throw new MissingBuildOutputError('pdf.html', publicationInput)
+      console.error(`[CLI:lib/pdf] Unrecognized PDF library '${name}'`)
+      return
   }
 
-  const defaultPath = getDefaultOutputPath(projectRoot, buildOutputDir, config.pdf, libName)
-  const pdfPath = resolveOutputPath(options.output, defaultPath, projectRoot)
-  debug('output: %s (user: %s, default: %s)', pdfPath, options.output || 'none', defaultPath)
-
   const { default: pdfLib } = await dynamicImport(lib.path)
 
-  reporter.start(`Generating PDF using ${lib.name}...`, { showElapsed: true })
-  reporter.detail(`Input: ${publicationInput}`)
-  reporter.detail(`Output: ${pdfPath}`)
-
-  try {
-    await pdfLib(publicationInput, coversInput, pdfPath, { ...options, pdfConfig: config.pdf })
-    reporter.succeed(`PDF saved to ${pdfPath}`)
-  } catch (error) {
-    reporter.fail(`PDF generation failed`)
-    throw error
+  return async (publicationInput, coversInput, output) => {
+    console.info(`[CLI:lib/pdf] generating PDF using ${lib.name}`)
+    return await pdfLib(publicationInput, coversInput, output, lib.options)
   }
-
-  return pdfPath
 }

package/src/lib/pdf/paged.js

@@ -4,39 +4,25 @@ import fs from 'fs-extra'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-import processManager from '#lib/process/manager.js'
-import reporter from '#lib/reporter/index.js'
 import { splitPdf } from './split.js'
-import { PdfGenerationError } from '#src/errors/index.js'
-import ENGINES from './engines.js'
-import createDebug from '#debug'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
-const debug = createDebug('lib:pdf:paged')
-
-/** Re-export engine metadata from central registry */
-export const metadata = ENGINES.pagedjs
+// FIXME: This module swallows errors currently.
 
 /**
- * A façade module for interacting with Paged.js and pagedjs-cli
+ * A façade module for interacting with Paged.js and pagedjs-cli  
  * @see https://gitlab.coko.foundation/pagedjs/
- *
- * @param {string} publicationInput - Path to the publication HTML file
- * @param {string} coversInput - Path to the covers HTML file
- * @param {string} pdfPath - Path where the PDF should be written
- * @param {Object} [options={}] - Generation options
- * @returns {Promise<string>} Path to the generated PDF file
  */
-export default async (publicationInput, coversInput, pdfPath, options = {}) => {
+export default async (publicationInput, coversInput, output, options = {}) => {
   /**
    * Configure the Paged.js Printer options
    * @see https://gitlab.coko.foundation/pagedjs/pagedjs-cli/-/blob/main/src/cli.js
    */
 
   let additionalScripts = []
-
+  
   const { pdfConfig } = options
 
   additionalScripts.push( path.join(__dirname, 'pagedPlugin.js') )
@@ -49,35 +35,25 @@ export default async (publicationInput, coversInput, pdfPath, options = {}) => {
     additionalScripts,
   }
 
-  debug('printer options: %O', printerOptions)
+  if (options.debug) {
+    const optionsOutput = JSON.stringify(printerOptions, null, 2)
+    console.debug(`[CLI:lib/pdf/pagedjs] Printer options\n${optionsOutput}`)
+  }
 
   let printer = new Printer(printerOptions)
 
-  // Register cleanup handler for graceful shutdown
-  processManager.onShutdown('pagedjs', () => {
-    debug('closing printer')
-    printer.close()
-  })
-
-  printer.on('page', (page, pageElement, breakToken) => {
+  printer.on('page', (page,pageElement,breakToken) => {
     if (page.position === 0) {
-      debug('paged.js loaded')
-    }
+      console.info(`[CLI:lib/pdf/pagedjs] loaded`)
+    } 
   })
 
   printer.on('rendered', (msg) => {
-    debug('rendered: %s', msg)
+    console.info(`[CLI:lib/pdf/pagedjs] ${msg}`)
   })
 
   printer.on('postprocessing', () => {
-    debug('post-processing')
-  })
-
-  // Capture browser console messages for debugging
-  printer.on('console', (type, ...args) => {
-    if (type === 'warning' || type === 'error') {
-      debug('browser %s: %s', type, args.join(' '))
-    }
+    console.info(`[CLI:lib/pdf/pagedjs] post-processing`)
   })
 
   /**
@@ -85,31 +61,29 @@ export default async (publicationInput, coversInput, pdfPath, options = {}) => {
    * @see
    *
    * @todo verify options before setting them
+   * @todo catch errors thrown by the printer
    */
   const pdfOptions = {
     outlineTags: options.outlineTags || ['h1'],
   }
 
-  debug('pdf options: %O', pdfOptions)
-
-  debug('printing %s', publicationInput)
-  reporter.update('Rendering PDF...')
+  if (options.debug) {
+    const optionsOutput = JSON.stringify(pdfOptions, null, 2)
+    console.debug(`[CLI:lib/pdf/pagedjs] PDF options\n${optionsOutput}`)
+  }
 
-  let file
   try {
-    file = await printer.pdf(publicationInput, pdfOptions)
-  } catch (error) {
-    throw new PdfGenerationError('Paged.js', 'PDF rendering', error.message)
-  }
+    console.info(`[CLI:lib/pdf/pagedjs] printing ${publicationInput}`)
 
-  let pageMap
+    const file = await printer.pdf(publicationInput, pdfOptions)
+      .catch((error) => console.error(error))
 
-  // Now it's printed, create the pageMap by running JS in the printer's context
-  let coversFile
+    let pageMap
 
-  debug('extracting page map')
-  reporter.update('Extracting page map...')
-  try {
+    // Now it's printed, create the pageMap by running JS in the printer's context
+    let coversFile
+
+    console.info(`[CLI:lib/pdf/pagedjs] generating page map`)
     const pages = await printer.browser.pages()
 
     if (pages.length > 0) {
@@ -118,24 +92,15 @@ export default async (publicationInput, coversInput, pdfPath, options = {}) => {
         return window.pageMap ?? {} // eslint-disable-line no-undef
       })
     }
-  } catch (error) {
-    throw new PdfGenerationError('Paged.js', 'page map extraction', error.message)
-  }
 
-  if ( pdfConfig?.pagePDF?.coverPage===true && fs.existsSync(coversInput) ) {
-    debug('printing covers %s', coversInput)
-    reporter.update('Rendering cover pages...')
+    if ( pdfConfig?.pagePDF?.coverPage===true && fs.existsSync(coversInput) ) {
+      console.info(`[CLI:lib/pdf/pagedjs] printing ${coversInput}`)
 
-    const coverPrinter = new Printer(printerOptions)
+      const coverPrinter = new Printer(printerOptions)
 
-    try {
       coversFile = await coverPrinter.pdf(coversInput, pdfOptions)
-    } catch (error) {
-      coverPrinter.close()
-      throw new PdfGenerationError('Paged.js', 'cover PDF rendering', error.message)
-    }
+        .catch((error) => console.error(error))
 
-    try {
       const coverPages = await coverPrinter.browser.pages()
 
       if (coverPages.length > 0) {
@@ -146,53 +111,40 @@ export default async (publicationInput, coversInput, pdfPath, options = {}) => {
 
         Object.values(coversMap).forEach( cov => {
           if (cov.id in pageMap) {
-            pageMap[cov.id].coverPage = cov.startPage
+            pageMap[cov.id].coverPage = cov.startPage           
           }
         })
-      }
-    } catch (error) {
-      coverPrinter.close()
-      throw new PdfGenerationError('Paged.js', 'cover page map extraction', error.message)
-    }
 
-    coverPrinter.close()
-  }
+      }
 
-  // Leave the printer open for debug logs
-  if (!options.debug) {
-    printer.close()
-  }
+      coverPrinter.close()
+    }      
 
-  // Unregister cleanup handler
-  processManager.onShutdownComplete('pagedjs')
+    // Leave the printer open for debug logs
+    if (!options.debug) {
+      printer.close()    
+    }
 
-  if (file && pdfPath) {
-    debug('writing files')
-    reporter.update('Writing PDF files...')
+    if (file && output) {
+      console.info(`[CLI:lib/pdf/pagedjs] writing file(s)`)
 
-    try {
-      const { dir } = path.parse(pdfPath)
-      if (!fs.existsSync(dir)) {
+      const { dir } = path.parse(output)
+      if (!fs.existsSync(dir)) { 
         fs.mkdirsSync(dir)
       }
 
-      await fs.promises.writeFile(pdfPath, file)
-    } catch (error) {
-      throw new PdfGenerationError('Paged.js', 'PDF file write', error.message)
-    }
+      await fs.promises.writeFile(output, file)
+        .catch((error) => console.error(error))
 
-    try {
-      const files = await splitPdf(file, coversFile, pageMap, options.pdfConfig)
+      const files = await splitPdf(file,coversFile,pageMap,options.pdfConfig)
 
-      await Promise.all(
-        Object.entries(files).map(([filePath, pagePdf]) =>
-          fs.promises.writeFile(filePath, pagePdf)
-        )
-      )
-    } catch (error) {
-      throw new PdfGenerationError('Paged.js', 'PDF splitting', error.message)
+      Object.entries(files).forEach( async ([filePath,pagePdf]) => {
+        await fs.promises.writeFile(filePath,pagePdf)
+          .catch((error) => console.error(error))
+      })
     }
-  }
 
-  return pdfPath
+  } catch (ERR_FILE_NOT_FOUND) {
+    console.error(`[CLI:lib/pdf/pagedjs] file not found ${publicationInput}`)
+  }
 }

package/src/lib/pdf/prince.js

@@ -5,53 +5,33 @@ import { fileURLToPath } from 'node:url'
 import { splitPdf } from './split.js'
 import fs from 'fs-extra'
 
-import processManager from '#lib/process/manager.js'
-import reporter from '#lib/reporter/index.js'
-import { PdfGenerationError } from '#src/errors/index.js'
-import createDebug from '#debug'
-import ENGINES from './engines.js'
+import which from '#helpers/which.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
-const debug = createDebug('lib:pdf:prince')
-
-/** Re-export engine metadata from central registry */
-export const metadata = ENGINES.prince
-
 /**
  * A façade module for interacting with the Prince CLI.
  * @see https://www.princexml.com/doc/command-line/
- *
- * Prince availability is checked by the parent façade (lib/pdf/index.js)
- * before this module is loaded, so we can assume prince is in PATH.
- *
- * @param {string} publicationInput - Path to the publication HTML file
- * @param {string} coversInput - Path to the covers HTML file
- * @param {string} pdfPath - Path where the PDF should be written
- * @param {Object} [options={}] - Generation options
- * @returns {Promise<string>} Path to the generated PDF file
  */
-export default async (publicationInput, coversInput, pdfPath, options = {}) => {
-  debug('input: %s', publicationInput)
-  debug('covers: %s', coversInput)
-  debug('output: %s', pdfPath)
+export default async (publicationInput, coversInput, output, options = {}) => {
+  which('prince')
 
   /**
    * @see https://www.princexml.com/doc/command-line/#options
    */
-
+  
   const { pdfConfig } = options
 
   // These options run once to get the map pages to essays
   const pageMapOptions = [
     `--script=${ path.join(__dirname, 'princePlugin.js') }`,
-    `--output=${pdfPath}`,
+    `--output=${output}`,
   ]
 
   // These options are for the actual user-facing PDF
   const cmdOptions = [
-    `--output=${pdfPath}`,
+    `--output=${output}`,
     `--pdf-profile=PDF/UA-1`,
   ]
 
@@ -59,118 +39,60 @@ export default async (publicationInput, coversInput, pdfPath, options = {}) => {
     pageMapOptions.push('--debug')
     cmdOptions.push('--debug')
   }
-
+  
   if (options.verbose) {
     pageMapOptions.push('--verbose')
     cmdOptions.push('--verbose')
   }
 
-  debug('page map options: %O', pageMapOptions)
-  debug('cmd options: %O', cmdOptions)
-
-  try {
-    const { dir } = path.parse(pdfPath)
-    if (!fs.existsSync(dir)) {
-      fs.mkdirsSync(dir)
-    }
-  } catch (error) {
-    throw new PdfGenerationError('Prince', 'output directory creation', error.message)
+  const { dir } = path.parse(output)
+  if (!fs.existsSync(dir)) { 
+    fs.mkdirsSync(dir)
   }
-
-  // Execute page map extraction (renders PDF with script to extract page info, then discards it)
-  debug('analyzing document structure')
-  reporter.update('Analyzing document structure...')
+  
+  // Execute the page mapping PDF build  
   let pageMap = {}
   try {
-    const pageMapOutput = await execa('prince', [...pageMapOptions, publicationInput], {
-      cancelSignal: processManager.signal,
-      gracefulCancel: true
-    })
+    const pageMapOutput = await execa('prince', [...pageMapOptions, publicationInput])  
     pageMap = JSON.parse(pageMapOutput.stdout)
-  } catch (error) {
-    if (error.isCanceled) {
-      debug('page map generation cancelled')
-      reporter.warn('PDF generation cancelled')
-      return
-    }
-    throw new PdfGenerationError('Prince', 'page map generation', error.stderr)
+  } catch (err) {
+    console.error(`Generating the PDF page map failed with the error ${err.stderr}`)
+    process.exit(1)
   }
-  debug('page map generated: %d entries', Object.keys(pageMap).length)
 
   let coversData
 
   if (pdfConfig?.pagePDF?.coverPage === true && fs.existsSync(coversInput)) {
-    debug('generating cover page map')
-    reporter.update('Rendering cover pages...')
-    try {
-      const coversPageMapOutput = await execa('prince', [...pageMapOptions, coversInput], {
-        cancelSignal: processManager.signal,
-        gracefulCancel: true
-      })
-      const coversMap = JSON.parse(coversPageMapOutput.stdout)
-
-      for (const pageId of Object.keys(coversMap)) {
-        if (pageId in pageMap) {
-          pageMap[pageId].coverPage = coversMap[pageId].startPage
-        }
-      }
 
-      coversData = fs.readFileSync(pdfPath, null)
-    } catch (error) {
-      if (error.isCanceled) {
-        debug('cover page map generation cancelled')
-        reporter.warn('PDF generation cancelled')
-        return
+    const coversPageMapOutput = await execa('prince', [...pageMapOptions, coversInput])
+    const coversMap = JSON.parse(coversPageMapOutput.stdout)
+
+    for (const pageId of Object.keys(coversMap))  {
+      if (pageId in pageMap) {
+        pageMap[pageId].coverPage = coversMap[pageId].startPage       
       }
-      throw new PdfGenerationError('Prince', 'cover page map generation', error.stderr || error.message)
     }
-    debug('cover page map merged')
-  }
 
-  debug('printing PDF')
-  reporter.update('Rendering PDF...')
+    coversData = fs.readFileSync(output,null)
 
-  try {
-    const { stderr } = await execa('prince', [...cmdOptions, publicationInput], {
-      cancelSignal: processManager.signal,
-      gracefulCancel: true
-    })
-    // Prince may emit warnings to stderr even on success (CSS warnings, font substitutions, etc.)
-    if (stderr) {
-      debug('prince warnings: %s', stderr)
-    }
-  } catch (error) {
-    if (error.isCanceled) {
-      debug('PDF printing cancelled')
-      reporter.warn('PDF generation cancelled')
-      return
-    }
-    throw new PdfGenerationError('Prince', 'PDF printing', error.stderr)
   }
-  debug('PDF printed')
 
-  let pdfData
-  try {
-    pdfData = fs.readFileSync(pdfPath, null)
-  } catch (error) {
-    throw new PdfGenerationError('Prince', 'PDF file read', error.message)
-  }
+  let stderror,stdout
 
-  debug('splitting PDF')
-  reporter.update('Writing PDF files...')
   try {
-    const files = await splitPdf(pdfData, coversData, pageMap, pdfConfig)
-
-    debug('writing %d section files', Object.keys(files).length)
-    await Promise.all(
-      Object.entries(files).map(([filePath, pagePdf]) =>
-        fs.promises.writeFile(filePath, pagePdf)
-      )
-    )
-  } catch (error) {
-    throw new PdfGenerationError('Prince', 'PDF splitting', error.message)
+    ({ stderror, stdout } = await execa('prince', [...cmdOptions, publicationInput]))
+  } catch (err) {
+    console.error(`Printing the PDF failed with the error ${err.stderr}`)
+    process.exit(1)
   }
 
-  debug('complete')
-  return pdfPath
+  const pdfData = fs.readFileSync(output,null)
+  
+  let files = await splitPdf(pdfData,coversData,pageMap,pdfConfig)
+  Object.entries(files).forEach( async ([filePath,pagePdf]) => {
+    await fs.promises.writeFile(filePath,pagePdf)
+      .catch((error) => console.error(error))
+  })
+
+  return { stderror, stdout }
 }