{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "slot-text",
  "title": "Slot Text",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "Número ou palavra que gira como rolo de caça-níquel e assenta da esquerda pra direita, sem passar do alvo.",
  "dependencies": [
    "motion"
  ],
  "registryDependencies": [
    "utils",
    "@visant/motion"
  ],
  "files": [
    {
      "path": "registry/visant/ui/slot-text.tsx",
      "content": "\"use client\";\n\n/* Adaptado de Slot Text — https://uiarc.dev/components/slot-text — Copyright (c) 2026 Elia Kuratli, licença MIT (texto integral em ATTRIBUTIONS.md do @visant/ui). */\n\nimport * as React from \"react\";\nimport {\n  AnimatePresence,\n  animate,\n  motion,\n  useMotionValue,\n  usePresence,\n  useReducedMotion,\n  useTransform,\n  useVelocity,\n} from \"motion/react\";\n\nimport { DUR } from \"@/lib/motion\";\nimport { cn } from \"@/lib/utils\";\n\n/**\n * Slot Text — o valor que gira como rolo de caça-níquel até assentar.\n *\n * Pra troca que merece uma batida: preço mudando de plano, número trocando de\n * período, status de lançamento virando. Cada caractere é um rolo. Dígito gira\n * pela roda na direção em que o número andou; letra embaralha pelo alfabeto; os\n * rolos param um depois do outro, da esquerda pra direita, sem passar do alvo.\n *\n * ── O que não é óbvio ──────────────────────────────────────────────────────\n *\n * 1. **Número casa os rolos pelo fim.** De 999 pra 1.000 só os dígitos giram:\n *    o separador fica no lugar e o rolo novo nasce à esquerda. Símbolo na\n *    frente (R$, +) ganha rolo próprio e nunca vira dígito.\n * 2. **Trocar no meio do giro recomeça de onde o rolo está**, guardando o\n *    deslocamento de fração de célula. Nada pula.\n * 3. **O desfoque segue a velocidade do rolo**, então o giro rápido borra e o\n *    pouso é nítido. Parado, o filtro sai inteiro (custo zero).\n * 4. **A largura do rolo vai até o caractere novo numa mola sem rebote**:\n *    a palavra nunca muda de tamanho num quadro.\n * 5. **O embaralhado é determinístico.** A mesma troca gira as mesmas letras,\n *    então servidor e cliente desenham igual.\n * 6. **O valor inteiro é texto de verdade** num `sr-only`; os rolos são\n *    `aria-hidden`. `announce` liga um `aria-live` pra valor que muda sozinho.\n *\n * A duração passa dos 300 ms da casa de propósito: isso é um momento, não\n * resposta a gesto. Pra valor que muda a cada segundo, use `spins={0}`.\n * Com `prefers-reduced-motion` o valor troca seco.\n */\n\nexport interface SlotTextProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, \"children\"> {\n  /** O valor. Número passa por `format`; texto entra como está. */\n  value: string | number;\n  /** Formata número. Default: agrupamento pt-BR (12.480). */\n  format?: (value: number) => string;\n  /** Segundos que o primeiro rolo gira. */\n  duration?: number;\n  /** Segundos entre um rolo parar e o próximo. */\n  stagger?: number;\n  /** Voltas inteiras antes de pousar. 0 rola direto pro dígito novo. */\n  spins?: number;\n  /** De que ponta os rolos casam quando o tamanho muda. Número: fim; texto: começo. */\n  align?: \"start\" | \"end\";\n  /** Anuncia o valor novo ao leitor de tela, com educação. */\n  announce?: boolean;\n}\n\nconst DIGITOS = \"0123456789\";\nconst MINUSC = \"abcdefghijklmnopqrstuvwxyz\";\nconst MAIUSC = MINUSC.toUpperCase();\n// Sai rápido, pousa longo e macio, nunca passa do alvo.\nconst POUSO = [0.12, 0.8, 0.16, 1] as const;\n// Altura de cada célula, em em. A célula é mais alta que a linha pra que os\n// vizinhos de um caractere pousado fiquem inteiros fora da janela.\nconst CELULA = 1.6;\n\nconst nada = () => () => {};\nfunction useReduzir() {\n  const hidratado = React.useSyncExternalStore(nada, () => true, () => false);\n  return !!useReducedMotion() && hidratado;\n}\n\nconst classe = (c: string) =>\n  DIGITOS.includes(c) ? DIGITOS : MINUSC.includes(c) ? MINUSC : MAIUSC.includes(c) ? MAIUSC : null;\n\nfunction sorteio(semente: number) {\n  let s = semente >>> 0 || 1;\n  return () => {\n    s = (s * 1664525 + 1013904223) >>> 0;\n    return s / 4294967296;\n  };\n}\n\n/** As células do rolo, do que está visível agora até o alvo. */\nfunction fita(de: string, para: string, voltas: number, subindo: boolean, semente: number) {\n  if (de === para) return [para];\n  const conj = classe(para);\n  if (!conj) return [de, para];\n  if (conj === DIGITOS && classe(de) === DIGITOS) {\n    const a = Number(de);\n    const b = Number(para);\n    const passos = voltas * 10 + (subindo ? (b - a + 10) % 10 : (a - b + 10) % 10);\n    return Array.from({ length: passos + 1 }, (_, i) => String((a + (subindo ? i : -i) + 100) % 10));\n  }\n  const r = sorteio(semente);\n  const meio = Array.from({ length: Math.max(2, voltas * 5 + 2) }, () => conj[Math.floor(r() * conj.length)]!);\n  return [de, ...meio, para];\n}\n\nconst visivel = (c: string) => (c === \" \" ? \" \" : c);\n\ninterface RoloProps {\n  char: string;\n  ordem: number;\n  entrando: boolean;\n  subindo: boolean;\n  duration: number;\n  stagger: number;\n  spins: number;\n  reduzir: boolean;\n}\n\nfunction Rolo({ char, ordem, entrando, subindo, duration, stagger, spins, reduzir }: RoloProps) {\n  const pos = useMotionValue(0);\n  const larg = useMotionValue<number | \"auto\">(\"auto\");\n  const medidor = React.useRef<HTMLSpanElement>(null);\n  const [presente, liberar] = usePresence();\n  const [rolo, setRolo] = React.useState(() => ({\n    char,\n    fita: entrando && !reduzir ? fita(\"\", char, spins, subindo, char.charCodeAt(0) + ordem) : [char],\n    de: 0,\n    cresce: entrando,\n    tempo: duration + ordem * stagger,\n  }));\n\n  if (rolo.char !== char) {\n    const agora = pos.get();\n    const i = Math.max(0, Math.min(rolo.fita.length - 1, Math.round(agora)));\n    const naTela = rolo.fita[i]!;\n    setRolo({\n      char,\n      fita: reduzir\n        ? [char]\n        : fita(naTela, char, spins, subindo, char.charCodeAt(0) * 31 + naTela.charCodeAt(0) * 7 + ordem + rolo.fita.length),\n      de: reduzir ? 0 : agora - i,\n      cresce: false,\n      tempo: duration + ordem * stagger,\n    });\n  }\n\n  const blur = useTransform(useVelocity(pos), (v) => {\n    const q = Math.min(Math.abs(v) * 0.05, 2.4);\n    return q < 0.15 ? \"none\" : `blur(${q.toFixed(2)}px)`;\n  });\n  const y = useTransform(pos, (v) => `translate3d(0, ${(-v * CELULA).toFixed(4)}em, 0)`);\n\n  React.useLayoutEffect(() => {\n    const medida = medidor.current?.getBoundingClientRect().width ?? 0;\n    const ultima = rolo.fita.length - 1;\n    if (reduzir) {\n      pos.jump(ultima);\n      larg.jump(medida);\n      return;\n    }\n    pos.jump(rolo.de);\n    const giro = animate(pos, ultima, { duration: ultima === 0 ? DUR.base : rolo.tempo, ease: [...POUSO] });\n    if (rolo.cresce) larg.jump(0);\n    if (larg.get() === \"auto\") {\n      larg.jump(medida);\n      return () => giro.stop();\n    }\n    const cresce = animate(larg, medida, { type: \"spring\", visualDuration: Math.min(rolo.tempo, 0.6), bounce: 0 });\n    return () => {\n      giro.stop();\n      cresce.stop();\n    };\n  }, [rolo, pos, larg, reduzir]);\n\n  // Rolo que sai fecha a largura até zero antes de ser removido.\n  React.useLayoutEffect(() => {\n    if (presente) return;\n    if (reduzir) {\n      liberar();\n      return;\n    }\n    const sai = animate(larg, 0, { type: \"spring\", visualDuration: 0.35, bounce: 0, onComplete: liberar });\n    return () => sai.stop();\n  }, [presente, liberar, larg, reduzir]);\n\n  return (\n    <motion.span className=\"relative inline-block h-[1.15em] flex-none\" style={{ width: larg }}>\n      <span ref={medidor} className=\"invisible inline-block whitespace-pre\">\n        {visivel(char)}\n      </span>\n      {/*\n        A janela passa só um fio da linha, pra o caractere esmaecer na borda em\n        vez de ser cortado seco. Mais que isso (era 0,22em) e, no meio do giro,\n        o vizinho de cima e o de baixo apareciam inteiros acima e abaixo do\n        número, e o valor grande virava uma pilha de dígitos.\n      */}\n      <span className=\"absolute -inset-x-[0.08em] -inset-y-[0.1em] overflow-hidden [mask-image:linear-gradient(to_bottom,transparent,black_0.16em,black_calc(100%-0.16em),transparent)]\">\n        <motion.span\n          className=\"absolute inset-x-[0.08em] top-[-0.005em] flex flex-col items-center will-change-transform\"\n          style={{ transform: y, filter: blur }}\n        >\n          {rolo.fita.map((c, i) => (\n            <span key={i} className=\"box-border block h-[1.6em] whitespace-pre pt-[0.225em] leading-[1.15]\">\n              {visivel(c)}\n            </span>\n          ))}\n        </motion.span>\n      </span>\n    </motion.span>\n  );\n}\n\nconst ptBR = (n: number) => n.toLocaleString(\"pt-BR\");\n\nexport function SlotText({\n  value,\n  format = ptBR,\n  duration = 0.9,\n  stagger = 0.07,\n  spins = 1,\n  align,\n  announce = false,\n  className,\n  ...props\n}: SlotTextProps) {\n  const reduzir = useReduzir();\n  const texto = typeof value === \"number\" ? format(value) : value;\n  const peloFim = (align ?? (typeof value === \"number\" ? \"end\" : \"start\")) === \"end\";\n  const chars = Array.from(texto);\n  // Uma sequência de símbolos na frente casa pelo começo; o resto casa pela ponta alinhada.\n  const lead = peloFim ? chars.findIndex((c) => /[\\p{L}\\p{N}]/u.test(c)) : 0;\n  const prefixo = lead < 0 ? chars.length : lead;\n  const chave = (i: number) => (i < prefixo ? `p${i}` : peloFim ? `e${chars.length - 1 - i}` : `s${i}`);\n  const [iniciais] = React.useState(() => new Set(chars.map((_, i) => chave(i))));\n  const [rumo, setRumo] = React.useState({ value, subindo: true });\n  if (rumo.value !== value) {\n    setRumo({ value, subindo: typeof value === \"number\" && typeof rumo.value === \"number\" ? value >= rumo.value : true });\n  }\n\n  return (\n    <span\n      className={cn(\"relative inline-block whitespace-nowrap align-bottom leading-[1.15] tabular-nums\", className)}\n      {...props}\n    >\n      <span className=\"sr-only\" aria-live={announce ? \"polite\" : undefined}>\n        {texto}\n      </span>\n      <span className=\"inline-flex h-[1.15em] items-start\" aria-hidden=\"true\">\n        <AnimatePresence initial={false}>\n          {chars.map((c, i) => (\n            <Rolo\n              key={chave(i)}\n              char={c}\n              ordem={i}\n              entrando={!iniciais.has(chave(i))}\n              subindo={rumo.subindo}\n              duration={duration}\n              stagger={stagger}\n              spins={spins}\n              reduzir={reduzir}\n            />\n          ))}\n        </AnimatePresence>\n      </span>\n    </span>\n  );\n}\n",
      "type": "registry:ui"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Preço, placar ou contador que muda ao vivo girando como rolo de caça-níquel",
      "evite": "Número que só apura ao entrar na tela: count-up; palavra de botão trocando, text-morph"
    }
  },
  "categories": [
    "texto",
    "numero",
    "preco",
    "contador",
    "slot"
  ],
  "type": "registry:ui"
}