react-native-inapp-inspector 2.3.13 → 2.3.15

package/src/helpers/qrGenerator.ts

@@ -1,49 +1,430 @@
 /**
- * ISO/IEC 18004 Standard QR Code Matrix Generator
- * Uses industry-standard qrcode-generator with full Reed-Solomon Error Correction
- * and BCH format encoding for 100% instant phone camera / Google Lens recognition.
+ * Zero-Dependency Pure TypeScript ISO/IEC 18004 QR Code Matrix Generator.
+ * Self-contained engine with Reed-Solomon Error Correction & BCH Format encoding.
+ * 100% compatible with Android Camera & Google Lens.
  */
-import qrcode from 'qrcode-generator';
 
 export type QRECC = 'L' | 'M' | 'Q' | 'H';
 
+const QR_ECC_LEVEL: Record<QRECC, number> = {
+  L: 1,
+  M: 0,
+  Q: 3,
+  H: 2,
+};
+
+// Galois field tables for GF(256)
+const EXP_TABLE = new Uint8Array(256);
+const LOG_TABLE = new Uint8Array(256);
+
+(function initGaloisField() {
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    EXP_TABLE[i] = x;
+    LOG_TABLE[x] = i;
+    x <<= 1;
+    if (x & 0x100) {
+      x ^= 0x11d; // GF(256) polynomial: x^8 + x^4 + x^3 + x^2 + 1
+    }
+  }
+  EXP_TABLE[255] = EXP_TABLE[0];
+})();
+
+function glog(n: number): number {
+  if (n < 1) throw new Error(`glog(${n})`);
+  return LOG_TABLE[n]!;
+}
+
+function gexp(n: number): number {
+  while (n < 0) n += 255;
+  while (n >= 256) n -= 255;
+  return EXP_TABLE[n]!;
+}
+
+class Polynomial {
+  num: number[];
+  constructor(num: number[], shift = 0) {
+    let offset = 0;
+    while (offset < num.length && num[offset] === 0) {
+      offset++;
+    }
+    this.num = new Array(num.length - offset + shift);
+    for (let i = 0; i < num.length - offset; i++) {
+      this.num[i] = num[i + offset]!;
+    }
+    for (let i = num.length - offset; i < this.num.length; i++) {
+      this.num[i] = 0;
+    }
+  }
+
+  get(index: number): number {
+    return this.num[index] || 0;
+  }
+
+  getLength(): number {
+    return this.num.length;
+  }
+
+  multiply(e: Polynomial): Polynomial {
+    const num = new Array(this.getLength() + e.getLength() - 1).fill(0);
+    for (let i = 0; i < this.getLength(); i++) {
+      for (let j = 0; j < e.getLength(); j++) {
+        num[i + j] ^= gexp(glog(this.get(i)) + glog(e.get(j)));
+      }
+    }
+    return new Polynomial(num);
+  }
+
+  mod(e: Polynomial): Polynomial {
+    if (this.getLength() - e.getLength() < 0) {
+      return this;
+    }
+    const ratio = glog(this.get(0)) - glog(e.get(0));
+    const num = new Array(this.getLength());
+    for (let i = 0; i < this.getLength(); i++) {
+      num[i] = this.get(i);
+    }
+    for (let i = 0; i < e.getLength(); i++) {
+      num[i] ^= gexp(glog(e.get(i)) + ratio);
+    }
+    return new Polynomial(num).mod(e);
+  }
+}
+
+// QR Code RS Block definition tables [totalCount, dataCount]
+const RS_BLOCK_TABLE: number[][][] = [
+  // 1
+  [[1, 26, 19], [1, 26, 16], [1, 26, 13], [1, 26, 9]],
+  // 2
+  [[1, 44, 34], [1, 44, 28], [1, 44, 22], [1, 44, 16]],
+  // 3
+  [[1, 70, 55], [1, 70, 44], [2, 35, 17], [2, 35, 13]],
+  // 4
+  [[1, 100, 80], [2, 50, 32], [2, 50, 24], [4, 25, 9]],
+  // 5
+  [[1, 134, 108], [2, 67, 43], [2, 33, 15, 2, 34, 16], [2, 33, 11, 2, 34, 12]],
+  // 6
+  [[2, 86, 68], [4, 43, 27], [4, 43, 19], [4, 43, 15]],
+  // 7
+  [[2, 98, 78], [4, 49, 31], [2, 32, 14, 4, 33, 15], [4, 39, 13, 1, 40, 14]],
+  // 8
+  [[2, 121, 97], [2, 60, 38, 2, 61, 39], [4, 40, 18, 2, 41, 19], [4, 40, 14, 2, 41, 15]],
+  // 9
+  [[2, 146, 116], [3, 58, 36, 2, 59, 37], [4, 36, 16, 4, 37, 17], [4, 36, 12, 4, 37, 13]],
+  // 10
+  [[2, 86, 68, 2, 87, 69], [4, 69, 43, 1, 70, 44], [6, 43, 19, 2, 44, 20], [6, 43, 15, 2, 44, 16]],
+];
+
+// Alignment pattern centers for Versions 1-10
+const PATTERN_POSITION_TABLE: number[][] = [
+  [],
+  [6, 18],
+  [6, 22],
+  [6, 26],
+  [6, 30],
+  [6, 34],
+  [6, 22, 38],
+  [6, 24, 42],
+  [6, 26, 46],
+  [6, 28, 50],
+];
+
+const G15 = (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | (1 << 0);
+const G15_MASK = (1 << 14) | (1 << 12) | (1 << 10) | (1 << 4) | (1 << 1);
+
+function getBCHTypeInfo(data: number): number {
+  let d = data << 10;
+  while (getBCHDigit(d) - getBCHDigit(G15) >= 0) {
+    d ^= G15 << (getBCHDigit(d) - getBCHDigit(G15));
+  }
+  return ((data << 10) | d) ^ G15_MASK;
+}
+
+function getBCHDigit(data: number): number {
+  let digit = 0;
+  while (data !== 0) {
+    digit++;
+    data >>>= 1;
+  }
+  return digit;
+}
+
+function getMask(maskPattern: number, i: number, j: number): boolean {
+  switch (maskPattern) {
+    case 0: return (i + j) % 2 === 0;
+    case 1: return i % 2 === 0;
+    case 2: return j % 3 === 0;
+    case 3: return (i + j) % 3 === 0;
+    case 4: return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
+    case 5: return ((i * j) % 2) + ((i * j) % 3) === 0;
+    case 6: return (((i * j) % 2) + ((i * j) % 3)) % 2 === 0;
+    case 7: return (((i * j) % 3) + ((i + j) % 2)) % 2 === 0;
+    default: return false;
+  }
+}
+
+class BitBuffer {
+  buffer: number[] = [];
+  length = 0;
+
+  get(index: number): boolean {
+    const bufIndex = Math.floor(index / 8);
+    return ((this.buffer[bufIndex]! >>> (7 - (index % 8))) & 1) === 1;
+  }
+
+  put(num: number, length: number): void {
+    for (let i = 0; i < length; i++) {
+      this.putBit(((num >>> (length - i - 1)) & 1) === 1);
+    }
+  }
+
+  putBit(bit: boolean): void {
+    const bufIndex = Math.floor(this.length / 8);
+    if (this.buffer.length <= bufIndex) {
+      this.buffer.push(0);
+    }
+    if (bit) {
+      this.buffer[bufIndex] |= 0x80 >>> (this.length % 8);
+    }
+    this.length++;
+  }
+}
+
+function getErrorCorrectionPolynomial(errorCorrectionLength: number): Polynomial {
+  let a = new Polynomial([1], 0);
+  for (let i = 0; i < errorCorrectionLength; i++) {
+    a = a.multiply(new Polynomial([1, gexp(i)], 0));
+  }
+  return a;
+}
+
+/**
+ * Generates boolean matrix for QR code string.
+ * Zero external dependencies.
+ */
 export function generateQRMatrix(text: string, ecc: QRECC = 'M'): boolean[][] {
-  try {
-    // Type 0 = auto detect smallest valid QR version
-    const qr = qrcode(0, ecc);
-    qr.addData(text);
-    qr.make();
-
-    const count = qr.getModuleCount();
-    const matrix: boolean[][] = [];
-
-    for (let row = 0; row < count; row++) {
-      const rowData: boolean[] = [];
-      for (let col = 0; col < count; col++) {
-        rowData.push(qr.isDark(row, col));
+  const eccLevel = QR_ECC_LEVEL[ecc] ?? 0;
+  const utf8Bytes: number[] = [];
+
+  for (let i = 0; i < text.length; i++) {
+    let c = text.charCodeAt(i);
+    if (c < 128) {
+      utf8Bytes.push(c);
+    } else if (c < 2048) {
+      utf8Bytes.push((c >> 6) | 192);
+      utf8Bytes.push((c & 63) | 128);
+    } else {
+      utf8Bytes.push((c >> 12) | 224);
+      utf8Bytes.push(((c >> 6) & 63) | 128);
+      utf8Bytes.push((c & 63) | 128);
+    }
+  }
+
+  // Determine minimum viable QR Version (1 to 10)
+  let version = 1;
+  for (let v = 1; v <= 10; v++) {
+    const blockList = RS_BLOCK_TABLE[v - 1]![eccLevel]!;
+    let totalDataCount = 0;
+    for (let i = 0; i < blockList.length; i += 3) {
+      totalDataCount += blockList[i]! * blockList[i + 2]!;
+    }
+    // 8-bit byte mode overhead: 4 bits mode + 8 bits length
+    if (utf8Bytes.length + 2 <= totalDataCount) {
+      version = v;
+      break;
+    }
+    version = v;
+  }
+
+  const moduleCount = version * 4 + 17;
+  const modules: (boolean | null)[][] = Array.from({ length: moduleCount }, () =>
+    Array(moduleCount).fill(null),
+  );
+
+  // 1. Position detection patterns
+  function setupPositionProbePattern(row: number, col: number) {
+    for (let r = -1; r <= 7; r++) {
+      if (row + r <= -1 || moduleCount <= row + r) continue;
+      for (let c = -1; c <= 7; c++) {
+        if (col + c <= -1 || moduleCount <= col + c) continue;
+        if (
+          (0 <= r && r <= 6 && (c === 0 || c === 6)) ||
+          (0 <= c && c <= 6 && (r === 0 || r === 6)) ||
+          (2 <= r && r <= 4 && 2 <= c && c <= 4)
+        ) {
+          modules[row + r]![col + c] = true;
+        } else {
+          modules[row + r]![col + c] = false;
+        }
+      }
+    }
+  }
+
+  setupPositionProbePattern(0, 0);
+  setupPositionProbePattern(moduleCount - 7, 0);
+  setupPositionProbePattern(0, moduleCount - 7);
+
+  // 2. Alignment patterns
+  const pos = PATTERN_POSITION_TABLE[version - 1] || [];
+  for (let i = 0; i < pos.length; i++) {
+    for (let j = 0; j < pos.length; j++) {
+      const row = pos[i]!;
+      const col = pos[j]!;
+      if (modules[row]![col] !== null) continue;
+
+      for (let r = -2; r <= 2; r++) {
+        for (let c = -2; c <= 2; c++) {
+          if (r === -2 || r === 2 || c === -2 || c === 2 || (r === 0 && c === 0)) {
+            modules[row + r]![col + c] = true;
+          } else {
+            modules[row + r]![col + c] = false;
+          }
+        }
+      }
+    }
+  }
+
+  // 3. Timing patterns
+  for (let r = 8; r < moduleCount - 8; r++) {
+    if (modules[r]![6] === null) modules[r]![6] = r % 2 === 0;
+  }
+  for (let c = 8; c < moduleCount - 8; c++) {
+    if (modules[6]![c] === null) modules[6]![c] = c % 2 === 0;
+  }
+
+  // 4. Encode data stream
+  const buffer = new BitBuffer();
+  buffer.put(4, 4); // 8-bit byte mode indicator
+  buffer.put(utf8Bytes.length, 8); // character count
+  for (let i = 0; i < utf8Bytes.length; i++) {
+    buffer.put(utf8Bytes[i]!, 8);
+  }
+
+  const rsBlocks = RS_BLOCK_TABLE[version - 1]![eccLevel]!;
+  let totalDataCount = 0;
+  for (let i = 0; i < rsBlocks.length; i += 3) {
+    totalDataCount += rsBlocks[i]! * rsBlocks[i + 2]!;
+  }
+
+  // Terminator
+  if (buffer.length + 4 <= totalDataCount * 8) {
+    buffer.put(0, 4);
+  }
+  while (buffer.length % 8 !== 0) {
+    buffer.putBit(false);
+  }
+
+  // Padding
+  while (buffer.length < totalDataCount * 8) {
+    buffer.put(0xec, 8);
+    if (buffer.length < totalDataCount * 8) {
+      buffer.put(0x11, 8);
+    }
+  }
+
+  // RS Error Correction calculation
+  const dataBytes = buffer.buffer;
+  let offset = 0;
+  const dcData: number[][] = [];
+  const ecData: number[][] = [];
+
+  for (let i = 0; i < rsBlocks.length; i += 3) {
+    const numBlocks = rsBlocks[i]!;
+    const totalCount = rsBlocks[i + 1]!;
+    const dataCount = rsBlocks[i + 2]!;
+    const ecCount = totalCount - dataCount;
+    const rsPoly = getErrorCorrectionPolynomial(ecCount);
+
+    for (let b = 0; b < numBlocks; b++) {
+      const rawDc = dataBytes.slice(offset, offset + dataCount);
+      offset += dataCount;
+      dcData.push(rawDc);
+
+      const rawPoly = new Polynomial(rawDc, rsPoly.getLength() - 1);
+      const modPoly = rawPoly.mod(rsPoly);
+      const ec = new Array(rsPoly.getLength() - 1).fill(0);
+      for (let k = 0; k < ec.length; k++) {
+        const modIndex = k + modPoly.getLength() - ec.length;
+        ec[k] = modIndex >= 0 ? modPoly.get(modIndex) : 0;
       }
-      matrix.push(rowData);
-    }
-
-    return matrix;
-  } catch (err) {
-    // Fallback: higher version if auto-detect fails
-    try {
-      const qr = qrcode(10, ecc);
-      qr.addData(text);
-      qr.make();
-      const count = qr.getModuleCount();
-      const matrix: boolean[][] = [];
-      for (let row = 0; row < count; row++) {
-        const rowData: boolean[] = [];
-        for (let col = 0; col < count; col++) {
-          rowData.push(qr.isDark(row, col));
+      ecData.push(ec);
+    }
+  }
+
+  // Interleave data & error correction codewords
+  const finalCodewords: number[] = [];
+  let maxDcCount = 0;
+  for (const block of dcData) maxDcCount = Math.max(maxDcCount, block.length);
+  for (let i = 0; i < maxDcCount; i++) {
+    for (const block of dcData) {
+      if (i < block.length) finalCodewords.push(block[i]!);
+    }
+  }
+
+  let maxEcCount = 0;
+  for (const block of ecData) maxEcCount = Math.max(maxEcCount, block.length);
+  for (let i = 0; i < maxEcCount; i++) {
+    for (const block of ecData) {
+      if (i < block.length) finalCodewords.push(block[i]!);
+    }
+  }
+
+  // 5. Place data into matrix using standard mask 0
+  let inc = -1;
+  let row = moduleCount - 1;
+  let bitIndex = 0;
+  const maskPattern = 0;
+
+  for (let col = moduleCount - 1; col > 0; col -= 2) {
+    if (col === 6) col--;
+    while (true) {
+      for (let c = 0; c < 2; c++) {
+        if (modules[row]![col - c] === null) {
+          let dark = false;
+          if (bitIndex < finalCodewords.length * 8) {
+            const byte = finalCodewords[Math.floor(bitIndex / 8)]!;
+            dark = ((byte >>> (7 - (bitIndex % 8))) & 1) === 1;
+            bitIndex++;
+          }
+          const mask = getMask(maskPattern, row, col - c);
+          modules[row]![col - c] = mask ? !dark : dark;
         }
-        matrix.push(rowData);
       }
-      return matrix;
-    } catch {
-      return [];
+      row += inc;
+      if (row < 0 || moduleCount <= row) {
+        row -= inc;
+        inc = -inc;
+        break;
+      }
+    }
+  }
+
+  // 6. Format Info (Type Info)
+  const typeData = (eccLevel << 3) | maskPattern;
+  const bits = getBCHTypeInfo(typeData);
+
+  for (let i = 0; i < 15; i++) {
+    const mod = ((bits >> i) & 1) === 1;
+    if (i < 6) {
+      modules[i]![8] = mod;
+    } else if (i < 8) {
+      modules[i + 1]![8] = mod;
+    } else {
+      modules[moduleCount - 15 + i]![8] = mod;
+    }
+
+    if (i < 8) {
+      modules[8]![moduleCount - i - 1] = mod;
+    } else if (i < 9) {
+      modules[8]![15 - i - 1 + 1] = mod;
+    } else {
+      modules[8]![15 - i - 1] = mod;
     }
   }
+
+  modules[moduleCount - 8]![8] = true;
+
+  return modules.map(r => r.map(cell => cell === true));
 }
+
+export default generateQRMatrix;