Skip to content

1.19.0

Choose a tag to compare

@github-actions github-actions released this 07 Oct 11:40
· 20 commits to main since this release

Breaking changes

  • A Transfer's lists are narrowed just after a letter reaches the search box, not in the same render. Each keystroke filtered the list and drew the rows it kept before the letter could appear, and every row of both lists, each a full Checkbox, was drawn again on every keystroke and every tick. The box now shows the letter at once and the list follows a moment later, and a tick redraws only the row it changed. A test that checks a row is gone straight after typing should wait for it to leave, with await expect.element(row).not.toBeInTheDocument() rather than row.query().

  • A TreeSelect's tree is narrowed just after a letter reaches its search box, not in the same render. A keystroke filtered the tree and drew what it kept in the same task, so a short query against a tree of a few thousand nodes, which keeps most of them and opens every branch it kept, held the letter back until all of it was drawn. The box now shows the letter at once and the tree follows a moment later. A test that checks a row is gone straight after typing should wait for it to leave, with await expect.element(row).not.toBeInTheDocument() rather than row.query().

  • A Sparkline's name is on its box rather than on its <svg>. role="img" and the label were on the strip's <svg>, which is only drawn once the strip has measured itself, so a server render named nothing and a crawler or a reader without JavaScript got a list of numbers with nothing saying what they were. The box that holds the drawing is in the HTML from the start and carries both now. A test that found the strip by its role and read it as the <svg> should take the <svg> inside it. A Sparkline given width as a number also no longer measures its box, and draws once instead of twice when it mounts.

  • A legend with showValue keeps room for its numbers while no column is active. The number beside each series' name appeared only while the pointer was over the plot, so every row grew as it entered and shrank as it left: a legend under the plot pushed the page below it down and back up, a layout shift of 0.0235 each way on a five-series chart, and one beside the plot took its width from the plot. Each row is now as wide as the widest number its series can show from the start, with the number hidden until a column is active, and the legend no longer changes size. The rows are wider at rest than they were, so a legend under the plot may take another line; a layout that relied on the narrower rows should allow for it.

  • A StreamingText answer goes back to plain text once its stream has ended. Every word that streamed in stayed an element of its own for good, so a long chat session kept one per word of every answer: fifteen thousand for fifty answers. Once streaming is off and the last word has faded in, the .neba-stream-word elements are gone and the answer is one run of text, which looks the same. A test that looked for .neba-stream-word after a stream ended should look while streaming is on, or read the text. A finished word's fade also no longer stays on it as a held animation.

Where the bytes went

What you import 1.18.1 1.19.0
Button 5.0 kB 5.0 kB
Chip 3.4 kB 5.5 kB
LineChart 17.1 kB 18.1 kB
CodeBlock 5.8 kB 5.9 kB
Image 9.0 kB 9.5 kB
Gallery 12.3 kB 12.8 kB
DataTable 65.4 kB 34.9 kB
CommandPalette 38.7 kB 1.9 kB
InlineCitation 31.7 kB 6.7 kB
a whole page shell 30.5 kB 13.8 kB
12 components — a typical app 74.5 kB 75.6 kB
12 components, with Korean 78.7 kB 79.8 kB
25 components — a large one 122.2 kB 123.8 kB
all exports 304.3 kB 317.9 kB
neba/styles.css 26.4 kB 27.2 kB

Each figure is what a page downloads before it draws, gzipped, with react and react-dom external. The four rows that fell are the parts of Base UI a page used to carry for something closed: a Sidebar's drawer, which a desktop page never opens, a paging DataTable's rows-per-page Select, which a scrolling table never draws, a CommandPalette's whole dialog, and an InlineCitation's preview card. Each is now a chunk of its own, fetched when it can first be needed.

A Chip alone grew 2.1 kB for href and render: the safe rel and href rules and the words a link that opens a new tab ends with, which every link in the library carries, and Base UI's useRender, which a page with a Button on it already has. An Image and a Gallery grew 0.5 kB for the shared observer a Skeleton now holds its sweep still with while it is off screen, and the helper that runs a React 19 ref's cleanup. A LineChart grew 1.0 kB for the hidden table's rows added in runs, the marks laid out once per layout, the transition it draws in after hydration and the room a legend keeps for showValue. The two apps grew 1.1 and 1.6 kB, spread across what they import: useToastActions, a Chip's link support, the sampling of labels that are elements, which a Select and a legend share, a tab bar that binds the wheel only while it overflows, a Select that can be opened from outside and the ref helper.

All exports grew 13.6 kB. About 3.6 kB of that is the code of the new chunks, which a page that imports everything counts as well, and much of the rest is those chunks being compressed as separate files rather than as one. Class strings written as concatenations rather than as an array and a join took 0.1 to 0.3 kB back off every scenario that imports more than one component. The stylesheet grew 0.8 kB for the server-rendered tab indicator, the reduced-transparency surfaces, the text effects' final text without a script, AnimateLighting's composited ring and the rules that hold a waiting entrance in place.

Added

  • autoComplete on Select and Combobox, so a browser's autofill can fill them in with the rest of a form: autoComplete="country" on a country list. It is written on the hidden input that submits the value, and a filled-in value that matches an option's value or label chooses that option. A Combobox's own text input keeps autocomplete="off", and a multiple Combobox takes no autofill.

  • name on Transfer, so a form submits what is on the right. Each chosen value is a hidden input under that name, in the order of value: FormData.getAll(name) reads them all, and a Form's onSubmit is handed them as an array. Nothing is submitted while nothing is chosen or while the Transfer is disabled.

  • href, target and rel on Chip, so a chip that leads somewhere, a tag to its page or a filter that is a URL, is a link a crawler can follow and a reader can open in a new tab. The label becomes an <a> that looks and focuses like the pressable label, and the onDelete button stays beside it rather than inside it. A link that opens in a new tab gets noopener noreferrer merged into its rel and says that it opens a new tab, as every other link in the library does. A selected link chip is marked aria-current="true", and a disabled chip is not a link.

  • NebaProvider warns in a development build when the scheme on <html> at mount is not the one it resolves. The provider writes data-theme only once it has mounted, so a page without colorSchemeScript(), or with one called with another storageKey or defaultColorScheme, is drawn in one scheme and changes to the other as it mounts. Call colorSchemeScript() in <head> with the provider's options. A page with no scheme of its own and a provider on system count as a match.

  • initialWidth on every chart, a GaugeChart and a Sparkline included. A chart is laid out in pixels and a server has nothing to measure, so a server-rendered chart is an empty box of the right height until the page has hydrated. Given a width in pixels, the chart is drawn at it on the server and while the page hydrates, so the drawing is in the first paint and in the HTML a crawler reads, and the measured width replaces it afterwards. It makes the server's HTML larger by the drawing: about 10 kB for a BarChart of a dozen categories, close to 400 kB for a 1,000-point ScatterChart. It is ignored when height is a CSS length, and left out nothing changes.

  • NavigationMenuItem warns in a development build when it has both an href and children. An item with children opens a panel and is drawn as a button, so the href went nowhere and nothing on the screen said so. Put that destination in the panel as a NavigationMenuLink, or drop the children to make the item a link. A production build says nothing.

  • useToastActions(): add, close, update and promise without the list of toasts. useToast also returns toasts, which is a subscription, so every component that raised toasts through it rendered again whenever any toast was added, updated or closed. A component that only raises toasts can call useToastActions instead and is never drawn again for that. useToast is unchanged, and the ToastActions type is exported.

  • CommandPaletteSlot, the type of the keys a CommandPalette's classNames takes. It was declared beside the component but not exported, so a slots object built apart from the element had no type to name. Import it with import type { CommandPaletteSlot } from 'neba'.

  • render on Chip, so a chip with an href can be your router's Link. A link chip drew a plain <a>, which reloads the page; render={<Link to="/tags/react" />} now moves without a reload, as it already does on BreadcrumbItem, TextLink and Button. Keep the href on the chip: it goes through to the Link with target, the merged rel and aria-current, and the onDelete button stays beside the link. A Chip imported on its own is 1.7 kB larger gzipped for it; a page that also draws a Button already carries that code.

  • open, defaultOpen and onOpenChange on Select, as Combobox, TreeSelect and the pickers already have. defaultOpen starts the list open, open with onOpenChange controls it, and onOpenChange is called with the new state whenever the reader opens or closes it.

  • Every component's classNames slot type is exported from the package. Fifteen were declared but left out of their barrels, so a caller writing classNames in a variable of its own could only name the type as NonNullable<Props['classNames']>: CheckboxSlot, CheckboxGroupSlot, ComboboxSlot, DialogSlot, FloatingActionButtonSlot, NumberFieldSlot, RadioSlot, RadioGroupSlot, SelectSlot, SliderSlot, SwitchSlot, TableSlot, TextFieldSlot, ToastSlot and TourSlot.

Changed

  • A Combobox filters its list only when the query, the options or filter change. The functions it handed Base UI were new on every render, so every render of anything above it, a keystroke in another field of the same form included, ran the filter over every option again. A filter of your own is no longer called on a render that changes none of those, as long as it is the same function from one render to the next.

  • A Select whose labels are elements lays out only the ones that could be the widest, as it already did for string labels. A label that was not a string was always drawn into the hidden box that holds the trigger's width, so a list of 250 countries with a flag <img> in each label fetched all 250 flags before it was opened and carried them in the server's HTML. The text among an element's children is now ranked like a string. An element with no text in it, such as a picture on its own, is still always laid out, and an icon or a flag beside the text is taken to be the same size in every option.

  • A Select no longer renders every option again each time it renders. Once the trigger has had the focus, the list stays mounted, hidden, so that the first press opens it at once, and every option in it was drawn again on each later render: a controlled Select of 250 countries in a form drew 250 rows on every keystroke in another field. The rows are now kept until items, size or classNames.item changes.

  • A ColorPicker does less on each pointer move of a drag. Every move across the square or a rail parsed all sixteen swatches again to work out which one to tick. They are now parsed once per swatches list; pass the same array between renders, as the default does, to keep it that way.

  • A SegmentedButton and a FloatingBottomNavigation no longer lay the page out each time their parent renders. Both measured the chosen item again on every new children, which is every render of the component above them, to place a tile that had not moved. They now measure when the value changes or when an item itself does: a label that changes size, an item added or removed, or the set reordered.

  • A component given a locale renders once when a server-rendered page hydrates, not twice. Every component that writes a number or a date rendered a second time once hydration was over, whether or not anything could change; with locale, or defaults.locale on a NebaProvider, that second render is gone. On a page of 400 Statistic and Meter, the work after hydration fell from about 6.9 ms to 1.6 ms. A component with no locale still switches from en-US to the reader's language after hydration, as before.

  • A page with a Sidebar no longer downloads the drawer it becomes on a narrow screen until it needs it. The drawer is a Base UI dialog, and it was two thirds of a page shell, carried by every page with a sidebar, desktop included: PageLayout, Header, Footer, Sidebar, SidebarTrigger and AppLogo went from 30.6 kB to 13.8 kB gzipped. The drawer is fetched as soon as the sidebar collapses, which on a phone is right after hydration, or when a pointer or the focus reaches a SidebarTrigger; a press that comes before it arrives opens the drawer when it does.

  • A chart writes its paths to a hundredth of a pixel. Every coordinate in a line, an area, a bar, a mark and an arc was written with all seventeen digits a float prints, so a 3,000-point line was a 110 kB d attribute in the server's HTML; it is 39 kB now, and a smoothed area of the same series went from 531 kB to 215 kB. Nothing on screen moves. A test that compared a path string written from fractional coordinates sees the rounded numbers.

  • A ScatterChart and a TimelineChart no longer lay out their marks on the server. Every mark was placed against a plot with no width in the server render and again in the render that hydrates it, and then thrown away when the chart measured itself. Those two renders now skip it, which on a 5,000-point scatter is that many marks less work before the page responds.

  • A chart past 500 points fills its hidden table in at a steady cost per batch. Each idle batch drew every row already in the table again along with its own, so the batches grew longer as the table filled: on a line chart of 3,000 categories under a fourfold CPU slowdown they went from 12 ms to 31 ms, 250 ms in all. A batch now draws only the rows it adds, about 6 ms each and 80 ms in all, and a 5,000-point scatter's table went from 393 ms to 98 ms. The table ends up exactly as before.

  • A server-rendered chart is drawn just after the page hydrates, in a transition, rather than inside the hydration's own task. Every chart on the page measured itself and drew itself before the hydration's task could end, so a dashboard held the main thread for all of them at once: on one of nine charts under a fourfold CPU slowdown the task was 182 to 208 ms, and is 106 to 117 ms now, with the drawing done in slices React can interrupt for input. On React 18 it is the same: 190 to 228 ms before, 102 to 114 ms now. A chart mounted in the browser is still drawn before its first paint, and a resize is now drawn in a transition too, so the drawing may trail a continuous resize by a frame. A test that waits for a hydrated chart's <svg> should retry, as expect.element and vi.waitFor do.

  • A HeatmapChart answers the pointer without drawing every cell again. Each cell the pointer entered formatted, measured and cut the label of every cell on the grid: 16 ms a move on a 40 by 60 grid with valueLabels="all" under a fourfold CPU slowdown, and 27 ms at worst. What a cell draws is now worked out once per layout and only the cells around the pointer are drawn again, 2.6 ms a move and 7 ms at worst. Each cell's <rect> carries data-row and data-index, which the chart's one pointer listener reads.

  • A chart with tooltip.mode: 'item' no longer redraws for every pixel the pointer moves. Over a column it kept the pointer's exact offset and redrew the whole chart each time it changed: 30 one-pixel moves inside one bar of a 365-category BarChart were 32 renders and 214 ms under a fourfold CPU slowdown. It keeps which series the pointer is nearest now, and the same moves draw nothing. The series a reading names is the same as before.

  • A BarChart, a TimelineChart and a LineChart or AreaChart with markers="all" or valueLabels draw less as the crosshair moves. Every bar, span, dot and label was worked out again each time the crosshair reached a new column, for the two that changed. Under a fourfold CPU slowdown a column change went from 7.6 ms to 2.9 ms on a BarChart of 365 categories in three series, from 7.9 ms to 3.0 ms on a LineChart of three 400-point series with every dot and label, and a span change from 4.3 ms to 2.3 ms on a TimelineChart of 1,200 spans.

  • Dragging a run of rows in a DataTable no longer walks every row on each frame. Each row the drag reached looked up where the run began and ended by searching the whole list of displayed rows twice, which on a hundred thousand rows was most of the frame; the arrow keys did the same to find the active row. Both are now a lookup in the positions the table already keeps, and the rows chosen are the same.

  • Typing into a DataTable's search field no longer stalls on a long table. The first key prepared every row for matching before it could filter one, about a hundred milliseconds on a hundred thousand rows, and every key filtered every row before the field showed it. A table with searchable now prepares its rows while the page is idle after it mounts, and the rows follow the query a render behind the field when the table is busy, settling on the same result. A test that typed into the field and read the rows straight away should wait for them, for example with expect.poll.

  • Scrolling a virtual DataTable draws only its rows again. Every scroll across a row boundary drew the whole table again, its search field, every heading and the footer with its page-size control, nearly every frame of a fast scroll. The scroll position now belongs to the body, so the rest of the table is left alone while it scrolls, and what is drawn is the same.

  • A DataTable weighs half what it did unless it pages. Every table carried the Select its footer draws with paging="pages", which was half of its 66.0 kB gzipped; a table that scrolls is now 34.6 kB. A table that pages fetches the Select as it mounts and draws the closed control in its place until it arrives, the same size and with the same label and value, so nothing moves when it takes over. A server sends that stand-in too, so a server render never waits on the Select. A test that opens the page-size control should wait for it to be the Select, which happens just after the table mounts.

  • Pressing Copy on a long CodeBlock no longer draws every line again. The button's label, the announcement and the overflow check are each a render of the block, and every one of them reconciled every line and token of the file; one press was three or four of those. The lines are now kept until something they show changes.

  • Highlight marks text that is not ASCII about three times faster. To ignore accents it folded the whole text one character at a time on every render that marked it, which was 12 ms for 46,000 characters of Korean. It now remembers each character it has folded, and the marks are the same.

  • A grid, quilted or justified Gallery no longer draws every tile again when the window crosses a breakpoint. Only a masonry needs to know its column count while rendering, but every layout asked, so each crossing redrew every tile and every picture in it. Now only a masonry's columns are drawn again, and the other three layouts are left alone.

  • An inline Calendar no longer carries the pickers' trigger and popup classes. Two class strings the pickers share were built with a call a bundler could not drop, so a page that drew only a Calendar carried both. A Calendar alone is 0.1 kB smaller gzipped; nothing it draws changes.

  • A DateRangePicker redraws only the days the band reaches or leaves as the pointer moves. While a range was half chosen, every cell the pointer entered drew the trigger, the popup and every day of both months again, and called shouldDisableDate for all of them: twenty cells crossed were 1,240 calls. Now a move calls it not at all, and takes about half the time. The band looks and moves as before. shouldDisableDate is still asked again each time the picker renders, so a function that reads data of its own sees that data change as before.

  • A CommandPalette adds 1.9 kB to what a page loads before it draws, rather than 38.7 kB. Its dialog and search list are fetched on their own once the page is first idle, and mounted by the first open, so the palette is normally ready by the time a reader presses the key. Added to the twelve-component app, it costs 4.4 kB rather than 12.6 kB. A palette that starts open opens once its sheet has arrived, which on a server-rendered page is after hydration; nothing was drawn for it on the server before either.

  • An Image is not drawn again when its file reports that it loaded a second time. Firefox can fire load after the picture was already read as loaded from the cache, and every Image, and so every Gallery tile, rendered once more for a size it already had.

  • Surfaces turn opaque and drop the backdrop blur when the reader's system asks for reduced transparency. The setting was ignored, so every sheet stayed translucent over a blurred page, and the blur is also what costs the most while a page with many surfaces scrolls. Each sheet and fill is now laid on --neba-surface, the colour it has over a plain page, and so are a text Pill and a Switch's off track, whose wash is all they have to stand on; other washes, hairlines and the scrim behind a modal stay as they are. Chrome and Edge 118 and later read the setting, and nothing changes for a reader who has not turned it on. To turn the blur off for everyone, set --neba-blur: none together with the new --neba-backing: var(--neba-surface) on every theme root, as the design-language page shows: --neba-blur: none alone leaves the sheets see-through.

  • An Animate* starting for the first time no longer forces a layout. Every start rewound the animation through a synchronous style and layout pass, so a page of scroll-triggered entrances paid one each time a section arrived. The first start of a visible, hover or manual effect has nothing to rewind and now costs none; a replay still rewinds as before.

  • A ChatBubble's typing dots and a Skeleton's reduced-motion pulse no longer repaint the page on every frame. Both changed a background colour for as long as they ran; they fade on opacity now, which the browser hands to the compositor. They look the same.

  • AnimateLighting no longer repaints the page on every frame. The arc travelled on an animated custom property, which restyled the element and repainted a blurred gradient on the main thread for as long as the light was on. It now turns on rotate, which the compositor runs, and looks the same. The light is drawn by an aria-hidden span added as the first child of the root, in place of ::before; a stylesheet or a test that counted on the caller's content being the first child should skip .neba-lighting-ring. Firefox 113 to 127, which have no @property, now show the light travelling too.

  • A running ToolCall, AgentStep or Reasoning no longer re-renders itself every second. Each kept its elapsed time in its own state on a timer of its own, so a transcript with several things running redrew every row and panel once a second, each at a different moment, and a Reasoning did so while showing no count at all. Now only the number renders on a tick, every count on the page ticks in one commit, and a Reasoning does not render until its stream ends. The count still moves in whole seconds and the total is exact; the first second of a run can now show up to a second late.

  • An InlineCitation fetches its preview card the first time a reader reaches for one. The card is a HoverCard, and importing it statically put Base UI's preview card and its positioning in the bundle of every answer with a footnote: 31.7 kB gzipped for one citation. A citation is now 6.7 kB until a pointer, the focus or a finger reaches it, and the card's 26.6 kB arrive then, while the card's own open delay runs. Hover and keyboard focus open it as before, and a server renders the bare mark.

  • HowToSteps draws the step it starts on without fading it in. The default transition="fade" also ran on the first panel, so a guide at the top of a page painted its largest content invisible and faded it in after the page had loaded, which delayed its first paint. A step the reader moves to still fades in, and so does the first one when they come back to it.

  • A Combobox whose items are written inline no longer filters its whole list again each time the page around it renders. A new array on every render read as a new list, so a combobox in a form ran its filter over every option on every keystroke in the field beside it. The options are now kept for as long as they say the same thing: the same values, labels and disabled flags.

  • A Skeleton holds its sweep still while it is scrolled out of view. The sweep is endless, so a long list loading below the fold, or a Gallery of lazy pictures waiting under their placeholders, kept the compositor drawing frames for every one of them and the page never went idle. It runs again as soon as the placeholder comes back into view.

  • A DateRangePicker no longer draws its calendars' headers again as the band follows the pointer. Each cell the pointer entered while a range was half chosen drew the steppers and the month and year buttons of both months again, though none of them changes as the band moves. They are left alone now, which took twenty hovers from about 44 ms to about 30 ms of rendering in Chromium. Nothing on screen changes.

  • A ScatterChart mark is about a sixth of the markup it was. Every mark carried a class, an inline style with three properties, its fill and its ring, about 390 bytes each, so a 1,000-point scatter drawn at an initialWidth was 387 kB of server HTML; it is 68 kB now, and the chart mounts about a quarter faster. Nothing on screen changes. The ring and the transition are on the group around the marks and each series' group carries its fill, so a test that found the marks by path[stroke] should look for the paths inside that group instead; a mark carries a style only while it is grown.

Fixed

  • A multiple Combobox keeps the error a Form put on it while the page around it renders again, and a single one keeps what is typed after a value its items do not have. The value handed to Base UI was a new object on every render, which Base UI took for a new choice: it cleared the field's errors, so a server error vanished the moment the reader typed in another field, and in single mode it wrote the chosen label back into the input, so typing after a custom value such as defaultValue="Foo" did nothing. The value now stays the same object for as long as it holds the same entries, including when value or items is written inline.

  • A breakpoint moved in your Tailwind theme reaches PageLayout, Sidebar and useBreakpoint even when the stylesheet loads after the first render. The widths were read once, at the first render that asked, and if the stylesheet had not finished loading by then the defaults were kept for the life of the page. A read that finds none of the widths is no longer kept.

  • A Header or a Footer given a ref written inline no longer makes its PageLayout measure it again on every render. A new ref on each render detached and attached the bar again, and the layout restarted its observers and rewrote the bar's height on its root as 0px and back, which made the browser recalculate the style of the whole page. The bar now registers once, and your ref is still handed the element whenever it changes.

  • A Tabs bar that fits no longer slows the page's scrolling under the pointer. Every tab bar, and every ScrollZone with wheel on, carried a wheel listener that can cancel the scroll, which makes the browser wait for the page's script before it scrolls anything under the pointer, so on a busy page the scroll stalled as the pointer crossed a bar with nowhere to go. The listener is attached only while the bar or the strip overflows, and the wheel behaves as before wherever it does.

  • A Collapsible or an Accordion with its default props no longer prints a Base UI warning in a development build. Both handed Base UI keepMounted={false} beside hiddenUntilFound, a pair it warns about because a panel hidden until found stays in the DOM anyway. keepMounted now reaches it only when hiddenUntilFound is off; nothing renders differently.

  • A NebaProvider given an inline onColorSchemeChange no longer re-renders everything that reads useColorScheme on each of its renders. The handler was part of what made the context value, so a new function on every render made a new value too. The newest handler is still the one a change reaches.

  • A server-rendered Carousel opens on its defaultValue from the first paint in Chrome and Edge 133 and later. The strip was moved there once the page had hydrated, so it showed the first slide until then and jumped. The opening slide now carries scroll-initial-target, which those browsers honour before any script runs. Firefox and Safari do not support it yet and still move the strip at hydration, as before.

  • A server-rendered Mockup is drawn from the first paint whatever it was sized with. Without a width or height in pixels, the device was hidden until hydration had measured its box, so content on its screen could not count for Largest Contentful Paint until the JavaScript had run, and with JavaScript off it never showed. CSS now works the scale out until the box is measured, and the measurement lands on the same scale, so nothing moves at hydration.

  • A server-rendered Tabs bar shows which tab is chosen from the first paint. The pill under the chosen tab of a solid bar, and the line under it on the other two, appeared only once the page had hydrated, because the indicator is placed by a measurement. Until then the chosen tab now draws the same thing itself and hands it to the indicator in the same frame, so nothing moves or fades. Firefox 113 to 120 lack the :has() this relies on and show the tab by its colour alone until hydration, as before.

  • A server-rendered PieChart no longer says it is empty. A pie has no size until it has measured itself, so its server HTML said "Nothing here" and carried no hidden table, no description and no tab stop, which is what a crawler and a reader without JavaScript got. Until it is measured the box is now empty and the table, the description and the tab stop are written around it, as a GaugeChart already did. A donut's center is written in the middle of the box from the first render; a semi one's still waits for the width.

  • A server-rendered DataTable with no locale no longer sorts and draws every row again just after it hydrates. The table is written in en-US until hydration is over and in the reader's language after it, and that step rebuilt the collator, re-ran a defaultSort over every row and drew every row on screen again, even in a browser that already spoke en-US. The table now compares the locales each formatter settles on, so nothing is redone when they are the same; a browser in another language still gets its own order and its own dates.

  • An Image's blurred letterbox and its picture placeholder are requested the way the picture is. The blurred copy comes before the picture and had no fetch priority, so a priority picture with letterbox="blur" was met first at low priority, and React 19's automatic preload was built from the copy without fetchpriority="high". A picture placeholder ignored loading, so a lazy Gallery of forty tiles with URL placeholders asked for forty thumbnails before anybody scrolled. The copy now asks for the file exactly as the picture does, and the stand-in waits under loading="lazy" as the picture does; a priority tile's stand-in is still fetched at once.

  • A TreeView has its tab stop from the first render, server HTML included, and no longer draws every row twice as it mounts. The tree gave the stop to its first row in an effect, which drew every row again after each mount and each hydration, and a server-rendered tree could not be reached with Tab until the page had hydrated. With no row chosen, the first top-level row now takes the stop as it is drawn. A tree with a chosen row still moves the stop there once it has mounted.

  • A server-rendered Calendar with no value, defaultMonth or month hydrates cleanly when the reader's month is not the server's. It took its month from the clock, so a page built in one month and served in the next drew last month on the server and this month in the browser, and React threw the server's HTML away for every visitor. The browser now hydrates the month the server drew and moves to the reader's month right after, unless the reader has already moved it. Pass defaultMonth to draw the final month from the first paint.

  • A server-rendered DatePicker, TimePicker, DateTimePicker or DateRangePicker with no locale no longer narrows when the page hydrates. Its trigger was held at the width of its widest date in en-US on the server and in the reader's language right after, so where that language writes shorter dates the field narrowed and the controls after it in a row moved sideways. It now keeps the server's width as well, so it can grow at hydration but not shrink. Pass locale, or defaults.locale on a NebaProvider, to keep the width the same from the first paint.

  • A Tour no longer adds to the page's layout shift while the page scrolls under it. The hole in its mask followed the target on top and left, which the browser reports as a layout shift on every frame of a scroll: a second and a half of scrolling under an open tour added 0.73 to the page's CLS. The mask moves on translate now and reports none. It looks and follows the target as before.

  • An await confirm(…) no longer hangs when its ConfirmProvider unmounts. A question on the sheet, or waiting behind one, was never answered if the provider went away first, so the code after the await never ran and kept whatever it held. Those awaits now resolve false, as a cancel does, and a confirm() called after the provider is gone resolves false at once. While the provider is mounted, only the reader answers.

  • A server-rendered SegmentedButton no longer shows a faint bloom in its chosen segment as the page hydrates. The fill the segment draws until its tile is placed shares a layer with the pointer light, and the light's own transition faded that layer out over a quarter of a second as a soft glow in the middle of the segment. It now goes in the same frame the tile arrives.

  • useOnScreen answers for an element something else is already watching. The library shares one IntersectionObserver per threshold, and an element it had already reported was not reported again until it moved, so a useOnScreen on an element an Animate* or a Carousel was watching at the same threshold stayed false while the element sat on screen. It is now told where things stand as soon as it starts watching.

  • An Animate* with trigger="visible" starts when its own box scrolls into view, wherever its first frame is. The observer measured the element as drawn on its first frame, so a full-width AnimateSlide from the left or the right, or one inside a box with overflow: hidden, was never on screen and never started, and an element taller than the screen never showed the share threshold asked for and stayed invisible. While an entrance whose first frame cannot be seen waits, it is now drawn where it belongs, and carries data-waiting; on an element larger than the screen, threshold is a share of the screen. A slide with fade={false} inside a clipping box or a frame can still wait for good, since what it shows while it waits has to stay where it is.

  • An Animate* waiting for its trigger is drawn as it ends when scripting is off. An effect with trigger="visible", "hover" or "manual" is paused on its first frame in the server's HTML, and only the script ever starts it, so with scripting off an entrance stayed invisible. It now shows its content, in Chrome and Edge 120 and Safari 17 and later. Content in the first screen of a page should keep trigger="mount" or take timeline="view", which run from the stylesheet alone; a visible one is drawn only once the page's script has run.

  • AnimateTyping no longer grows a line when its last character arrives. When the text filled its last line exactly, the caret wrapped onto a line of its own at the very end and pushed what came after it down. The box now holds the caret's room from the first frame. A caret given as a node, rather than a string, is not covered.

  • AnimateTyping, AnimateScramble and AnimateCounter show their final text from the first paint to a reader who has asked for less motion, and with scripting off. The answer was drawn by the script, so until the page hydrated such a reader saw an empty line, a line of noise or the from number, and with scripting off they never saw anything else. The stylesheet draws the final text now, and the page does not change when the script arrives.

  • AnimateMarquee no longer jumps when it measures itself. A server-rendered strip ran at a guessed twelve seconds until the page hydrated, and the measured duration that replaced it, and every one after a resize, moved the strip to a different place in one frame. It now carries on from where it was, at the new speed.

  • A PromptInput holding a server-rendered draft is the right height from the first paint, and typing in it no longer forces a layout per keystroke. The field measured its own height on every character, and a draft rendered on the server was one row tall until the page hydrated. A field that starts at one row now uses field-sizing: content in Chrome and Edge 123, Firefox 152 and Safari 26.2 and later; elsewhere, and with minRows above one, it measures as before. A measuring field also no longer pulls the page up in Firefox when it is typed into at the bottom of the page.

  • Links drawn by BottomNavigation, FloatingBottomNavigation, Breadcrumb, Pagination, Menu, List, TreeView, a ChatBubble card and a Button or IconButton rendered as an <a> look the same with neba/styles.css as they do under Tailwind. The stylesheet's reset leaves links alone, since a page's own links are the page's, and these relied on Tailwind's Preflight to take the browser's underline and, for a List row, a TreeView row and a ChatBubble card, its blue away. Each now says so itself; under Tailwind nothing changes.

  • Drawer takes a ref, and a collapsed Sidebar hands its own to the drawer it becomes. A Drawer was a plain function, so on React 18 a ref reached nothing; it now points at the panel, inline or open as an overlay. A Sidebar passed its ref to the column only, so below collapseBelow the same sidebar's ref stayed null; it now follows the sidebar into the drawer, and is null only while that drawer is shut.

  • Two dark-theme fills clear 4.5:1 against their label again. A primary fill under the pointer measured 4.45:1 against its white label and a pressed warning fill 4.11:1 against its dark one, both under WCAG AA for text. The primary hover is one step darker, oklch(61% 0.181 262) rather than 62%, and the pressed warning lighter, oklch(69.5% 0.126 80) rather than 66%; each still reads as a step from the fill at rest. A test now checks every family, state and theme.

  • AnimateTyping draws a caretChar given as a node for a reader who asked for less motion, and before the script runs. There the stylesheet draws the final line instead of the typed one, and only a caret given as a string was part of it, so an icon caret disappeared. The node is now rendered in both lines; only one of them is ever laid out at a time.

  • An AnimateSlide with fade={false} and trigger="visible" starts inside a box with overflow: hidden. It waited on its first frame, moved out of the box, where the box clipped it away from the observer that starts it, so it never started. It now waits in place and hidden, as a fading slide does, and is drawn at its first frame the moment it starts; before that it is no longer visible at its offset. With less motion asked for, with scripting off, and in a browser without the scripting media feature, it waits as it did.

  • A ref that returns a cleanup works on every component. React 19 lets a callback ref return a function, and calls that function when the element goes instead of calling the ref with null. Twenty components keep their element for themselves as well and handed it to your ref by hand, so on React 19 the function never ran and the ref was called with null instead: Header, Footer, PageLayout, Sidebar, Tabs, SegmentedButton, FloatingActionButton, FloatingBottomNavigation, Panes, WindowPane, Mockup, TextField, PromptInput, Image, TreeView, TreeItem, InlineCitation, AnimateTyping, AnimateMarquee and AnimateHeadline, and a ScrollZone's scrollerRef too. They now treat a ref as React does. A Tabs, a SegmentedButton and a FloatingActionButton also no longer call a callback ref with null and the element again on every render. React 18 is unchanged.

  • A press on a paging DataTable's page-size control before its Select has arrived opens the list once it does. The table draws the closed control until the Select's chunk is here, and a press on it was lost: the reader got the focus and had to press again. A click, Enter, Space or an arrow key on it now opens the Select as it arrives, unless the reader has moved the focus elsewhere in the meantime.

  • A server-rendered Calendar that moves to the reader's month after hydrating puts its tab stop on today. When the server's month and the reader's differed, the stop ended on the 1st of the reader's month, so Tab into the grid landed on the 1st while a calendar mounted in the browser lands on today. It lands on today in both now.

  • A Meter, ProgressLinear, ProgressCircular or ProgressBox with a label is named by it from the first render. The root only pointed at its label after a second commit, on every mount and every hydration, so the server's HTML had the label but nothing named by it. The root now carries aria-labelledby from the start, a labelled indicator renders once rather than twice as it mounts or hydrates, and the accessible name, the value text and the DOM after hydration are as before. A label's generated id no longer starts with base-ui-.

Documentation

  • Getting started says more about server rendering. A locale also keeps a date picker's field from widening at hydration and spares each component a render; a chart can draw in the server's HTML with initialWidth; content in the first screen should keep trigger="mount"; a Shortcut takes its platform from the request; and colorSchemeScript() should be called with the options the provider has.

Every release is in the changelog on the docs site and in CHANGELOG.md at this tag.