isahaq-barcode 1.9.0 → 2.0.0

package/browser.js

@@ -1,228 +1,221 @@
 /**
- * Browser-compatible version of Isahaq Barcode Generator
- * This version uses client-side libraries instead of Node.js modules
+ * Browser build of Isahaq Barcode Generator
+ *
+ * Uses the same encoder and type registry as the Node.js build, so a barcode
+ * rendered in the browser is identical to one rendered on the server. Node-only
+ * outputs (PDF, file writing) are not available here.
  */
 
-// Browser-compatible QR code generation
+const bwipjs = require('bwip-js');
 const QRCode = require('qrcode');
+const { BarcodeEncoder } = require('./src/encoders/BarcodeEncoder');
+const { BarcodeTypes } = require('./src/types/BarcodeTypes');
+const { RenderFormats } = require('./src/renderers/RenderFormats');
+const { Validator } = require('./src/validators/Validator');
 
-// Browser-compatible barcode generation using jsbarcode
-const JsBarcode = require('jsbarcode');
+const validator = new Validator();
+
+/**
+ * Assert that a DOM is available before touching document
+ * @param {string} feature - Feature name used in the error message
+ */
+function requireDom(feature) {
+  if (typeof document === 'undefined') {
+    throw new Error(`${feature} requires a browser environment with a DOM`);
+  }
+}
 
 class BrowserBarcodeGenerator {
   /**
-   * Generate PNG barcode (browser-compatible)
+   * Generate a barcode as SVG markup
    * @param {string} data - Data to encode
    * @param {string} type - Barcode type
    * @param {Object} options - Options
-   * @returns {Promise<Buffer>} PNG buffer
+   * @returns {string} SVG markup
    */
-  static async png(data, type = 'code128', options = {}) {
-    try {
-      // Create a canvas element
-      const canvas = document.createElement('canvas');
-
-      // Generate barcode using jsbarcode
-      JsBarcode(canvas, data, {
-        format: type.toUpperCase(),
-        width: options.width || 2,
-        height: options.height || 100,
-        displayValue: options.displayValue !== false,
-        fontSize: options.fontSize || 20,
-        textAlign: options.textAlign || 'center',
-        textPosition: options.textPosition || 'bottom',
-        textMargin: options.textMargin || 2,
-        background: options.background || '#ffffff',
-        lineColor: options.lineColor || '#000000',
-        margin: options.margin || 10,
-        ...options,
-      });
-
-      // Convert canvas to blob
-      return new Promise(resolve => {
-        canvas.toBlob(blob => {
-          const reader = new FileReader();
-          reader.onload = () => resolve(Buffer.from(reader.result));
-          reader.readAsArrayBuffer(blob);
-        }, 'image/png');
-      });
-    } catch (error) {
-      throw new Error(`Failed to generate PNG barcode: ${error.message}`);
-    }
+  static svg(data, type = 'code128', options = {}) {
+    return BarcodeEncoder.toSvg(data, type, options);
   }
 
   /**
-   * Generate SVG barcode (browser-compatible)
+   * Generate a barcode as SVG markup (alias of svg, mirrors the Node.js API)
    * @param {string} data - Data to encode
    * @param {string} type - Barcode type
    * @param {Object} options - Options
-   * @returns {string} SVG string
+   * @returns {string} SVG markup
    */
-  static svg(data, type = 'code128', options = {}) {
-    try {
-      // Create a temporary div to hold the SVG
-      const tempDiv = document.createElement('div');
-
-      // Generate barcode using jsbarcode
-      JsBarcode(tempDiv, data, {
-        format: type.toUpperCase(),
-        width: options.width || 2,
-        height: options.height || 100,
-        displayValue: options.displayValue !== false,
-        fontSize: options.fontSize || 20,
-        textAlign: options.textAlign || 'center',
-        textPosition: options.textPosition || 'bottom',
-        textMargin: options.textMargin || 2,
-        background: options.background || '#ffffff',
-        lineColor: options.lineColor || '#000000',
-        margin: options.margin || 10,
-        xmlDocument: document,
-        ...options,
-      });
-
-      return tempDiv.innerHTML;
-    } catch (error) {
-      throw new Error(`Failed to generate SVG barcode: ${error.message}`);
-    }
+  static svgSync(data, type = 'code128', options = {}) {
+    return BarcodeEncoder.toSvg(data, type, options);
   }
 
   /**
-   * Generate HTML barcode (browser-compatible)
+   * Generate a barcode as an HTML fragment containing an inline SVG
    * @param {string} data - Data to encode
    * @param {string} type - Barcode type
    * @param {Object} options - Options
-   * @returns {string} HTML string
+   * @returns {string} HTML markup
    */
   static html(data, type = 'code128', options = {}) {
-    const svg = this.svg(data, type, options);
-    return `<div class="barcode-container">${svg}</div>`;
+    const svg = BarcodeEncoder.toSvg(data, type, options);
+    return `<div class="barcode" data-barcode-type="${type}">${svg}</div>`;
+  }
+
+  /**
+   * Generate a barcode as an HTML fragment (alias of html)
+   * @param {string} data - Data to encode
+   * @param {string} type - Barcode type
+   * @param {Object} options - Options
+   * @returns {string} HTML markup
+   */
+  static htmlSync(data, type = 'code128', options = {}) {
+    return this.html(data, type, options);
+  }
+
+  /**
+   * Draw a barcode onto an existing canvas element
+   * @param {HTMLCanvasElement} canvas - Target canvas
+   * @param {string} data - Data to encode
+   * @param {string} type - Barcode type
+   * @param {Object} options - Options
+   * @returns {HTMLCanvasElement} The canvas that was drawn on
+   */
+  static toCanvas(canvas, data, type = 'code128', options = {}) {
+    return bwipjs.toCanvas(
+      canvas,
+      BarcodeEncoder.buildOptions(data, type, options)
+    );
+  }
+
+  /**
+   * Generate a barcode as a PNG blob
+   * @param {string} data - Data to encode
+   * @param {string} type - Barcode type
+   * @param {Object} options - Options
+   * @returns {Promise<Blob>} PNG blob
+   */
+  static png(data, type = 'code128', options = {}) {
+    requireDom('PNG generation');
+
+    const canvas = document.createElement('canvas');
+    this.toCanvas(canvas, data, type, options);
+
+    return new Promise((resolve, reject) => {
+      canvas.toBlob(blob => {
+        if (blob) {
+          resolve(blob);
+        } else {
+          reject(new Error('Failed to generate PNG blob'));
+        }
+      }, 'image/png');
+    });
+  }
+
+  /**
+   * Generate a barcode as a data URL
+   * @param {string} data - Data to encode
+   * @param {string} type - Barcode type
+   * @param {Object} options - Options
+   * @returns {string} Data URL
+   */
+  static dataUrl(data, type = 'code128', options = {}) {
+    requireDom('Data URL generation');
+
+    const canvas = document.createElement('canvas');
+    this.toCanvas(canvas, data, type, options);
+    return canvas.toDataURL('image/png');
   }
 
   /**
-   * Generate QR code (browser-compatible)
+   * Generate a QR code as a data URL
    * @param {string} data - Data to encode
    * @param {Object} options - Options
-   * @returns {Promise<Buffer>} PNG buffer
+   * @returns {Promise<string>} Data URL
    */
   static async qrCode(data, options = {}) {
-    try {
-      const canvas = document.createElement('canvas');
-      await QRCode.toCanvas(canvas, data, {
-        width: options.size || 300,
-        margin: options.margin || 10,
-        color: {
-          dark: options.foregroundColor || '#000000',
-          light: options.backgroundColor || '#FFFFFF',
-        },
-        errorCorrectionLevel: options.errorCorrectionLevel || 'M',
-        ...options,
-      });
-
-      return new Promise(resolve => {
-        canvas.toBlob(blob => {
-          const reader = new FileReader();
-          reader.onload = () => resolve(Buffer.from(reader.result));
-          reader.readAsArrayBuffer(blob);
-        }, 'image/png');
-      });
-    } catch (error) {
-      throw new Error(`Failed to generate QR code: ${error.message}`);
-    }
+    return QRCode.toDataURL(data, {
+      width: options.size || 300,
+      margin: options.margin === undefined ? 1 : options.margin,
+      errorCorrectionLevel: options.errorCorrectionLevel || 'M',
+      color: {
+        dark: options.foregroundColor || '#000000',
+        light: options.backgroundColor || '#ffffff',
+      },
+    });
+  }
+
+  /**
+   * Generate a QR code as SVG markup
+   * @param {string} data - Data to encode
+   * @param {Object} options - Options
+   * @returns {Promise<string>} SVG markup
+   */
+  static async qrCodeSvg(data, options = {}) {
+    return QRCode.toString(data, {
+      type: 'svg',
+      width: options.size || 300,
+      margin: options.margin === undefined ? 1 : options.margin,
+      errorCorrectionLevel: options.errorCorrectionLevel || 'M',
+      color: {
+        dark: options.foregroundColor || '#000000',
+        light: options.backgroundColor || '#ffffff',
+      },
+    });
   }
 
   /**
-   * Validate barcode data (browser-compatible)
+   * Validate barcode data
    * @param {string} data - Data to validate
    * @param {string} type - Barcode type
    * @returns {Object} Validation result
    */
   static validate(data, type) {
-    if (!data || typeof data !== 'string') {
-      return {
-        valid: false,
-        error: 'Data must be a non-empty string',
-      };
-    }
-
-    // Basic validation for common barcode types
-    switch (type.toLowerCase()) {
-      case 'code128':
-        if (!/^[\x00-\x7F]+$/.test(data)) {
-          return {
-            valid: false,
-            error: 'Code 128 supports ASCII characters only',
-          };
-        }
-        break;
-      case 'code39':
-        if (!/^[A-Z0-9\s\-\.\$\/\+\%]+$/.test(data)) {
-          return {
-            valid: false,
-            error: 'Code 39 supports characters: A-Z, 0-9, space, -.$/+%',
-          };
-        }
-        break;
-      case 'ean13':
-        if (!/^\d{12,13}$/.test(data)) {
-          return {
-            valid: false,
-            error: 'EAN-13 must be 12 or 13 digits',
-          };
-        }
-        break;
-      case 'qrcode':
-        if (data.length === 0) {
-          return {
-            valid: false,
-            error: 'QR Code data cannot be empty',
-          };
-        }
-        break;
-    }
-
-    return { valid: true };
+    return validator.validate(data, type);
   }
 
   /**
    * Get supported barcode types
-   * @returns {Array} Array of supported types
+   * @returns {string[]} Array of supported types
    */
   static getBarcodeTypes() {
-    return [
-      'code128',
-      'code128a',
-      'code128b',
-      'code128c',
-      'code128auto',
-      'code39',
-      'code39extended',
-      'code39checksum',
-      'code39auto',
-      'code93',
-      'ean13',
-      'ean8',
-      'upca',
-      'upce',
-      'codabar',
-      'code11',
-      'msi',
-      'pharmazentral',
-      'interleaved25',
-      'standard25',
-      'qrcode',
-      'datamatrix',
-      'pdf417',
-      'aztec',
-    ];
+    return BarcodeTypes.getAll();
+  }
+
+  /**
+   * Get barcode type information
+   * @param {string} type - Barcode type
+   * @returns {Object|null} Type information
+   */
+  static getBarcodeTypeInfo(type) {
+    return BarcodeTypes.getTypeInfo(type);
   }
 
   /**
-   * Get supported render formats
-   * @returns {Array} Array of supported formats
+   * Get supported output formats for the browser build
+   * @returns {string[]} Array of supported formats
    */
   static getRenderFormats() {
     return ['png', 'svg', 'html'];
   }
+
+  /**
+   * Get information about an output format
+   * @param {string} format - Output format
+   * @returns {Object|null} Format information
+   */
+  static getRenderFormatInfo(format) {
+    return RenderFormats.getFormatInfo(format);
+  }
+
+  /**
+   * Get the default render options
+   * @returns {Object} Default options
+   */
+  static getDefaultOptions() {
+    return BarcodeEncoder.getDefaultOptions();
+  }
 }
 
+BrowserBarcodeGenerator.BarcodeTypes = BarcodeTypes;
+BrowserBarcodeGenerator.BarcodeEncoder = BarcodeEncoder;
+
 module.exports = BrowserBarcodeGenerator;