minimal_parts library

Helpers for customizing components copied from minimal_ui.

Import this library in the copied widget to use its theme and component helpers.

import 'package:minimal_ui/minimal_parts.dart';

Outside semver: this library may change in any version, a patch included; the CHANGELOG says how to move.

Classes

AnimatedMinimalTheme
Animates to a new data over duration (200 ms, Material's AnimatedTheme default), as AnimatedTheme does: colours, type, corners and sizes blend through MinimalThemeData.lerp.
ChromeGroundScope
Publishes the ChromeGround of the page it wraps. ChromeRoutes.page mounts one inside a pushed page and inside a branch root (from its NavTab.ground); a system's chrome inside the page reads it.
DefaultDesignLocalizations
The words in English, with no localizations package.
DesignAdaptiveShell
An app's frame: destinations in a bar, a rail or a sidebar by the shell's width (DesignNavigationMode.fromWidth, or mode), and the app's body beside it (above a bar). The look paints each destination (destinationBuilder) and the navigation round them (navigationBuilder); the shell gives them their keys, their meaning to a screen reader and their place.
DesignAnchoredOverlay
A surface anchored to anchorBuilder's widget: a popover (DesignOverlayTrigger.press, focusOnOpen), a hover card (DesignOverlayTrigger.hover) or a menu (arrowKeyNavigation on).
DesignBandScale
Categories side by side (bars): count bands from start to end, paddingInner of each step between bands and paddingOuter at the ends. A value is a band's index; map gives its centre.
DesignBottomSheetController
Drives an open DesignBottomSheetRoute's size from outside it, as DraggableScrollableController drives a sheet, on the route's spring. The caller makes it, gives it to one route at a time, and disposes it.
DesignBottomSheetDetails
What a DesignBottomSheetRoute's panel paints from.
DesignBottomSheetDragHandle
A bottom sheet's drag handle, painted by builder: a button that moves the sheet to its next size (from the largest back to the smallest; a sheet of one size closes), Up and Down to a larger or smaller size when focused, and a screen reader's increase and decrease. Put it in a DesignBottomSheetRoute's panel.
DesignBottomSheetRoute<T>
A modal bottom sheet. Push it with Navigator.push; its panel is builder's, the screen's width, rising from the bottom edge.
DesignCalendar
One or more month grids over a DesignCalendarController.
DesignCalendarController
A calendar's state: the shown month, the keyboard's day and the selection.
DesignCalendarDay
One day as the grid paints it.
DesignCalendarHeader
A month's header, as DesignCalendar.headerBuilder gets it.
DesignCapCenter
Draws a one-line label or text entry so that the middle of its capitals is the middle of its own box, as Baseline puts a baseline where it is told.
DesignCarousel
Slides itemBuilder builds, itemCount of them.
DesignCarouselControls
What a carousel's controls act on.
DesignChart
A cartesian chart (line, area, bars, a sparkline): the look draws series from the scales and ticks in builder's details; the chart picks points, says them, and springs from one set of data to the next.
DesignChartDetails
A DesignChart as its look draws it.
DesignChartPoint
A point of a DesignChartSeries: x and y, or a gap where y is null.
DesignChartPointRef
A point of a chart: the indexth point of the seriesth series.
DesignChartSeries
A named run of points, in order along x.
DesignChartTable
A chart's data as a table, the alternative an app shows instead of the chart (a screen reader's "Show data table"): a row per x value, a column per series (DesignChartTable.new), or a row per slice with its value and share (DesignChartTable.slices). A screen reader reads a table, its column headers and cells, a missing value as "Empty"; cellBuilder paints each cell, and the columns are as wide as their widest cell.
DesignChartTableCellDetails
A cell of a DesignChartTable.
DesignColorArea
A saturation (across) and brightness (up) area for controller's hue.
DesignColorAreaDetails
What the look paints the area from.
DesignColorController
A colour being picked, as hue, saturation, brightness and alpha.
DesignColorPicker
An area over a hue slider (and an alpha slider), on one controller.
DesignColorSlider
A slider for one channel of controller's colour.
DesignCombobox<T extends Object>
A text field that suggests options as you type.
DesignComboboxField
The field, as DesignCombobox.fieldBuilder gets it: wire controller and focusNode to the look's text input, and submit to its onEditingComplete (and give it no onSubmitted; see submit).
DesignCommand
A command in a palette.
DesignCommandPalette
The palette's body: the field over the results. Put it in a route with showDesignCommandPalette, or anywhere (a sidebar's search).
DesignCommandShortcut
Opens a palette from anywhere under it on activators (Ctrl+K and Cmd+K).
DesignContextMenu
A menu of menuChildren that opens over child, where the user asks for it.
DesignControlBox
A control's box: at least minHeight tall, as wide as its child (or as the width it is told to be), with child placed by alignment and its text given even leading (TextLeadingDistribution.even).
DesignDataTable<R>
The rows of a DesignTableController's page under a header row, with one tab stop for the rows. The look paints the header cells, the cells, and each row around its cells.
DesignDateField
A date typed in segments, in the reader's order: value is a calendar day (its time ignored), null when empty; onChanged gets the day once every segment holds one, and null when one is cleared.
DesignDateRange
A range of days, start to end inclusive; end is null while only the start is chosen.
DesignDateSegmentDetails
One segment of a DesignDateField or DesignTimeField, as the look paints it.
DesignDensity
How compact a look's controls stand, as Material's VisualDensity: each step of vertical takes heightStep from a control's height and each step of horizontal paddingStep from its padding at either side, from -4 (tightest) to 4 (roomiest).
DesignDestinationDetails
What a look paints a destination from.
DesignDialog
An alert's or a simple dialog's layout: title and content scroll together over actions, which stay put. The actions sit side by side, sharing the row on a compact screen and aligned at the end on a larger screen. When their labels do not fit, including at a large text size, they stack, one to a line, the last given (the confirm) on top and the first (the dismissive one) at the bottom, as Material and iOS stack them.
DesignDialogAction
An action at the foot of a DesignDialog.
DesignDialogActionDetails
What the look paints a DesignDialogAction from.
DesignDialogDetails
What a DesignDialogRoute's builder paints from.
DesignDialogFrameDetails
What the look paints a DesignDialog's frame and action bar from.
DesignDialogRoute<T>
A modal dialog or alert. Push it with Navigator.push; its page is builder's, over a barrier.
DesignField
A control with its label, help and error.
DesignFieldParts
What a DesignField's builder lays out.
DesignForm
A Form that, on a submit that fails, shows every error, moves focus to the first field that is wrong (scrolling it into view) and tells a screen reader how many fields need attention; after that, errors update as the reader edits.
DesignFormField<T>
A FormField whose control DesignForm can focus: give focusNode to the control.
DesignFormState
The state of a DesignForm: submit and reset it.
DesignHaptics
The haptics ui_core's behaviours play: one callback per moment; a null callback plays nothing.
DesignHapticsScope
Puts haptics in force for child: the table every ui_core behaviour below reads with DesignHaptics.of.
DesignInputGroup
A field and its add-ons as one control.
DesignInventory
A look's inventory: one entry per DesignInventoryRow.
DesignInventoryEntry
A look's answer to one row: a live specimen (builder) or the reason the look leaves it out (absentReason).
DesignInventoryGallery
Lists an inventory, group by group in DesignInventoryRow.groups' order: each row's live specimen, or Deliberately absent: <reason> for a gap, or "Missing" for a row the inventory does not answer. Lazy: a row builds when it scrolls in.
DesignInventoryRow
One row of the inventory: a component every look either carries or leaves out with a reason.
DesignKeylineFace
Marks child as one face for the checks in package:ui_core_test: a control's face or a well (a field's, a list's, a table's) whose pixels may not show it, or a picture with things placed on it.
DesignKeylineRegion
Marks child as a card or a section whose contents share keylines: a keyline is the line that what starts a row (or ends one) sits on, so a card's title, its rows' words, its fields and its dividers start on one line, and its switches, chevrons and selects end on another.
DesignLinearScale
A number line: min at start, max at end.
DesignListDetail<T extends Object>
A list (listBuilder) and the detail of selectedItem (detailBuilder), as Compose's ListDetailPaneScaffold.
DesignLocalizations
The words a design system says on its own. The behaviours' words: the names a screen reader hears for a part with no text of its own (a carousel, a sheet's barrier, a split view's handle) and the messages they announce (a slide turned, a row moved, the results found), each also a parameter on its behaviour, which a null leaves to this. And the general words a look shows or says by itself (Cancel, Close, Today, Next month, "2 of 5"), under MaterialLocalizations' names where Flutter has the word, so a look built on any app (MaterialApp, CupertinoApp, WidgetsApp) has them.
DesignMenuBar
A row of menus.
DesignMenuEntry
An item of a menubar: a command, a submenu (children), or a divider.
DesignMotionPolicy
The Reduce Motion policy: which spring a component actually runs.
DesignNavigationDestination
A destination: its name and glyphs, as Material's NavigationDestination.
DesignNavigationDetails
What a look lays the navigation out from.
DesignNumberField
A number typed or stepped: value the number, null when empty; onChanged gets it as it is taken (Enter, the focus leaving, a step), not on each key typed.
DesignNumberFieldButtonDetails
One of a number field's step buttons, as the look paints it.
DesignNumberFieldDetails
The field, as DesignNumberField.fieldBuilder gets it: wire controller, focusNode, keyboardType, inputFormatters and onEditingComplete to the look's text input.
DesignOtpController
Holds a code: its text, its length, whether it is whole.
DesignOtpField
A one-time code drawn as boxes over one input.
DesignOtpSlot
One box, as DesignOtpField.slotBuilder gets it.
DesignOverlayAnchor
The anchor, as DesignAnchoredOverlay.anchorBuilder gets it.
DesignOverlayInfo
What DesignAnchoredOverlay.overlayBuilder paints the surface from.
DesignOverlayPadding
The edges a surface opened under it keeps clear of, beyond the screen's safe area and the on-screen keyboard: a look's own chrome over its pages, such as a desktop side bar a page's overlay runs under.
DesignOverlayPlacement
Where a surface goes relative to its anchor.
DesignPasswordController
Whether a password shows: true while it is hidden.
DesignPasswordDetails
What a DesignPasswordReveal's builder paints from.
DesignPasswordReveal
Holds whether a password shows and gives the field and its toggle what they need. The field keeps its focus and caret as it flips; with hideOnBlur a shown password hides again when focus leaves the field.
DesignPieChart
A pie or donut: the look draws slices from the angles in builder's details; the chart picks a slice, says it, and springs from one set of values to the next.
DesignPieChartDetails
A DesignPieChart as its look draws it.
DesignPieSlice
A slice of a DesignPieChart: a label and its value.
DesignPieSliceDetails
A slice as drawn.
DesignPressable
Makes any widget a control (press, focus, hover and what a screen reader hears), with no look of its own.
DesignPressableState
The state of a DesignPressable: states is what its builder was last given.
DesignPullToRefresh
child, a scroll view, refreshed by onRefresh on a pull.
DesignPullToRefreshState
The refresher's state: refresh runs one (a keyboard shortcut, a menu's "Refresh").
DesignRangeSlider
A slider of values between min and max.
DesignRangeTrack
The track's state, for the look to paint its rail and the filled part.
DesignRangeValues
A range's two ends.
DesignRating
A rating of itemCount items filled up to value (0, none, to itemCount): onChanged gets the value a tap, a drag, a key or a screen reader sets.
DesignRatingItemDetails
One item of a DesignRating, as the look paints it.
DesignRefreshDetails
What the look paints the indicator from.
DesignReorderableList<T extends Object>
A list of items the reader puts in order; onReorder gets an item's place from and its new place to (counted after it left).
DesignReorderItem
An item's place and moves, as DesignReorderableList.itemBuilder gets them.
DesignScale
Values to positions and back.
DesignScaleTick
A tick on a scale: a value, its position, its label.
DesignScrollArea
child, a scroll view on controller, with a scrollbar from thumbBuilder (and trackBuilder) on its end edge (or bottom).
DesignScrollThumb
A scrollbar's geometry and state, for the look to paint.
DesignSearchError
A search that failed, as a combobox's or a tag input's errorBuilder gets it: paint a message and a "Try again" (DesignLocalizations.retryButtonLabel) that calls retry, lit while focused.
DesignSheetInfo
What a side sheet's panel gets to paint with.
DesignSheetPageRoute<T>
A full-screen sheet presented as an opaque page of the navigator. The whole page rises on a spring and returns along the same path. With Reduce Motion it fades. Escape and Back respect the page's PopScope.
DesignSideSheetRoute<T>
A modal side sheet. Push it with Navigator.push; its panel is builder's, sized to width (at most the screen less minGap) and the full height.
DesignSpacing
The step a look's spacing stands on: every padding, gap and spacing token a multiple of grid.
DesignSpacingScope
Declares the spacing a look's parts stand on for the subtree, as a theme does; DesignSpacing.of reads it.
DesignSplitAction
An action in a split button's menu.
DesignSplitButton
A main action with a menu of actions beside it.
DesignSplitView
first and second side by side (or stacked, axis vertical), split at fraction of the room (the first pane's share).
DesignStyle
How one part of a look looks, as Material's ButtonStyle is: every slot resolves for the part's states (WidgetState.disabled, WidgetState.hovered, WidgetState.focused, WidgetState.pressed, WidgetState.selected, WidgetState.error).
DesignStyleOf
A part's style layers read at its states: its own style:, then its component theme (first wins). Each getter is the first layer's value for states, or null, so the part goes on to the theme-wide knobs and its own default.
DesignSwipeAction
An action behind a row.
DesignSwipeActionDetails
What the look paints an action from.
DesignSwipeActions
child with startActions behind its start edge and endActions behind its end edge.
DesignSwipeActionsController
Opens and closes a DesignSwipeActions row from outside, and says whether it is open, as flutter_slidable's controller does. The caller makes it, gives it to one row, and disposes it; with no row it does nothing.
DesignSwipeBackPageTransitionsBuilder
builder's page transition with iOS's swipe back from the screen's leading edge round it.
DesignTab
A tab: its name, and what a look paints it with.
DesignTabBar
A bar of tabs, controller choosing among them; the look paints each tab (tabBuilder) and the indicator under them (indicatorBuilder), or over them (indicatorPosition).
DesignTabController
Which tab is selected, and where a swipe or a change has got to: Material's TabController without Material. A DesignTabBar and a DesignTabView given the same one follow each other. The caller makes it, with a TickerProvider (TickerProviderStateMixin), and disposes it.
DesignTabDetails
What a look paints a tab from.
DesignTabIndicatorDetails
Where a look paints the indicator, and the selected tab's states.
DesignTableColumn<R>
A column of a DesignTableController.
DesignTableController<R>
A table's data and its view of it: the filter, the sort, the selection and the page.
DesignTableRow<R>
One row, as DesignDataTable.rowBuilder gets it.
DesignTabView
The pages of controller's tabs, one per tab, swiped between: Material's TabBarView without Material. Swiping moves the controller's DesignTabController.animation, so a bar's indicator follows the finger; let go, the pages spring to the nearer page (or the next, flung) on the controller's spring. A change from the bar springs the pages the same way. Each page is its tab's panel to a screen reader; pages off screen are not built, unless a page keeps itself alive.
DesignTagDetails
One tag, as DesignTagInput.tagBuilder gets it.
DesignTagInput<T extends Object>
Values chosen as tags, with a field that suggests and makes more.
DesignTapTarget
Lays child out at least minSize (the floor for what reaches the controls, DesignTapTargets.of, when null), placed by alignment, and sends a tap anywhere in that area to the child's centre: the control's layout, the area a tap reaches and the box a screen reader outlines are one.
DesignTapTargets
The least area a tap must reach on a control, by what reaches it: 44 by 44 for a finger (Apple's Human Interface Guidelines), 24 by 24 for a pointer (WCAG 2.2, success criterion 2.5.8, level AA).
DesignTapTargetScope
Declares the targets a look's controls stand at for the subtree, as a theme does; DesignTapTargets.of reads them.
DesignTextEntryBox
A text entry's box: at least minHeight tall, holding child, an editable as wide as the box, with one line centred in it and hint on the typed text's baseline while controller is empty.
DesignTimeField
A time of day typed in segments, on the reader's clock: value the time, null when empty; onChanged gets it once every segment holds one, and null when one is cleared.
DesignTimeOfDay
A time of day with no date: an hour (0–23), a minute and a second.
DesignTimeScale
Time, in local dates: min at start, max at end. Its values are milliseconds since the epoch (DateTime.millisecondsSinceEpoch); its ticks fall on calendar steps (seconds to years) and read as the reader's times and dates.
DesignToast
What a toast says and does. The look reads the fields it paints; data carries anything else it needs (a tone, an icon).
DesignToastDetails
What the look's DesignToaster.toastBuilder paints one toast from.
DesignToaster
Hosts toasts over child: put it above the app's navigator (WidgetsApp.builder), then call DesignToaster.of and DesignToasterState.show from anywhere below.
DesignToasterState
The state of a DesignToaster: show and dismiss toasts through it.
DesignToastHandle
A shown or waiting toast, as DesignToasterState.show returns it.
DesignToggleGroup<T>
A row (or column) of toggles over options.
DesignTooltip
A tooltip of message for child, painted by tooltipBuilder.
DesignTree<T extends Object>
The open rows of controller, one tab stop for all of them.
DesignTreeController<T extends Object>
A tree's nodes and which are open and selected.
DesignTreeItem<T extends Object>
A row's paint state.
DesignTreeRow<T extends Object>
A shown row of a tree.
DesignValueHandle
A focusable value between min and max.
DesignWheelColumn
One column of a DesignWheelPicker: its rows, their names and which of them can be chosen.
DesignWheelColumnDetails
One column of a DesignWheelPicker, as the look frames it: its lens, a band behind the centre row, a focus ring.
DesignWheelItemDetails
One row of a DesignWheelPicker, as the look paints it.
DesignWheelPicker
A wheel picker of linked columns: selection holds a row per column, columns gives the columns for a selection, and onChanged gets every pick as a whole, valid selection.
DisplayFormat
English display formats for amounts, counts and dates.
MediaSlot
Where a slot's picture comes from.
MediaSlotImage
Trusted image delivery for one declared media slot, shared by a system's photo and avatar components. fallback stands in while the picture is pending and whenever it misses, so a pending image never delays layout, first paint or publication.
MinimalActionBar
A page's persistent commit strip: a summary of what is about to happen on the leading side (a total, a count, the one line that matters) and the primary action on the trailing side. In MinimalScaffold(footer:) leave floating false — the screen owns the ground, the hairline and the insets; floating: true stands it on its own bordered card for a body that keeps its edges.
MinimalActionSheet
A short list of things to do with one object — a photo's Share, Save and Delete; a message's Reply and Copy — raised from the bottom on a phone: ONE card in the sheet's material holding an optional title and message, a row for each action (a glyph and the words, the destructive one in the destructive ink) and, last, under a hairline like every row, Cancel, centred in the muted ink: the quiet way out, not a second card.
MinimalActionSheetAction
One action of a MinimalActionSheet.
MinimalActivity
One event in a MinimalTimeline: when it happened (printed as a mono stamp, 28 Aug 07:12), what happened, and optionally who did it and a quiet detail (· note added). tone marks an event with a status dot (a failure, a completion). onPressed opens the event.
MinimalAppBar
The page's header band: 52 px on the ground over a 1 px hairline, its appearance follows the route (MinimalRouteChrome). title names the page and subtitle appears beside it in monospace.
MinimalAreaChart
A MinimalLineChart with the ground under each line filled with one flat, faint tint of its colour: for a quantity that accumulates or a total over time, where the area itself says "how much". Everything else — the scale, the labels, the legend, the readout, the loading and empty states — is the line chart's.
MinimalAvatar
A person's circle — 24 in a dense row or a stack, 28 by default, 32 beside a heading. With no imagery it draws deterministic initials in ink on a quiet neutral fill whose shade steps by the name, so a person is never a blank silhouette, the same person is always the same shade, and a face never borrows the accent or a status colour: identity is not meaning.
MinimalAvatarGroup
An overlapping row of avatars with a +N overflow disc — the members of a project, the people on a thread. Each circle stands in a ring of the ground the stack stands on — the page, or the card around it — and that ring alone cuts neighbours apart: in a stack a face's own faint rim takes the ground's colour too, so no grey line runs between two faces. The first face stands at the start edge and each next one toward the end, so right to left the stack reads from the right, as its names do. Announced as one image listing the names.
MinimalBadge
A count on the corner of what it counts — unread messages on the inbox glyph, a new comment on a face: a 16 px capsule (shapes.pill) in the tone's fill with the count in mono, past max as "99+"; a neutral count is a neutral tag's, the muted fill in a hairline with the count in the ink. With no count it is a 8 px dot: something new, no number (a neutral one in the faint ink). It wears a ring of the ground colour, concentric outside its own edge, so it stays clear of whatever it sits on. Without a child it stands alone (a nav row's count).
MinimalBanner
A notice that stands in the page until it is dealt with — a trial that ends Friday, a sync that failed, a setting that needs a look: a framed block on the shapes.medium step, the tone's glyph at its start, a title in the ink, a quiet message, at most two actions under them (Minimal's buttons, small), and a close button at its end when onDismissed is given.
MinimalBarActions
Marks a subtree as a bar's trailing actions: a MinimalIconButton with no variant of its own reads it and wears the bar's bordered square instead of the bare glyph it draws in a row. MinimalAppBar mounts it around its actions; nothing else does.
MinimalBarChart
A bar chart for a short series — a week of check-ins, a day of orders: thin square-shouldered bars on a hairline baseline, mono axis labels under them, and exactly one bar in the full ink, the highest unless highlight names another. Every other bar stays in the quiet ink; a zero draws no bar at all.
MinimalBottomSheet
The sheet card itself — Minimal's compact modal card: the surface on a 1 px border at the theme's sheet radius, a large soft shadow, a header band (the context pill, the title, the close x), the content, and a footer row of actions over a hairline. showMinimalBottomSheet presents the same widget modally. It can also be used as an anchored panel.
MinimalBreadcrumb
Minimal's path line — Habits / HAB-4: where a record sits, the ancestors in the quiet ink and tappable when they lead somewhere, a faint slash between, the current step last in the ink. Identifiers print in mono. It shortens with an ellipsis rather than wrapping. A path with a tappable ancestor stands in a 44 px band, the least tap target; a path of context alone is as tall as its text.
MinimalBreadcrumbItem
One step of a MinimalBreadcrumb: its label, whether it is an identifier printed in mono (HAB-4, #1047), and where tapping it goes.
MinimalButton
An action button with an optional icon or leading widget.
MinimalButtonGroup
Related actions joined into one bar — a document's Bold, Italic and Link, a list's Previous and Next, an editor's Undo and Redo. One bordered frame on the shapes.small step holds them, split by full-height hairlines; each action is a cell that fills its slot edge to edge, so its press wash and focus ring take the cell's exact shape: the frame's corners at the ends, square where it meets a neighbour.
MinimalButtonGroupItem
One action of a MinimalButtonGroup: words, a glyph, or both. A glyph alone names itself to a screen reader through semanticLabel.
MinimalButtonPaint
A MinimalButton's paint for tone, scale and style, at the theme in force where it is made.
MinimalButtonSegment<T>
One segment of a MinimalSegmentedButton: the value it stands for, its label and, optionally, a 16 px icon before the words.
MinimalCalendar
A month in the page to choose a day on: a booking's date, a journal's day. Minimal's month grid (the chosen day on the accent, today a bar under its figure) under the month's name and two small chevrons; months above 1 sets that many side by side.
MinimalCard
The container for grouped content: the surface inside a 1 px hairline on the theme's card radius, and never a shadow — Minimal separates what sits on the page with rules, not elevation.
MinimalCarouselView
Slides one at a time, a swipe or a press apart: a product's pictures, an onboarding's cards, featured items. Each slide stands on the card's outline (shapes.medium, clipped); under them, two small outlined arrows, Minimal's page dots between them on the slides' middle, and a pause button beside the next arrow when it plays on its own. Under 1, viewportFraction shows the neighbours' edges: the frame cuts them square, and they fade at the cut, as every sideways cut does.
MinimalCell
One cell of a MinimalTableRow: plain text in the column's register, a status badge, or any widget.
MinimalCentredSheetRoute<T>
The route a sheet page rides centred in a wide window (MinimalBottomSheet.centredRoute): ui_core's dialog route, which the page's bar still reads as a sheet (MinimalRouteChrome.sheet), so the card keeps its compact header and close. It adds nothing but its name.
MinimalChartSeries
One named run of values in a MinimalLineChart or MinimalAreaChart: one value per label. color overrides the chart's palette.
MinimalChartSlice
One part of a MinimalPieChart's whole.
MinimalCheckbox
Minimal's checkbox: a 16 px square with small corners that fills with the accent and a drawn tick when value is true — a checklist item, an agreement, a row picked for a bulk action. (A task's status glyph — the dashed ring, the half, the filled check — is MinimalStatusIcon's job.)
MinimalCheckMark
A checkbox's square and tick as a picture, not a control: a row that is itself the control (a picker's option, a bulk-select row) shows its state with one, and so does a finished line's tick. It renders at full ink, takes no press and no focus, and lets taps through to what holds it; label announces it. It wears components.checkbox as MinimalCheckbox does, so the two read as one part.
MinimalChip
A filter pill — the control a filter strip or a single-choice row is made of: 28 px, a hairline edge with 7 px corners, a 12.5 px medium label, an optional 14 px glyph before it and an optional mono count after it. Put a set of them in a MinimalChipRow.
MinimalChipRow
A chip strip that cannot overflow: its chips wrap onto new lines, 6 px apart each way, the rhythm of the create form's property pills. The row pads its own hit region by the 8 px a 28 px chip needs to reach 44, so the first line keeps its targets above it and the last below it.
MinimalChoiceRow
One option of a single choice: a 44 px hairline row — an optional leading glyph or mark, the title (and a quiet subtitle), and the accent check at the end when it is the choice, its title then in the full ink at medium weight (in a MinimalSelectionGroup with a choice, the other titles stay muted). The row draws its own bottom rule, like every Minimal row; stack them in a MinimalSelectionGroup. A null onPressed disables the option.
MinimalChromeMetrics
Minimal's chrome geometry and motion, in one place: the bars, the rows, the controls, the sheet card and the transitions, as the build spec (docs/architecture/design-systems-bench-tactile.md §6) and its reference mockups state them.
MinimalCircularProgressIndicator
A circular progress indicator in the current tone.
MinimalCodeBlock
A block of code, a command or a token in mono on the sunken well — an API key to paste, a webhook payload, a CLI line — with an optional caption band (label, usually the language or the file) and a copy action that puts code on the clipboard and confirms with a toast.
MinimalColorPicker
A colour picked by eye or by number: a label's colour, a calendar's, a brand accent. A saturation and brightness area for the hue (its outline shapes.small, a hairline round it) over a hue slider and, with showAlpha, an opacity slider on a checker; beside the hex field, a swatch of the colour; under them, swatches to pick at a press. One 16 px gap stands between each part and the next.
MinimalColors
Minimal's colour roles in one appearance, as Material's ColorScheme: the grounds, the hairlines, the inks, the one accent and the three status tones. Every role is materialised — components read values, they never derive them. MinimalThemeData.preset and MinimalThemeData.from build them with every contrast bar held; copyWith changes roles as given and checks nothing.
MinimalColumn
One column of a MinimalTable: its header label, how much of the width it takes, and how its cells print.
MinimalColumnMetrics
The plan's measure: the air between two columns where there is room, the least it closes to, and the least a shared column of words is cut to before the table scrolls sideways.
MinimalColumnPlan
A table's columns laid out: each one's width and the gaps between them.
MinimalCombobox<T extends Object>
A text field that suggests from options as you type: a city, an assignee, a country. The field is a MinimalTextField with a chevron at its end; the list opens under it in Minimal's panel of 32 px rows, the chosen value in the full ink at medium weight with a check (the other options muted), and the highlighted row (the keyboard's, or the pointer's) on the muted fill. Words no option fits say so in the panel ("No results").
MinimalCommand
Minimal's command palette — every action a page can run, searchable from one field: type to filter (the best matches first, by words and initials), arrow keys to move the highlight, Enter to run it; a pointer moves the highlight too. Results are listed under their groups, each row a glyph, the label and its shortcut as key caps; nothing matching prints an empty state, and a screen reader hears how many match. The field is a MinimalSearchField, clear cap and all. Result rows are the dense 36 px register (t.rowHeightCompact), grown with larger text — with the table's 40 and the menu's and time columns' 32, the dense-list exception to the 44 px target: a palette is walked by keyboard and read far more than it is tapped.
MinimalCommandItem
One action a MinimalCommand offers: its label, an optional glyph, the group it is listed under, its keyboard shortcut printed as key caps, and the extra keywords a search should also match.
MinimalComponentThemes
Every component theme in one, as ThemeData holds Material's: what MinimalThemeData.components carries and lerps. Each is null until an app sets it, and a null one leaves its parts as the look draws them.
MinimalComposer
Minimal's message input: a bordered box on the surface, a large control's 40 px at rest in messages, growing line by line as the draft does, with the 32 px attach control and send square inside it, centred on the first line. Focus draws the box's hairline in the focus colour, and focus on the draft takes the accent 1.5 px in from the box's outline, with no ring outside it, as a text field's does.
MinimalComposerAction
The send seat of a MinimalComposer, public for a flow that owns its action: a square in the accent, the act to take in both registers (32 px in messages, 28 among the assistant toolbar's small controls), holding the arrow (or icon). No onPressed dims it: nothing to send yet.
MinimalComposerLayout
A conversation page with its composer docked at the bottom edge, over the footer's hairline, and the transcript filling the rest. bodyBuilder receives the trailing inset to give the INNER scrollable's content (never the viewport), so the last message clears the composer's rule.
MinimalControlMetrics
Geometry the small controls share — the filter pill, the tabs' counts, the segmented track — named once so a chip, a tab strip and a property pill cannot drift apart. Not exported: pages never need it.
MinimalCorners
Corner radii for component identity (true circles and pills). The theme's corner language (card/control/small/sheet) lives on MinimalThemeData.
MinimalCounter
A number that MOVES: the screen's one live quantity — a streak, a total, a count kept today — rolls to its new value instead of swapping glyphs.
MinimalDataColumn<R>
One column of a MinimalDataTable: its label, the words a row shows in it (value), and whether a press on its header sorts it.
MinimalDataTable<R>
The back-office table that does its own work: the rows of rows under columns, sorted by a press on a sortable header (ascending, descending, then as given), filtered by query, pageSize at a time with a pager under them, and selected by a press, Space, Shift for a run or Ctrl/Cmd with A for the page, with a select-all box in the header.
MinimalDatePicker
Date and time selection in Minimal's grammar. The compact row prints the label in the quiet ink and the value as bordered mono pills — the date (28 Aug 2026), the clock (21:30) — each opening its own picker in an anchored popover: a month calendar with mono day numbers, the chosen day on the accent, today a bar under its figure; or two scrolling columns of hours and minutes. Choosing a day closes the calendar. With confirmSelection the picker rises in a sheet instead and commits only on Done. With no onChanged the whole row dims to the kit's 0.45, its pills' values in the quiet ink at the regular weight.
MinimalDateRangePicker
A range of days from a form row: a stay, a report's period, a leave. A boxed row like a MinimalDatePicker's, the range in mono (12 Mar – 18 Mar 2026) or the hint; a press opens Minimal's panel under it with two months side by side (one where the window is narrow). The first press chooses the start, the next the end, a band previewing the range between; the panel closes on the end, and the row reports the range.
MinimalDensity
How compact the controls stand, in Flutter's VisualDensity steps and names: each step of vertical takes 2 from a control's height and each step of horizontal 1 from its padding at either side, from -4 (tightest) to 4 (roomiest). Half Material's reading, because Minimal's controls start dense: compact, a desktop's default, is a 28 px control and a 32 px dense row. Minimal's own type, so the look's API names no Material class.
MinimalDescriptionList
An issue-style list of a record's properties — Status ● Active, Reminder 07:00 — one MinimalProperty per 36 px row, each over a hairline, with a hairline above the first. It holds the page's measure (it is not full-bleed): stand it in the screen's padding.
MinimalDialog
Minimal's confirm dialog — the kit's only modal question: a compact card centred over the scrim, its title in MinimalThemeData.h3, the message in the quiet 13 px ink, and small buttons right-aligned in a footer under a hairline (stacked, the confirm on top, when they do not share a line). showMinimalDialog raises it; raised, the confirm answers true and the cancel false (after onConfirm or onCancel, when given), and a tap on the scrim or Escape answers null. Raised, focus opens on the safe answer: the cancel when the confirm is destructive (Enter then keeps), else the confirm (Enter confirms). The layout and the focus are ui_core's (DesignDialog); Minimal paints them.
MinimalDisclosure
A row that opens to show what is under it — an FAQ's answer, advanced settings, a group of details: the title (and a quiet subtitle) with a chevron at the end that turns as it opens, then child growing into place under it in MinimalMotion.base. Like every Minimal row it draws its own bottom rule, so a column of them is an accordion.
MinimalDismissible
Swipe-to-delete for a list row, pulled from the trailing edge only.
MinimalDivider
A hairline that separates — two groups of fields, a toolbar's halves, a menu's sections: one t.hairline in the border colour, across the available width (or down the available height with MinimalDivider.vertical), with indent and endIndent at its ends. With a label it breaks in the middle for the words ("or"), quiet and small. Minimal's rows draw their own rules; reach for this between things that are not rows.
MinimalEdgeFade
A horizontally scrolling strip's affordance: the strip's own content fades out over a short run at each edge beyond which more of it lies, so a table, a code line or a tab strip cut by the screen reads as scrollable rather than clipped. Drawn only while there is more to reach on that side; a strip that fits shows none.
MinimalEmptyState
The centred empty state with an optional call to action — the empty render state for any page that lists things.
MinimalErrorState
The centred, screen-reader-announced error state with an optional retry — the error render state for any page that can fail.
MinimalFace
A part's face, which moves to each new state the way Minimal moves: a short plain fade. The face's whole style (its decoration, so its fill, rim, ring and any shadow, and the ink its words and glyph are drawn in) lerps from where it is to where the new state puts it, in MinimalMotion.base on MinimalMotion.out. It is an implicit animation over the style, not a tween per widget, so a change that comes mid-way turns from where the face is, with no jump back; with reduced motion (MinimalMotionContext.minimalStill) it switches at once.
MinimalFadeRoute<T>
A destination that cross-fades in over the page it covers — the peer register: no slide, the outgoing page staying exactly where it is beneath. A switched view (a workspace, a filter's saved page) rather than a step deeper. Timings are MinimalChromeMetrics.fadeIn and MinimalChromeMetrics.fadeOut.
MinimalFieldErrorScope
Whether the MinimalFormField round a control shows an error. A text field or an input group under one paints the error register (the danger rule and ring) as if it carried the error itself; the message is the form field's.
MinimalFieldMetrics
Geometry the form controls share — the text field, the search field, the form, picker, choice and date rows — named once so a field and a row cannot drift apart. Not exported: pages never need it.
MinimalFieldTarget
A boxed field's value area as one screen-reader node — the text input and the name a caller puts on it — whose bounds are the band a tap lands in (the box grown to the band's tap floor, minimalBandFloor, which the band round the box lays out), not the one line of text it paints: the target a screen reader outlines, and an accessibility audit measures, is the one a finger or a pointer has.
MinimalFileUpload
A drop zone for files — an attachment, an import, a profile picture: a dashed frame on the shapes.medium step with an upload glyph, title and a quiet hint (the kinds and the size it takes), and under it the files on their way up, each with its size, its progress and a remove button.
MinimalFilter
One count filter: a quiet word with its mono count beside it (Open 2). The selected filter takes an ink hairline and the ink at medium weight, as a chosen chip does; the rest print in the secondary ink on nothing at all.
MinimalFilterBar
A strip of MinimalFilters over a list: full bleed, a hairline under it, the filters left to right with a trailing control (a display menu, a sort) held at the end, at the filters' height (a small icon button). When the filters outrun the width — more of them, or a larger text scale — they scroll sideways rather than wrap, so the list below never moves.
MinimalForm
The fields of a form, validated together: a submit that finds a wrong field shows every error, moves focus to the first one (scrolling it into view) and tells a screen reader how many need attention; after that, the errors follow the edits. Fields take part through Flutter's FormField (ui_core's DesignFormField, with the control's focus node); MinimalForm.submit runs the check from a button.
MinimalFormat
Formats currency, dates and times for display.
MinimalFormField
A control with its words round it: a select, a switch, a group of radios, a combobox, anything that brings no label of its own. The label over it in the caption weight (a quiet asterisk after it when required), the help under it in the secondary ink, and the error in its place, in the destructive ink, when the value is wrong.
MinimalFormRow
A 44 px hairline form row for a control or an action: an optional glyph, the label in the ink, and the trailing control (a toggle, a stepper, a button) at the end. With onPressed the whole row is the control; with no trailing it then carries a forward chevron.
MinimalFormSection
Grouped form rows the Minimal way: no card — an uppercase group label over a hairline, the rows (each drawing its own rule under it), and a quiet footer line. It takes no inset of its own; the page's gutter is the measure. Compose MinimalInputRow, MinimalFormRow, picker and date rows inside it. A section holding a select or a date row keeps their measure (320 from the compact width up), every other row, its label and hairline with them, so the group's rows end on one edge.
MinimalGap
Square gap for Rows and Columns: MinimalGap(MinimalSpacing.s16).
MinimalGiveWayRow
children start to end at their natural widths, or narrower in proportion when the row's width cannot hold them; the children at fixed indices (a hairline, a gap) never give way. With stretch every child takes the row's full height; else each is centred in it.
MinimalGroundFill
Publishes fill as the ground the parts in child stand on (see minimalGround). A translucent fill is laid over the ground around it.
MinimalGroundScope
Stands child on ground: on MinimalGround.media, in the host's dark tokens under a light status bar; on MinimalGround.surface, as it is. The shell mounts one around its bar, MinimalPage(ground:) one around a page.
MinimalHeatmap
A habit's or a contributor's record as a grid of small squares — one column per week, seven days down (Monday first), oldest week at the start: at the left, or at the right in a right-to-left language, so time runs the way the page's charts run. Each day is a level: 0 nothing (the hairline colour, by night the stronger hairline's), 1 some (the success colour at half strength), 2 full (success); days past the end of levels are the future and stay blank. today is outlined in the ink.
MinimalHitTarget
Hands the MinimalLayout.minHitTarget margin on through a parent that hugs small controls — a 28 px strip of pills, a bare Row holding a switch, a 20 px content line inside a padded row. A render box rejects every point outside its own size before any child sees it, so a control's own inflated target (MinimalPressable) is cut off wherever an ancestor is smaller than 44 px; wrapping that ancestor here restores it.
MinimalHost
The one mount of Minimal in a host app. Picks the theme for the brightness in force, installs it with a MinimalTheme (the dark theme riding along for media grounds, its page transitions on every platform), paints the ground, hosts the toasts (MinimalToaster), carries status-bar polarity, and clamps text scaling at MinimalChromeMetrics.maxTextScale (200%), the largest size its parts are laid out for. Every render host mounts it once above its Navigator: the app in its router builder, a page preview in its own.
MinimalHoverCard
A preview shown while a pointer rests on child, or the keyboard is on it: a person's card behind a name, a link's page, an issue's summary. The same floating panel as MinimalPopover, width wide, padded 12 px; it opens after 0.7 s and stays while the pointer travels into it. A long press opens it on touch.
MinimalIcon
Minimal's glyph: an icon drawn at the theme's stroke, in the quiet ink unless told otherwise. Every Minimal component draws its icons through it, and a page should too.
MinimalIconButton
Minimal's square icon control: a 32 px square (28 or 40 by size) holding an 18 px Lucide glyph — the top bar's actions, a row's overflow, a sheet's close. The hit area pads out to 44.
MinimalIconSize
Icon sizes. i18 is Minimal's own default glyph; i14 is the glyph a 28 px pill or a small button carries.
MinimalIconTile
A glyph in a square — the leading element of a row that names a kind of thing (a settings entry, a category, an integration): 28 px by default, the glyph in the tone's ink. The neutral tone stands on the surface in a 1 px hairline; any other tone fills with its quiet tint and draws no rim, as a toned tag (the tone's ink and fill are its only colours). Decorative: the row beside it says the words.
MinimalInputGroup
A field with add-ons inside one box: a fixed text before or after the value (https://, .com, kg), a glyph, a button. The box is a MinimalTextField's, and so are its states: its rule turns to the focus accent, 1.5 px in from the outline, while anything in it has focus, and the danger rule at rest when error says. A text add-on stands on the quiet fill behind a hairline, as one part of the box. A tap on the box or a plain add-on puts the caret in the field.
MinimalInputOtp
A one-time code (a sign-in code, a PIN) as a row of boxes over one input: paste, the platform's SMS autofill and Backspace work as in any field. The boxes join edge to edge in groups of groupSize (three and three for six), a short dash between groups: a group is one outline, its boxes split by single hairlines. A box prints its figure in Geist Mono; the box the next figure goes in wears the focus colour, with a caret while it is empty. error turns every rim to the destructive ink and prints its message under the boxes. A long press or a secondary click offers Paste, in Minimal's menu, while the clipboard holds text.
MinimalInputRow
A labeled text field inline in a form: the label in the quiet ink in a column at the start, the boxless field in the ink beside it, and the row's own hairline under both — the accent while the field has focus, the danger with an error, whose message prints under the row. Narrow rows (under 280 px) stack the label over the field. mono: true sets the value in Geist Mono, for a number, an id or a time.
MinimalInsets
EdgeInsets shortcuts on the spacing scale.
MinimalInventoryGallery
minimalInventory listed in Minimal's own hand: each group under a section header counting the rows Minimal carries, each row its name in mono over its live specimen (a page in a card as tall as its bar and rows; a split in a card, and a side sheet, in a 220 px band; a scroll area and a palette in a card; a card across the column; a dialog, the sheets and a toast at their own widths; the floating parts with room for their shadow), and the gap's reason in place of one.
MinimalKbd
An inline key cap — ⌘, K, Esc — the shortcut a menu row or a command palette prints beside an action: a small mono label on the quiet fill in a flat hairline box, as every Minimal edge is. MinimalKbd.chord prints a whole chord ('⌘ K') as caps side by side, left to right in every language, as a code reads, and announced as one shortcut. The modifier symbols (⌘ ⇧ ⌥ ⌃), which the mono face does not carry, are drawn as glyphs — so a component that prints a shortcut prints caps, never the symbols as text.
MinimalKitPanel
A floating panel (a popover, a menu, a list of options): the surface on shapes.medium with its hairline rim and the menu's shadow, clipped to the outline. style's fill, edge or side and shape win.
MinimalKitRow
One 32 px row of an open list or menu (an option, a menu item, an action). A chosen value is said as Minimal says a choice: its words in the full ink at medium weight, with the accent check; in a list that picks one (choosing) the other options stay in the muted ink. The active row (the keyboard's, or the pointer's: an open list follows the pointer) takes the muted fill, a place and not a choice, so it never reads as a second chosen row; a destructive action the destructive ink.
MinimalLayout
Responsive layout invariants shared by Minimal apps.
MinimalLinearProgressIndicator
A quantity in flight — an upload, a goal, a quota — as a 4 px hairline of fill on a quiet track, clamped to 0..1. A new value eases to its width in MinimalMotion.base, and jumps there when the platform asks for reduced motion. A null value is work whose total is unknown: a third of the fill sweeps along the track, and stands still at its start under reduced motion.
MinimalLineChart
A series over a run of labels — signups a day, revenue a month, two plans against each other: 1.6 px lines with round joins on a plot of hairline rules, the values' scale in mono down its start edge and labels in mono under it, a legend over it when there is more than one series. The first series takes the accent.
Words that act: "Forgot password?", "View all", "Terms". The accent's ink with a thin underline a little below the baseline, in the size of the line it sits in (style unless stated, else the body). A link that leaves the app (external) ends in a small arrow out, mirrored right to left.
MinimalListSection
A vertical group of MinimalListTiles divided by hairlines — Minimal's list: no card around it, rules between the rows.
MinimalListTile
The workhorse row: an 18 px glyph (or a leading tile or avatar), the 14/500 title with an optional caption under it, then a trailing accessory, a mono meta figure and an optional chevron — 44 px tall (dense: 36), padded by the screen gutter so it runs edge to edge.
MinimalLoadingState
Minimal's three render states for a page that waits, fails or has nothing to show. They share one centred, announced layout: the bare glyph in its ink, a 15 px title, a quiet line, and at most one action as a small bordered button — a status report in type, not an illustration, with nothing drawn around the glyph. A centered loading indicator with a screen-reader announcement. The icon stays still under reduced motion.
MinimalLocalizations
The words Minimal's parts say when the caller gives none.
MinimalLocalizationsEn
Minimal's words: the shared ones from ui_core, Minimal's own in English.
MinimalMedia
An image in the theme's shapes.small inside a hairline — real corpus imagery for a declared media slot, or Minimal's placeholder while it is pending: a muted, deterministic gradient under a faint diagonal hatch, the drafting-table sign for "an image goes here".
MinimalMediaImage
Trusted image delivery for one declared media slot, shared by MinimalMedia.media and MinimalAvatar's media:: the bundled assets/media/<slot>.jpg first, else the durable link assets/media/remote.json maps the slot to. While a linked photo is still being made, fallback stands in under a slow sheen; the photo replaces it when it lands. A slot with neither, or a link that failed (404) or never landed within 15 minutes, shows fallback plain. A pending image never delays layout, first paint or publication.
MinimalMediaSource
A declared media slot's photograph as an ImageProvider, for the APIs that take one rather than a slot id (a kit's image:, a section's picture:, a sample's image: (name) => …), so no page loads assets/media/ by hand.
MinimalMenu
Anchored actions and checked choices: a compact card on the surface, a hairline all round and a menu's shadow, of 32 px items — a glyph, the label, a mono shortcut, a check for the current choice. It opens under the control (above it when the space is below is short), aligned to the control's nearer edge, fades in over MinimalMotion.fast, and closes on a choice, a tap outside or Escape, handing the keys back to the control.
MinimalMenuBar
A row of menus across a desktop app's top: File, Edit, View. A quiet strip on a hairline (its outline shapes.small), its menus' names in the control weight; an open menu's name stands on the quiet fill, and its menu is Minimal's card of 32 px items (a glyph, the words, the key caps or a chevron to a submenu, a check), the active item in the selection fill.
MinimalMenuEntry
One entry of a MinimalMenuBar: a top menu or a submenu (children), a command (onPressed), or a hairline between groups (MinimalMenuEntry.divider).
MinimalMenuItem
One menu action, optionally checked, destructive, disabled, carrying a keyboard shortcut or starting a new group; a null onPressed disables it.
MinimalMetaRow
A dense single-line metadata row: small fixed leading and trailing adornments around a flexible middle that ellipsizes. Only middle absorbs width; keep the fixed slots to a glyph, a tag, an id or a time so the row always fits its line. At large text (from MinimalChromeMetrics.rowStackScale) the slots flow onto lines of their own.
MinimalMeter
How full something is against its limit — storage used, seats taken, a budget spent: label and the reading (valueLabel, else the percentage in mono) over a 6 px bar (shapes.pill). The fill is the ink while all is well, turns the warning colour from warningAt and the danger colour from destructiveAt, so the bar says when to act. Unlike a progress bar it is not work in flight: it does not move on its own.
MinimalMotion
Motion durations and curves. Minimal motion is instant: fades finish inside base, nothing bounces and nothing scales.
MinimalMultiSelect<T extends Object>
Several choices as tags in one field: labels on an issue, recipients, skills. The chosen values stand as small tags (the quiet fill, a remove cross) in a box that grows a line as they wrap; typing suggests more from options in Minimal's panel, and with onCreate free text becomes a tag on Enter or a comma (a pasted "a, b, c" makes three).
MinimalNavigationBar
Minimal's bottom navigation: a slim bar docked on the bottom edge — a 1 px top hairline over MinimalChromeMetrics.tabHeight of the ground, then the bottom safe area — with a 20 px glyph over a 10.5 px label per tab. The current tab is the ink; the rest are the quiet ink. An optional action stands as a square at the trailing end: the app's one act reachable from every root.
MinimalNavigationDrawer
The app's places as a sidebar for a wide window, the way a desk tool lays them out: header on top (the workspace, a search), then sections of 32 px rows — a 16 px glyph and the label — inset from the sidebar's edges; footer at the foot. A hairline runs down its end. The current row is said in type alone: its glyph and label in the full ink, the label at medium weight, the rest in the muted ink; nothing behind it.
MinimalNavigationRail
The app's top-level places as a narrow rail at a window's start edge — a tablet, a desktop window too narrow for a sidebar: each destination a glyph over its label in a 56 px cell, a hairline down its end. The current one is said in type alone: its glyph and label in the full ink, the label at medium weight, the rest in the muted ink; nothing behind it. The same MinimalNavItems the phone's MinimalNavigationBar takes, so a shell swaps one for the other as the window widens.
MinimalNavigationSection
A titled run of a MinimalNavigationDrawer's destinations ("Workspace", "Your teams"); a null title prints none.
MinimalNavItem
A destination in a MinimalNavigationBar. The standard constructor shows its icon and text. MinimalNavItem.iconOnly uses semanticLabel to announce a destination with a hidden label.
MinimalNumberField
Bounded integer adjustment — guests, servings, pages, sets: a compact bordered 32 px control of − · value · +, the value in mono with tabular figures so the box never changes width as it counts. The parent owns the value.
MinimalPage<T>
The go_router Page for a route pushed off a root: a page route that runs the page transition the host's theme installs (Minimal's push under MinimalHost), as Material's own page does.
MinimalPageDots
Which of a few pages a carousel or an onboarding run stands on: a dot for each, the current one drawn long in the ink, the rest small on the control edge's ink (3:1 on the ground) — a capsule role, so the dots follow shapes.pill. The current dot grows into place in MinimalMotion.base.
MinimalPageFoot
Marks a page's footer (its act: Create, Save) so a toast never covers it: MinimalScaffold wraps its footer in one, and showMinimalSnackBar lifts the toast over every marked foot on the current route that stands at the window's foot. A page calls the toast with its own context, which is above its scaffold, so the feet are found by registration rather than by an inherited lookup.
MinimalPageTransitions
Minimal's push, as a PageTransitionsBuilder: the incoming page fades in over MinimalChromeMetrics.push while travelling MinimalChromeMetrics.pushSlide from the trailing side, and leaves the same way over MinimalChromeMetrics.pop. The page underneath stays exactly where it is — no parallax, no dim. minimalPageTransitions maps it to every platform.
MinimalPagination
The way through a long list split into pages — a table's rows, search results: Previous, the page numbers (the first, the last and the current one's neighbours, an ellipsis for each gap) and Next. Each number is a 32 px square on the shapes.small step in mono; the current page stands on the surface inside the control edge, the rest are bare. Under 360 px it folds to "Page 3 of 12" between the two arrows.
MinimalPaintsFocus
Inside it, a pressable under keyboard focus draws no ring: the row it presses paints the keyboard's place itself (an open menu's item, on the muted fill).
MinimalPasswordField
A password field: a MinimalTextField that hides what is typed, and at its end an eye that shows it (and hides it again), announced as Show password or Hide password. The field keeps its focus and caret as it flips; the keyboard never learns a shown password. With hideOnBlur a shown password hides again when focus leaves the field.
MinimalPieChart
Parts of a whole — spend by category, plans by count, a disk by kind: a donut of the slices in the chart palette with a 2 px gap of the surface between them, and in its hole the total (or centerValue and centerLabel); beside it (under it when narrow) a legend of each slice's swatch, label, value and share. Keep it to five or six slices; fold the rest into "Other".
MinimalPlaceholderImage
Reference to a placeholder image — never a URL, because network images are banned so every render is deterministic and offline-safe.
MinimalPlanColumn
One column as the plan sees it.
MinimalPopover
A small card a button opens beside itself: a filter's options, a date and its note, a share link, a short form. Minimal's floating panel (the surface on components.menu's shape, else shapes.medium, with the rim and the menu's shadow), width wide, padded 12 px; it fades in and slides 4 px from its anchor.
MinimalPressable
Adds keyboard, pointer and screen reader support to a custom control.
MinimalPreview
One page's isolated preview: the same host, bar, route and card the app gives the page live, without the router, so preview pixels match in-app pixels. The route decides the page's chrome exactly as it does live: a root leads with its title, a pushed page gets the back button and breadcrumb, a sheet page stands in the card with its close.
MinimalPriorityIcon
The glyph of a MinimalPriority, painted to sit beside a MinimalStatusIcon in a row: three rising bars filled to the level (high three, medium two, low one, the rest faint), urgent as a filled square in the destructive colour with an exclamation cut out of it, and no priority as three faint dashes. The bars print in the secondary ink, so priority reads by shape while status keeps the colour.
MinimalProperty
One row of a MinimalDescriptionList: the property's glyph, its name in the quiet ink on a fixed label column, then its value in the ink.
MinimalPropertyBar
A create form's row of MinimalPropertyPills, wrapping onto a second line rather than overflowing: the set properties first, then the ones still to choose. Every pill keeps its 44 px target, the first and last lines' included.
MinimalPropertyPill
A create form's property as a 28 px pill — ⟳ Every evening, 🔔 21:30 — the control that opens the property's menu or picker.
MinimalRadio
Minimal's radio: a 16 px circle on the control edge that takes the accent rim and a dot when it is the choice. Round by meaning in every corner family, so it never reads as a checkbox. Its press wash and its focus ring are circles too, the ring concentric outside the edge.
MinimalRadioGroup<T>
A single choice among a few options, all in view — a plan, a delivery speed, a theme: a column (or a row) of MinimalRadios, each followed by its label in the body type and a quiet description. A tap anywhere on an option's words chooses it. From the keyboard the group is one Tab stop, as Flutter's RadioGroup is: Tab lands on the choice (the first option while there is none) and leaves the group next. The arrow keys choose the next or the previous option, skipping disabled ones and wrapping at the ends: Down and Right the next, Up and Left the previous (Left the next in a right-to-left layout). Space chooses the focused option. More than five or six options, or long ones, belong in a MinimalSelect.
MinimalRadioOption<T>
One option of a MinimalRadioGroup: the value it stands for, its label, and a quiet description under it.
MinimalRailAction
The shell's act as a rail's leading square: the ink square (the accent's when MinimalShellAction.primary) the bottom bar ends with, standing at the top of the rail instead. MinimalShell and MinimalPreview stand it in their rail form.
MinimalRangeSlider
A range between two ends: a price band, a time window, an age range. A MinimalSlider's track and thumbs, twice: the 4 px track in the hairline ink, the accent between the two 16 px ringed thumbs, under a label line that prints both ends in mono.
MinimalRating
A score out of max stars — a review, a difficulty, how a session went: stars drawn in the ink when filled and on the control edge when not. A read-only rating (no onChanged) is a mark that can show halves: a score shown, not a control switched off, so it does not dim.
MinimalRefreshIndicator
A list refreshed by a pull past its top: an inbox, a feed. While the pull is short a small arrow fades in, bare in the band the pull opens above the list, and turns up once the pull is far enough to refresh; letting go there shows Minimal's spinner in the same place until onRefresh completes, then a check as the band closes. Nothing floats: no disc, no shadow, the mark only ever stands in the list's own air.
MinimalReorderableListView<T extends Object>
A list the reader puts in order: a playlist, priorities, a checklist's steps. Each row is a 44 px line on a hairline with a grip at its start; a press on the grip drags at once, a long press anywhere drags on touch, and the row under the finger lifts onto the surface with the menu's shadow, its outline shapes.small.
MinimalResizable
Two panes and a divider that resizes them: a list beside its detail, an editor over its output. The divider is a hairline (the focus colour at t.focusWidth while the keyboard is on it, the firm hairline while it is dragged); with handle, a small grip stands on its middle. Its target is 12 px across, over both panes' edges.
MinimalReveal
The arrival and departure of a row or a block inside a Column or a list: its extent grows from nothing while it fades in, and on the way out it fades while its neighbours close over it — MinimalMotion.base (120 ms) on MinimalMotion.out, no bounce, no scale.
MinimalRingRoom
A clip as large as its box and a focus ring's reach round it (its gap and its stroke): what cuts a scrolled run of controls without cutting the ring of the one at its edge.
MinimalScaffold
Root of every Minimal screen: the ground, the safe areas, a scrolling body by default, and chrome the route derives (MinimalRouteChrome).
MinimalScrollArea
A region of a page that scrolls on its own: a long list in a side panel, release notes in a card, a wide table sideways. Its scrollbar is Minimal's: a 6 px bar in the tertiary ink inside a 12 px track at the end edge (or the bottom), the content kept 16 px off that edge so it never runs up to the thumb, shown while it scrolls and while a pointer rests on it, then faded; a dragged thumb darkens. The thumb drags, a press on the gutter pages toward it, and the region is a tab stop the arrows, Page Up and Down, Home and End scroll, a focus ring round it while the keyboard is there.
MinimalScrollBehavior
How a scroll looks under Minimal: a thin bar in thumb on a desktop, the stretch on Android, and nothing of Material's. MinimalTheme installs it.
MinimalSearchEntry
A search that opens elsewhere: it looks like the field — the glyph, the label as its placeholder, an optional detail line, the shortcut caps — but is one tappable control that opens the search page or palette. An optional filter square stands beside it, as tall as the entry; while filters are on, its hairline and glyph turn to the full ink and an ink dot marks its corner. Like the field, it stands in a 44 px band so both controls keep their whole touch target.
MinimalSearchField
Search as Minimal draws it: a 32 px field on a hairline at the control radius — the search glyph, the query, and at the end the shortcut's key caps while the field is empty, the clear glyph once it holds text. Escape clears a query. When empty, Escape dismisses the enclosing popup or leaves the field. Focus turns the rule to the accent, 1.5 px in from the outline, with no ring outside it. showCancel adds a quiet Cancel beside the focused field; scopes (two or more) print a strip of MinimalFilters under it.
MinimalSection
A page region: the uppercase group-header label over its content, with an optional mono count and a trailing text action on the header's end, and the page's rhythm above it.
MinimalSectionHeader
The header over a group of full-bleed rows — MORNING 2/3: the label upper-cased in the label register, with a mono count (or any trailing widget) at the end, on the gutter with 14 px of air above and 6 below. No rule of its own: the rows under it draw theirs.
MinimalSeekIntent
The keyboard walk of a strip of views, as an intent.
MinimalSegmentBar
A count out of a small whole as a row of segments — 3/5 kept as three filled of five: one 6 px segment per unit with 3 px between, filled in the tone from the start, the rest in the hairline colour. Past 24 units the segments would be slivers, so use MinimalLinearProgressIndicator instead.
MinimalSegmentedButton<T>
Two to four mutually exclusive views of the same content — Week · Month · Year, List · Board — as a bordered 32 px control (28 with small: true): a hairline track on the ground, and the chosen segment's hairline in the ink, its words at medium weight, sliding to the chosen segment. Use chips for filters and a picker row for a longer set of choices.
MinimalSelect<T>
A form row that shows the current choice and opens the rest: the label in the quiet ink at the start, the chosen value (its glyph, its label) in the ink at the end over an up-down chevron — or a forward chevron when it opens a sheet. A 44 px hairline row, like every Minimal form row; with no onChanged or no options it is disabled: it dims, and its value takes the quiet ink, so it never reads stronger than an enabled row's. It rules itself: stand it in a MinimalFormSection, never in a MinimalListSection.
MinimalSelectionGroup
A single choice set out as hairline rows: a rule over the first MinimalChoiceRow, each row's own rule under it, no card and no inset of its own (the page's gutter is the inset). Where the group runs edge to edge (a phone page's lists do), padding insets the rows' words and checks while the rules still span the screen. Once a row is chosen the others' titles stay muted, so the choice reads at a glance. The arrow keys walk the options. Keep the chosen value in page state and wire every available option to update it.
MinimalSelectionList<T>
A single-choice list of MinimalSelectOptions: hairline rows with the accent check on the chosen one and each option's subtitle under its label — the body of a picker sheet, or a preference page of its own.
MinimalSelectOption<T>
One choice a picker offers: a stable value, the label it prints, an optional explanation and glyph. A disabled option shows but cannot be chosen.
MinimalShapes
The corner scale every framed part reads, on MinimalThemeData.shapes: each size is derived from the base radius.
MinimalSheet
A panel the full height of the screen, from its start or end edge: a record's details beside a list, filters, settings, a phone's navigation. The surface with a rim on its inner edge and the large shadow, square: it runs from the screen's top edge to its bottom, where a round corner would expose the shadow behind it. A style's shape rounds its inner corners alone. A header prints title (and subtitle as its pill) with a close button; child scrolls under it, and the footer holds leading and trailing over a hairline.
MinimalSheetAction
One action in a sheet's footer row — Cancel beside Create habit.
MinimalSheetFooter
A sheet card's footer line — what MinimalBottomSheet prints under its hairline, for a sheet PAGE (a MinimalScaffold in a MinimalSheetPage) to pass as its footer:: the accessory (a "create another" MinimalSwitch(showLabel: true), a hint) at the leading edge, the leading secondary and trailing confirming actions at the trailing one. When the two do not share a line — a long label, a larger text scale — they stack, each keeping its own edge. An action with no onPressed dismisses the sheet.
MinimalSheetHeader
The sheet card's header band — the context the sheet acts in as a small filled pill, what the sheet is, the header's actions and its close at the far end. After a pill the title is a quiet crumb (Habits New habit); alone it names the sheet as a dialog names itself, in MinimalThemeData.h3 (Filters). One widget, so the static MinimalBottomSheet, the modal sheet and a sheet page's derived MinimalAppBar print the same band.
MinimalSheetPage<T>
The go_router Page whose route is Minimal's page sheet: the modal card (or, with drawer: true, the edge-attached drawer), created on the root navigator so it rides above the shell's bar. In a wide window (MinimalBottomSheet.centresAt) the card stands centred over the page instead (MinimalBottomSheet.centredRoute); the drawer stays a drawer. A go_router route on the root navigator (parentNavigatorKey:) returns it from its pageBuilder with key: state.pageKey.
MinimalShellAction
An action available on every tab in the shell. The action supplies its icon, callback and screen-reader label.
MinimalShellInsets
The bottom allowance the shell's bar asks every nav root to reserve: published by MinimalShell over its branch container (and by a preview that stands the bar under a lone page), spent by MinimalScaffold on its scroll padding and by showMinimalSnackBar on its inset.
MinimalSignInButton
One Continue with <provider> button: Minimal's 40 px bordered button carrying the provider's mark — the real colours on the neutral surface, the mono silhouette in the on-accent ink on the accent fill — so every sign-in reads as one family in the app's own theme. Disabled, every mark turns to its mono silhouette in the label's ink and dims with the words, so no brand colour is left lit.
MinimalSignInStack
The providers a sign-in page offers, stacked full width at the dense 8 px gap — the first in emphasis when leadWithFirst is set. onPressed receives the slug chosen; null disables them all (a request in flight).
MinimalSkeleton
A placeholder in the shape of what is loading — a line of text, an avatar, a card — so the page keeps its layout while it waits: the hairline's grey (by night the stronger hairline's), pulsing gently (still under reduced motion). MinimalSkeleton is a block on the shapes.mark step; MinimalSkeleton.text a run of lines, the last one shorter; MinimalSkeleton.circle a face's circle. Skeletons are silent to a screen reader: announce the wait once, around them (a MinimalLoadingState, or a Semantics label on their column).
MinimalSlider
Continuous or stepped adjustment on a thin track: a 4 px hairline-weight track filled with the accent up to a 16 px ringed thumb, under a label line that prints the value in mono. Use a MinimalNumberField when the exact small integer matters.
MinimalSnackBar
The toast's card on its own — what showMinimalSnackBar floats above the page, as a plain widget: the surface on a hairline with the menu shadow, an optional 16 px glyph, the message in 13 px text and, with actionLabel, one action in the accent's ink. Compose it statically for a specimen or a screenshot; a page confirms through showMinimalSnackBar.
MinimalSpacing
Design tokens and theme assembly — the only styling vocabulary a Minimal screen uses.
MinimalSparkline
A trend line with no axes — the shape of a series inside a stat, a KPI cell or a row, never a chart in its own right: a 1.6 px line with round joins over a faint area, ending on a dot where the series stands now. The line spans the series' own range; a flat series (every value equal) runs through the middle of the box, steady rather than zero. Time runs from the start edge, as in Minimal's bar and line charts: right to left, the series begins at the right and stands now on the left.
MinimalSplitButton
A button whose action has close relatives: Save, and beside it a chevron that opens Save as, Save a copy. The two halves are one MinimalButton cut in two (each takes its share of the outline, a hairline between on a filled or outlined register; a ghost pair, with no frame, is divided by space), in any variant and size; the keyboard's ring stands outside the focused half, as a button's does, on that half's share of the outline (round on its outer side, square at the seam). The menu is Minimal's card of 32 px items under the chevron's end, the active item in the selection fill.
MinimalStat
A dashboard figure: the uppercase label, the value in mono with tabular figures, an optional delta and a line of detail, and an optional sparkline.
MinimalStatRow
Figures side by side, matched in height even when their contents differ (one carries a delta or a sparkline, its neighbour does not): separate tiles 8 px apart, or with MinimalStatRow.joined one bordered strip.
MinimalStatusBadge
A small bordered status label with a leading dot — an order's Late, Baking, Ready. The states that need attention (success, warn, danger) ink their label and tint their border; the waiting ones (neutral, accent) keep the ink and let the dot alone carry the colour, so a table of badges reads by exception.
MinimalStatusIcon
The glyph of a MinimalTaskStatus, painted at the icon stroke so it sits in a row beside Lucide glyphs: a dashed ring for backlog, a ring for todo, a half-filled ring for work in progress, a filled check for done, a ring with two bars for paused and a filled cross for cancelled. The check and the cross are cut out of their disc, so whatever row the glyph sits on (a highlighted one, a table header) shows through them.
MinimalStatusView
One of a page's render states by name — waiting, failed, done or empty — in the shared centred, announced layout: the bare glyph in its ink, a 15 px title, a quiet line and at most one action. The named constructors are the four; MinimalLoadingState, MinimalErrorState and MinimalEmptyState are the same views by their older names.
MinimalStepProgress
A short run of steps toward one goal — an onboarding, a checkout, an import: a numbered circle for each step joined by hairlines, its name under it. A finished step is the ink circle with a tick and an ink line on to the next; the current one is said in ink and weight, its circle an ink rim round its number and its name at medium weight in the ink; the steps ahead stay on the control edge in the faint ink. The circles are round by meaning in every corner family. Too narrow for every name, it prints the current step's alone ("Step 2 of 4 · Plan").
MinimalSwipeAction
One action a MinimalSwipeActions row reveals: a square the row's full height on the muted ground, holding the glyph over a short label in its tone's ink.
MinimalSwipeActions
Leading and trailing swipe actions for a list row: dragging the row aside reveals square actions the row's full height on the muted ground, a hairline between each, with no rounding and no gap: the acts are words, as everything in Minimal is; no block of colour stands behind them.
MinimalSwitch
Minimal's on/off switch for a preference: a compact 32 × 18 track with a 14 px thumb, the accent when on and the strong hairline when off. It sits in a row's trailing slot beside the words that name it; give a standalone switch a label so a screen reader can say what it turns on.
MinimalTabBar
In-page section tabs — Overview · Activity · Notes on a detail page: a 44 px strip over the page's hairline, 13 px medium labels (the current one in the ink, the rest quiet) with an optional mono count beside each, and a 2 px ink underline under the current tab. A strip wider than the screen scrolls sideways.
MinimalTable
Minimal's dense data table — the back-office list where every row is a record and every column a field: a 30 px header on the quiet fill with uppercase labels, 40 px rows divided by hairlines (the dense-list exception to the 44 px target, with the table palette's 36 and the menu's 32), figures in right-aligned mono, dot badges for status, and no card around it. It runs edge to edge, so stand it in a padding: EdgeInsets.zero screen.
MinimalTableGround
What a table that scrolls sideways stands on: its header's band, a picked row's wash and its rules, drawn across the whole frame the table scrolls in, under the strip. The strip's edge fade masks all it holds, so a band or a rule drawn in the strip would fade with the words and stop short of the frame's edge; drawn here they reach it, and only the words fade. A row on one hands its ground to it through a MinimalTableGroundRow and paints none itself.
MinimalTableGroundRow
One row of a table on a MinimalTableGround: fill across the frame (the header's band, a picked row's wash), top and bottom rules on its edges, at opacity (a faded row's). header is the band, drawn over any row scrolled up under it. Off a ground it draws nothing; the row paints its own.
MinimalTableRow
One row of a MinimalTable: its cells, one per column, and its state.
MinimalTag
A small static label ("Paid", "New", "Overdue", "v2.4"): 20 px tall on the small radius, its tone's quiet fill behind the tone's ink in the caption register. A tag says what a record IS; it is never a control — a filter is a chip, a status with a dot is a badge.
MinimalTapAlignment
Where the faces of the controls under it stand in their tap targets (MinimalPressable.tapAlignment for the ones that do not say): a list row's trailing slot stands its control on the end keyline, a field its trailing keys. Not exported: the parts set it.
MinimalTapBand
child (a face face tall, or its own height when null) laid out with as much room above and below as brings it up to the tap floor at the context (minimalTapFloor), and, when across is set, as much at either side as brings a face across wide up to it. A tap in the room, or on the face's outermost inset, lands inset inside the face's nearest edge, where its own control takes it.
MinimalTapReach
child reached from anywhere its parent lets a tap through: a tap past its box, or in its air between and round its parts, lands inset inside the nearest part's nearest edge (past its rim). For a run of controls smaller than the box they stand in (a field's tags and entry, a short tag beside a taller entry), so a tap in the box's air above or below them reaches the one under it.
MinimalTextArea
A field for more than a line — a note, a description, a message: the MinimalTextField box, label, helper and error, resting at minLines and growing with what is typed up to maxLines, then scrolling. Enter starts a new line rather than submitting.
MinimalTextField
Minimal's text field: a 32 px box (the control height a md button shares) on a 1 px rule at the control radius, a 12 px label above it, a helper or an error under it. Focus turns the rule to the accent (the danger's when the field is in error). Keyboard focus draws a single 2 px accent ring over the rule. mono: true sets the value in Geist Mono with tabular figures, for a number, an id, a time; a suffix prints its unit at the end. Read-only and disabled fields sink onto the quiet MinimalThemeData.sunken fill; a disabled one dims to the kit's 0.45.
MinimalTextTheme
Minimal's type scale, as Material's TextTheme: complete styles with family, size, weight, height and colour baked in. Geist for words, Geist Mono (tabular figures) for giant, figure and mono, whose word gap is Geist's space rather than a full mono cell, so 25 Sep reads as one space and a column of stamps still aligns (a code block restores the cell, MinimalCodeBlock). label is the uppercase group-header register: components print it upper-cased.
MinimalTheme
Puts Minimal in scope for everything under it, as Material's Theme does. It is the whole install: put one in any app's builder:, under a MaterialApp, a CupertinoApp or a WidgetsApp alike, and every look installs the same way (<Look>Theme(data: <Look>ThemeData.preset(...))). Under it, Flutter's own text field and scroll bar wear Minimal's caret, selection, handles and bar, with no ink, every text has Minimal's body style to fall back on, and a page route the app pushes (a MaterialPageRoute, a router's page, of the Material Minimal stands on) moves Minimal's way on every platform (minimalPageTransitions), not the platform's slide or zoom; an app on Flutter's own MaterialApp puts the same map in its ThemeData, as minimalPageTransitions shows. Another one restyles a part of the tree. An InheritedTheme, so what a route or an overlay captures keeps the Minimal it was raised in.
MinimalThemeData
Minimal's theme, as ThemeData is Material's: the colour roles, the type scale, the elevation, the corner scale and the other knobs, Minimal's own row geometry, and the component themes. What MinimalTheme.of(context) (and context.minimalTheme) returns. Immutable: copyWith and lerp make new ones. Install it with a MinimalTheme in the app's builder:, under a MaterialApp, a CupertinoApp or a WidgetsApp alike.
MinimalThemeDataTween
A tween between two Minimal themes, through MinimalThemeData.lerp.
MinimalTimeline
Minimal's audit trail — what happened to a record and when, newest first: one MinimalActivity per row, a mono time column on the left, the event in the ink, hairlines between (the last entry draws none, as a list's last row). It holds the page's measure (it is not full-bleed). When any entry has a MinimalActivity.tone, every entry keeps the dot's slot, so the events start on one keyline. An empty log prints emptyLabel in the faint ink.
MinimalTimePicker
A clock time — a reminder, an opening hour, a quiet-hours end: the MinimalDatePicker in its time mode. compact (the default) is a form row whose mono value opens two scrolling columns, hours and minutes, in a popover (or a sheet that commits on Done, with confirmSelection); wheel stands the columns on the page. Minimal prints the 24-hour clock unless use24HourFormat is false.
MinimalToaster
Hosts Minimal's toasts over child: MinimalHost installs one above the app's navigator, so a page needs nothing of its own. The toasts stand at the foot, centred, at most 560 px wide, inset by the gutter and lifted over the shell's bar and the keyboard. The behaviour is ui_core's (DesignToaster); Minimal paints each toast as a MinimalSnackBar.
MinimalToggleGroup<T>
A strip of toggles, as a toolbar holds them: text formats (any number on, multiple: true), or one view of several (one on). An outlined 32 px strip (28 with small: true) of cells edge to edge, a hairline between them; an on cell's glyph and words take the full ink (the words at medium weight), an off one the muted ink. outlined: false leaves the strip out: loose ghost toggles for a toolbar that draws its own frame.
MinimalToggleItem<T>
One toggle of a MinimalToggleGroup: the value it stands for, its label, a 16 px icon, or both. An icon alone needs a semanticLabel.
MinimalToneColors
The colours one MinimalTone resolves to in the active theme.
MinimalTooltip
A short line that names what is under the pointer — an icon button's action, a truncated value, a shortcut: the inverse surface on the shapes.small step with the words in the caption, a few pixels under child (over it near the screen's foot). It shows after a moment's hover with a mouse, on a long press by touch, and at once while the keyboard focuses the child; it fades in and out (a short fade under Reduce Motion). A tooltip is information, so it is the one surface a hovering pointer raises.
MinimalTrailingChevron
A row's trailing chevron, its ink (not its box) ending on the row's trailing keyline, where a switch's or a count's edge stands. Only the paint moves: the row lays out the glyph's box as before.
MinimalTreeView<T extends Object>
Nested things opened level by level: folders and files, a project's areas, a document's outline. Each row is 32 px: indented 16 px a level, a chevron that turns as its node opens, a 16 px glyph (iconOf) and the words. The selected row is said in type alone, as the sidebar's current page is: its glyph and words in the full ink, the words at medium weight, the rest in the muted ink; nothing behind it. Until a row is selected every row stands in the ink, as a list's rows do.
MinimalTypeface
The two faces the type is set in: sans for every word (the look's Geist), mono for figures, stamps and code (the look's Geist Mono, tabular), each from sansPackage and monoPackage (the package that bundles it, null for the app's own fonts). The look's faces are the default; an app's own fonts work when it declares them in its pubspec and loads them before the first frame.
MinimalUploadFile
One file in a MinimalFileUpload's list: its name, its size in bytes, and its progress (0..1) while it uploads; error when it failed.
MinimalWeekDots
A row's inline week — seven 7 px squares, oldest first: the kept days in the ink, the rest in the hairline colour, and today ringed in the ink with its own day inside (kept or not, as the heatmap marks today), so the row never loses its place in the week and a kept today shows. It sits MinimalSegmentBar.spacing before a row's trailing streak count.
One tab of the shell's navigation: a branch's root, with the glyph and the words it wears. The runtime emits one per StatefulShellBranch, in branch order; the system decides how it looks.
PreviewDevice
The device a platform previews on: its logical size and pixel density. The oracle captures and the gallery's renders use the same numbers.
PreviewFrame
The frame a preview stands in: publishes its platform and brightness to everything inside it, scopes the platform override there, and publishes its box as the screen.
PreviewFrameData
What a PreviewFrame publishes to everything inside it.
PreviewStage
A stage that raises a previewed page on a route over itself once it is on screen, and keeps it raised: how a pushed or sheet page is previewed alone, so its exit renders as it does live and the chrome it derives is the real one (RoutePresentation.pushed or the sheet's).
RenderDesignCapCenter
The render object of DesignCapCenter: keeps its child's size and paints it moved up or down so that its one-line label's capitals sit on the box's middle.
RenderDesignTapTarget
DesignTapTarget's render object: its child laid out as given, itself at least minSize, the child placed by alignment, a hit anywhere in it sent to the child's centre.
RenderMinimalTapBand
MinimalTapBand's render object.
RenderMinimalTapReach
MinimalTapReach's render object.
RoutePresentationScope
Publishes the RoutePresentation of the route it stands in, overriding what the route's position implies. A system's sheet page wraps its child in one with RoutePresentation.sheet; a preview or a hand-built navigator may publish any presentation.
ShellAction
The app-level act beside the shell's tabs: the one thing reachable from every root — add, compose, capture — with the glyph it wears and what it does. A system draws it in its own way (a floating action button, a disc in the bar, a square at its end).
ShellInsets
The bottom inset the shell's bar asks every branch root to keep clear: published by a system's shell over its branch container (and by a preview that stands the bar under a lone page), spent by the system's screen on its scroll padding and by its toast on its inset.

Enums

ChromeGround
The ground a page stands on, which is what its chrome is drawn against: the system's own surface, or media — a full-bleed feed of video or photographs, over which the chrome is dark and solid.
DesignBranchBackBehavior
Where back goes from a branch at its root page.
DesignCalendarMode
How a calendar selects.
DesignChartXAxis
What a DesignChart's x values are.
DesignColorChannel
A channel a DesignColorSlider sets.
DesignDateSegmentType
The kinds of segment a date or a time field is typed in.
DesignInput
What reaches a look's controls: a finger, or a pointer (a mouse, a trackpad, a stylus that hovers).
DesignMenuLevel
Where a DesignMenuBar's builder paints: the bar, a menu or a submenu.
DesignNavigationMode
How a shell shows its destinations.
DesignOverlayAlign
How a surface lines up with its anchor along the side it sits on.
DesignOverlaySide
Which side of the anchor a surface sits on. start and end follow the text direction.
DesignOverlayTrigger
What opens an anchored surface.
DesignRefreshMode
Where a pull stands.
DesignScrollbarVisibility
When a DesignScrollArea's scrollbar shows.
DesignSelection
A page's selection, for its select-all checkbox.
DesignSheetEdge
Which edge a DesignSideSheetRoute comes from.
DesignSortDirection
Which way a column sorts.
DesignSplitPart
Which part of a split button a builder paints.
DesignToastClosedReason
Why a toast left.
DesignWindowSizeClass
Material's window size classes, by width in logical pixels.
MinimalButtonScale
A button's height, as MinimalButtonSize names them: 28, 32 or 40 px.
MinimalButtonSize
A MinimalButton's height: 28, 32 (the default) or 40.
MinimalButtonTone
A button's fill, as MinimalButtonVariant names them: the primary fill, the bordered neutral, bare ink, the destructive fill.
MinimalButtonVariant
The visual treatment of a MinimalButton.
MinimalComposerStyle
A MinimalComposer's register: messages is the one-line bordered box a chat or a quick reply rests in, the attach and send squares inside it; assistant is the issue-comment box — a taller writing area over its own toolbar (attach, a model or visibility pill, dictate, send).
MinimalDatePickerMode
What a MinimalDatePicker sets: the day, the clock time, or both.
MinimalDatePickerPresentation
How a MinimalDatePicker stands on the page: compact a form row whose mono value pills open the picker in place; inline the calendar itself (with the time columns under it for dateAndTime); wheel the hour and minute columns alone.
MinimalGround
The ground a page stands on, which is what its chrome is drawn against: the theme's own surface, or media — a full-bleed feed of video or photographs.
MinimalIconButtonVariant
A MinimalIconButton's register: outline the bar's bordered square, ghost the bare glyph a row or a sheet header carries, secondary a quiet filled square, and primary the accent square the one primary act wears, as a primary MinimalButton does — the bar's +.
MinimalMediaKind
What a MinimalPlaceholderImage stands for: it picks the placeholder's glyph and seeds its tint.
MinimalMenuTrigger
How a MinimalMenu opens: a tap on its child, or as a context menu that leaves the child's ordinary tap to the child (a row's context menu).
MinimalPresentation
How a previewed page stands in the app: as a nav root over the shell's bar, pushed off one, or raised as a sheet.
MinimalPriority
How pressing a piece of work is — the five priorities an issue list sorts by, each with its glyph (MinimalPriorityIcon) and its label.
MinimalRouteChrome
Which chrome a route position earns, read off the route itself: a nav root, a page pushed off one, or a page raised as a sheet. MinimalAppBar and MinimalScaffold derive their register from it, which is why a page never authors its own back or close control.
MinimalSearchPresentation
Where a MinimalSearchField stands: inline in a list's header, on the page; toolbar floating over the body (a MinimalScaffold's floating: slot), a taller field on a card with a menu's shadow.
MinimalSeek
Where an arrow key walks a strip of views (a segmented track, a tab strip): one step each way, or to either end.
MinimalSelectPresentation
Where a MinimalSelect opens its choices: the anchored MinimalMenu for a short set, a sheet holding a MinimalSelectionList for a longer one or one whose options need their subtitles.
MinimalSide
The edge of an anchor where a popover or hover card opens. Side sheets use the start or end edge of the screen.
MinimalStatusKind
What a MinimalStatusView reports.
MinimalTaskStatus
Where a piece of work stands — the six states an issue, a habit or an order moves through, each with its glyph (MinimalStatusIcon), its default label and the tone a badge prints it in.
MinimalTone
Semantic colors for statuses, badges, tags and changes in a metric.
PreviewPlatform
The platform a preview is drawn for: its device size and the platform whose behaviour applies inside it. The look is the system's everywhere; behaviour (scroll physics, back gestures, text handling) follows this platform.
RoutePresentation
How a route is presented, which is what a screen derives its bar from: the title on a root, the back affordance on a pushed page, the dismiss affordance on a sheet. A page never authors its own back or close; it reads its presentation (of).

Mixins

MinimalFieldOwner<W extends StatefulWidget>
The controller and focus node a text field owns when its caller passes none, re-wired when the caller swaps them, and the state rebuilt on every edit and focus change. Shared by the boxed field and the search field.

Extensions

DesignSpringDrive on AnimationController
Runs an AnimationController on a spring instead of a duration.
MinimalCountFigure on MinimalThemeData
The mono count style beside a label: MinimalThemeData.mono at MinimalControlMetrics.countFigure.
MinimalFieldType on MinimalThemeData
The mono value style: MinimalThemeData.mono at the value size on its own line height — what a field, a date pill and a calendar day print.
MinimalKitStates on Set<WidgetState>
The states a ui_core builder hands over, read the way Minimal paints them: pressed and focused count only while the part is enabled. This file applies it by name (MinimalKitStates(states).down), so a copy of the file in an app, beside the package's own, reads its own copy unambiguously.
MinimalMotionContext on BuildContext
The one motion switch every Minimal component reads.
MinimalStyleReading on DesignStyleOf
What Minimal's parts read from their layers beyond ui_core's getters.
MinimalTextStyle on TextStyle
Scale-step adjustments that keep a style on the scale.
MinimalThemeContext on BuildContext
The accessor every Minimal widget reads its tokens through.
MinimalToneTheme on MinimalThemeData
Resolves a MinimalTone against the theme: t.tone(MinimalTone.warning).indicator.
PreviewPlatformDevice on PreviewPlatform
The platform's device, as data on the enum.

Constants

designSpringTolerance → const Tolerance
When a spring-driven controller counts as settled, in the controller's own units (a 0–1 progress, or dp for a position):
minimalCapHeight → const double
Geist's and Geist Mono's cap height over their em (OS/2 sCapHeight over unitsPerEm): the label typefaces of every Minimal face.
minimalChevronBearing → const double
The empty share of Lucide's chevron box past its ink's end edge: on the 24-unit grid it is drawn on, the stroke ends at 16.
minimalCrossBearing → const double
The same for Lucide's cross (a close): its stroke ends at 19.
minimalCupertinoWords → const LocalizationsDelegate<CupertinoLocalizations>
Cupertino's words for the app's locale, for an app that gives none.
minimalFontPackage → const String?
The package that bundles Minimal's faces and its sign-in marks, or null when the app does. Every Minimal text style passes it as TextStyle.package, and a sign-in mark looks under its assets.
minimalLucideCut → const Map<int, IconData>
Each glyph of lucide's own face on its 300 cut, by code point. Every entry is const, so a release build can still tree-shake icon fonts.
minimalLucideCutMirrored → const Map<int, IconData>
minimalLucideCut, each glyph mirrored in a right-to-left direction (lucide's …Dir glyphs).
minimalMaterialWords → const LocalizationsDelegate<MaterialLocalizations>
Material's words for the app's locale, for an app that gives none.
minimalPageTransitions → const Map<TargetPlatform, PageTransitionsBuilder>
Page transitions shared by MinimalPage, MinimalFadeRoute and minimalPageTransitions. Durations come from MinimalChromeMetrics. Reduced motion presents the destination in place. Minimal's push for every platform, for a PageTransitionsTheme: a page fades in over MinimalChromeMetrics.pushSlide and a pop reverses it, where the platform's own would slide or zoom it in.
minimalSeekShortcuts → const Map<ShortcutActivator, Intent>
The arrow, Home and End keys every strip of views binds.

Properties

minimalInventory → DesignInventory
Minimal in ui_core's shared inventory: each row's specimen is the Minimal part that answers it, built with plain values, and the one absent row says why. DesignInventory.verify checks every row is answered; a DesignInventoryGallery shows them all.
final

Functions

designMatchScore(String text, String query) → int?
How well query finds text: null not at all, higher better. A prefix beats a word's start, which beats a substring, which beats the letters in order.
designReduceMotionOf(BuildContext context) → bool
Whether the reader asked for reduced motion at context: Android's Remove animations or the web's prefers-reduced-motion (MediaQuery.disableAnimationsOf), or iOS's Reduce Motion (dart:ui's AccessibilityFeatures.reduceMotion, which MediaQuery does not carry).
designShortcutKeys(BuildContext context, MenuSerializableShortcut shortcut, {TargetPlatform? platform, bool appleSymbols = true}) → List<String>
The keys of shortcut (a SingleActivator or a CharacterActivator), one string a key, modifiers first, as Flutter's MenuItemButton labels them:
designShortcutLabel(BuildContext context, MenuSerializableShortcut shortcut, {TargetPlatform? platform, bool appleSymbols = true}) → String
designShortcutKeys joined as a menu row shows them: "⌃ ⇧ N" with Apple's symbols (Flutter's spacing), "Shift+Command+N" in words on macOS and iOS, "Ctrl+Shift+N" elsewhere.
designSpring({required double dampingRatio, required double stiffness}) → SpringDescription
The Flutter spring for the token (ζ = dampingRatio, k = stiffness): SpringDescription.withDampingRatio(mass: 1, stiffness: k, ratio: ζ), so damping = 2ζ√k. Compose's spring(dampingRatio, stiffness) is written against unit mass, so the two run the same curve.
designSpringSimulation(SpringDescription spring, {required double from, required double to, double velocity = 0, Tolerance tolerance = designSpringTolerance}) → SpringSimulation
The simulation of spring from from to to, starting at velocity units per second, that settles at tolerance and lands exactly on to.
designSwipeBack(Map<TargetPlatform, PageTransitionsBuilder> builders, {Set<TargetPlatform> platforms = const {TargetPlatform.iOS}}) → Map<TargetPlatform, PageTransitionsBuilder>
builders with the entries for platforms (iOS, by default) wrapped in DesignSwipeBackPageTransitionsBuilder, so a page there pops with a swipe from the screen's leading edge and otherwise plays the look's push.
minimalArrowGap(BuildContext context) → double
The gap between two small buttons side by side on an end keyline (a month's arrows), both faces on their targets' end: none where a finger's targets already hold the faces apart, MinimalSpacing.s8 where a pointer's do not.
minimalBandFloor(BuildContext context) → double
The tap floor's height of the band a face stands in: under minimalInlineTargets, the floor outside it, else minimalTapFloor.
minimalBareDecoration({String? hint, TextStyle? hintStyle, int? hintMaxLines}) → InputDecoration
The one way Minimal uses Flutter's TextField: the look draws the box (its rim, fill, ring, side air and a minimum height from a control's height), and the editable inside it is bare, exactly one line of text tall, placed by alignment. A line then stands where the look put it under any configuration: the platform's density, Material 2 or 3, larger text, or an app's own InputDecorationTheme between the look and the field.
minimalCapLabel(Widget label) → Widget
label (one line) drawn so its capitals' middle is its box's middle, so a face that centres the box centres the capitals: a button's, a tab's, a segment's, a chip's, a menu item's, a select's, a badge's, a one-line row's and a title bar's. Never around an icon.
minimalCell(OutlinedBorder frame, {required int index, required int count, double inset = 0, Axis axis = Axis.horizontal}) → OutlinedBorder
Cell index of count laid edge to edge along axis inside frame, inset px within it: the first cell keeps the frame's start (or top) corners, the last its end (or bottom) corners, each shrunk by inset so the two outlines stay concentric, and every corner that faces a neighbour is square. The frame's kind carries over (a bevel's cut, a squircle's curve); a capsule's ends stay round.
minimalChartPalette(MinimalThemeData t) → List<Color>
The colours a chart gives its series in order: the accent first, then the ink, then a grey and the tones — so one series is the accent and a second reads against it in either mode.
minimalClip(OutlinedBorder shape, {required Widget child}) → Widget
child clipped to shape: a rounded rectangle by its radii, any other outline by its path.
minimalDisabledOpacity({Color? ink, Color? face, required Color ground}) → double
Fades a disabled control while keeping an explicitly supplied label legible.
minimalFieldWordsStart(BuildContext context, MinimalStyle? fieldStyle, {bool icon = false}) → double
How far a boxed text field's words stand in from its leading edge (MinimalTextField): its rim, its side inset at the theme's density, and past a leading glyph with icon. Where a select's open list starts its options' words, so they meet the field's value.
minimalFocusEdge(MinimalThemeData t, {required bool shown, OutlinedBorder? shape}) → Decoration
A focused field's edge: the accent over the field's rim, reaching MinimalFieldMetrics.focusEdge in from shape's outline and never past it. However focus came (a tap, a click, Tab), the field shows it the same way, with no ring outside, and an invalid field takes the accent while it has focus. Always a border, transparent when not shown: a Container that gains or loses a foreground decoration re-parents its child, and the text field would be rebuilt (and lose its input) on the first focus.
minimalFontFamily(String family) → String
family under the name Flutter registers it by: Geist when the app bundles it, packages/minimal_ui/Geist from the package. A test that loads the faces itself loads them under this name.
minimalFrame(OutlinedBorder shape, {Color? fill, BorderSide side = BorderSide.none, List<BoxShadow>? shadows}) → Decoration
What a framed part paints on shape: its fill, its rim (side) and shadows. A rounded rectangle paints as a BoxDecoration, the look's own path pixel for pixel; any other outline as a ShapeDecoration. A side that is BorderSide.none keeps the shape's own.
minimalGround(BuildContext context) → Color
The ground under the parts at context: the fill of the card, dialog, sheet, panel, toast or banner they stand in (MinimalGroundFill), made opaque over the ground around it; else the page's background. What a focus ring's gap paints.
minimalGrownHeight(BuildContext context, double height) → double
A control's height grown by what the text scale adds to its 16 px label line, so the words keep at 130% the air they have at 100% (the control grows taller rather than crowd its words); height itself at 100% and below.
minimalInlineNode(BuildContext context, Widget target) → Widget
target as its one screen-reader node, as tall as the band it stands in under minimalInlineTargets (a field's clear glyph, its eye): the band's room reaches it, so the box a screen reader outlines is the one a tap reaches. Elsewhere target as it is.
minimalInlineTargets(BuildContext context, Widget child, {double height = 0}) → Widget
child (the controls inside a compact face: a field's clear glyph, its password eye) under floors of height: each control keeps the floor's width, laid out, and stands no taller than the face, whose MinimalTapBand gives it the floor's height. Pass the face's height inside its rim as height where a key is shorter than the face (a 28 glyph in a 40 toolbar field), so the face's air above and below the key is the key's, not the field's. The floors outside stay readable (minimalBandFloor).
minimalKitPresence(BuildContext context, DesignOverlayInfo info, Widget child) → Widget
A surface arriving from its anchor: it fades in and slides 4 px from the side it opens on, on the overlay's spring; still under Reduce Motion (the spring is then critically damped and the slide nothing).
minimalKitRowShape(MinimalThemeData t, [MinimalStyle? style]) → OutlinedBorder
The outline of a row inside a panel: the panel's own, moved in by the panel's 4 px padding so the two stay concentric.
minimalLayered(List<MinimalStyle?> layers) → MinimalStyle?
layers as one style, every slot falling through them state by state as a part's own reading does: for a part that hands its style on to another (a list section to its card). Null when no layer is set.
minimalLeastExtent(List<MinimalPlanColumn> columns) → double
The narrowest columns lay out with nothing cut that must stay whole: each at its least, the tight gap between (the full gap after a column of figures).
minimalLineAir({required double height, required double rim, required double line, double least = 0}) → double
The air above and below a field's text inside its rims so that a first line of line stands where a single line does in a box height tall with rims: half of what the line leaves, never under least. One line in such a box is centred by alignment; this places the first of several.
minimalLineHeight(BuildContext context, TextStyle style) → double
The height one line of style takes at the text scale in context: the look's styles set a line height and even leading, so a line's box is its scaled size times its height.
minimalLoadFonts() → Future<void>
Loads the faces Minimal bundles, so the first frame is set in them. Await it before runApp: on the web a bundled face otherwise arrives after the first frames, which flash in a fallback face. An app that names its own faces (MinimalTypeface.app) loads those itself, the same way, with a FontLoader.
minimalOpenedByKeys() → bool
Whether a menu opening now was opened from the keyboard: one of the keys that opens a menu is held as it opens. A menu the keyboard opened starts on its chosen item; one the pointer opened starts on none.
minimalOpensOnDown({required VoidCallback? open, required Widget child}) → Widget
child, a control that opens a menu with open, also opening it on Down; null open leaves child as it is. Takes no focus and adds no semantics of its own.
minimalPlanColumns(List<MinimalPlanColumn> columns, double room) → MinimalColumnPlan
columns laid out across room, the width of the columns and the gaps between them.
minimalPressInk(MinimalThemeData t, {Color? face, Color? faceInk}) → Color
The ink a press washes a face with, at 8%: of the page's ink and the face's own faceInk, the darker on a light or mid face and the lighter on a dark one, so a press always deepens or lifts the face it lands on (the dark appearance's pale accent deepens; a black solid button lifts). No face reads the page's ground.
minimalRingFrame(OutlinedBorder shape, {Color? wash, Color? ring, Color? ground, double width = 2}) → Decoration
A part's press wash and keyboard ring on shape, as one foreground decoration: the wash over the face; with a ring, _focusGap (2 px) of ground outside the edge, opaque, and the ring at width outside that, concentric with the face. The gap is what lets a ring read on a face filled in its own ink (an accent button's accent ring), and on an outlined or quiet face it is only a clean margin. With no ring the shape's own side, if it has one, paints as minimalFrame would. It animates between states (the ring and the gap fade in together).
minimalScaled(OutlinedBorder shape, double factor) → OutlinedBorder
shape grown or shrunk by factor (a 20 px check on a 16 px scale): its corners and rim; as given at 1, or when it does not scale to an outline.
minimalSeekIndex(MinimalSeek seek, {required int index, required int last, required bool rtl}) → int
The index seek lands on from index in a strip whose last view is last; the arrows follow the reading direction.
minimalSelectionControls(BuildContext context) → TextSelectionControls
The platform's selection handles, as TextField picks them for selectionControls: null (Material's on Android, Cupertino's on iOS, the desktops' own, which draw none), with one change: a handle the field hides takes no tap. Flutter keeps a focused field's handles in the overlay while hidden, faded to nothing, and the drop under its caret still took a tap, so a tap on the top of the field below a focused one (a form's next line) went to a handle no one could see.
minimalStateLayer(MinimalThemeData t, OutlinedBorder shape, Set<WidgetState> states, {bool inside = false, Color? overlay, Color? face, Color? faceInk, Color? ground}) → Decoration
The press wash and the keyboard ring over a part's face on shape: the ink at 8% while pressed (minimalPressInk), the focus ring while the keyboard is on it: minimalRingFrame's, outside the edge past a gap of ground (the page's background when null), or inside the edge with inside. A hovering pointer changes nothing. Always a decoration, so a container that wears it never re-parents its child as the states change.
minimalStates({bool enabled = true, bool pressed = false, bool hovered = false, bool focused = false, bool selected = false, bool error = false}) → Set<WidgetState>
The states a part resolves its style for.
minimalTapFloor(BuildContext context) → double
The least a tap reaches on a control at context, by what reaches it: the floors MinimalTheme declares (MinimalLayout.tapTargets), 44 for a finger and 24 for a pointer. A row or a strip that is its own tap target stands at least this tall; a compact face stands in the same target with more room round it, so density never moves it.
minimalTapStrip(BuildContext context, Widget face) → Widget
A compact face of several controls (a strip of joined toggles, a field with its steppers) as one band: its controls keep the floor's width (minimalInlineTargets) and the band round the face gives them the floor's height (MinimalTapBand).
minimalTodayMark({required Widget figure, required Color ink, required bool today}) → Widget
A day's figure, with today's mark under it when today: a short bar in the figure's ink, 5 px above the bottom of the day's mark (the box this fills), and lowered as larger text lowers the figure's foot, so the bar keeps its 4 px under the digits. Today is a fact, not a choice, so it never takes the chosen day's fill or an outline that reads as one.
minimalWholeExtent(List<MinimalPlanColumn> columns) → double
The width columns take with every word whole: each at its want (a fixed column at its width), 16 px apart. A table too narrow for its minimalLeastExtent scrolls at this width: once it scrolls, cutting a name gains nothing, so nothing is cut.
showDesignCommandPalette({required BuildContext context, required DesignCommandPalette palette(ValueChanged<DesignCommand> run), Widget surfaceBuilder(BuildContext context, Widget palette)?, Color barrierColor = const Color(0x66000000), DesignBarrierBuilder? barrierBuilder, String? barrierLabel, AlignmentGeometry alignment = const Alignment(0, -0.6)}) → Future<void>
Opens palette in a modal route over a barrier; surfaceBuilder paints the panel around it. A command runs after the route has closed and focus is back where it was.
showMinimalActionSheet(BuildContext context, {required List<MinimalActionSheetAction> actions, String? title, String? message}) → Future<void>
Raises a MinimalActionSheet over the app from the bottom, on a dimmed page, with a Cancel row. An action's press closes the sheet first, then runs; a tap on the scrim, a drag down, Escape or Cancel closes it with nothing done, and focus goes back to the control that raised it. It rises on a spring with no overshoot; the route is ui_core's (DesignBottomSheetRoute). On a wide window it stands centred at a bottom sheet's width (MinimalBottomSheet.widthCap); a phone sees it span the screen inside its margins.
showMinimalBottomSheet<T>(BuildContext context, {String? title, String? subtitle, required WidgetBuilder builder, bool floating = true, MinimalSheetAction? leading, MinimalSheetAction? trailing, Widget? accessory}) → Future<T?>
Present a transient modal sheet from a control — a picker, a filter, a short create form — over the whole app, on the root navigator. A page declared as a sheet is raised by MinimalSheetPage instead, and its close is derived.
showMinimalDialog<T>(BuildContext context, {required WidgetBuilder builder, bool barrierDismissible = true, bool useRootNavigator = true}) → Future<T?>
Raise the dialog builder returns over the whole app and wait for its answer: what the route is popped with, null when the scrim or Escape dismisses it. A MinimalDialog in it answers true or false by itself. It fades in without scaling (nothing in Minimal grows), on a spring with no overshoot that settles in about 120 ms, and fades out the same way; under Reduce Motion a short fade. As it opens it takes the focus and keeps Tab inside it; as it closes the focus goes back to what opened it. The route is ui_core's (DesignDialogRoute); Minimal paints it.
showMinimalMenu(BuildContext context, {required Rect anchor, required List<MinimalMenuItem> items, String? label, double width = _MenuMetrics.width, MinimalStyle? style}) → Future<void>
Present a MinimalMenu's anchored menu from any control — a picker row, a property pill, a button whose anchor the caller measured. The card is width wide, or as wide as anchor where that is wider. Runs the chosen item's MinimalMenuItem.onPressed after the menu has closed.
showMinimalSheet<T>(BuildContext context, {required WidgetBuilder builder, String? title, String? subtitle, MinimalSide side = MinimalSide.end, double width = 380, MinimalSheetAction? leading, MinimalSheetAction? trailing, MinimalStyle? style}) → Future<T?>
Shows a MinimalSheet from side over the whole app, on a dimmed page: it slides in on a spring with no overshoot, settling in about 180 ms (fades, under Reduce Motion), focus moves into it and back to the opener when it closes; Escape, a tap on the scrim, a drag toward its edge or its close button closes it. width is its width, at most the screen less 56 px. The behaviour is ui_core's (DesignSideSheetRoute); Minimal paints it.
showMinimalSnackBar(BuildContext context, String message, {IconData? icon, String? actionLabel, VoidCallback? onAction, MinimalStyle? style}) → void
Transient bottom notification — a confirmation the page does not have to hold, with one optional inline action (the undo pattern). Minimal draws it as a compact card (MinimalSnackBar): the surface on a hairline with a menu's shadow, an optional glyph, 13 px text, the action in the accent's ink. It fades in and rises 4 px, and stands above the shell's bar and the keyboard. One toast stands at a time: a new one replaces the one showing.

Typedefs

DesignBarrierBuilder = Widget Function(BuildContext context, Animation<double> animation)
Paints a modal part's barrier in place of its barrier colour: a look's own screen over the page behind (Ben-Day dots, a blur, a grain).
DesignBottomSheetBuilder = Widget Function(BuildContext context, DesignBottomSheetDetails details)
Builds a bottom sheet's panel from details.
DesignCalendarDayBuilder = Widget Function(BuildContext context, DesignCalendarDay day, Set<WidgetState> states)
Paints one day for its states (WidgetState.selected when chosen, WidgetState.focused while the keyboard is on it, hovered, pressed, disabled).
DesignChartBuilder = Widget Function(BuildContext context, DesignChartDetails details)
Draws a chart from its details.
DesignChartFormat = String Function(double value)
Formats a value for labels, readouts and speech.
DesignChartTableCellBuilder = Widget Function(BuildContext context, DesignChartTableCellDetails cell)
Paints a cell of a DesignChartTable.
DesignComboboxFieldBuilder = Widget Function(BuildContext context, DesignComboboxField field)
Paints the field.
DesignDateFieldFrameBuilder = Widget Function(BuildContext context, Set<WidgetState> states, Widget segments)
Frames a date or time field's laid-out segments (its box, its focus ring); states are the field's: focused (a segment has the focus), hovered, disabled, error.
DesignDateLiteralBuilder = Widget Function(BuildContext context, String literal)
Paints the text between a field's segments ("/", ".", ":", Japanese's year mark U+5E74).
DesignDateSegmentBuilder = Widget Function(BuildContext context, DesignDateSegmentDetails details)
Paints one segment of a date or time field. A segment is a tap target: a look gives its face the floor (DesignTapTarget).
DesignDestinationBuilder = Widget Function(BuildContext context, DesignNavigationDestination destination, DesignDestinationDetails details)
Paints a destination.
DesignDialogActionBuilder = Widget Function(BuildContext context, DesignDialogAction action, DesignDialogActionDetails details)
Paints an action of a DesignDialog.
DesignDialogBuilder = Widget Function(BuildContext context, DesignDialogDetails details)
Builds a dialog route's page: the look's dialog, which details lets it move as the route opens and closes.
DesignDialogPartBuilder = Widget Function(BuildContext context, DesignDialogFrameDetails details, Widget child)
Wraps a part of a DesignDialog (its frame or its action bar) in the look's paint.
DesignDividerBuilder = Widget Function(BuildContext context, Set<WidgetState> states, Axis axis)
Builds a split view's divider for its states (focused while the keyboard is on it, hovered, pressed while dragged).
DesignFieldBuilder = Widget Function(BuildContext context, DesignFieldParts parts)
Lays out a field's parts.
DesignHandleBuilder = Widget Function(BuildContext context, Set<WidgetState> states)
Builds a handle's face for its states (focused while the keyboard is on it, hovered, pressed while dragged, disabled).
DesignInputGroupBuilder = Widget Function(BuildContext context, Set<WidgetState> states, Widget child)
Builds the group's frame around child (the field and its add-ons) for states: WidgetState.focused while anything inside has focus, WidgetState.hovered, WidgetState.disabled and WidgetState.error.
DesignInventoryGroupBuilder = Widget Function(BuildContext context, String group, int present, int total)
Builds a group's heading in a DesignInventoryGallery: present of total rows carried.
DesignInventoryRowBuilder = Widget Function(BuildContext context, DesignInventoryRow row, DesignInventoryEntry? entry, Widget? specimen)
Builds one row in a DesignInventoryGallery. entry is null when the inventory does not answer the row; specimen is the entry's live specimen, built, when it has one.
DesignListSurfaceBuilder = Widget Function(BuildContext context, Widget list)
Paints the list's surface around list (a panel, its shadow).
DesignMenuItemBuilder = Widget Function(BuildContext context, DesignMenuEntry entry, DesignMenuLevel level, Set<WidgetState> states)
Paints an item for its states (WidgetState.focused while the keyboard is on it, WidgetState.selected for the active menu title, hovered, pressed, disabled). In a menu whose highlight follows the pointer, one item at most is focused or hovered: the current one.
DesignMenuSurfaceBuilder = Widget Function(BuildContext context, DesignOverlayInfo info, List<Widget> items)
Paints a menu's panel round its items (scroll them when DesignOverlayInfo.maxSize is short): a menubar's menus, a context menu's.
DesignNavigationBuilder = Widget Function(BuildContext context, DesignNavigationDetails details)
Lays out and paints the navigation round its destinations.
DesignNumberFieldBuilder = Widget Function(BuildContext context, DesignNumberFieldDetails details)
Paints the field's text input.
DesignNumberFieldButtonBuilder = Widget Function(BuildContext context, DesignNumberFieldButtonDetails details)
Paints a step button: a look gives it a finger's floor (DesignTapTarget).
DesignNumberFieldLayoutBuilder = Widget Function(BuildContext context, Widget field, Widget decrement, Widget increment)
Lays out the field and its decrement and increment buttons.
DesignOptionBuilder<T> = Widget Function(BuildContext context, T option, Set<WidgetState> states)
Paints one option for its states: WidgetState.focused while it is highlighted (the keyboard's place in the list), WidgetState.selected when it is the combobox's value, WidgetState.disabled when it cannot be taken, and a pointer's hovered and pressed.
DesignOptionSearch<T> = FutureOr<Iterable<T>> Function(String query)
Searches for the options matching query.
DesignOtpContextMenuBuilder = Widget Function(BuildContext context, TextSelectionToolbarAnchors anchors, List<ContextMenuButtonItem> items)
Draws the field's edit menu: Flutter's toolbar arguments, so a look can hand them on (Material's AdaptiveTextSelectionToolbar.buttonItems, Cupertino's CupertinoAdaptiveTextSelectionToolbar.buttonItems) or draw its own. items is the Paste item (its label from its ContextMenuButtonType, in the app's language); pressing it pastes and closes the menu.
DesignOtpLayoutBuilder = Widget Function(BuildContext context, List<Widget> slots)
Lays out the boxes (a row; a look may put a dash in the middle).
DesignOtpSlotBuilder = Widget Function(BuildContext context, DesignOtpSlot slot)
Paints one box.
DesignOverlayAnchorBuilder = Widget Function(BuildContext context, DesignOverlayAnchor anchor)
Paints the anchor.
DesignOverlaySurfaceBuilder = Widget Function(BuildContext context, DesignOverlayInfo info)
Paints the surface.
DesignPaletteLayoutBuilder = Widget Function(BuildContext context, Widget field, Widget results)
A palette's list, as DesignCommandPalette.layoutBuilder lays it out.
DesignPieChartBuilder = Widget Function(BuildContext context, DesignPieChartDetails details)
Draws a pie chart from its details.
DesignPressableBuilder = Widget Function(BuildContext context, Set<WidgetState> states, Widget? child)
Builds a pressable's face for its current states (hovered, focused, pressed, disabled, selected, error). child is the pressable's own child, passed through so a face that does not change with state is built once.
DesignRatingItemBuilder = Widget Function(BuildContext context, DesignRatingItemDetails details)
Paints one item of a rating.
DesignRatingLayoutBuilder = Widget Function(BuildContext context, List<Widget> items)
Lays out a rating's items, in reading order.
DesignScrollbarBuilder = Widget Function(BuildContext context, DesignScrollThumb thumb)
Paints a scrollbar's thumb or track.
DesignSearchErrorBuilder = Widget Function(BuildContext context, DesignSearchError error)
Paints a failed search (error) in the list's surface.
DesignSwipeActionBuilder = Widget Function(BuildContext context, DesignSwipeAction action, DesignSwipeActionDetails details)
Paints an action.
DesignTabBuilder = Widget Function(BuildContext context, DesignTab tab, DesignTabDetails details)
Paints a tab.
DesignTabIndicatorBuilder = Widget Function(BuildContext context, DesignTabIndicatorDetails details)
Paints the indicator, laid out in DesignTabIndicatorDetails.rect.
DesignTableHeaderBuilder<R> = Widget Function(BuildContext context, DesignTableColumn<R> column, DesignSortDirection? sort, Set<WidgetState> states)
A sortable header, as DesignDataTable.headerBuilder gets it.
DesignTagBuilder<T> = Widget Function(BuildContext context, T value, DesignTagDetails tag)
Paints one tag.
DesignTagLayoutBuilder = Widget Function(BuildContext context, List<Widget> tags, Widget field)
Lays out the tags and the field (a wrap, by default).
DesignToastBuilder = Widget Function(BuildContext context, DesignToastDetails details)
Paints one toast.
DesignToastStackBuilder = Widget Function(BuildContext context, List<Widget> toasts)
Lays out the shown toasts, oldest first.
DesignToggleItemBuilder<T> = Widget Function(BuildContext context, T value, Set<WidgetState> states)
Builds an item's face for its states (selected, focused while the keyboard is on it, hovered, pressed, disabled).
DesignWheelColumnBuilder = Widget Function(BuildContext context, DesignWheelColumnDetails details, Widget wheel)
Frames one column of a DesignWheelPicker round its wheel.
DesignWheelItemBuilder = Widget Function(BuildContext context, DesignWheelItemDetails details)
Builds one row of a DesignWheelPicker.
MinimalMediaReference = ({ImageProvider<Object>? image, String? slot})
What MinimalMediaSource.reference reads a picture value as: the declared slot it stands for, or the image that draws it.
MinimalStyle = DesignStyle
How one part looks: ui_core's DesignStyle, under Minimal's name. Every slot resolves for the part's states (WidgetState.disabled, WidgetState.hovered, WidgetState.focused, WidgetState.pressed, WidgetState.selected, WidgetState.error).
MinimalStyleOf = DesignStyleOf
One part's style layers (its own style: first, then its component theme) read for one set of states: ui_core's DesignStyleOf. Every getter is null where no layer says, and the part goes on to the knob and its own default.

Exceptions / Errors

DesignInventoryError
Thrown by DesignInventory.verify: the rows an inventory answers wrong.