isahaq-barcode 1.9.0 → 2.0.0

package/src/renderers/PDFRenderer.js

@@ -1,28 +1,22 @@
 /**
- * PDF Renderer - Renders barcodes as PDF
+ * PDF Renderer - Renders barcodes as PDF documents
+ *
+ * The barcode itself is encoded as a real symbology (see BarcodeEncoder) and
+ * embedded as a lossless PNG image, so the PDF is scannable.
  */
 
 const PDFDocument = require('pdfkit');
+const { BarcodeEncoder } = require('../encoders/BarcodeEncoder');
 
 class PDFRenderer {
   constructor() {
     this.defaultOptions = {
-      width: 2,
-      height: 100,
-      displayValue: true,
-      fontSize: 20,
-      textAlign: 'center',
-      textPosition: 'bottom',
-      textMargin: 2,
-      background: '#ffffff',
-      lineColor: '#000000',
-      margin: 10,
-      marginTop: 10,
-      marginBottom: 10,
-      marginLeft: 10,
-      marginRight: 10,
-      pageWidth: 612,
+      ...BarcodeEncoder.getDefaultOptions(),
+      pageWidth: 612, // US Letter at 72dpi
       pageHeight: 792,
+      pageSize: null, // e.g. 'A4' - takes precedence over pageWidth/pageHeight
+      fitToBarcode: false, // size the page to the barcode plus margins
+      title: null,
     };
   }
 
@@ -31,137 +25,93 @@ class PDFRenderer {
    * @param {string} data - The data to encode
    * @param {string} type - The barcode type
    * @param {Object} options - Render options
-   * @returns {Buffer} PDF buffer
+   * @returns {Promise<Buffer>} PDF buffer
    */
-  render(data, type, options = {}) {
-    try {
-      // Merge options with defaults
-      const renderOptions = { ...this.defaultOptions, ...options };
-
-      // Create PDF document
-      const doc = new PDFDocument({
-        size: [renderOptions.pageWidth, renderOptions.pageHeight],
-        margins: {
-          top: renderOptions.marginTop,
-          bottom: renderOptions.marginBottom,
-          left: renderOptions.marginLeft,
-          right: renderOptions.marginRight,
-        },
-      });
-
-      // Collect PDF data
-      const chunks = [];
-      doc.on('data', chunk => chunks.push(chunk));
-
-      return new Promise((resolve, reject) => {
-        doc.on('end', () => {
-          const pdfBuffer = Buffer.concat(chunks);
-          resolve(pdfBuffer);
-        });
+  async render(data, type, options = {}) {
+    const renderOptions = { ...this.defaultOptions, ...options };
 
-        doc.on('error', reject);
-
-        // Add barcode to PDF
-        this.addBarcodeToPDF(doc, data, type, renderOptions);
+    let png;
+    let dimensions;
+    try {
+      png = await BarcodeEncoder.toPng(data, type, renderOptions);
+      dimensions = readPngSize(png);
+    } catch (error) {
+      throw new Error(`PDF rendering failed: ${error.message}`);
+    }
 
-        // Finalize PDF
-        doc.end();
-      });
+    try {
+      return await this.buildDocument(png, dimensions, renderOptions);
     } catch (error) {
       throw new Error(`PDF rendering failed: ${error.message}`);
     }
   }
 
   /**
-   * Add barcode to PDF document
-   * @param {PDFDocument} doc - PDF document
-   * @param {string} data - The data to encode
-   * @param {string} type - The barcode type
+   * Build the PDF document around an encoded barcode image
+   * @param {Buffer} png - Encoded barcode as PNG
+   * @param {{width: number, height: number}} dimensions - Image size in pixels
    * @param {Object} options - Render options
+   * @returns {Promise<Buffer>} PDF buffer
    */
-  addBarcodeToPDF(doc, data, type, options) {
-    // Set background color
-    doc.rect(0, 0, options.pageWidth, options.pageHeight);
-    doc.fillColor(options.background);
-    doc.fill();
-
-    // Calculate position
-    const x = options.marginLeft;
-    const y = options.marginTop;
-
-    if (type === 'qrcode') {
-      this.addQRCodeToPDF(doc, data, x, y, options);
-    } else {
-      this.addLinearBarcodeToPDF(doc, data, type, x, y, options);
-    }
+  buildDocument(png, dimensions, options) {
+    const margins = {
+      top: fallbackNumber(options.marginTop, options.margin, 10),
+      bottom: fallbackNumber(options.marginBottom, options.margin, 10),
+      left: fallbackNumber(options.marginLeft, options.margin, 10),
+      right: fallbackNumber(options.marginRight, options.margin, 10),
+    };
 
-    // Add text if displayValue is true
-    if (options.displayValue) {
-      doc.fontSize(options.fontSize);
-      doc.fillColor(options.lineColor);
-      doc.text(data, x, y + options.height + options.textMargin, {
-        align: options.textAlign,
-      });
+    const pageSetup = options.fitToBarcode
+      ? {
+          size: [
+            dimensions.width + margins.left + margins.right,
+            dimensions.height + margins.top + margins.bottom,
+          ],
+        }
+      : {
+          size: options.pageSize || [options.pageWidth, options.pageHeight],
+        };
+
+    const doc = new PDFDocument({ ...pageSetup, margins, autoFirstPage: true });
+
+    if (options.title) {
+      doc.info.Title = options.title;
     }
-  }
 
-  /**
-   * Add QR Code to PDF
-   * @param {PDFDocument} doc - PDF document
-   * @param {string} data - The data to encode
-   * @param {number} x - X position
-   * @param {number} y - Y position
-   * @param {Object} options - Render options
-   */
-  addQRCodeToPDF(doc, data, x, y, options) {
-    // This is a simplified representation
-    // In a real implementation, you would use a QR code library
-    const size = 200;
-    const cellSize = 10;
-    const cells = size / cellSize;
-
-    // Draw QR code pattern
-    for (let row = 0; row < cells; row++) {
-      for (let col = 0; col < cells; col++) {
-        const shouldFill =
-          (data.charCodeAt((row * cells + col) % data.length) + row + col) %
-            2 ===
-          0;
-
-        if (shouldFill) {
-          doc.rect(x + col * cellSize, y + row * cellSize, cellSize, cellSize);
-          doc.fillColor(options.lineColor);
-          doc.fill();
+    const chunks = [];
+    doc.on('data', chunk => chunks.push(chunk));
+
+    return new Promise((resolve, reject) => {
+      doc.on('end', () => resolve(Buffer.concat(chunks)));
+      doc.on('error', reject);
+
+      try {
+        const pageWidth = doc.page.width;
+        const pageHeight = doc.page.height;
+        const availableWidth = pageWidth - margins.left - margins.right;
+        const availableHeight = pageHeight - margins.top - margins.bottom;
+
+        if (options.background) {
+          doc.rect(0, 0, pageWidth, pageHeight).fill(options.background);
         }
-      }
-    }
-  }
 
-  /**
-   * Add linear barcode to PDF
-   * @param {PDFDocument} doc - PDF document
-   * @param {string} data - The data to encode
-   * @param {string} type - The barcode type
-   * @param {number} x - X position
-   * @param {number} y - Y position
-   * @param {Object} options - Render options
-   */
-  addLinearBarcodeToPDF(doc, data, type, x, y, options) {
-    const barWidth = options.width || 2;
-    let currentX = x;
-
-    // Draw bars based on data
-    for (let i = 0; i < data.length; i++) {
-      const char = data.charCodeAt(i);
-      const barCount = (char % 5) + 1;
-
-      for (let j = 0; j < barCount; j++) {
-        doc.rect(currentX, y, barWidth, options.height);
-        doc.fillColor(options.lineColor);
-        doc.fill();
-        currentX += barWidth * 2;
+        // Never upscale - a barcode drawn larger than encoded loses crispness
+        const scale = Math.min(
+          1,
+          availableWidth / dimensions.width,
+          availableHeight / dimensions.height
+        );
+
+        doc.image(png, margins.left, margins.top, {
+          width: dimensions.width * scale,
+          height: dimensions.height * scale,
+        });
+
+        doc.end();
+      } catch (error) {
+        reject(error);
       }
-    }
+    });
   }
 
   /**
@@ -181,4 +131,32 @@ class PDFRenderer {
   }
 }
 
+/**
+ * Read the pixel dimensions out of a PNG buffer's IHDR chunk
+ * @param {Buffer} png - PNG buffer
+ * @returns {{width: number, height: number}} Dimensions
+ */
+function readPngSize(png) {
+  if (!Buffer.isBuffer(png) || png.length < 24) {
+    throw new Error('Encoded barcode is not a valid PNG buffer');
+  }
+
+  return { width: png.readUInt32BE(16), height: png.readUInt32BE(20) };
+}
+
+/**
+ * First finite number out of the candidates
+ * @param {...*} values - Candidate values
+ * @returns {number} The first usable number, or 0
+ */
+function fallbackNumber(...values) {
+  for (const value of values) {
+    const num = Number(value);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  return 0;
+}
+
 module.exports = PDFRenderer;

package/src/renderers/PNGRenderer.js

@@ -2,27 +2,11 @@
  * PNG Renderer - Renders barcodes as PNG images
  */
 
-const { createCanvas } = require('canvas');
-const JsBarcode = require('jsbarcode');
+const { BarcodeEncoder } = require('../encoders/BarcodeEncoder');
 
 class PNGRenderer {
   constructor() {
-    this.defaultOptions = {
-      width: 2,
-      height: 100,
-      displayValue: true,
-      fontSize: 20,
-      textAlign: 'center',
-      textPosition: 'bottom',
-      textMargin: 2,
-      background: '#ffffff',
-      lineColor: '#000000',
-      margin: 10,
-      marginTop: 10,
-      marginBottom: 10,
-      marginLeft: 10,
-      marginRight: 10,
-    };
+    this.defaultOptions = BarcodeEncoder.getDefaultOptions();
   }
 
   /**
@@ -30,79 +14,19 @@ class PNGRenderer {
    * @param {string} data - The data to encode
    * @param {string} type - The barcode type
    * @param {Object} options - Render options
-   * @returns {Buffer} PNG buffer
+   * @returns {Promise<Buffer>} PNG buffer
    */
-  render(data, type, options = {}) {
+  async render(data, type, options = {}) {
     try {
-      // Merge options with defaults
-      const renderOptions = { ...this.defaultOptions, ...options };
-
-      // Create canvas
-      const canvas = createCanvas(400, 200);
-      const ctx = canvas.getContext('2d');
-
-      // Set background
-      ctx.fillStyle = renderOptions.background;
-      ctx.fillRect(0, 0, canvas.width, canvas.height);
-
-      // Generate barcode using JsBarcode
-      JsBarcode(canvas, data, {
-        format: this.mapBarcodeType(type),
-        width: renderOptions.width,
-        height: renderOptions.height,
-        displayValue: renderOptions.displayValue,
-        fontSize: renderOptions.fontSize,
-        textAlign: renderOptions.textAlign,
-        textPosition: renderOptions.textPosition,
-        textMargin: renderOptions.textMargin,
-        background: renderOptions.background,
-        lineColor: renderOptions.lineColor,
-        margin: renderOptions.margin,
-        marginTop: renderOptions.marginTop,
-        marginBottom: renderOptions.marginBottom,
-        marginLeft: renderOptions.marginLeft,
-        marginRight: renderOptions.marginRight,
+      return await BarcodeEncoder.toPng(data, type, {
+        ...this.defaultOptions,
+        ...options,
       });
-
-      // Convert to PNG buffer
-      return canvas.toBuffer('image/png');
     } catch (error) {
       throw new Error(`PNG rendering failed: ${error.message}`);
     }
   }
 
-  /**
-   * Map barcode type to JsBarcode format
-   * @param {string} type - The barcode type
-   * @returns {string} JsBarcode format
-   */
-  mapBarcodeType(type) {
-    const typeMap = {
-      code128: 'CODE128',
-      code128a: 'CODE128A',
-      code128b: 'CODE128B',
-      code128c: 'CODE128C',
-      code128auto: 'CODE128',
-      code39: 'CODE39',
-      code39extended: 'CODE39',
-      code39checksum: 'CODE39',
-      code39auto: 'CODE39',
-      code93: 'CODE93',
-      ean13: 'EAN13',
-      ean8: 'EAN8',
-      upca: 'UPC',
-      upce: 'UPC',
-      codabar: 'codabar',
-      code11: 'CODE11',
-      msi: 'MSI',
-      pharmazentral: 'pharmazentral',
-      interleaved25: 'ITF',
-      standard25: 'STD25',
-    };
-
-    return typeMap[type] || 'CODE128';
-  }
-
   /**
    * Get default options
    * @returns {Object} Default options

package/src/renderers/RenderFormats.js

@@ -2,40 +2,75 @@
  * Render Formats - Supported output formats
  */
 
+const FORMAT_REGISTRY = {
+  png: {
+    name: 'PNG',
+    mimeType: 'image/png',
+    extension: '.png',
+    returns: 'Buffer',
+    description: 'Portable Network Graphics - Raster image format',
+  },
+  svg: {
+    name: 'SVG',
+    mimeType: 'image/svg+xml',
+    extension: '.svg',
+    returns: 'string',
+    description: 'Scalable Vector Graphics - Vector image format',
+  },
+  html: {
+    name: 'HTML',
+    mimeType: 'text/html',
+    extension: '.html',
+    returns: 'string',
+    description: 'HTML fragment wrapping an inline SVG barcode',
+  },
+  pdf: {
+    name: 'PDF',
+    mimeType: 'application/pdf',
+    extension: '.pdf',
+    returns: 'Buffer',
+    description: 'Portable Document Format - Document format',
+  },
+};
+
+const FORMATS = Object.keys(FORMAT_REGISTRY).reduce((acc, format) => {
+  acc[format.toUpperCase()] = format;
+  return acc;
+}, {});
+
 class RenderFormats {
-  static FORMATS = {
-    PNG: 'png',
-    SVG: 'svg',
-    HTML: 'html',
-    PDF: 'pdf',
-    JPG: 'jpg',
-    JPEG: 'jpeg',
-  };
+  static FORMATS = FORMATS;
 
-  static MIME_TYPES = {
-    png: 'image/png',
-    svg: 'image/svg+xml',
-    html: 'text/html',
-    pdf: 'application/pdf',
-    jpg: 'image/jpeg',
-    jpeg: 'image/jpeg',
-  };
+  static MIME_TYPES = Object.entries(FORMAT_REGISTRY).reduce(
+    (acc, [format, info]) => {
+      acc[format] = info.mimeType;
+      return acc;
+    },
+    {}
+  );
 
-  static EXTENSIONS = {
-    png: '.png',
-    svg: '.svg',
-    html: '.html',
-    pdf: '.pdf',
-    jpg: '.jpg',
-    jpeg: '.jpeg',
-  };
+  static EXTENSIONS = Object.entries(FORMAT_REGISTRY).reduce(
+    (acc, [format, info]) => {
+      acc[format] = info.extension;
+      return acc;
+    },
+    {}
+  );
 
   /**
    * Get all supported formats
-   * @returns {Array} Array of all formats
+   * @returns {string[]} Array of all formats
    */
   static getAll() {
-    return Object.values(this.FORMATS);
+    return Object.keys(FORMAT_REGISTRY);
+  }
+
+  /**
+   * Get all supported formats (alias of getAll)
+   * @returns {string[]} Array of all formats
+   */
+  static getFormats() {
+    return this.getAll();
   }
 
   /**
@@ -44,7 +79,7 @@ class RenderFormats {
    * @returns {boolean} True if valid
    */
   static isValid(format) {
-    return Object.values(this.FORMATS).includes(format);
+    return typeof format === 'string' && Object.hasOwn(FORMAT_REGISTRY, format);
   }
 
   /**
@@ -53,7 +88,9 @@ class RenderFormats {
    * @returns {string} MIME type
    */
   static getMimeType(format) {
-    return this.MIME_TYPES[format] || 'application/octet-stream';
+    return FORMAT_REGISTRY[format]
+      ? FORMAT_REGISTRY[format].mimeType
+      : 'application/octet-stream';
   }
 
   /**
@@ -62,7 +99,7 @@ class RenderFormats {
    * @returns {string} File extension
    */
   static getExtension(format) {
-    return this.EXTENSIONS[format] || '';
+    return FORMAT_REGISTRY[format] ? FORMAT_REGISTRY[format].extension : '';
   }
 
   /**
@@ -71,16 +108,30 @@ class RenderFormats {
    * @returns {string} Description
    */
   static getDescription(format) {
-    const descriptions = {
-      png: 'Portable Network Graphics - Raster image format',
-      svg: 'Scalable Vector Graphics - Vector image format',
-      html: 'HyperText Markup Language - Web page format',
-      pdf: 'Portable Document Format - Document format',
-      jpg: 'JPEG - Compressed raster image format',
-      jpeg: 'JPEG - Compressed raster image format',
-    };
+    return FORMAT_REGISTRY[format]
+      ? FORMAT_REGISTRY[format].description
+      : 'Unknown format';
+  }
+
+  /**
+   * Get full information about a format
+   * @param {string} format - The format
+   * @returns {Object|null} Format information, or null when unknown
+   */
+  static getFormatInfo(format) {
+    const info = FORMAT_REGISTRY[format];
+    if (!info) {
+      return null;
+    }
 
-    return descriptions[format] || 'Unknown format';
+    return {
+      format,
+      name: info.name,
+      mimeType: info.mimeType,
+      extension: info.extension,
+      returns: info.returns,
+      description: info.description,
+    };
   }
 }