isahaq-barcode 1.0.0

package/bin/generate.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+/**
+ * CLI for Isahaq Barcode Generator
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const ora = require('ora');
+const fs = require('fs').promises;
+const path = require('path');
+const BarcodeGenerator = require('../index');
+
+const program = new Command();
+
+program
+  .name('barcode-generate')
+  .description('Generate barcodes and QR codes from command line')
+  .version('1.0.0');
+
+// Barcode generation command
+program
+  .command('barcode')
+  .description('Generate a barcode')
+  .requiredOption('-d, --data <data>', 'Data to encode')
+  .option('-t, --type <type>', 'Barcode type', 'code128')
+  .option('-f, --format <format>', 'Output format (png, svg, html, pdf)', 'png')
+  .option('-o, --output <file>', 'Output file path')
+  .option('-w, --width <width>', 'Barcode width', '2')
+  .option('-h, --height <height>', 'Barcode height', '100')
+  .option('--no-text', 'Hide text below barcode')
+  .option('--foreground <color>', 'Foreground color (hex)', '#000000')
+  .option('--background <color>', 'Background color (hex)', '#ffffff')
+  .action(async (options) => {
+    const spinner = ora('Generating barcode...').start();
+
+    try {
+      const renderOptions = {
+        width: parseInt(options.width),
+        height: parseInt(options.height),
+        displayValue: options.text,
+        lineColor: options.foreground,
+        background: options.background,
+      };
+
+      let result;
+      switch (options.format) {
+      case 'png':
+        result = BarcodeGenerator.png(
+          options.data,
+          options.type,
+          renderOptions
+        );
+        break;
+      case 'svg':
+        result = BarcodeGenerator.svg(
+          options.data,
+          options.type,
+          renderOptions
+        );
+        break;
+      case 'html':
+        result = BarcodeGenerator.html(
+          options.data,
+          options.type,
+          renderOptions
+        );
+        break;
+      case 'pdf':
+        result = BarcodeGenerator.pdf(
+          options.data,
+          options.type,
+          renderOptions
+        );
+        break;
+      default:
+        throw new Error(`Unsupported format: ${options.format}`);
+      }
+
+      if (options.output) {
+        await fs.writeFile(options.output, result);
+        spinner.succeed(`Barcode saved to ${options.output}`);
+      } else {
+        // Output to stdout (for base64 encoding)
+        if (Buffer.isBuffer(result)) {
+          console.log(result.toString('base64'));
+        } else {
+          console.log(result);
+        }
+      }
+    } catch (error) {
+      spinner.fail(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// QR code generation command
+program
+  .command('qr')
+  .description('Generate a QR code')
+  .requiredOption('-d, --data <data>', 'Data to encode')
+  .option('-s, --size <size>', 'QR code size', '300')
+  .option('-f, --format <format>', 'Output format (png, svg, jpg)', 'png')
+  .option('-o, --output <file>', 'Output file path')
+  .option('-m, --margin <margin>', 'Margin size', '10')
+  .option(
+    '-e, --error-correction <level>',
+    'Error correction level (L, M, Q, H)',
+    'M'
+  )
+  .option('--foreground <color>', 'Foreground color (hex)', '#000000')
+  .option('--background <color>', 'Background color (hex)', '#ffffff')
+  .option('--logo <path>', 'Logo image path')
+  .option('--logo-size <size>', 'Logo size percentage', '60')
+  .option('--label <text>', 'Label text')
+  .option('--watermark <text>', 'Watermark text')
+  .option('--watermark-position <position>', 'Watermark position', 'center')
+  .action(async (options) => {
+    const spinner = ora('Generating QR code...').start();
+
+    try {
+      const qrOptions = {
+        data: options.data,
+        size: parseInt(options.size),
+        margin: parseInt(options.margin),
+        errorCorrectionLevel: options.errorCorrection,
+        foregroundColor: hexToRgb(options.foreground),
+        backgroundColor: hexToRgb(options.background),
+        format: options.format,
+      };
+
+      if (options.logo) {
+        qrOptions.logoPath = options.logo;
+        qrOptions.logoSize = parseInt(options.logoSize);
+      }
+
+      if (options.label) {
+        qrOptions.label = options.label;
+      }
+
+      if (options.watermark) {
+        qrOptions.watermark = options.watermark;
+        qrOptions.watermarkPosition = options.watermarkPosition;
+      }
+
+      const qrCode = BarcodeGenerator.modernQr(qrOptions);
+      const result = await qrCode.generate();
+
+      if (options.output) {
+        await fs.writeFile(options.output, result);
+        spinner.succeed(`QR code saved to ${options.output}`);
+      } else {
+        // Output to stdout (for base64 encoding)
+        console.log(result.toString('base64'));
+      }
+    } catch (error) {
+      spinner.fail(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// Batch generation command
+program
+  .command('batch')
+  .description('Generate multiple barcodes from a JSON file')
+  .requiredOption('-i, --input <file>', 'Input JSON file')
+  .option('-o, --output-dir <dir>', 'Output directory', './output')
+  .action(async (options) => {
+    const spinner = ora('Processing batch generation...').start();
+
+    try {
+      const inputData = JSON.parse(await fs.readFile(options.input, 'utf8'));
+
+      if (!Array.isArray(inputData)) {
+        throw new Error(
+          'Input file must contain an array of barcode configurations'
+        );
+      }
+
+      // Create output directory if it doesn't exist
+      await fs.mkdir(options.outputDir, { recursive: true });
+
+      const results = BarcodeGenerator.batch(inputData);
+
+      let successCount = 0;
+      let errorCount = 0;
+
+      for (const result of results) {
+        if (result.success) {
+          const filename = `barcode_${result.index}.${result.format}`;
+          const filepath = path.join(options.outputDir, filename);
+          await fs.writeFile(filepath, result.result);
+          successCount++;
+        } else {
+          errorCount++;
+          console.error(
+            chalk.red(`Error in item ${result.index}: ${result.error}`)
+          );
+        }
+      }
+
+      spinner.succeed(
+        `Batch generation completed: ${successCount} successful, ${errorCount} errors`
+      );
+    } catch (error) {
+      spinner.fail(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// List supported types command
+program
+  .command('types')
+  .description('List supported barcode types')
+  .action(() => {
+    const types = BarcodeGenerator.getBarcodeTypes();
+    console.log(chalk.blue('Supported barcode types:'));
+    types.forEach((type) => {
+      console.log(`  - ${type}`);
+    });
+  });
+
+// List supported formats command
+program
+  .command('formats')
+  .description('List supported output formats')
+  .action(() => {
+    const formats = BarcodeGenerator.getRenderFormats();
+    console.log(chalk.blue('Supported output formats:'));
+    formats.forEach((format) => {
+      console.log(`  - ${format}`);
+    });
+  });
+
+// Validate data command
+program
+  .command('validate')
+  .description('Validate data for a specific barcode type')
+  .requiredOption('-d, --data <data>', 'Data to validate')
+  .requiredOption('-t, --type <type>', 'Barcode type')
+  .action((options) => {
+    try {
+      const validation = BarcodeGenerator.validate(options.data, options.type);
+
+      if (validation.valid) {
+        console.log(chalk.green('✓ Data is valid'));
+        console.log(`  Type: ${validation.type}`);
+        console.log(`  Length: ${validation.length}`);
+        console.log(`  Charset: ${validation.charset}`);
+      } else {
+        console.log(chalk.red('✗ Data is invalid'));
+        console.log(`  Error: ${validation.error}`);
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Validation error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// Helper function to convert hex to RGB
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result
+    ? [
+      parseInt(result[1], 16),
+      parseInt(result[2], 16),
+      parseInt(result[3], 16),
+    ]
+    : [0, 0, 0];
+}
+
+// Parse command line arguments
+program.parse();

package/eslint.config.js

@@ -0,0 +1,68 @@
+module.exports = [
+  {
+    files: ['**/*.js'],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      globals: {
+        console: 'readonly',
+        process: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        global: 'readonly',
+        module: 'readonly',
+        require: 'readonly',
+        exports: 'readonly',
+        document: 'readonly'
+      }
+    },
+    rules: {
+      'indent': ['error', 2],
+      'quotes': ['error', 'single'],
+      'semi': ['error', 'always'],
+      'no-unused-vars': 'warn',
+      'no-console': 'off',
+      'no-undef': 'error',
+      'no-trailing-spaces': 'error',
+      'eol-last': 'error'
+    }
+  },
+  {
+    files: ['tests/**/*.js', '**/*.test.js'],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      globals: {
+        console: 'readonly',
+        process: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        global: 'readonly',
+        module: 'readonly',
+        require: 'readonly',
+        exports: 'readonly',
+        describe: 'readonly',
+        test: 'readonly',
+        it: 'readonly',
+        expect: 'readonly',
+        beforeEach: 'readonly',
+        afterEach: 'readonly',
+        beforeAll: 'readonly',
+        afterAll: 'readonly',
+        jest: 'readonly'
+      }
+    },
+    rules: {
+      'indent': ['error', 2],
+      'quotes': ['error', 'single'],
+      'semi': ['error', 'always'],
+      'no-unused-vars': 'warn',
+      'no-console': 'off',
+      'no-undef': 'error',
+      'no-trailing-spaces': 'error',
+      'eol-last': 'error'
+    }
+  }
+];

package/examples/basic-usage.js

@@ -0,0 +1,58 @@
+/**
+ * Basic usage examples for Isahaq Barcode Generator
+ */
+
+const BarcodeGenerator = require('../index');
+
+async function basicExamples() {
+  console.log('🚀 Basic Barcode Generation Examples\n');
+
+  // 1. Generate PNG barcode
+  console.log('1. Generating PNG barcode...');
+  const pngBuffer = BarcodeGenerator.png('1234567890', 'code128');
+  console.log(`   PNG buffer size: ${pngBuffer.length} bytes`);
+
+  // 2. Generate SVG barcode
+  console.log('2. Generating SVG barcode...');
+  const svgString = BarcodeGenerator.svg('1234567890', 'ean13');
+  console.log(`   SVG length: ${svgString.length} characters`);
+
+  // 3. Generate HTML barcode
+  console.log('3. Generating HTML barcode...');
+  const htmlString = BarcodeGenerator.html('1234567890', 'code39');
+  console.log(`   HTML length: ${htmlString.length} characters`);
+
+  // 4. Generate PDF barcode
+  console.log('4. Generating PDF barcode...');
+  const pdfBuffer = await BarcodeGenerator.pdf('1234567890', 'code128');
+  console.log(`   PDF buffer size: ${pdfBuffer.length} bytes`);
+
+  // 5. Generate QR code
+  console.log('5. Generating QR code...');
+  const qrCode = BarcodeGenerator.modernQr({
+    data: 'https://example.com',
+    size: 300,
+    margin: 10,
+  });
+  const qrBuffer = await qrCode.generate();
+  console.log(`   QR code buffer size: ${qrBuffer.length} bytes`);
+
+  // 6. Generate QR code with logo
+  console.log('6. Generating QR code with logo...');
+  const qrWithLogo = BarcodeGenerator.modernQr({
+    data: 'https://example.com',
+    size: 300,
+    logoPath: 'path/to/logo.png',
+    logoSize: 60,
+    label: 'Scan me!',
+  });
+  const qrWithLogoBuffer = await qrWithLogo.generate();
+  console.log(
+    `   QR code with logo buffer size: ${qrWithLogoBuffer.length} bytes`
+  );
+
+  console.log('\n✅ All examples completed successfully!');
+}
+
+// Run examples
+basicExamples().catch(console.error);

package/examples/batch-example.json

@@ -0,0 +1,56 @@
+[
+  {
+    "data": "1234567890",
+    "type": "code128",
+    "format": "png",
+    "options": {
+      "width": 3,
+      "height": 150,
+      "displayValue": true
+    }
+  },
+  {
+    "data": "9876543210",
+    "type": "code39",
+    "format": "svg",
+    "options": {
+      "width": 2,
+      "height": 100,
+      "displayValue": false
+    }
+  },
+  {
+    "data": "1234567890123",
+    "type": "ean13",
+    "format": "png",
+    "options": {
+      "width": 2,
+      "height": 120,
+      "displayValue": true
+    }
+  },
+  {
+    "data": "https://example.com",
+    "type": "qrcode",
+    "format": "png",
+    "options": {
+      "size": 300,
+      "margin": 10,
+      "logoPath": "path/to/logo.png",
+      "logoSize": 60,
+      "label": "Scan me!"
+    }
+  },
+  {
+    "data": "https://github.com",
+    "type": "qrcode",
+    "format": "png",
+    "options": {
+      "size": 400,
+      "margin": 15,
+      "watermark": "GitHub",
+      "watermarkPosition": "center",
+      "errorCorrectionLevel": "H"
+    }
+  }
+]

package/examples/express-server.js

@@ -0,0 +1,159 @@
+/**
+ * Express.js server example for Isahaq Barcode Generator
+ */
+
+const express = require('express');
+const BarcodeGenerator = require('../index');
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// Middleware
+app.use(express.json());
+app.use(express.static('public'));
+
+// Barcode generation endpoint
+app.get('/barcode/:data', async (req, res) => {
+  const { data } = req.params;
+  const { type = 'code128', format = 'png', width, height } = req.query;
+
+  try {
+    const options = {};
+    if (width) options.width = parseInt(width);
+    if (height) options.height = parseInt(height);
+
+    let result;
+    let contentType;
+
+    switch (format) {
+    case 'png':
+      result = BarcodeGenerator.png(data, type, options);
+      contentType = 'image/png';
+      break;
+    case 'svg':
+      result = BarcodeGenerator.svg(data, type, options);
+      contentType = 'image/svg+xml';
+      break;
+    case 'html':
+      result = BarcodeGenerator.html(data, type, options);
+      contentType = 'text/html';
+      break;
+    case 'pdf':
+      result = await BarcodeGenerator.pdf(data, type, options);
+      contentType = 'application/pdf';
+      break;
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+    }
+
+    res.set('Content-Type', contentType);
+    res.send(result);
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// QR code generation endpoint
+app.get('/qr/:data', async (req, res) => {
+  const { data } = req.params;
+  const {
+    size = 300,
+    logo,
+    label,
+    watermark,
+    watermarkPosition = 'center',
+    errorCorrection = 'M'
+  } = req.query;
+
+  try {
+    const qrOptions = {
+      data: decodeURIComponent(data),
+      size: parseInt(size),
+      errorCorrectionLevel: errorCorrection
+    };
+
+    if (logo) qrOptions.logoPath = logo;
+    if (label) qrOptions.label = label;
+    if (watermark) {
+      qrOptions.watermark = watermark;
+      qrOptions.watermarkPosition = watermarkPosition;
+    }
+
+    const qrCode = BarcodeGenerator.modernQr(qrOptions);
+    const result = await qrCode.generate();
+
+    res.set('Content-Type', 'image/png');
+    res.send(result);
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// Batch generation endpoint
+app.post('/batch', async (req, res) => {
+  try {
+    const { items } = req.body;
+
+    if (!Array.isArray(items)) {
+      throw new Error('Items must be an array');
+    }
+
+    const results = BarcodeGenerator.batch(items);
+    res.json({ results });
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// Validation endpoint
+app.get('/validate/:data/:type', (req, res) => {
+  const { data, type } = req.params;
+
+  try {
+    const validation = BarcodeGenerator.validate(data, type);
+    res.json(validation);
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// Get supported types
+app.get('/types', (req, res) => {
+  const types = BarcodeGenerator.getBarcodeTypes();
+  res.json({ types });
+});
+
+// Get supported formats
+app.get('/formats', (req, res) => {
+  const formats = BarcodeGenerator.getRenderFormats();
+  res.json({ formats });
+});
+
+// Get watermark positions
+app.get('/watermark-positions', (req, res) => {
+  const positions = BarcodeGenerator.getWatermarkPositions();
+  res.json({ positions });
+});
+
+// Health check
+app.get('/health', (req, res) => {
+  res.json({ status: 'OK', timestamp: new Date().toISOString() });
+});
+
+// Error handling middleware
+app.use((error, req, res) => {
+  console.error('Error:', error);
+  res.status(500).json({ error: 'Internal server error' });
+});
+
+// Start server
+app.listen(PORT, () => {
+  console.log(`🚀 Server running on http://localhost:${PORT}`);
+  console.log(`📊 Health check: http://localhost:${PORT}/health`);
+  console.log(`🔗 Barcode endpoint: http://localhost:${PORT}/barcode/{data}?type=code128&format=png`);
+  console.log(`🔗 QR code endpoint: http://localhost:${PORT}/qr/{data}?size=300`);
+  console.log(`🔗 Types endpoint: http://localhost:${PORT}/types`);
+  console.log(`🔗 Formats endpoint: http://localhost:${PORT}/formats`);
+});
+
+module.exports = app;