quadqr-js 1.2.0 → 1.4.2

package/dist/esm/benchmark.js

@@ -12,6 +12,8 @@ import {
   decodeMatrix,
   getVersionInfo,
   compressPayload,
+  compressDeflatePayload,
+  compressBrotliPayload,
   MAX_VERSION
 } from "./quadqr.js";
 
@@ -30,6 +32,16 @@ function normalizeEcc(ecc = "M") {
   return value;
 }
 
+function resolveHighDensity(options = {}) {
+  if (typeof options.highDensity === "boolean") return options.highDensity;
+  // Backward compatibility for the first experimental Triangle16 branch.
+  return options.cellEncoding === "triangle16";
+}
+
+function encodingForHighDensity(highDensity) {
+  return highDensity ? "triangle16" : "rgbw";
+}
+
 function nowMs() {
   if (typeof performance !== "undefined" && typeof performance.now === "function") {
     return performance.now();
@@ -76,9 +88,11 @@ export function getStandardQrByteCapacity(version, ecc = "M") {
   return STANDARD_QR_BYTE_CAPACITY[normalizeEcc(ecc)][version - 1];
 }
 
-export function compareCapacity(version, ecc = "M") {
+export function compareCapacity(version, ecc = "M", options = {}) {
   const level = normalizeEcc(ecc);
-  const quadqr = getVersionInfo(version, { ecc: level });
+  const highDensity = resolveHighDensity(options);
+  const cellEncoding = encodingForHighDensity(highDensity);
+  const quadqr = getVersionInfo(version, { ecc: level, highDensity });
   const standardQrBytes = getStandardQrByteCapacity(version, level);
   const quadqrBytes = quadqr.capacityBytes;
   const differenceBytes = quadqrBytes - standardQrBytes;
@@ -94,6 +108,8 @@ export function compareCapacity(version, ecc = "M") {
     differenceBytes,
     ratio,
     gainPercent,
+    highDensity,
+    cellEncoding: quadqr.cellEncoding,
     quadqrBitsPerDataCell: quadqr.bitsPerDataCell,
     quadqrPayloadEfficiencyPercent: quadqr.theoreticalBits > 0
       ? (quadqrBytes * 8 / quadqr.theoreticalBits) * 100
@@ -108,42 +124,72 @@ export function compareCapacity(version, ecc = "M") {
 /** Calculate the smallest QuadQR and standard QR versions for a payload size. */
 export function calculateCapacityPlan(options = {}) {
   const ecc = normalizeEcc(options.ecc ?? "M");
+  const highDensity = resolveHighDensity(options);
+  const cellEncoding = encodingForHighDensity(highDensity);
   let sourceBytes;
   const hasConcretePayload = options.payload instanceof Uint8Array || typeof options.payload === "string";
   if (options.payload instanceof Uint8Array) sourceBytes = options.payload;
   else if (typeof options.payload === "string") sourceBytes = new TextEncoder().encode(options.payload);
   else sourceBytes = new Uint8Array(Math.max(0, Math.floor(options.payloadBytes ?? 0)));
 
-  const requestedCompression = options.compression ?? "none";
+  const requestedCompression = String(options.compression ?? "none").toLowerCase();
+  if (!["none", "auto", "smart", "lz", "deflate", "brotli"].includes(requestedCompression)) {
+    throw new Error("compression must be none, auto, smart, lz, deflate, or brotli.");
+  }
   const signed = Boolean(options.signed);
   const keyIdBytes = options.keyId ? new TextEncoder().encode(String(options.keyId)).length : 0;
   const envelopeHeaderBytes = 16;
   const signingBytes = signed ? 64 + keyIdBytes + (options.embedPublicKey ? 32 : 0) : 0;
   let compression = requestedCompression;
+  let compressionLevel = null;
   let storedBytes = sourceBytes.length;
   let compressed = false;
 
   if (requestedCompression !== "none" && hasConcretePayload) {
-    const candidate = compressPayload(sourceBytes);
-    if (requestedCompression === "lz" || candidate.length < sourceBytes.length - 2) {
-      storedBytes = candidate.length;
+    const candidates = [];
+    const explicitLevel = options.compressionLevel;
+    if (requestedCompression === "auto" || requestedCompression === "smart" || requestedCompression === "lz") {
+      const level = requestedCompression === "lz" ? (explicitLevel ?? options.lzLevel ?? 6) : 6;
+      candidates.push({ compression: "lz", bytes: compressPayload(sourceBytes, { level }).length, level });
+    }
+    if (requestedCompression === "auto") {
+      candidates.push({ compression: "deflate", bytes: compressDeflatePayload(sourceBytes, { level: 6 }).length, level: 6 });
+      candidates.push({ compression: "brotli", bytes: compressBrotliPayload(sourceBytes, { quality: 6 }).length, level: 6 });
+    } else if (requestedCompression === "smart") {
+      for (const level of [6, 8, 9]) candidates.push({ compression: "deflate", bytes: compressDeflatePayload(sourceBytes, { level }).length, level });
+      for (const level of [6, 9, 11]) candidates.push({ compression: "brotli", bytes: compressBrotliPayload(sourceBytes, { quality: level }).length, level });
+    } else if (requestedCompression === "deflate") {
+      const level = explicitLevel ?? options.deflateLevel ?? 6;
+      candidates.push({ compression: "deflate", bytes: compressDeflatePayload(sourceBytes, { level }).length, level });
+    } else if (requestedCompression === "brotli") {
+      const level = explicitLevel ?? options.brotliQuality ?? 11;
+      candidates.push({ compression: "brotli", bytes: compressBrotliPayload(sourceBytes, { quality: level }).length, level });
+    }
+    if (!candidates.length) throw new Error("compression must be none, auto, smart, lz, deflate, or brotli.");
+    candidates.sort((a, b) => a.bytes - b.bytes);
+    const best = candidates[0];
+    const compressionOverhead = signed ? 0 : envelopeHeaderBytes;
+    if (!["auto", "smart"].includes(requestedCompression) || best.bytes + compressionOverhead < sourceBytes.length) {
+      storedBytes = best.bytes;
       compressed = true;
-      compression = "lz";
+      compression = best.compression;
+      compressionLevel = best.level ?? null;
     } else {
       compression = "none";
+      compressionLevel = null;
     }
   } else if (requestedCompression !== "none" && !hasConcretePayload) {
     compression = "unknown";
   }
 
-  const needsEnvelope = signed || compressed || requestedCompression === "lz";
+  const needsEnvelope = signed || compressed || requestedCompression === "lz" || requestedCompression === "deflate" || requestedCompression === "brotli";
   const encodedBytes = storedBytes + (needsEnvelope ? envelopeHeaderBytes + signingBytes : 0);
   const extensionOverheadBytes = encodedBytes - storedBytes;
 
   let quadqrVersion = null;
   let quadqrInfo = null;
   for (let version = 1; version <= MAX_VERSION; version++) {
-    const info = getVersionInfo(version, { ecc });
+    const info = getVersionInfo(version, { ecc, highDensity });
     if (encodedBytes <= info.capacityBytes) {
       quadqrVersion = version;
       quadqrInfo = info;
@@ -162,11 +208,14 @@ export function calculateCapacityPlan(options = {}) {
 
   return {
     ecc,
+    highDensity,
+    cellEncoding,
     sourceBytes: sourceBytes.length,
     encodedBytes,
     storedBytes,
     extensionOverheadBytes,
     compression,
+    compressionLevel,
     compressed,
     signed,
     quadqrVersion,
@@ -185,12 +234,15 @@ export function calculateCapacityPlan(options = {}) {
 
 export function buildCapacityComparison(options = {}) {
   const ecc = normalizeEcc(options.ecc ?? "M");
+  const highDensity = resolveHighDensity(options);
   const versions = options.versions ?? Array.from({ length: MAX_VERSION }, (_, i) => i + 1);
-  return versions.map((version) => compareCapacity(version, ecc));
+  return versions.map((version) => compareCapacity(version, ecc, { highDensity }));
 }
 
 export function benchmarkCodec(options = {}) {
   const ecc = normalizeEcc(options.ecc ?? "M");
+  const highDensity = resolveHighDensity(options);
+  const cellEncoding = encodingForHighDensity(highDensity);
   const iterations = Math.max(1, Math.floor(options.iterations ?? 30));
   const warmup = Math.max(0, Math.floor(options.warmup ?? Math.min(5, iterations)));
   const requestedSizes = options.payloadSizes ?? [24, 32, 128, 512, 1024, 2048];
@@ -202,14 +254,14 @@ export function benchmarkCodec(options = {}) {
 
     let probe;
     try {
-      probe = encodeBytes(payload, { ecc });
+      probe = encodeBytes(payload, { ecc, highDensity });
     } catch (error) {
       results.push({ payloadBytes, skipped: true, reason: error.message });
       continue;
     }
 
     for (let i = 0; i < warmup; i++) {
-      const encoded = encodeBytes(payload, { ecc, version: probe.version });
+      const encoded = encodeBytes(payload, { ecc, highDensity, version: probe.version });
       decodeMatrix(encoded.matrix);
     }
 
@@ -219,7 +271,7 @@ export function benchmarkCodec(options = {}) {
 
     for (let i = 0; i < iterations; i++) {
       let start = nowMs();
-      encoded = encodeBytes(payload, { ecc, version: probe.version });
+      encoded = encodeBytes(payload, { ecc, highDensity, version: probe.version });
       encodeSamples.push(nowMs() - start);
 
       start = nowMs();
@@ -231,7 +283,7 @@ export function benchmarkCodec(options = {}) {
       }
     }
 
-    const versionInfo = getVersionInfo(encoded.version, { ecc });
+    const versionInfo = getVersionInfo(encoded.version, { ecc, highDensity });
     results.push({
       payloadBytes,
       skipped: false,
@@ -250,6 +302,8 @@ export function benchmarkCodec(options = {}) {
   return {
     format: "QuadQR",
     ecc,
+    highDensity,
+    cellEncoding,
     iterations,
     warmup,
     generatedAt: new Date().toISOString(),
@@ -259,11 +313,13 @@ export function benchmarkCodec(options = {}) {
 
 export function benchmarkReport(options = {}) {
   const ecc = normalizeEcc(options.ecc ?? "M");
+  const highDensity = resolveHighDensity(options);
   const versions = options.versions ?? [1, 2, 5, 10, 20, 30, 40];
   return {
-    capacity: buildCapacityComparison({ ecc, versions }),
+    capacity: buildCapacityComparison({ ecc, versions, highDensity }),
     performance: benchmarkCodec({
       ecc,
+      highDensity,
       iterations: options.iterations ?? 30,
       warmup: options.warmup,
       payloadSizes: options.payloadSizes