kafox-cli 0.9.9 → 0.10.0

package/src/mobile/qr.js

@@ -0,0 +1,487 @@
+/**
+ * QR Code em ASCII, sem dependencia externa.
+ *
+ * Escopo de proposito: URLs curtas do pareamento mobile (byte mode, ECC M,
+ * versoes 1..10 = ate 213 bytes). Nao e um QR generico: e exatamente o que o
+ * `kafox mobile` precisa e nada mais — zero `npm install`.
+ *
+ * A saida usa meios blocos ("#" / espaco) para o terminal renderizar com boa
+ * densidade e o celular conseguir ler a tela.
+ */
+
+// Capacidade (bytes) em ECC-M por versao 1..10.
+const CAPACITY_M = { 1: 14, 2: 26, 3: 42, 4: 62, 5: 84, 6: 106, 7: 122, 8: 152, 9: 180, 10: 213 };
+
+// Config de blocos ECC-M por versao: [eccPorBloco, blocosG1, dadosG1, blocosG2, dadosG2].
+const BLOCKS_M = {
+  1: [10, 1, 16, 0, 0],
+  2: [16, 1, 28, 0, 0],
+  3: [26, 1, 44, 0, 0],
+  4: [18, 2, 32, 0, 0],
+  5: [24, 2, 43, 0, 0],
+  6: [16, 4, 27, 0, 0],
+  7: [18, 4, 31, 0, 0],
+  8: [22, 2, 38, 2, 39],
+  9: [22, 3, 36, 2, 37],
+  10: [26, 4, 43, 1, 44],
+};
+
+const ALIGNMENT = {
+  1: [], 2: [6, 18], 3: [6, 22], 4: [6, 26], 5: [6, 30],
+  6: [6, 34], 7: [6, 22, 38], 8: [6, 24, 42], 9: [6, 26, 46], 10: [6, 28, 50],
+};
+
+function sizeFor(version) {
+  return version * 4 + 17;
+}
+
+function pickVersion(byteLength) {
+  for (let v = 1; v <= 10; v += 1) if (CAPACITY_M[v] >= byteLength) return v;
+  return null;
+}
+
+// ---- Galois field GF(256) para Reed-Solomon ----
+const EXP = new Array(512);
+const LOG = new Array(256);
+(() => {
+  let x = 1;
+  for (let i = 0; i < 255; i += 1) {
+    EXP[i] = x;
+    LOG[x] = i;
+    x <<= 1;
+    if (x & 0x100) x ^= 0x11d;
+  }
+  for (let i = 255; i < 512; i += 1) EXP[i] = EXP[i - 255];
+})();
+
+function mul(a, b) {
+  if (a === 0 || b === 0) return 0;
+  return EXP[LOG[a] + LOG[b]];
+}
+
+function rsGenerator(degree) {
+  let poly = [1];
+  for (let i = 0; i < degree; i += 1) {
+    const next = new Array(poly.length + 1).fill(0);
+    for (let j = 0; j < poly.length; j += 1) {
+      next[j] ^= mul(poly[j], 1);
+      next[j + 1] ^= mul(poly[j], EXP[i]);
+    }
+    poly = next;
+  }
+  return poly;
+}
+
+function rsEncode(data, eccLen) {
+  const gen = rsGenerator(eccLen);
+  const res = new Array(eccLen).fill(0);
+  for (const byte of data) {
+    const factor = byte ^ res[0];
+    res.shift();
+    res.push(0);
+    for (let i = 0; i < eccLen; i += 1) res[i] ^= mul(gen[i + 1], factor);
+  }
+  return res;
+}
+
+// ---- Bit buffer ----
+class Bits {
+  constructor() {
+    this.bits = [];
+  }
+  put(value, length) {
+    for (let i = length - 1; i >= 0; i -= 1) this.bits.push((value >> i) & 1);
+  }
+  get length() {
+    return this.bits.length;
+  }
+}
+
+function encodeData(text, version) {
+  const bytes = Buffer.from(text, "utf8");
+  const bits = new Bits();
+  bits.put(0b0100, 4); // byte mode
+  // contador de caracteres: 8 bits para versoes 1..9, 16 bits na 10.
+  bits.put(bytes.length, version <= 9 ? 8 : 16);
+  for (const byte of bytes) bits.put(byte, 8);
+
+  const spec = BLOCKS_M[version];
+  const eccPerBlock = spec[0];
+  const totalBlocks = spec[1] + spec[3];
+  const dataBlocks = spec[1] + spec[3];
+  const totalDataBytes = spec[1] * spec[2] + spec[3] * spec[4];
+
+  // terminador (ate 4 bits) + padding ate fechar o byte.
+  const capacityBits = totalDataBytes * 8;
+  const terminate = Math.min(4, capacityBits - bits.length);
+  bits.put(0, terminate);
+  while (bits.length % 8 !== 0) bits.put(0, 1);
+
+  const dataBytes = [];
+  for (let i = 0; i < bits.length; i += 8) {
+    let byte = 0;
+    for (let j = 0; j < 8; j += 1) byte = (byte << 1) | bits.bits[i + j];
+    dataBytes.push(byte);
+  }
+  // bytes de preenchimento alternados.
+  const PAD = [0xec, 0x11];
+  let padIndex = 0;
+  while (dataBytes.length < totalDataBytes) {
+    dataBytes.push(PAD[padIndex % 2]);
+    padIndex += 1;
+  }
+
+  // divide em blocos.
+  const blocks = [];
+  let offset = 0;
+  for (let i = 0; i < spec[1]; i += 1) {
+    blocks.push(dataBytes.slice(offset, offset + spec[2]));
+    offset += spec[2];
+  }
+  for (let i = 0; i < spec[3]; i += 1) {
+    blocks.push(dataBytes.slice(offset, offset + spec[4]));
+    offset += spec[4];
+  }
+
+  const eccBlocks = blocks.map((block) => rsEncode(block, eccPerBlock));
+
+  // interleave dos dados, depois do ECC.
+  const interleaved = [];
+  const maxData = Math.max(spec[2], spec[4]);
+  for (let i = 0; i < maxData; i += 1) {
+    for (const block of blocks) if (i < block.length) interleaved.push(block[i]);
+  }
+  for (let i = 0; i < eccPerBlock; i += 1) {
+    for (const block of eccBlocks) interleaved.push(block[i]);
+  }
+  return interleaved;
+}
+
+// ---- Matriz ----
+function createMatrix(version) {
+  const size = sizeFor(version);
+  const modules = Array.from({ length: size }, () => new Array(size).fill(null));
+  const reserved = Array.from({ length: size }, () => new Array(size).fill(false));
+
+  const setFinder = (row, col) => {
+    for (let r = -1; r <= 7; r += 1) {
+      for (let c = -1; c <= 7; c += 1) {
+        const rr = row + r;
+        const cc = col + c;
+        if (rr < 0 || cc < 0 || rr >= size || cc >= size) continue;
+        const inRing = r >= 0 && r <= 6 && c >= 0 && c <= 6;
+        const dark = inRing && (r === 0 || r === 6 || c === 0 || c === 6 || (r >= 2 && r <= 4 && c >= 2 && c <= 4));
+        modules[rr][cc] = dark ? 1 : 0;
+        reserved[rr][cc] = true;
+      }
+    }
+  };
+  setFinder(0, 0);
+  setFinder(0, size - 7);
+  setFinder(size - 7, 0);
+
+  // timing patterns
+  for (let i = 8; i < size - 8; i += 1) {
+    if (modules[6][i] === null) {
+      modules[6][i] = i % 2 === 0 ? 1 : 0;
+      reserved[6][i] = true;
+    }
+    if (modules[i][6] === null) {
+      modules[i][6] = i % 2 === 0 ? 1 : 0;
+      reserved[i][6] = true;
+    }
+  }
+
+  // alignment patterns
+  const positions = ALIGNMENT[version];
+  for (const row of positions) {
+    for (const col of positions) {
+      if (reserved[row][col]) continue;
+      for (let r = -2; r <= 2; r += 1) {
+        for (let c = -2; c <= 2; c += 1) {
+          const dark = Math.max(Math.abs(r), Math.abs(c)) !== 1;
+          modules[row + r][col + c] = dark ? 1 : 0;
+          reserved[row + r][col + c] = true;
+        }
+      }
+    }
+  }
+
+  // Reserva a area da info de formato (15 bits x 2 copias), contornando os
+  // finders. Copia 1: em volta do finder superior esquerdo (linha 8 e coluna 8,
+  // pulando a coluna/linha de timing em 6). Copia 2: sob o finder superior
+  // direito (linha 8, ultimas 8 colunas) e a direita do finder inferior
+  // esquerdo (coluna 8, ultimas 7 linhas).
+  for (let i = 0; i <= 8; i += 1) {
+    if (i !== 6) {
+      reserved[8][i] = true;
+      reserved[i][8] = true;
+    }
+  }
+  for (let i = 0; i < 8; i += 1) {
+    reserved[8][size - 1 - i] = true;
+  }
+  for (let i = 0; i < 7; i += 1) {
+    reserved[size - 1 - i][8] = true;
+  }
+  // dark module (sempre escuro, nao carrega dado)
+  modules[size - 8][8] = 1;
+  reserved[size - 8][8] = true;
+
+  return { size, modules, reserved };
+}
+
+function placeData(matrix, codewords) {
+  const { size, modules, reserved } = matrix;
+  let bitIndex = 0;
+  let upward = true;
+  for (let col = size - 1; col > 0; col -= 2) {
+    if (col === 6) col -= 1; // pula a coluna de timing
+    for (let i = 0; i < size; i += 1) {
+      const row = upward ? size - 1 - i : i;
+      for (let c = 0; c < 2; c += 1) {
+        const cc = col - c;
+        if (reserved[row][cc]) continue;
+        const bit =
+          bitIndex < codewords.length * 8
+            ? (codewords[bitIndex >> 3] >> (7 - (bitIndex & 7))) & 1
+            : 0;
+        modules[row][cc] = bit;
+        bitIndex += 1;
+      }
+    }
+    upward = !upward;
+  }
+}
+
+function applyMask(modules, reserved, size, maskId) {
+  const maskFn = {
+    0: (r, c) => (r + c) % 2 === 0,
+    1: (r) => r % 2 === 0,
+    2: (_, c) => c % 3 === 0,
+    3: (r, c) => (r + c) % 3 === 0,
+    4: (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0,
+    5: (r, c) => ((r * c) % 2) + ((r * c) % 3) === 0,
+    6: (r, c) => (((r * c) % 2) + ((r * c) % 3)) % 2 === 0,
+    7: (r, c) => (((r + c) % 2) + ((r * c) % 3)) % 2 === 0,
+  }[maskId];
+  for (let r = 0; r < size; r += 1) {
+    for (let c = 0; c < size; c += 1) {
+      if (!reserved[r][c] && maskFn(r, c)) modules[r][c] ^= 1;
+    }
+  }
+}
+
+function penalty(modules, size) {
+  let score = 0;
+  // regra 1: sequencias iguais
+  for (let r = 0; r < size; r += 1) {
+    let run = 1;
+    for (let c = 1; c < size; c += 1) {
+      if (modules[r][c] === modules[r][c - 1]) run += 1;
+      else {
+        if (run >= 5) score += run - 2;
+        run = 1;
+      }
+    }
+    if (run >= 5) score += run - 2;
+  }
+  for (let c = 0; c < size; c += 1) {
+    let run = 1;
+    for (let r = 1; r < size; r += 1) {
+      if (modules[r][c] === modules[r - 1][c]) run += 1;
+      else {
+        if (run >= 5) score += run - 2;
+        run = 1;
+      }
+    }
+    if (run >= 5) score += run - 2;
+  }
+  // regra 2: blocos 2x2
+  for (let r = 0; r < size - 1; r += 1) {
+    for (let c = 0; c < size - 1; c += 1) {
+      const v = modules[r][c];
+      if (v === modules[r][c + 1] && v === modules[r + 1][c] && v === modules[r + 1][c + 1]) score += 3;
+    }
+  }
+  // regra 3: padrao 1:1:3:1:1 intercalado com 4 claros
+  const pattern = [1, 0, 1, 1, 1, 0, 1];
+  for (let r = 0; r < size; r += 1) {
+    for (let i = 0; i <= size - 7; i += 1) {
+      let match = true;
+      for (let j = 0; j < 7; j += 1) if (modules[r][i + j] !== pattern[j]) { match = false; break; }
+      if (match) {
+        const before = i >= 4 && [0, 1, 2, 3].every((k) => modules[r][i - 4 + k] === 0);
+        const after = i + 11 <= size && [0, 1, 2, 3].every((k) => modules[r][i + 7 + k] === 0);
+        if (before || after) score += 40;
+      }
+    }
+  }
+  for (let c = 0; c < size; c += 1) {
+    for (let i = 0; i <= size - 7; i += 1) {
+      let match = true;
+      for (let j = 0; j < 7; j += 1) if (modules[i + j][c] !== pattern[j]) { match = false; break; }
+      if (match) {
+        const before = i >= 4 && [0, 1, 2, 3].every((k) => modules[i - 4 + k][c] === 0);
+        const after = i + 11 <= size && [0, 1, 2, 3].every((k) => modules[i + 7 + k][c] === 0);
+        if (before || after) score += 40;
+      }
+    }
+  }
+  // regra 4: proporcao de escuros
+  let dark = 0;
+  for (let r = 0; r < size; r += 1) for (let c = 0; c < size; c += 1) if (modules[r][c]) dark += 1;
+  const ratio = (dark * 100) / (size * size);
+  score += Math.floor(Math.abs(ratio - 50) / 5) * 10;
+  return score;
+}
+
+function drawFormat(modules, size, maskId) {
+  const ECC_M = 0b00;
+  const data = (ECC_M << 3) | maskId;
+  let rem = data;
+  for (let i = 0; i < 10; i += 1) {
+    rem = (rem << 1) ^ ((rem >> 9) & 1 ? 0x537 : 0);
+  }
+  const bits = ((data << 10) | rem) ^ 0x5412;
+  // A spec coloca o bit MAIS significativo (14) na primeira posicao da copia-1
+  // e assim por diante: a posicao i recebe o bit (14 - i). Escrever LSB-first
+  // gera um QR que parece certo mas nao decodifica em nenhuma camera.
+  const b = (i) => (bits >> (14 - i)) & 1;
+
+  for (let i = 0; i <= 5; i += 1) modules[8][i] = b(i);
+  modules[8][7] = b(6);
+  modules[8][8] = b(7);
+  modules[7][8] = b(8);
+  for (let i = 9; i < 15; i += 1) modules[14 - i][8] = b(i);
+
+  for (let i = 0; i < 8; i += 1) modules[size - 1 - i][8] = b(i);
+  for (let i = 8; i < 15; i += 1) modules[8][size - 15 + i] = b(i);
+  modules[size - 8][8] = 1;
+}
+
+/**
+ * Gera a matriz final do QR (0/1) para o texto.
+ * @param {string} text
+ * @returns {{size:number, modules:number[][]}}
+ */
+function generate(text) {
+  const byteLength = Buffer.byteLength(text, "utf8");
+  const version = pickVersion(byteLength);
+  if (!version) throw new Error(`texto grande demais para o QR (${byteLength} bytes > 213)`);
+
+  const codewords = encodeData(text, version);
+  const matrix = createMatrix(version);
+  placeData(matrix, codewords);
+
+  let best = null;
+  let bestScore = Infinity;
+  for (let maskId = 0; maskId < 8; maskId += 1) {
+    const trial = matrix.modules.map((row) => row.slice());
+    applyMask(trial, matrix.reserved, matrix.size, maskId);
+    // escreve o formato numa copia para o calculo de penalidade
+    const withFormat = trial.map((row) => row.slice());
+    drawFormat(withFormat, matrix.size, maskId);
+    const score = penalty(withFormat, matrix.size);
+    if (score < bestScore) {
+      bestScore = score;
+      best = { maskId, modules: withFormat };
+    }
+  }
+  return { size: matrix.size, modules: best.modules };
+}
+
+/**
+ * Renderiza o QR em ASCII usando meios blocos Unicode.
+ *
+ * Por que meios blocos e nao "#"/espaco: o terminal do usuario costuma ter
+ * fundo escuro, e um QR desenhado com caracteres claros "inverte" a leitura.
+ * Com "▀ ▄ █" cada linha de texto carrega DUAS linhas de modulos, o modulo
+ * claro e o proprio fundo do terminal e o escuro e o glifo — entao funciona
+ * em fundo claro E escuro, e cabe na tela pela metade.
+ *
+ * LEGIBILIDADE POR CAMERA (o que mais importa):
+ *   - quietZone padrao 4 modulos: e o minimo da especificacao do QR. Com menos
+ *     que isso, muitas cameras de celular simplesmente nao acham o codigo.
+ *   - `scale` multiplica a largura: cada modulo vira `scale` caracteres na
+ *     horizontal. Como o caractere do terminal e ~2x mais alto que largo e
+ *     cada linha de texto carrega 2 linhas de modulos, `scale=2` deixa cada
+ *     modulo QUADRADO (2 chars de largura ≈ 2 linhas de altura) e sem vao
+ *     entre modulos vizinhos — que e o que a camera consegue travar.
+ *
+ * @param {string} text
+ * @param {{quietZone?:number, scale?:number}} [options]
+ */
+function toAscii(text, { quietZone = 4, scale = 1, color = false } = {}) {
+  const { size, modules } = generate(text);
+  // Geometria do terminal: uma celula (char) e ~1 de largura por ~2 de altura.
+  // Uma linha de texto carrega DUAS meias-linhas de modulo (via meios-blocos).
+  //
+  // `scale = N` faz cada modulo ocupar N chars de LARGURA e N meias-linhas de
+  // ALTURA, ou seja, multiplica o QR inteiro por N mantendo o modulo QUADRADO:
+  //   - scale=1: 1 char x 1 meia-linha   (menor; cada linha de texto = 2 fileiras)
+  //   - scale=2: 2 chars x 2 meias-linhas (1 linha de texto por fileira, bloco cheio)
+  // Nunca estica: largura e altura crescem juntas.
+  // `scale` precisa ser 1 ou par (par = N chars largura + N meias-linhas altura).
+  let N = Math.max(1, Math.floor(scale));
+  if (N !== 1 && N % 2 !== 0) N = N + 1; // arredonda impar pra par
+  const total = size + quietZone * 2; // linhas/colunas de modulos (com margem)
+  const bit = (row, col) => {
+    const rr = row - quietZone;
+    const cc = col - quietZone;
+    if (rr < 0 || cc < 0 || rr >= size || cc >= size) return 0;
+    return modules[rr][cc];
+  };
+
+  // Cor ANSI (preto no branco) quando color=true: camera de celular costuma
+  // NAO decodificar QR invertido (claro no fundo escuro do terminal). Sem cor,
+  // o modulo escuro e o proprio glifo e o claro e o fundo do terminal.
+  const ON = color ? "\x1b[30;47m" : ""; // preto sobre branco
+  const OFF = color ? "\x1b[0m" : "";
+
+  const lines = [];
+  if (N === 1) {
+    // Duas fileiras de modulos por linha de texto (meios-blocos). Modulo = 1
+    // char de largura x 1 meia-linha de altura => quadrado.
+    for (let row = 0; row < total; row += 2) {
+      let line = color ? ON : "";
+      for (let col = 0; col < total; col += 1) {
+        const a = bit(row, col);
+        const b = row + 1 < total ? bit(row + 1, col) : 0;
+        line += (a ? (b ? "█" : "▀") : b ? "▄" : " ").repeat(1);
+      }
+      if (color) line += OFF;
+      lines.push(line);
+    }
+  } else {
+    // Cada fileira de modulos vira N/2 linhas de texto, cada modulo com N
+    // chars de largura => quadrado. Blocos cheios (preto) ou espaco (claro).
+    const linesPerRow = N / 2;
+    for (let row = 0; row < total; row += 1) {
+      let line = color ? ON : "";
+      for (let col = 0; col < total; col += 1) {
+        line += (bit(row, col) ? "█" : " ").repeat(N);
+      }
+      if (color) line += OFF;
+      for (let k = 0; k < linesPerRow; k += 1) lines.push(line);
+    }
+  }
+  return lines.join("\n");
+}
+
+module.exports = { generate, toAscii, pickVersion, CAPACITY_M, reservedFor };
+
+/**
+ * Mapa de modulos "reservados" (finder/timing/alignment/formato/dark) para o
+ * texto dado. Exposto para os testes de ida-e-volta: quem decodifica precisa
+ * saber exatamente quais modulos NAO carregam dados, e a fonte da verdade e o
+ * proprio encoder (`createMatrix`) — duplicar essa logica num teste e o jeito
+ * mais facil de o teste mentir.
+ * @param {string} text
+ * @returns {boolean[][]}
+ */
+function reservedFor(text) {
+  const version = pickVersion(Buffer.byteLength(text, "utf8"));
+  if (!version) throw new Error(`texto grande demais para o QR`);
+  return createMatrix(version).reserved.map((row) => row.slice());
+}