@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/js/render/image-data.js

@@ -27,15 +27,12 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Raster output as ImageData, and 2D-canvas drawing.
  *
  * @module render/image-data
  */
-
 import { normalizeOptions, parseColor } from './options.js';
-
 /**
  * Render to an `ImageData`-shaped object.
  *
@@ -48,37 +45,32 @@ import { normalizeOptions, parseColor } from './options.js';
  * @returns {{data: Uint8ClampedArray, width: number, height: number}}
  */
 export function toImageData(matrix, options = {}) {
-  const opts = normalizeOptions(matrix, options);
-  const { scale, source, pixelWidth, pixelHeight } = opts;
-
-  const dark = parseColor(opts.dark);
-  const light = parseColor(opts.light);
-  const data = new Uint8ClampedArray(pixelWidth * pixelHeight * 4);
-
-  // Fill one scanline per module row, then copy it `scale` times. Barcodes are
-  // wide and repetitive, so this is markedly faster than a per-pixel loop.
-  const line = new Uint8ClampedArray(pixelWidth * 4);
-
-  for (let my = 0; my < source.height; my++) {
-    for (let mx = 0; mx < source.width; mx++) {
-      const colour = source.get(mx, my) ? dark : light;
-      const start = mx * scale * 4;
-      for (let px = 0; px < scale; px++) {
-        const p = start + px * 4;
-        line[p] = colour[0];
-        line[p + 1] = colour[1];
-        line[p + 2] = colour[2];
-        line[p + 3] = colour[3];
-      }
+    const opts = normalizeOptions(matrix, options);
+    const { scale, source, pixelWidth, pixelHeight } = opts;
+    const dark = parseColor(opts.dark);
+    const light = parseColor(opts.light);
+    const data = new Uint8ClampedArray(pixelWidth * pixelHeight * 4);
+    // Fill one scanline per module row, then copy it `scale` times. Barcodes are
+    // wide and repetitive, so this is markedly faster than a per-pixel loop.
+    const line = new Uint8ClampedArray(pixelWidth * 4);
+    for (let my = 0; my < source.height; my++) {
+        for (let mx = 0; mx < source.width; mx++) {
+            const colour = source.get(mx, my) ? dark : light;
+            const start = mx * scale * 4;
+            for (let px = 0; px < scale; px++) {
+                const p = start + px * 4;
+                line[p] = colour[0];
+                line[p + 1] = colour[1];
+                line[p + 2] = colour[2];
+                line[p + 3] = colour[3];
+            }
+        }
+        for (let py = 0; py < scale; py++) {
+            data.set(line, ((my * scale + py) * pixelWidth) * 4);
+        }
     }
-    for (let py = 0; py < scale; py++) {
-      data.set(line, ((my * scale + py) * pixelWidth) * 4);
-    }
-  }
-
-  return { data, width: pixelWidth, height: pixelHeight };
+    return { data, width: pixelWidth, height: pixelHeight };
 }
-
 /**
  * Draw into a canvas using its 2D context.
  *
@@ -91,35 +83,38 @@ export function toImageData(matrix, options = {}) {
  * @returns {boolean} True when it drew.
  */
 export function toCanvas(matrix, canvas, options = {}) {
-  const opts = normalizeOptions(matrix, options);
-  const ctx = canvas.getContext('2d');
-  if (!ctx) return false;
-
-  canvas.width = opts.pixelWidth;
-  canvas.height = opts.pixelHeight;
-
-  // Draw with fillRect rather than putImageData: it respects the canvas's
-  // alpha compositing, so a transparent `light` leaves the page showing
-  // through instead of punching a hole.
-  const [, , , lightAlpha] = parseColor(opts.light);
-  if (lightAlpha > 0) {
-    ctx.fillStyle = opts.light;
-    ctx.fillRect(0, 0, opts.pixelWidth, opts.pixelHeight);
-  } else {
-    ctx.clearRect(0, 0, opts.pixelWidth, opts.pixelHeight);
-  }
-
-  ctx.fillStyle = opts.dark;
-  const { source, scale } = opts;
-  for (let y = 0; y < source.height; y++) {
-    let x = 0;
-    while (x < source.width) {
-      if (!source.get(x, y)) { x++; continue; }
-      let run = 1;
-      while (x + run < source.width && source.get(x + run, y)) run++;
-      ctx.fillRect(x * scale, y * scale, run * scale, scale);
-      x += run;
+    const opts = normalizeOptions(matrix, options);
+    const ctx = canvas.getContext('2d');
+    if (!ctx)
+        return false;
+    canvas.width = opts.pixelWidth;
+    canvas.height = opts.pixelHeight;
+    // Draw with fillRect rather than putImageData: it respects the canvas's
+    // alpha compositing, so a transparent `light` leaves the page showing
+    // through instead of punching a hole.
+    const [, , , lightAlpha] = parseColor(opts.light);
+    if (lightAlpha > 0) {
+        ctx.fillStyle = opts.light;
+        ctx.fillRect(0, 0, opts.pixelWidth, opts.pixelHeight);
+    }
+    else {
+        ctx.clearRect(0, 0, opts.pixelWidth, opts.pixelHeight);
+    }
+    ctx.fillStyle = opts.dark;
+    const { source, scale } = opts;
+    for (let y = 0; y < source.height; y++) {
+        let x = 0;
+        while (x < source.width) {
+            if (!source.get(x, y)) {
+                x++;
+                continue;
+            }
+            let run = 1;
+            while (x + run < source.width && source.get(x + run, y))
+                run++;
+            ctx.fillRect(x * scale, y * scale, run * scale, scale);
+            x += run;
+        }
     }
-  }
-  return true;
+    return true;
 }

package/src/js/render/index.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Output backends.
  *
@@ -57,18 +56,15 @@
  *
  * @module render
  */
-
 export { toSVG, toSVGDataURI } from './svg.js';
 export { toImageData, toCanvas } from './image-data.js';
 export { toPNG, toPNGDataURI, deflateStored } from './png.js';
 export { isWebGL2Available, renderToCanvasWebGL } from './webgl.js';
 export { isWebGPUAvailable, renderToCanvasWebGPU } from './webgpu.js';
 export { normalizeOptions, parseColor } from './options.js';
-
 import { toCanvas } from './image-data.js';
 import { isWebGL2Available, renderToCanvasWebGL } from './webgl.js';
 import { isWebGPUAvailable, renderToCanvasWebGPU } from './webgpu.js';
-
 /**
  * Draw into a canvas using the best backend available.
  *
@@ -88,15 +84,15 @@ import { isWebGPUAvailable, renderToCanvasWebGPU } from './webgpu.js';
  * @returns {{backend: 'webgl2' | '2d' | 'none'}}
  */
 export function renderToCanvasAuto(matrix, canvas, options = {}) {
-  const preferred = options.backend ?? 'auto';
-
-  if ((preferred === 'auto' || preferred === 'webgl2') && isWebGL2Available()) {
-    if (renderToCanvasWebGL(matrix, canvas, options)) return { backend: 'webgl2' };
-  }
-  if (toCanvas(matrix, canvas, options)) return { backend: '2d' };
-  return { backend: 'none' };
+    const preferred = options.backend ?? 'auto';
+    if ((preferred === 'auto' || preferred === 'webgl2') && isWebGL2Available()) {
+        if (renderToCanvasWebGL(matrix, canvas, options))
+            return { backend: 'webgl2' };
+    }
+    if (toCanvas(matrix, canvas, options))
+        return { backend: '2d' };
+    return { backend: 'none' };
 }
-
 /**
  * Draw into a canvas using the best backend available, including WebGPU.
  *
@@ -115,16 +111,18 @@ export function renderToCanvasAuto(matrix, canvas, options = {}) {
  * @returns {Promise<{backend: 'webgpu' | 'webgl2' | '2d' | 'none'}>}
  */
 export async function renderToCanvasAutoAsync(matrix, canvas, options = {}) {
-  const preferred = options.backend ?? 'auto';
-
-  if (preferred === 'auto' || preferred === 'webgpu') {
-    if (await isWebGPUAvailable()) {
-      if (await renderToCanvasWebGPU(matrix, canvas, options)) return { backend: 'webgpu' };
+    const preferred = options.backend ?? 'auto';
+    if (preferred === 'auto' || preferred === 'webgpu') {
+        if (await isWebGPUAvailable()) {
+            if (await renderToCanvasWebGPU(matrix, canvas, options))
+                return { backend: 'webgpu' };
+        }
+    }
+    if ((preferred === 'auto' || preferred === 'webgl2') && isWebGL2Available()) {
+        if (renderToCanvasWebGL(matrix, canvas, options))
+            return { backend: 'webgl2' };
     }
-  }
-  if ((preferred === 'auto' || preferred === 'webgl2') && isWebGL2Available()) {
-    if (renderToCanvasWebGL(matrix, canvas, options)) return { backend: 'webgl2' };
-  }
-  if (toCanvas(matrix, canvas, options)) return { backend: '2d' };
-  return { backend: 'none' };
+    if (toCanvas(matrix, canvas, options))
+        return { backend: '2d' };
+    return { backend: 'none' };
 }

package/src/js/render/options.js

@@ -27,15 +27,12 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Shared render options, normalised once so every backend agrees.
  *
  * @module render/options
  */
-
 import { BitMatrix } from '../core/bit-matrix.js';
-
 /**
  * @typedef {object} RenderOptions
  * @property {number} [scale] Pixels per module. Default 8.
@@ -44,7 +41,6 @@ import { BitMatrix } from '../core/bit-matrix.js';
  * @property {string} [light] Colour of clear modules, or 'none' for transparent.
  * @property {number} [barHeight] For 1D symbols: total bar height in pixels.
  */
-
 /**
  * Expand and pad the matrix, and resolve every dimension.
  *
@@ -57,42 +53,39 @@ import { BitMatrix } from '../core/bit-matrix.js';
  * @param {RenderOptions} options
  */
 export function normalizeOptions(matrix, options = {}) {
-  const scale = Math.max(1, Math.floor(options.scale ?? 8));
-  const margin = Math.max(0, Math.floor(options.margin ?? 4));
-  const dark = options.dark ?? '#000000';
-  const light = options.light ?? '#ffffff';
-  const barHeight = options.barHeight ?? null;
-
-  let base = matrix;
-  const is1D = matrix.height === 1;
-
-  if (is1D) {
-    // Default to a bar height that stays scannable: tall enough that a laser
-    // crossing at a slight angle still passes through the whole symbol.
-    const targetPixels = barHeight ?? Math.max(40, Math.round(matrix.width * scale * 0.15));
-    const rows = Math.max(1, Math.round(targetPixels / scale));
-    base = new BitMatrix(matrix.width, rows);
-    for (let x = 0; x < matrix.width; x++) {
-      if (!matrix.get(x, 0)) continue;
-      for (let y = 0; y < rows; y++) base.set(x, y);
+    const scale = Math.max(1, Math.floor(options.scale ?? 8));
+    const margin = Math.max(0, Math.floor(options.margin ?? 4));
+    const dark = options.dark ?? '#000000';
+    const light = options.light ?? '#ffffff';
+    const barHeight = options.barHeight ?? null;
+    let base = matrix;
+    const is1D = matrix.height === 1;
+    if (is1D) {
+        // Default to a bar height that stays scannable: tall enough that a laser
+        // crossing at a slight angle still passes through the whole symbol.
+        const targetPixels = barHeight ?? Math.max(40, Math.round(matrix.width * scale * 0.15));
+        const rows = Math.max(1, Math.round(targetPixels / scale));
+        base = new BitMatrix(matrix.width, rows);
+        for (let x = 0; x < matrix.width; x++) {
+            if (!matrix.get(x, 0))
+                continue;
+            for (let y = 0; y < rows; y++)
+                base.set(x, y);
+        }
     }
-  }
-
-  const source = margin > 0 ? base.withMargin(margin) : base;
-
-  return {
-    scale,
-    margin,
-    dark,
-    light,
-    is1D,
-    source,
-    rowHeight: scale,
-    pixelWidth: source.width * scale,
-    pixelHeight: source.height * scale,
-  };
+    const source = margin > 0 ? base.withMargin(margin) : base;
+    return {
+        scale,
+        margin,
+        dark,
+        light,
+        is1D,
+        source,
+        rowHeight: scale,
+        pixelWidth: source.width * scale,
+        pixelHeight: source.height * scale,
+    };
 }
-
 /**
  * Parse a CSS colour into RGBA bytes.
  *
@@ -103,58 +96,57 @@ export function normalizeOptions(matrix, options = {}) {
  * @returns {[number, number, number, number]}
  */
 export function parseColor(colour) {
-  const value = String(colour).trim().toLowerCase();
-
-  if (value === 'none' || value === 'transparent') return [0, 0, 0, 0];
-  if (value === 'white') return [255, 255, 255, 255];
-  if (value === 'black') return [0, 0, 0, 255];
-
-  if (value[0] === '#') {
-    const hex = value.slice(1);
-    const expand = (c) => parseInt(c + c, 16);
-    if (hex.length === 3) {
-      return [expand(hex[0]), expand(hex[1]), expand(hex[2]), 255];
+    const value = String(colour).trim().toLowerCase();
+    if (value === 'none' || value === 'transparent')
+        return [0, 0, 0, 0];
+    if (value === 'white')
+        return [255, 255, 255, 255];
+    if (value === 'black')
+        return [0, 0, 0, 255];
+    if (value[0] === '#') {
+        const hex = value.slice(1);
+        const expand = (c) => parseInt(c + c, 16);
+        if (hex.length === 3) {
+            return [expand(hex[0]), expand(hex[1]), expand(hex[2]), 255];
+        }
+        if (hex.length === 4) {
+            return [expand(hex[0]), expand(hex[1]), expand(hex[2]), expand(hex[3])];
+        }
+        if (hex.length === 6) {
+            return [
+                parseInt(hex.slice(0, 2), 16),
+                parseInt(hex.slice(2, 4), 16),
+                parseInt(hex.slice(4, 6), 16),
+                255,
+            ];
+        }
+        if (hex.length === 8) {
+            return [
+                parseInt(hex.slice(0, 2), 16),
+                parseInt(hex.slice(2, 4), 16),
+                parseInt(hex.slice(4, 6), 16),
+                parseInt(hex.slice(6, 8), 16),
+            ];
+        }
     }
-    if (hex.length === 4) {
-      return [expand(hex[0]), expand(hex[1]), expand(hex[2]), expand(hex[3])];
+    const fn = value.match(/^rgba?\(([^)]+)\)$/);
+    if (fn) {
+        const parts = fn[1].split(/[,/\s]+/).filter(Boolean);
+        const channel = (s) => (s.endsWith('%')
+            ? Math.round((parseFloat(s) / 100) * 255)
+            : Math.round(parseFloat(s)));
+        const r = channel(parts[0]);
+        const g = channel(parts[1]);
+        const b = channel(parts[2]);
+        let a = 255;
+        if (parts.length > 3) {
+            a = parts[3].endsWith('%')
+                ? Math.round((parseFloat(parts[3]) / 100) * 255)
+                : Math.round(parseFloat(parts[3]) * 255);
+        }
+        return [r, g, b, a];
     }
-    if (hex.length === 6) {
-      return [
-        parseInt(hex.slice(0, 2), 16),
-        parseInt(hex.slice(2, 4), 16),
-        parseInt(hex.slice(4, 6), 16),
-        255,
-      ];
-    }
-    if (hex.length === 8) {
-      return [
-        parseInt(hex.slice(0, 2), 16),
-        parseInt(hex.slice(2, 4), 16),
-        parseInt(hex.slice(4, 6), 16),
-        parseInt(hex.slice(6, 8), 16),
-      ];
-    }
-  }
-
-  const fn = value.match(/^rgba?\(([^)]+)\)$/);
-  if (fn) {
-    const parts = fn[1].split(/[,/\s]+/).filter(Boolean);
-    const channel = (s) => (s.endsWith('%')
-      ? Math.round((parseFloat(s) / 100) * 255)
-      : Math.round(parseFloat(s)));
-    const r = channel(parts[0]);
-    const g = channel(parts[1]);
-    const b = channel(parts[2]);
-    let a = 255;
-    if (parts.length > 3) {
-      a = parts[3].endsWith('%')
-        ? Math.round((parseFloat(parts[3]) / 100) * 255)
-        : Math.round(parseFloat(parts[3]) * 255);
-    }
-    return [r, g, b, a];
-  }
-
-  // Unrecognised: fall back to opaque black rather than throwing, so an
-  // unusual colour never costs someone a barcode.
-  return [0, 0, 0, 255];
+    // Unrecognised: fall back to opaque black rather than throwing, so an
+    // unusual colour never costs someone a barcode.
+    return [0, 0, 0, 255];
 }