isahaq-barcode 1.8.0 → 2.0.0

package/src/encoders/BarcodeEncoder.js

@@ -0,0 +1,260 @@
+/**
+ * Barcode Encoder - Turns data into a real, scannable symbology
+ *
+ * All renderers go through this module so that PNG, SVG, HTML and PDF output
+ * describe the exact same encoding. Encoding is done by bwip-js (BWIPP), which
+ * covers every type listed in BarcodeTypes.
+ */
+
+const bwipjs = require('bwip-js');
+const { BarcodeTypes } = require('../types/BarcodeTypes');
+
+/** bwip-js expresses bar height in millimetres at 72dpi */
+const PX_PER_MM = 72 / 25.4;
+
+/** Types whose size is driven by the module scale rather than a bar height */
+const MATRIX_CATEGORIES = new Set(['MATRIX_2D', 'STACKED']);
+
+/**
+ * Quiet zone in modules used when the caller does not specify a margin.
+ * Most 1D specifications require at least 10 narrow modules of clear space;
+ * scanners reject codes with less.
+ */
+const DEFAULT_QUIET_ZONE_MODULES = 10;
+
+const DEFAULT_OPTIONS = {
+  width: 2, // module (narrow bar) width in pixels
+  height: 100, // bar height in pixels - 1D symbologies only
+  displayValue: true, // print the human readable text
+  fontSize: 20, // human readable text size in pixels
+  textAlign: 'center', // center | left | right | justify
+  textMargin: 2, // gap between bars and text in pixels
+  background: '#ffffff',
+  lineColor: '#000000',
+  margin: null, // quiet zone in pixels; defaults to 10 modules when omitted
+  marginTop: null,
+  marginBottom: null,
+  marginLeft: null,
+  marginRight: null,
+  quietZone: DEFAULT_QUIET_ZONE_MODULES, // quiet zone in modules
+  rotate: 'N', // N | R | L | I (none, right, left, inverted)
+  size: null, // target size in pixels for 2D symbologies
+};
+
+/**
+ * Strip the internal BWIPP error prefix so messages read like normal errors.
+ * "bwipp.ean13badLength#6878: EAN-13 must be 12 or 13 digits" -> "EAN-13 must be 12 or 13 digits"
+ * @param {Error|string} error - Error thrown by the encoder
+ * @returns {string} Human readable message
+ */
+function cleanMessage(error) {
+  const message = error && error.message ? error.message : String(error);
+  return message.replace(/^bwipp?\.[A-Za-z0-9]+(#\d+)?:\s*/, '');
+}
+
+/**
+ * Normalise a colour to the hex form bwip-js expects.
+ * @param {string} color - Colour as #rgb, #rrggbb or rrggbb
+ * @param {string} fallback - Value used when color is missing/invalid
+ * @returns {string} Hex colour without the leading '#'
+ */
+function toHex(color, fallback) {
+  const raw = String(color == null ? fallback : color)
+    .replace(/^#/, '')
+    .toLowerCase();
+
+  if (/^[0-9a-fA-F]{3}$/.test(raw)) {
+    return raw
+      .split('')
+      .map(c => c + c)
+      .join('');
+  }
+
+  if (/^[0-9a-fA-F]{6}$/.test(raw) || /^[0-9a-fA-F]{8}$/.test(raw)) {
+    return raw;
+  }
+
+  return String(fallback).replace(/^#/, '');
+}
+
+/**
+ * Pick a positive number, falling back when the value is unusable.
+ * @param {*} value - Candidate value
+ * @param {number} fallback - Fallback value
+ * @returns {number} A finite positive number
+ */
+function positive(value, fallback) {
+  const num = Number(value);
+  return Number.isFinite(num) && num > 0 ? num : fallback;
+}
+
+class BarcodeEncoder {
+  /**
+   * Get the default render options
+   * @returns {Object} Default options
+   */
+  static getDefaultOptions() {
+    return { ...DEFAULT_OPTIONS };
+  }
+
+  /**
+   * Check whether a type is a 2D/stacked symbology (sized by scale, not height)
+   * @param {string} type - The barcode type
+   * @returns {boolean} True for matrix and stacked symbologies
+   */
+  static isMatrix(type) {
+    const info = BarcodeTypes.getTypeInfo(type);
+    return !!info && MATRIX_CATEGORIES.has(info.category);
+  }
+
+  /**
+   * Translate this package's options into bwip-js encoder options
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {Object} bwip-js options
+   */
+  static buildOptions(data, type, options = {}) {
+    const bcid = BarcodeTypes.getSymbology(type);
+    if (!bcid) {
+      throw new Error(`Invalid barcode type: ${type}`);
+    }
+
+    const merged = { ...DEFAULT_OPTIONS, ...options };
+    const scale = Math.max(1, Math.round(positive(merged.width, 2)));
+
+    const encoded = {
+      bcid,
+      text: data,
+      scale,
+      includetext: merged.displayValue !== false,
+      textxalign: merged.textAlign || 'center',
+      textsize: Math.max(1, positive(merged.fontSize, 20) / scale),
+      textyoffset: Number(merged.textMargin) || 0,
+      barcolor: toHex(merged.lineColor, '#000000'),
+      backgroundcolor: toHex(merged.background, '#ffffff'),
+      textcolor: toHex(merged.textColor || merged.lineColor, '#000000'),
+      rotate: ['N', 'R', 'L', 'I'].includes(merged.rotate)
+        ? merged.rotate
+        : 'N',
+      ...BarcodeTypes.getEncodeOptions(type),
+    };
+
+    // Quiet zone. bwip-js padding is expressed in modules (it multiplies by
+    // scale), our public options are pixels. When no margin is given we fall
+    // back to the module count the specifications ask for.
+    const quietZone = Math.max(
+      0,
+      Math.round(
+        merged.quietZone === undefined || merged.quietZone === null
+          ? DEFAULT_QUIET_ZONE_MODULES
+          : Number(merged.quietZone) || 0
+      )
+    );
+    const pad = value => {
+      const pixels =
+        value === undefined || value === null ? merged.margin : value;
+      if (pixels === undefined || pixels === null) {
+        return quietZone;
+      }
+      return Math.max(0, Math.round((Number(pixels) || 0) / scale));
+    };
+    encoded.paddingleft = pad(merged.marginLeft);
+    encoded.paddingright = pad(merged.marginRight);
+    encoded.paddingtop = pad(merged.marginTop);
+    encoded.paddingbottom = pad(merged.marginBottom);
+
+    if (this.isMatrix(type)) {
+      // 2D symbologies keep their own aspect ratio; an explicit target size is
+      // honoured by scaling the module size instead of stretching bars.
+      if (merged.size) {
+        encoded.scale = this.scaleForSize(
+          { ...encoded, scale: 1 },
+          positive(merged.size, 300)
+        );
+      }
+    } else {
+      encoded.height = positive(merged.height, 100) / (scale * PX_PER_MM);
+    }
+
+    // Allow advanced callers to hand raw bwip-js options through untouched
+    if (options.bwipOptions && typeof options.bwipOptions === 'object') {
+      Object.assign(encoded, options.bwipOptions);
+    }
+
+    return encoded;
+  }
+
+  /**
+   * Work out the module scale needed to reach a target pixel size
+   * @param {Object} baseOptions - bwip-js options rendered at scale 1
+   * @param {number} targetPx - Desired width/height in pixels
+   * @returns {number} Module scale
+   */
+  static scaleForSize(baseOptions, targetPx) {
+    try {
+      const svg = bwipjs.toSVG(baseOptions);
+      const viewBox = /viewBox="0 0 ([\d.]+) ([\d.]+)"/.exec(svg);
+      const baseSize = viewBox
+        ? Math.max(Number(viewBox[1]), Number(viewBox[2]))
+        : 0;
+
+      if (!baseSize) {
+        return 4;
+      }
+
+      return Math.max(1, Math.round(targetPx / baseSize));
+    } catch {
+      return 4;
+    }
+  }
+
+  /**
+   * Encode as an SVG string (synchronous)
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {string} SVG markup
+   */
+  static toSvg(data, type, options = {}) {
+    try {
+      return bwipjs.toSVG(this.buildOptions(data, type, options));
+    } catch (error) {
+      throw new Error(`Failed to encode ${type}: ${cleanMessage(error)}`);
+    }
+  }
+
+  /**
+   * Encode as a PNG buffer
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {Promise<Buffer>} PNG buffer
+   */
+  static async toPng(data, type, options = {}) {
+    try {
+      return await bwipjs.toBuffer(this.buildOptions(data, type, options));
+    } catch (error) {
+      throw new Error(`Failed to encode ${type}: ${cleanMessage(error)}`);
+    }
+  }
+
+  /**
+   * Get the pixel dimensions an encoding will produce
+   * @param {string} data - The data to encode
+   * @param {string} type - The barcode type
+   * @param {Object} options - Render options
+   * @returns {{width: number, height: number}} Dimensions in pixels
+   */
+  static getDimensions(data, type, options = {}) {
+    const svg = this.toSvg(data, type, options);
+    const viewBox = /viewBox="0 0 ([\d.]+) ([\d.]+)"/.exec(svg);
+
+    return {
+      width: viewBox ? Math.round(Number(viewBox[1])) : 0,
+      height: viewBox ? Math.round(Number(viewBox[2])) : 0,
+    };
+  }
+}
+
+module.exports = { BarcodeEncoder, cleanMessage };

package/src/renderers/HTMLRenderer.js

@@ -1,26 +1,18 @@
 /**
- * HTML Renderer - Renders barcodes as HTML
+ * HTML Renderer - Renders barcodes as an HTML fragment wrapping a real SVG
  */
 
+const { BarcodeEncoder } = require('../encoders/BarcodeEncoder');
+
+let counter = 0;
+
 class HTMLRenderer {
   constructor() {
     this.defaultOptions = {
-      width: 2,
-      height: 100,
-      displayValue: true,
-      fontSize: 20,
-      textAlign: 'center',
-      textPosition: 'bottom',
-      textMargin: 2,
-      background: '#ffffff',
-      lineColor: '#000000',
-      margin: 10,
-      marginTop: 10,
-      marginBottom: 10,
-      marginLeft: 10,
-      marginRight: 10,
+      ...BarcodeEncoder.getDefaultOptions(),
       className: 'barcode',
       id: null,
+      includeStyles: true,
     };
   }
 
@@ -29,169 +21,31 @@ class HTMLRenderer {
    * @param {string} data - The data to encode
    * @param {string} type - The barcode type
    * @param {Object} options - Render options
-   * @returns {string} HTML string
+   * @returns {string} HTML markup
    */
   render(data, type, options = {}) {
     try {
-      // Merge options with defaults
       const renderOptions = { ...this.defaultOptions, ...options };
-
-      // Generate HTML structure
-      const html = this.createHTMLStructure(data, type, renderOptions);
-      return html;
+      const svg = BarcodeEncoder.toSvg(data, type, renderOptions);
+      const id = renderOptions.id || `barcode-${++counter}`;
+      const className = renderOptions.className || 'barcode';
+
+      const styles = renderOptions.includeStyles
+        ? ` style="display:inline-block;background:${escapeAttribute(
+            renderOptions.background
+          )};text-align:center"`
+        : '';
+
+      return (
+        `<div id="${escapeAttribute(id)}" class="${escapeAttribute(className)}"` +
+        `${styles} data-barcode-type="${escapeAttribute(type)}"` +
+        ` data-barcode-value="${escapeAttribute(data)}">${svg}</div>`
+      );
     } catch (error) {
       throw new Error(`HTML rendering failed: ${error.message}`);
     }
   }
 
-  /**
-   * Create HTML structure for barcode
-   * @param {string} data - The data to encode
-   * @param {string} type - The barcode type
-   * @param {Object} options - Render options
-   * @returns {string} HTML string
-   */
-  createHTMLStructure(data, type, options) {
-    const containerId =
-      options.id ||
-      `barcode-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const containerClass = options.className || 'barcode';
-
-    let html = `<div id="${containerId}" class="${containerClass}" style="${this.getContainerStyles(
-      options
-    )}">`;
-
-    // Add barcode representation
-    if (type === 'qrcode') {
-      html += this.createQRCodeHTML(data, options);
-    } else {
-      html += this.createLinearBarcodeHTML(data, type, options);
-    }
-
-    // Add text if displayValue is true
-    if (options.displayValue) {
-      html += `<div class="barcode-text" style="${this.getTextStyles(
-        options
-      )}">${data}</div>`;
-    }
-
-    html += '</div>';
-
-    // Add CSS styles
-    html += this.getCSSStyles(containerId, options);
-
-    return html;
-  }
-
-  /**
-   * Create QR Code HTML representation
-   * @param {string} data - The data to encode
-   * @param {Object} options - Render options
-   * @returns {string} HTML content
-   */
-  createQRCodeHTML(data, options) {
-    // This is a simplified representation
-    // In a real implementation, you would use a QR code library
-    const size = 200;
-    const cellSize = 10;
-    const cells = size / cellSize;
-
-    let html = `<div class="qr-code" style="width: ${size}px; height: ${size}px; display: grid; grid-template-columns: repeat(${cells}, 1fr); gap: 1px; background: ${options.background}; padding: 10px;">`;
-
-    // Generate a simple pattern based on data
-    for (let i = 0; i < cells * cells; i++) {
-      const shouldFill = (data.charCodeAt(i % data.length) + i) % 2 === 0;
-      const color = shouldFill ? options.lineColor : options.background;
-      html += `<div style="background-color: ${color}; width: 100%; height: 100%;"></div>`;
-    }
-
-    html += '</div>';
-    return html;
-  }
-
-  /**
-   * Create linear barcode HTML representation
-   * @param {string} data - The data to encode
-   * @param {string} type - The barcode type
-   * @param {Object} options - Render options
-   * @returns {string} HTML content
-   */
-  createLinearBarcodeHTML(data, type, options) {
-    const barWidth = options.width || 2;
-    const barHeight = options.height || 100;
-
-    let html = `<div class="linear-barcode" style="display: flex; align-items: flex-start; background: ${options.background}; padding: 10px;">`;
-
-    // Generate bars based on data
-    for (let i = 0; i < data.length; i++) {
-      const char = data.charCodeAt(i);
-      const barCount = (char % 5) + 1;
-
-      for (let j = 0; j < barCount; j++) {
-        html += `<div style="width: ${barWidth}px; height: ${barHeight}px; background-color: ${options.lineColor}; margin-right: ${barWidth}px;"></div>`;
-      }
-    }
-
-    html += '</div>';
-    return html;
-  }
-
-  /**
-   * Get container styles
-   * @param {Object} options - Render options
-   * @returns {string} CSS styles
-   */
-  getContainerStyles(options) {
-    return `
-      display: inline-block;
-      background: ${options.background};
-      padding: ${options.margin}px;
-      margin: ${options.marginTop}px ${options.marginRight}px ${options.marginBottom}px ${options.marginLeft}px;
-      border: 1px solid #ccc;
-      text-align: center;
-    `;
-  }
-
-  /**
-   * Get text styles
-   * @param {Object} options - Render options
-   * @returns {string} CSS styles
-   */
-  getTextStyles(options) {
-    return `
-      font-family: Arial, sans-serif;
-      font-size: ${options.fontSize}px;
-      color: ${options.lineColor};
-      text-align: ${options.textAlign};
-      margin-top: ${options.textMargin}px;
-    `;
-  }
-
-  /**
-   * Get CSS styles for the barcode
-   * @param {string} containerId - Container ID
-   * @param {Object} options - Render options
-   * @returns {string} CSS styles
-   */
-  getCSSStyles(containerId) {
-    return `
-      <style>
-        #${containerId} {
-          font-family: Arial, sans-serif;
-        }
-        #${containerId} .barcode-text {
-          font-weight: bold;
-        }
-        #${containerId} .qr-code {
-          margin: 0 auto;
-        }
-        #${containerId} .linear-barcode {
-          justify-content: center;
-        }
-      </style>
-    `;
-  }
-
   /**
    * Get default options
    * @returns {Object} Default options
@@ -209,4 +63,17 @@ class HTMLRenderer {
   }
 }
 
+/**
+ * Escape a value for use inside a double quoted HTML attribute
+ * @param {string} value - Raw value
+ * @returns {string} Escaped value
+ */
+function escapeAttribute(value) {
+  return String(value == null ? '' : value)
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
 module.exports = HTMLRenderer;