spring_boot_starter_flutter 0.8.3
spring_boot_starter_flutter: ^0.8.3 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.3 #
- Editors know Spring Boot's
spring.web.resources.cache.cachecontrol.*in a Flutter app withoutspring_boot_starter_web(FlutterWebCacheControlProperties, read by the generator at build time for the web build'sweb/_headers, nothing at run time): the keys were unknown to the language server there. - The resources downloaded and kept (
spring.flutter.resources.cache.*): anhttp:orhttps:resource of theResourceLoader(aResourceof@Value,getResource) is aCachedResource, downloaded once into the files'cacheplace (spring/resources/<sha256 of the address>/,dataandmeta.json), read from the disk from then on and across starts, asked again in the background past its age (max-age, 7 days) withIf-None-Match/If-Modified-Since; bytes that do not match their digest are downloaded again; rules by address (locations: an age of their own, or not kept). ACachedResourcegives its media type, its content's version (a key of@Cacheablewithspring.cache.resource-version),refresh,evict, its file on the disk andplayableUri()for a player of the app's own (the kept file, ablob:in a browser, or its address while it is still being kept). On iOS, Android and the desktops this keeps the app's images from the network across starts, whichImage.networkkeeps in memory only. ResourceView, a resource of any kind in the page by its location or aResource: its media type (the server's, else the extension) picks the firstResourceRendererbean that shows it (images:ImageResourceRenderer; an app adds its own for a video or a document), and the view does the rest for every kind (the placeholder, the error, the fade ofspring.flutter.resources.view.fade, the size, the shape, the semantics).ResourceImage, anImageProviderof a resource by its location, for Flutter's widgets that take one (DecorationImage,CircleAvatar,precacheImage): read through the same cache, one image per location in Flutter's image cache.- The files'
cacheplace as the app'sCacheStore(FileCacheStore), where each cache keeps a folder of its own: the resourcesspring/resources/, the@Cacheablecaches ofspring.cache.type: diskspring/caches/. Each keeps to a limit of its own, the other's files not counted:spring.flutter.resources.cache.max-sizekeeps the resources under a number of bytes, the least recently used going first (LimitedCacheStoreover one folder),spring.cache.disk.max-sizeeach cache on disk. PageUnderlay: what the browser shows under the page, covering the view (the scenes' canvas withspring.flutter.scene.canvas: engine). While one shows, the theme's background around the navigator draws nothing, which would hide it; a screen's own background (ThemeBackground.screen) and an opaque one (ThemeBackground.none) still draw.OutsideFrames: frames an app draws without Flutter (a 3D scene on a canvas of its own), reported with what they cost the page's thread. The frame meter shows each source on a line of its own (3D 60 fps · 0.9 ms) beside Flutter's frames.
0.8.2 #
- No changes of its own; released with the family version 0.8.2.
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 oneshow(id)went to until the reader scrolls again), kept up to date by theMarkdownViewfrom 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 fpsandworst 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(andWidgetBuildTracking): a bean of this type follows what thebuildof aSpringStatelessWidgetorSpringStatereads 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_signalsdeclares 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:flutterinto the packagesmaterial_uiandcupertino_ui. The starter follows: it importspackage:flutter/widgets.dartonly, and an app ofspring.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(theMaterialApp,toMaterial(),ThemeCustomizer, thecomponents.*,visual-density,tap-target-sizeand inksplashtheme properties, the palette fromseed-color) andspring_boot_starter_flutter_cupertino(theCupertinoApp,toCupertino(),CupertinoThemeCustomizer, thecupertino.*theme properties). An app of typematerialorcupertinoadds its starter to the dependencies and rebuilds; nothing else changes for it. Requires Flutter 3.50. - Breaking:
spring.flutter.app.typeis a text, not the enumAppType(removed): the type of aSpringAppFactorybean, which builds the app widget.WidgetsAppFactoryis the starter's own (widgets); the design starters addmaterialandcupertino; a design of your own is one more bean. A type without its starter fails the start, naming the starter to add.FlutterAppSettings.typeis aString,FlutterAppProperties.typeaString?. spring.flutter.app.typeneed not be set: the application's starters decide, as Spring Boot deducesspring.main.web-application-typefrom the class path (SpringAppFactories.resolve). With one design starter (or oneSpringAppFactorybean of the app's own) the app is of its type, without onewidgets, 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:widgetskeeps aWidgetsAppthough a design starter came with another package. An app that sets its type is not changed.- Breaking:
SpringThemeData.colorSchemeis aSpringColorScheme, 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'sColorScheme. Code that reads roles compiles as it is; code that needs Material's class takestoMaterial().colorSchemeof the Material starter. Gone fromSpringThemeDatato the design starters (as extension members of the same names):toMaterial(),visualDensity,tapTargetSize,splashFactory,SpringThemeExtension,toCupertino(),cupertinoPrimaryColor,cupertinoProperties;schemeVariantis the variant's name. Gone fromSpringThemes:material(name),cupertino(name), the customizers and the replacing themes (now the beansMaterialThemesandCupertinoThemesof the starters). - Breaking: a theme with
seed-color,scheme-variantorcontrastneeds 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 undercolors.*; what it does not set is Flutter's baseline, as before. The same for the page transitionszoom(Material's) andcupertino. The theme properties of a design (components,visual-density,tap-target-size, a single-valuesplash,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 onspring_boot_starter_flutter.SpringThemesnames the starter that reads each (SpringThemeData.unreadDesignProperties). - Breaking (a visible change): a theme without
motion.page-transitionhas the platform's page transition, as Flutter does, instead of none: Material's per platform in aMaterialApp(with the Material starter), the iOS slide in aCupertinoApp, and, as in Flutter's ownWidgetsApp, none in an app without a design library, whose pages still switch at once.PageTransitionSpec()and amotion.page-transitionmap without atypeareplatformtoo. An app that wants the pages to switch at once writesmotion.page-transition: none. spring.flutter.web.page.wasm-allow-list(FlutterWebPageProperties.wasmAllowList): the browser engines that run the WebAssembly of aflutter build web --wasmbuild (blink,geckofor Firefox 147+,webkitfor Safari 26.2+). The generator passes it to Flutter's loader inweb/index.html, under the app's ownwasmAllowList; not set, Flutter's default (Blink only) applies.ThemeDesign,ThemeDesigns,ColorSchemeSpecand the librarypackage:spring_boot_starter_flutter/theme_design.dart: how a design library takes part in the themes ofspring.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,DesignPageRoutesandSpringPageRequest: the app widget and the page routes of a design library, as beans;DesignScope(withDesignControls,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), soMarkdownViewand the login form of the security starter follow Material or Cupertino without importing them;DesignScope.controlsOffinds a design starter's controls below an app widget the app builds itself (aMaterialAppof its own).SpringTypeScaleandTextScript,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 whatTheme.of(context).textThemegives in aMaterialApp.ThemeValues.standardEasing: the Material 3 easings are numbers of the starter.SpringTextSelectionControls: the selection handles ofMarkdownViewin 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,borderRadiusAtandparseNumber: 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 ofisolateLoads(how busy, how late), and a tab of the debug panel with every value, the details and Copy JSON; in the cornerposition(bottom-right), read everyinterval(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, theflutterEngineLoadsbean, anIsolateLoadSource; in a release build too, without a VM service): the frames' build times inmain,rasterfrom the frames' raster times,platformfrom the round trip of a harmless call of an engine channel,iofrom decoding a picture of one pixel; a browser hasmainandrasteronly. It measures from the first read until 30 seconds pass without one. AnEngineLoadProbeis 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
DebugOverlaybeans that thedebugDockputs 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 andmargin; 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.FrameMeterGaugeis 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.TimelineObservationsis anObservationHandlerbean collecting every observation. - The start is measured always: the
SplashTraceis the app'sApplicationStartupand thesplashTracebean, 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 thestartupEventsbean); each bean's creation only withspring.flutter.splash.traceor the debug timeline in the build, and the log only with the trace. ResourcePrefetch(resourcePrefetch): on the web, the file ofspring.resources.prefetchis downloaded once,delayafter 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.lastmodis in the metadata (FlutterWebSeoProperties.lastmod): the build read it, editors called it unknown.- The Flutter assets are resource roots (
AssetResourceRoot):resources:finds the assets belowlib/resources/the build did not embed (spring.resources.embed.exclude), andasset:patterns list the assets (asset:docs/**/*.md), so both read, check and search alike.AssetResourceis aContextResource: its path within the root it was found in. spring.flutter.markdown.placeholders(falseby default):MarkdownViewreplaces 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.showof 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) andspring.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 inspring.flutter.frame-meter.position. Breaking:DebugPanel.frameMeter,frameMeterPositionandanimationsmoved toDebugFrameMeterandDebugMotion; 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 aMarkdownView(RouteContentView) types itself in line after line from the top, each line's characters running through glyphs astext-change: morphdoes, 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 ofduration;delayhow long the page waits before its first line (the duration oftext-change, so breadcrumbs above it morph first).TextMorphis 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 (.woff2on 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'sfont-family-fallbackbehind it now. motion.page-transition: content: a screen comes in the waymotion.content-changeshows 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(trueby default):falsemakes 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 asourcefile 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 withthemes="a b"after its language shows a button per palette above it and switches its colors; a palette is the theme's stylecode-<name>(the properties ofstyles.code, and alabel).spring.flutter.web.dev-server.content-security-policy-report-onlyis aboolinFlutterWebPropertiesand the metadata, as the generator reads it (it was typedString, 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,trueby default;falsefor 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,trueby default;falsekeeps it as wide as its text).StyleValues.flagreads a true-or-false property of a style.spring.flutter.web.page.translate(trueby default):falsekeeps browsers and Google from offering to translate the page, whose text Flutter draws on a canvas.- A
MarkdownViewtable wider than the view scrolls sideways; a column grows tostyles.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 ofMarkdownView's headings, to set them apart from the text.- Fixed:
MarkdownViewin aWidgetsApp(no MaterialTheme) 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(defaulttrue): the theme chosen withThemeSelection.selectis kept between runs (ThemeChoiceStore,FileThemeChoiceStorein the app's files) and shown again while the splash shows (ThemeChoiceRestore, aSplashTask), 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 actiondebug.open(⌘⇧D, or four quick taps and a fifth held three seconds).spring.flutter.debug.enableddecides at build time:trueevery build,falsenone (no code), not set debug and profile builds only. - Shortcuts done with taps:
taps:4+hold:3s(TouchPatternNotation,TouchPattern,ShortcutGesture,TouchPatternDetector), on every platform, inspring.flutter.shortcutslike 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'sframe-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-scrollsteps 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. SplashTaskbeans run while the splash shows, once the beans exist and before the app: the new stageSplashStage.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, aSplashTask, 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 ofspring.flutter.splash.warm-up.text.resources(default the messages) and theTextWarmUpSourcebeans.ThemeText(changeKey:, appear:): anotherchangeKeyplays the change again though the text is the same (the results of a search at every query);appearbrings the text in the theme's way when it first shows.motion.overscroll(platform,none):noneturns 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 overdurationand scaled byspeedfor 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,nonejumps.- The build is an active profile, after the platform's:
release,profileordebug(buildModeProfile), soapplication-release.ymlconfigures 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.glyphsandglyph-duration: the characters amorphruns through (taken as written) and how long each shows;ThemeText.glyphsis gone (TextChangeSpec.defaultGlyphs).motion.text-change.keep-unchanged(defaultfalse):trueleaves the characters that stay the same in place, so only the changed part of amorphruns 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 inContentTransitions; a map withdurationandcurve) andContentChange: how a part of a screen shows other content in its place.MarkdownView.resourcekeeps 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+kis ⌘K on Apple's platforms and Ctrl+K elsewhere,char:?, lists), handlers as@Shortcutbean methods andShortcutHandlerbeans asked in order, a screen's ownShortcutHandlersasked first,ShortcutLabelfor the platform's way of writing them. Keys are read by a chain ofShortcutNotations (an app adds its own as beans); a wrong value stops the start naming the property. Installed around the navigator byKeyboardShortcutsCustomizer;KeyboardShortcutsScopefor an app's ownMaterialApp. - The stages of the start,
SplashStage(page,engine,splash,starting,ready,exit,app; a platform goes through those it has): theSplashStagesbean (aValueListenablewith each stage's time), aSplashStageEventper stage (those before the context are published when it is ready),LoaderFrame.stageandThemeLoader(stages:). On the web the page loader recordspageandengineand 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 byfollows: time(duration,curve,repeat,delay),stage(from, ...) orprogress(smoothing,curve: never jumps). Eachfollowsis aLoaderTrackDriverin theLoaderTrackDriversregistry; an app registers its own.LoaderValues.failandchoiceOrNullfor readers of an app's own. spring.flutter.splash.yield-frames(on by default on the web, off elsewhere) andframe-budget(8ms): the beans are created between frames (FramePacer, aStartupPacer), 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, aBufferingApplicationStartup), logged at the end with the slowest beans; on the web also in the browser's Performance tab.- Breaking: an image's
allow-httpis gone. Every address of the themes (a theme'ssource, the sharedsource, the images) goes throughRemoteAddressPolicy: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, unlessspring.remote.allow-insecure=true, which logs a warning listing them. Images takegithub:owner/repo/path@refaddresses too. loaders.<name>.webtakes anhttps://orgithub:address as well as a path, andloaders.<name>.web-sha256pins 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, andshow(id)to scroll to one; a link to#idscrolls to its heading by itself.MarkdownView: GitHub's callouts (> [!NOTE],[!TIP],[!IMPORTANT],[!WARNING],[!CAUTION]) instyles.callout.<kind>, titled by the messagesmarkdown.alert.<kind>; a fenced block'stitle="..."as a header with a copy button (styles.code.header,styles.code.title); inline code instyles.code.inline-textandinline-background; links instyles.link.color.MarkdownView.resourceshows the app language's translation next to the file (beans.ja.md) and follows the language.ThemeTextandmotion.text-change(none,fade,morph, withduration,curveandstagger): a text that changes the theme's way when the same widget gets another text, the app's language switched say;morphchanges 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.oftakes aCodeSyntax,SpringThemeData.syntaxOffinds one by name or alias. Dart, Java, YAML, properties, shell and JSON are in farum-azula/themes (themes/code.yml). spring.flutter.theme.source(withsource-sha256andrefresh): 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:
FlutterWebPropertiesisspring.flutter.web.dev-server.*(the dev server offlutter runon the web:host,port,base-href,https.*,headers.*, the CSP keys,proxy[n].*); a key at its old place underspring.flutter.webfails 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.fromEnvironmentreads 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-transitionnot set isnone(it was Flutter's own per platform), for Material's page routes too; writemotion.page-transition: platformto get the platform's transition back. motion.page-transitiontakesfadeand a map form,{ type, duration, curve }(references such as$motion.durations.fastallowed);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 anHttpTransport(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 intoweb/index.htmland the web manifest (with the title, and the theme's colors).MarkdownView(MarkdownView.resourcefor 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 toonLink; code blocks colored byCodeTokens(Dart, YAML, properties, shell, JSON) with the theme'sstyles.code(background,text,keyword,string,comment,number,key,annotation,variable,type,punctuation; the color scheme otherwise; the block'spadding,radius,border,border-width).MarkdownView.codeshows one block of code the same way. Selectable in any app: Material'sSelectionAreaunder aMaterialApp, aSelectableRegionwithout a menu otherwise. New dependency: the Dart team'smarkdown.SpringAppwithout ahomebuildsMaterialApp.router(or the Cupertino or widgets one) on the application'sRouterConfig<Object>bean, the onespring_boot_starter_flutter_navigationadds or the app's own (SpringApp.routerOf);SpringApplicationWidgettakes neitherhomenorchildfor 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 itsrouteandbranchscopes.
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.*,typeis theAppTypeenum),FlutterLifecycleProperties,FlutterFontsProperties,DesktopWindowProperties,FlutterWebProperties(spring.flutter.web.*, with@Range(0, 65535)and the blocked ports as@WarnValuesonport; the generator still reads these keys from the configuration files),FlutterRestartProperties,FlutterSqliteProperties,FlutterDataSourcePropertiesandFlutterProperties(lib/src/properties/); the hand-writtenspring_metadata_additional.jsonis gone. The classes are bound by the Binder (@ComponentScanmoduleflutterConfigBeans, imported by the auto-configuration, so each is a bean too) and the starter reads nothing by key string any more: thebind(Environment)factories,FlutterSqliteProperties.locationOfandSqliteLocation.parseare gone. Keys and defaults are unchanged. A bad value now fails the start with the standardBinding to target properties under '...' failedreport (aConfigurationPropertiesBindException, not anArgumentError) 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 astrue.spring.flutter.scan-os-environmentin the--dart-definevalues is bound the same way. A named data source'surlis found by bindingspring.datasources.<name>.*. - Generated files live in
lib/spring_gen/: importpackage:app/spring_gen/main.spring.dart(wasmain.spring.dart); the auto-configuration importsspring_gen/spring_auto_configuration.spring.dart. - Themes without Dart (0.6.3): a design system in YAML under
spring.flutter.theme.- References:
$colors.primarynames another value of the same theme (a whole value, or an operand of a color object), resolved per theme afterextends.${...}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 havedefault), insets, andtransition: <duration> [<curve>]. NewThemeStateswidget (hover, focus, press, disabled, keyboard activation, cursor, blended values),ThemeStyle<V>andStateStyle.- Motion:
motion.durations.<name>andmotion.curves.<name>(a named curve or four numbers),Duration.zerowhen the system asks for less motion. The oldmotion.duration-<name>/motion.easing-<name>forms are gone (an unknownmotionkey fails the start).animations.<name>(duration,curve,repeat: none | loop | reverse),AnimationSpecand theThemeAnimationwidget. Style and animation names read in any spelling. background(color, image, overlay with a linear or radial gradient,animationandeffectdrift / zoom / pulse,transition,screens.<name>):SpringAppputs it under every screen and makes the Material scaffold and Cupertino page backgrounds transparent unless the theme sets them.ThemeBackground,ThemeBackground.screen(name)andThemeBackground.none.- Images from the network:
ThemeImage(source,refresh,source-sha256,headersas a map,timeout,fallback,allow-http) forbackground.image, the screens' backgrounds and image tokens (a token map withsource). Cached throughFileTemplate(support,spring/images/<sha256 of source and pin>/; IndexedDB on the web), read from the cache at once and re-read in the background withrefresh; the start never waits for the network.httpsunlessallow-http: true. A redirect to another origin (host, port or scheme: no https to http downgrade either) drops custom headers; headers and the image keyssource,fallbackandsource-sha256are never searched for references, so a$from a placeholder stays. A file that does not matchsource-sha256is 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 takems,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:
ThemeBackgroundkeeps 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 withrepeat: nonegoes to its end; a style that animates with an overshooting curve never gets negative insets. - Fix: a
CupertinoThemeDatamade fromtypographyorcupertino.text-themekept 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(seespring_core_dart_generator). ThemeStates(showFocusAlways: true):focusedshows 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, aColorsname, a$reference) or an object{ color, mix: { with, amount }, alpha }(mixfirst, thenalpha; a percent is0%..100%or0..1;coloris required; an unknown key fails with a "did you mean"). It works incolors.*,seed-color, tokens, styles (also per state), components (also per state),cupertino.*,backgroundand gradient colors. A token or style map with acoloris a color;colornext to a key other thanmixandalphais an error.ThemeProperties.color,colorListandThemeValues.percentread 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 kindsspinner,dots,pulse,barandskeleton,phases(animations or{progress: true}) and kinds of your own (@ThemeLoaderKind,ThemeLoaderPainter<P>,ThemeLoaderWidget<P>,LoaderFrame<P>, theThemeLoaderKindsregistry);ThemeLoader,ThemeSkeleton;splash(background, logo, title, loader, animation,min-duration,exit) shown bySpringApplicationWidgetfrom the moment the properties are read, following the start's progress (SpringApplication.progressListener), unless its ownsplash:builder is given;window.springLoaderHandOff(progress)is called on the web when the Flutter splash has painted.ThemeKeyReader.loaderandsplash;ThemeBackground.data. With less motion each phase is at its end and nothing shimmers. A plainsplash: rippleis still the ink effect. A progress phase takes amin-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.reveallets 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,hord, decimals allowed, in motion, animations, styles, tokens,transition,refreshandtimeout(the ISO-8601 form ofrefreshandtimeoutis gone). - Checks (0.6.3):
background.effectwithout ananimation, a radial gradient withend(it usesbeginas its center), and acontrastoutside -1 to 1 stop the start;ThemeBackground.screen('x')of a screen the theme does not have throws aFlutterErrorin 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 ignoresextendswith a warning, likeactiveandsource. - The type schema of the theme (
types.color,percent,duration, ...) is intool/theme_metadata.jsonfor the editor and the JSON Schema.
- References:
- Removed:
lib/spring_keys.dartis gone (importspring_gen/main.spring.dart);classpath:is gone (useresources:); the old motion formsmotion.duration-<name>andmotion.easing-<name>are gone (usemotion.durations.<name>andmotion.curves.<name>); the one-line color forms (<color> alpha 12%,<color> mix <color> 14%, chains,role@38%, bare role names such asprimaryin components,0xcolors) are gone (use a color object or$colors.primary);SpringThemeData.duration(name)is gone (usecontext.theme.motionortokenDuration); theheaders: ['Name: value']list form of a theme image is gone (use a map). - The theme section of
spring_metadata.jsonlists every key ofspring.flutter.theme, not only the components (active,extends,colors.<role>,typography.<style>.<key>,shape.*,motion.*,animations.*,background.*,styles.*,tokens.*,cupertino.*), withscope(root/theme) andopen.tool/theme_metadata.jsonhas them asproperties.
0.6.2 #
Changes #
- Files of the app (0.6.2):
FileTemplate(beansfileTemplateandplatformFileStore, each only when the app declares none) writes and reads text, bytes and objects (JSON through theObjectMapper) in the placessupport(default),cacheanddocuments(files.cache.write(...)), withexists,delete,list(prefix)andmodifiedAt. Writes are atomic (temporary file, then rename), paths stay inside their place (..and absolute paths are refused).temp((file) async {...})andtempDir(...)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 replaceableFileStore(LocalFileStoreonpath_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
locationandFileTemplate's places share one mapping. On Windowssupportis%LOCALAPPDATA%\<company>\<product>(the machine's own) for both, andcacheis thecachefolder inside it (path_provider's cache directory is the local root itself, so it would have been the same folder assupport); the other platforms are unchanged. - The theme from a URL (0.6.2):
spring.flutter.theme.themes.<name>.source(anhttpsURL orgithub:owner/repo/path@ref),source-sha256andrefresh. The theme is cached throughFileTemplate(support,spring/themes/<sha256 of source and pin>/theme.ymlandmeta.json) and survives restarts: withoutrefreshdownloaded once and read from the cache for ever; withrefreshthe 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. Anothersourceorsource-sha256downloads 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,httpsonly (redirects too). Only the theme's keys are taken from the file, the rest is ignored with a warning.SpringThemes.applySourcesets the properties of one such theme. The HTTP client is the app'sHttpTransportbean orspring_web_dart's platform client: the package depends onspring_web_dartnow. - The whole theme (0.6.2):
spring.flutter.theme.components.*sets every component theme ofThemeData(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.*setsCupertinoThemeData(primary and contrasting colors, backgrounds, handles,text-theme.*). EveryWidgetStatePropertytakes 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: whenbuttonand a button kind (filled-button, ...) set the same property, the kind's value now wins (it was the shared one). The component reference ofdocs/configuration.mdis generated from the mapping and a test keeps it in step. ThemeKeyReader(context.themeof the generatedlib/spring_keys.dart): the typed theme keys read the theme shown now throughSpringTheme.of(context). Seespring_core_dart_generator.- The theme files and the property-file lookup use
resources:(resources:themes/*.yml);classpath:still works with a warning (seespring_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-sizeandmax-size(1280x800, logical pixels; min <= initial <= max, else the start stops naming the values;max-sizeis macOScontentMaxSize, WindowsptMaxTrackSizeand GTKGDK_HINT_MAX_SIZE).SpringApplicationWidgetreads 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/DesktopWindowInsetsgive the space the window buttons take,WindowDragAreamoves 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, orspring.datasources.<name>.url),SpringApplicationWidgetreads the app's directories frompath_providerbefore the application starts and, once the configuration files are read, setsspring.datasource.sqlite.base-directoryto the directory ofspring.datasource.sqlite.location(support, the default;cache;documents; any other value stops the start) andspring.datasource.sqlite.isolate=true, with the lowest precedence (the app's own properties win), for the primary data source and each named one.supportis Android'sdatabases/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 (nopath_providerplugin). The starter depends onpath_provider(flutter.dev) and its platform interface, and only sets properties: it does not depend on the data starter. BeanReadsPointcut.annotationTypesandNotifyListenersPointcut.annotationTypeslist 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.dartfiles).
0.5.0 #
Changes #
SpringApplicationWidgetcloses 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
@ChangeNotifierComponentcounter and Spring widgets. spring_auto_configuration.dartre-exports the logging starter's (and through itspring_boot_dart's) auto-configuration, so a test namingspringBootAutoConfiguration(ApplicationContextRunner) needs no other dependency.
0.3.0 #
- Reading is free: a
SpringStatelessWidgetorSpringStatelistens to a@ChangeNotifierComponentor@NotifyListenersbean of its record only when itsbuildread 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, aBuilderbelow it, a callback) keeps it listening; aChangeNotifierbean without either annotation is listened to always, as before. - The
flutter_counterexample uses Spring widgets for every widget that takes beans (CounterPage,AboutPage). - Breaking:
spring.flutter.app.theme-modeis gone (the theme shown isspring.flutter.theme.active), and so areFlutterAppSettings.themeMode,color,theme,darkThemeandcupertinoTheme(the theme comes fromSpringThemes;ThemeDatabeanstheme/darkThemeand aCupertinoThemeDatabean still replace the made ones). - Themes from properties (
spring.flutter.theme.*): a shared part, the standardlight/darkthemes and named custom ones (themes.<name>,extends), the fullColorScheme(seed, variant, contrast, any role), the 15TextThemestyles pluscode, 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 aSpringThemeData, a MaterialThemeDataand aCupertinoThemeData.ThemeSelection(active,system-light,system-dark,select) switches at run time;SpringThemes.loadYamladds themes from a server;SpringTheme.of(context)for the app's own widgets;ThemeCustomizer/CupertinoThemeCustomizerbeans;ThemeDatabeanstheme/darkThemestill replace the made ones. Replacesspring.flutter.app.theme-mode(nowspring.flutter.theme.active). - Fonts from the assets: every
.ttf/.otfunderflutter: 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(widgetsby default,material,cupertino),title,debug-banner,theme-mode,locales(by default the languages of the messages files), theThemeDatabeanstheme/darkThemeand aCupertinoThemeDatabean,NavigatorObserverbeans,FlutterAppCustomizerbeans; Flutter's localization delegates come with the starter (flutter_localizations).child:keeps working for an app's ownMaterialApp.- An example (
example/): the counter app in one runnable file, and the way with the generator step by step.
0.2.2 #
- Breaking:
SpringStatelessWidget.buildtakes only theBuildContext; the widget reads its beans asbeans, like aSpringState(inbuildand the callbacks made there). Tests build it with fakes throughbuildWith(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 withspring.devtools.restart.enabled=false, closes the context when removed),SpringScope,context.bean<T>(), getters generated for@BuildContextAccessbeans,SpringStatelessWidget<(...)>andSpringStatefulWidget<(...)>withSpringState<W, (...)>, beans checked at startup,AppLifecycleStateEventwith 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 unlessspring.flutter.scan-os-environment,context.messagein the app's locale. @ChangeNotifierComponent(exclude: [...]): a stereotype for a plain class whose proxy mixesChangeNotifierin and notifies after every public method and setter;listenableOf(bean).SpringStatelessWidgetandSpringStaterebuild when aListenablebean of their record notifies.@NotifyListeners(exclude: [...])on aChangeNotifierbean (or some of its methods):notifyListeners()after each call through the AOP proxy, after a returnedFuturecompletes, also after an error.asset:resources:@Value('asset:assets/intro.mp4') Resource videoinjects anAssetResourceof the app's asset bundle (keyfor Flutter's APIs,exists()from the asset manifest), likeclasspath:forlib/resources/.- Brings
spring_boot_starter_logging, switched on (console output in Boot's format,logging.*,LogBuffer). - Exports
spring_core_dart,spring_boot_dartandspring_boot_starter_logging(withoutBannerandSize, which clash with Flutter's; the constraint isSizeConstraint), so an app depends only onspring_boot_starter_flutter.