isahaq-barcode 1.9.0 → 2.0.0

package/bin/generate.js

@@ -5,20 +5,91 @@
  */
 
 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 { version } = require('../package.json');
+
+/** Minimal ANSI colouring - honours NO_COLOR and non-TTY output */
+const useColor =
+  !process.env.NO_COLOR && process.stderr.isTTY && process.env.TERM !== 'dumb';
+
+const color = {
+  red: text => (useColor ? `${text}` : text),
+  green: text => (useColor ? `${text}` : text),
+  blue: text => (useColor ? `${text}` : text),
+  dim: text => (useColor ? `${text}` : text),
+};
+
+/**
+ * Report progress on stderr so stdout stays pipeable
+ * @param {string} message - Message to print
+ */
+function status(message) {
+  process.stderr.write(`${color.dim(message)}\n`);
+}
+
+/**
+ * Report success on stderr
+ * @param {string} message - Message to print
+ */
+function succeed(message) {
+  process.stderr.write(`${color.green('✔')} ${message}\n`);
+}
+
+/**
+ * Print an error and exit with a non-zero status
+ * @param {string} message - Message to print
+ */
+function fail(message) {
+  process.stderr.write(`${color.red('✖')} ${message}\n`);
+  process.exit(1);
+}
+
+/**
+ * Convert a hex colour into an RGB array
+ * @param {string} hex - Hex colour
+ * @returns {number[]} RGB components
+ */
+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];
+}
+
+/**
+ * Write output to a file, or to stdout when no path is given
+ * @param {Buffer|string} result - Generated barcode
+ * @param {string|undefined} output - Output file path
+ * @param {string} label - Label used in the success message
+ * @returns {Promise<void>}
+ */
+async function emit(result, output, label) {
+  if (output) {
+    await fs.writeFile(output, result);
+    succeed(`${label} saved to ${output}`);
+    return;
+  }
+
+  if (Buffer.isBuffer(result)) {
+    process.stdout.write(`${result.toString('base64')}\n`);
+  } else {
+    process.stdout.write(`${result}\n`);
+  }
+}
 
 const program = new Command();
 
 program
   .name('barcode-generate')
-  .description('Generate barcodes and QR codes from command line')
-  .version('1.0.0');
+  .description('Generate barcodes and QR codes from the command line')
+  .version(version);
 
-// Barcode generation command
 program
   .command('barcode')
   .description('Generate a barcode')
@@ -26,103 +97,83 @@ program
   .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')
+  .option('-w, --width <width>', 'Module (narrow bar) width in pixels', '2')
+  .option('-h, --height <height>', 'Bar height in pixels', '100')
+  .option('-s, --size <size>', 'Target size in pixels for 2D barcodes')
+  .option('-m, --margin <margin>', 'Quiet zone in pixels (default: 10 modules)')
+  .option('-q, --quiet-zone <modules>', 'Quiet zone in modules', '10')
+  .option('--no-text', 'Hide the human readable text')
+  .option('--foreground <color>', 'Foreground colour (hex)', '#000000')
+  .option('--background <color>', 'Background colour (hex)', '#ffffff')
+  .option('--rotate <rotation>', 'Rotation: N, R, L or I', 'N')
   .action(async options => {
-    const spinner = ora('Generating barcode...').start();
+    status('Generating barcode...');
 
     try {
       const renderOptions = {
-        width: parseInt(options.width),
-        height: parseInt(options.height),
+        width: parseInt(options.width, 10),
+        height: parseInt(options.height, 10),
+        quietZone: parseInt(options.quietZone, 10),
         displayValue: options.text,
         lineColor: options.foreground,
         background: options.background,
+        rotate: options.rotate,
       };
 
-      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}`);
+      // Only override the module based quiet zone when a pixel margin is asked for
+      if (options.margin !== undefined) {
+        renderOptions.margin = parseInt(options.margin, 10);
       }
 
-      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);
-        }
+      if (options.size) {
+        renderOptions.size = parseInt(options.size, 10);
       }
+
+      const result = await BarcodeGenerator.generate(
+        options.data,
+        options.type,
+        options.format,
+        renderOptions
+      );
+
+      await emit(result, options.output, 'Barcode');
     } catch (error) {
-      spinner.fail(`Error: ${error.message}`);
-      process.exit(1);
+      fail(error.message);
     }
   });
 
-// 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('-s, --size <size>', 'QR code size in pixels', '300')
+  .option('-f, --format <format>', 'Output format (png, jpeg, svg)', 'png')
   .option('-o, --output <file>', 'Output file path')
-  .option('-m, --margin <margin>', 'Margin size', '10')
+  .option('-m, --margin <margin>', 'Margin in pixels', '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('--foreground <color>', 'Foreground colour (hex)', '#000000')
+  .option('--background <color>', 'Background colour (hex)', '#ffffff')
+  .option('--logo <path>', 'Logo image path (requires the canvas package)')
+  .option(
+    '--logo-size <size>',
+    'Logo size as a percentage of the QR code',
+    '20'
+  )
+  .option('--label <text>', 'Label text (requires the canvas package)')
+  .option('--watermark <text>', 'Watermark text or image path')
   .option('--watermark-position <position>', 'Watermark position', 'center')
   .action(async options => {
-    const spinner = ora('Generating QR code...').start();
+    status('Generating QR code...');
 
     try {
       const qrOptions = {
         data: options.data,
-        size: parseInt(options.size),
-        margin: parseInt(options.margin),
+        size: parseInt(options.size, 10),
+        margin: parseInt(options.margin, 10),
         errorCorrectionLevel: options.errorCorrection,
         foregroundColor: hexToRgb(options.foreground),
         backgroundColor: hexToRgb(options.background),
@@ -131,7 +182,7 @@ program
 
       if (options.logo) {
         qrOptions.logoPath = options.logo;
-        qrOptions.logoSize = parseInt(options.logoSize);
+        qrOptions.logoSize = parseInt(options.logoSize, 10);
       }
 
       if (options.label) {
@@ -143,30 +194,20 @@ program
         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'));
-      }
+      const result = await BarcodeGenerator.modernQr(qrOptions).generate();
+      await emit(result, options.output, 'QR code');
     } catch (error) {
-      spinner.fail(`Error: ${error.message}`);
-      process.exit(1);
+      fail(error.message);
     }
   });
 
-// 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();
+    status('Processing batch generation...');
 
     try {
       const inputData = JSON.parse(await fs.readFile(options.input, 'utf8'));
@@ -177,10 +218,9 @@ program
         );
       }
 
-      // Create output directory if it doesn't exist
       await fs.mkdir(options.outputDir, { recursive: true });
 
-      const results = BarcodeGenerator.batch(inputData);
+      const results = await BarcodeGenerator.batch(inputData);
 
       let successCount = 0;
       let errorCount = 0;
@@ -188,87 +228,84 @@ program
       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);
+          await fs.writeFile(
+            path.join(options.outputDir, filename),
+            result.result
+          );
           successCount++;
         } else {
           errorCount++;
-          console.error(
-            chalk.red(`Error in item ${result.index}: ${result.error}`)
+          process.stderr.write(
+            `${color.red(`Error in item ${result.index}:`)} ${result.error}\n`
           );
         }
       }
 
-      spinner.succeed(
-        `Batch generation completed: ${successCount} successful, ${errorCount} errors`
+      succeed(
+        `Batch generation completed: ${successCount} successful, ${errorCount} failed`
       );
+
+      if (errorCount > 0) {
+        process.exitCode = 1;
+      }
     } catch (error) {
-      spinner.fail(`Error: ${error.message}`);
-      process.exit(1);
+      fail(error.message);
     }
   });
 
-// List supported types command
 program
   .command('types')
   .description('List supported barcode types')
-  .action(() => {
-    const types = BarcodeGenerator.getBarcodeTypes();
-    console.log(chalk.blue('Supported barcode types:'));
+  .option('-c, --category <category>', 'Only list types in this category')
+  .action(options => {
+    const types = options.category
+      ? BarcodeGenerator.getBarcodeTypesByCategory(options.category)
+      : BarcodeGenerator.getBarcodeTypes();
+
+    if (!types.length) {
+      fail(
+        `Unknown category: ${options.category}. Categories: ${BarcodeGenerator.getBarcodeCategories().join(
+          ', '
+        )}`
+      );
+    }
+
+    process.stderr.write(`${color.blue('Supported barcode types:')}\n`);
     types.forEach(type => {
-      console.log(`  - ${type}`);
+      const info = BarcodeGenerator.getBarcodeTypeInfo(type);
+      process.stdout.write(`  ${type.padEnd(24)} ${info.description}\n`);
     });
   });
 
-// 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}`);
+    process.stderr.write(`${color.blue('Supported output formats:')}\n`);
+    BarcodeGenerator.getRenderFormats().forEach(format => {
+      const info = BarcodeGenerator.getRenderFormatInfo(format);
+      process.stdout.write(`  ${format.padEnd(6)} ${info.description}\n`);
     });
   });
 
-// 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}`));
+    const validation = BarcodeGenerator.validate(options.data, options.type);
+
+    if (!validation.valid) {
+      process.stderr.write(`${color.red('✖ Data is invalid')}\n`);
+      process.stderr.write(`  Error: ${validation.error}\n`);
       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];
-}
+    process.stderr.write(`${color.green('✔ Data is valid')}\n`);
+    process.stdout.write(`  Type: ${validation.type}\n`);
+    process.stdout.write(`  Length: ${validation.length}\n`);
+    process.stdout.write(`  Charset: ${validation.charset}\n`);
+  });
 
-// Parse command line arguments
 program.parse();