{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "heat-word",
  "title": "Heat Word",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "Uma grade de gotas ou uma palavra que derrete num mapa de calor por onde o cursor passa, pintada com as cores da marca.",
  "dependencies": [],
  "registryDependencies": [
    "utils",
    "@visant/css-color"
  ],
  "files": [
    {
      "path": "registry/visant/ui/heat-word.tsx",
      "content": "\"use client\";\n\nimport * as React from \"react\";\n\nimport { cn } from \"@/lib/utils\";\nimport { onThemeChange, resolveCssColor, type RGB } from \"@/lib/css-color\";\n\n/**\n * Heat Word — uma forma (pontos ou palavra) que derrete num mapa de calor\n * debaixo do cursor e esfria sozinha quando ele sai.\n *\n * É peça de vitrine, não de controle: o gesto é passear o mouse, e o retorno\n * é a forma \"lembrando\" por onde ele passou. Por isso o calor acumula, espalha\n * e decai — um rastro que some em ~2s, e não um holofote preso ao ponteiro.\n *\n * ── As decisões que não se veem ────────────────────────────────────────────\n *\n * 1. **Canvas 2D numa grade grossa, não WebGL.** A simulação roda em células de\n *    2px e o quadro sobe para o tamanho real pelo próprio `drawImage`, com\n *    suavização bilinear. A interpolação é que derrete a borda; um shader daria\n *    o mesmo desenho custando um contexto WebGL por peça, e a vitrine tem dezenas.\n * 2. **A forma é um campo, não um contorno.** A máscara é desenhada borrada e\n *    cortada num limiar (o truque das \"metaballs\"): pontos vizinhos se fundem\n *    conforme `softness`. O calor BAIXA esse limiar, então onde está quente a\n *    forma incha e as gotas se juntam. É isso que lê como derreter.\n * 3. **A paleta vem do tema, nunca de prop hex.** As paradas da rampa são cores\n *    CSS (`var(--brand)`, `color-mix(...)`), resolvidas pelo `resolveCssColor`\n *    numa tabela de 256 tons por troca de tema, não por quadro. No escuro o\n *    núcleo quente puxa para `--foreground` e clareia sozinho.\n * 4. **O laço dorme.** Sem ponteiro e com a grade fria, o `requestAnimationFrame`\n *    para. Uma página com a peça parada não gasta nada.\n * 5. **Movimento reduzido:** sem difusão e com decaimento curto. O calor ainda\n *    responde ao ponteiro (é a função da peça), mas não deixa rastro viajando.\n */\n\n/** Tamanho da célula da simulação, em px CSS. */\nconst CELULA = 2;\n\n/** Rampa padrão: repouso → marca → núcleo. Tudo token. */\nconst RAMPA_PADRAO = [\n  \"var(--muted-foreground)\",\n  \"color-mix(in oklab, var(--brand) 45%, var(--muted-foreground))\",\n  \"var(--brand)\",\n  \"color-mix(in oklab, var(--brand) 55%, var(--foreground))\",\n];\n\nexport interface HeatWordProps extends Omit<React.HTMLAttributes<HTMLDivElement>, \"children\"> {\n  /** A forma em repouso: grade de gotas ou uma palavra. */\n  shape?: \"dots\" | \"word\";\n  /** O texto quando `shape=\"word\"`. Curto: cabe numa linha e é desenhado grande. */\n  word?: string;\n  /** 0–100. Quanto calor o ponteiro deposita por quadro. */\n  heat?: number;\n  /** 0–100. O raio do pincel de calor. */\n  area?: number;\n  /** 0–100. O quanto a forma é borrada antes do limiar: funde as gotas. */\n  softness?: number;\n  /** Paradas da rampa, do frio ao quente. Qualquer cor CSS ou token. */\n  colors?: string[];\n}\n\nconst smooth = (a: number, b: number, x: number) => {\n  const t = Math.min(1, Math.max(0, (x - a) / (b - a)));\n  return t * t * (3 - 2 * t);\n};\n\n/** Pseudoaleatório estável por índice: o tamanho das gotas não muda a cada render. */\nconst ruido = (i: number) => {\n  const s = Math.sin(i * 127.1 + 311.7) * 43758.5453;\n  return s - Math.floor(s);\n};\n\nfunction montarRampa(cores: RGB[]): Uint8ClampedArray {\n  const lut = new Uint8ClampedArray(256 * 3);\n  const n = cores.length - 1;\n  for (let i = 0; i < 256; i++) {\n    const t = (i / 255) * n;\n    const k = Math.min(n - 1, Math.floor(t));\n    const f = t - k;\n    const a = cores[k];\n    const b = cores[k + 1] ?? a;\n    for (let c = 0; c < 3; c++) lut[i * 3 + c] = (a[c] + (b[c] - a[c]) * f) * 255;\n  }\n  return lut;\n}\n\nfunction montarMascara(\n  gw: number,\n  gh: number,\n  shape: \"dots\" | \"word\",\n  word: string,\n  borrao: number,\n  fonte: string,\n): Float32Array {\n  const c = document.createElement(\"canvas\");\n  c.width = gw;\n  c.height = gh;\n  const x = c.getContext(\"2d\", { willReadFrequently: true });\n  const out = new Float32Array(gw * gh);\n  if (!x) return out;\n  x.filter = borrao > 0 ? `blur(${borrao}px)` : \"none\";\n  // A máscara só usa o canal alfa: o preenchimento padrão do canvas basta.\n\n  if (shape === \"word\") {\n    let tam = gh * 0.62;\n    x.font = `800 ${tam}px ${fonte}`;\n    const larg = x.measureText(word).width || 1;\n    tam = Math.min(tam, (tam * gw * 0.84) / larg);\n    x.font = `800 ${tam}px ${fonte}`;\n    x.textAlign = \"center\";\n    x.textBaseline = \"middle\";\n    x.fillText(word, gw / 2, gh / 2 + tam * 0.04);\n  } else {\n    // Grade larga e gotas quase iguais: em repouso cada ponto fica SOLTO (lê\n    // como textura, não como mancha), e só o calor faz os vizinhos se tocarem.\n    const cols = 12;\n    const rows = 5;\n    const passo = Math.min((gw * 0.86) / cols, (gh * 0.8) / rows);\n    const x0 = gw / 2 - (passo * (cols - 1)) / 2;\n    const y0 = gh / 2 - (passo * (rows - 1)) / 2;\n    for (let r = 0; r < rows; r++) {\n      for (let k = 0; k < cols; k++) {\n        const i = r * cols + k;\n        const raio = passo * (0.26 + ruido(i) * 0.06);\n        x.beginPath();\n        x.arc(x0 + k * passo, y0 + r * passo, raio, 0, Math.PI * 2);\n        x.fill();\n      }\n    }\n  }\n\n  const px = x.getImageData(0, 0, gw, gh).data;\n  for (let i = 0; i < out.length; i++) out[i] = px[i * 4 + 3] / 255;\n  return out;\n}\n\nexport function HeatWord({\n  shape = \"dots\",\n  word = \"Calor\",\n  heat = 60,\n  area = 50,\n  softness = 50,\n  colors,\n  className,\n  ...props\n}: HeatWordProps) {\n  const wrapRef = React.useRef<HTMLDivElement>(null);\n  const canvasRef = React.useRef<HTMLCanvasElement>(null);\n\n  // Parâmetros vivos num ref: mexer no knob não reinicia a simulação.\n  const params = React.useRef({ heat, area, softness });\n  params.current = { heat, area, softness };\n\n  const coresChave = (colors ?? RAMPA_PADRAO).join(\"|\");\n\n  React.useEffect(() => {\n    const wrap = wrapRef.current;\n    const canvas = canvasRef.current;\n    const ctx = canvas?.getContext(\"2d\");\n    if (!wrap || !canvas || !ctx) return;\n\n    const reduzido = window.matchMedia(\"(prefers-reduced-motion: reduce)\").matches;\n    const buf = document.createElement(\"canvas\");\n    const bctx = buf.getContext(\"2d\");\n    if (!bctx) return;\n\n    let gw = 0;\n    let gh = 0;\n    let mascara: Float32Array = new Float32Array(0);\n    let calor: Float32Array = new Float32Array(0);\n    let tmp: Float32Array = new Float32Array(0);\n    let img: ImageData | null = null;\n    let lut: Uint8ClampedArray = new Uint8ClampedArray(256 * 3);\n    const ponteiro = { x: 0, y: 0, dentro: false, rajada: false };\n    let raf = 0;\n    let ultimo = 0;\n    let escala = 1;\n\n    const fonte = () => {\n      const cs = getComputedStyle(wrap);\n      return cs.getPropertyValue(\"--font-display\").trim() || cs.fontFamily || \"sans-serif\";\n    };\n\n    const relerCores = () => {\n      lut = montarRampa(coresChave.split(\"|\").map((c) => resolveCssColor(c, wrap)));\n    };\n\n    const remontar = () => {\n      const r = wrap.getBoundingClientRect();\n      const dpr = Math.min(2, window.devicePixelRatio || 1);\n      canvas.width = Math.max(1, Math.round(r.width * dpr));\n      canvas.height = Math.max(1, Math.round(r.height * dpr));\n      escala = dpr;\n      const nw = Math.max(1, Math.ceil(r.width / CELULA));\n      const nh = Math.max(1, Math.ceil(r.height / CELULA));\n      if (nw !== gw || nh !== gh) {\n        gw = nw;\n        gh = nh;\n        calor = new Float32Array(gw * gh);\n        tmp = new Float32Array(gw * gh);\n        buf.width = gw;\n        buf.height = gh;\n        img = bctx.createImageData(gw, gh);\n      }\n      const borrao = 0.4 + (params.current.softness / 100) * 4.5;\n      mascara = montarMascara(gw, gh, shape, word, borrao, fonte());\n    };\n\n    const depositar = (ganho: number) => {\n      const raioPx = 18 + (params.current.area / 100) * 90;\n      const rc = raioPx / CELULA;\n      const s2 = 2 * (rc / 2) * (rc / 2);\n      const cx = ponteiro.x / CELULA;\n      const cy = ponteiro.y / CELULA;\n      const x0 = Math.max(0, Math.floor(cx - rc));\n      const x1 = Math.min(gw - 1, Math.ceil(cx + rc));\n      const y0 = Math.max(0, Math.floor(cy - rc));\n      const y1 = Math.min(gh - 1, Math.ceil(cy + rc));\n      for (let y = y0; y <= y1; y++) {\n        for (let x = x0; x <= x1; x++) {\n          const d2 = (x - cx) ** 2 + (y - cy) ** 2;\n          const i = y * gw + x;\n          calor[i] = Math.min(1, calor[i] + ganho * Math.exp(-d2 / s2));\n        }\n      }\n    };\n\n    const passo = (k: number) => {\n      if (ponteiro.dentro) depositar((0.015 + (params.current.heat / 100) * 0.1) * k);\n      if (ponteiro.rajada) {\n        depositar(0.5);\n        ponteiro.rajada = false;\n      }\n      // Difusão de 4 vizinhos: o calor escorre para as bordas do rastro.\n      const D = reduzido ? 0 : 0.22;\n      const decai = Math.pow(reduzido ? 0.82 : 0.968, k);\n      let max = 0;\n      for (let y = 0; y < gh; y++) {\n        for (let x = 0; x < gw; x++) {\n          const i = y * gw + x;\n          const v = calor[i];\n          const viz =\n            (x > 0 ? calor[i - 1] : v) +\n            (x < gw - 1 ? calor[i + 1] : v) +\n            (y > 0 ? calor[i - gw] : v) +\n            (y < gh - 1 ? calor[i + gw] : v);\n          const n = (v * (1 - D) + viz * 0.25 * D) * decai;\n          tmp[i] = n < 0.001 ? 0 : n;\n          if (n > max) max = n;\n        }\n      }\n      const t = calor;\n      calor = tmp;\n      tmp = t;\n      return max;\n    };\n\n    const pintar = () => {\n      if (!img) return;\n      const d = img.data;\n      const borda = 0.06 + (params.current.softness / 100) * 0.1;\n      // Letra borrada e cortada no meio afina o traço; a palavra corta mais baixo\n      // para manter o peso de display mesmo quando a fonte da marca é leve.\n      const base = shape === \"word\" ? 0.4 : 0.5;\n      // As gotas soltas precisam inchar mais que a letra para chegar a se tocar.\n      const inchar = shape === \"word\" ? 0.28 : 0.4;\n      for (let i = 0; i < mascara.length; i++) {\n        const h = calor[i];\n        const limiar = base - h * inchar; // quente = forma incha e as gotas se fundem\n        const a = smooth(limiar - borda, limiar + borda, mascara[i]);\n        const c = Math.min(255, Math.round(h * 255)) * 3;\n        const o = i * 4;\n        d[o] = lut[c];\n        d[o + 1] = lut[c + 1];\n        d[o + 2] = lut[c + 2];\n        d[o + 3] = a * 255;\n      }\n      bctx.putImageData(img, 0, 0);\n      ctx.clearRect(0, 0, canvas.width, canvas.height);\n      ctx.imageSmoothingEnabled = true;\n      ctx.imageSmoothingQuality = \"high\";\n      ctx.drawImage(buf, 0, 0, gw * CELULA * escala, gh * CELULA * escala);\n    };\n\n    const quadro = (agora: number) => {\n      const k = ultimo ? Math.min(3, (agora - ultimo) / 16.67) : 1;\n      ultimo = agora;\n      const max = passo(k);\n      pintar();\n      if (ponteiro.dentro || max > 0.002) {\n        raf = requestAnimationFrame(quadro);\n      } else {\n        raf = 0;\n        ultimo = 0;\n      }\n    };\n\n    const acordar = () => {\n      if (!raf) raf = requestAnimationFrame(quadro);\n    };\n\n    const mover = (e: PointerEvent) => {\n      const r = canvas.getBoundingClientRect();\n      ponteiro.x = e.clientX - r.left;\n      ponteiro.y = e.clientY - r.top;\n      ponteiro.dentro = true;\n      acordar();\n    };\n    const sair = () => {\n      ponteiro.dentro = false;\n    };\n    const apertar = (e: PointerEvent) => {\n      mover(e);\n      ponteiro.rajada = true;\n    };\n\n    relerCores();\n    remontar();\n    pintar();\n\n    const ro = new ResizeObserver(() => {\n      remontar();\n      pintar();\n    });\n    ro.observe(wrap);\n    const offTema = onThemeChange(() => {\n      relerCores();\n      remontar();\n      pintar();\n    });\n    // A fonte da marca pode chegar depois do primeiro desenho da palavra.\n    let vivo = true;\n    document.fonts?.ready.then(() => {\n      if (!vivo) return;\n      remontar();\n      pintar();\n    });\n\n    canvas.addEventListener(\"pointermove\", mover);\n    canvas.addEventListener(\"pointerdown\", apertar);\n    canvas.addEventListener(\"pointerleave\", sair);\n    canvas.addEventListener(\"pointercancel\", sair);\n\n    return () => {\n      vivo = false;\n      cancelAnimationFrame(raf);\n      ro.disconnect();\n      offTema();\n      canvas.removeEventListener(\"pointermove\", mover);\n      canvas.removeEventListener(\"pointerdown\", apertar);\n      canvas.removeEventListener(\"pointerleave\", sair);\n      canvas.removeEventListener(\"pointercancel\", sair);\n    };\n    // softness entra no remontar; heat e area são lidos ao vivo pelo ref.\n  }, [shape, word, softness, coresChave]);\n\n  return (\n    <div\n      ref={wrapRef}\n      role=\"img\"\n      aria-label={shape === \"word\" ? word : \"Grade de pontos que esquenta sob o cursor\"}\n      className={cn(\"relative block aspect-[2/1] w-full touch-pan-y select-none\", className)}\n      {...props}\n    >\n      <canvas ref={canvasRef} aria-hidden=\"true\" className=\"absolute inset-0 block h-full w-full\" />\n    </div>\n  );\n}\n",
      "type": "registry:ui"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Palavra de destaque ou grade de gotas que derrete num mapa de calor sob o cursor, em hero",
      "evite": "Fundo de pontos que reage: spring-dots; título que precisa ler animado, line-reveal"
    }
  },
  "categories": [
    "efeitos",
    "canvas",
    "cursor",
    "hover",
    "calor",
    "efeito"
  ],
  "type": "registry:ui"
}