qr-terminal 1.0.0

package/src/engine.js

@@ -0,0 +1,286 @@
+/**
+ * ╔══════════════════════════════════════════════════════════════╗
+ * ║        HIGH-DENSITY HALF-BLOCK RENDERING ENGINE             ║
+ * ║  Compresses 2 vertical QR pixels → 1 Unicode character      ║
+ * ║  2D per-character color: diagonal · wave · 4-corner · radial║
+ * ╚══════════════════════════════════════════════════════════════╝
+ */
+
+import QRCode from 'qrcode';
+import chalk from 'chalk';
+
+// Unicode half-block set
+const BLOCK = {
+  FULL:  '█',
+  UPPER: '▀',
+  LOWER: '▄',
+  EMPTY: ' ',
+};
+
+/**
+ * Gradient presets.
+ * Each has a `type` that controls 2D color distribution,
+ * and `stops` — an array of [R,G,B] color points.
+ *
+ * Types:
+ *   solid    — single color
+ *   diagonal — top-left → bottom-right blend
+ *   vertical — top → bottom
+ *   wave     — sinusoidal ripple across x+y
+ *   radial   — center → edge bloom
+ *   4corner  — bilinear blend between 4 corner colors [tl, tr, bl, br]
+ */
+export const GRADIENT_PRESETS = {
+  none:   { type: 'solid',    stops: [[220, 220, 220]] },
+  retro:  { type: 'diagonal', stops: [[235, 77, 75],  [255, 184, 64]] },
+  ocean:  { type: 'diagonal', stops: [[0, 48, 200],   [0, 210, 255]] },
+  neon:   { type: 'wave',     stops: [[57, 255, 20],  [0, 200, 255], [255, 0, 200]] },
+  sunset: { type: 'diagonal', stops: [[255, 40, 40],  [255, 140, 40], [255, 220, 60]] },
+  galaxy: { type: '4corner',  stops: [[160, 32, 240], [59, 130, 246], [255, 0, 128], [0, 200, 255]] },
+  cherry: { type: 'radial',   stops: [[255, 255, 200],[255, 80, 130], [200, 0, 80]] },
+  matrix: { type: 'vertical', stops: [[0, 60, 0],     [0, 200, 50],   [160, 255, 160]] },
+  fire:   { type: 'diagonal', stops: [[160, 0, 0],    [255, 80, 0],   [255, 210, 0]] },
+  vapor:  { type: '4corner',  stops: [[255, 0, 255],  [0, 220, 255],  [180, 0, 180], [80, 80, 255]] },
+};
+
+/**
+ * Generate QR bit-matrix, bypassing qrcode's own renderer.
+ */
+export function createMatrix(text, { errorLevel = 'M' } = {}) {
+  if (!text || text.length === 0) throw new Error('Empty input');
+  return QRCode.create(text, { errorCorrectionLevel: errorLevel }).modules;
+}
+
+/**
+ * Core renderer with 2D per-character color.
+ *
+ * For each character position (col, row), we compute tx ∈ [0,1] and ty ∈ [0,1]
+ * then apply the gradient type formula to get a unique RGB for that character.
+ * This creates diagonal sweeps, waves, and corner blooms across the QR matrix.
+ *
+ * @returns {string[]} — chalk-colored strings, one per display row
+ */
+export function renderHalfBlock(modules, options = {}) {
+  const { gradient = 'none', quietZone = 2 } = options;
+  const { size, data } = modules;
+
+  const colStart    = -quietZone;
+  const colEnd      = size + quietZone;
+  const rowStart    = -quietZone;
+  const rowEnd      = size + quietZone;
+  const totalCols   = colEnd - colStart;
+  const totalRows   = rowEnd - rowStart;
+  const displayRows = Math.ceil(totalRows / 2);
+
+  const preset = GRADIENT_PRESETS[gradient] ?? GRADIENT_PRESETS.none;
+
+  const px = (r, c) => {
+    if (r < 0 || r >= size || c < 0 || c >= size) return 0;
+    return data[r * size + c] ? 1 : 0;
+  };
+
+  const output = [];
+
+  for (let di = 0; di < displayRows; di++) {
+    const row = rowStart + di * 2;
+    const ty  = displayRows > 1 ? di / (displayRows - 1) : 0;
+
+    let coloredLine = '';
+
+    // Track current run for grouping consecutive same-color chars
+    let runColor  = null;
+    let runChars  = '';
+
+    const flushRun = () => {
+      if (!runChars) return;
+      if (runColor) {
+        coloredLine += chalk.rgb(runColor[0], runColor[1], runColor[2])(runChars);
+      } else {
+        coloredLine += runChars;
+      }
+      runChars = '';
+      runColor = null;
+    };
+
+    for (let ci = 0; ci < totalCols; ci++) {
+      const col = colStart + ci;
+      const tx  = totalCols > 1 ? ci / (totalCols - 1) : 0;
+
+      const bitmask = (px(row, col) << 1) | px(row + 1, col);
+      let char;
+      switch (bitmask) {
+        case 0b11: char = BLOCK.FULL;  break;
+        case 0b10: char = BLOCK.UPPER; break;
+        case 0b01: char = BLOCK.LOWER; break;
+        default:   char = BLOCK.EMPTY;
+      }
+
+      if (char === BLOCK.EMPTY) {
+        // Light module: transparent space — flush colored run first
+        flushRun();
+        coloredLine += char;
+      } else {
+        // Dark module: compute 2D color for this exact position
+        const color = computeColor(preset, tx, ty);
+
+        // Group with previous char if colors are close enough (Δ < 8 per channel)
+        if (runColor && colorsClose(runColor, color, 8)) {
+          runChars += char;
+        } else {
+          flushRun();
+          runColor = color;
+          runChars = char;
+        }
+      }
+    }
+
+    flushRun();
+    output.push(coloredLine);
+  }
+
+  return output;
+}
+
+/**
+ * Render QR as plain Unicode half-blocks (no ANSI).
+ * For clipboard / README / text file export.
+ */
+export function renderASCII(modules, { quietZone = 2 } = {}) {
+  const { size, data } = modules;
+  const px = (r, c) => (r < 0 || r >= size || c < 0 || c >= size)
+    ? 0 : (data[r * size + c] ? 1 : 0);
+
+  const rows = [];
+  for (let di = 0; di < Math.ceil((size + quietZone * 2) / 2); di++) {
+    const row = -quietZone + di * 2;
+    let line  = '';
+    for (let col = -quietZone; col < size + quietZone; col++) {
+      const bitmask = (px(row, col) << 1) | px(row + 1, col);
+      switch (bitmask) {
+        case 0b11: line += BLOCK.FULL;  break;
+        case 0b10: line += BLOCK.UPPER; break;
+        case 0b01: line += BLOCK.LOWER; break;
+        default:   line += BLOCK.EMPTY;
+      }
+    }
+    rows.push(line);
+  }
+  return rows.join('\n');
+}
+
+export function getQrVersion(size) {
+  return Math.round((size - 17) / 4);
+}
+
+// ── Color computation ─────────────────────────────────────────────────────────
+
+export function computeColor({ type, stops }, tx, ty) {
+  switch (type) {
+    case 'solid':
+      return stops[0];
+
+    case 'diagonal': {
+      const t = clamp((tx + ty) / 2);
+      return lerpStops(stops, t);
+    }
+
+    case 'vertical': {
+      return lerpStops(stops, ty);
+    }
+
+    case 'wave': {
+      // Sinusoidal ripple — creates a shimmering interference pattern
+      const raw = Math.sin((tx * 3.5 + ty * 2.5) * Math.PI);
+      const t   = clamp((raw + 1) / 2);
+      return lerpStops(stops, t);
+    }
+
+    case 'radial': {
+      // Bloom from center outward
+      const dx = tx - 0.5;
+      const dy = ty - 0.5;
+      const t  = clamp(Math.sqrt(dx * dx + dy * dy) * Math.SQRT2);
+      return lerpStops(stops, t);
+    }
+
+    case '4corner': {
+      // Bilinear blend: [top-left, top-right, bottom-left, bottom-right]
+      const [tl, tr, bl, br] = stops;
+      const top    = lerp3(tl, tr, tx);
+      const bottom = lerp3(bl, br, tx);
+      return lerp3(top, bottom, ty);
+    }
+
+    default:
+      return [220, 220, 220];
+  }
+}
+
+// Multi-stop linear gradient interpolation
+function lerpStops(stops, t) {
+  if (stops.length === 1) return stops[0];
+  const seg = 1 / (stops.length - 1);
+  const i   = Math.min(Math.floor(t / seg), stops.length - 2);
+  const lt  = clamp((t - i * seg) / seg);
+  return lerp3(stops[i], stops[i + 1], lt);
+}
+
+// Lerp between two [R,G,B] triplets
+function lerp3(a, b, t) {
+  return [
+    Math.round(a[0] + (b[0] - a[0]) * t),
+    Math.round(a[1] + (b[1] - a[1]) * t),
+    Math.round(a[2] + (b[2] - a[2]) * t),
+  ];
+}
+
+function clamp(v, lo = 0, hi = 1) {
+  return Math.max(lo, Math.min(hi, v));
+}
+
+// Check if two colors are close enough to group into the same chalk call
+function colorsClose([r1, g1, b1], [r2, g2, b2], threshold) {
+  return Math.abs(r1 - r2) < threshold &&
+         Math.abs(g1 - g2) < threshold &&
+         Math.abs(b1 - b2) < threshold;
+}
+
+/**
+ * Build particle data for the fly-in animation.
+ * Returns an array of { targetRow, targetCol, char, color } objects
+ * and the framebuffer dimensions { displayRows, totalCols }.
+ */
+export function buildParticleData(modules, { gradient = 'none', quietZone = 2 } = {}) {
+  const { size, data } = modules;
+  const preset = GRADIENT_PRESETS[gradient] ?? GRADIENT_PRESETS.none;
+  const colStart = -quietZone, colEnd = size + quietZone;
+  const rowStart = -quietZone, rowEnd = size + quietZone;
+  const totalCols = colEnd - colStart;
+  const totalRows = rowEnd - rowStart;
+  const displayRows = Math.ceil(totalRows / 2);
+
+  const px = (r, c) => {
+    if (r < 0 || r >= size || c < 0 || c >= size) return 0;
+    return data[r * size + c] ? 1 : 0;
+  };
+
+  const particles = [];
+  for (let di = 0; di < displayRows; di++) {
+    const row = rowStart + di * 2;
+    const ty = displayRows > 1 ? di / (displayRows - 1) : 0;
+    for (let ci = 0; ci < totalCols; ci++) {
+      const col = colStart + ci;
+      const tx = totalCols > 1 ? ci / (totalCols - 1) : 0;
+      const bitmask = (px(row, col) << 1) | px(row + 1, col);
+      if (bitmask === 0) continue;
+      let char;
+      switch (bitmask) {
+        case 0b11: char = '█'; break;
+        case 0b10: char = '▀'; break;
+        default:   char = '▄';
+      }
+      particles.push({ targetRow: di, targetCol: ci, char, color: computeColor(preset, tx, ty) });
+    }
+  }
+  return { particles, displayRows, totalCols };
+}

package/src/export.js

@@ -0,0 +1,76 @@
+/**
+ * Export module: save QR codes as PNG, SVG, or plain ASCII text.
+ * Leverages qrcode's built-in renderers for pixel-perfect file output.
+ */
+
+import QRCode from 'qrcode';
+import { writeFile } from 'fs/promises';
+import { createMatrix, renderASCII } from './engine.js';
+
+/**
+ * Export as high-resolution PNG using qrcode's canvas renderer.
+ *
+ * @param {string} text      - Data to encode
+ * @param {string} filePath  - Output path (e.g. "qr-code.png")
+ * @param {object} opts
+ * @param {string} opts.errorLevel  - QR error correction level
+ * @param {number} opts.width       - Image width in pixels (default 600)
+ * @param {string} opts.darkColor   - Hex color for dark modules
+ * @param {string} opts.lightColor  - Hex color for light modules
+ */
+export async function exportPNG(text, filePath, {
+  errorLevel = 'M',
+  width      = 600,
+  darkColor  = '#000000',
+  lightColor = '#FFFFFF',
+} = {}) {
+  await QRCode.toFile(filePath, text, {
+    type:                 'png',
+    width,
+    margin:               4,
+    errorCorrectionLevel: errorLevel,
+    color: {
+      dark:  darkColor,
+      light: lightColor,
+    },
+  });
+}
+
+/**
+ * Export as clean, scalable SVG vector.
+ * SVG output is ideal for print, presentations, and web embedding.
+ *
+ * @param {string} text      - Data to encode
+ * @param {string} filePath  - Output path (e.g. "qr-code.svg")
+ * @param {object} opts
+ */
+export async function exportSVG(text, filePath, {
+  errorLevel = 'M',
+  darkColor  = '#000000',
+  lightColor = '#FFFFFF',
+} = {}) {
+  const svg = await QRCode.toString(text, {
+    type:                 'svg',
+    margin:               4,
+    errorCorrectionLevel: errorLevel,
+    color: {
+      dark:  darkColor,
+      light: lightColor,
+    },
+  });
+  await writeFile(filePath, svg, 'utf8');
+}
+
+/**
+ * Export as plain Unicode half-block text (no ANSI codes).
+ * Paste into README files, Markdown, or any plain-text environment.
+ *
+ * @param {string} text      - Data to encode
+ * @param {string} filePath  - Output path (e.g. "qr-code.txt")
+ * @param {object} opts
+ */
+export async function exportTXT(text, filePath, { errorLevel = 'M' } = {}) {
+  const modules = createMatrix(text, { errorLevel });
+  const ascii   = renderASCII(modules);
+  await writeFile(filePath, ascii, 'utf8');
+}

package/src/formatters.js

@@ -0,0 +1,44 @@
+/**
+ * Data formatters + UI metadata for prompts
+ */
+
+export function formatWifi({ ssid, password, security = 'WPA', hidden = false }) {
+  const esc = s => String(s).replace(/([\\;,":])/, '\\$1');
+  if (security === 'nopass') return `WIFI:T:nopass;S:${esc(ssid)};;`;
+  return `WIFI:T:${security};S:${esc(ssid)};P:${esc(password)};H:${hidden};;`;
+}
+
+export function formatVCard({ firstName = '', lastName = '', phone = '', email = '', org = '', url = '' }) {
+  const lines = [
+    'BEGIN:VCARD',
+    'VERSION:3.0',
+    `N:${lastName};${firstName};;;`,
+    `FN:${[firstName, lastName].filter(Boolean).join(' ')}`,
+  ];
+  if (org)   lines.push(`ORG:${org}`);
+  if (phone) lines.push(`TEL;TYPE=CELL:${phone}`);
+  if (email) lines.push(`EMAIL;TYPE=INTERNET:${email}`);
+  if (url)   lines.push(`URL:${url}`);
+  lines.push('END:VCARD');
+  return lines.join('\r\n');
+}
+
+export const ERROR_LEVELS = {
+  L: { label: 'L  —  Low        (7% recovery)',      desc: 'Smallest matrix. Best for pristine digital screens.',       recovery: '7%'  },
+  M: { label: 'M  —  Medium    (15% recovery)',       desc: 'Balanced. Recommended for URLs and general use.',          recovery: '15%' },
+  Q: { label: 'Q  —  Quartile  (25% recovery)',       desc: 'Good tolerance for printed/folded materials.',             recovery: '25%' },
+  H: { label: 'H  —  High      (30% recovery)',       desc: 'Maximum redundancy — logos can overlay up to 30% area.',  recovery: '30%' },
+};
+
+export const GRADIENT_OPTIONS = [
+  { name: '  ◆  Classic    — Crisp white, terminal-native',                     value: 'none'   },
+  { name: '  ◈  Retro      — Diagonal: coral red → warm amber',                 value: 'retro'  },
+  { name: '  ◈  Ocean      — Diagonal: deep navy → electric cyan',              value: 'ocean'  },
+  { name: '  ◈  Neon       — Sine-wave: green · cyan · magenta ripple',         value: 'neon'   },
+  { name: '  ◈  Sunset     — Diagonal: hot red → orange → gold',               value: 'sunset' },
+  { name: '  ◈  Galaxy     — 4-corner bilinear: purple · blue · pink · teal',   value: 'galaxy' },
+  { name: '  ◈  Cherry     — Radial bloom: soft white center → deep rose',      value: 'cherry' },
+  { name: '  ◈  Matrix     — Vertical cascade: dark → electric green',          value: 'matrix' },
+  { name: '  ◈  Fire       — Diagonal: blood red → ember orange → gold',        value: 'fire'   },
+  { name: '  ◈  Vaporwave  — 4-corner: magenta · cyan · purple · blue',         value: 'vapor'  },
+];

package/src/handshake.js

@@ -0,0 +1,112 @@
+/**
+ * Terminal-to-Mobile WebSocket Handshake
+ *
+ * Starts an HTTP + WebSocket server. The QR code encodes the server URL.
+ * When scanned, the phone opens a mobile-optimized page and connects.
+ * The terminal detects the connection and streams any text the user types
+ * on their phone directly into the terminal session.
+ */
+
+import http from 'http';
+import { WebSocketServer } from 'ws';
+import { networkInterfaces } from 'os';
+
+// Minimal mobile web UI — served to the phone browser after scan
+const MOBILE_PAGE = `<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Terminal Link</title>
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{background:#0d0d0d;color:#00ff41;font-family:monospace;padding:20px;min-height:100vh}
+h1{font-size:14px;letter-spacing:3px;color:#444;margin-bottom:20px}
+#st{font-size:18px;font-weight:bold;padding:14px;border:1px solid;border-radius:4px;text-align:center;margin-bottom:20px}
+.on{border-color:#00ff41;background:#0a1a0a}.off{border-color:#ff0040;color:#ff0040;background:#1a000a}
+textarea{width:100%;height:160px;background:#111;color:#00ff41;border:1px solid #00ff41;padding:12px;font-size:15px;font-family:monospace;outline:none;resize:none;border-radius:4px}
+button{display:block;width:100%;margin-top:12px;padding:18px;background:#00ff41;color:#000;border:none;font-size:18px;font-family:monospace;font-weight:bold;border-radius:4px;cursor:pointer;letter-spacing:2px}
+button:active{background:#00cc33}
+#log{margin-top:14px;font-size:12px;color:#444;min-height:20px}
+</style>
+</head>
+<body>
+<h1>◈ QR TERMINAL LINK</h1>
+<div id="st" class="off">○ CONNECTING...</div>
+<textarea id="inp" placeholder="Type here — press TRANSMIT to send to the terminal"></textarea>
+<button onclick="send()">▶ TRANSMIT TO TERMINAL</button>
+<div id="log"></div>
+<script>
+var ws=new WebSocket('ws://'+location.host);
+var st=document.getElementById('st');
+var log=document.getElementById('log');
+ws.onopen=function(){st.textContent='● DEVICE LINKED';st.className='on'};
+ws.onclose=function(){st.textContent='○ DISCONNECTED';st.className='off'};
+function send(){
+  var t=document.getElementById('inp').value.trim();
+  if(!t||ws.readyState!==1)return;
+  ws.send(t);
+  log.textContent='✓ Sent '+t.length+' chars';
+  document.getElementById('inp').value='';
+}
+document.getElementById('inp').addEventListener('keydown',function(e){
+  if((e.metaKey||e.ctrlKey)&&e.key==='Enter'){e.preventDefault();send()}
+});
+</script>
+</body>
+</html>`;
+
+function getLocalIP() {
+  const nets = networkInterfaces();
+  for (const name of Object.keys(nets)) {
+    for (const iface of nets[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) return iface.address;
+    }
+  }
+  return '127.0.0.1';
+}
+
+/**
+ * Start the handshake server.
+ *
+ * @returns {Promise<{url, waitForDevice, onMessage, close}>}
+ *   url           — The URL to encode in the QR code
+ *   waitForDevice — Promise that resolves when the first phone connects
+ *   onMessage     — Register a callback for incoming phone messages
+ *   close         — Shut down the server
+ */
+export function startHandshakeServer() {
+  return new Promise((resolve, reject) => {
+    const port = 3847 + Math.floor(Math.random() * 100);
+    const ip   = getLocalIP();
+    const url  = `http://${ip}:${port}`;
+
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(MOBILE_PAGE);
+    });
+
+    const wss = new WebSocketServer({ server });
+    const messageHandlers = [];
+    let deviceConnectResolve = null;
+    const deviceConnected = new Promise(r => { deviceConnectResolve = r; });
+
+    wss.on('connection', (ws) => {
+      deviceConnectResolve(); // signal first connection
+      ws.on('message', (raw) => {
+        const text = raw.toString();
+        messageHandlers.forEach(h => h(text));
+      });
+    });
+
+    server.on('error', reject);
+
+    server.listen(port, () => {
+      resolve({
+        url,
+        waitForDevice: deviceConnected,
+        onMessage:     (handler) => messageHandlers.push(handler),
+        close:         () => { wss.close(); server.close(); },
+      });
+    });
+  });
+}