isahaq-barcode 1.0.0

package/src/renderers/SVGRenderer.js

@@ -0,0 +1,221 @@
+/**
+ * SVG Renderer - Renders barcodes as SVG
+ */
+
+const JsBarcode = require('jsbarcode');
+
+class SVGRenderer {
+  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 SVG
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {string} SVG string
+   */
+  render(data, type, options = {}) {
+    try {
+      // Merge options with defaults
+      const renderOptions = { ...this.defaultOptions, ...options };
+
+      // Create a temporary canvas element for JsBarcode
+      const canvas = document.createElement('canvas');
+
+      // 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,
+        xmlDocument: this.createXMLDocument(),
+      });
+
+      // Get SVG string from canvas
+      const svgString = canvas.toSVG();
+      return svgString;
+    } catch {
+      // Fallback: create SVG manually
+      return this.createManualSVG(data, type, options);
+    }
+  }
+
+  /**
+   * Create SVG manually as fallback
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {string} SVG string
+   */
+  createManualSVG(data, type, options = {}) {
+    const renderOptions = { ...this.defaultOptions, ...options };
+
+    // Simple SVG structure for basic barcodes
+    const width = 300;
+    const height = renderOptions.height + (renderOptions.displayValue ? 30 : 0);
+
+    let svg = `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">`;
+    svg += `<rect width="${width}" height="${height}" fill="${renderOptions.background}"/>`;
+
+    // Add barcode representation (simplified)
+    if (type === 'qrcode') {
+      svg += this.createQRCodeSVG(data, width, height, renderOptions);
+    } else {
+      svg += this.createLinearBarcodeSVG(data, width, height, renderOptions);
+    }
+
+    // Add text if displayValue is true
+    if (renderOptions.displayValue) {
+      svg += `<text x="${width / 2}" y="${
+        height - 5
+      }" text-anchor="middle" font-family="Arial" font-size="${
+        renderOptions.fontSize
+      }" fill="${renderOptions.lineColor}">${data}</text>`;
+    }
+
+    svg += '</svg>';
+    return svg;
+  }
+
+  /**
+   * Create QR Code SVG representation
+   * @param {string} data - The data to encode
+   * @param {number} width - SVG width
+   * @param {number} height - SVG height
+   * @param {Object} options - Render options
+   * @returns {string} SVG content
+   */
+  createQRCodeSVG(data, width, height, options) {
+    // This is a simplified representation
+    // In a real implementation, you would use a QR code library
+    const size = Math.min(width, height) - 40;
+    const x = (width - size) / 2;
+    const y = (height - size) / 2;
+
+    return `<rect x="${x}" y="${y}" width="${size}" height="${size}" fill="${options.lineColor}" stroke="${options.lineColor}" stroke-width="1"/>`;
+  }
+
+  /**
+   * Create linear barcode SVG representation
+   * @param {string} data - The data to encode
+   * @param {number} width - SVG width
+   * @param {number} height - SVG height
+   * @param {Object} options - Render options
+   * @returns {string} SVG content
+   */
+  createLinearBarcodeSVG(data, width, height, options) {
+    // This is a simplified representation
+    // In a real implementation, you would use a barcode library
+    const barWidth = 2;
+    const barHeight = height - (options.displayValue ? 30 : 0);
+    const startX = 20;
+    let currentX = startX;
+
+    let svg = '';
+    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++) {
+        svg += `<rect x="${currentX}" y="10" width="${barWidth}" height="${barHeight}" fill="${options.lineColor}"/>`;
+        currentX += barWidth * 2;
+      }
+    }
+
+    return svg;
+  }
+
+  /**
+   * Create XML document for JsBarcode
+   * @returns {Object} XML document
+   */
+  createXMLDocument() {
+    // Create a minimal XML document for JsBarcode
+    return {
+      createElement: (tagName) => ({
+        tagName,
+        setAttribute: () => {},
+        appendChild: () => {},
+        toSVG: () => '<svg></svg>',
+      }),
+    };
+  }
+
+  /**
+   * 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 = SVGRenderer;

package/src/services/BarcodeService.js

@@ -0,0 +1,175 @@
+/**
+ * Barcode Service - Core service for barcode generation
+ */
+
+const { BarcodeTypes } = require('../types/BarcodeTypes');
+const { RenderFormats } = require('../renderers/RenderFormats');
+const PNGRenderer = require('../renderers/PNGRenderer');
+const SVGRenderer = require('../renderers/SVGRenderer');
+const HTMLRenderer = require('../renderers/HTMLRenderer');
+const PDFRenderer = require('../renderers/PDFRenderer');
+const { Validator } = require('../validators/Validator');
+
+class BarcodeService {
+  constructor() {
+    this.renderers = {
+      png: new PNGRenderer(),
+      svg: new SVGRenderer(),
+      html: new HTMLRenderer(),
+      pdf: new PDFRenderer(),
+    };
+    this.validator = new Validator();
+  }
+
+  /**
+   * Generate a barcode
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {string} format - The output format
+   * @param {Object} options - Additional options
+   * @returns {Buffer|string} Generated barcode
+   */
+  generate(data, type = 'code128', format = 'png', options = {}) {
+    // Validate inputs
+    if (!data || typeof data !== 'string') {
+      throw new Error('Data must be a non-empty string');
+    }
+
+    if (!BarcodeTypes.isValid(type)) {
+      throw new Error(
+        `Invalid barcode type: ${type}. Supported types: ${BarcodeTypes.getAll().join(
+          ', '
+        )}`
+      );
+    }
+
+    if (!RenderFormats.isValid(format)) {
+      throw new Error(
+        `Invalid format: ${format}. Supported formats: ${RenderFormats.getAll().join(
+          ', '
+        )}`
+      );
+    }
+
+    // Validate data for the specific barcode type
+    const validation = this.validator.validate(data, type);
+    if (!validation.valid) {
+      throw new Error(`Invalid data for ${type}: ${validation.error}`);
+    }
+
+    // Get renderer
+    const renderer = this.renderers[format];
+    if (!renderer) {
+      throw new Error(`No renderer available for format: ${format}`);
+    }
+
+    // Generate barcode
+    return renderer.render(data, type, options);
+  }
+
+  /**
+   * Generate a barcode in PNG format
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Additional options
+   * @returns {Buffer} PNG buffer
+   */
+  png(data, type = 'code128', options = {}) {
+    return this.generate(data, type, 'png', options);
+  }
+
+  /**
+   * Generate a barcode in SVG format
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Additional options
+   * @returns {string} SVG string
+   */
+  svg(data, type = 'code128', options = {}) {
+    return this.generate(data, type, 'svg', options);
+  }
+
+  /**
+   * Generate a barcode in HTML format
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Additional options
+   * @returns {string} HTML string
+   */
+  html(data, type = 'code128', options = {}) {
+    return this.generate(data, type, 'html', options);
+  }
+
+  /**
+   * Generate a barcode in PDF format
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Additional options
+   * @returns {Buffer} PDF buffer
+   */
+  pdf(data, type = 'code128', options = {}) {
+    return this.generate(data, type, 'pdf', options);
+  }
+
+  /**
+   * Generate multiple barcodes in batch
+   * @param {Array} items - Array of barcode generation items
+   * @returns {Array} Array of generated barcodes
+   */
+  batch(items) {
+    if (!Array.isArray(items)) {
+      throw new Error('Items must be an array');
+    }
+
+    return items.map((item, index) => {
+      try {
+        const { data, type = 'code128', format = 'png', options = {} } = item;
+        return {
+          index,
+          success: true,
+          result: this.generate(data, type, format, options),
+          data,
+          type,
+          format,
+        };
+      } catch (error) {
+        return {
+          index,
+          success: false,
+          error: error.message,
+          data: item.data,
+          type: item.type || 'code128',
+          format: item.format || 'png',
+        };
+      }
+    });
+  }
+
+  /**
+   * Validate data for a specific barcode type
+   * @param {string} data - The data to validate
+   * @param {string} type - The barcode type
+   * @returns {Object} Validation result
+   */
+  validate(data, type) {
+    return this.validator.validate(data, type);
+  }
+
+  /**
+   * Get available barcode types
+   * @returns {Array} Array of barcode types
+   */
+  getBarcodeTypes() {
+    return BarcodeTypes.getAll();
+  }
+
+  /**
+   * Get available render formats
+   * @returns {Array} Array of render formats
+   */
+  getRenderFormats() {
+    return RenderFormats.getAll();
+  }
+}
+
+module.exports = BarcodeService;

package/src/types/BarcodeTypes.js

@@ -0,0 +1,195 @@
+/**
+ * Barcode Types - Supported barcode types and their configurations
+ */
+
+class BarcodeTypes {
+  static TYPES = {
+    // Linear Barcodes
+    CODE128: 'code128',
+    CODE128A: 'code128a',
+    CODE128B: 'code128b',
+    CODE128C: 'code128c',
+    CODE128AUTO: 'code128auto',
+    CODE39: 'code39',
+    CODE39EXTENDED: 'code39extended',
+    CODE39CHECKSUM: 'code39checksum',
+    CODE39AUTO: 'code39auto',
+    CODE93: 'code93',
+    CODE25: 'code25',
+    CODE25AUTO: 'code25auto',
+    CODE32: 'code32',
+    STANDARD25: 'standard25',
+    STANDARD25CHECKSUM: 'standard25checksum',
+    INTERLEAVED25: 'interleaved25',
+    INTERLEAVED25CHECKSUM: 'interleaved25checksum',
+    INTERLEAVED25AUTO: 'interleaved25auto',
+    MSI: 'msi',
+    MSICHECKSUM: 'msichecksum',
+    MSIAUTO: 'msiauto',
+
+    // EAN/UPC Family
+    EAN13: 'ean13',
+    EAN8: 'ean8',
+    EAN2: 'ean2',
+    EAN5: 'ean5',
+    UPCA: 'upca',
+    UPCE: 'upce',
+    ITF14: 'itf14',
+
+    // Postal Barcodes
+    POSTNET: 'postnet',
+    PLANET: 'planet',
+    RMS4CC: 'rms4cc',
+    KIX: 'kix',
+    IMB: 'imb',
+
+    // Specialized Barcodes
+    CODABAR: 'codabar',
+    CODE11: 'code11',
+    PHARMACODE: 'pharmacode',
+    PHARMACODETWOTRACKS: 'pharmacodetwotracks',
+
+    // 2D Matrix Codes
+    QRCODE: 'qrcode',
+    DATAMATRIX: 'datamatrix',
+    AZTEC: 'aztec',
+    PDF417: 'pdf417',
+    MICROQR: 'microqr',
+    MAXICODE: 'maxicode',
+
+    // Stacked Linear Codes
+    CODE16K: 'code16k',
+    CODE49: 'code49',
+  };
+
+  static CATEGORIES = {
+    LINEAR: [
+      'code128',
+      'code128a',
+      'code128b',
+      'code128c',
+      'code128auto',
+      'code39',
+      'code39extended',
+      'code39checksum',
+      'code39auto',
+      'code93',
+      'code25',
+      'code25auto',
+      'code32',
+      'standard25',
+      'standard25checksum',
+      'interleaved25',
+      'interleaved25checksum',
+      'interleaved25auto',
+      'msi',
+      'msichecksum',
+      'msiauto',
+    ],
+    EAN_UPC: ['ean13', 'ean8', 'ean2', 'ean5', 'upca', 'upce', 'itf14'],
+    POSTAL: ['postnet', 'planet', 'rms4cc', 'kix', 'imb'],
+    SPECIALIZED: ['codabar', 'code11', 'pharmacode', 'pharmacodetwotracks'],
+    MATRIX_2D: [
+      'qrcode',
+      'datamatrix',
+      'aztec',
+      'pdf417',
+      'microqr',
+      'maxicode',
+    ],
+    STACKED: ['code16k', 'code49'],
+  };
+
+  /**
+   * Get all supported barcode types
+   * @returns {Array} Array of all barcode types
+   */
+  static getAll() {
+    return Object.values(this.TYPES);
+  }
+
+  /**
+   * Get barcode types by category
+   * @param {string} category - The category name
+   * @returns {Array} Array of barcode types in the category
+   */
+  static getByCategory(category) {
+    return this.CATEGORIES[category.toUpperCase()] || [];
+  }
+
+  /**
+   * Get all categories
+   * @returns {Array} Array of category names
+   */
+  static getCategories() {
+    return Object.keys(this.CATEGORIES);
+  }
+
+  /**
+   * Check if a barcode type is valid
+   * @param {string} type - The barcode type to check
+   * @returns {boolean} True if valid
+   */
+  static isValid(type) {
+    return Object.values(this.TYPES).includes(type);
+  }
+
+  /**
+   * Get barcode type configuration
+   * @param {string} type - The barcode type
+   * @returns {Object} Configuration object
+   */
+  static getConfig(type) {
+    const configs = {
+      code128: { minLength: 1, maxLength: 80, charset: 'ASCII' },
+      code128a: { minLength: 1, maxLength: 80, charset: 'ASCII A' },
+      code128b: { minLength: 1, maxLength: 80, charset: 'ASCII B' },
+      code128c: { minLength: 2, maxLength: 80, charset: 'Numeric' },
+      code39: {
+        minLength: 1,
+        maxLength: 43,
+        charset: '0-9, A-Z, space, -.$/+%',
+      },
+      code39extended: {
+        minLength: 1,
+        maxLength: 43,
+        charset: 'Extended ASCII',
+      },
+      code93: { minLength: 1, maxLength: 43, charset: '0-9, A-Z, -.$/+%' },
+      ean13: { minLength: 12, maxLength: 13, charset: 'Numeric' },
+      ean8: { minLength: 7, maxLength: 8, charset: 'Numeric' },
+      upca: { minLength: 11, maxLength: 12, charset: 'Numeric' },
+      upce: { minLength: 6, maxLength: 8, charset: 'Numeric' },
+      qrcode: { minLength: 1, maxLength: 2953, charset: 'Unicode' },
+      datamatrix: { minLength: 1, maxLength: 2335, charset: 'Unicode' },
+      pdf417: { minLength: 1, maxLength: 1850, charset: 'Unicode' },
+    };
+
+    return (
+      configs[type] || { minLength: 1, maxLength: 100, charset: 'Unknown' }
+    );
+  }
+
+  /**
+   * Get barcode type description
+   * @param {string} type - The barcode type
+   * @returns {string} Description
+   */
+  static getDescription(type) {
+    const descriptions = {
+      code128: 'Code 128 - High-density linear barcode',
+      code39: 'Code 39 - Alphanumeric barcode',
+      ean13: 'EAN-13 - European Article Number',
+      ean8: 'EAN-8 - European Article Number (short)',
+      upca: 'UPC-A - Universal Product Code',
+      upce: 'UPC-E - Universal Product Code (compressed)',
+      qrcode: 'QR Code - 2D matrix barcode',
+      datamatrix: 'Data Matrix - 2D matrix barcode',
+      pdf417: 'PDF417 - 2D stacked barcode',
+    };
+
+    return descriptions[type] || 'Unknown barcode type';
+  }
+}
+
+module.exports = { BarcodeTypes };