btrz-liquid-templates 1.11.0 → 2.0.0

package/docs/index.md

@@ -5,7 +5,7 @@ layout: default
 
 Create pdf documents from liquid templates.
 
-This library uses [LiquidJS](https://liquidjs.com/), [Symbology](https://symbology.dev/), [Bz-Date](https://www.npmjs.com/package/bz-date), [btrz-formatter](https://www.npmjs.com/package/btrz-formatter) and link them together while adding some helpers to easily generate PDFs from templates.
+This library uses [LiquidJS](https://liquidjs.com/), [bwip-js](https://github.com/metafloor/bwip-js), [Bz-Date](https://www.npmjs.com/package/bz-date), [btrz-formatter](https://www.npmjs.com/package/btrz-formatter) and link them together while adding some helpers to easily generate PDFs from templates.
 
 The vesion of PDFMake has been inlined and modified to allow for text rotation.
 
@@ -286,8 +286,11 @@ It will use the value given and use generate a 'code11' barcode with a height of
 
 ### Supported types
 
-It supports all types supported by [https://symbology.dev/](Symbology).
-While symbology supports QRCODE PDFMake also had support for QR natively and we recommend it.
+The `{% barcode %}` tag accepts legacy Symbology-style type names and maps them to [bwip-js](https://github.com/metafloor/bwip-js) barcode identifiers. Common examples include `code128`, `code11`, `code39`, `qrcode`, `pdf417`, and `datamatrix`.
+
+The following legacy type names are not supported and will throw an explicit error: `gridmatrix`, `koreapost`, `upnqr`, and `vin`.
+
+While barcode generation supports QR codes, PDFMake also had support for QR natively and we recommend it for QR-specific use cases.
 
 * ## httpImg
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "btrz-liquid-templates",
-  "version": "1.11.0",
+  "version": "2.0.0",
   "description": "Extension and helpers for liquid templates to deal with our data and other things we need to encapsulate",
   "main": "src/index.js",
   "scripts": {
-    "tdd": "node --test --watch test/index-test.js",
-    "test": "node --test test/index-test.js",
+    "tdd": "node --test --watch test/*-test.js",
+    "test": "node --test test/*-test.js",
     "preversion": "npm test",
     "postversion": "git push origin main && git push --tags",
     "version": "git tag $1"
@@ -23,11 +23,15 @@
   "dependencies": {
     "axios": "1.18.1",
     "btrz-formatter": "1.7.0",
+    "bwip-js": "^4.11.2",
     "bz-date": "2.2.0",
     "liquidjs": "10.27.1",
     "moment": "2.30.1",
     "moment-timezone": "0.6.2",
-    "symbology": "4.0.2",
     "written-number": "0.11.1"
+  },
+  "devDependencies": {
+    "@undecaf/zbar-wasm": "^0.11.0",
+    "pngjs": "^7.0.0"
   }
 }

package/src/barcode-generator.js

@@ -0,0 +1,20 @@
+const bwipjs = require("bwip-js");
+const {resolveBarcodeType} = require("./barcode-types.js");
+
+async function generateBarcodePng({type, content, height}) {
+  const bcid = resolveBarcodeType(type);
+  const pngBuffer = await bwipjs.toBuffer({
+    bcid,
+    text: String(content),
+    scale: 2,
+    height: Number(height) || 30,
+    includetext: false,
+    backgroundcolor: "FFFFFF"
+  });
+
+  return `data:image/png;base64,${pngBuffer.toString("base64")}`;
+}
+
+module.exports = {
+  generateBarcodePng
+};

package/src/barcode-types.js

@@ -0,0 +1,133 @@
+const UNSUPPORTED_TYPES = new Set([
+  "GRIDMATRIX",
+  "KOREAPOST",
+  "UPNQR",
+  "VIN"
+]);
+
+const SYMBLOGY_TO_BWIP = {
+  AUSPOST: "auspost",
+  AUSREDIRECT: "auspost",
+  AUSREPLY: "auspost",
+  AUSROUTE: "auspost",
+  AZRUNE: "aztecrune",
+  AZTEC: "azteccode",
+  C25IATA: "iata2of5",
+  C25IND: "industrial2of5",
+  C25INTER: "interleaved2of5",
+  C25LOGIC: "datalogic2of5",
+  C25MATRIX: "matrix2of5",
+  CHANNEL: "channelcode",
+  CODABAR: "rationalizedCodabar",
+  CODABLOCKF: "codablockf",
+  CODE11: "code11",
+  CODE128: "code128",
+  CODE128B: "code128",
+  CODE16K: "code16k",
+  CODE32: "code32",
+  CODE39: "code39",
+  CODE49: "code49",
+  CODE93: "code93",
+  CODEONE: "codeone",
+  DAFT: "daft",
+  DATAMATRIX: "datamatrix",
+  DOTCODE: "dotcode",
+  DPIDENT: "identcode",
+  DPLEIT: "leitcode",
+  EAN128: "gs1-128",
+  EAN128_CC: "gs1-128composite",
+  EAN14: "ean14",
+  EANX: "ean13",
+  EANX_CC: "ean13composite",
+  EANX_CHK: "ean13",
+  EXCODE39: "code39ext",
+  FIM: "flattermarken",
+  FLAT: "flattermarken",
+  HANXIN: "hanxin",
+  HIBC_128: "hibccode128",
+  HIBC_39: "hibccode39",
+  HIBC_AZTEC: "hibcazteccode",
+  HIBC_DM: "hibcdatamatrix",
+  HIBC_MICPDF: "hibcmicropdf417",
+  HIBC_PDF: "hibcpdf417",
+  HIBC_QR: "hibcqrcode",
+  ISBNX: "isbn",
+  ITF14: "itf14",
+  JAPANPOST: "japanpost",
+  KIX: "kix",
+  LOGMARS: "code39",
+  MAILMARK: "mailmark",
+  MAXICODE: "maxicode",
+  MICROPDF417: "micropdf417",
+  MICROQR: "microqrcode",
+  MSI_PLESSEY: "msi",
+  NVE18: "sscc18",
+  ONECODE: "onecode",
+  PDF417: "pdf417",
+  PDF417TRUNC: "pdf417compact",
+  PHARMA: "pharmacode",
+  PHARMA_TWO: "pharmacode2",
+  PLANET: "planet",
+  PLESSEY: "plessey",
+  POSTNET: "postnet",
+  PZN: "pzn",
+  QRCODE: "qrcode",
+  RM4SCC: "royalmail",
+  RSS14: "databaromni",
+  RSS14STACK: "databarstacked",
+  RSS14STACK_CC: "databarstackedcomposite",
+  RSS14STACK_OMNI: "databarstackedomni",
+  RSS14_CC: "databaromnicomposite",
+  RSS14_OMNI_CC: "databarstackedomnicomposite",
+  RSS_EXP: "databarexpanded",
+  RSS_EXPSTACK: "databarexpandedstacked",
+  RSS_EXPSTACK_CC: "databarexpandedstackedcomposite",
+  RSS_EXP_CC: "databarexpandedcomposite",
+  RSS_LTD: "databarlimited",
+  RSS_LTD_CC: "databarlimitedcomposite",
+  TELEPEN: "telepen",
+  TELEPEN_NUM: "telepennumeric",
+  ULTRA: "ultracode",
+  UPCA: "upca",
+  UPCA_CC: "upcacomposite",
+  UPCA_CHK: "upca",
+  UPCE: "upce",
+  UPCE_CC: "upcecomposite",
+  UPCE_CHK: "upce"
+};
+
+function normalizeBarcodeType(type) {
+  return String(type || "code128").toUpperCase();
+}
+
+function resolveBarcodeType(type) {
+  const normalized = normalizeBarcodeType(type);
+
+  if (UNSUPPORTED_TYPES.has(normalized)) {
+    throw new Error(`Unsupported barcode type: ${normalized}`);
+  }
+
+  const bcid = SYMBLOGY_TO_BWIP[normalized];
+  if (!bcid) {
+    throw new Error(`Unsupported barcode type: ${normalized}`);
+  }
+
+  return bcid;
+}
+
+function listSupportedSymbologyTypes() {
+  return Object.keys(SYMBLOGY_TO_BWIP).sort();
+}
+
+function listUnsupportedSymbologyTypes() {
+  return [...UNSUPPORTED_TYPES].sort();
+}
+
+module.exports = {
+  UNSUPPORTED_TYPES,
+  SYMBLOGY_TO_BWIP,
+  normalizeBarcodeType,
+  resolveBarcodeType,
+  listSupportedSymbologyTypes,
+  listUnsupportedSymbologyTypes
+};

package/src/barcode.js

@@ -1,8 +1,4 @@
-const {SymbologyType, createStream, OutputType} = require("symbology");
-
-function getCode(code) {
-  return SymbologyType[code.toUpperCase()];
-}
+const {generateBarcodePng} = require("./barcode-generator.js");
 
 function Barcode(engine) {
   this.registerTag("barcode", {
@@ -23,13 +19,12 @@ function Barcode(engine) {
       }
     },
     render: async function(ctx) {
-      let content = await this.liquid.evalValue(this.content, ctx) || this.content;
-      let result = await createStream({
-        symbology: getCode(this.type),
-        height: this.height,
-        showHumanReadableText: false,
-        scale: 2.0,
-      }, String(content), OutputType.PNG);
+      const content = await this.liquid.evalValue(this.content, ctx) || this.content;
+      const image = await generateBarcodePng({
+        type: this.type,
+        content,
+        height: this.height
+      });
       let margin = [0,0,0,0];
       try {
         margin = this.margin.split(",").map((i) => {
@@ -43,7 +38,7 @@ function Barcode(engine) {
         margin = [0,0,0,0];
       }
       return `{
-        "image": "${result.data}",
+        "image": "${image}",
         "width": ${this.width || 200},
         "margin": [${margin.join(",")}]
       }`;

package/test/barcode-equivalence-test.js

@@ -0,0 +1,63 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const {describe, it} = require("node:test");
+const {listSupportedSymbologyTypes} = require("../src/barcode-types.js");
+const {decodePngDataUri, isValidPngDataUri} = require("./helpers/barcode-decode.js");
+const {generateBwipTestPng} = require("./helpers/generate-bwip-test-png.js");
+
+const FIXTURE_DIR = path.join(__dirname, "fixtures/legacy-barcodes");
+const manifest = JSON.parse(fs.readFileSync(path.join(FIXTURE_DIR, "manifest.json"), "utf8"));
+const manifestByType = new Map(manifest.map((entry) => [entry.type, entry]));
+
+function legacyFixtureToDataUri(filename) {
+  const pngBuffer = fs.readFileSync(path.join(FIXTURE_DIR, filename));
+  return `data:image/png;base64,${pngBuffer.toString("base64")}`;
+}
+
+describe("barcode equivalence", () => {
+  it("should include a manifest entry for every supported symbology type", () => {
+    for (const type of listSupportedSymbologyTypes()) {
+      assert.ok(manifestByType.has(type.toLowerCase()), `Missing manifest entry for ${type}`);
+    }
+    assert.equal(manifest.length, listSupportedSymbologyTypes().length);
+  });
+
+  for (const testCase of manifest) {
+    it(`should support ${testCase.type} with bwip-js`, async () => {
+      const nextImage = await generateBwipTestPng({
+        type: testCase.type,
+        content: testCase.bwipContent || testCase.content,
+        height: testCase.height,
+        bwipOptions: testCase.bwipOptions || {}
+      });
+
+      assert.match(nextImage, /^data:image\/png;base64,/);
+      assert.equal(isValidPngDataUri(nextImage), true);
+      assert.equal(testCase.bwipGenerated, true);
+    });
+
+    if (testCase.legacyGenerated) {
+      it(`should match legacy ${testCase.type} decoded payload when scannable`, async () => {
+        const legacyImage = legacyFixtureToDataUri(testCase.file);
+        const nextImage = await generateBwipTestPng({
+          type: testCase.type,
+          content: testCase.bwipContent || testCase.content,
+          height: testCase.height,
+          bwipOptions: testCase.bwipOptions || {}
+        });
+
+        if (!testCase.decodable) {
+          assert.equal(isValidPngDataUri(legacyImage), true);
+          assert.equal(isValidPngDataUri(nextImage), true);
+          return;
+        }
+
+        const legacyDecoded = await decodePngDataUri(legacyImage);
+        const nextDecoded = await decodePngDataUri(nextImage);
+
+        assert.equal(nextDecoded, legacyDecoded);
+      });
+    }
+  }
+});

package/test/barcode-test.js

@@ -0,0 +1,44 @@
+const assert = require("node:assert/strict");
+const {describe, it} = require("node:test");
+const {generateBarcodePng} = require("../src/barcode-generator.js");
+const {decodePngDataUri, isValidPngDataUri} = require("./helpers/barcode-decode.js");
+
+describe("barcode-generator.js", () => {
+  it("should generate a valid PNG data URI for code128", async () => {
+    const image = await generateBarcodePng({
+      type: "code128",
+      content: "1234",
+      height: 10
+    });
+
+    assert.match(image, /^data:image\/png;base64,/);
+    assert.equal(isValidPngDataUri(image), true);
+  });
+
+  it("should decode generated code128 barcodes to the original payload", async () => {
+    const image = await generateBarcodePng({
+      type: "code128",
+      content: "1234",
+      height: 10
+    });
+
+    assert.equal(await decodePngDataUri(image), "1234");
+  });
+
+  it("should decode generated eanx barcodes to the original payload", async () => {
+    const image = await generateBarcodePng({
+      type: "eanx",
+      content: "5901234123457",
+      height: 10
+    });
+
+    assert.equal(await decodePngDataUri(image), "5901234123457");
+  });
+
+  it("should reject unsupported symbology formats", async () => {
+    await assert.rejects(
+      () => generateBarcodePng({type: "gridmatrix", content: "1234", height: 10}),
+      /Unsupported barcode type: GRIDMATRIX/
+    );
+  });
+});

package/test/barcode-types-test.js

@@ -0,0 +1,61 @@
+const assert = require("node:assert/strict");
+const {describe, it} = require("node:test");
+const SYMBOLOGY_TYPE_NAMES = require("./fixtures/symbology-type-names.js");
+const {
+  resolveBarcodeType,
+  listSupportedSymbologyTypes,
+  listUnsupportedSymbologyTypes,
+  UNSUPPORTED_TYPES,
+  SYMBLOGY_TO_BWIP
+} = require("../src/barcode-types.js");
+
+describe("barcode-types.js", () => {
+  it("should map every symbology enum name except unsupported ones", () => {
+    const expectedSupported = SYMBOLOGY_TYPE_NAMES
+      .filter((type) => !UNSUPPORTED_TYPES.has(type))
+      .sort();
+
+    assert.deepStrictEqual(listSupportedSymbologyTypes(), expectedSupported);
+  });
+
+  it("should expose unsupported symbology formats", () => {
+    assert.deepStrictEqual(listUnsupportedSymbologyTypes(), [
+      "GRIDMATRIX",
+      "KOREAPOST",
+      "UPNQR",
+      "VIN"
+    ]);
+  });
+
+  it("should resolve known aliases to bwip-js bcid values", () => {
+    assert.equal(resolveBarcodeType("code128"), "code128");
+    assert.equal(resolveBarcodeType("CODE11"), "code11");
+    assert.equal(resolveBarcodeType("qrcode"), "qrcode");
+    assert.equal(resolveBarcodeType("EAN128"), "gs1-128");
+    assert.equal(resolveBarcodeType("RM4SCC"), "royalmail");
+  });
+
+  it("should throw for unsupported symbology formats", () => {
+    for (const type of listUnsupportedSymbologyTypes()) {
+      assert.throws(
+        () => resolveBarcodeType(type),
+        (err) => err.message === `Unsupported barcode type: ${type}`
+      );
+    }
+  });
+
+  it("should throw for unknown symbology formats", () => {
+    assert.throws(
+      () => resolveBarcodeType("not-a-real-format"),
+      /Unsupported barcode type: NOT-A-REAL-FORMAT/
+    );
+  });
+
+  it("should map every supported symbology type to a non-empty bcid", () => {
+    for (const type of listSupportedSymbologyTypes()) {
+      const bcid = SYMBLOGY_TO_BWIP[type];
+      assert.ok(bcid, `Expected bcid mapping for ${type}`);
+      assert.equal(typeof bcid, "string");
+    }
+  });
+});

package/test/fixtures/barcode-sample-content.js

@@ -0,0 +1,100 @@
+// Sample payloads per legacy Symbology type. Values prefer content that works in both
+// Symbology 4.0.2 and bwip-js where possible; `bwipContent` overrides bwip-only cases.
+module.exports = {
+  AUSPOST: {content: "62123456789"},
+  AUSREDIRECT: {content: "62123456789"},
+  AUSREPLY: {content: "62123456789"},
+  AUSROUTE: {content: "62123456789"},
+  AZRUNE: {content: "1"},
+  AZTEC: {content: "AZTEC"},
+  C25IATA: {content: "1234567"},
+  C25IND: {content: "1234567"},
+  C25INTER: {content: "1234567890"},
+  C25LOGIC: {content: "1234567"},
+  C25MATRIX: {content: "1234567"},
+  CHANNEL: {content: "01"},
+  CODABAR: {content: "A123456A"},
+  CODABLOCKF: {content: "CODABLOCK"},
+  CODE11: {content: "1234"},
+  CODE128: {content: "1234"},
+  CODE128B: {content: "1234"},
+  CODE16K: {content: "1234"},
+  CODE32: {content: "12345678"},
+  CODE39: {content: "ABC123"},
+  CODE49: {content: "1234"},
+  CODE93: {content: "1234"},
+  CODEONE: {content: "1234"},
+  DAFT: {content: "DAFT"},
+  DATAMATRIX: {content: "DATAMATRIX"},
+  DOTCODE: {content: "DOTCODE"},
+  DPIDENT: {content: "12345678901"},
+  DPLEIT: {content: "1234567890123"},
+  EAN128: {content: "[01]09501101530003", bwipContent: "(01)09501101530003"},
+  EAN128_CC: {content: "(01)09501101530003|99TEST", bwipContent: "(01)09501101530003|(10)ABC"},
+  EAN14: {content: "1234567890123", bwipContent: "(01)09501101530003", bwipOptions: {parse: true}},
+  EANX: {content: "5901234123457"},
+  EANX_CC: {content: "5901234123457|99TEST", bwipContent: "5901234123457|(10)ABC"},
+  EANX_CHK: {content: "5901234123457"},
+  EXCODE39: {content: "ABC-123"},
+  FIM: {content: "1"},
+  FLAT: {content: "1"},
+  HANXIN: {content: "HANXIN"},
+  HIBC_128: {content: "+ABC1234ABC1234/$$0123456789012"},
+  HIBC_39: {content: "+ABC1234ABC1234/$$0123456789012"},
+  HIBC_AZTEC: {content: "+ABC1234ABC1234/$$0123456789012"},
+  HIBC_DM: {content: "+ABC1234ABC1234/$$0123456789012"},
+  HIBC_MICPDF: {content: "+ABC1234ABC1234/$$0123456789012"},
+  HIBC_PDF: {content: "+ABC1234ABC1234/$$0123456789012"},
+  HIBC_QR: {content: "+ABC1234ABC1234/$$0123456789012"},
+  ISBNX: {content: "9780306406157", bwipContent: "978-0-306-40615-7"},
+  ITF14: {content: "1234567890123"},
+  JAPANPOST: {content: "12345678901"},
+  KIX: {content: "15400171583802"},
+  LOGMARS: {content: "ABC123"},
+  MAILMARK: {
+    content: "AV11HX7TCH",
+    bwipContent: `JGB ${"X".repeat(41)}`,
+    bwipOptions: {type: 9}
+  },
+  MAXICODE: {content: "1234567890123456789012345678901234"},
+  MICROPDF417: {content: "MICROPDF"},
+  MICROQR: {content: "MICROQR"},
+  MSI_PLESSEY: {content: "123456"},
+  NVE18: {
+    content: "12345678901234567",
+    bwipContent: "(00)12345678901234567",
+    bwipOptions: {parse: true, includecheck: true}
+  },
+  ONECODE: {content: "01234567890501234567890501", bwipContent: "01234567890501234567890501234"},
+  PDF417: {content: "PDF417"},
+  PDF417TRUNC: {content: "PDF417"},
+  PHARMA: {content: "123"},
+  PHARMA_TWO: {content: "123456"},
+  PLANET: {content: "01234567890"},
+  PLESSEY: {content: "1234567890"},
+  POSTNET: {content: "01234"},
+  PZN: {content: "123456"},
+  QRCODE: {content: "hello-world"},
+  RM4SCC: {content: "W1J0TRQ"},
+  RSS14: {content: "0123456789051", bwipContent: "(01)09501101530003", bwipOptions: {parse: true}},
+  RSS14STACK: {content: "0123456789051", bwipContent: "(01)09501101530003", bwipOptions: {parse: true}},
+  RSS14STACK_CC: {content: "0123456789051|99TEST", bwipContent: "(01)09501101530003|(10)ABC"},
+  RSS14STACK_OMNI: {content: "0123456789051", bwipContent: "(01)09501101530003", bwipOptions: {parse: true}},
+  RSS14_CC: {content: "012345678905|99TEST", bwipContent: "(01)09501101530003|(10)ABC"},
+  RSS14_OMNI_CC: {content: "0123456789051|99TEST", bwipContent: "(01)09501101530003|(10)ABC"},
+  RSS_EXP: {content: "[01]09501101530003", bwipContent: "(01)09501101530003"},
+  RSS_EXPSTACK: {content: "(01)09501101530003"},
+  RSS_EXPSTACK_CC: {content: "(01)09501101530003|99TEST", bwipContent: "(01)09501101530003|(10)ABC"},
+  RSS_EXP_CC: {content: "(01)09501101530003|99TEST", bwipContent: "(01)09501101530003|(10)ABC"},
+  RSS_LTD: {content: "0123456789051", bwipContent: "(01)09501101530003", bwipOptions: {parse: true}},
+  RSS_LTD_CC: {content: "0123456789051|99TEST", bwipContent: "(01)09501101530003|(10)ABC"},
+  TELEPEN: {content: "Telepen"},
+  TELEPEN_NUM: {content: "123456"},
+  ULTRA: {content: "ULTRA"},
+  UPCA: {content: "012345678905"},
+  UPCA_CC: {content: "012345678905|99TEST", bwipContent: "012345678905|(10)ABC"},
+  UPCA_CHK: {content: "012345678905"},
+  UPCE: {content: "0123456"},
+  UPCE_CC: {content: "0123456|99TEST", bwipContent: "0123456|(10)ABC"},
+  UPCE_CHK: {content: "0123456"}
+};

package/test/fixtures/generate-legacy-barcodes.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * One-time maintenance script: requires symbology@4.0.2 (npm i -D symbology@4.0.2).
+ * Generates legacy PNG fixtures for every supported barcode type.
+ *
+ * Usage: node test/fixtures/generate-legacy-barcodes.js
+ */
+const fs = require("node:fs");
+const path = require("node:path");
+const bwipjs = require("bwip-js");
+const {SymbologyType, createStream, OutputType} = require("symbology");
+const {scanImageData} = require("@undecaf/zbar-wasm");
+const {PNG} = require("pngjs");
+const {listSupportedSymbologyTypes, resolveBarcodeType} = require("../../src/barcode-types.js");
+const SAMPLE_CONTENT = require("./barcode-sample-content.js");
+
+const FIXTURE_DIR = path.join(__dirname, "legacy-barcodes");
+const HEIGHT = 30;
+
+function slug(value) {
+  return String(value).replace(/[^a-zA-Z0-9]+/g, "_").slice(0, 40);
+}
+
+async function tryDecodePngBuffer(pngBuffer) {
+  const png = PNG.sync.read(pngBuffer);
+  const symbols = await scanImageData({
+    data: png.data,
+    width: png.width,
+    height: png.height
+  });
+  return symbols.length ? symbols[0].decode() : null;
+}
+
+async function generateLegacyPng(type, content) {
+  const symbologyType = SymbologyType[type];
+  if (!symbologyType) {
+    throw new Error(`Symbology enum missing for ${type}`);
+  }
+
+  const result = await createStream({
+    symbology: symbologyType,
+    height: HEIGHT,
+    showHumanReadableText: false,
+    scale: 2.0
+  }, String(content), OutputType.PNG);
+
+  const base64 = result.data.replace(/^data:image\/png;base64,/, "");
+  return Buffer.from(base64, "base64");
+}
+
+async function generateBwipPng(type, content, bwipOptions = {}) {
+  const bcid = resolveBarcodeType(type);
+  return bwipjs.toBuffer({
+    bcid,
+    text: String(content),
+    scale: 2,
+    height: HEIGHT,
+    includetext: false,
+    backgroundcolor: "FFFFFF",
+    ...bwipOptions
+  });
+}
+
+async function main() {
+  fs.mkdirSync(FIXTURE_DIR, {recursive: true});
+
+  const manifest = [];
+  const failures = [];
+
+  for (const type of listSupportedSymbologyTypes()) {
+    const sample = SAMPLE_CONTENT[type];
+    if (!sample) {
+      failures.push({type, stage: "sample-content", error: "Missing sample content"});
+      continue;
+    }
+
+    const legacyContent = sample.content;
+    const bwipContent = sample.bwipContent || sample.content;
+    const bwipOptions = sample.bwipOptions || {};
+    const filename = `${type.toLowerCase()}-${slug(legacyContent)}.png`;
+    const entry = {
+      type: type.toLowerCase(),
+      content: legacyContent,
+      bwipContent,
+      bwipOptions,
+      height: HEIGHT
+    };
+
+    let legacyBuffer = null;
+    try {
+      legacyBuffer = await generateLegacyPng(type, legacyContent);
+      fs.writeFileSync(path.join(FIXTURE_DIR, filename), legacyBuffer);
+      entry.file = filename;
+      entry.legacyGenerated = true;
+      process.stdout.write("L");
+    } catch (error) {
+      entry.legacyGenerated = false;
+      entry.legacyError = error.message || String(error);
+      process.stdout.write("l");
+    }
+
+    try {
+      const bwipBuffer = await generateBwipPng(type, bwipContent, bwipOptions);
+      entry.bwipGenerated = true;
+      process.stdout.write("B");
+
+      if (legacyBuffer) {
+        entry.legacyDecoded = await tryDecodePngBuffer(legacyBuffer);
+        entry.bwipDecoded = await tryDecodePngBuffer(bwipBuffer);
+        entry.decodable = entry.legacyDecoded !== null
+          && entry.bwipDecoded !== null
+          && entry.legacyDecoded === entry.bwipDecoded;
+      } else {
+        entry.bwipDecoded = await tryDecodePngBuffer(bwipBuffer);
+        entry.decodable = entry.bwipDecoded !== null;
+      }
+    } catch (error) {
+      entry.bwipGenerated = false;
+      entry.bwipError = error.message || String(error);
+      failures.push({type, stage: "bwip", error: entry.bwipError});
+      process.stdout.write("b");
+    }
+
+    manifest.push(entry);
+    process.stdout.write(" ");
+  }
+
+  process.stdout.write("\n");
+  manifest.sort((a, b) => a.type.localeCompare(b.type));
+  fs.writeFileSync(
+    path.join(FIXTURE_DIR, "manifest.json"),
+    `${JSON.stringify(manifest, null, 2)}\n`
+  );
+
+  fs.writeFileSync(
+    path.join(FIXTURE_DIR, "generation-failures.json"),
+    `${JSON.stringify(failures, null, 2)}\n`
+  );
+
+  const legacyCount = manifest.filter((entry) => entry.legacyGenerated).length;
+  const bwipCount = manifest.filter((entry) => entry.bwipGenerated).length;
+  const decodableCount = manifest.filter((entry) => entry.decodable).length;
+
+  console.log(`Manifest entries: ${manifest.length}`);
+  console.log(`Legacy fixtures: ${legacyCount}`);
+  console.log(`Bwip generated: ${bwipCount}`);
+  console.log(`Decodable pairs: ${decodableCount}`);
+  console.log(`Bwip failures: ${failures.length}`);
+
+  if (failures.length) {
+    process.exitCode = 1;
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});