Elementos
HoverCard
A hover card mostra uma prévia do que o gatilho indica, sem sair da página: o perfil por trás de uma menção, a página por trás de um link, a cotação por trás de um ticker. Em desktops e em navegadores desktop, ele abre quando o ponteiro permanece sobre o gatilho por openDelay (600 ms) ou assim que o foco do teclado chega ao gatilho. Ele permanece aberto enquanto o ponteiro se move do gatilho para o card e de volta, e enquanto o foco do teclado está no gatilho ou em um link ou botão do card, de modo que tudo no card pode ser usado tanto com o ponteiro quanto com o teclado. Ele fecha closeDelay (300 ms) depois que o ponteiro saiu de ambos e o foco não está em nenhum deles. Escape e um toque fora o fecham imediatamente. Em celulares e tablets, um toque no gatilho abre e fecha o card, e um toque fora o fecha.
import { type JSX, mount, signal, Text, View } from "nsh";
import { HoverCard, type OpenChangeReason } from "nsh/base";
import { desktop, focusRing, Inspector, Log, PopIn, type PopupSide, Segmented, Stage, tint, ui, wide } from "./palette";
type Placement = PopupSide;
/** A card's surface, the look the app gives it; `PopIn` brings it in from the trigger's side. */
const surface = (width: number) => ({ ...ui().card, width, borderRadius: 12, padding: 14, gap: 10 });
/** The popup's box fades on its way out (its ending class, kept while the transition runs). */
const exit = { popupClass: "transition-opacity duration-150 ease-in motion-reduce:transition-none", popupEndingClass: "opacity-0" };
function App() {
const openDelay = signal(600);
const closeDelay = signal(300);
const placement = signal<Placement>("bottom");
const events = signal<string[]>([]);
const following = signal(false);
const price = signal(227.52);
let timer: ReturnType<typeof setInterval> | undefined;
const log = (name: string) => ({ open, reason }: { open: boolean; reason: OpenChangeReason }) =>
events.set([`${name} ${open ? "opened" : "closed"} · ${reason}`, ...events()].slice(0, 6));
const shared = () => ({ ...exit, openDelay: openDelay(), closeDelay: closeDelay(), placement: placement(), offset: 8, margin: 12 });
// Running text in a wrapping row: one piece per word, so a line breaks
// between words, and the row's gap is the space between them.
const words = (s: string) => s.split(" ").map((w) => <Text style={{ fontSize: 15, color: ui().text }}>{w}</Text>);
// A mention: the person's card, with a button that works because the
// pointer can move into the card.
const mention = () => (
<HoverCard {...shared()} onOpenChange={log("@ada")} trigger={
<View role="link" onPress={() => events.set(["onPress /people/ada", ...events()].slice(0, 6))} focusStyle={focusRing(1)} style={{ borderRadius: 4, borderWidth: 1, borderColor: "transparent", paddingHorizontal: 2, marginHorizontal: -3 }} hoverStyle={{ backgroundColor: tint(ui().accent, 0.14) }}>
<Text style={{ fontSize: 15, fontWeight: "600", color: ui().accent }}>@ada</Text>
</View>
}>
<PopIn side={placement()} style={surface(260)}>
<View style={{ flexDirection: "row", alignItems: "center", gap: 10 }}>
<View style={{ width: 40, height: 40, borderRadius: 20, backgroundColor: tint(ui().accent, 0.18), alignItems: "center", justifyContent: "center" }}>
<Text style={{ fontSize: 15, fontWeight: "600", color: ui().accent }}>AL</Text>
</View>
<View style={{ flex: 1, gap: 2 }}>
<Text style={{ fontSize: 15, fontWeight: "600", color: ui().text }}>Ada Lovelace</Text>
<Text style={{ fontSize: 12, color: ui().muted }}>Analyst · Engines</Text>
</View>
</View>
<Text style={{ fontSize: 13, lineHeight: 18, color: ui().text }}>Writes the first programs for the Analytical Engine.</Text>
<View
onPress={() => following.set(!following())}
style={{ height: 30, borderRadius: 8, alignItems: "center", justifyContent: "center", ...(following() ? ui().raised : ui().accentFill), transitionProperty: "background-color", transitionDuration: 150 }}
>
<Text style={{ fontSize: 13, fontWeight: "500", color: following() ? ui().text : ui().onAccent }}>{following() ? "Following" : "Follow"}</Text>
</View>
</PopIn>
</HoverCard>
);
// A link with a preview of the page behind it.
const preview = () => (
<HoverCard {...shared()} onOpenChange={log("taffy")} trigger={
<View role="link" onPress={() => events.set(["onPress github.com/DioxusLabs/taffy", ...events()].slice(0, 6))} focusStyle={focusRing(1)} style={{ borderBottomWidth: 1, borderBottomColor: tint(ui().accent, 0.4) }}>
<Text style={{ fontSize: 15, color: ui().accent }}>Taffy</Text>
</View>
}>
<PopIn side={placement()} style={{ ...surface(280), padding: 0, gap: 0, overflow: "hidden" }}>
<View style={{ height: 64, backgroundImage: "linear-gradient(135deg, #3b82f6, #8b5cf6)" }} />
<View style={{ padding: 12, gap: 4 }}>
<Text style={{ fontSize: 11, color: ui().faint }}>github.com</Text>
<Text style={{ fontSize: 14, fontWeight: "600", color: ui().text }}>taffy: flexbox, grid and block layout</Text>
<Text style={{ fontSize: 12, color: ui().muted }}>A high-performance UI layout library written in Rust.</Text>
</View>
</PopIn>
</HoverCard>
);
// A ticker whose quote ticks while its card is open.
const ticker = () => (
<HoverCard
{...shared()}
onOpenChange={log("$AAPL")}
onOpen={() => (timer = setInterval(() => price.set(Math.round((price() + (Math.random() - 0.48) * 0.6) * 100) / 100), 900))}
onClose={() => clearInterval(timer)}
trigger={
<View focusable focusStyle={focusRing(1)} style={{ paddingHorizontal: 8, height: 26, borderRadius: 13, justifyContent: "center", borderWidth: 1, borderColor: tint(ui().up, 0.3), backgroundColor: tint(ui().up, 0.1) }}>
<Text style={{ fontSize: 13, fontWeight: "600", color: ui().up }}>$AAPL ▲</Text>
</View>
}
>
<PopIn side={placement()} style={surface(220)}>
<Text style={{ fontSize: 12, color: ui().muted }}>Apple Inc. · live</Text>
<Text style={{ fontSize: 26, fontWeight: "600", color: ui().text, fontVariant: ["tabular-nums"] }}>{price().toFixed(2)}</Text>
<Text style={{ fontSize: 13, color: price() >= 224.1 ? ui().up : ui().down, fontVariant: ["tabular-nums"] }}>
{price() >= 224.1 ? "+" : ""}
{(price() - 224.1).toFixed(2)} today
</Text>
</PopIn>
</HoverCard>
);
const stage = (): JSX.Element => (
<View style={{ gap: 18, alignItems: "flex-start" }}>
<View style={{ flexDirection: "row", flexWrap: "wrap", alignItems: "center", columnGap: 4, rowGap: 6 }}>
{words("Ask")}
{mention()}
{words("about the layout engine,")}
{/* The period stays with the link. */}
<View style={{ flexDirection: "row", alignItems: "center" }}>
{preview()}
{words(".")}
</View>
</View>
<View style={{ flexDirection: "row", alignItems: "center", gap: 8 }}>
{words("Today:")}
{ticker()}
</View>
</View>
);
const controls = () => (
<>
<Segmented label="openDelay" options={[0, 300, 600, 1200]} value={openDelay()} onChange={(v) => openDelay.set(v)} />
<Segmented label="closeDelay" options={[0, 300, 1000]} value={closeDelay()} onChange={(v) => closeDelay.set(v)} />
<Segmented label="placement" options={["top", "bottom", "left", "right"] as Placement[]} value={placement()} onChange={(v) => placement.set(v)} />
</>
);
const changes = () => <Log title="onOpenChange({ open, reason })" lines={events()} minHeight={110} />;
return (
<View style={{ flex: 1, backgroundColor: ui().page, padding: 20, paddingTop: 24, gap: 14 }}>
<Text style={{ fontSize: 22, fontWeight: "700", color: ui().text }}>hover card</Text>
<Text style={{ color: ui().muted }}>
{desktop ? "Rest the pointer on a mention, a link or a ticker, then move into the card" : "Tap a mention, a link or a ticker; tap outside to close"}
</Text>
{() =>
wide() ? (
<View style={{ flex: 1, flexDirection: "row", gap: 16 }}>
<Stage gap={24}>{stage()}</Stage>
<Inspector>
{controls()}
{changes()}
</Inspector>
</View>
) : (
<>
{controls()}
<View style={{ flex: 1, minHeight: 220, justifyContent: "center" }}>{stage()}</View>
{changes()}
</>
)
}
</View>
);
}
mount(App);HoverCard de nsh/base não desenha nada por conta própria: o gatilho é o seu elemento, e o popup e seu conteúdo também são seus.
use nsh_base::hover_card;
use nsh_core::prelude::*;
fn mention() -> impl IntoElement {
hover_card()
.offset(px(8.0))
.popup_class("w-72 gap-2 rounded-xl border border-border bg-popover p-4 shadow-lg")
.trigger(text("@ada").text_color(rgb(0x2563eb)))
.child(text("Ada Lovelace").font_weight(FontWeight::SEMIBOLD))
.child(text("Writes the first programs for the Analytical Engine."))
}import { Text } from "nsh";
import { HoverCard } from "nsh/base";
function Mention() {
return (
<HoverCard
offset={8}
popupClass="w-72 gap-2 rounded-xl border border-border bg-popover p-4 shadow-lg"
trigger={<Text class="text-blue-600">@ada</Text>}
>
<Text class="font-semibold">Ada Lovelace</Text>
<Text>Writes the first programs for the Analytical Engine.</Text>
</HoverCard>
);
}O gatilho mantém seu próprio papel, seus toques e sua aparência: uma view com role="link" e seu próprio onPress continua indo para onde iria ao ser tocada, e o card apenas adiciona uma prévia a ela. O conteúdo é criado a cada abertura do card, portanto pode carregar o que exibe nesse momento. Em celulares e tablets, onde um toque abre o card, o gatilho informa aos leitores de tela se o seu card está aberto. Em uma Toolbar, o gatilho pode ser um dos itens; o que o card exibe não é: seus botões e links mantêm seus próprios pontos de Tab, e o disabled da Toolbar não interfere neles.
#Atrasos
openDelay evita que o card apareça de repente quando o ponteiro cruza o gatilho a caminho de outro lugar; closeDelay dá ao ponteiro tempo para atravessar o espaço entre o gatilho e o card. Ambos são em milissegundos. O ponteiro e os atrasos são acompanhados nativamente, de modo que repousar sobre um gatilho e se mover entre ele e o card não executa nenhum código seu até que o card abra ou feche. Um openDelay de Infinity deixa a abertura a cargo do app (e de um toque em uma tela sensível ao toque); um closeDelay de Infinity deixa o fechamento a cargo de Escape, de um toque fora e do app.
<HoverCard openDelay={300} closeDelay={150} trigger={<Text>AAPL</Text>}>
<Quote symbol="AAPL" />
</HoverCard>
#Estado de abertura
Sem open, o card mantém seu próprio estado, começando em defaultOpen. Com open, o app é o dono do estado: altere-o em onOpenChange({ open, reason }), que informa cada pedido para abrir ou fechar com o seu motivo: "hover" (o ponteiro), "focus" (o foco do teclado), "triggerPress" (um toque em uma tela sensível ao toque), "pressOutside" ou "cancel" (Escape ou voltar).
const open = signal(false);
<HoverCard open={open()} onOpenChange={(e) => open.set(e.open)} trigger={<Text>@ada</Text>}>
<Profile id="ada" />
</HoverCard>
#Entrada e saída
Um hover card entra e sai com as suas transições, como um Popover. popupStartingClass é a aparência do popup no primeiro quadro, e as classes transition-* de popupClass o levam até a sua própria aparência. popupEndingClass é a aparência dele depois de fechado: o card permanece, sem receber o ponteiro, enquanto essas transições são executadas, depois some, e onClose vem em seguida. Repousar sobre o gatilho de novo enquanto ele está saindo o traz de volta. Quando o usuário pede menos movimento, ele aparece e some imediatamente.
<HoverCard
popupClass="rounded-xl bg-popover p-4 shadow-lg transition-all duration-150 ease-out"
popupStartingClass="opacity-0 scale-95"
popupEndingClass="opacity-0 scale-95"
trigger={<Text>@ada</Text>}
>
<Profile id="ada" />
</HoverCard>
Por padrão, ele aparece abaixo do gatilho (placement, align), do outro lado quando não há espaço, e permanece dentro da área segura. onPosition({ placement, bounds, available }) informa para onde ele foi.
#Props
| Prop | Rust | Tipo | Padrão | Descrição |
|---|---|---|---|---|
open |
.open(..) |
boolean |
nenhum | Aberto, controlado pelo app. |
defaultOpen |
.default_open(..) |
boolean |
false |
Aberto inicialmente, sem open. |
openDelay |
.open_delay(..) |
number |
600 |
Milissegundos em que o ponteiro permanece sobre o gatilho, ou o foco permanece nele, antes de abrir; Infinity: nunca abre sozinho. |
closeDelay |
.close_delay(..) |
number |
300 |
Milissegundos em que o ponteiro está longe do gatilho e do card, com o foco em nenhum dos dois, antes de fechar; Infinity: nunca fecha sozinho. |
placement |
.placement(..) |
"top" | "bottom" | "left" | "right" |
"bottom" |
O lado do gatilho em que ele aparece. |
align |
.align(..) |
"start" | "center" | "end" |
"center" |
Como ele se alinha ao gatilho ao longo desse lado. |
offset |
.offset(..) |
number |
0 |
O espaço entre o gatilho e o card. |
margin |
.margin(..) |
number |
0 |
A distância que ele mantém das bordas da área segura. |
popupClass, popupStyle |
.popup_class(..), .popup_style(..) |
string, StyleProp<ViewStyle> |
nenhum | A aparência do popup, o card em que o conteúdo está. |
popupStartingClass, popupStartingStyle |
.popup_starting_class(..), .popup_starting_style(..) |
string, StyleProp<ViewStyle> |
nenhum | A aparência do popup no primeiro quadro, sobreposta à sua própria: suas transições partem dela. |
popupEndingClass, popupEndingStyle |
.popup_ending_class(..), .popup_ending_style(..) |
string, StyleProp<ViewStyle> |
nenhum | A aparência do popup depois de fechado, sobreposta à sua própria: ela permanece enquanto suas transições são executadas. |
trigger |
.trigger(..) |
JSX.Element |
nenhum | O que ele mostra em prévia; o popup é posicionado em relação a ele. |
children |
.child(..) |
JSX.Element |
nenhum | O conteúdo, criado a cada abertura. |
#Eventos
| Evento | Rust | Descrição |
|---|---|---|
onOpenChange |
.on_open_change(|e| ..) |
Pede para abrir ou fechar, informando o motivo: "hover", "focus", "triggerPress", "pressOutside" ou "cancel". |
onOpen |
.on_open(|| ..) |
Ele é exibido. |
onClose |
.on_close(|| ..) |
Ele sumiu, após a sua saída; também quando o app o fechou. |
onPosition |
.on_position(|e| ..) |
O popup foi posicionado: placement (o lado em que ele foi), bounds (seu frame), available (o espaço disponível nesse lado). |
#Acessibilidade
Um hover card acrescenta algo ao seu gatilho: o gatilho mantém seu papel e seu rótulo, e o que ele abre ou faz ao ser tocado continua igual. Usuários de teclado recebem o card quando o foco repousa sobre o gatilho, e Escape o fecha. O card não recebe foco por conta própria, então Tab segue adiante a partir do gatilho como antes. Links e botões no card recebem o foco como em qualquer outro lugar, e o card permanece aberto enquanto um deles o tem; o que é importante no card também deve estar acessível a partir da página para a qual o gatilho leva.