isahaq-barcode 1.0.0

package/src/renderers/HTMLRenderer.js

@@ -0,0 +1,212 @@
+/**
+ * HTML Renderer - Renders barcodes as HTML
+ */
+
+class HTMLRenderer {
+  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,
+      className: 'barcode',
+      id: null,
+    };
+  }
+
+  /**
+   * Render a barcode as HTML
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {string} HTML string
+   */
+  render(data, type, options = {}) {
+    try {
+      // Merge options with defaults
+      const renderOptions = { ...this.defaultOptions, ...options };
+
+      // Generate HTML structure
+      const html = this.createHTMLStructure(data, type, renderOptions);
+      return html;
+    } catch (error) {
+      throw new Error(`HTML rendering failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create HTML structure for barcode
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {string} HTML string
+   */
+  createHTMLStructure(data, type, options) {
+    const containerId =
+      options.id ||
+      `barcode-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const containerClass = options.className || 'barcode';
+
+    let html = `<div id="${containerId}" class="${containerClass}" style="${this.getContainerStyles(
+      options
+    )}">`;
+
+    // Add barcode representation
+    if (type === 'qrcode') {
+      html += this.createQRCodeHTML(data, options);
+    } else {
+      html += this.createLinearBarcodeHTML(data, type, options);
+    }
+
+    // Add text if displayValue is true
+    if (options.displayValue) {
+      html += `<div class="barcode-text" style="${this.getTextStyles(
+        options
+      )}">${data}</div>`;
+    }
+
+    html += '</div>';
+
+    // Add CSS styles
+    html += this.getCSSStyles(containerId, options);
+
+    return html;
+  }
+
+  /**
+   * Create QR Code HTML representation
+   * @param {string} data - The data to encode
+   * @param {Object} options - Render options
+   * @returns {string} HTML content
+   */
+  createQRCodeHTML(data, 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;
+
+    let html = `<div class="qr-code" style="width: ${size}px; height: ${size}px; display: grid; grid-template-columns: repeat(${cells}, 1fr); gap: 1px; background: ${options.background}; padding: 10px;">`;
+
+    // Generate a simple pattern based on data
+    for (let i = 0; i < cells * cells; i++) {
+      const shouldFill = (data.charCodeAt(i % data.length) + i) % 2 === 0;
+      const color = shouldFill ? options.lineColor : options.background;
+      html += `<div style="background-color: ${color}; width: 100%; height: 100%;"></div>`;
+    }
+
+    html += '</div>';
+    return html;
+  }
+
+  /**
+   * Create linear barcode HTML representation
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {string} HTML content
+   */
+  createLinearBarcodeHTML(data, type, options) {
+    const barWidth = options.width || 2;
+    const barHeight = options.height || 100;
+
+    let html = `<div class="linear-barcode" style="display: flex; align-items: flex-start; background: ${options.background}; padding: 10px;">`;
+
+    // Generate 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++) {
+        html += `<div style="width: ${barWidth}px; height: ${barHeight}px; background-color: ${options.lineColor}; margin-right: ${barWidth}px;"></div>`;
+      }
+    }
+
+    html += '</div>';
+    return html;
+  }
+
+  /**
+   * Get container styles
+   * @param {Object} options - Render options
+   * @returns {string} CSS styles
+   */
+  getContainerStyles(options) {
+    return `
+      display: inline-block;
+      background: ${options.background};
+      padding: ${options.margin}px;
+      margin: ${options.marginTop}px ${options.marginRight}px ${options.marginBottom}px ${options.marginLeft}px;
+      border: 1px solid #ccc;
+      text-align: center;
+    `;
+  }
+
+  /**
+   * Get text styles
+   * @param {Object} options - Render options
+   * @returns {string} CSS styles
+   */
+  getTextStyles(options) {
+    return `
+      font-family: Arial, sans-serif;
+      font-size: ${options.fontSize}px;
+      color: ${options.lineColor};
+      text-align: ${options.textAlign};
+      margin-top: ${options.textMargin}px;
+    `;
+  }
+
+  /**
+   * Get CSS styles for the barcode
+   * @param {string} containerId - Container ID
+   * @param {Object} options - Render options
+   * @returns {string} CSS styles
+   */
+  getCSSStyles(containerId) {
+    return `
+      <style>
+        #${containerId} {
+          font-family: Arial, sans-serif;
+        }
+        #${containerId} .barcode-text {
+          font-weight: bold;
+        }
+        #${containerId} .qr-code {
+          margin: 0 auto;
+        }
+        #${containerId} .linear-barcode {
+          justify-content: center;
+        }
+      </style>
+    `;
+  }
+
+  /**
+   * Get default options
+   * @returns {Object} Default options
+   */
+  getDefaultOptions() {
+    return { ...this.defaultOptions };
+  }
+
+  /**
+   * Set default options
+   * @param {Object} options - New default options
+   */
+  setDefaultOptions(options) {
+    this.defaultOptions = { ...this.defaultOptions, ...options };
+  }
+}
+
+module.exports = HTMLRenderer;

package/src/renderers/PDFRenderer.js

@@ -0,0 +1,184 @@
+/**
+ * PDF Renderer - Renders barcodes as PDF
+ */
+
+const PDFDocument = require('pdfkit');
+
+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,
+      pageHeight: 792,
+    };
+  }
+
+  /**
+   * Render a barcode as PDF
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {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);
+        });
+
+        doc.on('error', reject);
+
+        // Add barcode to PDF
+        this.addBarcodeToPDF(doc, data, type, renderOptions);
+
+        // Finalize PDF
+        doc.end();
+      });
+    } 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
+   * @param {Object} options - Render options
+   */
+  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);
+    }
+
+    // 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,
+      });
+    }
+  }
+
+  /**
+   * 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();
+        }
+      }
+    }
+  }
+
+  /**
+   * 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;
+      }
+    }
+  }
+
+  /**
+   * Get default options
+   * @returns {Object} Default options
+   */
+  getDefaultOptions() {
+    return { ...this.defaultOptions };
+  }
+
+  /**
+   * Set default options
+   * @param {Object} options - New default options
+   */
+  setDefaultOptions(options) {
+    this.defaultOptions = { ...this.defaultOptions, ...options };
+  }
+}
+
+module.exports = PDFRenderer;

package/src/renderers/PNGRenderer.js

@@ -0,0 +1,123 @@
+/**
+ * PNG Renderer - Renders barcodes as PNG images
+ */
+
+const { createCanvas } = require('canvas');
+const JsBarcode = require('jsbarcode');
+
+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,
+    };
+  }
+
+  /**
+   * Render a barcode as PNG
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {Buffer} PNG buffer
+   */
+  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,
+      });
+
+      // 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
+   */
+  getDefaultOptions() {
+    return { ...this.defaultOptions };
+  }
+
+  /**
+   * Set default options
+   * @param {Object} options - New default options
+   */
+  setDefaultOptions(options) {
+    this.defaultOptions = { ...this.defaultOptions, ...options };
+  }
+}
+
+module.exports = PNGRenderer;

package/src/renderers/RenderFormats.js

@@ -0,0 +1,87 @@
+/**
+ * Render Formats - Supported output formats
+ */
+
+class RenderFormats {
+  static FORMATS = {
+    PNG: 'png',
+    SVG: 'svg',
+    HTML: 'html',
+    PDF: 'pdf',
+    JPG: 'jpg',
+    JPEG: 'jpeg',
+  };
+
+  static MIME_TYPES = {
+    png: 'image/png',
+    svg: 'image/svg+xml',
+    html: 'text/html',
+    pdf: 'application/pdf',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+  };
+
+  static EXTENSIONS = {
+    png: '.png',
+    svg: '.svg',
+    html: '.html',
+    pdf: '.pdf',
+    jpg: '.jpg',
+    jpeg: '.jpeg',
+  };
+
+  /**
+   * Get all supported formats
+   * @returns {Array} Array of all formats
+   */
+  static getAll() {
+    return Object.values(this.FORMATS);
+  }
+
+  /**
+   * Check if a format is valid
+   * @param {string} format - The format to check
+   * @returns {boolean} True if valid
+   */
+  static isValid(format) {
+    return Object.values(this.FORMATS).includes(format);
+  }
+
+  /**
+   * Get MIME type for a format
+   * @param {string} format - The format
+   * @returns {string} MIME type
+   */
+  static getMimeType(format) {
+    return this.MIME_TYPES[format] || 'application/octet-stream';
+  }
+
+  /**
+   * Get file extension for a format
+   * @param {string} format - The format
+   * @returns {string} File extension
+   */
+  static getExtension(format) {
+    return this.EXTENSIONS[format] || '';
+  }
+
+  /**
+   * Get format description
+   * @param {string} format - The format
+   * @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 descriptions[format] || 'Unknown format';
+  }
+}
+
+module.exports = { RenderFormats };