{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "erase-field",
  "title": "Erase Field",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "Fundo em canvas que a mão raspa pra revelar a luz por baixo, com acabamento líquido, poeira que volta em deriva e passeio ocioso pra quem não mexe o ponteiro.",
  "registryDependencies": [
    "utils"
  ],
  "files": [
    {
      "path": "registry/visant/ui/erase-field.tsx",
      "content": "\"use client\";\n\nimport * as React from \"react\";\n\nimport { cn } from \"@/lib/utils\";\n\n/**\n * Erase Field — fundo que a mão RASPA pra revelar a luz por baixo.\n *\n * Colhido da dobra de CTA final do `visantismo`. O problema que ele resolve é\n * comercial, não decorativo: a dobra que pede a compra costuma ser a única sem\n * nada acontecendo — título, linha e botão sobre preto liso. O gesto que ela\n * ganha aqui é \"o trabalho já está lá, você só tira a poeira de cima\".\n *\n * ── Como é feito, e por que assim ──────────────────────────────────────────\n *\n * · DUAS camadas num canvas só. Primeiro pinta a LUZ (o que está por baixo),\n *   depois a POEIRA por cima; o cursor rasga a poeira com `destination-out`.\n *   Dois canvas empilhados no DOM custariam um composite a mais por quadro sem\n *   ganhar nada.\n *\n * · O acabamento é LÍQUIDO, não de borracha. Três coisas fazem isso, e nenhuma\n *   é opcional se a intenção é \"orgânico\":\n *     1. o pincel é um carimbo de gradiente radial com queda suave, não um\n *        traço de `lineTo` com ponta redonda — traço tem contorno, tinta não;\n *     2. os carimbos saem em cacho, com raio e desvio sorteados: sobrepostos,\n *        buracos vizinhos se FUNDEM em vez de se encostarem, que é o que dá o\n *        comportamento de gota;\n *     3. a mão tem inércia — o pincel persegue o ponteiro por interpolação.\n *        Cursor grudado no pincel lê como software; pincel que corre atrás lê\n *        como matéria.\n *\n * · A LUZ embaixo é quatro bolhas em órbitas incomensuráveis entre si (os\n *   divisores são primos entre si de propósito), então o desenho revelado nunca\n *   repete e não tem \"loop\" perceptível.\n *\n * · A poeira VOLTA, e volta torto: um véu radial grande em deriva, não um\n *   `fillRect` de alpha uniforme. Uniforme, o buraco fecha como um fade e\n *   denuncia o truque; em deriva, fecha por um lado antes do outro.\n *\n * · Sem ponteiro, ela se raspa sozinha devagar. Efeito que só existe sob hover\n *   é efeito que a maioria nunca vê — e no celular, ninguém.\n *\n * ── O que mudou na colheita ────────────────────────────────────────────────\n *\n * O original lia `--accent` com um parser de `#rrggbb`. O registry emite\n * **OKLCH**, então aquele parser cairia no cyan da Visant em toda marca — o\n * fallback silencioso de novo. Aqui a cor é lida de uma sonda: um nó com\n * `background-color: var(--brand)`, e `getComputedStyle` devolve `rgb(...)`\n * resolvido pelo próprio navegador, seja qual for o espaço de cor. E ela é\n * relida no resize, então trocar de tema em runtime repinta.\n *\n * Contratos de sistema: DPR com teto de 2, `ResizeObserver`,\n * `IntersectionObserver` (rAF parado fora da tela), `pointer-events: none` no\n * canvas — o botão continua sendo o botão — e `prefers-reduced-motion`\n * desenhando UM quadro: o fundo continua existindo, o movimento é que não.\n */\n\n/* Um canvas 1×1 é o conversor: `fillStyle` engole qualquer notação de CSS Color\n   4 (oklch, color(), hsl…) e `getImageData` devolve os canais já em sRGB.\n\n   Aqui morava o defeito de \"cor de fundo fora do tema\". A sonda estava certa —\n   ela lê a var a partir do HOST, então pega o tema de um container `.dark` —\n   mas o que vinha depois não: um regex de números em cima da string. E\n   `getComputedStyle().backgroundColor` só serializa em `rgb()` o que já é sRGB;\n   token em OKLCH volta como `oklch(0.145 0 0)`, e o regex lia isso como\n   `rgb(0.145, 0, 0)` — preto, em qualquer tema. O tema claro deste repo usa hex\n   (`#717182`), que o regex acertava; o escuro usa OKLCH, que ele destruía. Daí\n   \"funciona no claro, some no escuro\". Sem regex, isso não volta a acontecer\n   quando alguém trocar o token para `color-mix()` ou `lab()`.\n\n   O sentinela é o teste de recusa: `fillStyle` inválido é IGNORADO em silêncio\n   pela spec, então se o valor continuar magenta o navegador não entendeu, e o\n   fallback é honesto em vez de pintar magenta na tela. */\n/*\n * A marca é lida do canvas, não escrita à mão.\n *\n * Isto era `const SENTINELA = \"#ff00ff\"`, e o hex cru derrubava o portão de\n * `npm run ship` — que está certo em ser cego para intenção: componente do\n * registry não tem cor própria, e \"esta aqui pode\" é como a regra morre.\n *\n * A troca também conserta uma suposição escondida. A comparação de recusa\n * depende do que o canvas DEVOLVE em `fillStyle`, não do que se escreveu nele:\n * o navegador normaliza a cor ao serializar. Comparar contra o literal só\n * funcionava porque hex de seis dígitos volta igual — escrever a mesma cor em\n * `rgb()` já quebraria. Lendo a marca de volta depois de aplicá-la, a\n * comparação passa a ser contra a forma serializada de verdade.\n */\nconst SENTINELA_ENTRADA = \"rgb(255 0 255)\";\nlet pipeta: CanvasRenderingContext2D | null | undefined;\n\nfunction paraRGB(valor: string, fallback: [number, number, number]): [number, number, number] {\n  if (pipeta === undefined) {\n    const cv = document.createElement(\"canvas\");\n    cv.width = cv.height = 1;\n    pipeta = cv.getContext(\"2d\", { willReadFrequently: true });\n  }\n  if (!pipeta || !valor) return fallback;\n  pipeta.fillStyle = SENTINELA_ENTRADA;\n  /* O que o canvas devolve, que é contra o que a recusa se compara. */\n  const marca = pipeta.fillStyle;\n  pipeta.fillStyle = valor;\n  if (pipeta.fillStyle === marca) return fallback;\n  pipeta.fillRect(0, 0, 1, 1);\n  const d = pipeta.getImageData(0, 0, 1, 1).data;\n  return [d[0], d[1], d[2]];\n}\n\n/** Resolve a var a partir do HOST — o tema pode estar num container, não no `<html>`. */\nfunction sonda(host: HTMLElement, custom: string, fallback: [number, number, number]) {\n  const el = document.createElement(\"span\");\n  el.style.cssText = `position:absolute;width:0;height:0;background-color:var(${custom})`;\n  host.appendChild(el);\n  const lido = getComputedStyle(el).backgroundColor;\n  host.removeChild(el);\n  return paraRGB(lido, fallback);\n}\n\nexport interface EraseFieldProps extends React.HTMLAttributes<HTMLDivElement> {\n  /** Var de cor da luz revelada. Default `--brand`. */\n  lightVar?: string;\n  /** Var de cor da poeira que cobre. Default `--background`. */\n  dustVar?: string;\n  /** Intensidade da luz, 0–1. Acima de ~0.7 o texto por cima começa a sofrer. */\n  intensity?: number;\n  children?: React.ReactNode;\n}\n\nexport function EraseField({\n  lightVar = \"--brand\",\n  dustVar = \"--background\",\n  intensity = 0.5,\n  className,\n  children,\n  ...props\n}: EraseFieldProps) {\n  const hostRef = React.useRef<HTMLDivElement>(null);\n  const canvasRef = React.useRef<HTMLCanvasElement>(null);\n\n  React.useEffect(() => {\n    const host = hostRef.current;\n    const canvas = canvasRef.current;\n    if (!host || !canvas) return;\n\n    const ctx = canvas.getContext(\"2d\");\n    const poeira = document.createElement(\"canvas\");\n    const pctx = poeira.getContext(\"2d\");\n    if (!ctx || !pctx) return;\n\n    const reduzido = window.matchMedia(\"(prefers-reduced-motion: reduce)\").matches;\n\n    let luzRGB: [number, number, number] = [82, 221, 235];\n    let dustRGB: [number, number, number] = [10, 10, 11];\n    let w = 0;\n    let h = 0;\n    let t = 0;\n    let rodando = false;\n    // px/py = onde o pincel está (com inércia); tx/ty = pra onde ele vai.\n    let px = 0;\n    let py = 0;\n    let tx = 0;\n    let ty = 0;\n    let temPonteiro = false;\n    let ociosoDesde = 0;\n    let raf = 0;\n\n    const rgba = (c: [number, number, number], a: number) =>\n      `rgba(${c[0]},${c[1]},${c[2]},${a})`;\n\n    /* A luz, num buffer de METADE da resolução e esticada na hora de compor.\n       São cinco preenchimentos de tela cheia por quadro; em meia escala custam\n       um quarto dos pixels, e como não existe uma única borda dura aqui — é\n       tudo gradiente — a interpolação da esticada é literalmente invisível. */\n    const luzCv = document.createElement(\"canvas\");\n    const lctx = luzCv.getContext(\"2d\")!;\n    const ESCALA = 0.5;\n\n    function luz(ms: number) {\n      const lw = luzCv.width;\n      const lh = luzCv.height;\n      const g = lctx.createLinearGradient(0, 0, 0, lh);\n      g.addColorStop(0, rgba(dustRGB, 1));\n      g.addColorStop(1, rgba(dustRGB, 1));\n      lctx.globalCompositeOperation = \"source-over\";\n      lctx.fillStyle = g;\n      lctx.fillRect(0, 0, lw, lh);\n\n      // Duas grandes e frias dão a massa; duas menores dão o brilho. Os\n      // divisores são primos entre si: órbitas que não fecham juntas não batem.\n      const bolhas: Array<[number, number, number, number]> = [\n        [0.5 + Math.sin(ms / 7900) * 0.16, 0.46 + Math.cos(ms / 11300) * 0.14, 0.72, 1],\n        [0.34 + Math.cos(ms / 6100) * 0.2, 0.6 + Math.sin(ms / 8700) * 0.18, 0.5, 0.64],\n        [0.68 + Math.sin(ms / 9700) * 0.18, 0.38 + Math.cos(ms / 5300) * 0.2, 0.42, 0.56],\n        [0.5 + Math.cos(ms / 4300) * 0.26, 0.55 + Math.sin(ms / 6700) * 0.22, 0.26, 0.44],\n      ];\n      const r0 = Math.max(lw, lh);\n      lctx.globalCompositeOperation = \"lighter\";\n      for (const b of bolhas) {\n        const x = b[0] * lw;\n        const y = b[1] * lh;\n        const r = b[2] * r0 * 0.5;\n        const a = b[3] * intensity;\n        const rg = lctx.createRadialGradient(x, y, 0, x, y, r);\n        rg.addColorStop(0, rgba(luzRGB, a));\n        rg.addColorStop(0.45, rgba(luzRGB, a * 0.22));\n        rg.addColorStop(1, rgba(luzRGB, 0));\n        lctx.fillStyle = rg;\n        lctx.fillRect(0, 0, lw, lh);\n      }\n      lctx.globalCompositeOperation = \"source-over\";\n      ctx!.drawImage(luzCv, 0, 0, lw, lh, 0, 0, w, h);\n    }\n\n    /* O pincel é um SPRITE, desenhado uma vez. A versão anterior montava um\n       `createRadialGradient` por carimbo e passava `filter: blur(14px)` no\n       contexto — com até nove carimbos por quadro isso é uma passada de filtro\n       em tela cheia nove vezes a 60fps, e travava o renderer num gesto rápido.\n       Um `drawImage` de sprite dá a MESMA borda, porque quem faz a borda morrer\n       devagar é a queda do gradiente, não o blur. */\n    const pincel = document.createElement(\"canvas\");\n    {\n      const S = 128;\n      pincel.width = pincel.height = S;\n      const g2 = pincel.getContext(\"2d\")!;\n      const g = g2.createRadialGradient(S / 2, S / 2, 0, S / 2, S / 2, S / 2);\n      g.addColorStop(0, \"rgba(0,0,0,1)\");\n      g.addColorStop(0.4, \"rgba(0,0,0,0.82)\");\n      g.addColorStop(0.75, \"rgba(0,0,0,0.3)\");\n      g.addColorStop(1, \"rgba(0,0,0,0)\");\n      g2.fillStyle = g;\n      g2.fillRect(0, 0, S, S);\n    }\n\n    /* Raspa do ponto anterior até o atual. Interpola pra o rastro não sair\n       pontilhado num gesto rápido, e sorteia raio e desvio a cada carimbo: é o\n       sorteio que tira a cara de tubo e devolve a de gota. O teto de 10 existe\n       porque um salto grande (troca de aba, scroll brusco) não pode virar um\n       pico de centenas de draws num quadro só. */\n    function raspar(x0: number, y0: number, x1: number, y1: number, forca: number) {\n      const d = Math.hypot(x1 - x0, y1 - y0);\n      const base = 46 + Math.min(34, d * 0.7); // gesto rápido, pincel mais largo\n      const n = Math.min(10, Math.max(1, Math.ceil(d / 14)));\n      pctx!.globalCompositeOperation = \"destination-out\";\n      for (let i = 0; i <= n; i++) {\n        const u = i / n;\n        const jx = (Math.random() - 0.5) * base * 0.5;\n        const jy = (Math.random() - 0.5) * base * 0.5;\n        const r = base * (0.62 + Math.random() * 0.6);\n        // 0.62, não 0.4: com 0.4 cada carimbo mal marcava, o rasgo dependia de\n        // sobreposição e o gesto lia como \"quase não aconteceu nada\". A borda\n        // continua morrendo devagar — quem faz a maciez é a queda do gradiente\n        // do sprite, não este alpha.\n        pctx!.globalAlpha = 0.62 * forca;\n        pctx!.drawImage(pincel, x0 + (x1 - x0) * u + jx - r, y0 + (y1 - y0) * u + jy - r, r * 2, r * 2);\n      }\n      pctx!.globalAlpha = 1;\n      pctx!.globalCompositeOperation = \"source-over\";\n    }\n\n    /** A poeira volta. Véu radial gigante e fora de centro, em deriva. */\n    function repor(ms: number, a: number) {\n      const x = w * (0.5 + Math.sin(ms / 12100) * 0.4);\n      const y = h * (0.5 + Math.cos(ms / 9100) * 0.4);\n      const g = pctx!.createRadialGradient(x, y, 0, x, y, Math.max(w, h) * 1.1);\n      g.addColorStop(0, rgba(dustRGB, a));\n      g.addColorStop(1, rgba(dustRGB, a * 0.35));\n      pctx!.fillStyle = g;\n      pctx!.fillRect(0, 0, w, h);\n    }\n\n    /* Passeio ocioso: uma Lissajous lenta, curva sem repetição visível e sem\n       nenhum canto. Só entra depois de 1.2s sem ponteiro, pra não brigar com a\n       mão de quem está de fato mexendo. */\n    const ocioso = (ms: number): [number, number] => [\n      w * (0.5 + Math.sin(ms / 5200) * 0.3 + Math.sin(ms / 2300) * 0.06),\n      h * (0.5 + Math.cos(ms / 3900) * 0.26 + Math.cos(ms / 1700) * 0.05),\n    ];\n\n    /* Reduced motion: a luz e a poeira ficam, com um rasgo já aberto no meio\n       pra a dobra não parecer um retângulo chapado. Um quadro, sem loop. */\n    function quadroEstatico() {\n      raspar(w * 0.3, h * 0.62, w * 0.72, h * 0.42, 1);\n      luz(0);\n      ctx!.drawImage(poeira, 0, 0, w, h);\n    }\n\n    function medir() {\n      const r = host!.getBoundingClientRect();\n      const dpr = Math.min(2, window.devicePixelRatio || 1);\n      w = Math.max(1, Math.round(r.width));\n      h = Math.max(1, Math.round(r.height));\n      // Relido a cada medida: trocar de tema em runtime tem que repintar.\n      luzRGB = sonda(host!, lightVar, luzRGB);\n      dustRGB = sonda(host!, dustVar, dustRGB);\n      canvas!.width = Math.round(w * dpr);\n      canvas!.height = Math.round(h * dpr);\n      ctx!.setTransform(dpr, 0, 0, dpr, 0, 0);\n      poeira.width = w;\n      poeira.height = h;\n      pctx!.setTransform(1, 0, 0, 1, 0, 0);\n      luzCv.width = Math.max(1, Math.round(w * ESCALA));\n      luzCv.height = Math.max(1, Math.round(h * ESCALA));\n      repor(0, 1); // nasce fechada\n      px = tx = w * 0.5;\n      py = ty = h * 0.5;\n      if (reduzido) quadroEstatico();\n    }\n\n    function quadro(now: number) {\n      if (!rodando) return;\n      t = now;\n      let x = tx;\n      let y = ty;\n      if (!temPonteiro || now - ociosoDesde > 1200) {\n        [x, y] = ocioso(now);\n      }\n      const ax = px;\n      const ay = py;\n      px += (x - px) * 0.12; // inércia: persegue, não teletransporta\n      py += (y - py) * 0.12;\n      // 0.62 no passeio ocioso (era 0.45): quem nunca leva o ponteiro até aqui\n      // — celular inteiro — só vê o passeio, e ele não pode ser o irmão fraco.\n      if (Math.hypot(px - ax, py - ay) > 0.4) raspar(ax, ay, px, py, temPonteiro ? 1 : 0.62);\n      repor(now, 0.008); // a poeira volta mais devagar, senão ela come o rasgo\n\n      ctx!.clearRect(0, 0, w, h);\n      luz(now);\n      ctx!.drawImage(poeira, 0, 0, w, h);\n      raf = requestAnimationFrame(quadro);\n    }\n\n    const aoMover = (e: PointerEvent) => {\n      const r = canvas!.getBoundingClientRect();\n      tx = e.clientX - r.left;\n      ty = e.clientY - r.top;\n      temPonteiro = true;\n      ociosoDesde = t;\n    };\n    const aoSair = () => {\n      temPonteiro = false;\n    };\n    host.addEventListener(\"pointermove\", aoMover, { passive: true });\n    host.addEventListener(\"pointerleave\", aoSair);\n\n    const ro = new ResizeObserver(medir);\n    ro.observe(host);\n    medir();\n\n    /* Trocar de tema não muda tamanho nenhum, então o ResizeObserver não acorda\n       e o campo ficaria com a cor do tema anterior até alguém redimensionar a\n       janela — o \"relido no resize\" acima só valia por acidente. Vigiar a classe\n       do `<html>` (é lá que o botão de tema escreve) custa um observer. */\n    const mo = new MutationObserver(() => {\n      luzRGB = sonda(host, lightVar, luzRGB);\n      dustRGB = sonda(host, dustVar, dustRGB);\n      // A poeira é um BUFFER: os pixels dela já estão pintados na cor do tema\n      // anterior, e `repor` só sobrepõe 0.011 de alpha por quadro. Sem apagar,\n      // o campo ficava com o fundo claro de antes por segundos dentro do tema\n      // escuro — que é literalmente a queixa de \"cor de fundo fora do tema\".\n      pctx!.clearRect(0, 0, w, h);\n      repor(0, 1);\n      if (reduzido) quadroEstatico(); // sem laço, o repinte tem que ser pedido\n    });\n    mo.observe(document.documentElement, { attributes: true, attributeFilter: [\"class\"] });\n\n    let io: IntersectionObserver | undefined;\n    if (!reduzido) {\n      io = new IntersectionObserver(\n        (es) => {\n          if (es[0].isIntersecting) {\n            if (!rodando) {\n              rodando = true;\n              raf = requestAnimationFrame(quadro);\n            }\n          } else {\n            rodando = false;\n          }\n        },\n        { threshold: 0.02 },\n      );\n      io.observe(host);\n    }\n\n    return () => {\n      rodando = false;\n      cancelAnimationFrame(raf);\n      ro.disconnect();\n      mo.disconnect();\n      io?.disconnect();\n      host.removeEventListener(\"pointermove\", aoMover);\n      host.removeEventListener(\"pointerleave\", aoSair);\n    };\n  }, [lightVar, dustVar, intensity]);\n\n  return (\n    <div ref={hostRef} className={cn(\"relative isolate overflow-hidden\", className)} {...props}>\n      <canvas\n        ref={canvasRef}\n        aria-hidden=\"true\"\n        className=\"pointer-events-none absolute inset-0 -z-10 h-full w-full\"\n      />\n      {children}\n    </div>\n  );\n}\n",
      "type": "registry:ui"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Hero ou CTA com fundo em canvas que a pessoa raspa pra revelar a luz, convidando a mexer",
      "evite": "Malha que só reage ao ponteiro: spring-dots; fundo calmo atrás de texto longo, grid-dots"
    }
  },
  "categories": [
    "efeitos",
    "fundo",
    "canvas",
    "ponteiro",
    "cta",
    "revelar",
    "raspar"
  ],
  "type": "registry:ui"
}