isahaq-barcode 1.8.0 → 2.0.0

package/src/renderers/SVGRenderer.js

@@ -2,26 +2,11 @@
  * SVG Renderer - Renders barcodes as SVG
  */
 
-const JsBarcode = require('jsbarcode');
+const { BarcodeEncoder } = require('../encoders/BarcodeEncoder');
 
 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,
-    };
+    this.defaultOptions = BarcodeEncoder.getDefaultOptions();
   }
 
   /**
@@ -29,176 +14,17 @@ class SVGRenderer {
    * @param {string} data - The data to encode
    * @param {string} type - The barcode type
    * @param {Object} options - Render options
-   * @returns {string} SVG string
+   * @returns {string} SVG markup
    */
   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(),
+      return BarcodeEncoder.toSvg(data, type, {
+        ...this.defaultOptions,
+        ...options,
       });
-
-      // 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;
-      }
+    } catch (error) {
+      throw new Error(`SVG rendering failed: ${error.message}`);
     }
-
-    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';
   }
 
   /**

package/src/services/BarcodeService.js

@@ -10,6 +10,9 @@ const HTMLRenderer = require('../renderers/HTMLRenderer');
 const PDFRenderer = require('../renderers/PDFRenderer');
 const { Validator } = require('../validators/Validator');
 
+/** Formats that can be produced without any asynchronous work */
+const SYNC_FORMATS = ['svg', 'html'];
+
 class BarcodeService {
   constructor() {
     this.renderers = {
@@ -22,15 +25,13 @@ class BarcodeService {
   }
 
   /**
-   * Generate a barcode
+   * Validate the arguments of a generate call and return the matching renderer
    * @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
+   * @returns {Object} The renderer for the requested format
    */
-  generate(data, type = 'code128', format = 'png', options = {}) {
-    // Validate inputs
+  resolve(data, type, format) {
     if (!data || typeof data !== 'string') {
       throw new Error('Data must be a non-empty string');
     }
@@ -51,19 +52,45 @@ class BarcodeService {
       );
     }
 
-    // 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}`);
+    return this.renderers[format];
+  }
+
+  /**
+   * 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 {Promise<Buffer|string>} Generated barcode
+   */
+  async generate(data, type = 'code128', format = 'png', options = {}) {
+    const renderer = this.resolve(data, type, format);
+    return renderer.render(data, type, options);
+  }
+
+  /**
+   * Generate a barcode synchronously (SVG and HTML only)
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {string} format - The output format (svg or html)
+   * @param {Object} options - Additional options
+   * @returns {string} Generated barcode
+   */
+  generateSync(data, type = 'code128', format = 'svg', options = {}) {
+    if (!SYNC_FORMATS.includes(format)) {
+      throw new Error(
+        `Format ${format} cannot be generated synchronously. Synchronous formats: ${SYNC_FORMATS.join(
+          ', '
+        )}`
+      );
     }
 
-    // Generate barcode
+    const renderer = this.resolve(data, type, format);
     return renderer.render(data, type, options);
   }
 
@@ -72,9 +99,9 @@ class BarcodeService {
    * @param {string} data - The data to encode
    * @param {string} type - The barcode type
    * @param {Object} options - Additional options
-   * @returns {Buffer} PNG buffer
+   * @returns {Promise<Buffer>} PNG buffer
    */
-  png(data, type = 'code128', options = {}) {
+  async png(data, type = 'code128', options = {}) {
     return this.generate(data, type, 'png', options);
   }
 
@@ -83,66 +110,99 @@ class BarcodeService {
    * @param {string} data - The data to encode
    * @param {string} type - The barcode type
    * @param {Object} options - Additional options
-   * @returns {string} SVG string
+   * @returns {Promise<string>} SVG markup
    */
-  svg(data, type = 'code128', options = {}) {
+  async svg(data, type = 'code128', options = {}) {
     return this.generate(data, type, 'svg', options);
   }
 
+  /**
+   * Generate a barcode in SVG format synchronously
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Additional options
+   * @returns {string} SVG markup
+   */
+  svgSync(data, type = 'code128', options = {}) {
+    return this.generateSync(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
+   * @returns {Promise<string>} HTML markup
    */
-  html(data, type = 'code128', options = {}) {
+  async html(data, type = 'code128', options = {}) {
     return this.generate(data, type, 'html', options);
   }
 
+  /**
+   * Generate a barcode in HTML format synchronously
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Additional options
+   * @returns {string} HTML markup
+   */
+  htmlSync(data, type = 'code128', options = {}) {
+    return this.generateSync(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
+   * @returns {Promise<Buffer>} PDF buffer
    */
-  pdf(data, type = 'code128', options = {}) {
+  async 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
+   * Generate multiple barcodes in batch. Individual failures are reported in
+   * the result instead of rejecting the whole batch.
+   * @param {Array<Object>} items - Array of barcode generation items
+   * @returns {Promise<Array<Object>>} Array of results
    */
-  batch(items) {
+  async batch(items) {
     if (!Array.isArray(items)) {
       throw new Error('Items must be an array');
     }
 
-    return items.map((item, index) => {
+    const results = [];
+
+    for (const [index, item] of items.entries()) {
+      const {
+        data,
+        type = 'code128',
+        format = 'png',
+        options = {},
+      } = item || {};
+
       try {
-        const { data, type = 'code128', format = 'png', options = {} } = item;
-        return {
+        results.push({
           index,
           success: true,
-          result: this.generate(data, type, format, options),
+          result: await this.generate(data, type, format, options),
           data,
           type,
           format,
-        };
+        });
       } catch (error) {
-        return {
+        results.push({
           index,
           success: false,
           error: error.message,
-          data: item.data,
-          type: item.type || 'code128',
-          format: item.format || 'png',
-        };
+          data,
+          type,
+          format,
+        });
       }
-    });
+    }
+
+    return results;
   }
 
   /**
@@ -157,7 +217,7 @@ class BarcodeService {
 
   /**
    * Get available barcode types
-   * @returns {Array} Array of barcode types
+   * @returns {string[]} Array of barcode types
    */
   getBarcodeTypes() {
     return BarcodeTypes.getAll();
@@ -165,7 +225,7 @@ class BarcodeService {
 
   /**
    * Get available render formats
-   * @returns {Array} Array of render formats
+   * @returns {string[]} Array of render formats
    */
   getRenderFormats() {
     return RenderFormats.getAll();