Skip to main content

spring_boot_starter_flutter 0.8.1 copy "spring_boot_starter_flutter: ^0.8.1" to clipboard
spring_boot_starter_flutter: ^0.8.1 copied to clipboard

Spring Boot for Flutter apps: SpringApplicationWidget, beans in widgets, state beans that rebuild widgets, lifecycle, platform profiles, themes from properties.

0.8.1 #

  • MarkdownOutline.current: the heading being read as the page scrolls (the last one in the top part of the screen; the last on the screen at the end of the page; the one show(id) went to until the reader scrolls again), kept up to date by the MarkdownView from the scrollable it is in. It notifies only at a change of heading. currentAmong(shown) gives the entry to mark in a list of some levels.
  • The frame meter tells a late frame from a frame nobody waited for: as each frame ends it notes whether the next was asked for. While something moves at every frame the time between frames is measured, as before; an animation that asks for a frame now and then (a background drifting 15 times a second) shows its rate in the plain color, with each frame measured by its build and raster, where it showed a red 19 fps and worst 67 ms. A frame the app waited more than a quarter of a second for is late too (it was taken for a pause). Fixed: a frame drawn for the meter alone made the app's frames look closer to each other (19 a second for 15).
  • WidgetBuildTracker (and WidgetBuildTracking): a bean of this type follows what the build of a SpringStatelessWidget or SpringState reads and asks for a new build when that changes. The way a state library of another package joins the Spring widgets; spring_boot_starter_flutter_signals declares one.

0.8.0 #

  • Breaking: Flutter 3.50 (Dart 3.14) and no design library. Flutter 3.50 moves Material and Cupertino out of the SDK's package:flutter into the packages material_ui and cupertino_ui. The starter follows: it imports package:flutter/widgets.dart only, and an app of spring.flutter.app.type: widgets (the default) has neither library in its build. What is Material's or Cupertino's is in two new starters: spring_boot_starter_flutter_material (the MaterialApp, toMaterial(), ThemeCustomizer, the components.*, visual-density, tap-target-size and ink splash theme properties, the palette from seed-color) and spring_boot_starter_flutter_cupertino (the CupertinoApp, toCupertino(), CupertinoThemeCustomizer, the cupertino.* theme properties). An app of type material or cupertino adds its starter to the dependencies and rebuilds; nothing else changes for it. Requires Flutter 3.50.
  • Breaking: spring.flutter.app.type is a text, not the enum AppType (removed): the type of a SpringAppFactory bean, which builds the app widget. WidgetsAppFactory is the starter's own (widgets); the design starters add material and cupertino; a design of your own is one more bean. A type without its starter fails the start, naming the starter to add. FlutterAppSettings.type is a String, FlutterAppProperties.type a String?.
  • spring.flutter.app.type need not be set: the application's starters decide, as Spring Boot deduces spring.main.web-application-type from the class path (SpringAppFactories.resolve). With one design starter (or one SpringAppFactory bean of the app's own) the app is of its type, without one widgets, as before; with several the start fails and asks for the property (in a profile of each platform when the platforms differ). Set, it always wins: widgets keeps a WidgetsApp though a design starter came with another package. An app that sets its type is not changed.
  • Breaking: SpringThemeData.colorScheme is a SpringColorScheme, the starter's own palette class with Material 3's 46 roles under the same names (primary, onSurface, surfaceContainerHigh; role(name), roles, withRoles, SpringColorScheme.baseline(brightness)), not Material's ColorScheme. Code that reads roles compiles as it is; code that needs Material's class takes toMaterial().colorScheme of the Material starter. Gone from SpringThemeData to the design starters (as extension members of the same names): toMaterial(), visualDensity, tapTargetSize, splashFactory, SpringThemeExtension, toCupertino(), cupertinoPrimaryColor, cupertinoProperties; schemeVariant is the variant's name. Gone from SpringThemes: material(name), cupertino(name), the customizers and the replacing themes (now the beans MaterialThemes and CupertinoThemes of the starters).
  • Breaking: a theme with seed-color, scheme-variant or contrast needs a design starter, which has the algorithm of Material 3's palette; without one the start fails and says so. A theme for an app without a design library sets its roles under colors.*; what it does not set is Flutter's baseline, as before. The same for the page transitions zoom (Material's) and cupertino. The theme properties of a design (components, visual-density, tap-target-size, a single-value splash, cupertino) stay accepted in an app without its starter, as a library theme has them for the apps of that design: they are not shown, as before, and no longer checked; one INFO line on spring_boot_starter_flutter.SpringThemes names the starter that reads each (SpringThemeData.unreadDesignProperties).
  • Breaking (a visible change): a theme without motion.page-transition has the platform's page transition, as Flutter does, instead of none: Material's per platform in a MaterialApp (with the Material starter), the iOS slide in a CupertinoApp, and, as in Flutter's own WidgetsApp, none in an app without a design library, whose pages still switch at once. PageTransitionSpec() and a motion.page-transition map without a type are platform too. An app that wants the pages to switch at once writes motion.page-transition: none.
  • spring.flutter.web.page.wasm-allow-list (FlutterWebPageProperties.wasmAllowList): the browser engines that run the WebAssembly of a flutter build web --wasm build (blink, gecko for Firefox 147+, webkit for Safari 26.2+). The generator passes it to Flutter's loader in web/index.html, under the app's own wasmAllowList; not set, Flutter's default (Blink only) applies.
  • ThemeDesign, ThemeDesigns, ColorSchemeSpec and the library package:spring_boot_starter_flutter/theme_design.dart: how a design library takes part in the themes of spring.flutter.theme.* (its palette from a seed, its own theme properties, its page transitions, its check at the start). A design is not a bean but a factory of its starter's module (@AutoConfigurationModule(factories: [OceanDesign()])), because the themes are read for the splash before any bean exists.
  • SpringAppFactory, SpringAppRequest, DesignPageRoutes and SpringPageRequest: the app widget and the page routes of a design library, as beans; DesignScope (with DesignControls, DesignTextField, DesignButton): what the design of the app gives the starters' own widgets (its text styles, its text selection, its text field and filled button), so MarkdownView and the login form of the security starter follow Material or Cupertino without importing them; DesignScope.controlsOf finds a design starter's controls below an app widget the app builds itself (a MaterialApp of its own).
  • SpringTypeScale and TextScript, SpringThemeData.localizedTextStyle(style, script): the sizes of the Material 3 type scale and the platform's default fonts as a table, so the 15 text styles of a theme are in an app without a design library what Theme.of(context).textTheme gives in a MaterialApp. ThemeValues.standardEasing: the Material 3 easings are numbers of the starter.
  • SpringTextSelectionControls: the selection handles of MarkdownView in an app without a design library: none where a mouse selects, two round handles in the theme's primary color on a touch screen (they were Material's on Android and Cupertino's on iOS; a design starter still gives its library's own).
  • ThemeReader.custom, customStates, leaf, kids, keys, sideAt, borderRadiusAt and parseNumber: a design reads values of its own kinds (an input border, a visual density) with the reader's rules and messages.

0.7.4 #

  • The task manager (spring.flutter.debug.isolates.enabled, a module of its own; debug.isolates: ⌘⇧I or seven taps and a hold): a small table in the dock with a line per row of isolateLoads (how busy, how late), and a tab of the debug panel with every value, the details and Copy JSON; in the corner position (bottom-right), read every interval (1s) only while the table or the tab shows, so nothing is measured otherwise (DebugIsolates, IsolateLoadsWatch, DebugIsolatesGauge, IsolatesView, DebugIsolatesSection). With it the engine's threads are rows too (FlutterEngineLoads, the flutterEngineLoads bean, an IsolateLoadSource; in a release build too, without a VM service): the frames' build times in main, raster from the frames' raster times, platform from the round trip of a harmless call of an engine channel, io from decoding a picture of one pixel; a browser has main and raster only. It measures from the first read until 30 seconds pass without one. An EngineLoadProbe is one source of its rows (FrameLoadProbe, RoundTripProbe).
  • Fixed: the timeline's Start tab stretched to the last event (a tab hidden a minute later), squeezing the start and its labels; it ends with the start now, the labels at least 60 apart. Long event names wrap in the Events tab, and events show by their eventName.
  • Debug overlays: the frame meter and the timeline are DebugOverlay beans that the debugDock puts on screen: those of one corner one under the other when they fit (spring.flutter.debug.overlays.layout: auto, max-height), one at a time with dots to swipe, tap or turn a wheel otherwise (a stack on a laptop, pages on a phone), past the safe area and margin; hidden while the debug panel is open. The debug panel's Overlays tab shows or hides each, and the Frames tab shows the live meter. FrameMeterGauge is the meter's panel alone.
  • spring.flutter.debug.drag.enabled (a module of its own, never in the build unless set): the debug overlays are dragged, with a mouse at once, on a touch screen after a long press, to the nearest corner (spring.flutter.debug.overlays.drag.snap: corners) or anywhere (free), kept for the next start (remember).
  • The timeline (spring.flutter.debug.timeline.enabled, debug.timeline: ⌘⇧L or six taps and a hold): a pill with the start (context ready, app shown) and the last observation, and a full view (a side panel, the whole screen on a phone) with the splash stages, each bean (grouped, the slowest first), the events, the observations' statistics and Copy JSON; also a tab of the debug panel. TimelineObservations is an ObservationHandler bean collecting every observation.
  • The start is measured always: the SplashTrace is the app's ApplicationStartup and the splashTrace bean, with a step per splash stage (spring.flutter.splash.<stage>), the steps of the start and every application event the context publishes (spring.event, by the startupEvents bean); each bean's creation only with spring.flutter.splash.trace or the debug timeline in the build, and the log only with the trace.
  • ResourcePrefetch (resourcePrefetch): on the web, the file of spring.resources.prefetch is downloaded once, delay after the app is shown (stage: app, the default) or behind the splash (stage: tasks), and its files kept in memory as resources, read a piece at a time: a site's pages then open without a download each.

0.7.3 #

  • spring.flutter.web.seo.lastmod is in the metadata (FlutterWebSeoProperties.lastmod): the build read it, editors called it unknown.
  • The Flutter assets are resource roots (AssetResourceRoot): resources: finds the assets below lib/resources/ the build did not embed (spring.resources.embed.exclude), and asset: patterns list the assets (asset:docs/**/*.md), so both read, check and search alike. AssetResource is a ContextResource: its path within the root it was found in.
  • spring.flutter.markdown.placeholders (false by default): MarkdownView replaces each {{key}} of a page by the configuration's value of the key (^{{site.package-version}} in a dependency example), leaving one without a value as it is (FlutterMarkdownProperties).
  • MarkdownView: a long page comes in over a few frames, the top first, so no frame builds and lays out the whole page (a page of tables took a fifth of a second on the web); MarkdownOutline.show of a heading not built yet builds the rest first (MarkdownOutline.buildAll). A table of more than 30 rows measures its columns once from their longest cells and adds its rows a few at a frame, instead of measuring every cell twice (IntrinsicColumnWidth).
  • The debug features are modules of their own, each decided at build time by its property and switched by its own action: spring.flutter.debug.frame-meter.enabled (DebugFrameMeter, debug.frame-meter: ⌘⇧X, or five quick taps and a sixth held two seconds) and spring.flutter.debug.motion.enabled (DebugMotion, debug.motion: ⌘⇧M), apart from the panel (spring.flutter.debug.enabled), so a release can have the frame meter alone. The meter starts in spring.flutter.frame-meter.position. Breaking: DebugPanel.frameMeter, frameMeterPosition and animations moved to DebugFrameMeter and DebugMotion; the Frames and Motion tabs say when the build left them out.
  • motion.wheel-scroll.inertia (mouse, trackpad, touch; 0, none, by default): quick wheel steps one after another go further each and glide longer; a trackpad's page glides on once the fingers stop (where the system does not); a flick throws the page further (ScrollInertia, InertiaScrollPhysics).
  • A frame a trackpad sends no step in, while the fingers move, gets the step of the frames before, and the next step is that much shorter: the page no longer stops for a frame and jumps twice as far in the next (a browser sends a step a frame, and now and then none).
  • Fixed: the frame meter counted the pauses in which nothing changed (Flutter draws only what changes) as slow frames, so a page scrolled step by step showed 45 fps at 60; its rate and worst frame are those of the frames while the app moves, a long frame included.
  • Fixed: on the web the theme's splash stopped while the app's first frames were made under it (a page of text: a tenth of a second and more), and it took over from the page loader with its ring turned back by the time the engine missed while the page started. The page loader now stays over the splash until the app is built (its own timeout removes it anyway), and the splash runs on the page loader's clock while that one is in the page.
  • motion.content-change: morph: the new page of a MarkdownView (RouteContentView) types itself in line after line from the top, each line's characters running through glyphs as text-change: morph does, the old page gone at once; the page has its full height from the first frame. stagger (30ms) is how much later each line starts than the one before it, over at most 85 percent of duration; delay how long the page waits before its first line (the duration of text-change, so breadcrumbs above it morph first). TextMorph is the glyph-by-glyph change both share, over the pieces of a span with their styles and links kept.
  • spring.flutter.fonts.families.<family> (files, languages): a font family declared by name, loaded from its files in any format the platform reads (.woff2 on the web too), and one for a language only when the app shows that language: before the first frame when it starts in it, else when it switches to it (ThemeFonts.loadLanguage). On the web, the engine then downloads no fallback fonts of its own, page after page, for the characters the main font lacks, which laid a Japanese page out again at every download.
  • Fixed: the text warm-up (spring.flutter.splash.warm-up.text) laid each font family out alone, so the characters the main font lacks counted as missing even when a fallback family has them, and the web engine downloaded Noto subsets for a Japanese app that had its own Japanese font. Each family is laid out with the theme's font-family-fallback behind it now.
  • motion.page-transition: content: a screen comes in the way motion.content-change shows other content (fade-up, a kind of the app's own), with its duration and curve unless the transition sets its own; so the pages of a site and its screens change alike (ContentPageTransitionsBuilder).
  • motion.enabled (true by default): false makes every motion of the app instant, as the device's "reduce motion" does (SpringThemeData.motionEnabled). The debug panel has a Motion tab that switches it at run time (DebugPanel.animations, DebugMotionSection).
  • The debug panel's Theme tab offers the themes the app's own files declare or choose (SpringThemes.ownNames), not every base theme a source file brings.
  • FlutterAppSettings.locale: the locale the app shows (MaterialApp.locale); a customizer sets it, the navigation starter to the first address's language.

0.7.2 #

  • README: the link goes to the package's own page on farum-azula.org, and what the README says was checked against the code and brought up to date.
  • background.image.repeat (no-repeat, repeat, repeat-x, repeat-y): tiles the background picture, so a small texture covers the screen at its own size (ThemeBackgroundImage.repeat).
  • MarkdownView: a code block with themes="a b" after its language shows a button per palette above it and switches its colors; a palette is the theme's style code-<name> (the properties of styles.code, and a label).
  • spring.flutter.web.dev-server.content-security-policy-report-only is a bool in FlutterWebProperties and the metadata, as the generator reads it (it was typed String, so an editor accepted any text the build then refused).
  • MarkdownView: a heading's long identifier (spring_boot_starter_flutter) breaks after an underscore on a narrow screen, not in the middle of a word.
  • MarkdownView: every code block has a copy button, in the corner of a block without a title (styles.code.copy, true by default; false for none). It was only in the header of a titled block.
  • MarkdownView: a table narrower than the view widens its columns to the view's width, so it lines up with the text (styles.table.fill, true by default; false keeps it as wide as its text). StyleValues.flag reads a true-or-false property of a style.
  • spring.flutter.web.page.translate (true by default): false keeps browsers and Google from offering to translate the page, whose text Flutter draws on a canvas.
  • A MarkdownView table wider than the view scrolls sideways; a column grows to styles.table.cell-width (default 280) and wraps there, not squeezed to a word a line on a phone.
  • styles.heading (color, h1 ... h6): the color of MarkdownView's headings, to set them apart from the text.
  • Fixed: MarkdownView in a WidgetsApp (no Material Theme) took Material's light fallback: black text and small headings on a dark theme. It takes the theme's text styles with Material's sizes for the locale's script. The router's task-switcher color likewise comes from the theme shown.
  • spring.flutter.theme.remember (default true): the theme chosen with ThemeSelection.select is kept between runs (ThemeChoiceStore, FileThemeChoiceStore in the app's files) and shown again while the splash shows (ThemeChoiceRestore, a SplashTask), so a reload does not flash the default theme.
  • The debug panel (springBootStarterFlutterDebugAutoConfiguration, DebugPanel, DebugPanelSection): logs, frames, configuration, beans, themes and the start of the running app, opened by the action debug.open (⌘⇧D, or four quick taps and a fifth held three seconds). spring.flutter.debug.enabled decides at build time: true every build, false none (no code), not set debug and profile builds only.
  • Shortcuts done with taps: taps:4+hold:3s (TouchPatternNotation, TouchPattern, ShortcutGesture, TouchPatternDetector), on every platform, in spring.flutter.shortcuts like keys. KeyedShortcutHandler: a handler bean that names its action's default keys.
  • The frame meter neither shows nor counts while the splash shows (FrameMeter.stages).
  • spring.flutter.web.seo.page-files (FlutterWebSeoProperties.pageFiles), read by the generator.
  • The frame meter (FrameMeter, spring.flutter.frame-meter.enabled, position, target-rate): a panel over the app with the frames a second it really draws, the build and raster times, the worst frame and a bar per frame, from Flutter's own timings, so a phone shows whether it keeps up. Its look is the theme's frame-meter (background, foreground, good, warning, bad, text-style; FrameMeterTheme).
  • The text warm-up lays its characters out once, spring.flutter.splash.warm-up.text.chunk (default 200) a frame, not all of them at every font that came in: the splash no longer stutters on a phone while the fonts come.
  • spring.flutter.web.page.max-pixel-ratio (FlutterWebPageProperties.maxPixelRatio), read by the generator: the most pixels for each point Flutter draws at on the web, so a phone's 3x screen can be drawn at 2.
  • background.frame-rate (default 15; every-frame): a moving background is drawn again that many times a second, not at every frame, so a slow drift no longer keeps the whole screen repainting (on the web it took the time of scrolling). ThemeAnimation(frameRate:) plays any repeating theme animation so.
  • Fixed: motion.wheel-scroll steps once in each frame, by the frame's time, not by a 16 ms timer (steps came two in a frame, then none, and a 120 Hz screen moved at 60); a trackpad's scroll passes as it comes, not eased again behind the fingers.
  • SplashTask beans run while the splash shows, once the beans exist and before the app: the new stage SplashStage.tasks, their progress the loader's last share (spring.flutter.splash.tasks.enabled, timeout, share). A task that fails or hangs does not stop the start.
  • textWarmUp (TextWarmUp, a SplashTask, off by default: spring.flutter.splash.warm-up.text.enabled): lays out the characters of the app's text while the splash shows, so the Noto fonts for Japanese, Chinese or emoji are downloaded then, not at the first change of the language. The text is the files of spring.flutter.splash.warm-up.text.resources (default the messages) and the TextWarmUpSource beans.
  • ThemeText(changeKey:, appear:): another changeKey plays the change again though the text is the same (the results of a search at every query); appear brings the text in the theme's way when it first shows.
  • motion.overscroll (platform, none): none turns off the stretch or glow at a scrollable's end for the whole app (Material's stretch distorts the content on Android).
  • spring.flutter.web.page.swipe-to-close (FlutterWebPageProperties), read by the generator.
  • motion.wheel-scroll (WheelScrollSpec, WheelScrollSmoother): a mouse wheel's steps eased over duration and scaled by speed for every scrollable of the app; none, Flutter's own jump, by default.
  • spring.flutter.web.seo.site-name: the site's name in link previews.
  • motion.scroll-to-top (SpringThemeData.scrollToTop): how a screen goes back to its top when it shows another page; 400ms ease-out-cubic by default, none jumps.
  • The build is an active profile, after the platform's: release, profile or debug (buildModeProfile), so application-release.yml configures what users run (logging.level.root: warn, say).
  • Fixed: two pages on screen at once (motion.content-change) with headings of the same text no longer share their keys (MarkdownOutline.keyOf(id, page:)), which failed with "Multiple widgets used the same GlobalKey".
  • motion.text-change.glyphs and glyph-duration: the characters a morph runs through (taken as written) and how long each shows; ThemeText.glyphs is gone (TextChangeSpec.defaultGlyphs).
  • motion.text-change.keep-unchanged (default false): true leaves the characters that stay the same in place, so only the changed part of a morph runs through glyphs. ThemeText(highlights:, highlightStyle:): stretches of the text highlighted once the change has settled.
  • motion.content-change (none, fade, fade-up, or a kind of the app's own registered in ContentTransitions; a map with duration and curve) and ContentChange: how a part of a screen shows other content in its place. MarkdownView.resource keeps the page shown until the next one is read, instead of showing nothing for a frame, then changes the theme's way.
  • HighlightedText: a text with stretches of it highlighted (TextRanges, in any order, overlapping), for the words a search found.
  • Keyboard shortcuts: keys in spring.flutter.shortcuts.<action> (primary+k is ⌘K on Apple's platforms and Ctrl+K elsewhere, char:?, lists), handlers as @Shortcut bean methods and ShortcutHandler beans asked in order, a screen's own ShortcutHandlers asked first, ShortcutLabel for the platform's way of writing them. Keys are read by a chain of ShortcutNotations (an app adds its own as beans); a wrong value stops the start naming the property. Installed around the navigator by KeyboardShortcutsCustomizer; KeyboardShortcutsScope for an app's own MaterialApp.
  • The stages of the start, SplashStage (page, engine, splash, starting, ready, exit, app; a platform goes through those it has): the SplashStages bean (a ValueListenable with each stage's time), a SplashStageEvent per stage (those before the context are published when it is ready), LoaderFrame.stage and ThemeLoader(stages:). On the web the page loader records page and engine and the splash goes on with the page's clock.
  • Loader tracks, loaders.<name>.tracks.<track>: values from 0 to 1 beside the phases (LoaderFrame.track), led by follows: time (duration, curve, repeat, delay), stage (from, ...) or progress (smoothing, curve: never jumps). Each follows is a LoaderTrackDriver in the LoaderTrackDrivers registry; an app registers its own. LoaderValues.fail and choiceOrNull for readers of an app's own.
  • spring.flutter.splash.yield-frames (on by default on the web, off elsewhere) and frame-budget (8ms): the beans are created between frames (FramePacer, a StartupPacer), so the splash keeps moving while the context starts.
  • spring.flutter.splash.trace (off by default): each stage and each bean's creation measured (SplashTrace, a BufferingApplicationStartup), logged at the end with the slowest beans; on the web also in the browser's Performance tab.
  • Breaking: an image's allow-http is gone. Every address of the themes (a theme's source, the shared source, the images) goes through RemoteAddressPolicy: http:// (and, off the web, a certificate that is not valid) stops the start with "the connection is not secure" naming the address and its property, unless spring.remote.allow-insecure=true, which logs a warning listing them. Images take github:owner/repo/path@ref addresses too.
  • loaders.<name>.web takes an https:// or github: address as well as a path, and loaders.<name>.web-sha256 pins it (the generator downloads it into the web page).
  • MarkdownOutline (MarkdownView(outline:)): the page's headings (MarkdownHeading: level, text, GitHub's anchor id) for an "On this page" list, and show(id) to scroll to one; a link to #id scrolls to its heading by itself.
  • MarkdownView: GitHub's callouts (> [!NOTE], [!TIP], [!IMPORTANT], [!WARNING], [!CAUTION]) in styles.callout.<kind>, titled by the messages markdown.alert.<kind>; a fenced block's title="..." as a header with a copy button (styles.code.header, styles.code.title); inline code in styles.code.inline-text and inline-background; links in styles.link.color. MarkdownView.resource shows the app language's translation next to the file (beans.ja.md) and follows the language.
  • ThemeText and motion.text-change (none, fade, morph, with duration, curve and stagger): a text that changes the theme's way when the same widget gets another text, the app's language switched say; morph changes the characters one after the other from the start of the line, each running through a few glyphs. At once with reduced motion.
  • Breaking: the starter knows no language of code by itself. What the code of a fenced block is made of comes from the theme's syntax.<language> (CodeSyntax): rules of regular expressions and kinds tried in order, keywords, types, aliases; a block in a language no theme has is plain text. CodeTokens.of takes a CodeSyntax, SpringThemeData.syntaxOf finds one by name or alias. Dart, Java, YAML, properties, shell and JSON are in farum-azula/themes (themes/code.yml).
  • spring.flutter.theme.source (with source-sha256 and refresh): a file downloaded for every theme, its values shared by all of them and under the app's own files; the way to take the languages of code (source: github:farum-azula/themes/themes/code.yml@<tag>).

0.7.1 #

  • Breaking: FlutterWebProperties is spring.flutter.web.dev-server.* (the dev server of flutter run on the web: host, port, base-href, https.*, headers.*, the CSP keys, proxy[n].*); a key at its old place under spring.flutter.web fails the build with its new name.
  • The web start no longer jumps when the page's loader hands over to the theme's splash: the splash keeps a square box of the logo's size from its first frame, lays out its logo, title and loader as the page's loader does (20 between them, the title's letter spacing), and the page's loader goes only after the frame that painted the logo (at most ThemeSplash.logoWait, 1.5 s, later).
  • SpringThemes.fromEnvironment reads the themes once per environment: the bean reuses those the splash read while the app started (and their Material themes), so the start no longer reads every theme twice while the splash animates. Customizers and replacing themes still apply per instance.
  • Behavior change: screens show at once by default. motion.page-transition not set is none (it was Flutter's own per platform), for Material's page routes too; write motion.page-transition: platform to get the platform's transition back.
  • motion.page-transition takes fade and a map form, { type, duration, curve } (references such as $motion.durations.fast allowed); SpringThemeData.pageTransitions (PageTransitionSpec, PageTransitionType) is what the navigation starter's router follows in every app type.
  • Re-exports spring_web_dart: the starter's API takes an HttpTransport (RemoteCache, the theme's network images), and an app that sends its own requests needs no other dependency.
  • spring.flutter.web.seo.* (FlutterWebSeoProperties, read by the generator): the pages the build writes for search engines, link previews and models.
  • spring.flutter.app.description: what the app is, which the build writes into web/index.html and the web manifest (with the title, and the theme's colors).
  • MarkdownView (MarkdownView.resource for a resource): GitHub's Markdown as widgets with the theme's text styles, HTML in it shown as text, a front matter left out, links to onLink; code blocks colored by CodeTokens (Dart, YAML, properties, shell, JSON) with the theme's styles.code (background, text, keyword, string, comment, number, key, annotation, variable, type, punctuation; the color scheme otherwise; the block's padding, radius, border, border-width). MarkdownView.code shows one block of code the same way. Selectable in any app: Material's SelectionArea under a MaterialApp, a SelectableRegion without a menu otherwise. New dependency: the Dart team's markdown.
  • SpringApp without a home builds MaterialApp.router (or the Cupertino or widgets one) on the application's RouterConfig<Object> bean, the one spring_boot_starter_flutter_navigation adds or the app's own (SpringApp.routerOf); SpringApplicationWidget takes neither home nor child for it, and a start without a router then fails with a message saying what to add.
  • BeanLookupScope: the bean lookups of the widgets below it (context.bean<T>(), the generated getters, the bean records of Spring widgets) run in its zone, so a custom scope knows which part of the app asks; the navigation starter puts one around every screen for its route and branch scopes.

0.7.0 #

  • No changes of its own: its generated code (lib/spring_gen/) is regenerated with spring_core_dart_generator 0.7.0.

0.6.3 #

Changes #

  • The editor metadata of the starter's properties is made from code: FlutterAppProperties (spring.flutter.app.*, type is the AppType enum), FlutterLifecycleProperties, FlutterFontsProperties, DesktopWindowProperties, FlutterWebProperties (spring.flutter.web.*, with @Range(0, 65535) and the blocked ports as @WarnValues on port; the generator still reads these keys from the configuration files), FlutterRestartProperties, FlutterSqliteProperties, FlutterDataSourceProperties and FlutterProperties (lib/src/properties/); the hand-written spring_metadata_additional.json is gone. The classes are bound by the Binder (@ComponentScan module flutterConfigBeans, imported by the auto-configuration, so each is a bean too) and the starter reads nothing by key string any more: the bind(Environment) factories, FlutterSqliteProperties.locationOf and SqliteLocation.parse are gone. Keys and defaults are unchanged. A bad value now fails the start with the standard Binding to target properties under '...' failed report (a ConfigurationPropertiesBindException, not an ArgumentError) naming the key and the accepted values; booleans accept what Spring does (true/false, on/off, yes/no, 1/0) and a bad one fails instead of counting as true. spring.flutter.scan-os-environment in the --dart-define values is bound the same way. A named data source's url is found by binding spring.datasources.<name>.*.
  • Generated files live in lib/spring_gen/: import package:app/spring_gen/main.spring.dart (was main.spring.dart); the auto-configuration imports spring_gen/spring_auto_configuration.spring.dart.
  • Themes without Dart (0.6.3): a design system in YAML under spring.flutter.theme.
    • References: $colors.primary names another value of the same theme (a whole value, or an operand of a color object), resolved per theme after extends. ${...} stays Spring's placeholder. A cycle or an unknown path stops the start with the chain and a "did you mean".
    • Nested tokens of any depth, with lists (List<Color>, List<double>, List<String>) and durations (250ms); no JSON in a YAML string. Two-level tokens read as before.
    • styles.<name>: values per state (default, hovered, focused, pressed, dragged, selected, scrolled-under, disabled, error; a property with states must have default), insets, and transition: <duration> [<curve>]. New ThemeStates widget (hover, focus, press, disabled, keyboard activation, cursor, blended values), ThemeStyle<V> and StateStyle.
    • Motion: motion.durations.<name> and motion.curves.<name> (a named curve or four numbers), Duration.zero when the system asks for less motion. The old motion.duration-<name> / motion.easing-<name> forms are gone (an unknown motion key fails the start). animations.<name> (duration, curve, repeat: none | loop | reverse), AnimationSpec and the ThemeAnimation widget. Style and animation names read in any spelling.
    • background (color, image, overlay with a linear or radial gradient, animation and effect drift / zoom / pulse, transition, screens.<name>): SpringApp puts it under every screen and makes the Material scaffold and Cupertino page backgrounds transparent unless the theme sets them. ThemeBackground, ThemeBackground.screen(name) and ThemeBackground.none.
    • Images from the network: ThemeImage (source, refresh, source-sha256, headers as a map, timeout, fallback, allow-http) for background.image, the screens' backgrounds and image tokens (a token map with source). Cached through FileTemplate (support, spring/images/<sha256 of source and pin>/; IndexedDB on the web), read from the cache at once and re-read in the background with refresh; the start never waits for the network. https unless allow-http: true. A redirect to another origin (host, port or scheme: no https to http downgrade either) drops custom headers; headers and the image keys source, fallback and source-sha256 are never searched for references, so a $ from a placeholder stays. A file that does not match source-sha256 is dropped with a warning. The web logs a CORS hint when a download fails.
    • References to the Material roles and shapes a theme does not declare ($colors.outline, $colors.surface-container-lowest, $shape.extra-small) are computed from the theme's own seed color, brightness, scheme variant and contrast. Durations take ms, s, m, h, d (any case, decimals, a space allowed: 250 ms, 1.5s); numbers take +5, .5, 1e3. One shared fixture (test/fixtures/theme_value_kinds.yaml) fixes how a value is typed (number, duration, insets, color, text).
    • Fixes: ThemeBackground keeps the child's state when a theme switch adds or drops the background (and lays out under unbounded constraints); the image loader sets no refresh timer for an image that went away; with less motion an animation with repeat: none goes to its end; a style that animates with an overshooting curve never gets negative insets.
    • Fix: a CupertinoThemeData made from typography or cupertino.text-theme kept iOS blue in the action and nav action text styles; they now carry the theme's primary color.
    • The typed theme keys read from the generated lib/spring_gen/theme.spring.dart (see spring_core_dart_generator).
    • ThemeStates(showFocusAlways: true): focused shows after a tap or a click too, not only with the keyboard (Flutter's focus highlight); for the frame of a text input.
    • One form for a color (0.6.3): a plain string (#RGB, #RRGGBB, #AARRGGBB, a Colors name, a $ reference) or an object { color, mix: { with, amount }, alpha } (mix first, then alpha; a percent is 0%..100% or 0..1; color is required; an unknown key fails with a "did you mean"). It works in colors.*, seed-color, tokens, styles (also per state), components (also per state), cupertino.*, background and gradient colors. A token or style map with a color is a color; color next to a key other than mix and alpha is an error. ThemeProperties.color, colorList and ThemeValues.percent read it; the generator and the editor check it with the same rules (test/fixtures/theme_value_kinds.yaml).
    • Loaders and the splash (0.6.3): loaders.<name> with the built-in kinds spinner, dots, pulse, bar and skeleton, phases (animations or {progress: true}) and kinds of your own (@ThemeLoaderKind, ThemeLoaderPainter<P>, ThemeLoaderWidget<P>, LoaderFrame<P>, the ThemeLoaderKinds registry); ThemeLoader, ThemeSkeleton; splash (background, logo, title, loader, animation, min-duration, exit) shown by SpringApplicationWidget from the moment the properties are read, following the start's progress (SpringApplication.progressListener), unless its own splash: builder is given; window.springLoaderHandOff(progress) is called on the web when the Flutter splash has painted. ThemeKeyReader.loader and splash; ThemeBackground.data. With less motion each phase is at its end and nothing shimmers. A plain splash: ripple is still the ink effect. A progress phase takes a min-duration (fill: { progress: true, min-duration: 2.5s }): it shows no more than its eased clock, so a fast start does not jump to 100 %. splash.exit.reveal lets the loader's last phase play over the app, which is already built under it (panels that part over the page instead of a fade from the splash's background). The splash takes the page loader's progress and elapsed time (ThemeLoader.resumeFrom, resumeElapsed, LoaderFrame.elapsed), so its phases, a flicker or a glitch go on where the page left them.
    • One duration syntax (0.6.3): a number with ms, s, m, h or d, decimals allowed, in motion, animations, styles, tokens, transition, refresh and timeout (the ISO-8601 form of refresh and timeout is gone).
    • Checks (0.6.3): background.effect without an animation, a radial gradient with end (it uses begin as its center), and a contrast outside -1 to 1 stop the start; ThemeBackground.screen('x') of a screen the theme does not have throws a FlutterError in debug that lists the screens. Every Material accent family is a color name (pinkAccent.shade200, shades 100, 200, 400, 700). A theme from a URL ignores extends with a warning, like active and source.
    • The type schema of the theme (types.color, percent, duration, ...) is in tool/theme_metadata.json for the editor and the JSON Schema.
  • Removed: lib/spring_keys.dart is gone (import spring_gen/main.spring.dart); classpath: is gone (use resources:); the old motion forms motion.duration-<name> and motion.easing-<name> are gone (use motion.durations.<name> and motion.curves.<name>); the one-line color forms (<color> alpha 12%, <color> mix <color> 14%, chains, role@38%, bare role names such as primary in components, 0x colors) are gone (use a color object or $colors.primary); SpringThemeData.duration(name) is gone (use context.theme.motion or tokenDuration); the headers: ['Name: value'] list form of a theme image is gone (use a map).
  • The theme section of spring_metadata.json lists every key of spring.flutter.theme, not only the components (active, extends, colors.<role>, typography.<style>.<key>, shape.*, motion.*, animations.*, background.*, styles.*, tokens.*, cupertino.*), with scope (root / theme) and open. tool/theme_metadata.json has them as properties.

0.6.2 #

Changes #

  • Files of the app (0.6.2): FileTemplate (beans fileTemplate and platformFileStore, each only when the app declares none) writes and reads text, bytes and objects (JSON through the ObjectMapper) in the places support (default), cache and documents (files.cache.write(...)), with exists, delete, list(prefix) and modifiedAt. Writes are atomic (temporary file, then rename), paths stay inside their place (.. and absolute paths are refused). temp((file) async {...}) and tempDir(...) give a unique temporary file or folder deleted after the block (an error too); createTemp() leaves the deleting to the caller; leftovers are removed when the context closes and, for runs that died, at the next start (<system temp>/spring/<run id>/). The bytes go through a replaceable FileStore (LocalFileStore on path_provider's directories, IndexedDB in a browser; temporary files in memory there, with no path). New dependency: spring_web_dart (see below).
  • One set of app directories (0.6.2): SQLite's location and FileTemplate's places share one mapping. On Windows support is %LOCALAPPDATA%\<company>\<product> (the machine's own) for both, and cache is the cache folder inside it (path_provider's cache directory is the local root itself, so it would have been the same folder as support); the other platforms are unchanged.
  • The theme from a URL (0.6.2): spring.flutter.theme.themes.<name>.source (an https URL or github:owner/repo/path@ref), source-sha256 and refresh. The theme is cached through FileTemplate (support, spring/themes/<sha256 of source and pin>/theme.yml and meta.json) and survives restarts: without refresh downloaded once and read from the cache for ever; with refresh the cache is used at once and read again in the background (If-None-Match / If-Modified-Since) when older, and a new theme is shown live. Another source or source-sha256 downloads again; caches of sources no longer configured are removed at start; offline or on any error the cache, else the theme of the app's own files; size limit 1 MiB, timeout 10 s, https only (redirects too). Only the theme's keys are taken from the file, the rest is ignored with a warning. SpringThemes.applySource sets the properties of one such theme. The HTTP client is the app's HttpTransport bean or spring_web_dart's platform client: the package depends on spring_web_dart now.
  • The whole theme (0.6.2): spring.flutter.theme.components.* sets every component theme of ThemeData (48: app bar, badge, banner, bottom app bar, bottom navigation bar, bottom sheet, the buttons, card, carousel, checkbox, chip, data table, date and time pickers, dialog, divider, drawer, dropdown menu, expansion tile, icon themes, input decoration, list tile, menu, menu bar, menu button, navigation bar, drawer and rail, popup menu, progress indicator, radio, scrollbar, search bar and view, slider, snack bar, switch, tab bar, text selection, toggle buttons, tooltip) with Flutter's own property names in kebab case, read by the type of the value (color, shape, border side, insets, size, constraints, text style, icon theme, number, elevation, enum, duration, mouse cursor, alignment, decoration, input border); cupertino.* sets CupertinoThemeData (primary and contrasting colors, backgrounds, handles, text-theme.*). Every WidgetStateProperty takes one value or a map per state (default, hovered, focused, pressed, dragged, selected, scrolled-under, disabled, error; the strongest wins in that order of strength: disabled, error, pressed, dragged, hovered, focused, selected, scrolled-under, default). Colors take an opacity (primary@12%), shapes a map (type, radius, side), text styles a map over a base style. An unknown component or property, or a wrong value, stops the start naming the valid ones, with a "did you mean". The 16 earlier components keep their keys. One fix: when button and a button kind (filled-button, ...) set the same property, the kind's value now wins (it was the shared one). The component reference of docs/configuration.md is generated from the mapping and a test keeps it in step.
  • ThemeKeyReader (context.theme of the generated lib/spring_keys.dart): the typed theme keys read the theme shown now through SpringTheme.of(context). See spring_core_dart_generator.
  • The theme files and the property-file lookup use resources: (resources:themes/*.yml); classpath: still works with a warning (see spring_core_dart).

0.6.1 #

Changes #

  • The desktop window from properties (0.6.1): spring.flutter.desktop.window.title-bar (default, transparent, hidden), title (the window's title; blank is none), initial-size, min-size and max-size (1280x800, logical pixels; min <= initial <= max, else the start stops naming the values; max-size is macOS contentMaxSize, Windows ptMaxTrackSize and GTK GDK_HINT_MAX_SIZE). SpringApplicationWidget reads them when the environment is ready and makes one call to the new platform code, before the first frame is shown (the frame is held back until the window is set, at most five seconds). A malformed value, or sizes that contradict each other, stops the start; phones and the web ignore the keys. DesktopWindow / DesktopWindowInsets give the space the window buttons take, WindowDragArea moves the window and maximizes it on a double click. The starter becomes a Flutter plugin for macOS (Swift: NSWindow), Windows (C++: DWM, WM_GETMINMAXINFO, WM_NCCALCSIZE) and Linux (GTK): its own code, no third-party package; it needs Flutter 3.47.

0.6.0 #

Changes #

  • Where a SQLite database lives: with a SQL database in the properties (spring.datasource.url, or spring.datasources.<name>.url), SpringApplicationWidget reads the app's directories from path_provider before the application starts and, once the configuration files are read, sets spring.datasource.sqlite.base-directory to the directory of spring.datasource.sqlite.location (support, the default; cache; documents; any other value stops the start) and spring.datasource.sqlite.isolate=true, with the lowest precedence (the app's own properties win), for the primary data source and each named one. support is Android's databases/ directory, iOS's and macOS's Application Support, Windows' %LOCALAPPDATA%\<company>\<product> (not the roaming directory) and Linux's $XDG_DATA_HOME/<app id>. The directory is created when it is missing. Nothing is set on the web or in a widget test (no path_provider plugin). The starter depends on path_provider (flutter.dev) and its platform interface, and only sets properties: it does not depend on the data starter.
  • BeanReadsPointcut.annotationTypes and NotifyListenersPointcut.annotationTypes list the annotations the pointcuts match (@ChangeNotifierComponent, @NotifyListeners); the generator reads them to give a proxy class only to the beans that carry one (smaller generated code; regenerate the .spring.dart files).

0.5.0 #

Changes #

  • SpringApplicationWidget closes the application context when a check fails after the start, and a hot reload's restart that fails closes both contexts, so runners and scheduled tasks no longer run behind the failure screen, and each retry no longer leaves another context running.

0.4.3 #

  • Flutter security (#15)
  • feat(security): spring_boot_starter_flutter_security — app login on e… (#13)
  • feat: single sign-on with OAuth 2.0 / OpenID Connect (spring_boot_sta… (#11)
  • docs: the READMEs and docs/ rewritten: what it is, why and when you need it, an example, then Spring (#10)

0.4.2 #

  • Docs (#9)

0.4.1 #

  • feat: guides replace the examples; optional parameters from Dart nullability; coloured logs

0.4.0 #

  • feat: spring_security_core, spring_boot_starter_security and a CI quality gate

0.3.2 #

  • feat: hot reload on the Dart VM, flutter_notes example, fixes for example resources and workspace builds

0.3.1 #

  • The example is a Spring Boot application written by the generator: a @ChangeNotifierComponent counter and Spring widgets.
  • spring_auto_configuration.dart re-exports the logging starter's (and through it spring_boot_dart's) auto-configuration, so a test naming springBootAutoConfiguration (ApplicationContextRunner) needs no other dependency.

0.3.0 #

  • Reading is free: a SpringStatelessWidget or SpringState listens to a @ChangeNotifierComponent or @NotifyListeners bean of its record only when its build read the bean's state (a getter, a field, through the proxy); calling its methods (onPressed: counter.increment) no longer rebuilds the widget. A read outside the widget's build (an item builder, a Builder below it, a callback) keeps it listening; a ChangeNotifier bean without either annotation is listened to always, as before.
  • The flutter_counter example uses Spring widgets for every widget that takes beans (CounterPage, AboutPage).
  • Breaking: spring.flutter.app.theme-mode is gone (the theme shown is spring.flutter.theme.active), and so are FlutterAppSettings.themeMode, color, theme, darkTheme and cupertinoTheme (the theme comes from SpringThemes; ThemeData beans theme / darkTheme and a CupertinoThemeData bean still replace the made ones).
  • Themes from properties (spring.flutter.theme.*): a shared part, the standard light / dark themes and named custom ones (themes.<name>, extends), the full ColorScheme (seed, variant, contrast, any role), the 15 TextTheme styles plus code, the Material 3 shape scale, elevations, density, splash, page transitions, motion, spacing, 19 components and the app's own tokens; checked at the start (values and the keys themselves: a misspelled key fails too), each made once into a SpringThemeData, a Material ThemeData and a CupertinoThemeData. ThemeSelection (active, system-light, system-dark, select) switches at run time; SpringThemes.loadYaml adds themes from a server; SpringTheme.of(context) for the app's own widgets; ThemeCustomizer / CupertinoThemeCustomizer beans; ThemeData beans theme / darkTheme still replace the made ones. Replaces spring.flutter.app.theme-mode (now spring.flutter.theme.active).
  • Fonts from the assets: every .ttf / .otf under flutter: assets:, in any directory, is loaded before the first frame in the family its file names (spring.flutter.fonts.auto-load, spring.flutter.fonts.exclude); a family the theme names but nothing provides is logged.

0.2.3 #

  • SpringApplicationWidget(home: ...) builds the app widget from the configuration (SpringApp): spring.flutter.app.type (widgets by default, material, cupertino), title, debug-banner, theme-mode, locales (by default the languages of the messages files), the ThemeData beans theme / darkTheme and a CupertinoThemeData bean, NavigatorObserver beans, FlutterAppCustomizer beans; Flutter's localization delegates come with the starter (flutter_localizations). child: keeps working for an app's own MaterialApp.
  • An example (example/): the counter app in one runnable file, and the way with the generator step by step.

0.2.2 #

  • Breaking: SpringStatelessWidget.build takes only the BuildContext; the widget reads its beans as beans, like a SpringState (in build and the callbacks made there). Tests build it with fakes through buildWith(context, beans).
  • README: the generator's check of @Value('asset:...').

0.2.1 #

  • First version: SpringApplicationWidget (starts the application, splash and failure screens, restarts the context on a hot reload when the generated code changed, switched off with spring.devtools.restart.enabled=false, closes the context when removed), SpringScope, context.bean<T>(), getters generated for @BuildContextAccess beans, SpringStatelessWidget<(...)> and SpringStatefulWidget<(...)> with SpringState<W, (...)>, beans checked at startup, AppLifecycleStateEvent with the context paused in the background and restarted in the foreground (spring.flutter.lifecycle.pause-in-background), platform profiles (android, ios, web, macos, windows, linux, mobile, desktop), the OS environment off unless spring.flutter.scan-os-environment, context.message in the app's locale.
  • @ChangeNotifierComponent(exclude: [...]): a stereotype for a plain class whose proxy mixes ChangeNotifier in and notifies after every public method and setter; listenableOf(bean).
  • SpringStatelessWidget and SpringState rebuild when a Listenable bean of their record notifies.
  • @NotifyListeners(exclude: [...]) on a ChangeNotifier bean (or some of its methods): notifyListeners() after each call through the AOP proxy, after a returned Future completes, also after an error.
  • asset: resources: @Value('asset:assets/intro.mp4') Resource video injects an AssetResource of the app's asset bundle (key for Flutter's APIs, exists() from the asset manifest), like classpath: for lib/resources/.
  • Brings spring_boot_starter_logging, switched on (console output in Boot's format, logging.*, LogBuffer).
  • Exports spring_core_dart, spring_boot_dart and spring_boot_starter_logging (without Banner and Size, which clash with Flutter's; the constraint is SizeConstraint), so an app depends only on spring_boot_starter_flutter.
0
likes
0
points
2.53k
downloads

Documentation

Documentation

Publisher

verified publisherfarum-azula.org

Weekly Downloads

Spring Boot for Flutter apps: SpringApplicationWidget, beans in widgets, state beans that rebuild widgets, lifecycle, platform profiles, themes from properties.

Repository (GitHub)
View/report issues

Topics

#dependency-injection #flutter #spring

License

unknown (license)

Dependencies

flutter, flutter_localizations, markdown, path_provider, path_provider_platform_interface, spring_boot_dart, spring_boot_starter_logging, spring_web_dart

More

Packages that depend on spring_boot_starter_flutter

Packages that implement spring_boot_starter_flutter