isahaq-barcode 1.3.0 → 1.7.0

package/README.md

@@ -44,15 +44,23 @@ npm install isahaq-barcode
 
 **Requirements:** Node.js 18.0 or higher
 
-## 🌐 Browser Compatibility
+## 🌐 Universal Compatibility
 
-> **Important:** This package is designed for **Node.js server-side environments** and is not compatible with browser environments.
+> **Great News:** This package now works in **both Node.js and browser environments**!
 
-### Why Not Browser Compatible?
+### ✅ Server-Side (Node.js)
 
-- **Canvas Dependency**: Uses Node.js `canvas` library for image generation
-- **File System Access**: Requires Node.js `fs` module for file operations
-- **Server-Side Rendering**: Designed for server-side barcode generation
+- **Full Features**: All barcode types, formats, and advanced features
+- **Canvas Support**: High-quality image generation with Node.js canvas
+- **File Operations**: Save files directly to filesystem
+- **CLI Tools**: Command-line interface available
+
+### ✅ Client-Side (Browser)
+
+- **Core Features**: PNG, SVG, HTML generation
+- **QR Codes**: Full QR code generation with customization
+- **Barcode Types**: Code128, Code39, EAN13, UPC, and more
+- **No Dependencies**: Works with just jsbarcode and qrcode
 
 ### Recommended Usage Patterns
 
@@ -83,11 +91,17 @@ export default function handler(req, res) {
 }
 ```
 
-**❌ Client-Side (Not Supported):**
+**✅ Client-Side (Browser/React/Vue):**
 
 ```javascript
-// This will NOT work in browsers
-import BarcodeGenerator from 'isahaq-barcode'; // ❌
+// Browser/React/Vue components
+import BarcodeGenerator from 'isahaq-barcode';
+
+// Generate barcode in browser
+const generateBarcode = async () => {
+  const barcode = await BarcodeGenerator.png('123456789', 'code128');
+  // Use the barcode buffer
+};
 ```
 
 ### Alternative for Client-Side

package/browser.js

@@ -0,0 +1,228 @@
+/**
+ * Browser-compatible version of Isahaq Barcode Generator
+ * This version uses client-side libraries instead of Node.js modules
+ */
+
+// Browser-compatible QR code generation
+const QRCode = require('qrcode');
+
+// Browser-compatible barcode generation using jsbarcode
+const JsBarcode = require('jsbarcode');
+
+class BrowserBarcodeGenerator {
+  /**
+   * Generate PNG barcode (browser-compatible)
+   * @param {string} data - Data to encode
+   * @param {string} type - Barcode type
+   * @param {Object} options - Options
+   * @returns {Promise<Buffer>} PNG buffer
+   */
+  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}`);
+    }
+  }
+
+  /**
+   * Generate SVG barcode (browser-compatible)
+   * @param {string} data - Data to encode
+   * @param {string} type - Barcode type
+   * @param {Object} options - Options
+   * @returns {string} SVG string
+   */
+  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}`);
+    }
+  }
+
+  /**
+   * Generate HTML barcode (browser-compatible)
+   * @param {string} data - Data to encode
+   * @param {string} type - Barcode type
+   * @param {Object} options - Options
+   * @returns {string} HTML string
+   */
+  static html(data, type = 'code128', options = {}) {
+    const svg = this.svg(data, type, options);
+    return `<div class="barcode-container">${svg}</div>`;
+  }
+
+  /**
+   * Generate QR code (browser-compatible)
+   * @param {string} data - Data to encode
+   * @param {Object} options - Options
+   * @returns {Promise<Buffer>} PNG buffer
+   */
+  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}`);
+    }
+  }
+
+  /**
+   * Validate barcode data (browser-compatible)
+   * @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 };
+  }
+
+  /**
+   * Get supported barcode types
+   * @returns {Array} 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',
+    ];
+  }
+
+  /**
+   * Get supported render formats
+   * @returns {Array} Array of supported formats
+   */
+  static getRenderFormats() {
+    return ['png', 'svg', 'html'];
+  }
+}
+
+module.exports = BrowserBarcodeGenerator;

package/eslint.config.js

@@ -15,6 +15,7 @@ module.exports = [
         require: 'readonly',
         exports: 'readonly',
         document: 'readonly',
+        FileReader: 'readonly',
       },
     },
     plugins: {

package/index.js

@@ -3,132 +3,152 @@
  * A universal barcode generator package supporting multiple barcode types and output formats
  */
 
-const BarcodeService = require('./src/services/BarcodeService');
-const QrCodeBuilder = require('./src/builders/QrCodeBuilder');
-const { BarcodeTypes } = require('./src/types/BarcodeTypes');
-const { RenderFormats } = require('./src/renderers/RenderFormats');
+// Detect environment
+const isBrowser =
+  typeof window !== 'undefined' && typeof document !== 'undefined';
 
-// Main service instance
-const barcodeService = new BarcodeService();
+if (isBrowser) {
+  // Browser environment - use browser-compatible version
+  module.exports = require('./browser');
+} else {
+  // Node.js environment - use full-featured version
+  const BarcodeService = require('./src/services/BarcodeService');
+  const QrCodeBuilder = require('./src/builders/QrCodeBuilder');
+  const { BarcodeTypes } = require('./src/types/BarcodeTypes');
+  const { RenderFormats } = require('./src/renderers/RenderFormats');
 
-/**
- * Main Barcode Generator Class
- */
-class BarcodeGenerator {
-  /**
-   * 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
-   */
-  static png(data, type = 'code128', options = {}) {
-    return barcodeService.generate(data, type, 'png', options);
-  }
+  // Main service instance
+  const barcodeService = new BarcodeService();
 
   /**
-   * 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
+   * Main Barcode Generator Class
    */
-  static svg(data, type = 'code128', options = {}) {
-    return barcodeService.generate(data, type, 'svg', options);
-  }
+  class BarcodeGenerator {
+    /**
+     * Generate a barcode in PNG format
+     * @param {string} data - The data to encode
+     * @param {string} type - The barcode type
+     * @param {Object} options - Generation options
+     * @returns {Buffer} PNG buffer
+     */
+    static png(data, type = 'code128', options = {}) {
+      return barcodeService.generate(data, type, 'png', 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
-   */
-  static html(data, type = 'code128', options = {}) {
-    return barcodeService.generate(data, type, 'html', options);
-  }
+    /**
+     * Generate a barcode in SVG format
+     * @param {string} data - The data to encode
+     * @param {string} type - The barcode type
+     * @param {Object} options - Generation options
+     * @returns {string} SVG string
+     */
+    static svg(data, type = 'code128', options = {}) {
+      return barcodeService.generate(data, type, 'svg', 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
-   */
-  static pdf(data, type = 'code128', options = {}) {
-    return barcodeService.generate(data, type, 'pdf', options);
-  }
+    /**
+     * Generate a barcode in HTML format
+     * @param {string} data - The data to encode
+     * @param {string} type - The barcode type
+     * @param {Object} options - Generation options
+     * @returns {string} HTML string
+     */
+    static html(data, type = 'code128', options = {}) {
+      return barcodeService.generate(data, type, 'html', options);
+    }
 
-  /**
-   * Generate a QR code with advanced features
-   * @param {Object} options - QR code options
-   * @returns {Object} QR code result
-   */
-  static modernQr(options = {}) {
-    return QrCodeBuilder.create(options);
-  }
+    /**
+     * Generate a barcode in PDF format
+     * @param {string} data - The data to encode
+     * @param {string} type - The barcode type
+     * @param {Object} options - Generation options
+     * @returns {Promise<Buffer>} PDF buffer
+     */
+    static async pdf(data, type = 'code128', options = {}) {
+      return barcodeService.generate(data, type, 'pdf', options);
+    }
 
-  /**
-   * Get available barcode types
-   * @returns {Array} Array of barcode types
-   */
-  static getBarcodeTypes() {
-    return BarcodeTypes.getAll();
-  }
+    /**
+     * Generate a QR code
+     * @param {string} data - The data to encode
+     * @param {Object} options - Generation options
+     * @returns {QrCodeBuilder} QR code builder instance
+     */
+    static qrCode(data, options = {}) {
+      return new QrCodeBuilder({ data, ...options });
+    }
 
-  /**
-   * Get available render formats
-   * @returns {Array} Array of render formats
-   */
-  static getRenderFormats() {
-    return RenderFormats.getAll();
-  }
+    /**
+     * Validate barcode data
+     * @param {string} data - The data to validate
+     * @param {string} type - The barcode type
+     * @returns {Object} Validation result
+     */
+    static validate(data, type) {
+      return barcodeService.validate(data, type);
+    }
 
-  /**
-   * Validate data for a specific barcode type
-   * @param {string} data - The data to validate
-   * @param {string} type - The barcode type
-   * @returns {Object} Validation result
-   */
-  static validate(data, type) {
-    return barcodeService.validate(data, type);
-  }
+    /**
+     * Generate multiple barcodes in batch
+     * @param {Array} items - Array of barcode configurations
+     * @returns {Promise<Array>} Array of generated barcodes
+     */
+    static async batch(items) {
+      return barcodeService.batch(items);
+    }
 
-  /**
-   * Generate multiple barcodes in batch
-   * @param {Array} items - Array of barcode generation items
-   * @returns {Array} Array of generated barcodes
-   */
-  static batch(items) {
-    return barcodeService.batch(items);
-  }
+    /**
+     * Get supported barcode types
+     * @returns {Array} Array of supported types
+     */
+    static getBarcodeTypes() {
+      return BarcodeTypes.getTypes();
+    }
 
-  /**
-   * Get watermark positions for QR codes
-   * @returns {Array} Array of watermark positions
-   */
-  static getWatermarkPositions() {
-    return [
-      'top-left',
-      'top-right',
-      'bottom-left',
-      'bottom-right',
-      'center',
-      'top-center',
-      'bottom-center',
-      'left-center',
-      'right-center',
-    ];
-  }
-}
+    /**
+     * Get supported render formats
+     * @returns {Array} Array of supported formats
+     */
+    static getRenderFormats() {
+      return RenderFormats.getFormats();
+    }
 
-// Export main class and utilities
-module.exports = BarcodeGenerator;
-module.exports.BarcodeGenerator = BarcodeGenerator;
-module.exports.BarcodeService = BarcodeService;
-module.exports.QrCodeBuilder = QrCodeBuilder;
-module.exports.BarcodeTypes = BarcodeTypes;
-module.exports.RenderFormats = RenderFormats;
+    /**
+     * Get watermark positions
+     * @returns {Array} Array of watermark positions
+     */
+    static getWatermarkPositions() {
+      return [
+        'top-left',
+        'top-center',
+        'top-right',
+        'left-center',
+        'center',
+        'right-center',
+        'bottom-left',
+        'bottom-center',
+        'bottom-right',
+      ];
+    }
 
-// Default export
-module.exports.default = BarcodeGenerator;
+    /**
+     * Get barcode type information
+     * @param {string} type - The barcode type
+     * @returns {Object} Type information
+     */
+    static getBarcodeTypeInfo(type) {
+      return BarcodeTypes.getTypeInfo(type);
+    }
+
+    /**
+     * Get render format information
+     * @param {string} format - The render format
+     * @returns {Object} Format information
+     */
+    static getRenderFormatInfo(format) {
+      return RenderFormats.getFormatInfo(format);
+    }
+  }
+
+  module.exports = BarcodeGenerator;
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "isahaq-barcode",
-  "version": "1.3.0",
+  "version": "1.7.0",
   "description": "A universal barcode generator package supporting multiple barcode types and output formats, with extra features like batch generation, watermarking, validation, CLI, and Express.js integration",
   "main": "index.js",
   "browser": {
     "fs": false,
     "path": false,
-    "os": false
+    "os": false,
+    "canvas": false
   },
   "bin": {
     "barcode-generate": "./bin/generate.js"
@@ -54,6 +55,10 @@
     "pdfkit": "^0.17.2",
     "qrcode": "^1.5.4"
   },
+  "peerDependencies": {
+    "jsbarcode": "^3.12.1",
+    "qrcode": "^1.5.4"
+  },
   "devDependencies": {
     "@types/node": "^22.10.0",
     "eslint": "^9.38.0",

package/src/builders/QrCodeBuilder.js

@@ -10,7 +10,7 @@ let fs;
 try {
   fs = require('fs').promises;
 } catch {
-  // fs not available in browser environments
+  // fs not available in browser environment
   fs = null;
 }