auth library
Sign-in: the auth action, as authCatalog.
Over package:codelessly_api/core.dart, which it exports.
Classes
- AccordionProps
- An accordion: its first child is the header (with a toggle button over its end), its second the content shown while expanded.
- ActionCommon
- The fields every action has, read from its JSON: what an ActionSpec.decode passes on to the action's constructor.
- ActionCommonFields
- The fields every action has.
- ActionDef
-
One action. Every action can be turned off (enabled), run without
being awaited (nonBlocking: the chain goes on at once and its failure
doesn't stop it) and run only while a predicate holds (when). JSON:
{"type": type, ...its fields, "enabled": false, "nonBlocking": true, "when": {...}}. - ActionSpec
-
The declaration of one action type: what a
WidgetSpecis to a node. Its fields generate an editor's panel and validate; decode makes the typed action. Without decode (a type declared as data, by a hosted or native plugin manifest) the action decodes as a DeclaredAction holding its fields as Props. - ActivityIndicatorProps
-
Flutter
CupertinoActivityIndicator. - Alignment
-
Flutter's
Alignment: -1 (start) to 1 (end) per axis. JSON:[x, y]. - AnimateAction
-
Drives an animation (Flutter's
AnimationControllermethods): node node's animation (NodeAnimation), or the number variable variable (an unbounded controller the screen keeps for it). JSON:{"type": "animate", "node": "card", "animation": "pop", "command": "forward", "from": "0"},{"type": "animate", "variable": "shownTotal", "command": "animateTo", "target": "${total}", "duration": "800", "curve": "easeOutCubic"}. The chain waits for it to end (TickerFuture) unless it's nonBlocking; a repeat ends when its count does. - AnimateFields
-
AnimateAction: an
AnimationControllermethod on a node's animation or a number variable. - AnimationCurveCodec
-
An AnimationCurve, by the name of its Flutter
Curvesconstant. Reads as leniently as the models do (AnimationCurve.parse). - AnimationPreset
- A named short form of a NodeAnimation: its default timing, and the tracks it stands for as a function of its params.
- AnimationPresets
-
The presets an animation's
presetnames. Loops (pulse,fade,scale,spin,bob,sway,flicker) repeat for a second and rest (on the design canvas) at their start; one-shot effects (shake,bounce,pop,wiggle,jelly,flash,keyframes) wait for a cue and last 520 ms;enterplays once from itsfromvalues to the node's own. Their tracks add to or multiply the node's own pose (TrackBlend), as a FlutterScaleTransitionorRotationTransitionwrapped around it would. - AnimationRepeat
-
controller.repeat(reverse:, count:). count 0 repeats forever; a count ends at the end of its last run. JSON:{}(forever),{"reverse": true, "count": 3};trueand a bare count read too. - AnimationRepeatFields
-
AnimationRepeat:
repeat(reverse:, count:). - AnimationTrack
- One tween a NodeAnimation drives: a property at a binding path of a node, or a variable.
- AnimationTrackFields
- AnimationTrack: one tween.
- AppBarProps
-
AppBar. - ArcOp
-
Canvas.drawArc(rect, startAngle, sweepAngle, useCenter, paint): angles in radians, clockwise from 3 o'clock, as Flutter's. - ArcOpFields
- AuthAction
- Signs app users in, up and out, and manages their account. A failure's message goes in errorVariable (and stops the chain).
- AuthFields
- AuthAction.
- AxisPosition
-
Where a child of a freeform (stack) parent sits on one axis, as
Flutter's
PositionedorAlign, in the parent's padded box: - AxisSize
-
Sizing along one axis. value is the design size: the size for
SizeFit.fixed, and the fallback whenever a mode can't apply. JSON: a
number (fixed) or
{"fill"|"flexible"|"hug": value}. - BadgeProps
-
Badge: a small label (or a dot) over itschildslot. - BarChartProps
- A bar chart of values with optional labels, grid and a highlighted bar.
- BarcodeProps
- A barcode or QR code of data, filling the box.
- BaseSegment
-
A piece of the base template: text, included when every condition in
when holds (
files,runtime,card,page,app,scripts,noScripts,docsTool,noDocsTool). - BehaviorFields
-
A node's Behaviors, one per key of Behaviors.keys: stored flat in
the node's JSON (
"motion": {...},"tooltip": "..."), defaults as in Behaviors.none. - Behaviors
- A node's behaviors. Stored flat in the node's JSON under keys.
- BindPaths
- Binding paths (keys of Node.bind) and how values are applied to them.
- BindValue
- Loose readers for bound values (what an expression gave). Each returns null for a value it can't read.
- BoolCodec
- BorderRadius
-
Flutter's
BorderRadius: four corners, each circular or elliptical. JSON (sparse, see fromJson):8,[16, 8]or[8, [16, 8], 0, 0]. - BorderSide
-
Flutter's
BorderSide. A null color is unset: the widget's theme default where it has one, else Flutter's black. - BorderSideFields
- BoxConstraints
-
Flutter's
BoxConstraints, where a missing bound means unconstrained. - BoxProps
-
A leaf box: Flutter
Containerwith a decoration and no child. - Breakpoint
- One screen size class of a project: from minWidth (inclusive) up to the next breakpoint's.
- Breakpoints
- A project's breakpoints, narrowest first (DESIGN.md §5.3).
- BreakpointWidthsCodec
- Breakpoint id → width (a variance's own switch points).
- ButtonProps
-
ElevatedButton,FilledButton,TextButton,OutlinedButton: a label with an optional icon (their.iconconstructors), styled by aButtonStyle. - ButtonSegment
-
Flutter's
ButtonSegment<String>: one segment of a segmented button. - ButtonSegmentFields
- ButtonStyle
-
Flutter's
ButtonStyle, as the buttons'styleFromtakes it. Null fields are the button's own defaults. The padding is the node'slayout.padding; the size is the node's box (no minimum size). - ButtonStyleFields
- CallFunctionAction
-
Calls a function the app registered by name with params (text
values are expressions). Its result is the chain's
${result}: what the app's code answered (a permission granted, a share completed), which the next actions branch on. A function the app didn't register fails the chain, unless the action is optional. - CallFunctionFields
- CallFunctionAction.
- CanvasProps
-
A screen (
Scaffold): itsbodyslot is the page content. - Catalog
-
What a document may contain: declared node types, action types, data
sources and formula functions. Immutable; composed with
+or parts, never mutated. - ChartProps
- A chart of data rows: bars, lines and areas over categories, a timeline of segments, or a donut.
- ChartReferenceLine
- A horizontal line across a chart's plot at value.
- ChartSeries
- One series of a chart: the values of field in each data row.
- CheckboxProps
-
Flutter
Checkbox, scaled to its box (40 px is Flutter's own size, 18 px when compact). - ChipProps
-
Chip,ActionChip,ChoiceChip,FilterChipandInputChip. - CircleOp
-
Canvas.drawCircle(c, radius, paint). - CircleOpFields
- CircularProgressIndicatorProps
-
Flutter
CircularProgressIndicator: a spinner, or a ring filled to value. startAngle and sweepAngle draw it as an arc (a dial). - CloseModalAction
-
Closes the modal it runs in, giving the chain that opened it result
(its text values are expressions) as
${result}. - CloseModalFields
- CloseModalAction.
- Codecs
-
Common codecs. Nullable variants (
optional*) read a missing or unreadable value as null. - CollectionCodecs
- Codecs for the collections' value types.
- CollectionScrollProps
-
The props every scrolling collection shares (
ScrollView's parameters). - CollectionSlots
- The slots a list or grid takes besides its item template.
- Color
-
A 32-bit ARGB color, as Flutter's
Color. JSON:"#AARRGGBB"("#RRGGBB"and ints also read), or the name of one of the project's theme colors ("ember": ThemeTokens.colors, resolved before the document renders; seeresolveThemeRefs). - ColorStop
- One gradient stop.
- ColorStopFields
- Comparison
-
left op right(the right side only for ops that ConditionOp.takesRight). - ComponentDefinition
- A component in a project's library: its nodes as a layout document with one root, its design size, and where it was made from.
- ComponentEventAction
-
Inside a component definition: fires the component's event event with
value as its payload. The call's reactions whose trigger is
{"type": "event", "event": "<event>"}run, in the caller's scope, with the payload as${result}(Flutter: callingwidget.onChanged(value)). JSON:{"type": "componentEvent", "event": "onChoose", "value": "${props.plan.id}"}. Outside an instance it does nothing. - ComponentEventFields
- CopyToClipboardAction. ComponentEventAction.
- ComponentLibrary
- Component definitions by type name: the project's (or a document's) library, and the catalog a page's calls decode with.
- ComponentLink
-
A node's link to a component (
Node.component): the component's main node, or the top node of an instance of it. - ComponentPreview
-
A named parameter set a component renders with alone (Flutter's
@Preview(name:, size:)):{"name": "Team, annual", "size": [432, 760], "props": {...}}. - ComponentSetting
- One thing a component lets an instance customize, or a group of them.
- Condition
- An if / else-if / else rule. Its first branch whose test holds and that sets a property gives the property its value; when none does, the property keeps its binding's or its own value. JSON:
- ConditionBranch
-
One branch: when when holds (always, for an
else: null), the properties in sets take their values. - ConditionOperand
-
One side of a Comparison: an expression text whose
${...}are read (${count},${= a + b},3,done), or, when raw, a literal taken as written. Both are then parsed loosely (3is a number,truea bool,[1, 2]a list). JSON: the text, or{"raw": text}. - ConfirmAction
-
Asks the user to confirm; runs actions when they do, cancelActions
when they don't. With dialog (a screen id), that screen is the dialog
and what its close modal action returns is
${result}. - ConfirmFields
- ConfirmAction.
- ControlDismissibleAction
- Dismisses, brings back or resets node node (several ids: comma-separated).
- ControlDismissibleFields
- ControlDismissibleAction.
- ControlTrackAction
- Turns the Track of node node (several ids: comma-separated, the first on screen takes it).
- ControlTrackFields
- ControlTrackAction.
- ControlTransformAction
- Resets, zooms or poses the transform gesture of node node.
- ControlTransformFields
- ControlTransformAction.
- CopyToClipboardAction
- Copies text (an expression) to the clipboard.
- CopyToClipboardFields
- CoreAction
- The core action types: navigation, modals, values and variables, flow, feedback, focus, scroll, animation, scripts, pagination. Exhaustive within itself.
- CustomPaint
-
Flutter's
CustomPainton a node: painter drawn behind the node's content (its decoration and children) and foregroundPainter over it, both in the node's box (inside its transform and opacity, outside its clip). The node's layout isCustomPaint.size; its content ischild. - CustomPaintFields
-
CustomPaint: the
customPaintbehavior. - DataSourceSpec
-
A kind of data a list, grid or pagination can load from, declared like a
widget so its settings get a panel:
data(the bound list) in the core,cloudandapiin the data library. - DatePickerProps
-
A field showing a date (
yyyy-MM-dd; empty shows its hint) that opens a calendar (Flutter'sshowDatePicker). - DateTimeInputProps
-
A field (Flutter's
InputDecorator) showing a date, time or both, that opens the pickers. - DeclaredAction
- An action of a type its catalog declares without a Dart class (a hosted plugin's, or one a native plugin declares by manifest): its spec and its fields as typed props, as a node holds props for its WidgetSpec. Keys the spec doesn't declare are kept (Props.unknown).
- DecodedOps
-
A batch of ops read from a tool input: each op with the index of the
input op it came from (a
setwithnodesgives several), and what could not be read. - Decoration
-
A box's paint: Flutter's
BoxDecoration, with stacked paints as in a design tool (fills bottom to top, then strokes). - DecorationFields
-
A node's Decoration, field by field (JSON under
decoration). - DelayAction
- Waits ms milliseconds, or duration (a formula giving them) when that gives a number.
- DelayFields
- DelayAction.
- DesignSystem
- A design system in memory: its manifest, its two documents' text and its component library, whatever loaded them (load: a folder, a publish, an asset bundle; fromJson: one bundle).
- DesignSystemComponent
- One component of a design system as its list shows it.
- DesignSystemManifest
-
A design system's manifest (
design_system.json), loader-agnostic like SiteManifest: its id and name, references to its two documents and its component definitions (paths relative to the manifest, or publish ids), its tokens (a theme, the shape ofsite.json'stheme), the fonts it ships and the base node types its components stand in for. - DismissibleBehavior
-
Swiped away past a threshold (node key
dismissible): Flutter'sDismissible. The node follows the pointer toward its directions (held back by resistance the other ways); let go past its dismissThresholds share of its size, or faster than flingVelocity, it flies off over movementDuration and fires the swipe of that direction (swipeLeft...;Dismissible.onDismissed), then shows its next content back at rest. Otherwise it returns: on returnSpring, else over returnDuration along returnCurve. A swipe card. - DismissibleFields
-
DismissibleBehavior (node key
dismissible): Flutter'sDismissible. - DividerProps
-
DividerandVerticalDivider: a line across the node's box. - DocPage
-
One page of the reference, as
ui_docsserves it. - DocSection
- One section of a reference page: its anchor id, title and Markdown text (links as in the page files).
- DoubleCodec
- DragSource
-
Lets the user pick the node up and drop it on a DropTarget that takes
its group (Flutter's
Draggable;LongPressDraggablewith startlongPress). - DragSourceFields
-
DragSource (node key
draggable): Flutter'sDraggable. - DrawOp
-
One draw operation:
{"op": name, ...}. Every op may carry an id (editor selection, a binding pathcustomPaint.painter.<id>.<field>) and when (false skips it). Keys an op doesn't know are kept in extra and written back. - DrawOpCommonFields
- The fields every op has.
- DrawOpsCodec
- A list of draw ops.
- DrawOpSpec
- A draw op, as an editor shows it.
- DrawOpSpecs
-
Every op an editor can add, by its JSON
op. - DrawPaint
-
How a shape is drawn: Flutter's
Paint, with its field names and defaults (black,fill,strokeWidth0: a hairline,butt,miter, miter limit 4,srcOver, anti-aliased). shader is a gradient or image in the model's Paint form, laid out in the shape's bounds (Flutter'sGradient.createShader(rect)). dashPattern and scaleStroke have noPaintcounterpart: dashes as a decoration'sdashPattern, and a stroke that stays in the box's pixels under a scaling view box or group as thepathnode'sscaleStroke: false. - DrawPaintFields
-
DrawPaint: Flutter's
Paint. - DrawPaintsCodec
-
An op's
paint: one DrawPaint or several (each may be an expression). - DrawRRect
-
A rounded clip: Flutter's
RRectas{"rect": [l, t, w, h], "radius"}. - DrawRRectFields
- DropdownProps
-
Flutter
DropdownButton<Object>. Its padding is the node'slayout.padding. - DropTarget
-
Takes DragSources of the groups it accepts (Flutter's
DragTarget). - DropTargetFields
- EdgeInsets
-
Flutter's
EdgeInsets(left, top, right, bottom). JSON: a number (all sides) or[left, top, right, bottom]. - EditCheckInput
- What an EditCheck is asked to check: the nodes an op touched, as JSON (as written: a set's node, a patched node's merged JSON), in the document after the op.
- EditCode
- One diagnostic code of the edit layer: its name, whether it rejects the op, and what it means.
- EditCodes
-
The codes the edit layer itself reports. A check of the nodes an op
touched adds the validator's codes (
unknown_prop,wrong_type,invalid_enum...), listed with strict validation. - EditDiagnostic
- One problem with one op of a batch.
- EditOp
- One edit operation on a layout document, addressed by node id.
- EditOpField
- One field of an op: its key, kind, whether the op needs it, and what it means.
- EditOpSpec
- The declaration of one op: its name, fields, meaning and an example.
- EditResult
- The outcome of applyOps.
- EditRevisions
-
The revision of every field changed through ops, and by whom: what
baseRevis compared with. - EditTextAction
- Edits text field node's text at its cursor: wraps the selection in before / after, toggles a (numbered) list, inserts or sets text, replaces the word being typed, clears it or focuses it.
- EditTextFields
- EditTextAction.
- Effect
-
A shadow or blur (Flutter's
BoxShadow,ImageFilter.blur). - EffectFields
-
EnumCodec<
T extends Enum> - ErrorTextCodec
-
Text, or a yes/no:
trueis kErrorWithoutMessage,falseno error. - EventSpec
-
An event a component fires with
componentEvent(Flutter: aVoidCallbackorValueChanged<T>constructor parameter,onChanged). JSON:{"key": "onChoose", "payload": {"kind": "string"}, "doc": "..."}. - ExpansionTileProps
-
Flutter
ExpansionTile. Thetileslot is a list tile whoseleading,title,subtitleandtrailingslots make the header; the children are shown while expanded. -
Expr<
T extends Object> -
A value given as a literal value or computed by an expression
source (
"${size.width}","${= index * 2}") when the list draws. -
ExprCodec<
T extends Object> -
A value or an expression (
"${...}") giving one: inner reads and writes the literal, and its type is the field's type. - ExternalProps
-
A widget the app builds (
Codelessly's external component builders). - FieldValue
- An immutable value made of declared fields, as a widget's props are: decoding is total, encoding sparse (a field at its default is omitted), equality by value. spec lists the fields (the editor's panels read it).
- FlexProps
-
RowandColumn: the same props, different main axis. - Flight
-
How a hero that flies in place (HeroFlies.inPlace) flies in from where
the node with its tag was: on a spring by default (the node's
motiontransition's, when it has one with a spring), or, with a duration, along a curve that rises lift (or liftShare of the distance, the larger) above the higher end (as Flutter'sMaterialRectArcTweenbends a hero's path), swelling to swell at the middle and spinning turns times (toward the way it flies), trailing trail fading dots. - FlightFields
- FlipCard
-
Makes the node a two-sided card (node key
flip; a runtime 3D turn, not a mirror): its first child is the front, its second the back, turned 180° in advance; each hides while it faces away. The turn is the node's own Motion (rotateY, or rotateX for FlipAxis.x, 0 or 180), with its perspective, duration (600 ms without one), curve and keyframes. Inside the card${flip.flipped}and${flip.progress}(0 front, 1 back) can be read. - FlipCardFields
-
FlipCard (node key
flip): a card that turns over. - FloatingActionButtonProps
-
FloatingActionButton(and its small, large and extended forms). - FocusAction
- Focuses text field node (selecting its text with selectAll), or takes the focus away (unfocus; from every field when node is empty).
- FocusFields
- FocusAction.
- FontAsset
-
One font file of a FontFamily (a pubspec
fonts:entry's- asset:): its path relative to the site's folder, its weight (100–900) and style. - FontFamily
-
A font family a site declares (a pubspec
fonts:entry): text styles name it by family ("fontFamily": "Fraunces", whatever the files call themselves inside), and each weight and style draws from its file. - FontWeightCodec
-
Flutter's
FontWeight, as its weight: 100, 200 ... 900. - ForEachAction
-
Runs actions once per item of list items (a path or expression).
Every action of a turn reads the item and its index as
${loop.item}and${loop.index};${result.item}and${result.index}hold them too, until an action of the turn gives a result of its own. - ForEachFields
- ForEachAction.
- FormBehavior
-
Flutter's
Form: the text fields inside the node are one form. Thevalidateaction (FormState.validate()) checks them all with their validators, shows each one's error and focuses the first invalid field; autovalidateMode makes them check themselves too, as each field's ownautovalidateModedoes. The node and the nodes inside it read${form.valid}(every field passes its validator now) and${form.errors}(the errors the fields show, in order:{field, label, message}), for a summary. JSONtrueor{"autovalidateMode": ...}. - FormFields
-
FormBehavior: Flutter's
Form. - FormulaSpec
- A formula function: its name, parameters and what it does. A built-in one (the expression engine's) or a plugin's (a function variable).
- GaugeMeterProps
- A meter: value between min and max as a filled arc or bar (continuous or in segments), with ticks and a limit marker.
- GaugeZone
- A colored band of a radial gauge, from from to to in value units.
- GesturePhysics
-
How a node moves on its own once the pointer lets go, the same for a
DragMotion, a DragSource's return and a TransformGesture: a fling that slows by friction (Flutter'sFrictionSimulation), a stretch of overscroll past the bounds, and a spring onto the snap target nearest to where the fling would stop. - GesturePhysicsFields
- GesturePhysics: the release a drag, a drag source's return and a transform gesture share.
- GestureSnap
- The places a released node settles at (GesturePhysics.snap).
- GestureSnapFields
- GridViewProps
-
Flutter
GridViewwith a fixed cross-axis count (SliverGridDelegateWithFixedCrossAxisCount) or, when maxCrossAxisExtent is set, a maximum cell extent (SliverGridDelegateWithMaxCrossAxisExtent). - GroupOp
-
canvas.save()(saveLayerwith opacity or blendMode), thentranslate,scale,rotate(radians) andtransform(aMatrix4's 16 numbers, column-major asMatrix4.storage), in that order, thenclipRect,clipRRect,clipPath; its ops;canvas.restore(). - GroupOpFields
- HapticAction
-
Buzzes the device (
HapticFeedback, on phones that support it; nothing elsewhere). Its commonwhenbuzzes only while a setting holds. - HapticFields
- HapticAction.
- HeroTag
-
Makes the node a shared element (Flutter's
Hero): it flies from where the node with the same tag was to where it is, between two screens while a navigation plays (HeroFlies.betweenScreens, Flutter's) or when it appears in place (HeroFlies.inPlace). JSON: the tag alone ("hero": "avatar-1") or{"tag", "flies", "flightShuttle", "placeholder", "flight"}. - HeroTagFields
-
HeroTag (Flutter's
Hero). Its JSON is{"tag", "flies", "flightShuttle", "placeholder", "flight"}, or just the tag when the rest is Flutter's default. - IconAction
-
An icon with its own size, color and tooltip: an app bar's leading icon
or action (Flutter's
IconButtoninAppBar.actions). actions are its reactions, as a node's. - IconActionFields
- IconButtonProps
-
IconButton: an icon, styled by aButtonStyle. - IconProps
-
Flutter
Icon(font icons) or an SVG/image icon. - IfAction
-
Runs then when condition holds, else orElse. JSON:
{"type": "if", "condition": {...}, "then": [...], "else": [...]}. - IfFields
- IfAction.
- ImageOp
-
Canvas.drawImageRect(image, src, dst, paint): the image at url (may hold${...}), its src rect (source pixels; null: the whole image) drawn into dst (null: the whole drawing). Without a paint, Flutter's defaultPaint(). - ImageOpFields
- ImagePaint
-
An image source and how it fills its box (Flutter's
DecorationImage). - ImagePaintFields
- IndicatorCodecs
- Codecs shared by the indicators declarations.
- InkWellStyle
-
The ink a tappable box shows, as Flutter's
InkWell: ripples and the overlays of its states. Clipped to the box's radius. - InkWellStyleFields
- InputBorder
-
Flutter's
InputBorder: anOutlineInputBorder(the default here), anUnderlineInputBorderorInputBorder.none. - InputBorderFields
- InputCodecs
- Codecs for the inputs' value types.
- InputDecoration
-
Flutter's
InputDecoration: a text field's border, label, hint, helper, error, prefix and suffix. Every field has Flutter's default (unset: the theme's). - InputDecorationFields
- InputIcon
-
An icon an input shows (
Icon): a glyph as the icon node'siconprop ({"source", "name", "codepoint", ...}or an image), its size and color, and the actions a tap on it runs. - InputIconFields
- IntCodec
- Junction
-
All of parts (
and) or any of them (or). Every part is evaluated. JSON:{"and": [...]}/{"or": [...]}. - KeyCombo
-
A key with the modifiers held with it, as Trigger.key names it:
Enter,Meta+Enter,Shift+Tab,Meta+b,ArrowDown,Escape. Every part but the last is a modifier:Meta(alsoCmd,Command,Ctrl,Control,Mod: Command on macOS, Control elsewhere),Shift,Alt(alsoOption). The key compares without case or spaces;Escreads asEscape,ReturnasEnter. - Keyframe
-
One stop of a
TweenSequence: the track's value at at (0–1 of the track's run), reached on curve from the stop before it. - KeyframeFields
-
Keyframe: a
TweenSequencestop. - Layout
- A node's layout.
- LayoutDocument
- A layout: a set of node trees (one per canvas/screen) in one flat map.
- LayoutFields
-
A node's Layout, field by field (JSON under
layout). - LayoutLogic
- The variables and conditions of each screen of a layout, by canvas id. JSON (two keys of the layout document):
- LineChartProps
- A line chart of data rows (xField, yField; dates or numbers on x), with bands, ticks, markers and lines given as data (usually bound).
- LineOp
-
Canvas.drawLine(p1, p2, paint). - LineOpFields
-
ListCodec<
T> - ListReorder
-
Dragging a list's items to a new place, within the list and, with a
group, into other lists of the group (a Kanban board). A drop runs the
list's
reorderreactions with${result.from},${result.to},${result.item},${result.fromList}and${result.toList}. - ListReorderFields
- ListSections
-
Groups a data list's consecutive items with the same groupBy value into
sections, each under the list's
sectionHeaderslot. - ListSectionsFields
- ListTileProps
-
ListTile, its widgets in theleading,title,subtitleandtrailingslots. - ListViewProps
-
Flutter
ListView: its first child repeated per item. - Measure
-
Writes where the node is laid out,
{x, y, width, height, centerX, centerY}in pixels, to a variable as layout changes: in the coordinates of the ancestor node relativeTo (empty: the screen), under key when the variable is a map. Other nodes then follow it: a marker traveling to the chip of the reader's layer on a timeline whose chips are laid out by data. The design canvas measures too. - MeasureFields
- MediaRule
- One media rule of a node: patch applies while the screen meets every condition given (minWidth, maxWidth, orientation).
- MigrationEntry
- One thing a migration step did.
- MigrationReport
-
The entries of one or more migrations, in the order they happened.
Pass one to
migrate2to3(and the other migrations) to collect them; document names the document the next entries belong to. - MigrationScope
- What a step reports through, while it runs on one node or document.
- MigrationStep
-
A named, separately tested step of a migration. It changes a node's JSON
(node) or a document's (document) in place, and says what it did
through the MigrationScope it is given. A node step may read the
document it is in (MigrationScope.document) to see what other nodes do
to its node (a state style or a
setValuethat targets it). - ModalProps
-
A dialog: its
triggerslot is shown in place and opens thecontentslot in aDialog. - Motion
-
A transform painted over the node's layout (Flutter's
Transform): it moves nothing else. Its values are the node's rest pose; how it gets there is the node'sanimationsandtransitions. - MotionFields
-
Motion: a transform over the node's layout (Flutter's
Transform). - MoveOp
- Move node id under parent at index (or into slot); reordering is a move within the same parent.
-
Goes to another screen. JSON:
{"type": "navigate", "mode": "push", "to": "canvas-b", "params": {"id": "${item.id}"}}. The destination reads params as${route.<name>}. - NavigateAction.
-
What
NavigationBarandBottomNavigationBarshare: items, the selection, and the selected/unselected label and icon styles. -
A navigation bar item: Flutter's
NavigationDestination(andBottomNavigationBarItem). Icon colors are the item's own, over the bar's. actions are its reactions. - Node
- One node: a widget declaration's values, placed in a tree by id.
- NodeAnimation
-
One
AnimationControlleron a node and the tweens it drives (behavior keyanimations, a list). A screen-wide one sits on the canvas node. - NodeAnimationFields
-
NodeAnimation: an
AnimationControllerand its tracks. - NodeFields
- A node's own top-level fields.
- NodeValue
- One property a SetValueAction sets: a binding path of the node (DESIGN.md §5.1) and its value (a string is an expression).
- NoisePaint
-
A
noisepaint's procedural noise, parameterised as SVG's<feTurbulence>(baseFrequency,numOctaves,seed,type): the texture a web page's grain overlay draws (filter: url(#grain)), here a paint, drawn as a seamless tile repeated over the box. - NoisePaintFields
-
NoisePaint: SVG
feTurbulence's attributes. - NotationIssue
- A problem in the notation's text: where and what.
- NotationOptions
- How the notation expands.
- NotationResult
- NotationStream
-
The notation read as it arrives: add takes text in any chunks and
returns the edit operations of the lines completed so far (a
setper node under its parent,varsfor the state a line introduced), ready forapplyOps; close gives the last line's. - NullableDoublesCodec
-
A list of numbers with gaps (
nullitems kept, e.g. a bar with no value). - NumberInText
- The first number in a text ("1,204", "-3.5", "$12.50" → 12.50) and how it is written: what is around it, its decimals and whether its thousands are grouped. A text's number counts (AnimationTrack.lerpValue): each value between is written the same way (format).
- Offset
-
An offset. JSON:
[dx, dy]. - OpenLinkAction
-
Opens a URL (a web page,
mailto:,tel:, an app link). - OpenLinkFields
- OpenLinkAction.
- OpenModalAction
-
Shows a screen (canvas) as a modal: a dialog, a sheet, a popover. The
CloseModalAction that closes it gives the chain that opened it its
${result}. JSON:{"type": "openModal", "to": "canvas-d", "presentation": "bottomSheet"}. - OpenModalFields
- OpenModalAction.
- OpenTypeFeature
-
An OpenType feature setting: a four-character tag and its value
(1 on, 0 off, n an alternate). JSON is a string,
"lnum"or"liga=0". - OpStreamDecoder
-
Decodes a streamed
ui_applyinput: add each text delta and it returns the ops that delta completed; close at the end. - OpStreamEnd
-
What is left when a stream ends: what could not be read, the tool
input's
baseRevandatomic, and the truncated tail if it ended inside an op. - OptionalBoolCodec
- A bool that may be absent (null: the widget's own default).
- OptionalDoubleCodec
-
A double that may be absent (
itemExtent,mainAxisExtent). -
OptionalEnumCodec<
T extends Enum> - An enum value that may be absent (Flutter's nullable enum parameters).
- OptionalIntCodec
-
An int that may be absent (
maxLines). - OptionalStringCodec
- A string that may be absent (a font family that falls back).
- OvalOp
-
Canvas.drawOval(rect, paint). - OvalOpFields
- PageViewProps
-
Flutter
PageView: its first child repeated per page. - PaginateAction
-
Moves the pagination controller of a list or grid (its
pagination, by controller, the pagination's name). - PaginateFields
- PaginateAction.
- Pagination
-
A pagination controller: loads a list's items page by page and exposes
its state as a map variable named name (
${name.items},${name.page},${name.pageCount},${name.hasMore},${name.isLoadingMore},${name.error}...). Paginate actions move it. - PaginationFields
- PaginationProps
-
Page controls for a list's pagination (found by its name,
controller): first, previous, page numbers with ellipses
(1 … 4 5 6 … 16), next, last, a page size select and a summary. Choosing
a page fires the node's
changedreactions with the page as${result}. - Paint
- A fill or stroke paint: a solid color, a gradient or an image. Several paints stack, first at the bottom.
- PaintFields
- Pan
-
Follows the pointer (node key
pan):GestureDetector(onPanUpdate:)moving aTransform.translate. On release it springs back to rest or stays (release), with physics a fling that slows by friction, a spring and snap points within bounds and the limits minX...maxY (a bottom sheet:{"axis": "vertical", "release": "stay", "minY": -560, "maxY": 0, "physics": {"snap": {"points": [[0, 0], [0, -560]]}}}). Its offset binds two-way to xVariable and yVariable; x and y (bindable) place its rest. - PanFields
-
Pan (node key
pan): follows the pointer. - ParagraphOp
-
Canvas.drawParagraph(whatTextPainter(text: TextSpan(text, style)) ..layout(maxWidth: maxWidth)..paint(canvas, offset)draws): text (may hold${...}) in style, laid out up to maxWidth and maxLines, with the point anchor names (top left by default) at offset. A paint is the text'sTextStyle.foreground. - ParagraphOpFields
- ParticleEmitter
- Confetti, stars or emoji the node bursts with on cue.
- ParticleEmitterFields
- PatchOp
-
An RFC 7396 merge patch on node id: objects merge, arrays and scalars
replace,
nulldeletes a key. It never changeschildren,slotsortype(structural_key_in_patch). - PathCommand
-
One call of Flutter's
Pathbuilder: method (moveTo,lineTo,quadraticBezierTo,cubicTo,close) with its positional arguments args (each a literal or an expression), made only while when holds (if (cond) path.lineTo(x, y)). JSON:{"lineTo": [x, y]},{"quadraticBezierTo": [x1, y1, x2, y2]},{"close": true}, with an optional"when". - PathCommandsCodec
-
A path op's
commands: FlutterPathbuilder calls (PathCommand). - PathFollow
-
A place along an SVG path: progress (0–1) of the way along path's
length, turned with it as orient says. Shared by
motion.pathand a drag track's path. - PathFollowFields
- PathFollow: a place along an SVG path.
- PathOp
-
Canvas.drawPath: SVG path data d; or thePathbuilder's calls commands; or points joined by straight lines (closed back to the first). trimStart–trimEnd of its length (PathMetric.extractPath). - PathOpFields
- PathProps
-
An SVG path, filled and stroked with the node's decoration
(Flutter
CustomPaint). - PickerFieldProps
- The look of a date or time picker: by default the design system's select field (a calendar or clock icon, the value, a chevron); with a PickerFieldProps.decoration the decoration's border, fill, hint and icons. The value shows in PickerFieldProps.format. Tapping opens the picker (a calendar, or hour and minute columns) under the field, or as a bottom sheet on a narrow screen, themed by PickerFieldProps.pickerTheme.
- PlaceholderProps
-
An empty slot shown at design time (Flutter
SizedBox). - PlotChartLabel
- A label on a plot chart's x axis, centered on x.
- PlotChartMarker
- A labeled dot on a plot chart (on the curve when y is null).
- PlotChartProps
- A line/area chart of points spread evenly over an x domain, with an x value selected by tapping or dragging.
- PlotChartRange
- A shaded x range of a plot chart, painted behind the curve.
- PlotChartSeries
- One more curve on a plot chart, over the chart's x domain: points are evenly spaced from xMin to xMax like the chart's own, and a null point is a gap (the line breaks there: an undefined value or an asymptote).
- PlotChartYLine
- A horizontal line across a plot chart at y: a grid line, or a reference such as a target (dashed, with an inline label). axisLabel is written in the chart's y-axis gutter (PlotChartProps.yAxisWidth).
- PointsCodec
-
Points (
[[x, y], ...], anullbreaking the line). - PointsOp
-
Canvas.drawPoints(pointMode, points, paint). - PointsOpFields
- Pose
-
A Motion drawn with a fade and a blur: the pose a page of a page view
(
pageMotion) or a side of a route transition is drawn at. Flutter: aTransformin anOpacityin anImageFiltered. JSON: motion's keys withopacityandblurbeside them, flat ({"shiftX": -1, "opacity": 0.5}). - PoseFields
- Pose: a Motion with a fade and a blur (flat).
- Predicate
- What a branch tests.
- ProgressBand
- A colored zone of an arc progress bar, from start to end as fractions of the max value.
- ProgressBarProps
- A progress bar filled to value of max: a bar (horizontal, or vertical filling upward) or an arc with ticks, bands and a needle.
-
PropCodec<
T> - Reads and writes one prop's JSON. Decoding returns null for values it can't read (the prop then has its default).
-
PropDef<
T> - One prop of a widget.
- PropertySet
-
Sets property path (a binding path, DESIGN.md §5.1) of node node to
value: a JSON value, where a string is an expression read like a
binding's (
${= qty * 2},#FF0000,Hello ${name}). - PropRecord
- A small immutable model whose fields are declared as PropDefs in schema (as a widget's props are): only non-default fields are held and encoded; unknown keys round-trip.
- Props
-
A widget's prop values: only the ones that differ from Flutter's defaults
are held. Keys a declaration doesn't know round-trip untouched, and read
through a PropDef they decode: a node decoded with a catalog that
doesn't declare its type (
Catalog.corereading avideo) still gives its values to code that knows the type. - PropType
- What a prop holds (see PropKind). Pure data, read from a codec (PropCodec.type); a prop is nullable when its default is null (PropDef.nullable).
- PropTypes
- The Flutter value types' PropTypes.
- RadialGaugeProps
- A radial dial: zones, ticks, labels, a value arc (continuous or in segments), a target notch and a needle.
- RadioGroupBehavior
-
Flutter's
RadioGroup: theradionodes inside the node that set nogroupValueof their own share this one, and choosing one of them runs the node'schangedreactions with its value as${result}(RadioGroup.onChanged). Bind groupValue to the variable the choice is kept in:"bind": {"radioGroup.groupValue": "${budget}"}. - RadioGroupFields
-
RadioGroupBehavior: Flutter's
RadioGroup. - RadioProps
-
Flutter
Radio<String>, scaled to its box (32 px is its own size; its ring, 18 px, when compact). - Reaction
- A trigger and the actions it runs, in order: one chain. A blocking action is awaited before the next; a failing one stops the chain. JSON:
- RectOp
-
Canvas.drawRect(rect, paint); rect is[left, top, width, height]. - RectOpFields
- RemoveOp
- Remove nodes ids and their subtrees, detaching them from their parents.
- RepeatOp
-
Its ops once per item of each (an expression giving a list; a map
gives its values), or count times: Flutter's
for (final (index, item) in list.indexed) { ... }. Inside, the item is named as (item), its position indexAs (index), andcountis how many there are. - RepeatOpFields
- RetryFailedAction
-
Runs again the action chain whose failure the screen's
actionErrorreaction is handling (a toast's Retry after an offline save or a failed load): the same node's reactions to the same trigger, with the same event and list item. Nothing happens outside anactionErrorreaction or when that failure can't be retried (${error.retryable}is false). - Reveal
-
Scrolls the node into view when it appears (or when its
reveal.whenbinding turns true), to alignment of the viewport (0 top, 1 bottom). With follow it stays there while the content around it moves (lines added above an end marker, an image that loads late), until the user scrolls away: a chat or transcript pinned to its newest line. - RevealFields
- RootsOp
- Set the document's canvases (roots).
- RouteDismiss
- A drag anywhere on a screen that closes it interactively: the drag runs the transition backwards, and on release the pop completes or cancels with spring.
- RouteDismissFields
- RouteTransition
- A composable route transition. enter is where the incoming screen starts, exit where the covered one ends; closing plays them in reverse unless popEnter (where the screen revealed by the pop starts) or popExit (where the closing screen goes) are given. A preset fills in what's left null. JSON: an object, or a bare preset name.
- RouteTransitionFields
- RRectOp
-
Canvas.drawRRect(RRect.fromRectAndCorners(rect, ...), paint); radius as a decoration's (8,[x, y],[tl, tr, br, bl]). - RRectOpFields
- RunScriptAction
-
Runs script script (a layout's
scripts, by id) with arguments (by parameter name; expressions: one${...}passes its value as is, other text passes as JSON when it is JSON, else as text). Its result is the chain's${result}(and goes in resultVariable when set). When it fails, onError runs with${result}{error: {type, message, line, column}, logs}; without onError a failure stops the chain. - RunScriptFields
- RunScriptAction.
- ScriptDef
-
A script. Its params are variables in its source; what it returns at
its top level (or what its
mainreturns) is its result. It runs in a sandbox with no network, files or timers, reaching the app only through what its capabilities grant, and stops past timeoutMs of computing or memoryLimitMb. A page script (pageId set) wins over a project script of the same name. JSON (sparse): - ScriptFields
-
ScriptDef (a layout's
scripts). - ScriptParam
- A parameter of a ScriptDef: a JavaScript identifier, and the value a caller that passes none gets (defaultValue, JSON).
- ScriptsOp
-
Define, change or remove the document's scripts by name (sandboxed
JavaScript:
ScriptDef). Allowed only where the trust profile allows scripts. - ScriptTest
-
A sample run of a ScriptDef and what it should give (the editor's test
console): args by parameter, sample vars and input nodes values,
and the result expected, or the error expectError (its type, its
message, or
Type: message). - ScrollProps
-
Scrolling, for any container that can scroll its content
(
SingleChildScrollView). - ScrollToAction
- Scrolls node node into view: alignment 0 puts it at the start of the view, 1 at the end; offset moves it further. axis limits it to the scroll views along one axis (a map in a sideways window centers a point without scrolling the page under it); null scrolls every one around it.
- ScrollToFields
- ScrollToAction.
- SegmentedButtonProps
-
Flutter
SegmentedButton<String>. - SetOp
-
Create or replace node id with node (its JSON, as a document holds it
under
nodes), and optionally place it under parent at index (or in slot). Flutter: inserting a widget into the tree. - SetThemeModeAction
-
Sets the site's theme mode (Flutter's
ThemeMode, as an app setsMaterialApp.themeMode): mode is an expression givingsystem,lightordark("dark","${= theme.isDark ? 'light' : 'dark'}"to toggle). Every screen of the site redraws its named colors, text styles and controls in that mode at once, and${theme.mode}/${theme.isDark}change with it. With persist the choice is kept in the site's local storage: a reload, and every page after it, starts in it. JSON:{"type": "setThemeMode", "mode": "dark"}. - SetThemeModeFields
- SetThemeModeAction.
- SettingTarget
-
Where a ComponentSetting writes: a node and a binding path into it
(DESIGN.md §5.1), as a condition's
setentries. A field path in the olderproperties.*form that has no binding path is kept as v1 (the stored key's name). - SetValueAction
- Sets properties of node node at runtime (until the screen goes). A property bound to a variable sets the variable instead.
- SetValueFields
- SetValueAction.
- SetVariableAction
-
Changes variable variable (of the screen, or the app): write. JSON:
{"type": "setVariable", "variable": "count", "op": "add", "value": "1"}. A computed variable can't be set. To glide a number to a new value, AnimateAction it (animateTo). - SetVariableFields
- SetVariableAction.
- SetVariantAction
- Shows variant variant of variance node node.
- SetVariantFields
- SetVariantAction.
- ShapeBorder
-
One of Flutter's
OutlinedBorders: its kind, corner radius and side. JSON:{"type": "stadium", "borderRadius": 8, "side": {...}}. - ShapeBorderFields
- ShapeOp
-
An op that draws a shape: its paints, and hit, which makes it a hit
region (Flutter's
CustomPainter.hitTest). - ShapeOpFields
- The fields every shape op has.
- Shimmer
-
A band of light across what the node paints (a loading skeleton's
shimmer: Flutter's
ShaderMaskwith a movingLinearGradient), blended over the node's own pixels only. position places it; theshimmeranimation preset sweeps it across, over and over. JSON (sparse):{"color": "#FFFFFFFF", "strength": 0.8, "width": 0.44, "angle": 0, "position": 0.5}. - ShimmerFields
- Shimmer: a band of light across the node.
- ShowToastAction
- Shows a short message (a snackbar). Its button (actionLabel) runs actions on the chain that showed it. Cosmetics beyond the fields below (colors, radius, shadows, text styles, offsets per breakpoint) are in style, JSON.
- ShowToastFields
- ShowToastAction.
- SignatureProps
- A signature pad: strokes drawn with a finger or mouse, on a bordered card with a placeholder and a sign line.
- SinglePlaceholderProps
- A slot that shows its one child, or keeps its size when empty.
- Site
- A site in memory: its manifest, pages and component library, whatever loaded them (files, a publish, an editor's store).
- SiteManifest
-
A site's manifest (
site.json), loader-agnostic: which documents are its pages and components (as references the loader resolves: file paths relative to the manifest, publish ids...), its project variables (read by bare name in every document), breakpoints and any keys it doesn't model. - SliderProps
-
Flutter
Sliderwith itsSliderThemeData, at its box's design size. - SlotProps
-
Where a definition places what a call passes: the
childrenslot (the call'schildren) or a named one (the call'sslots[name]). With nothing passed it shows its own children (the default). Outside a definition it shows its children. Flutter:child/children/ aWidget titleparameter, placed inbuild. - SpacerProps
-
Flexible empty space in a row/column (
Spacer), or a fixed gap. With no size along its parent's main axis it is Flutter'sSpacer(): it takes the free space by itslayout.flex; a fixed size there makes it a gap. - Spring
-
Flutter's
SpringDescription: either the physical triple (SpringDescription(mass:, stiffness:, damping:), when stiffness and damping are both given) orSpringDescription.withDurationAndBounce(duration ms, bounce). The one spring value of the model: transitions, animations, gestures, a flip card's settle and a route's dismiss all take it. JSON:{"stiffness": 380, "damping": 36}or{"duration": 500, "bounce": 0.3}(sparse;{}iswithDurationAndBounce()'s defaults). - SpringFields
-
Spring: Flutter's
SpringDescription, physical or by duration and bounce. - StackProps
-
A freeform container: children placed by
layout.x/layout.y(FlutterStackwithPositioned/Alignchildren). - StateStyles
-
What a node and its descendants change to in each WidgetState: per
state, node id → a patch of that node's JSON (a merge patch: maps
merge,
nullremoves, anything else replaces; see mergePatch). Later states in WidgetState's order win where active states overlap. - StateStylesFields
- StateStyles: one field per WidgetState. Each holds that state's patches (node id → a merge patch of the node's JSON), which are free-form JSON (nodePatchesType): a patch can override any key of any node.
- Sticky
-
Pins the node inside the scrolling row or column it scrolls in, as CSS
position: sticky: once its leading edge reaches offset from the view's leading edge it stays there, drawn above the content scrolling under it, until the end of its parent (the section it heads) pushes it on.${sticky.stuck}says whether it is pinned now (the node's own bindings and the nodes inside it read it). The design canvas, which doesn't scroll, draws it in place. JSONtrueor{"offset": 8}. - StickyFields
- StreamedOp
-
One op out of a stream: the index of the op it came from in the tool
input's
ops, and whether it is part of asetop still arriving (a node of itsnodesmap). - StringCodec
- SwipeAction
- One action revealed behind a list item as it is swiped.
- SwipeActionFields
- SwipeActions
-
Swipe actions on a list's items (
Dismissible): toward the start reveals endActions, toward the end startActions; past threshold the first of the side runs. Running one fires the list'sswipeActionreactions with${result.action},${result.item},${result.index}. - SwipeActionsFields
- SwitchProps
-
Flutter
Switch, scaled to its box (59 px wide is Flutter's own size). - TabBarProps
-
Flutter
TabBar(labels only; no pages). - TableColumn
-
One column of a table view: the row field its cells show (key, read
as
${item.value}), its header text (label,${item.label}) and its width (null: the table'scolumnWidth). - TableColumnFields
- TableViewProps
-
Flutter's
TableView(two_dimensional_scrollables): a table that scrolls on both axes, with a header row and column that stay pinned. Rows are the bounddata(or rowCount); columns are columns (or boundprops.columns). Its slots are templates built per cell with${item}:cell({value, row, column, rowIndex, columnIndex}),columnHeader({label, column, columnIndex}),rowHeader({row, rowIndex}) andcorner. - TabsProps
-
A
TabBarover the selected child: one tab per child, titled by titles. - TextFieldProps
-
Flutter
TextField(aTextFormFieldwhen it validates). - TextProps
-
Text.rich: a string with styled runs. - TextRun
-
A styled range of a text's characters,
[start, end). - TextRunFields
- TextStyle
-
Flutter's
TextStyle. Every field is optional: a span's style is merged over its text's base style, as inText.rich. - TextStyleFields
- ThemeRefs
- Resolves theme names in JSON written for declared types against a ThemeTokens (already for the screen's size and mode: ThemeTokens.atScreen, ThemeTokens.forBrightness).
- ThemeTokens
-
A project's theme as published: what the runtime draws itself (dialogs,
toasts, the loading and error screens), what layouts read at run time
(
${theme.primary},${theme.colors.brand},${theme.text.title.fontSize},${theme.isDark}) and what an app can read to match its own widgets to a layout. Every token is optional. - Tilt
-
Tilts the node in 3D toward the pointer while it hovers or drags over
it. max holds the Motion values reached with the pointer at an
edge: the edge under it tips away (rotateX at the top and bottom,
rotateY at the sides, with its perspective); scale and translate are
reached while the pointer is over the node at all. Inside it
${tilt.x},${tilt.y}(-1–1) can be read, for parallax. - TiltFields
- TimePickerProps
-
A field showing a time (
HH:mm; empty shows its hint) that opens hour and minute columns (Flutter'sshowTimePicker). - Track
-
A value the user sets by dragging (node key
track): Flutter'sSlider(value,min,max, divisions as step,onChangedas thechangedreaction,onChangeEndaschangeEnd), generalised from a straight bar to a line, an arc or any path. The node carrying it is the thumb: it moves along the track as variable variable goes from min to max, and the design canvas draws it at the variable's value. Dragging it writes the variable; the wheel and arrow keys step it. Inside it${track.value},${track.progress},${track.dragging}and${track.focused}can be read; it fireschanged(${result.value},from,direction,crossed),dragEndandchangeEnd. - TrackFields
-
Track (node key
track): a value set by dragging (Flutter'sSlider). - TransformGesture
-
Makes the node pannable, zoomable and rotatable by touch, mouse and
trackpad (Flutter's
InteractiveViewer, and more): pinch and ctrl+wheel zoom about the focal point, one finger pans, two rotate, a double tap zooms to a point; a release flings and settles by physics within bounds and minScale–maxScale. The pose binds two-way to variables (xVariable...); inside it reads as${transform.x},${transform.scale}... Each change runs the node'schangedreactions, the end of a gesture itschangeEndones. - TransformGestureFields
- TransformHandles
- On-canvas handles that make a node an editable object (a sticker, a collage): corners scale it, edges stretch it, a knob rotates it.
- TransformHandlesFields
- Transition
-
How a change of property animates (Flutter's implicit animations:
AnimatedContainer(duration:, curve:),AnimatedOpacity,AnimatedScale,TweenAnimationBuilder): when the value there changes (a binding, a condition, a state style), the node tweens from what it shows to the new value over duration after delay on curve, or on spring. A change mid-flight carries on from where it is. A behavior key, a list:"transitions": [{"property": "motion", "duration": 240, "curve": "easeOutCubic"}, {"property": "opacity", "duration": 120}]. - TransitionFields
- Transition: how changes of one property path animate.
- TransitionReveal
- A clip that reveals a screen as a transition plays: a circle or rectangle growing from origin until it covers the screen.
- TransitionRevealFields
- TransitionSide
-
How one screen moves during a RouteTransition: an entering screen
starts at motion and comes to rest; a leaving one starts at rest and
ends at motion (a Pose: a transform,
shiftX/shiftYin screen sizes, with an opacity and a blur); this side's curve, delayMs and durationMs time it inside the route's duration. - TransitionSideFields
- Trigger
-
A trigger and its settings. JSON (sparse):
{"type": "click"},{"type": "changed", "debounceMs": 300},{"type": "timer", "intervalMs": 500},{"type": "keyDown", "key": "Meta+Enter"}. - TriggerFields
-
A reaction's trigger (
Trigger, its JSON keys). - TrustProfile
- What an edited document may use: node types, action types, scripts, link and image hosts, navigation, and size limits. TrustProfile.none allows everything; TrustProfile.agent is the default for agent-written UI.
- Typewriter
- Text that types itself out in a running app, like a typewriter or a terminal: charsPerSecond characters a second after delayMs, with a blinking block caret after the last one while it types. It types when the text first shows and again from the start when playKey changes; when the text grows by appending (a streamed reply) only the new characters type, and when it changes otherwise it types afresh. skip (bindable, e.g. to a tap that sets a variable) shows the rest at once; off enabled it shows all of it. The layout never changes as it types: the whole text is laid out and only what's typed is painted. The design canvas shows it all.
- TypewriterFields
- UnknownAction
- An action of a type this version doesn't know: its JSON, kept. Running it does nothing.
- UnknownDrawOp
- An op this version doesn't know: kept whole and written back; it draws nothing.
- ValidateAction
-
Flutter's
FormState.validate(): checks every text field of the form with its validator and shows each one's error; the first invalid field takes the focus. node is the form (a node with aformbehavior); empty: the form around the node whose reaction runs it, else every field of the screen.${result}after it: whether all are valid (true/false), for anifthat submits. - ValidateFields
- ValidateAction.
-
ValueCodec<
T> -
A value type with its own
fromJson/toJson. - ValueWrite
-
How a value is changed: op with value (an expression), at index
in a list or mapKey in a map (expressions too). Stored flat in its
action's JSON:
"op": "insert", "value": "${item}", "index": "0". - ValueWriteFields
- The ValueWrite keys, stored flat in SetVariableAction, SetStorageAction and CloudDocumentsAction JSON.
- Variable
- A variable: a name, a type and a default value, or a formula that computes it from other variables. JSON (sparse):
- VariableOption
- One option of a VariableType.choice variable.
- VarianceProps
- Shows one of several variants of its content (by id, or by breakpoint).
- VarsOp
-
Set variable values, declare variables (a full variable object as the
value) or remove them, in scope (a canvas id or
page_variables). - VecCodec
-
A list of numbers of one of lengths (
[x, y],[l, t, w, h]), each a literal or an expression. - ViewProgress
-
How far the node has scrolled through the viewport of the scrolling row
or column (or list) it is in, as
${view.progress}(0–1) and${view.visible}for its own bindings and the nodes inside it: a figure that draws itself as it scrolls up the screen (a path'strimEnd), a heading that fades in, a gauge reading how far through a section the reader is. Positions are fractions of the viewport's extent from its leading edge (0 top, 1 bottom), plus offset pixels. With variable, the progress is also written to that screen (or app) variable, under key when it's a map, for nodes elsewhere to read. The design canvas reads progress 0 above the fold and 1 for a node it shows whole. - ViewProgressFields
- VisualDensity
-
Flutter's
VisualDensity. - VisualDensityFields
- WantedBlock
-
What parseNotation gives: the document and what it could not read.
A component an answer asked for because none fitted a part of its UI:
Wanted "PollResults" "each option with its share of the votes", with the part built from plain parts under it. The part shows as written; a host may have the component designed and added for the answers that follow. - Wave
-
A sine added to a track's value:
amplitude * sin(2π(cycles·t + phase)), fading by1 − decay·t(a shake dies out with decay 1), folded to its absolute value with rectify (a ball's hops). Flutter has no counterpart; a list of them is a Fourier series: a wobble, a sway, a flame's flicker. - WaveFields
- Wave: a sine added to a track.
- WidgetSpec
- The declaration of one widget type.
Enums
- AnimateCommand
-
An
AnimationControllermethod (AnimateAction.command). - AnimationCurve
-
An easing curve, by the name of its Flutter
Curvesconstant.springis a damped spring (seeMotion.spring);stepjumps half way. - ArcFit
- How an arc progress bar sits in its box: the arc fitted to the box, or its whole circle (so arcs of any length line up into one ring).
- AuthOperation
- What an AuthAction does.
- AutovalidateMode
-
Flutter's
AutovalidateMode: when a field (or every field of aform) checks itself with its validator and shows the error, besides when the form is validated (thevalidateaction). - Axis
- BarcodeErrorCorrection
- How much of a QR code can be damaged and still be read.
- BarcodeSymbology
- The encoding of a barcode.
- BaseForm
- Which form of the base: for an agent writing files, or for a model streaming ops at run time.
- BlendMode
- BorderStyle
-
Flutter's
BorderStyle. - BoxFit
- BoxHeightStyle
-
Flutter's
BoxHeightStyle(selection boxes). - BoxWidthStyle
-
Flutter's
BoxWidthStyle(selection boxes). - ChartGridLineMode
- How a series chart places its grid lines (and solid reference lines). centered: centered on the value's rounded y (the bottom line one pixel row up, inside the plot); a 1 px line there straddles two pixel rows. crisp (the default): whole pixel rows from the value's rounded y down (the bottom line's up, inside the plot), so a line of whole width is sharp; other widths stay centered on the value. exact: the rows just above the value's unrounded y, like a Flutter box of that height whose bottom edge sits at the value (sharp when that is a whole pixel, soft otherwise).
- ChartSeriesKind
- How a chart series draws its values.
- ChartStackGapEdge
- Where a stacked bar's ChartProps.stackGap goes. between (the default): under each segment but the first, so the bar keeps its height. top: over every segment, the top one included, as a column of boxes each with a top margin (the bar's top sits the gap below its value).
- ChartType
- What a series chart draws.
- ChartYLabelAlign
- Where a series chart's y labels sit in the gutter left of the plot: end right-aligned 8 px left of the plot, start left-aligned at the chart's left edge.
- ChildModel
- How a widget takes children.
- ChipVariant
- How a chip is drawn.
- Clip
- ComponentRole
- What a node is to its component.
- ConditionOp
- How a Comparison compares its operands. Loose: numbers as numbers, booleans as booleans, anything else as case-insensitive text.
- CrossAxisAlignment
- DateTimeInputMode
- What a date/time input picks.
- DateTimeInputPicker
- What tapping a date/time input opens: the date and time pickers, or nothing (its own click reactions show a picker the design builds, and set its value).
- DecorationShape
-
The shape a Decoration paints: Flutter's
BoxShape. - DismissCommand
-
What a ControlDismissibleAction does to a DismissibleBehavior (or a
Pan): dismiss flies it off toward the direction as if swiped (and
fires that swipe: removing the item); returnFrom brings it back from
off-screen on that side (re-inserting it; a card built in the next
frame, an undo's, starts there); reset springs it back to rest.
shake wiggles it once (deprecated: the
shakeanimation preset). - DragAnchor
-
Which point of the copy that follows the pointer sits under it
(
Draggable.dragAnchorStrategy): where it was grabbed (childDragAnchorStrategy), or its center (a feedback node of another size). - DragAxis
- DragDirection
- A direction a node is dragged or dismissed in.
- DragSourceStyle
-
What the node shows where it was picked up while dragged
(
Draggable.childWhenDragging): a faded copy, nothing, or itself. - DragStart
- How a node starts a drag: on press, on long press, or long press on touch and press with a mouse.
- DropSlot
- Where a DropTarget inserts what's dropped on a list.
- DropSlotSize
- How big the slot a DropTarget opens in its list is: the dragged node's size, the slot node's own (room for an insertion line), or none: inGap draws the slot node in the gap between the items it would land between, moving nothing (a board's column insertion bar).
- EditFieldKind
- The kind of value an op field holds (its JSON Schema type).
- EditTextOperation
- What an EditTextAction does to its text field.
- EffectType
- FlipAxis
- The axis a FlipCard turns around.
- FloatingActionButtonLocation
-
Flutter's
FloatingActionButtonLocations, by name. - FloatingActionButtonType
-
Which
FloatingActionButtonconstructor:FloatingActionButton(),.small,.largeor.extended. - FloatingLabelBehavior
-
Flutter's
FloatingLabelBehavior. - FontStyle
- GaugeLimitStyle
- How a gauge meter's limit line is drawn.
- GaugeShape
- The shape of a gauge meter.
- GestureBounds
- What a gesture keeps a node inside of.
- HapticKind
-
How strong a HapticAction buzz is (Flutter's
HapticFeedback). - HeroFlies
- When a hero flies.
- HeroFlightShuttle
-
What a hero's navigation flight draws (Flutter's
Hero.flightShuttleBuilder; standard is Flutter's default shuttle). - HeroPlaceholder
- What a shared element's destination shows while its own drawing isn't ready (a network image still loading).
- IconAlignment
-
Where a button's icon sits: Flutter's
IconAlignment. - ImageRepeat
- InputBorderType
-
Which of Flutter's
InputBorders. - Join
- KeyboardDismissBehavior
-
When a view's keyboard is dismissed (
ScrollViewKeyboardDismissBehavior). - KeyframeInterpolation
- How a track's AnimationTrack.keyframes are joined.
- LineChartXLabelAnchor
- Where a line chart's x labels sit about their tick. edgeClamped: centered, the first starting at the tick and the last ending there (so both stay over the plot). start: starting at the tick. center: centered on it. end: ending at it.
- ListApply
- What a reorder (or a swipe action that removes the item) changes on its own, before the list's reactions run.
- ListLayout
- How a list arranges its items.
- ListSeparator
- What a list draws between its items.
- ListTileControlAffinity
-
Which side of a tile its control sits on (
ListTileControlAffinity). - ListTileTitleAlignment
- MainAxisAlignment
- MainAxisSize
- MasonryPlacement
- Which lane a masonry grid puts each item in.
- MediaOrientation
-
CSS
orientation: portrait when the screen is at least as tall as wide. - MigrationEntryKind
- What kind of thing a MigrationEntry records.
- ModalAnchor
-
What a popover is anchored to: nothing, the node that opened it, the
pointer, or a named node (OpenModalAction.anchorNode; in a list, the
copy built for OpenModalAction.anchorItem), so a modal opened from a
keyboard shortcut or a screen's
loadcan sit by a node too. - ModalPresentation
- How a modal shows.
-
Flutter's
NavigationDestinationLabelBehavior(plus showing only the unselected labels, whichBottomNavigationBarcan). - Where navigation may go.
- How a NavigateAction moves.
- NodeValueMode
- How a NodeValue sets its property.
- NoiseType
-
SVG
feTurbulence'stype: Perlin noise summed (fractalNoise, a soft grain) or its absolute values summed (turbulence, ridged). - PagePaintOrder
- Which pages of a page view draw on top where they overlap.
- PageTransition
- A page transition.
- PaginateCommand
- What a PaginateAction does to a pagination controller.
- PaginationMode
- How a list shows the pages.
- PaginationSource
- Where a pagination reads its items from.
- PaginationStrategy
- How a page is asked for.
- PaintingStyle
-
Flutter's
PaintingStyle: fill the shape, or stroke its outline. - PaintType
- PanRelease
- What a Pan does when let go: springs back to rest, or stays where it is (settling by its physics: a fling, snap points).
- ParticleShape
-
A particle's shape;
imagedraws the emitter's ParticleEmitter.image. - PathFillType
-
Flutter's
PathFillType. - PathOrient
- How a node on a PathFollow turns with the path.
- PlotChartGridAnchor
- Where a plot chart's grid lines start: at xMin (every step from the left edge, as a category axis), or at multiples of the step (0, ±step, …: a Cartesian graph whose grid stays put as the domain pans).
- PlotChartMarkerPosition
- Where a plot chart marker's label sits relative to its dot.
- PlotChartMarkerShape
- How a plot chart marker is drawn: a filled dot (the default), a hollow ring, a square or a diamond.
- PlotChartSelectionGuides
- How the selection is marked: a full-height line, dashed guides from the point to both axes, or only the dot.
- PointMode
-
Flutter's
PointMode(Canvas.drawPoints). - PopoverPlacement
- Where a popover sits relative to its anchor.
- ProgressBarShape
- A straight progress bar, or an arc like a dial.
- PropKind
-
The shape of a prop's value, for tools: PropType.name is the Flutter
type (
double,Color,EdgeInsets,MainAxisAlignment,List<Paint>,ButtonStyle), so a properties panel picks the control a Flutter developer expects, docs print it and codegen emits it. - ReorderPlaceholder
- What shows where a dragged item would land.
- ReorderStart
- How a drag of a list item to a new place starts.
- RevealOrigin
- Where a TransitionReveal grows from.
- RevealShape
- The shape a TransitionReveal clips a screen to.
- RouteSwipeBack
- When a route can be swiped back from its left edge (iOS style).
- RouteTransitionPreset
- A ready-made RouteTransition; sides given next to it override its own.
- ScaleMode
- How a screen fits the device.
- ScriptCapability
- What a script may do besides computing; anything else it calls fails. JSON: the capability's id.
- ScrollAxis
- The scroll views a ScrollToAction moves.
- ScrollPhysicsType
- SegmentedVariant
- How a segmented button is drawn.
- ShapeBorderType
-
Which of Flutter's
OutlinedBorders a ShapeBorder is. - ShowValueIndicator
-
Flutter's
ShowValueIndicator. - SignaturePlaceholderPosition
- Where a signature pad's placeholder sits.
- SignLineStyle
- How a signature pad's sign line is stroked.
- SignMarkPlacement
- Where a signature pad's mark sits: over the line's start, or before the line (centered on it, the line starting after it).
- SizeFit
- How a node sizes along one axis.
- SliderThumbShape
-
The slider's thumb (
SliderThemeData.thumbShape). - SliderTickMarkStyle
- The tick marks of a discrete slider.
- SliderTrackShape
-
The slider's track (
SliderThemeData.trackShape). - SliderValueIndicatorShape
-
The value indicator (
SliderThemeData.valueIndicatorShape). - SnapKind
- Where a GestureSnap settles a released node.
- StrokeAlign
-
Where a stroke sits relative to the box edge (Flutter's
BorderSide.strokeAlign: inside -1, center 0, outside 1). - StrokeCap
- StrokeJoin
- StrokeSides
-
Which sides a box's stroke runs along: every side (rounded with the
corners), one side, a pair of opposite sides (a ruled band), two sides
meeting at a corner (
topRight: the top and right sides, as a table's header corner), every side but one (noTop), or none, as Flutter'sBordertakes any of its sides. - TabAlignment
-
Flutter's
TabAlignment. - TabBarIndicatorSize
-
Flutter's
TabBarIndicatorSize. - TabContent
- What a tab shows.
- TabIndicatorStyle
- How the selected tab is marked.
- TextAlign
- TextAlignVertical
-
Vertical placement of text inside its box (Flutter's
TextAlignVertical). - TextCapitalization
-
Flutter's
TextCapitalization. - TextDecoration
- TextDecorationStyle
- TextDirection
- TextInputAction
-
Flutter's
TextInputAction. - TextInputType
-
Flutter's
TextInputType. - TextLeadingDistribution
- How a line's extra height is shared above and below its glyphs.
- TextOverflow
- ThemeMode
-
Whether a site shows its light or dark colors (Flutter's
ThemeMode, asMaterialApp.themeModetakes it). - TileMode
- ToastPosition
- Where a toast shows.
- ToastStyle
- A toast's look.
- TrackBlend
- How a track's value meets the property's own.
- TrackCommand
-
What a ControlTrackAction does to a Track: step turns it by
ControlTrackAction.steps of its step, as if dragged there (crossing
each step, then settling: a dial's nudge buttons); animateTo moves it
to ControlTrackAction.value (
Slider.onChanged(value)), reportingchanged,dragEndandchangeEnd. - TrackHitArea
- Where a Track's node takes the pointer: on itself, or anywhere in its parent too (a knob turned from anywhere in its box).
- TrackInput
- How the pointer moves along a Track: following it (along the line or path, round the arc), or dragging up/down, left/right, or either (up or right raises it: dx − dy).
- TrackInteraction
-
How the pointer may move a Track's value (Flutter's
SliderInteraction, the two it has of four): only by dragging the thumb (slideThumb), or also by pressing the track, which moves the thumb there before the drag goes on (tapAndSlide; TrackInput.follow only). - TrackShape
- The shape of a Track: a straight line, an arc about a pivot, or an SVG path (Track.path).
- TrackUnits
- What a Track's line and pivot are measured in: pixels, or fractions of the parent's size (x values of its width, y of its height).
- TransformCommand
-
What a ControlTransformAction does to a TransformGesture (a map, a
photo;
transformationController.value = ...): reset springs it to its rest pose (on a node without one, its dismissible or pan); scaleBy scales it by ControlTransformAction.value (a factor:1.5in,0.67out) about the middle of what its viewport shows; animateTo springs it to the pose ControlTransformAction.value gives ({x, y, scale, rotation}, keys left out kept: "fit to route"). - TransformPan
- When one finger (or a mouse) pans a TransformGesture.
- TransformTarget
- What a TransformGesture moves.
- TriggerType
- What starts a reaction.
- VariableType
- What a variable holds.
- VerticalDirection
- ViewProgressMode
- How a ViewProgress measures its node against the viewport.
- WheelZoom
- What the mouse wheel does over a TransformGesture.
- WidgetState
-
The interaction states of Flutter's
WidgetStatea node can style. - WrapAlignment
-
How the items of a run are placed along it (Flutter's
WrapAlignment). - WrapCrossAlignment
-
How the items of a run are placed across it (
WrapCrossAlignment). - WriteOp
- How a write changes a value.
Extensions
- CatalogSelect on Catalog
- A catalog's slice.
- ComponentDocument on LayoutDocument
- A layout document read as a component definition.
- LayoutDocumentBreakpoints on LayoutDocument
- A page document's copy of its project's breakpoints, until the editor keeps per-project data (as it keeps project scripts in the document).
- LayoutDocumentLogic on LayoutDocument
- LayoutDocumentScripts on LayoutDocument
-
The scripts of a layout document (its
scriptskey, in LayoutDocument.extra): project scripts and its page's. - Let on T
- VarianceBreakpoints on Node
- A variance node's responsive layout (DESIGN.md §5.3).
Constants
- animationRepeatType → const PropType
- animationTrackType → const PropType
-
authActionSpecs
→ const List<
ActionSpec> - The auth library's action type (AuthAction).
- authCatalog → const Catalog
- The auth library's declarations: Sign-in (AuthAction).
- axisPositionType → const PropType
-
AxisPosition: where a child of a freeform parent sits on one axis (Positioned/Align). - axisSizeType → const PropType
-
AxisSize: a design size and how it fits (SizedBox/Expanded/Flexible/ intrinsic). JSON: a number or{"fill"|"flexible"|"hug": v}. -
baseProps
→ const Map<
String, List< String> > - The base node types and the props the base shows for each (in this order; a key the type does not declare is skipped).
-
callForbiddenKeys
→ const Set<
String> -
The node fields a call may not carry: the inside belongs to the
definition (
call_field_not_allowed). -
callLayoutKeys
→ const Set<
String> -
The layout fields a call gives the instance's root: its size and
placement. The root keeps its own
padding(the inside is the definition's). -
collectionsSpecs
→ const List<
WidgetSpec> -
componentDocumentKeys
→ const Set<
String> - The keys a component document reads beyond a layout document's.
-
coreActionSpecs
→ const List<
ActionSpec> - The core action types (the CoreAction family).
- coreCatalog → const Catalog
- Catalog.core: the core's node types and actions.
-
coreWidgetSpecs
→ const List<
WidgetSpec> - The core's node types, in the order an editor lists them.
- customPaintType → const PropType
- dismissibleType → const PropType
-
docPages
→ const List<
DocPage> -
The reference's pages by section: what
ui_docsserves (docs/reference/<id>.md). -
docTasks
→ const List<
DocTask> - The index's task table: a need and the section that answers it.
- dragSourceType → const PropType
- drawOpType → const PropType
-
One draw op: a union on
op, its fields per DrawOpSpecs. - drawPaintType → const PropType
- drawRRectType → const PropType
- dropTargetType → const PropType
-
editNodeKeys
→ const Set<
String> - The keys a node reads (beyond the behaviors).
- everyItem → const String
- The wildcard key: every item of a list.
- flightType → const PropType
- flipCardType → const PropType
- formType → const PropType
- gesturePhysicsType → const PropType
- gestureSnapType → const PropType
- heroTagType → const PropType
-
indicatorsSpecs
→ const List<
WidgetSpec> - inkWellStyleType → const PropType
-
inputsSpecs
→ const List<
WidgetSpec> - jsonEquality → const DeepCollectionEquality
- Deep equality for JSON-like values (maps, lists, scalars).
- kChildrenSlot → const String
-
The slot a call's
childrenfill. - kDefaultHoldMs → const int
- How long a TriggerType.hold is held by default, in milliseconds.
- kDefaultVisibleFraction → const double
- How much of a node must be visible, by default, for TriggerType.enterViewport.
- kErrorWithoutMessage → const String
-
The InputDecorationFields.errorText of a field in error that shows no
message (its error text bound to
true): the error border only. - keyframeType → const PropType
- kOldestSchemaVersion → const int
-
The oldest schema this package migrates. Anything older (and a document
with no
schema) is read as this one. - kPreviewsKey → const String
- The document key of a component's previews.
- kSchemaVersion → const int
- The schema version this package reads and writes.
- kWidgetKey → const String
- The document key of a component's declaration.
- listDataSource → const DataSourceSpec
-
The core's data source: the list bound to a list's
data(or its item count). The data library addscloudandapi. -
materialSpecs
→ const List<
WidgetSpec> - measureType → const PropType
- motionType → const PropType
- nodeAnimationType → const PropType
- nodePatchesType → const PropType
- One interaction state's patches: node id → a merge patch of that node's JSON (see StateStyles). Free-form: a patch can touch any node key.
- panType → const PropType
- particleEmitterType → const PropType
-
pathAndSlotSpecs
→ const List<
WidgetSpec> - The core's media-like types: vector paths and slots the app fills.
- pathCommandType → const PropType
-
One
Pathbuilder call:{"<method>": [numbers...], "when": ...}. - pathFollowType → const PropType
- poseType → const PropType
- radioGroupType → const PropType
- revealType → const PropType
- routeDismissType → const PropType
-
routeTransitionCodec
→ const ValueCodec<
RouteTransition?> - RouteTransition; a bare preset name reads as that preset.
- routeTransitionType → const PropType
-
schemaMigrations
→ const Map<
int, SchemaMigration> - Upgrades by the version they produce: 3 is migrate2to3.
- scriptType → const PropType
- shimmerType → const PropType
- springType → const PropType
- starterBuildExample → const Json
-
The base's build example: a
ui_applyinput that applies with no error or warning under TrustProfile.agent and strict validation, with a selectable list and a labeled button. - starterEditExample → const Json
- The base's edit example, on starterBuildExample's document.
- stateStylesType → const PropType
- stickyType → const PropType
-
streamReferenceCodes
→ const Set<
String> - Codes of a reference to something that may arrive later in a stream: a warning while it streams, an error if it is still unresolved at the end.
-
symbolIcons
→ const Map<
int, String> - Icon names for symbols models write as text.
-
tableColumnCodec
→ const ValueCodec<
TableColumn> - tiltType → const PropType
- trackType → const PropType
- transformGestureType → const PropType
- transformHandlesType → const PropType
- transitionRevealType → const PropType
- transitionSideType → const PropType
- transitionType → const PropType
- typewriterType → const PropType
- uiApplyCompactDescription → const String
-
The
ui_applytool's description in the compact tools, whose node contents the system prompt (the runtime starter) describes. - uiApplyDescription → const String
-
The
ui_applytool's description: what a model reads about the ops. - uiDocsDescription → const String
-
The
ui_docstool: the full reference, one topic at a time. - uiDocsInputSchema → const Json
-
The
ui_docstool input's JSON Schema. - uiReadCompactDescription → const String
-
The
ui_readtool's description in the compact tools. - uiReadDescription → const String
-
The
ui_readtool's description. - uiReadInputSchema → const Json
-
The
ui_readtool input's JSON Schema. - viewProgressType → const PropType
- waveType → const PropType
Properties
-
schema3Steps
→ List<
MigrationStep> -
The steps of migrate2to3, in order: schema 2's (
migrationSteps2to3), then the one-way steps of 30.1.0 (spellingMigrationSteps).no setter
Functions
-
actionsEqual(
List< ActionDef> a, List<ActionDef> b) → bool -
Whether
aandbhold equal actions in the same order. -
allowedChildFits(
Node? parent, {required bool horizontal}) → List< SizeFit> -
The fits allowed under
parentalong an axis. -
animationRepeatFields(
) → List< PropDef< Object?> > -
animationTrackFields(
) → List< PropDef< Object?> > -
applyOps(
LayoutDocument document, Object? ops, {Catalog? catalog, TrustProfile profile = TrustProfile.none, EditCheck? check = catalogCheck, bool atomic = false, EditRevisions revisions = const EditRevisions(), int? baseRev, String author = 'agent', bool incomplete = false, bool protectRoots = false}) → EditResult -
Applies
opstodocumentin order and returns the result. Never throws. -
baseDocument(
{BaseForm form = BaseForm.runtime, Catalog catalog = Catalog.core, TrustProfile? profile, String kind = 'card', bool docsTool = true, DesignSystem? designSystem, List< BaseSegment> ? segments, List<DocPage> ? pages, List<DocTask> ? tasks}) → String -
The base:
baseSegmentsassembled forform, with the node types and actions ofcatalogrestricted byprofile(the file form: every type; the runtime form: TrustProfile.agent unless given).kind(runtime) iscard,pageorapp.docsTool:ui_docsis offered (runtime).segmentsandpagesdefault to the generated ones; the generator passes the ones it just made. -
borderSideFields(
) → List< PropDef< Object?> > -
breakpointKey(
String label) → String -
labelas a formula key: lower camel case of its letters and digits ("Large desktop" →largeDesktop, "XL" →xl). Empty for none. -
canonicalJson(
Object? value) → String -
value(JSON) as text with every object's keys sorted, no whitespace, and a whole double written as an integer (1.0→1): one text for one value, whatever order a store kept its keys in. What a published component's digest is over, and how validation compares subtrees. -
catalogCheck(
EditCheckInput input) → List< EditDiagnostic> - An EditCheck over EditCheckInput.catalog's declarations: unknown node types, node keys, props, layout and decoration keys and action types; prop values a declaration cannot read; children or slots a type does not take. Codes as strict validation's.
-
cellChildFits(
Node parent, SizeFit fit, bool horizontal) → String? -
A grid or page view sizes its children: they fill their cell or page.
Along a grid's rows, a grid whose rows shrink-wrap (
shrinkWrapRows, CSS grid's auto rows) sizes each row by its tallest item and stretches the others to it (CSSalign-items: stretch): a hugging or filling item counts its content there; a masonry grid's items keep their own length (they hug; fill has no end to reach). -
changedVariables(
LayoutDocument before, LayoutDocument after) → Map< String, Set< String> > -
Scope → the names of the variables declared in
afterthat are new or changed sincebefore(what unresolvedReferences checks after a stream). -
childFitOptions(
Node? parent, {required bool horizontal}) → Map< SizeFit, String?> -
Every fit, each with the reason it isn't allowed under
parent(null: allowed). With no parent (a top-level node on the board), fixed, hug and fill. -
colorStopFields(
) → List< PropDef< Object?> > -
componentCycles(
Map< String, Set< calls) → List<String> >List< String> > -
Every cycle in the call graph
calls(type → the types it calls), each as the path from its first type back to it ([A, B, A]), reported once (from the type that sorts first in it). -
containerTypes(
Catalog catalog) → List< String> -
The node types of
catalogthat take achildrenlist, most used first. -
copyJson(
Object? json) → Object? -
jsondeep-copied (maps and lists; other values are shared). -
customPaintFields(
) → List< PropDef< Object?> > -
declaredProps(
Catalog catalog, String type) → List< String> -
The declared prop keys of
typeincatalog(for messages). -
decodeOps(
Object? input) → DecodedOps -
Reads a batch of ops: the
ui_applytool input ({"ops": [...], "baseRev": 42, "atomic": false}), a bare list of ops, or one op. Total: what is not an op becomes a diagnostic with its index. -
decodeOpStream(
Stream< String> deltas, {bool partialSets = true}) → Stream<StreamedOp> -
Decodes
deltasas they arrive (OpStreamDecoder): every op as soon as it is complete. The stream's problems are not reported here: use the decoder for OpStreamEnd. -
defaultChildFits(
Node parent, SizeFit fit, bool horizontal) → String? - Most parents (stacks, screens' slots...): no Flexible; no Fill along an axis the parent scrolls.
-
describeTypes(
Catalog catalog, Iterable< String> types) → Json -
What
ui_read {"types": [...]}answers: each node type's children and slots, whether it takes a decoration, and its props (type and doc). -
designSystemSection(
DesignSystem ds, {bool docsTool = true}) → String -
The section of the base for
ds: its principles in brief, its tokens by name, its components (each with its purpose, parameters, slots, events and a minimal call) and its patterns in brief. -
designSystemTopic(
DesignSystem ds, String topic) → String? -
The
ui_docsanswer fortopicfromds:design(DESIGN.md),patterns(PATTERNS.md),tokens, or a component's name (its whole declaration). Null whentopicis none of them. -
diffPatch(
Json from, Json to) → Json? -
The merge patch that turns
fromintoto(null when they're equal). -
dismissibleFields(
) → List< PropDef< Object?> > -
docsIndex(
{Catalog catalog = Catalog.core, TrustProfile? profile, BaseForm form = BaseForm.runtime, List< DocPage> ? pages, List<DocTask> ? tasks}) → String -
The index the base ends with: the task table (need → section) and the
pages with what each documents. In the runtime form, every entry is a
ui_docstopic. -
docsTopic(
String topic, {Catalog catalog = Catalog.core, TrustProfile? profile, List< DocPage> ? pages, DesignSystem? designSystem}) → String -
One topic, sized for a tool result (a few hundred tokens): a page (its
"When to use", minimal example and pitfalls, and the list of its
sections), a section of a page by its anchor, or a node type, action
type, trigger or behavior by name (or by its anchor,
node-slider). Whatprofiledoes not allow says so: it is documented, not available. -
docsTopicNames(
{Catalog catalog = Catalog.core, List< DocPage> ? pages}) → List<String> - Every topic docsTopic answers.
-
dragSourceFields(
) → List< PropDef< Object?> > -
drawPaintFields(
) → List< PropDef< Object?> > -
drawRRectFields(
) → List< PropDef< Object?> > -
dropNaturalLineHeightFlags(
Object? json, {MigrationReport? report, String at = ''}) → Object? -
jsonwithout schema 2's natural line height flags (_naturalFlag), for a carrier migrated by hand (a publish model). -
dropTargetFields(
) → List< PropDef< Object?> > -
editPointer(
String path, Object key) → String -
pathextended bykey, escaped as a JSON pointer token. -
effectFields(
) → List< PropDef< Object?> > -
endOfStream(
LayoutDocument document) → List< EditDiagnostic> -
What is wrong with
documentonce a stream has ended: every child, slot or root id that still names no node (dangling_child, an error) and every node no root reaches (unreachable_node, a warning). -
explainDiagnostic(
EditDiagnostic d, {required Catalog catalog, Json? node}) → EditDiagnostic -
dwith a message that says how to fix it, when its code is one models hit;nodeis the node's JSON as the op wrote it. -
findScript(
Iterable< ScriptDef> scripts, String idOrName) → ScriptDef? -
The script of
scriptsthatidOrNamenames: by id, else by name, a page script over a project one. -
firstSentences(
String text, int n, {int max = 260}) → String -
The first
nsentences oftext, at mostmaxcharacters. -
fixInstruction(
{required int rev, Set< String> pending = const {}}) → String - What a tool result tells a model to do about rejected ops and pending ids: fix the document as it is now, by patching it.
-
flexAxisOf(
Node n) → Axis? -
The main axis of a row, column or flex node (a
flexby its FlexProps.direction); null for any other node. -
flexChildFits(
Node parent, SizeFit fit, bool horizontal) → String? - A row or column: Flexible along its main axis only; no Fill or Flexible along the main axis when it wraps or scrolls.
-
flickerAt(
double t) → double -
How far (0–1) the
flickerpreset (AnimationPresets) is between itsfromandtovalues att(0–1) of a run: waves of 3, 7 and 17 per run, so it wavers, flares and dips like a flame and ends where it began. -
flightFields(
) → List< PropDef< Object?> > -
flipCardFields(
) → List< PropDef< Object?> > -
fontCodepoints(
List< int> bytes) → Set<int> -
The codepoints a TrueType or OpenType font file maps (its
cmaptable, formats 4 and 12): what GlyphCoverage needs for a font a host loads. Empty when the file cannot be read. -
formFields(
) → List< PropDef< Object?> > -
gesturePhysicsFields(
) → List< PropDef< Object?> > -
gestureSnapFields(
) → List< PropDef< Object?> > -
heroTagFields(
) → List< PropDef< Object?> > -
imagePaintFields(
) → List< PropDef< Object?> > -
inkWellStyleFields(
) → List< PropDef< Object?> > -
inverseOps(
LayoutDocument before, LayoutDocument after) → List< EditOp> -
The ops that turn
afterback intobefore(apply them withatomic: true): what EditResult.inverse holds for one batch, for any two documents (a whole stream of batches). -
isComponentTypeName(
String type) → bool -
Whether
typeis written as a component's type name: UpperCamelCase, like a Dart class (PlanCard). Core types are lowerCamelCase (row), plugin typesvendor.name. -
isLayoutDocumentJson(
Object? json) → bool -
Whether
jsonis a layout document: anodesmap holding a typed node. -
isRelativeAssetPath(
String path) → bool -
Whether
pathnames a file relative to a published site (images/hero.jpg,./fonts/a.ttf), not a URL (https:,data:,asset:...), an absolute path or an expression. -
isUnionType(
PropType type) → bool -
Whether
typeis a union: a value written in one of several forms. -
jsonEncodeShort(
Object? v) → String -
keyframeFields(
) → List< PropDef< Object?> > -
listChildFits(
Node parent, SizeFit fit, bool horizontal) → String? - A list: its items fill across it; along it, they size themselves unless the list gives each the same extent (then they fill it).
-
listEquals<
T> (List< T> ? a, List<T> ? b) → bool - Element-wise list equality.
-
materialIconNamed(
String name) → Json? -
The Material icon
namenames (check_circle,lock_open_rounded): a suffix (_outlined,_rounded,_sharp) sets its style. Null whennameisn't an icon name. -
measureFields(
) → List< PropDef< Object?> > -
mediaPatchAt(
List< MediaRule> rules, double width, double? height, Breakpoints breakpoints, {List<PropDef< ? props}) → Json?Object?> > -
The merged patch of the
rulesthat hold on a screenwidth×height: in order, a later one winning where two set the same field (a union-typed value written in another form replaces the earlier one: mergeNodePatch, with the node type'sprops); keys outside MediaRule.patchKeys left out. Null when none holds. -
mediaRuleSetting(
List< MediaRule> rules, List<String> path, double width, double? height, Breakpoints breakpoints) → int? -
The index of the last rule of
rulesholding on a screenwidth×heightwhose patch sets the field atpath(["layout", "width"]), or null when none does (the node's own value applies). -
mediaWidthRanges(
Iterable< MediaRule> rules, Breakpoints breakpoints) → List<({double end, double width})> -
Screen widths that between them meet every combination of
rules' width conditions: the first width of each range their bounds cut the widths into (from 0), each with the range's end (exclusive; infinity for the last). -
mergeNodePatch(
Json base, Json patch, {List< PropDef< ? props, bool keepNulls = false}) → JsonObject?> > -
base(a node's JSON, or a patch of it) withpatchmerged in, as the node's declarations read them: as mergePatch's JSON merge patch, except that wherepatchwrites a union-typed field (isUnionType) in another form thanbasehas, the patch's value replacesbase's (itsnullkeys left out), as CSS replaces a declaration. A size object always replaces (it has one key).propsare the node type's prop declarations (null: its props merge as plain JSON). WithkeepNulls, anullis kept (two patches merged into one). -
mergePatch(
Json base, Json patch, {bool keepNulls = false}) → Json -
basewithpatchmerged in (RFC 7386): maps merge recursively, anullvalue removes the key (kept asnullwithkeepNulls, to merge two patches), anything else replaces. -
migrate2to3(
Json document, {MigrationReport? report, List< MigrationStep> ? steps}) → Json -
Upgrades a schema-2 layout document's JSON to schema 3: every legacy key
and deprecated field rewritten into the schema-3 form, or kept as
legacy.<name>and reported when it has none. Then the steps of 30.1.0, which give each concept one spelling (the node'sscaleandlayout.rotationare itsmotion,flightKeyandflightitshero,strokePath,subpathColorsandgradientPerSubpathcustomPaintpath ops, a box'spatha path node), run on the result. A document already at schema 3 (or later) is returned as given: it is read as current schema 3. Never throws: a step that fails on a node leaves that node as it was before the step and is reported.reportcollects what was done (MigrationReport.document names the document).steps, when given, are run instead, in one pass. -
migrateDocument(
Json document, {MigrationReport? report}) → Json -
document(a layout document of any schema; none reads as kOldestSchemaVersion) at kSchemaVersion (migrate2to3). A document at kSchemaVersion or later is returned as given. -
migrateJson(
Object? json, {MigrationReport? report}) → Object? - Any JSON that carries documents at kSchemaVersion (migrateJson2to3).
-
migrateJson2to3(
Object? json, {MigrationReport? report}) → Object? -
Any JSON that carries documents (a document, a publish model or bundle,
a component definition, a site manifest, a plugin package, or a file
holding several) with every schema-2 document in it migrated
(migrate2to3) and every other
"schema": 2(the carriers') set to 3. Text that holds a document (a stored payload) and a stored published component (adocumentwith adigest) are left as they are: the digest covers what was stored, so they are migrated when they are read. Never throws. -
migrateNode(
Json node, {int from = kOldestSchemaVersion, MigrationReport? report, String id = ''}) → Json -
A node's JSON alone, written in schema
from, upgraded to kSchemaVersion (migrateNode2to3). Returns a new map; never throws. -
migrateNode2to3(
Json node, {MigrationReport? report, String id = ''}) → Json - A node's JSON alone (outside a document) upgraded as migrate2to3 upgrades the nodes of a document (its state and media patches on itself included). Returns a new map; never throws.
-
migrationReportMarkdown(
MigrationReport report, {String title = 'Schema 2 → 3 migration report'}) → String -
reportas Markdown: the counts per step, every unconvertible value with the documents it was in, and every behavior change, grouped by what was said. -
motionFields(
) → List< PropDef< Object?> > -
movedPathHint(
String path) → String? -
What to write now instead of a binding path
path30.1.0 moved (as 30.0.0 spelled it), or null when it is not one: in 30.1.0 the node'sscaleandlayout.rotationare inmotion,flightKeyandflightinhero;strokePathandprops.subpathColorsarecustomPaintpath ops, a box'sprops.patha path node'sprops.data. A path an action or a condition names in a schema-2 document is rewritten by the migration; one that comes from elsewhere at run time (another document, a script) is refused where it is used, with this. -
nearestName(
String word, Iterable< String> candidates) → String? -
The candidate nearest to
word(case-insensitive edit distance), or null when none is close. -
nodeAnimationFields(
) → List< PropDef< Object?> > -
nodeSchema(
Catalog catalog) → Json -
The JSON Schema of a node in
catalog(itstypeone of the catalog's node types; the node keys and the behaviors as declared). -
noisePaintFields(
) → List< PropDef< Object?> > -
notationPrompt(
{Catalog? catalog, NotationOptions options = const NotationOptions(), DesignSystem? designSystem, Set< String> ? only, bool natural = false, bool wanted = false}) → String -
The prompt for the notation over
catalog(its level 0 and 1 types). -
olderSchemaPathHint(
String path) → String? -
schema2PathHint, else movedPathHint: what to write in the current
schema instead of an older schema's binding path
path. -
opSchema(
EditOpSpec spec) → Json - The JSON Schema of one op, from its declaration.
-
opsFromDocument(
LayoutDocument document) → List< EditOp> -
The ops that build
documentfrom nothing, in the order a model writes them top-down:roots, then each canvas's nodes depth-first (its state variables right after it, a large data variable just before the first node that reads it) (a node before its children, the first section complete before the second). Nodes no root reaches come last. -
outline(
LayoutDocument document, {int rev = 0, int labelLength = 40}) → Json -
The outline of
document:{"rev": rev, "outline": [[id, type, label, depth, extras?], ...], "pending": [...]}. The label is the node's name, else the firstlabelLengthcharacters of its text; extras list what is bound ("bind": ["props.text"]), its interaction states, its reactions' triggers and its media rules. Nodes under no root follow, at depth -1. -
outlineRow(
Node n, int depth, {int labelLength = 40}) → List< Object?> - One outline line: id, type, label, depth, and extras when there are any.
-
paintFields(
) → List< PropDef< Object?> > -
panFields(
) → List< PropDef< Object?> > -
parseNotation(
String text, {Catalog? catalog, NotationOptions options = const NotationOptions()}) → NotationResult -
textin the compact notation as a layout document. Never throws: what cannot be read is reported and skipped. -
particleEmitterFields(
) → List< PropDef< Object?> > -
pathFollowFields(
) → List< PropDef< Object?> > -
pendingIds(
LayoutDocument document) → Set< String> -
Ids
documentreferences (children, slots, roots) that it does not define. -
poseFields(
) → List< PropDef< Object?> > -
propKeys(
WidgetSpec spec) → List< String> -
The prop declarations of
specby key (for messages). -
propTypeLabel(
PropType t) → String -
A prop type as a model writes it:
start|end|center,number,"#AARRGGBB",TextStyle {fontSize, color...}. -
put(
Json json, String key, Object? value, [Object? defaultValue]) → void -
Puts
keyinjsonunlessvalueis null or equalsdefaultValue. -
radioGroupFields(
) → List< PropDef< Object?> > -
readBool(
Object? v) → bool? -
vas a bool, or null. -
readDouble(
Object? v) → double? -
vas a finite double, or null. -
readEnum<
T extends Enum> (List< T> values, Object? v, T fallback) → T -
The enum value named
v, orfallback. -
readExprPoints(
Object? json) → Expr< List< ?Vec?> > -
readExprVec(
Object? json, Set< int> lengths) → Expr<Vec> ? -
A vector field: a list of
lengthsnumbers (each may be an expression), or one expression giving the list. -
readFontFeatures(
Object? json) → List< String> -
A
fontFeatureslist read loosely: a list of settings (strings or{tag, value}maps) or one string of them separated by commas or spaces, as canonical strings; settings that aren't valid are dropped. -
readInt(
Object? v) → int? -
vas an int, or null. -
readList(
Object? v) → List< Object?> ? -
vas a list, or null. -
readMap(
Object? v) → Json? -
vas a JSON object, or null. Keys are stringified. -
readPaints(
Object? json) → List< Expr< DrawPaint> > -
An op's
paint: one paint, or several drawn in order (a fill then a stroke of the same shape, as two Flutter calls would). Each may be an expression. -
readPathCommands(
Object? json) → List< PathCommand> ? - A list of PathCommands; unreadable entries are dropped.
-
readPoints(
Object? json) → List< Vec?> ? -
A list of points:
[[x, y], ...](each coordinate may be an expression),{"x", "y"}maps, or flat numbers[x0, y0, x1, y1...]; anullentry breaks the line. Unreadable entries are dropped. -
readString(
Object? v) → String? -
vas a string, or null. -
readStrings(
Object? v) → List< String> -
vas a list of strings (non-strings dropped). -
readUi(
LayoutDocument document, Object? input, {int rev = 0, Catalog? catalog}) → Json -
Answers a
ui_readtool call (input:{"ids": [...], "outline": true}): the full nodes asked for (as the document holds them), missing ids, and the outline when asked or when no ids are given. -
readVec(
Object? json, Set< int> lengths) → Vec? -
A literal Vec of one of
lengths, or null. -
resolveStyleColors(
TextStyle style, Color? color(String)) → TextStyle -
stylewith each color it names read bycolor(left as written whencolorhas none). -
resolveThemeRefs(
LayoutDocument doc, ThemeTokens theme) → LayoutDocument -
docresolved againsttheme(ThemeRefs.document);docitself when it names nothing of it. -
revealFields(
) → List< PropDef< Object?> > -
routeDismissFields(
) → List< PropDef< Object?> > -
routeTransitionFields(
) → List< PropDef< Object?> > -
runtimeStarter(
{Catalog catalog = Catalog.core, TrustProfile? profile, String kind = 'card', bool docsTool = true, DesignSystem? designSystem}) → String -
The runtime form of the base: the system prompt of a model that streams
ui_applyops (baseDocument with BaseForm.runtime). -
schema2PathHint(
String path) → String? -
What to write in schema 3 instead of schema-2 binding path
path, or null whenpathis not one of schema 2's. Paths whose schema-3 form depends on the node (a loop's animation id, a drag's mode) name the pattern. -
schemaOf(
Object? json) → int -
The schema of document (or publish model, bundle, manifest, package)
JSON
json: itsschema, or kOldestSchemaVersion when it has none. -
scriptFields(
) → List< PropDef< Object?> > -
scriptSourceProblems(
Object? scripts) → List< ({int index, String message, String suggestion})> -
Names a script is often written against that it does not have, found
in the sources of
scripts(the document'sscriptslist as JSON):variables.get/setforvars, and another script called bare instead of asscript.<name>(…). At run time these are only "not defined". -
seamCall(
Node root, Node call) → Node -
The instance's root as shown at its call (
rootandcalleach as shown in their own scope): one box with the call's size and placement (its layout but for padding),visiblethe AND of both,opacitytheir product, the call's pointer reactions after the root's and the call's behaviors over the root's, key by key. -
setJsonPath(
Object? root, List< PathKey> keys, Object? value) → Json? - setJsonPathValue for a JSON object root.
-
setJsonPathValue(
Object? root, List< PathKey> keys, Object? value) → Object? -
Sets
keysin JSONroot(copied along the way) tovalue. Maps are created for missing keys; an index past a list's end (or a list missing) fails. Null when it can't be set. -
settingSlug(
String label) → String -
labelas a setting key: lower case, runs of other characters as_. -
shimmerFields(
) → List< PropDef< Object?> > -
springFields(
) → List< PropDef< Object?> > -
stateStylesFields(
) → List< PropDef< Object?> > -
stickyFields(
) → List< PropDef< Object?> > -
textRunFields(
) → List< PropDef< Object?> > -
textStyleFields(
) → List< PropDef< Object?> > -
tiltFields(
) → List< PropDef< Object?> > -
toolInputText(
List< EditOp> ops, {int? baseRev}) → String -
opsas aui_applytool input, the way a model streams it: compact JSON, one op per line. -
toRuntimeLinks(
String text) → String -
text's links asui_docslookups:[x](forms.md#forms-validation)isx (ui_docs "forms-validation"),[x](forms.md)isx (ui_docs "forms"); a link within the base keeps its text only. -
toRuntimeLinksIf(
String s, bool runtime) → String -
trackFields(
) → List< PropDef< Object?> > -
transformGestureFields(
) → List< PropDef< Object?> > -
transformHandlesFields(
) → List< PropDef< Object?> > -
transitionFields(
) → List< PropDef< Object?> > -
transitionRevealFields(
) → List< PropDef< Object?> > -
transitionSideFields(
) → List< PropDef< Object?> > -
typewriterFields(
) → List< PropDef< Object?> > -
uiApplyCompactInputSchema(
) → Json -
The compact
ui_applyinput schema: the op envelope, strictly (op names, field names and kinds from EditOp.specs); a node is any object, its contents described by the starter and checked by validation. -
uiApplyInputSchema(
Catalog catalog) → Json -
The
ui_applytool input's JSON Schema, forcatalog's node types. -
uiLints(
LayoutDocument document, {Iterable< String> ? ids, GlyphCoverage? hasGlyph}) → List<EditDiagnostic> -
Lints
document(or only the nodesids):empty_button,dead_controlandlow_contrastwarnings, and withhasGlyph,missing_glyph. -
uiTools(
Catalog catalog, {bool compact = false, bool docs = false}) → List< Json> -
The two tools, as
{"name", "description", "input_schema"}(the shape most providers take; renameinput_schemafor one that differs).compact: the op envelope only (uiApplyCompactInputSchema), for a system prompt that describes the nodes (runtimeStarter); otherwise every node type and key ofcatalogis in the schema.docs: alsoui_docs, the full reference one topic at a time (docsTopic). -
unionForm(
PropType type, Object? v) → String? -
The form a union-typed value
voftypeis written in (what decides whether a patch merges into it or replaces it), or null whentypehas one form only, orvnames none. -
unresolvedReferences(
LayoutDocument document, EditCheck check, {required Catalog catalog, required Iterable< String> nodes, Map<String, Set< variables = const {}}) → List<String> >EditDiagnostic> -
What
checkstill finds unresolved indocumentonce a stream has ended: the references (streamReferenceCodes) of thenodesandvariables(scope → names) the stream changed that were accepted as warnings while it ran ("it must exist when the stream ends") and never arrived, now errors (op -1; the ops stay applied). A formula that reads a name nothing declares, such as an item's field written without its item (filter(rows, status == 'Paid')), is reported here. -
viewProgressFields(
) → List< PropDef< Object?> > -
waveFields(
) → List< PropDef< Object?> > -
writeDouble(
double v) → num - Rounds a double for storage: integral values become ints, others keep up to 4 decimals (sub-pixel noise from editors goes away).
-
writeExprPoints(
Expr< List< e) → Object?Vec?> > -
writeExprVec(
Expr< Vec> e) → Object? - readExprVec's JSON; a one-number vector is written as the number.
-
writePaints(
List< Expr< paints) → Object?DrawPaint> > - readPaints' JSON: a single paint unwrapped.
-
writePoints(
List< Vec?> points) → List<Object?> -
writeRatio(
double v) → num - A ratio for storage: integral values become ints, others keep 12 significant decimals. Rounding a ratio to 4 decimals (writeDouble) is off by up to 0.00005 per unit, which a size scales: 320/180 stored as 1.7778 made a 300 px drawing 168.748 tall instead of 168.75.
-
writeVec(
Vec v) → List< Object?> - A Vec as JSON.
Typedefs
- ActionDecoder = ActionDef Function(Json json, ActionCommon common)
-
Decodes one action type's JSON (
jsonis the whole object). - ChildFitRule = String? Function(Node parent, SizeFit fit, bool horizontal)
-
Why
fitisn't allowed on a child ofparentalong thehorizontalaxis, or null when it is. - DocTask = ({String anchor, String need})
- A need and the section that answers it (the index's task table).
-
EditCheck
= List<
EditDiagnostic> Function(EditCheckInput input) -
Checks the nodes an op touched; errors reject the op. catalogCheck is
the core's;
strictEditCheck(package:codelessly_api/validate.dart) runs the strict validator on them. - GlyphCoverage = bool Function(String? family, int codepoint)
-
Whether the font a text is drawn with (
family: itsfontFamily, null for the default) has a glyph forcodepoint. - IconGlyph = Json
-
An icon glyph, as
IconProps.iconholds it:{"source", "codepoint", "name", "style", "fontFamily"?, ...}or{"image": url}. -
Json
= Map<
String, Object?> - A JSON object.
- PathKey = Object
-
One step of a binding path: a key, an index (
[2]), or every item (*). - SchemaMigration = Json Function(Json document, {MigrationReport? report})
-
One step that upgrades a document's JSON from schema
n - 1ton. -
Vec
= List<
Expr< double> > -
A list of numbers (a point
[x, y], a rect[left, top, width, height], a scale, a matrix), each a literal or an expression.