isahaq-barcode 1.0.0

package/src/validators/Validator.js

@@ -0,0 +1,352 @@
+/**
+ * Validator - Data validation for different barcode types
+ */
+
+const { BarcodeTypes } = require('../types/BarcodeTypes');
+
+class Validator {
+  constructor() {
+    this.patterns = {
+      // Numeric patterns
+      numeric: /^[0-9]+$/,
+      // Alphanumeric patterns
+      alphanumeric: /^[A-Za-z0-9]+$/,
+      // Code 39 pattern
+      code39: /^[A-Z0-9\s\-\.\$\/\+\%]+$/,
+      // Code 39 extended pattern
+      code39extended: /^[\x00-\x7F]+$/,
+      // EAN/UPC patterns
+      ean13: /^[0-9]{12,13}$/,
+      ean8: /^[0-9]{7,8}$/,
+      upca: /^[0-9]{11,12}$/,
+      upce: /^[0-9]{6,8}$/,
+      // QR Code pattern (supports Unicode)
+      qrcode: /^[\s\S]+$/,
+      // Data Matrix pattern
+      datamatrix: /^[\s\S]+$/,
+      // PDF417 pattern
+      pdf417: /^[\s\S]+$/,
+    };
+  }
+
+  /**
+   * 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) {
+    if (!data || typeof data !== 'string') {
+      return {
+        valid: false,
+        error: 'Data must be a non-empty string',
+      };
+    }
+
+    if (!BarcodeTypes.isValid(type)) {
+      return {
+        valid: false,
+        error: `Invalid barcode type: ${type}`,
+      };
+    }
+
+    // Get configuration for the barcode type
+    const config = BarcodeTypes.getConfig(type);
+
+    // Check length constraints
+    if (data.length < config.minLength) {
+      return {
+        valid: false,
+        error: `Data too short. Minimum length: ${config.minLength}`,
+      };
+    }
+
+    if (data.length > config.maxLength) {
+      return {
+        valid: false,
+        error: `Data too long. Maximum length: ${config.maxLength}`,
+      };
+    }
+
+    // Type-specific validation
+    const validationResult = this.validateByType(data, type);
+    if (!validationResult.valid) {
+      return validationResult;
+    }
+
+    return {
+      valid: true,
+      data,
+      type,
+      length: data.length,
+      charset: config.charset,
+    };
+  }
+
+  /**
+   * Validate data by barcode type
+   * @param {string} data - The data to validate
+   * @param {string} type - The barcode type
+   * @returns {Object} Validation result
+   */
+  validateByType(data, type) {
+    switch (type) {
+    case 'code128':
+    case 'code128a':
+    case 'code128b':
+    case 'code128c':
+    case 'code128auto':
+      return this.validateCode128(data, type);
+
+    case 'code39':
+    case 'code39extended':
+    case 'code39checksum':
+    case 'code39auto':
+      return this.validateCode39(data, type);
+
+    case 'code93':
+      return this.validateCode93(data);
+
+    case 'ean13':
+      return this.validateEAN13(data);
+
+    case 'ean8':
+      return this.validateEAN8(data);
+
+    case 'upca':
+      return this.validateUPCA(data);
+
+    case 'upce':
+      return this.validateUPCE(data);
+
+    case 'qrcode':
+      return this.validateQRCode(data);
+
+    case 'datamatrix':
+      return this.validateDataMatrix(data);
+
+    case 'pdf417':
+      return this.validatePDF417(data);
+
+    default:
+      // For other types, just check if data is not empty
+      return {
+        valid: data.length > 0,
+        error: data.length === 0 ? 'Data cannot be empty' : null,
+      };
+    }
+  }
+
+  /**
+   * Validate Code 128 data
+   * @param {string} data - The data to validate
+   * @param {string} type - The Code 128 variant
+   * @returns {Object} Validation result
+   */
+  validateCode128(data) {
+    // Code 128 supports ASCII characters
+    if (!/^[\x00-\x7F]+$/.test(data)) {
+      return {
+        valid: false,
+        error: 'Code 128 supports ASCII characters only',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate Code 39 data
+   * @param {string} data - The data to validate
+   * @param {string} type - The Code 39 variant
+   * @returns {Object} Validation result
+   */
+  validateCode39(data, type) {
+    if (type === 'code39extended') {
+      // Extended Code 39 supports full ASCII
+      if (!/^[\x00-\x7F]+$/.test(data)) {
+        return {
+          valid: false,
+          error: 'Extended Code 39 supports ASCII characters only',
+        };
+      }
+    } else {
+      // Standard Code 39 supports limited character set
+      if (!this.patterns.code39.test(data)) {
+        return {
+          valid: false,
+          error: 'Code 39 supports characters: A-Z, 0-9, space, -.$/+%',
+        };
+      }
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate Code 93 data
+   * @param {string} data - The data to validate
+   * @returns {Object} Validation result
+   */
+  validateCode93(data) {
+    if (!this.patterns.alphanumeric.test(data)) {
+      return {
+        valid: false,
+        error: 'Code 93 supports alphanumeric characters only',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate EAN-13 data
+   * @param {string} data - The data to validate
+   * @returns {Object} Validation result
+   */
+  validateEAN13(data) {
+    if (!this.patterns.ean13.test(data)) {
+      return {
+        valid: false,
+        error: 'EAN-13 must be 12 or 13 digits',
+      };
+    }
+
+    // Validate check digit if 13 digits provided
+    if (data.length === 13) {
+      const checkDigit = this.calculateEANCheckDigit(data.substring(0, 12));
+      if (parseInt(data[12]) !== checkDigit) {
+        return {
+          valid: false,
+          error: 'Invalid EAN-13 check digit',
+        };
+      }
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate EAN-8 data
+   * @param {string} data - The data to validate
+   * @returns {Object} Validation result
+   */
+  validateEAN8(data) {
+    if (!this.patterns.ean8.test(data)) {
+      return {
+        valid: false,
+        error: 'EAN-8 must be 7 or 8 digits',
+      };
+    }
+
+    // Validate check digit if 8 digits provided
+    if (data.length === 8) {
+      const checkDigit = this.calculateEANCheckDigit(data.substring(0, 7));
+      if (parseInt(data[7]) !== checkDigit) {
+        return {
+          valid: false,
+          error: 'Invalid EAN-8 check digit',
+        };
+      }
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate UPC-A data
+   * @param {string} data - The data to validate
+   * @returns {Object} Validation result
+   */
+  validateUPCA(data) {
+    if (!this.patterns.upca.test(data)) {
+      return {
+        valid: false,
+        error: 'UPC-A must be 11 or 12 digits',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate UPC-E data
+   * @param {string} data - The data to validate
+   * @returns {Object} Validation result
+   */
+  validateUPCE(data) {
+    if (!this.patterns.upce.test(data)) {
+      return {
+        valid: false,
+        error: 'UPC-E must be 6 to 8 digits',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate QR Code data
+   * @param {string} data - The data to validate
+   * @returns {Object} Validation result
+   */
+  validateQRCode(data) {
+    // QR Code supports Unicode, so we just check if it's not empty
+    if (data.length === 0) {
+      return {
+        valid: false,
+        error: 'QR Code data cannot be empty',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate Data Matrix data
+   * @param {string} data - The data to validate
+   * @returns {Object} Validation result
+   */
+  validateDataMatrix(data) {
+    if (data.length === 0) {
+      return {
+        valid: false,
+        error: 'Data Matrix data cannot be empty',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate PDF417 data
+   * @param {string} data - The data to validate
+   * @returns {Object} Validation result
+   */
+  validatePDF417(data) {
+    if (data.length === 0) {
+      return {
+        valid: false,
+        error: 'PDF417 data cannot be empty',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Calculate EAN check digit
+   * @param {string} data - The data without check digit
+   * @returns {number} Check digit
+   */
+  calculateEANCheckDigit(data) {
+    let sum = 0;
+    for (let i = 0; i < data.length; i++) {
+      const digit = parseInt(data[i]);
+      sum += i % 2 === 0 ? digit : digit * 3;
+    }
+    return (10 - (sum % 10)) % 10;
+  }
+}
+
+module.exports = { Validator };

package/tests/BarcodeGenerator.test.js

@@ -0,0 +1,187 @@
+/**
+ * Tests for BarcodeGenerator
+ */
+
+const BarcodeGenerator = require('../index');
+
+describe('BarcodeGenerator', () => {
+  describe('PNG Generation', () => {
+    test('should generate PNG barcode', () => {
+      const result = BarcodeGenerator.png('1234567890', 'code128');
+      expect(Buffer.isBuffer(result)).toBe(true);
+    });
+
+    test('should generate PNG barcode with options', () => {
+      const options = {
+        width: 3,
+        height: 150,
+        displayValue: false,
+      };
+      const result = BarcodeGenerator.png('1234567890', 'code128', options);
+      expect(Buffer.isBuffer(result)).toBe(true);
+    });
+
+    test('should throw error for invalid data', () => {
+      expect(() => {
+        BarcodeGenerator.png('', 'code128');
+      }).toThrow('Data must be a non-empty string');
+    });
+
+    test('should throw error for invalid barcode type', () => {
+      expect(() => {
+        BarcodeGenerator.png('1234567890', 'invalid-type');
+      }).toThrow('Invalid barcode type');
+    });
+  });
+
+  describe('SVG Generation', () => {
+    test('should generate SVG barcode', () => {
+      const result = BarcodeGenerator.svg('1234567890', 'code128');
+      expect(typeof result).toBe('string');
+      expect(result).toContain('<svg');
+    });
+
+    test('should generate SVG barcode with options', () => {
+      const options = {
+        width: 3,
+        height: 150,
+        displayValue: false,
+      };
+      const result = BarcodeGenerator.svg('1234567890', 'code128', options);
+      expect(typeof result).toBe('string');
+    });
+  });
+
+  describe('HTML Generation', () => {
+    test('should generate HTML barcode', () => {
+      const result = BarcodeGenerator.html('1234567890', 'code128');
+      expect(typeof result).toBe('string');
+      expect(result).toContain('<div');
+    });
+
+    test('should generate HTML barcode with options', () => {
+      const options = {
+        width: 3,
+        height: 150,
+        displayValue: false,
+      };
+      const result = BarcodeGenerator.html('1234567890', 'code128', options);
+      expect(typeof result).toBe('string');
+    });
+  });
+
+  describe('PDF Generation', () => {
+    test('should generate PDF barcode', async () => {
+      const result = await BarcodeGenerator.pdf('1234567890', 'code128');
+      expect(Buffer.isBuffer(result)).toBe(true);
+    });
+
+    test('should generate PDF barcode with options', async () => {
+      const options = {
+        width: 3,
+        height: 150,
+        displayValue: false,
+      };
+      const result = await BarcodeGenerator.pdf(
+        '1234567890',
+        'code128',
+        options
+      );
+      expect(Buffer.isBuffer(result)).toBe(true);
+    });
+  });
+
+  describe('QR Code Generation', () => {
+    test('should generate QR code', () => {
+      const result = BarcodeGenerator.modernQr({
+        data: 'https://example.com',
+        size: 300,
+      });
+      expect(result).toBeDefined();
+      expect(typeof result.generate).toBe('function');
+    });
+
+    test('should generate QR code with logo', () => {
+      const result = BarcodeGenerator.modernQr({
+        data: 'https://example.com',
+        size: 300,
+        logoPath: 'path/to/logo.png',
+        logoSize: 60,
+      });
+      expect(result).toBeDefined();
+    });
+
+    test('should generate QR code with watermark', () => {
+      const result = BarcodeGenerator.modernQr({
+        data: 'https://example.com',
+        size: 300,
+        watermark: 'Watermark Text',
+        watermarkPosition: 'center',
+      });
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('Validation', () => {
+    test('should validate data for Code 128', () => {
+      const validation = BarcodeGenerator.validate('1234567890', 'code128');
+      expect(validation.valid).toBe(true);
+    });
+
+    test('should validate data for EAN-13', () => {
+      const validation = BarcodeGenerator.validate('1234567890123', 'ean13');
+      expect(validation.valid).toBe(true);
+    });
+
+    test('should reject invalid data for EAN-13', () => {
+      const validation = BarcodeGenerator.validate('123', 'ean13');
+      expect(validation.valid).toBe(false);
+      expect(validation.error).toContain('too short');
+    });
+  });
+
+  describe('Batch Generation', () => {
+    test('should generate multiple barcodes', () => {
+      const items = [
+        { data: '1234567890', type: 'code128', format: 'png' },
+        { data: '9876543210', type: 'code39', format: 'svg' },
+      ];
+      const results = BarcodeGenerator.batch(items);
+      expect(Array.isArray(results)).toBe(true);
+      expect(results.length).toBe(2);
+    });
+
+    test('should handle batch generation errors', () => {
+      const items = [
+        { data: '1234567890', type: 'code128', format: 'png' },
+        { data: '', type: 'code128', format: 'png' }, // Invalid data
+      ];
+      const results = BarcodeGenerator.batch(items);
+      expect(results[0].success).toBe(true);
+      expect(results[1].success).toBe(false);
+    });
+  });
+
+  describe('Utility Methods', () => {
+    test('should get barcode types', () => {
+      const types = BarcodeGenerator.getBarcodeTypes();
+      expect(Array.isArray(types)).toBe(true);
+      expect(types).toContain('code128');
+      expect(types).toContain('ean13');
+    });
+
+    test('should get render formats', () => {
+      const formats = BarcodeGenerator.getRenderFormats();
+      expect(Array.isArray(formats)).toBe(true);
+      expect(formats).toContain('png');
+      expect(formats).toContain('svg');
+    });
+
+    test('should get watermark positions', () => {
+      const positions = BarcodeGenerator.getWatermarkPositions();
+      expect(Array.isArray(positions)).toBe(true);
+      expect(positions).toContain('center');
+      expect(positions).toContain('top-left');
+    });
+  });
+});

package/tests/BarcodeService.test.js

@@ -0,0 +1,76 @@
+/**
+ * Tests for BarcodeService
+ */
+
+const BarcodeService = require('../src/services/BarcodeService');
+
+describe('BarcodeService', () => {
+  let service;
+
+  beforeEach(() => {
+    service = new BarcodeService();
+  });
+
+  describe('PNG Generation', () => {
+    test('should generate PNG barcode', () => {
+      const result = service.png('1234567890', 'code128');
+      expect(Buffer.isBuffer(result)).toBe(true);
+    });
+
+    test('should generate PNG barcode with options', () => {
+      const options = {
+        width: 3,
+        height: 150,
+        displayValue: false,
+      };
+      const result = service.png('1234567890', 'code128', options);
+      expect(Buffer.isBuffer(result)).toBe(true);
+    });
+  });
+
+  describe('SVG Generation', () => {
+    test('should generate SVG barcode', () => {
+      const result = service.svg('1234567890', 'code128');
+      expect(typeof result).toBe('string');
+    });
+  });
+
+  describe('HTML Generation', () => {
+    test('should generate HTML barcode', () => {
+      const result = service.html('1234567890', 'code128');
+      expect(typeof result).toBe('string');
+      expect(result).toContain('<div');
+    });
+  });
+
+  describe('PDF Generation', () => {
+    test('should generate PDF barcode', async () => {
+      const result = await service.pdf('1234567890', 'code128');
+      expect(Buffer.isBuffer(result)).toBe(true);
+    });
+  });
+
+  describe('Validation', () => {
+    test('should validate data', () => {
+      const validation = service.validate('1234567890', 'code128');
+      expect(validation.valid).toBe(true);
+    });
+
+    test('should reject invalid data', () => {
+      const validation = service.validate('', 'code128');
+      expect(validation.valid).toBe(false);
+    });
+  });
+
+  describe('Batch Generation', () => {
+    test('should generate multiple barcodes', () => {
+      const items = [
+        { data: '1234567890', type: 'code128', format: 'png' },
+        { data: '9876543210', type: 'code39', format: 'svg' },
+      ];
+      const results = service.batch(items);
+      expect(Array.isArray(results)).toBe(true);
+      expect(results.length).toBe(2);
+    });
+  });
+});