@urbicon-ui/blocks 6.35.0 → 6.37.0

package/dist/components/QRCode/qr-encode.js

@@ -0,0 +1,528 @@
+/**
+ * Zero-dependency QR Code encoder (ISO/IEC 18004).
+ *
+ * Produces the module matrix for a piece of text — no rendering, no runtime
+ * dependency. Supports numeric / alphanumeric / byte segment modes (whichever
+ * is most compact for the input), all 40 versions, the four error-correction
+ * levels, and automatic data-mask selection by the standard penalty rules.
+ *
+ * The algorithm follows the reference structure of Project Nayuki's public
+ * QR generator (the canonical, spec-faithful design); the code here is an
+ * independent TypeScript implementation of the ISO standard.
+ */
+/** ECC level → ordinal used to index the correction tables. */
+const ECL_ORDINAL = { L: 0, M: 1, Q: 2, H: 3 };
+/** ECC level → the 2 format bits it contributes (L=01, M=00, Q=11, H=10). */
+const ECL_FORMAT_BITS = { L: 1, M: 0, Q: 3, H: 2 };
+const MIN_VERSION = 1;
+const MAX_VERSION = 40;
+const PENALTY_N1 = 3;
+const PENALTY_N2 = 3;
+const PENALTY_N3 = 40;
+const PENALTY_N4 = 10;
+// Number of error-correction codewords per block, indexed [ecl][version].
+// Index 0 of each row is unused padding.
+const ECC_CODEWORDS_PER_BLOCK = [
+    // 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
+    [
+        -1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30,
+        30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30
+    ], // Low
+    [
+        -1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28,
+        28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28
+    ], // Medium
+    [
+        -1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30,
+        30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30
+    ], // Quartile
+    [
+        -1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30,
+        30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30
+    ] // High
+];
+// Number of error-correction blocks, indexed [ecl][version].
+const NUM_ERROR_CORRECTION_BLOCKS = [
+    // 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
+    [
+        -1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14,
+        15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25
+    ], // Low
+    [
+        -1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23,
+        25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49
+    ], // Medium
+    [
+        -1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34,
+        34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68
+    ], // Quartile
+    [
+        -1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35,
+        37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81
+    ] // High
+];
+const ALPHANUMERIC_CHARSET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';
+/** Mode indicator (4-bit) values. */
+const MODE_BITS = { numeric: 0x1, alphanumeric: 0x2, byte: 0x4 };
+/** Character-count-indicator bit width for a mode within a version's group. */
+function charCountBits(mode, version) {
+    const group = version <= 9 ? 0 : version <= 26 ? 1 : 2;
+    if (mode === 'numeric')
+        return [10, 12, 14][group];
+    if (mode === 'alphanumeric')
+        return [9, 11, 13][group];
+    return [8, 16, 16][group]; // byte
+}
+/** A growable bit buffer (MSB-first). */
+class BitBuffer {
+    bits = [];
+    append(value, length) {
+        for (let i = length - 1; i >= 0; i--)
+            this.bits.push((value >>> i) & 1);
+    }
+}
+function selectMode(text) {
+    if (/^[0-9]*$/.test(text))
+        return 'numeric';
+    for (const ch of text)
+        if (!ALPHANUMERIC_CHARSET.includes(ch))
+            return 'byte';
+    return 'alphanumeric';
+}
+function utf8Bytes(text) {
+    return Array.from(new TextEncoder().encode(text));
+}
+/** Encode the payload (mode + count + data) into a bit buffer, given version. */
+function encodeData(text, mode, version, bytes) {
+    const bb = new BitBuffer();
+    bb.append(MODE_BITS[mode], 4);
+    if (mode === 'numeric') {
+        bb.append(text.length, charCountBits(mode, version));
+        for (let i = 0; i < text.length; i += 3) {
+            const chunk = text.substring(i, i + 3);
+            bb.append(Number.parseInt(chunk, 10), chunk.length * 3 + 1);
+        }
+    }
+    else if (mode === 'alphanumeric') {
+        bb.append(text.length, charCountBits(mode, version));
+        for (let i = 0; i < text.length; i += 2) {
+            if (i + 1 < text.length) {
+                const v = ALPHANUMERIC_CHARSET.indexOf(text[i]) * 45 + ALPHANUMERIC_CHARSET.indexOf(text[i + 1]);
+                bb.append(v, 11);
+            }
+            else {
+                bb.append(ALPHANUMERIC_CHARSET.indexOf(text[i]), 6);
+            }
+        }
+    }
+    else {
+        bb.append(bytes.length, charCountBits(mode, version));
+        for (const b of bytes)
+            bb.append(b, 8);
+    }
+    return bb;
+}
+function getNumRawDataModules(ver) {
+    let result = (16 * ver + 128) * ver + 64;
+    if (ver >= 2) {
+        const numAlign = Math.floor(ver / 7) + 2;
+        result -= (25 * numAlign - 10) * numAlign - 55;
+        if (ver >= 7)
+            result -= 36;
+    }
+    return result;
+}
+function getNumDataCodewords(ver, ecl) {
+    const o = ECL_ORDINAL[ecl];
+    return (Math.floor(getNumRawDataModules(ver) / 8) -
+        ECC_CODEWORDS_PER_BLOCK[o][ver] * NUM_ERROR_CORRECTION_BLOCKS[o][ver]);
+}
+// --- Reed–Solomon over GF(2^8) with primitive polynomial 0x11D ---
+function rsMultiply(x, y) {
+    let z = 0;
+    for (let i = 7; i >= 0; i--) {
+        z = (z << 1) ^ ((z >>> 7) * 0x11d);
+        z ^= ((y >>> i) & 1) * x;
+    }
+    return z & 0xff;
+}
+function rsComputeDivisor(degree) {
+    const result = new Array(degree).fill(0);
+    result[degree - 1] = 1;
+    let root = 1;
+    for (let i = 0; i < degree; i++) {
+        for (let j = 0; j < result.length; j++) {
+            result[j] = rsMultiply(result[j], root);
+            if (j + 1 < result.length)
+                result[j] ^= result[j + 1];
+        }
+        root = rsMultiply(root, 0x02);
+    }
+    return result;
+}
+function rsComputeRemainder(data, divisor) {
+    const result = new Array(divisor.length).fill(0);
+    for (const b of data) {
+        const factor = b ^ result.shift();
+        result.push(0);
+        for (let i = 0; i < result.length; i++)
+            result[i] ^= rsMultiply(divisor[i], factor);
+    }
+    return result;
+}
+/** Split data codewords into EC blocks, compute EC, and interleave. */
+function addEccAndInterleave(data, ver, ecl) {
+    const o = ECL_ORDINAL[ecl];
+    const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[o][ver];
+    const blockEccLen = ECC_CODEWORDS_PER_BLOCK[o][ver];
+    const rawCodewords = Math.floor(getNumRawDataModules(ver) / 8);
+    const numShortBlocks = numBlocks - (rawCodewords % numBlocks);
+    const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+    const blocks = [];
+    const rsDiv = rsComputeDivisor(blockEccLen);
+    for (let i = 0, k = 0; i < numBlocks; i++) {
+        const dat = data.slice(k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));
+        k += dat.length;
+        const ecc = rsComputeRemainder(dat, rsDiv);
+        const block = dat.slice();
+        if (i < numShortBlocks)
+            block.push(0); // padding placeholder, skipped on interleave
+        blocks.push(block.concat(ecc));
+    }
+    const result = [];
+    for (let i = 0; i < blocks[0].length; i++) {
+        for (let j = 0; j < blocks.length; j++) {
+            // Skip the padding cell in short blocks.
+            if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks)
+                result.push(blocks[j][i]);
+        }
+    }
+    return result;
+}
+// --- Matrix construction ---
+class QrMatrix {
+    version;
+    ecl;
+    size;
+    modules;
+    isFunction;
+    constructor(version, ecl, dataCodewords) {
+        this.version = version;
+        this.ecl = ecl;
+        this.size = version * 4 + 17;
+        this.modules = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+        this.isFunction = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+        this.drawFunctionPatterns();
+        const allCodewords = addEccAndInterleave(dataCodewords, version, ecl);
+        this.drawCodewords(allCodewords);
+        // Pick the mask that minimises the penalty score.
+        let minPenalty = Infinity;
+        let bestMask = 0;
+        for (let mask = 0; mask < 8; mask++) {
+            this.applyMask(mask);
+            this.drawFormatBits(mask);
+            const penalty = this.getPenaltyScore();
+            if (penalty < minPenalty) {
+                minPenalty = penalty;
+                bestMask = mask;
+            }
+            this.applyMask(mask); // undo (XOR is its own inverse)
+        }
+        this.applyMask(bestMask);
+        this.drawFormatBits(bestMask);
+    }
+    setFunctionModule(x, y, isDark) {
+        this.modules[y][x] = isDark;
+        this.isFunction[y][x] = true;
+    }
+    drawFunctionPatterns() {
+        // Timing patterns.
+        for (let i = 0; i < this.size; i++) {
+            this.setFunctionModule(6, i, i % 2 === 0);
+            this.setFunctionModule(i, 6, i % 2 === 0);
+        }
+        // Finder patterns (with their separators via the 8×8 boxes).
+        this.drawFinderPattern(3, 3);
+        this.drawFinderPattern(this.size - 4, 3);
+        this.drawFinderPattern(3, this.size - 4);
+        // Alignment patterns.
+        const alignPos = this.getAlignmentPatternPositions();
+        const n = alignPos.length;
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                // Skip the three finder corners.
+                if (!((i === 0 && j === 0) || (i === 0 && j === n - 1) || (i === n - 1 && j === 0))) {
+                    this.drawAlignmentPattern(alignPos[i], alignPos[j]);
+                }
+            }
+        }
+        // Reserve format + version areas (filled with placeholders now, real bits later).
+        this.drawFormatBits(0);
+        this.drawVersion();
+    }
+    drawFinderPattern(cx, cy) {
+        for (let dy = -4; dy <= 4; dy++) {
+            for (let dx = -4; dx <= 4; dx++) {
+                const dist = Math.max(Math.abs(dx), Math.abs(dy));
+                const x = cx + dx;
+                const y = cy + dy;
+                if (x >= 0 && x < this.size && y >= 0 && y < this.size) {
+                    this.setFunctionModule(x, y, dist !== 2 && dist !== 4);
+                }
+            }
+        }
+    }
+    drawAlignmentPattern(cx, cy) {
+        for (let dy = -2; dy <= 2; dy++) {
+            for (let dx = -2; dx <= 2; dx++) {
+                this.setFunctionModule(cx + dx, cy + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+            }
+        }
+    }
+    getAlignmentPatternPositions() {
+        if (this.version === 1)
+            return [];
+        const numAlign = Math.floor(this.version / 7) + 2;
+        const step = this.version === 32 ? 26 : Math.ceil((this.size - 13) / (numAlign * 2 - 2)) * 2;
+        const result = [6];
+        for (let pos = this.size - 7; result.length < numAlign; pos -= step)
+            result.splice(1, 0, pos);
+        return result;
+    }
+    drawFormatBits(mask) {
+        const data = (ECL_FORMAT_BITS[this.ecl] << 3) | mask;
+        let rem = data;
+        for (let i = 0; i < 10; i++)
+            rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+        const bits = ((data << 10) | rem) ^ 0x5412;
+        // First copy (around the top-left finder).
+        for (let i = 0; i <= 5; i++)
+            this.setFunctionModule(8, i, ((bits >>> i) & 1) !== 0);
+        this.setFunctionModule(8, 7, ((bits >>> 6) & 1) !== 0);
+        this.setFunctionModule(8, 8, ((bits >>> 7) & 1) !== 0);
+        this.setFunctionModule(7, 8, ((bits >>> 8) & 1) !== 0);
+        for (let i = 9; i < 15; i++)
+            this.setFunctionModule(14 - i, 8, ((bits >>> i) & 1) !== 0);
+        // Second copy (split across the other two finders).
+        for (let i = 0; i < 8; i++)
+            this.setFunctionModule(this.size - 1 - i, 8, ((bits >>> i) & 1) !== 0);
+        for (let i = 8; i < 15; i++)
+            this.setFunctionModule(8, this.size - 15 + i, ((bits >>> i) & 1) !== 0);
+        this.setFunctionModule(8, this.size - 8, true); // always-dark module
+    }
+    drawVersion() {
+        if (this.version < 7)
+            return;
+        let rem = this.version;
+        for (let i = 0; i < 12; i++)
+            rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
+        const bits = (this.version << 12) | rem;
+        for (let i = 0; i < 18; i++) {
+            const bit = ((bits >>> i) & 1) !== 0;
+            const a = this.size - 11 + (i % 3);
+            const b = Math.floor(i / 3);
+            this.setFunctionModule(a, b, bit);
+            this.setFunctionModule(b, a, bit);
+        }
+    }
+    drawCodewords(data) {
+        let i = 0; // bit index into data
+        for (let right = this.size - 1; right >= 1; right -= 2) {
+            // Reassign `right` (not a local copy) when it hits the vertical timing
+            // column so the following `-= 2` keeps the column pairs odd-aligned —
+            // otherwise columns past 6 double up and the leftmost pair is dropped.
+            if (right === 6)
+                right = 5;
+            for (let vert = 0; vert < this.size; vert++) {
+                for (let j = 0; j < 2; j++) {
+                    const x = right - j;
+                    const upward = ((right + 1) & 2) === 0;
+                    const y = upward ? this.size - 1 - vert : vert;
+                    if (!this.isFunction[y][x] && i < data.length * 8) {
+                        this.modules[y][x] = ((data[i >>> 3] >>> (7 - (i & 7))) & 1) !== 0;
+                        i++;
+                    }
+                }
+            }
+        }
+    }
+    applyMask(mask) {
+        for (let y = 0; y < this.size; y++) {
+            for (let x = 0; x < this.size; x++) {
+                if (this.isFunction[y][x])
+                    continue;
+                let invert;
+                switch (mask) {
+                    case 0:
+                        invert = (x + y) % 2 === 0;
+                        break;
+                    case 1:
+                        invert = y % 2 === 0;
+                        break;
+                    case 2:
+                        invert = x % 3 === 0;
+                        break;
+                    case 3:
+                        invert = (x + y) % 3 === 0;
+                        break;
+                    case 4:
+                        invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
+                        break;
+                    case 5:
+                        invert = ((x * y) % 2) + ((x * y) % 3) === 0;
+                        break;
+                    case 6:
+                        invert = (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
+                        break;
+                    case 7:
+                        invert = (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
+                        break;
+                    default:
+                        throw new Error('unreachable mask');
+                }
+                if (invert)
+                    this.modules[y][x] = !this.modules[y][x];
+            }
+        }
+    }
+    getPenaltyScore() {
+        let result = 0;
+        const size = this.size;
+        // N1: rows/columns of ≥5 same-coloured modules.
+        for (let y = 0; y < size; y++) {
+            let runColor = false;
+            let runLen = 0;
+            const history = [0, 0, 0, 0, 0, 0, 0];
+            for (let x = 0; x < size; x++) {
+                if (this.modules[y][x] === runColor) {
+                    runLen++;
+                    if (runLen === 5)
+                        result += PENALTY_N1;
+                    else if (runLen > 5)
+                        result++;
+                }
+                else {
+                    this.finderPenaltyAddHistory(runLen, history);
+                    if (!runColor)
+                        result += this.finderPenaltyCountPatterns(history) * PENALTY_N3;
+                    runColor = this.modules[y][x];
+                    runLen = 1;
+                }
+            }
+            result += this.finderPenaltyTerminateAndCount(runColor, runLen, history) * PENALTY_N3;
+        }
+        for (let x = 0; x < size; x++) {
+            let runColor = false;
+            let runLen = 0;
+            const history = [0, 0, 0, 0, 0, 0, 0];
+            for (let y = 0; y < size; y++) {
+                if (this.modules[y][x] === runColor) {
+                    runLen++;
+                    if (runLen === 5)
+                        result += PENALTY_N1;
+                    else if (runLen > 5)
+                        result++;
+                }
+                else {
+                    this.finderPenaltyAddHistory(runLen, history);
+                    if (!runColor)
+                        result += this.finderPenaltyCountPatterns(history) * PENALTY_N3;
+                    runColor = this.modules[y][x];
+                    runLen = 1;
+                }
+            }
+            result += this.finderPenaltyTerminateAndCount(runColor, runLen, history) * PENALTY_N3;
+        }
+        // N2: 2×2 blocks of the same colour.
+        for (let y = 0; y < size - 1; y++) {
+            for (let x = 0; x < size - 1; x++) {
+                const c = this.modules[y][x];
+                if (c === this.modules[y][x + 1] &&
+                    c === this.modules[y + 1][x] &&
+                    c === this.modules[y + 1][x + 1]) {
+                    result += PENALTY_N2;
+                }
+            }
+        }
+        // N4: proportion of dark modules deviating from 50%.
+        let dark = 0;
+        for (const row of this.modules)
+            for (const cell of row)
+                if (cell)
+                    dark++;
+        const total = size * size;
+        const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
+        result += k * PENALTY_N4;
+        return result;
+    }
+    finderPenaltyCountPatterns(runHistory) {
+        const n = runHistory[1];
+        const core = n > 0 &&
+            runHistory[2] === n &&
+            runHistory[3] === n * 3 &&
+            runHistory[4] === n &&
+            runHistory[5] === n;
+        return ((core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0) +
+            (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0));
+    }
+    finderPenaltyTerminateAndCount(currentRunColor, currentRunLength, runHistory) {
+        let runLen = currentRunLength;
+        if (currentRunColor) {
+            this.finderPenaltyAddHistory(runLen, runHistory);
+            runLen = 0;
+        }
+        runLen += this.size;
+        this.finderPenaltyAddHistory(runLen, runHistory);
+        return this.finderPenaltyCountPatterns(runHistory);
+    }
+    finderPenaltyAddHistory(currentRunLength, runHistory) {
+        if (runHistory[0] === 0)
+            currentRunLength += this.size; // add light border to first run
+        runHistory.pop();
+        runHistory.unshift(currentRunLength);
+    }
+}
+/**
+ * Encode `text` into a QR module matrix (`true` = dark). The returned matrix has
+ * no quiet zone — the renderer adds it. Throws when the text does not fit any
+ * version at the requested ECC level.
+ */
+export function encodeQr(text, ecl = 'M', opts = {}) {
+    const minV = Math.max(MIN_VERSION, opts.minVersion ?? MIN_VERSION);
+    const maxV = Math.min(MAX_VERSION, opts.maxVersion ?? MAX_VERSION);
+    const mode = selectMode(text);
+    const bytes = mode === 'byte' ? utf8Bytes(text) : [];
+    // Find the smallest version that fits.
+    let version = -1;
+    let dataUsedBits = -1;
+    for (let v = minV; v <= maxV; v++) {
+        const capacityBits = getNumDataCodewords(v, ecl) * 8;
+        const bb = encodeData(text, mode, v, bytes);
+        if (bb.bits.length <= capacityBits) {
+            version = v;
+            dataUsedBits = bb.bits.length;
+            break;
+        }
+    }
+    if (version === -1) {
+        throw new Error('QR data too long for the given error-correction level');
+    }
+    const capacityBits = getNumDataCodewords(version, ecl) * 8;
+    const bb = encodeData(text, mode, version, bytes);
+    // Terminator + bit padding to a byte boundary.
+    const terminator = Math.min(4, capacityBits - dataUsedBits);
+    bb.append(0, terminator);
+    bb.append(0, (8 - (bb.bits.length % 8)) % 8);
+    // Byte padding (alternating 0xEC, 0x11) up to capacity.
+    for (let pad = 0xec; bb.bits.length < capacityBits; pad ^= 0xec ^ 0x11)
+        bb.append(pad, 8);
+    // Pack bits into codewords.
+    const dataCodewords = [];
+    for (let i = 0; i < bb.bits.length; i += 8) {
+        let byte = 0;
+        for (let j = 0; j < 8; j++)
+            byte = (byte << 1) | bb.bits[i + j];
+        dataCodewords.push(byte);
+    }
+    return new QrMatrix(version, ecl, dataCodewords).modules;
+}