Elementos
Collapsible
Um collapsible é uma região cujo conteúdo expande e recolhe: detalhes sob um resumo, um “mostrar mais”, uma seção de configurações avançadas. Ele renderiza sempre os filhos e, depois deles, seu content enquanto open. O app é dono de open e do gatilho que o alterna (um dos filhos), e a aparência é do app: um Collapsible não tem gatilho, seta nem rótulo próprios. Com reveal, o conteúdo abre e fecha com movimento: a altura da sua região vai de zero até a do próprio conteúdo, com efeito de mola, e volta, e o que vem depois do collapsible se move junto.
import { type JSX, mount, signal, Text, View } from "nsh";
import { Collapsible, Switch } from "nsh/base";
import { desktop, focusRing, hoverFill, Log, Panel, size, Split, ui } from "./palette";
// Each section: a summary row, the app's trigger (it says whether it is
// expanded to screen readers), and details the collapsible reveals while the
// app has it open: its height springs open and shut (`reveal`), and the
// sections below move with it. The chevron turns with a transition of the
// app's. One inset per card, leading and trailing: the summary's chevron
// lane is as wide as the turned chevron, so it ends where the values below
// it end.
// The pointer's hover and the keyboard's focus ring come from the palette;
// the reveal, the chevron and the switch stay still with reduced motion.
const pad = desktop ? "px-3" : "px-4";
function Section(props: { label: string; detail: string; open: boolean; onToggle: () => void; content: JSX.Element }) {
return (
<Collapsible open={props.open} reveal content={props.content}>
<View
role="button"
accessibilityState={{ expanded: props.open }}
onPress={props.onToggle}
hoverStyle={hoverFill()}
focusStyle={focusRing()}
class={`flex-row items-center gap-3 ${pad} active:opacity-70`}
style={{ minHeight: size.row + 8 }}
>
<View style={{ flex: 1, gap: 2 }}>
<Text style={{ fontSize: size.label, fontWeight: "500", color: ui().text }}>{props.label}</Text>
<Text style={{ fontSize: size.detail, color: ui().muted }}>{props.detail}</Text>
</View>
<View class="h-5 w-2 items-center justify-center transition-transform duration-150 motion-reduce:transition-none" style={{ rotate: props.open ? "90deg" : "0deg" }}>
<Text style={{ fontSize: 18, color: ui().muted }}>›</Text>
</View>
</View>
</Collapsible>
);
}
const USAGE: [string, string][] = [
["Photos", "120 GB"],
["Apps", "54 GB"],
["System", "38 GB"],
];
function App() {
const storage = signal(true);
const advanced = signal(false);
const originals = signal(false);
const events = signal<string[]>([]);
const log = (line: string) => events.set([line, ...events()].slice(0, 4));
const toggle = (name: string, open: { (): boolean; set: (v: boolean) => void }) => () => {
open.set(!open());
log(`${name} → ${open() ? "open" : "closed"}`);
};
const line = () => <View style={{ height: 1, marginLeft: desktop ? 12 : 16, backgroundColor: ui().line }} />;
return (
<View style={{ flex: 1, backgroundColor: ui().page, padding: 20, paddingTop: 24, gap: 14 }}>
<Text style={{ fontSize: 22, fontWeight: "700", color: ui().text }}>collapsible</Text>
<Text style={{ color: ui().muted }}>{desktop ? "Click a summary, or Tab to it and press Space" : "Tap a summary to show its details"}</Text>
<Split
gap={14}
inspector={
<>
<Panel title="open">
<Text style={{ fontSize: 13, color: ui().text }}>
Storage {storage() ? "open" : "closed"} · Advanced {advanced() ? "open" : "closed"}
</Text>
<Text style={{ fontSize: 12, color: ui().muted }}>Keep originals {originals() ? "on" : "off"}: kept while collapsed</Text>
</Panel>
<Log title="onPress (trigger) → open" lines={events()} minHeight={92} />
</>
}
>
<View style={{ ...ui().card, borderRadius: 16, overflow: "hidden" }}>
<Section
label="Storage"
detail="212 GB of 256 GB used"
open={storage()}
onToggle={toggle("Storage", storage)}
content={
<View class={`${pad} pb-2`}>
{USAGE.map(([name, value]) => (
<View class="flex-row items-center" style={{ minHeight: size.rowSm }}>
<Text style={{ flex: 1, fontSize: size.label, color: ui().muted }}>{name}</Text>
<Text style={{ fontSize: size.label, color: ui().muted, fontVariant: ["tabular-nums"] }}>{value}</Text>
</View>
))}
</View>
}
/>
{line()}
<Section
label="Advanced"
detail="Options most people leave alone"
open={advanced()}
onToggle={toggle("Advanced", advanced)}
content={
<Switch
checked={originals()}
onChange={({ checked }) => {
originals.set(checked);
}}
class={`flex-row-reverse items-center justify-between gap-3 ${pad} pb-3 active:opacity-70`}
hoverStyle={hoverFill()}
focusStyle={focusRing()}
trackClass={`${desktop ? "w-9" : "w-12"} rounded-full p-0.5 transition-colors motion-reduce:transition-none`}
trackStyle={originals() ? ui().accentFill : ui().inset}
thumbClass={desktop ? "size-4 rounded-full transition-transform motion-reduce:transition-none checked:translate-x-4" : "size-5.5 rounded-full transition-transform motion-reduce:transition-none checked:translate-x-5"}
thumbStyle={originals() ? { backgroundColor: ui().onAccent } : ui().raised}
>
<Text style={{ flex: 1, fontSize: size.label, color: ui().text }}>Keep originals</Text>
</Switch>
}
/>
</View>
</Split>
</View>
);
}
mount(App);use nsh_base::{collapsible, theme};
use nsh_core::{AccessibilityState, prelude::*};
fn storage() -> impl IntoElement {
let open = signal(false);
collapsible()
.open(open)
.reveal(true)
.gap_2()
.child(
view()
.role(AccessibilityRole::Button)
.accessibility_state(move || AccessibilityState {
expanded: Some(open.get()),
..AccessibilityState::default()
})
.on_press(move || open.update(|o| *o = !*o))
.flex_row()
.items_center()
.justify_between()
.child(text("Storage"))
.child(text("›").transition_transform().rotate(move || {
if open.get() { deg(90.0) } else { deg(0.0) }
})),
)
.content(text("Photos 120 GB · Apps 54 GB · System 38 GB").text_color(move || theme().muted_foreground))
}import { mount, signal, Text, View } from "nsh";
import { Collapsible } from "nsh/base";
function App() {
const open = signal(false);
return (
<Collapsible
open={open()}
reveal
class="gap-2"
content={<Text class="text-muted-foreground">Photos 120 GB · Apps 54 GB · System 38 GB</Text>}
>
<View
role="button"
accessibilityState={{ expanded: open() }}
onPress={() => open.set(!open())}
class="flex-row items-center justify-between active:opacity-70"
>
<Text class="font-medium">Storage</Text>
<Text class={`transition-transform ${open() ? "rotate-90" : ""}`}>›</Text>
</View>
</Collapsible>
);
}
mount(App);Collapsible vem de nsh/base, o crate nsh-base em Rust. O valor pertence ao app: o gatilho alterna open, e o collapsible mostra o valor que o app passa. Em Rust, collapsible() cria um com um setter por prop (.open(..), .reveal(..), .content(..)), os métodos de estilo tipados para a região e .child(..) para o que aparece sempre.
#Props
| Prop | Rust | Tipo | Padrão | Descrição |
|---|---|---|---|---|
open |
.open(..) |
boolean |
false |
Expandido: o content está na árvore, depois dos filhos. O app é dono do valor. |
reveal |
.reveal(..) |
boolean |
false |
Abre e fecha com uma revelação: o conteúdo fica em uma região que o recorta, e a altura dela vai de zero até a do próprio conteúdo, com efeito de mola, quando open é ativado, e volta quando é desativado, com amortecimento crítico (cerca de 265 ms, sem overshoot). O que vem depois do collapsible se move junto, e o conteúdo permanece na árvore até que a região tenha fechado. Com movimento reduzido, abre e fecha de imediato. A região fica no layout também quando fechada, com altura zero, então um gap do collapsible também vem antes dela. |
content |
.content(..) |
JSX.Element |
nenhum | O que expande. É criado uma vez e mantido enquanto recolhido, então o que está dentro preserva seu estado (o texto de um campo, a posição de rolagem, um switch) de uma abertura para a outra. |
children |
.child(..) |
JSX.Element |
nenhum | O que aparece em ambos os casos: um resumo, o gatilho que alterna open. |
class, style |
métodos de estilo | string, StyleProp<ViewStyle> |
nenhum | A região ao redor dos filhos e do conteúdo (gap-2 os espaça). |
#Eventos
Um collapsible não reporta nada por conta própria: o gatilho é do app, e o seu toque (onPress do View com role="button") é onde o app alterna open.
#Partes
| Parte | Dentro de | Estilizada com |
|---|---|---|
| A região | class, style |
|
| Os filhos | a região, primeiro | seus próprios elementos |
| A região da revelação | a região, depois dos filhos, com reveal |
nenhum: ela recorta o conteúdo e assume a altura dele |
| O conteúdo | a região, depois dos filhos (na região da revelação com reveal), enquanto open |
seus próprios elementos (content) |
Sem reveal, o conteúdo aparece e some de imediato, e cada plataforma refaz o layout da região quando ele chega ou sai. Com reveal, a mudança é uma animação de layout do commit que altera open (como LayoutAnimation.configureNext, executada nativamente, então nenhum JavaScript roda enquanto ela se move): a região da revelação cresce de zero até a altura do conteúdo e encolhe de volta, e os frames de tudo o que a mesma mudança move, entre eles as views depois do collapsible, se movem junto. Uma transição do app acompanha: a seta do gatilho gira (transition-transform), e o conteúdo pode surgir com um fade usando suas próprias classes.
#Acessibilidade
- A região não é um elemento próprio para leitores de tela: seus filhos e seu conteúdo são lidos como são.
- O gatilho informa se a região está expandida: dê a ele
accessibilityState={{ expanded: open }}e um papel de botão (role="button"em umView), e os leitores de tela anunciam “expandido” ou “recolhido” junto com o rótulo dele. - No macOS e na web, o gatilho é uma parada do foco do teclado quando recebe toques: Tab chega até ele, e Espaço e Return alternam a região.
Veja Acessibilidade para rótulos, papéis e anúncios em geral.
#Notas de plataforma
- Toda plataforma mostra o conteúdo depois dos filhos enquanto
open, e o deixa fora do layout caso contrário. - Com
reveal, toda plataforma anima a altura da região com mola em seu próprio animador (iOS, Android, macOS, Windows, Linux, GPUI e a web), e a abre e fecha de imediato enquanto o sistema pede movimento reduzido. - iOS, Android e Mac Catalyst: o toque no gatilho é um tap. Desktops (macOS, Windows, Linux, GPUI) e a web: um clique, e Espaço ou Return no gatilho focado no macOS e na web.