FlexColorScheme.light constructor

FlexColorScheme.light(
  1. {FlexSchemeColor? colors,
  2. FlexScheme? scheme,
  3. ColorScheme? colorScheme,
  4. int usedColors = 6,
  5. FlexSurfaceMode? surfaceMode,
  6. int blendLevel = 0,
  7. FlexAppBarStyle? appBarStyle,
  8. double? appBarOpacity,
  9. bool transparentStatusBar = true,
  10. double? appBarElevation,
  11. double? bottomAppBarElevation,
  12. FlexTabBarStyle? tabBarStyle,
  13. Color? primary,
  14. Color? primaryContainer,
  15. Color? secondary,
  16. Color? secondaryContainer,
  17. Color? tertiary,
  18. Color? tertiaryContainer,
  19. Color? error,
  20. Color? surface,
  21. Color? background,
  22. Color? scaffoldBackground,
  23. Color? dialogBackground,
  24. Color? appBarBackground,
  25. Color? onPrimary,
  26. Color? onPrimaryContainer,
  27. Color? onSecondary,
  28. Color? onSecondaryContainer,
  29. Color? onTertiary,
  30. Color? onTertiaryContainer,
  31. Color? onSurface,
  32. Color? onBackground,
  33. Color? onError,
  34. Color? surfaceTint,
  35. bool lightIsWhite = false,
  36. bool swapColors = false,
  37. bool tooltipsMatchBackground = false,
  38. FlexSubThemesData? subThemesData,
  39. FlexKeyColors? keyColors,
  40. bool useMaterial3ErrorColors = false,
  41. FlexTones? tones,
  42. VisualDensity? visualDensity,
  43. TextTheme? textTheme,
  44. TextTheme? primaryTextTheme,
  45. String? fontFamily,
  46. List<String>? fontFamilyFallback,
  47. String? package,
  48. MaterialTapTargetSize? materialTapTargetSize,
  49. PageTransitionsTheme? pageTransitionsTheme,
  50. InteractiveInkFeatureFactory? splashFactory,
  51. TargetPlatform? platform,
  52. Typography? typography,
  53. bool applyElevationOverlayColor = true,
  54. bool useMaterial3 = false,
  55. bool swapLegacyOnMaterial3 = false,
  56. Iterable<ThemeExtension>? extensions}
)

Creates a FlexColorScheme for light theme mode.

The factory has no required FlexSchemeColor properties, but typically a FlexScheme enum scheme value would be provided to use a pre-defined color scheme.

As a second alternative the FlexSchemeColor class colors property can be used to define custom scheme colors, that can be created with just one color property by using the factory FlexSchemeColor.from.

As a third option you can provide a complete ColorScheme in colorScheme and the custom colors for the theme will be based on that scheme. Since this is the light theme factory the brightness value in used colorScheme is ignored and resulting effective theme and color scheme will always be light. Make sure you use colors in your color scheme that are actually colors for a light theme.

The factory can produce blended surface colors, and also has other parameters that may impact the effective color scheme used by final theme, even when a colorScheme are provided. The FlexColorScheme.toScheme will give you the effective color scheme that will also be used when producing ThemeData from FlexColorScheme and its factories with FlexColorScheme.toTheme.

The factory contains a large number of other properties that can be used to create beautiful themes by just adjusting a few behavior properties.

To activate using opinionated sub themes that further refines the produced theme, pass in a default FlexSubThemesData to subThemesData, or use short cut properties to setup additional features in the sub-themes.

Material 3 guide introduces a new color system with key colors and tonal palettes, see https://m3.material.io/styles/color/the-color-system/key-colors-tones.

You can opt-in on using this new M3 color system by creating your tonal theme colors using the effective primary, secondary and tertiary colors in the factory, as key colors to create tonal palettes for these main Material 3 color palettes. Colors from these key color seed generated palettes will then be used as color tones for the produce ColorScheme, as defined by the Material 3 design guide. By studying the Flutter SDK ColorScheme.from factory you can see which color tone from what key color is used where. FlexColorScheme uses the same assignments for the tones to the generated ColorScheme when you opt in using Material 3 tonal palettes.

The FlexColorScheme light and dark factory offer more control over the seed generation setup. With ColorScheme.fromSeed you can only generate the ColorScheme from one key color, the primary color. With FlexColorScheme factories you can use separate key colors for secondary and tertiary from the primary color, to make their tonal palettes. The effective colors in your FlexColorScheme for these color properties are used as key color inputs when you provide a FlexKeyColors via keyColors and enable it by setting FlexKeyColors.useKeyColors to true, which it is in its default constructor, so to enable it you can just pass in a default FlexKeyColors() to keyColors.

By setting FlexKeyColors.useSecondary or FlexKeyColors.useTertiary to false, the corresponding effective colors in FlexColorScheme will not be used as keys for corresponding TonalPalette. If one is off, its tonal palette will instead be based on the primary color as key. If both are false, the FlexColorScheme.light seeding algorithm becomes the same as using ColorScheme.from. The primary color is always used as seed color when key color seeding is enabled with FlexKeyColors.useKeyColors set to true.

You can also opt to keep selected effective main colors, primary, secondary, tertiary and their containers, in your FlexColorScheme as their effective color, even when you enable key color based seeded tonal palette based ColorScheme output. You do this by setting FlexKeyColors.keepPrimary, FlexKeyColors.keepSecondary etc to true, for each color property where you want to keep its exact color value as defined, but otherwise may be OK with using key seeded color values.

You can use this feature if you for example want to use an exact predefined primary brand color in light mode, but are OK with all other colors using tones derived from its Material 3 tonal palette.

When you use key color based seeded theme generation, the used key inputs for primary, secondary and tertiary are only used to set and generate the tone of the palette used for each colors tonal palette. You will rarely see the same color on that actual, primary, secondary and tertiary color in the produced ColorScheme, unless you lock them down with the "keep" properties.

The same tonal palette should typically be used for both light and dark mode colors. Under the hood FlexColorScheme selects the right color tone from the tonal palette, which is different for light and dark mode. For a matched light and dark theme, you should use the same input key color. When you use FlexColorScheme.light and FlexColorScheme.dark and the FlexScheme enum based scheme property, to use a built-in color scheme, it automatically uses also its predefined light theme mode defined colors as the key colors for primary, secondary and tertiary in dark mode, to ensure that the produced ColorScheme is using same tonal palette, but only different tones from it for light and dark mode.

When you use colors, colorScheme or direct override color properties primary, secondary or tertiary in the factories, these effective colors are used directly as key color inputs. It is then up to you to decide and design if you use the same key color for tonal palette generation in light and dark mode.

If you use colorScheme or pass in primary, secondary or tertiary, and enable using keyColors the generated scheme will first use color from passed in direct color properties primary, secondary or tertiary, as key colors, then the same ones from the passed in colorScheme when it generates the output ColorScheme using the active FlexKeyColors setup.

The generated ColorScheme's properties will override all color properties that were passed in via a colorScheme, except those locked via the keep properties in FlexKeyColors.

If you assign override colors via direct color properties for the main colors primary, secondary or tertiary and their containers, they will also only override the generated resulting ColorScheme if the the keep properties are set in FlexKeyColors. Other color properties that exist as both direct color properties and as a color in the generated resulting ColorScheme, will be overridden by the generated colors scheme colors.

Normally if you provide an entire colorScheme to FlexColorScheme it is typically because you already have a scheme that you want to use as is, then don't enable keyColors or any blends. It is however possible to apply both blends to passed in colorScheme surfaces or to just use the primary, secondary or tertiary colors in passed in colorScheme as keyColors to generate an entirely new ColorScheme from the passed in colors, using primary, secondary or tertiary as keys.

Implementation

factory FlexColorScheme.light({
  /// The [FlexSchemeColor] that will be used to create the light
  /// [FlexColorScheme].
  ///
  /// You can use predefined [FlexSchemeColor] values from [FlexColor] or
  /// [FlexColor.schemes] map or define your own colors with
  /// [FlexSchemeColor] or [FlexSchemeColor.from].
  ///
  /// For using built-in color schemes, the convenience shortcut to select
  /// it with the [scheme] property is recommended and leaving [colors]
  /// undefined. If both are specified the scheme colors defined by [colors]
  /// are used. If both are null then [scheme] defaults to
  /// [FlexScheme.material], thus defining the resulting scheme.
  final FlexSchemeColor? colors,

  /// Use one of the built-in color schemes defined by enum [FlexScheme].
  ///
  /// Give it one of the enum values to use the scheme, like eg.
  /// [FlexScheme.mandyRed].
  ///
  /// To create custom color schemes use the [colors] property. If both
  /// [colors] and [scheme] are specified, the scheme defined by
  /// [colors] is used. If both are null, then [scheme] defaults to
  /// [FlexScheme.material].
  final FlexScheme? scheme,

  /// The overall [ColorScheme] based colors for the theme.
  ///
  /// This property provides a new way to define custom colors for
  /// [FlexColorScheme] and is available from version 4.2.0. It is useful if
  /// you already have a custom [ColorScheme] based color definition that
  /// you want to use with FlexColorScheme theming and its sub-theming
  /// capabilities.
  ///
  /// If you provide both a [ColorScheme] and some individual direct property
  /// values that also exist in a [ColorScheme], the individual property
  /// values will override the corresponding ones in your [ColorScheme].
  ///
  /// If you do not define a [colorScheme], the used colors will be determined
  /// by the [colors] and [scheme] properties. However, when a [colorScheme]
  /// is defined it takes precedence. The [brightness] in the provided
  /// [colorScheme] is always ignored and set to [Brightness.light] since this
  /// is the light theme mode factory. Make sure the colors used in your color
  /// scheme are intended for a light theme.
  ///
  /// If you define a [surfaceMode] and set [blendLevel] > 0, then [surface],
  /// [surfaceVariant], [background] and [inverseSurface] colors in the
  /// provided [colorScheme] will be overridden by the computed color branded
  /// surfaces. If your [colorScheme] already contains branded surface colors,
  /// then keep [blendLevel] = 0 to continue using them.
  ///
  /// If you use [lightIsWhite] factory feature, it will also override your
  /// [colorScheme] based mentioned color properties above and make them
  /// 5% lighter.
  ///
  /// If you opt in on using sub themes and have set
  /// [subThemesData.blendOnColors] to true and have defined [surfaceMode]
  /// and set [blendLevel] > 0, then the effective color scheme based on
  /// colors onPrimary, onSecondary, onError, onSurface and onBackground will
  /// be changed accordingly too.
  ///
  /// The [colorScheme] colors are also included and affected by factory
  /// properties [usedColors] and [swapColors] and included in their behavior.
  ///
  /// The [FlexColorScheme]'s effective [ColorScheme] can be returned with
  /// [toScheme]. This will always get you a complete color scheme, including
  /// calculated and derived color values, which is particularly useful when
  /// using the [FlexColorScheme.light] and [FlexColorScheme.dark] factories
  /// to compute color scheme branded surface colors for you. The effective
  /// [ColorScheme] for your theme is often needed if you want to create
  /// custom sub-themes that should use the colors from the scheme using none
  /// default color assignments from the color scheme.
  final ColorScheme? colorScheme,

  /// The selection of the six main scheme colors to be used when creating
  /// effective [ColorScheme].
  ///
  /// This is a convenience property that allows you to vary which colors to
  /// use of the primary, secondary and tertiary colors and their container
  /// colors when FlexSchemeColor creates its effective [ColorScheme] from
  /// the input colors. The integer number corresponds to using:
  ///
  /// * 1 = Only the primary color
  /// * 2 = Primary & Secondary colors
  /// * 3 = Primary + container & Secondary colors
  /// * 4 = Primary + container & Secondary + container
  /// * 5 = Primary + container & Secondary + container & tertiary colors
  /// * 6 = Primary + container & Secondary + container & tertiary + container
  /// * 7 = Primary, Secondary and tertiary, container colors computed.
  ///
  /// By default the value is 6 and all main scheme colors in
  /// `FlexSchemeColor` are used.
  ///
  /// The integer value is not a very obvious property to use to configure
  /// this feature. Future version may improve it. However, with the Themes
  /// Playground you don't have to remember what number does what.
  ///
  /// When the value is 1, the result is the same as if we would have
  /// created the colors with [FlexSchemeColor.from] by only giving it the
  /// required primary color. With 2, it is equivalent to as if we would have
  /// given it only the primary and secondary colors, and so on.
  /// This property makes it possible to simulate and change the resulting
  /// [FlexColorScheme] to as if you would have specified 1, 2, 3 ... 7 of
  /// the color selection. If your used [FlexColorScheme] `colors` was
  /// actually created with [FlexSchemeColor.from] with only the primary
  /// color defined, then changing the value from 7 ... 3, 2 or 1, will
  /// all produce the same effective scheme as the computed values will be
  /// the same as the [FlexSchemeColor.from] is using to compute any main
  /// missing scheme color values.
  final int usedColors = 6,

  /// Blends theme colors into surfaces and backgrounds.
  ///
  /// If defined, used mode overrides the older [surfaceStyle]
  /// property setting. Prefer using [surfaceMode] over [surfaceStyle],
  /// it offers more color branded surface modes and separate control over
  /// the used branding level via the separate [blendLevel] property.
  ///
  /// The mode [FlexSurfaceMode.highBackgroundLowScaffold] can be used to
  /// replace the style that was produced when using old and removed
  /// `FlexColorScheme.surfaceStyle` enum property `FlexSurface` in
  /// [FlexColorScheme.light] and [FlexColorScheme.dark] before version 4.
  ///
  /// The mode [FlexSurfaceMode.highBackgroundLowScaffold] uses the same
  /// design concept as the only style offered via removed `FlexSurface`
  /// in `FlexColorScheme.surfaceStyle` that was in use before version 4,
  /// and deprecated in version 4.2 and removed in version 5.0.0.
  ///
  /// By adjusting the [FlexColorScheme.blendLevel] property and using this
  /// style, you can find a similar visual effect when using
  /// [FlexSurfaceMode.highBackgroundLowScaffold] with the following values
  /// when matching match most prominent blended [ColorScheme.background]
  /// color.
  ///
  /// In light theme mode:
  ///
  /// * [FlexSurface.material] 0% : blendLevel = 0
  /// * [FlexSurface.light]    2% : blendLevel = 3...4
  /// * [FlexSurface.medium]   4% : blendLevel = 7
  /// * [FlexSurface.strong]   6% : blendLevel = 10
  /// * [FlexSurface.heavy]    8% : blendLevel = 13...14
  ///
  /// In dark theme mode:
  ///
  /// * [FlexSurface.material] 0% : blendLevel = 0
  /// * [FlexSurface.light]    5% : blendLevel = 8
  /// * [FlexSurface.medium]   8% : blendLevel = 13...14
  /// * [FlexSurface.strong]  11% : blendLevel = 19
  /// * [FlexSurface.heavy]   14% : blendLevel = 23
  ///
  /// Since there it is not the same relationship between background and
  /// surface, when using the older [FlexSurface] based style, that uses
  /// individually tuned relationships. The old and new designs do never
  /// align exactly at any blendLevel. The above values produce visually
  /// similar results for the most prominent background color blend.
  ///
  /// To get elevation overlay color in dark themes on all surfaces used by
  /// [Material], use one of the modes where background and dialog color
  /// equals the blend strength on surface color, like [level],
  /// [levelSurfacesLowScaffold], [highScaffoldLowSurfaces] and
  /// [highScaffoldLowSurfaces]. Other modes will only use
  /// elevation overlay if their background happens to be equal to resulting
  /// colorScheme.surface color. For more information
  /// see issue: https://github.com/flutter/flutter/issues/90353
  ///
  /// When using very strong surface branding in dark mode, having an overlay
  /// elevation color in dark mode is less critical, since the elevation
  /// becomes partially visible via shadows and the surface may even have
  /// another color tint if using e.g. [levelSurfacesLowScaffoldVariantDialog]
  /// or [highScaffoldLowSurfacesVariantDialog].
  ///
  /// If values for the properties [surface], [background],
  /// [dialogBackground] or [scaffoldBackground] are given,
  /// they are used instead of values that would be assigned based
  /// on used [FlexSurfaceMode] via [surfaceMode] or [FlexSurface] in
  /// this [surfaceMode].
  ///
  /// Defaults to using [FlexSurfaceMode.highScaffoldLowSurfaces] when
  /// [blendLevel] > 0.
  final FlexSurfaceMode? surfaceMode,

  /// Sets the blend level strength used by the surface mode.
  ///
  /// The blend level is the integer decimal value of the alpha value
  /// used in the alpha blend function. It mixes one color with another
  /// by using alpha opacity value in the color of a surface put on top of
  /// another surface with opaque color and returns the result as one opaque
  /// color.
  ///
  /// Defaults to 0.
  final int blendLevel = 0,

  /// Style used to define the themed color of the AppBar background color.
  ///
  /// Defaults to null, which when [useMaterial3] is false results in
  /// [FlexAppBarStyle.primary] which produces the same results
  /// as a Flutter standard M2 light [ThemeData.from] by tying the app bar
  /// color to the primary color. If [useMaterial3] is true it defaults
  /// [FlexAppBarStyle.surface] which is the same as M3 default.
  final FlexAppBarStyle? appBarStyle,

  /// Themed [AppBar] opacity.
  ///
  /// The opacity is applied to the effective AppBar color, which may be from
  /// used [appBarStyle], that gets its color selection from used [scheme]
  /// or [colors]. Or that color may have been overridden by AppBar sub-theme
  /// and there selected [SchemeColor] based color.
  /// Lastly and with highest priority it may be from here directly supplied
  /// [appBarBackground] color.
  ///
  /// A useful opacity range is from 0.85 to 0.95 when using the [Scaffold]
  /// property [extendBodyBehindAppBar] set to true, to partially show
  /// scrolling content behind the app bar. To use more opacity, in a way
  /// that the AppBar does not become too transparent, you also need to blur
  /// the background to create a frosted glass effect. This cannot
  /// be made with only theming, you need a custom AppBar Widget for that.
  /// Frosted glass UI effect is thus beyond the scope of what
  /// FlexColorScheme can do alone as it only affects ThemeData.
  ///
  /// If null, defaults to 1, fully opaque, no transparency.
  /// If not null, must be from 0 to 1.
  final double? appBarOpacity,

  /// When set to `true`, it makes the status bar on Android the same color as
  /// the rest of the AppBar.
  ///
  /// Defaults to true.
  ///
  /// When true, the AppBar in Android mimics the look of one-toned AppBar's
  /// typically used on iOS. Set to `false`, to revert back and use
  /// Android's default two-toned look. If true the status bar area is
  /// actually also transparent so that if the app bar is also translucent,
  /// content that scrolls behind it, is also visible behind the status
  /// bar area.
  ///
  /// In standard Material 2 this would be false, FCS uses an opinionated
  /// style and sets it true. In Material 3 the style you get when setting
  /// this to true is used by default. In M3 mode FCS will thus not create
  /// an AppBar sub theme to adjust this,if it is true and it is not needed
  /// for any other direct AppBar impacting properties in FlexColorScheme
  /// constructor. In M2 mode an AppBar theme will always be created, also
  /// when not opting in on the actual sub-themes feature, this per its
  /// opinionated and legacy styling for M2 mode.
  final bool transparentStatusBar = true,

  /// The themed elevation for the [AppBar].
  ///
  /// If not defined, defaults to 0 in M2 (FCS opinionated) and to 0 in (M3
  /// spec default).
  ///
  /// The FCS 0dp elevation in M2 is an iOS style influenced opinionated
  /// choice, it can easily be adjusted for the theme with this property.
  final double? appBarElevation,

  /// The themed elevation for the [BottomAppBar].
  ///
  /// If undefined (null), defaults to 3 in M3 mode and to 8 in M2 mode,
  /// both via the defaults for the respective theme mode from Flutter's
  /// default elevation behavior of [BottomAppBar].
  final double? bottomAppBarElevation,

  /// Select preferred style for the default [TabBarTheme].
  ///
  /// By default the TabBarTheme is made to fit with the style of the AppBar.
  /// In M2 mode that is done by defaulting to using
  /// [FlexTabBarStyle.forAppBar] if not defined. In M3 mode it done by
  /// defaulting to using [FlexTabBarStyle.flutterDefault].
  ///
  /// When setting this to [FlexTabBarStyle.forBackground], it will default
  /// to a theme that uses the color scheme and fits on background color,
  /// which typically also on works surface and scaffoldBackground color.
  /// This TabBarTheme style is useful if you primarily intended to use the
  /// TabBar in a Scaffold, Dialog, Drawer or Side panel on their background
  /// colors.
  final FlexTabBarStyle? tabBarStyle,

  /// The color displayed most frequently across your app’s screens and
  /// components.
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] or for this color defined when using a
  /// pre-defined color scheme based on [FlexScheme] [scheme] property, or
  /// if a [colorScheme] was provided it will override the same color in it
  /// as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  ///
  /// This override color is included and affected by factory
  /// properties [usedColors] and [swapColors] and included in their behavior.
  ///
  /// Defaults to null.
  final Color? primary,

  /// A color used for elements needing less emphasis than [primary].
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] or for this color defined when using a
  /// pre-defined color scheme based on [FlexScheme] [scheme] property, or
  /// if a [colorScheme] was provided it will override the same color in it
  /// as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  ///
  /// The override color is included and affected by factory
  /// properties [usedColors] and [swapColors] and included in their behavior.
  ///
  /// Defaults to null.
  final Color? primaryContainer,

  /// An accent color that, when used sparingly, calls attention to parts
  /// of your app.
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] or for this color defined when using a
  /// pre-defined color scheme based on [FlexScheme] [scheme] property, or
  /// if a [colorScheme] was provided it will override the same color in it
  /// as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  ///
  /// The override color is included and affected by factory properties
  /// [usedColors] and [swapColors] and included in their behavior.
  ///
  /// Defaults to null.
  final Color? secondary,

  /// A color used for elements needing less emphasis than [secondary].
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] or for this color defined when using a
  /// pre-defined color scheme based on [FlexScheme] [scheme] property, or
  /// if a [colorScheme] was provided it will override the same color in it
  /// as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  ///
  /// The override color is included and affected by factory properties
  /// [usedColors] and [swapColors] and included in their behavior.
  ///
  /// Defaults to null.
  final Color? secondaryContainer,

  /// A color used as a contrasting accent that can balance [primary]
  /// and [secondary] colors or bring heightened attention to an element,
  /// such as an input field.
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] or for this color defined when using a
  /// pre-defined color scheme based on [FlexScheme] [scheme] property, or
  /// if a [colorScheme] was provided it will override the same color in it
  /// as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  ///
  /// The override color is included and affected by factory properties
  /// [usedColors] and [swapColors] and included in their behavior.
  ///
  /// Defaults to null.
  final Color? tertiary,

  /// A color used for elements needing less emphasis than [tertiary].
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] or for this color defined when using a
  /// pre-defined color scheme based on [FlexScheme] [scheme] property, or
  /// if a [colorScheme] was provided it will override the same color in it
  /// as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  ///
  /// The override color is included and affected by factory properties
  /// [usedColors] and [swapColors] and included in their behavior.
  ///
  /// Defaults to null.
  final Color? tertiaryContainer,

  /// The color to use for input validation errors, e.g. for
  /// [InputDecoration.errorText].
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] or for this color defined when using a
  /// pre-defined color scheme based on [FlexScheme] [scheme] property, or
  /// if a [colorScheme] was provided it will override the same color in it
  /// as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? error,

  /// The surface (background) color for widgets like [Card] and
  /// [BottomAppBar].
  ///
  /// The color is applied to [ThemeData.cardColor] and
  /// [ColorScheme.surface] in [ThemeData.colorScheme], it is also used
  /// by all [Material] of type [MaterialType.card].
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on mode defined by property
  /// [surfaceMode] [FlexSurfaceMode] enum or [surfaceStyle] enum
  /// [FlexSurface], or if a [colorScheme] was provided it will override the
  /// same color in it as well.
  ///
  /// Defaults to null.
  final Color? surface,

  /// A color that typically appears behind scrollable content.
  ///
  /// The color is applied to [ThemeData.canvasColor] and
  /// [ThemeData.backgroundColor], it is used eg by menu [Drawer] and by all
  /// [Material] of type [MaterialType.canvas].
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on mode defined by property
  /// [surfaceMode] [FlexSurfaceMode] enum or [surfaceStyle] enum
  /// [FlexSurface], or if a [colorScheme] was provided it will override the
  /// same color in it as well.
  ///
  /// Defaults to null.
  final Color? background,

  /// The color of the [Scaffold] background.
  ///
  /// The color is applied to [ThemeData.scaffoldBackgroundColor].
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on mode defined by property
  /// [surfaceMode] [FlexSurfaceMode] enum or [surfaceStyle] enum
  /// [FlexSurface].
  ///
  /// Defaults to null.
  final Color? scaffoldBackground,

  /// The background color of [Dialog] elements.
  ///
  /// The color is applied to [ThemeData.dialogBackgroundColor]. It cannot be
  /// controlled separately with only a [ThemeData.from] a color scheme.
  ///
  /// When using sub-themes, it is also applied to backgroundColor in
  /// dialog themes, but only if [subThemesData.dialogBackgroundSchemeColor]
  /// has not be defined in [subThemesData].
  ///
  /// * DatePickerThemeData
  /// * DialogTheme
  /// * TimePickerThemeData
  ///
  /// If no value is given, and no [subThemesData.dialogBackgroundSchemeColor]
  /// is defined, default color is [surface].
  final Color? dialogBackground,

  /// Background theme color for the [AppBar].
  ///
  /// When using the factory this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] or for this color defined when using a
  /// pre-defined color scheme based on [FlexScheme] `scheme` property and
  /// the [FlexAppBarStyle] [appBarStyle] property.
  ///
  /// Thus custom color will also override any scheme color based selection
  /// for the [AppBAr] in active used sub-themes.
  final Color? appBarBackground,

  /// A color that is clearly legible when drawn on [primary] color.
  ///
  /// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
  /// [primary] and [onPrimary] is recommended. See
  /// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
  ///
  /// When using this factory, this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] property or when using pre-defined color
  /// scheme based [FlexScheme] and its [scheme] property, including any
  /// used blend logic. If a [colorScheme] was provided with this
  /// corresponding color defined, this color property will override the
  /// same color in it as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? onPrimary,

  /// A color that's clearly legible when drawn on [primaryContainer].
  ///
  /// To ensure that an app is accessible, a contrast ratio between
  /// [primaryContainer] and [onPrimaryContainer] of at least 4.5:1
  /// is recommended. See
  /// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
  ///
  /// When using this factory, this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] property or when using pre-defined color
  /// scheme based [FlexScheme] and its [scheme] property, including any
  /// used blend logic. If a [colorScheme] was provided with this
  /// corresponding color defined, this color property will override the
  /// same color in it as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? onPrimaryContainer,

  /// A color that is clearly legible when drawn on [secondary] color.
  ///
  /// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
  /// [secondary] and [onSecondary] is recommended. See
  /// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
  ///
  /// When using this factory, this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] property or when using pre-defined color
  /// scheme based [FlexScheme] and its [scheme] property, including any
  /// used blend logic. If a [colorScheme] was provided with this
  /// corresponding color defined, this color property will override the
  /// same color in it as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? onSecondary,

  /// A color that's clearly legible when drawn on [secondaryContainer].
  ///
  /// To ensure that an app is accessible, a contrast ratio between
  /// [secondaryContainer] and [onSecondaryContainer] of at least 4.5:1
  /// is recommended. See
  /// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
  ///
  /// When using this factory, this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] property or when using pre-defined color
  /// scheme based [FlexScheme] and its [scheme] property, including any
  /// used blend logic. If a [colorScheme] was provided with this
  /// corresponding color defined, this color property will override the
  /// same color in it as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? onSecondaryContainer,

  /// A color that's clearly legible when drawn on [tertiary].
  ///
  /// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
  /// [secondary] and [onSecondary] is recommended. See
  /// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
  ///
  /// When using this factory, this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] property or when using pre-defined color
  /// scheme based [FlexScheme] and its [scheme] property, including any
  /// used blend logic. If a [colorScheme] was provided with this
  /// corresponding color defined, this color property will override the
  /// same color in it as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? onTertiary,

  /// A color that's clearly legible when drawn on [tertiaryContainer].
  ///
  /// To ensure that an app is accessible, a contrast ratio between
  /// [secondaryContainer] and [onSecondaryContainer] of at least 4.5:1
  /// is recommended. See
  /// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
  ///
  /// When using this factory, this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] property or when using pre-defined color
  /// scheme based [FlexScheme] and its [scheme] property, including any
  /// used blend logic. If a [colorScheme] was provided with this
  /// corresponding color defined, this color property will override the
  /// same color in it as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? onTertiaryContainer,

  /// A color that is clearly legible when drawn on [surface] color.
  ///
  /// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
  /// [surface] and [onSurface] is recommended. See
  /// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
  ///
  /// When using this factory, this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] property or when using pre-defined color
  /// scheme based [FlexScheme] and its [scheme] property, including any
  /// used blend logic. If a [colorScheme] was provided with this
  /// corresponding color defined, this color property will override the
  /// same color in it as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? onSurface,

  /// A color that is clearly legible when drawn on [background] color.
  ///
  /// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
  /// [background] and [onBackground] is recommended. See
  /// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
  ///
  /// When using this factory, this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] property or when using pre-defined color
  /// scheme based [FlexScheme] and its [scheme] property, including any
  /// used blend logic. If a [colorScheme] was provided with this
  /// corresponding color defined, this color property will override the
  /// same color in it as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? onBackground,

  /// A color that is clearly legible when drawn on [error] color.
  ///
  /// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
  /// [error] and [onError] is recommended. See
  /// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
  ///
  /// When using this factory, this is an override color for the color that
  /// would be used based on the corresponding color property defined in
  /// [FlexSchemeColor] [colors] property or when using pre-defined color
  /// scheme based [FlexScheme] and its [scheme] property, including any
  /// used blend logic. If a [colorScheme] was provided with this
  /// corresponding color defined, this color property will override the
  /// same color in it as well.
  ///
  /// You can use this property for convenience if you want to override the
  /// color that this scheme color gets via the factory behavior.
  final Color? onError,

  /// A custom color used as an overlay on a surface color to indicate a
  /// component's elevation and surface color branding or tinting.
  ///
  /// If a [colorScheme] was provided where this corresponding color is
  /// defined, this color property will override the same color in it.
  ///
  /// This color is used by Material 3 for colored elevation, it is also used
  /// as the blend color for FlexColorScheme surface blends. Additionally
  /// this color is if provided used as key color for seeding
  /// the neutral color palettes, when seed generated color schemes are used.
  /// It is important that all these properties use the same color.
  ///
  /// Typically this color is not customized, most designs use the default
  /// where the theme primary color is used for slightly mixing it into the
  /// neutral background and surface colors, when seeding is used. As well as
  /// using it for the the elevation tint in Material 3, plus for the
  /// surface blends that can optionally be added with FlexColorScheme.
  ///
  /// If undefined, [primary] color is used.
  final Color? surfaceTint,

  /// Makes the light theme backgrounds lighter or even white.
  ///
  /// Scaffold background will become white, and other surfaces also get
  /// lighter (8%), if using low blend levels they may become fully white too.
  final bool lightIsWhite = false,

  /// When true, the primary and primaryContainer colors will be swapped with
  /// their secondary counterparts.
  ///
  /// Set this flag to true if you want to make a theme where
  /// your primary and secondary colors are swapped, compared to how they
  /// are defined in the passed in color properties or used pre-defined
  /// color scheme.
  ///
  /// This is useful if you want to do this with the pre-defined
  /// schemes. If you are explicitly defining all your theme colors you can
  /// of course define them in any desired config. Even if you do
  /// that, this feature will still swap whatever colors you defined
  /// for primary and secondary. You can offer this feature as an easy end
  /// user modifiable theme option if you like. One usage possibility is to
  /// set `swapColors` to true only for the dark modem and use your color
  /// scheme the other way around only in dark mode.
  final bool swapColors = false,

  /// When set to true, tooltip background color will match the brightness of
  /// the theme's background color.
  ///
  /// By default Flutter's Material tooltips use a theme where the tooltip
  /// background color brightness is inverted in relation to the overall
  /// theme's background color.
  ///
  /// [FlexColorScheme] allows you to use a single toggle to invert this.
  /// Light tooltips on light background is e.g. the default style on
  /// Windows Desktop toggle. You can use this toggle to use this style,
  /// or use it as a means to create a platform adaptive tooltip style, where
  /// the Material and Flutter style is used on devices and Web, but the
  /// inverted scheme is used on e.g. Windows platform.
  ///
  /// Defaults to false, and uses same background style as Material Design
  /// guide and Flutter.
  ///
  /// Additional tooltip styles when NOT opting in on FlexColorScheme sub
  /// themes are:
  ///
  /// - tooltipsMatchBackground: false
  ///   - none
  ///
  /// - tooltipsMatchBackground: true
  ///   - light theme:
  ///     - background: Color(0xF0FCFCFC),
  ///     - text: black
  ///   - Dark theme:
  ///     - background: Color(0xED444444),
  ///     - text: white
  ///   - Border radius: 4 dp
  ///   - Border: Yes, dividerColor
  ///   - Desktop OS (macOS, Linux, Windows)
  ///     - Font size : 12 dp
  ///   - Mobile OS (iOS, Android, Fuchsia)
  ///     - Font size : 14 dp
  ///
  /// Additional styles when opting in on FlexColorScheme sub themes are:
  ///
  /// - Desktop OS (macOS, Linux, Windows)
  ///   - Font size : 12 dp
  /// - Mobile OS (iOS, Android, Fuchsia)
  ///   - Font size : 14 dp
  /// - Border radius: 8 dp
  /// - Border: Yes, dividerColor
  /// - tooltipsMatchBackground: false
  ///   - light theme:
  ///     - background: Color(0xFF111111).blendAlpha(primary, 45%) opacity 95%
  ///     - text: white
  ///   - Dark theme:
  ///     - background: Color(0xFFFFFFFF).blendAlpha(primary, 39%) opacity 95%
  ///     - text: black
  /// - tooltipsMatchBackground: true
  ///   - light theme:
  ///     - background:  Color(0xFFFFFFFF).blendAlpha(primary, 4%) opacity 95%
  ///     - text: black
  ///   - Dark theme:
  ///     - background: Color(0xFF111111).blendAlpha(primary, 16%) opacity 95%
  ///     - text: white
  ///
  /// When using additional theming via sub-themes properties, its
  /// properties will if used override background color, text color and
  /// background opacity as well as border radius.
  final bool tooltipsMatchBackground = false,

  /// Activate using FlexColorScheme opinionated component sub-themes by
  /// passing in a default `FlexSubThemesData()`.
  ///
  /// To further configure the sub-themes, change the simple flat value
  /// properties as desired in `FlexSubThemesData()`.
  ///
  /// By default [FlexThemeData.light], [FlexThemeData.dark] and
  /// [FlexColorScheme.toTheme], do as little as they need to just
  /// provide a consistent Material 2 color schemed theme. The additions they
  /// do are described in [FlexColorScheme.toTheme].
  ///
  /// The original purpose of the opinionated sub-themes was to make it easy
  /// to add themed corner radius to all Widgets that support it, and to
  /// provide a consistent look on all buttons, including [ToggleButtons].
  ///
  /// Therefore the sub themes are a convenient way to opt-in on customized
  /// corner radius on Widgets using above themes. By opting in you can set
  /// corner radius for all covered Widgets to same corner radius in one go.
  /// There are also properties to override the global default for each widget
  /// to set different rounding per widget if so desired.
  ///
  /// By default, if a `defaultRadius` is not specified, each widgets corner
  /// radius and some other styling take inspiration from the Material 3 (M3)
  /// specification https://m3.material.io/ and uses its specifications as
  /// defaults when it is possible to do so in Flutter SDK theming when using
  /// Material2 mode and via defaults also in Material 3 mode.
  ///
  /// Starting from version 5, by opting in via a default [subThemesData] you
  /// get an extensive set of widget component sub themes applied.
  /// They can be customized via the [subThemesData] property, that has
  /// quick and flat sub theme configuration values in the data class
  /// [FlexSubThemesData].
  ///
  /// Customizable sub-themes are available for:
  ///
  /// * [AppBarTheme] for [AppBar] via [FlexSubThemes.appBarTheme].
  /// * [BottomAppBarTheme] for [BottomAppBar] via
  ///   [FlexSubThemes.bottomAppBarTheme].
  /// * [BottomNavigationBarThemeData] for [BottomNavigationBar] via
  ///   [FlexSubThemes.bottomNavigationBar].
  /// * [BottomSheetThemeData] for [BottomSheet] via
  ///   [FlexSubThemes.bottomSheetTheme].
  /// * [ButtonThemeData] for old deprecated buttons, via
  ///   [FlexSubThemes.buttonTheme].
  /// * [CardTheme] for [Card] via [FlexSubThemes.cardTheme].
  /// * [CheckboxThemeData] for [Checkbox] via [FlexSubThemes.checkboxTheme].
  /// * [ChipThemeData] for [Chip] via [FlexSubThemes.chipTheme].
  /// * [DatePickerThemeData] for [DatePicker] via
  ///   [FlexSubThemes.datePickerTheme].
  /// * [DialogTheme] for [Dialog] via [FlexSubThemes.dialogTheme].
  /// * [DrawerThemeData] for [Drawer] via [FlexSubThemes.drawerTheme].
  /// * [DropdownMenuThemeData] for [DropDownMenu] via
  ///   [FlexSubThemes.dropdownMenuTheme].
  /// * [ElevatedButtonThemeData] for [ElevatedButton] via
  ///   [FlexSubThemes.elevatedButtonTheme].
  /// * [FilledButtonThemeData] for [FilledButton] via
  ///   [FlexSubThemes.filledButtonTheme].
  /// * [FloatingActionButtonThemeData] for [FloatingActionButton] via
  ///   [FlexSubThemes.floatingActionButtonTheme].
  /// * [IconButtonThemeData] for [IconButton] via
  ///   [FlexSubThemes.iconButtonTheme].
  /// * [InputDecorationTheme] for [InputDecoration] via
  ///   [FlexSubThemes.inputDecorationTheme].
  /// * [MenuBarThemeData] for [MenuBar] via [FlexSubThemes.menuBarTheme].
  /// * [MenuButtonThemeData] for [MenuButton] via
  ///   [FlexSubThemes.menuButtonTheme].
  /// * [MenuThemeData] for [MenuBar], [MenuAnchor] and [DropDownMenu] via
  ///   [FlexSubThemes.menuTheme].
  /// * [ListTileThemeData] for [ListTile] via
  ///   [FlexSubThemes.listTileTheme].
  /// * [NavigationBarThemeData] for [NavigationBar] via
  ///   [FlexSubThemes.navigationBarTheme].
  /// * [NavigationDrawerThemeData] for [NavigationDrawer] via
  ///   [FlexSubThemes.navigationDrawerTheme].
  /// * [NavigationRailThemeData] for [NavigationRail] via
  ///   [FlexSubThemes.navigationRailTheme].
  /// * [OutlinedButtonThemeData] for [OutlinedButton] via
  ///   [FlexSubThemes.outlinedButtonTheme].
  /// * [PopupMenuThemeData] for [PopupMenuButton] via
  ///   [FlexSubThemes.popupMenuTheme].
  /// * [RadioThemeData] for [Radio] via [FlexSubThemes.radioTheme].
  /// * [SliderThemeData] for [Slider] via [FlexSubThemes.sliderTheme].
  /// * [SnackBarThemeData] for [SnackBar] via [FlexSubThemes.snackBarTheme].
  /// * [SwitchThemeData] for [Switch] via [FlexSubThemes.switchTheme].
  /// * [TabBarTheme] for [TabBar] via [FlexSubThemes.tabBarTheme].
  /// * [TextButtonThemeData] for [TextButton] via
  ///   [FlexSubThemes.textButtonTheme].
  /// * [TextSelectionThemeData] for [TextField] via
  ///   [FlexSubThemes.textSelectionTheme].
  /// * [TimePickerThemeData] for [TimePickerDialog] via
  ///   [FlexSubThemes.timePickerTheme].
  /// * [ToggleButtonsThemeData] for [ToggleButtons] via
  ///   [FlexSubThemes.toggleButtonsTheme].
  /// * [TooltipThemeData] for [Tooltip] via [FlexSubThemes.tooltipTheme].
  ///
  /// Defaults to null, resulting in FlexColorScheme not using any extra
  /// sub-theming in addition to those described in [FlexColorScheme.toTheme].
  final FlexSubThemesData? subThemesData,

  /// To use and activate Material 3 color system based [ColorScheme]
  /// defined via key colors for primary, secondary and tertiary colors and
  /// the [TonalPalette] generated by these key color values, pass
  /// in a [FlexKeyColors] to [keyColors].
  ///
  /// By default it is not defined (null), and a traditional manually
  /// configured color scheme will be created based on input property values
  /// or a passed in [colorScheme].
  ///
  /// If a [FlexKeyColors] instance is passed in, the key color seeding
  /// behavior depends on properties defined in the [FlexKeyColors]
  /// instance. The default constructor makes one where
  /// [FlexKyColors.useKeyColors] is true, it will automatically enable usage
  /// of the used light scheme's primary color as key color and to seed
  /// generated a color scheme. The result will by default be equal to using
  /// Flutter SDK `ColorScheme.fromSeed`. With `FlexKeyColors` you can also
  /// use `secondary` and `tertiary` colors as key colors. Currently Flutter
  /// SDK does not support this.
  ///
  /// For more information on Material 3 color system and usage of key colors
  /// to generate tonal palettes and tones, see:
  /// https://m3.material.io/styles/color/the-color-system/key-colors-tones
  final FlexKeyColors? keyColors,

  /// Set to true, to use the new Material 3 error colors.
  ///
  /// If [useMaterial3ErrorColors] is false, the generated [ColorScheme]
  /// and [ThemeData] will use Material 2 default error colors or
  /// error colors as defined by the built in color schemes. Thus using same
  /// error colors as in FlexColorScheme versions before version 5.
  ///
  /// If [useMaterial3ErrorColors] is true, the resulting [ColorScheme]
  /// and [ThemeData] will use the Material 3 design guide error colors.
  ///
  /// Key color seed generated [ColorScheme]s always use the Material 3
  /// design guide error colors, or error colors from its customized
  /// [TonalPalette] generation setup.
  final bool useMaterial3ErrorColors = false,

  /// A configuration class enabling complete customization of
  /// used chroma for [TonalPalette] generation for the used seed [keyColors],
  /// as well as changing which tone in the tonal palettes is used
  /// for which [ColorScheme] color.
  ///
  /// By default a `FlexTones` configuration `FlexTones.material` that
  /// matches what Flutter SDK does with `ColorScheme.fromSeed` is used.
  ///
  /// There are six other built-in definitions that you can use, they can also
  /// serve as an example of how you can make custom `FlexTones`
  /// configurations.
  final FlexTones? tones,

  /// The density value for specifying the compactness of various UI
  /// components.
  ///
  /// Consider using [FlexColorScheme.comfortablePlatformDensity],
  /// it is similar to [VisualDensity.adaptivePlatformDensity], but the
  /// density for desktop and Web is less dense in order to offer a bit larger
  /// touch friendly surfaces, but not quite as large as small touch devices.
  ///
  /// This is the same property as in [ThemeData] factory, it is just
  /// passed along to it. Included for convenience, to avoid a copyWith
  /// to change it.
  ///
  /// Density, in the context of a UI, is the vertical and horizontal
  /// "compactness" of the elements in the UI. It is unit less, since it means
  /// different things to different UI elements. For buttons, it affects the
  /// spacing around the centered label of the button. For lists, it affects
  /// the distance between baselines of entries in the list.
  ///
  /// Typically, density values are integral, but any value in range may be
  /// used. The range includes values from [VisualDensity.minimumDensity]
  /// (which is -4), to [VisualDensity.maximumDensity] (which is 4),
  /// inclusive, where negative values indicate a denser, more compact, UI,
  /// and positive values indicate a less dense, more expanded, UI. If a
  /// component doesn't support the value given, it will clamp to the nearest
  /// supported value.
  ///
  /// The default for visual densities is zero for both vertical and
  /// horizontal densities, which corresponds to the default visual density of
  /// components in the Material Design specification.
  ///
  /// As a rule of thumb, a change of 1 or -1 in density corresponds to 4
  /// logical pixels. However, this is not a strict relationship since
  /// components interpret the density values appropriately for their needs.
  ///
  /// A larger value translates to a spacing increase (less dense), and a
  /// smaller value translates to a spacing decrease (more dense).
  ///
  /// Defaults to [VisualDensity.adaptivePlatformDensity].
  final VisualDensity? visualDensity,

  /// Text with a color that contrasts with background, surface, card and
  /// canvas colors.
  ///
  /// If a default `TextTheme` from package GoogleFonts is passed.
  /// FlexColorScheme will detect this and make the color in the passed
  /// in `GoogleFonts` null for all its `TextStyle`s so that the correct
  /// color for M2/M3 mode and contrast for light/dark mode is used.
  final TextTheme? textTheme,

  /// A text theme that contrasts with the primary color.
  ///
  /// If a default `TextTheme` from package GoogleFonts is passed.
  /// FlexColorScheme will detect this and make the color in the passed
  /// in `GoogleFonts` null for all its `TextStyle`s so that the correct
  /// color for M2/M3 mode and contrast for primary color is used.
  final TextTheme? primaryTextTheme,

  /// Name of the font family to use as default font for the text theme in
  /// created theme.
  ///
  /// Same feature as in [ThemeData] factory. Used to apply the font family
  /// name to default text theme and primary text theme, also passed along
  /// to [ThemeData],
  final String? fontFamily,

  /// Name of the font families to use as fallback to main font family.
  ///
  /// Same feature as in [ThemeData] factory. Used to apply the font family
  /// fallback to default text theme and primary text theme, also passed
  /// along to [ThemeData],
  final List<String>? fontFamilyFallback,

  /// Name of the font package to use with font fallback.
  ///
  /// Same feature as in [ThemeData] factory. Used to apply the font package
  /// to default text theme and primary text theme, also passed along
  /// to [ThemeData],
  final String? package,

  /// Configures the hit test size of certain Material widgets.
  ///
  /// Defaults to a [platform]-appropriate size: MaterialTapTargetSize.padded
  /// on mobile platforms, MaterialTapTargetSize.shrinkWrap on desktop
  /// platforms.
  final MaterialTapTargetSize? materialTapTargetSize,

  /// Default [MaterialPageRoute] transitions per [TargetPlatform].
  ///
  /// [MaterialPageRoute.buildTransitions] delegates to a [platform] specific
  /// [PageTransitionsBuilder]. If a matching builder is not found, a builder
  /// whose platform is null is used.
  ///
  /// This is convenience pass through in FlexColorScheme to avoid a
  /// `copyWith` on `ThemeData` produced by FlexColorScheme.
  final PageTransitionsTheme? pageTransitionsTheme,

  /// Defines the appearance of ink splashes produces by [InkWell]
  /// and [InkResponse].
  ///
  /// Providing a [splashFactory] value will override the default one created
  /// by [ThemeData], it will also override any splash settings in
  /// [subThemesData].
  ///
  /// See also:
  ///
  ///  * [InkSplash.splashFactory], which defines the default splash.
  ///  * [InkRipple.splashFactory], which defines a splash that spreads out
  ///    more aggressively than the default.
  ///  * [InkSparkle.splashFactory], which defines a more aggressive and
  ///    organic splash with sparkle effects.
  final InteractiveInkFeatureFactory? splashFactory,

  /// The platform adaptive widgets adapt to defined target and mechanics,
  /// like scrolling too.
  ///
  /// Same property as in [ThemeData] factory. Included for convenience to
  /// avoid a copyWith to change it.
  ///
  /// Defaults to the current platform, as exposed by [defaultTargetPlatform].
  /// This should be used in order to style UI elements according to platform
  /// conventions.
  ///
  /// Widgets from the material library should use this getter (via
  /// [Theme.of]) to determine the current platform for the purpose of
  /// emulating the platform behavior (e.g. scrolling or haptic effects).
  /// Widgets and render objects at lower layers that try to emulate the
  /// underlying platform platform can depend on [defaultTargetPlatform]
  /// directly, or may require that the target platform be provided as an
  /// argument. The `dart.io.Platform` object should only be used directly
  /// when it's critical to actually know the current platform, without
  /// any overrides possible, e.g. when a system API is about to be called.
  ///
  /// In a test environment, the platform returned is [TargetPlatform.android]
  /// regardless of the host platform. (Android was chosen because the tests
  /// were originally written assuming Android-like behavior, and we added
  /// platform adaptations for other platforms later). Tests can check
  /// behavior for other platforms by setting the [platform] of the [Theme]
  /// explicitly to another [TargetPlatform] value, or by setting
  /// [debugDefaultTargetPlatformOverride].
  ///
  /// When developing applications you can use this property to dynamically
  /// in the application change the used platform and partially test and see
  /// how adaptive widgets and scroll looks and feels on other platforms.
  final TargetPlatform? platform,

  /// The color and geometry [TextTheme] values used to configure [textTheme].
  ///
  /// Same property as in [ThemeData] factory.
  /// Included for convenience to avoid a copyWith if it needs to be changed.
  /// Default value deviates from the Flutter standard that uses the old
  /// [Typography.material2014], in favor of newer [Typography.material2018]
  /// as default typography if one is not provided.
  ///
  /// In M3 mode FCS default to [Typography.material2021] and in M2 mode to
  /// older [Typography.material2018], which is correct for M2. Please note
  /// that Flutter ThemeData defaults to even older Typography
  /// [Typography.material2014] when not using M3. This is done for legacy
  /// compatibility reasons, you should use 2018 with M2.
  final Typography? typography,

  /// Apply a semi-transparent overlay color on Material surfaces to indicate
  /// elevation for dark themes.
  ///
  /// Same property as in [ThemeData] factory. Included for convenience to
  /// avoid a copyWith change it.
  ///
  /// In FlexColorScheme it defaults to true. In Flutter [ThemeData.from] it
  /// also default to true, but in [ThemeData] factory it defaults to false.
  ///
  /// Material drop shadows can be difficult to see in a dark theme, so the
  /// elevation of a surface should be portrayed with an "overlay" in addition
  /// to the shadow. As the elevation of the component increases, the
  /// overlay increases in opacity. The [applyElevationOverlayColor] turns the
  /// application of this overlay on or off for dark themes.
  ///
  /// If true and [brightness] is [Brightness.dark], a
  /// semi-transparent version of [ColorScheme.onSurface] will be
  /// applied on top of [Material] widgets that have a [ColorScheme.surface]
  /// color. The level of transparency is based on [Material.elevation] as
  /// per the Material Dark theme specification.
  ///
  /// If false the surface color will be used unmodified.
  ///
  /// Defaults to false in order to maintain backwards compatibility with
  /// apps that were built before the Material Dark theme specification
  /// was published. New apps should set this to true for any themes
  /// where [brightness] is [Brightness.dark].
  ///
  /// See also:
  ///
  ///  * [Material.elevation], which effects the level of transparency of the
  ///    overlay color.
  ///  * [ElevationOverlay.applyOverlay], which is used by [Material] to apply
  ///    the overlay color to its surface color.
  ///  * <https://material.io/design/color/dark-theme.html>, which specifies
  ///    how the overlay should be applied.
  ///
  /// Known limitations:
  ///
  /// Because of how the overlay color application is implemented in Flutter
  /// SDK, you will only get overlay color applied in dark mode when this
  /// value  is true, if the [Material] surface color being elevated is equal
  /// to [ThemeData.colorScheme] and its [ColorScheme.surface] color property.
  ///
  /// Thus when using color branded surfaces, if you want all [Material]
  /// surfaces in your theme to get an overlay color in dark mode, you must
  /// for dark themes only use background colors that are equal to the surface
  /// color. This when using [FlexColorScheme.dark] use a [FlexSurfaceMode]
  /// that starts with `equal`. That said, if using heavy color branding,
  /// some surfaces may not need any overlay color, so the
  /// lack of it might not be an issue with other modes in such themes.
  /// For more information about this limitation see Flutter SDK issue:
  /// https://github.com/flutter/flutter/issues/90353
  final bool applyElevationOverlayColor = true,

  /// A temporary flag used to opt-in to new SDK Material 3 features.
  ///
  /// Flutter SDK [useMaterial3] documentation:
  /// --------------------------------------------------------
  /// If true, then widgets that have been migrated to Material 3 will
  /// use new colors, typography and other features of Material 3. If false,
  /// they will use the Material 2 look and feel.
  ///
  /// During the migration to Material 3, turning this on may yield
  /// inconsistent look and feel in your app as some widgets are migrated
  /// while others have yet to be.
  ///
  /// Defaults to false. When the Material 3 specification is complete
  /// and all widgets are migrated on stable, we will change this flag to be
  /// true by default. After that change has landed on stable, we will
  /// deprecate this flag and remove all uses of it. At that point, the
  /// `material` library will aim to only support Material 3.
  ///
  /// ## Defaults
  /// If a [ThemeData] is constructed with [useMaterial3] set to true, then
  /// some properties will get updated defaults. Please note that
  /// [ThemeData.copyWith] with [useMaterial3] set to true will
  /// not change any of these properties in the resulting [ThemeData].
  ///
  /// <style>table,td,th { border-collapse: collapse; padding: 0.45em; } td { border: 1px solid }</style>
  ///
  /// | Property        | M3 default                 | M2 default           |
  /// | :-------------- | :------------------------- | :------------------- |
  /// | [colorScheme]   | M3 baseline scheme         | M2 baseline scheme |
  /// | [typography]  | [Typography.material2021]| [Typography.material2014] |
  /// | [splashFactory] | [InkSparkle]* or [InkRipple] | [InkSplash]         |
  ///
  /// \* if the target platform is Android and the app is not
  /// running on the web, otherwise it will fallback to [InkRipple].
  ///
  /// If [brightness] is [Brightness.dark] then the default color scheme will
  /// be either the M3 baseline dark color scheme or the M2 baseline dark
  /// color scheme depending on [useMaterial3].
  ///
  /// ## Affected widgets
  ///
  /// This flag affects styles and components.
  ///
  /// ### Styles
  ///   * Color: [ColorScheme], [Material] (see table above)
  ///   * Shape: (see components below)
  ///   * Typography: [Typography] (see table above)
  ///
  /// ### Components
  ///   * Badges: [Badge]
  ///   * Bottom app bar: [BottomAppBar]
  ///   * Bottom sheets: [BottomSheet]
  ///   * Buttons
  ///     - Common buttons: [ElevatedButton], [FilledButton],
  ///       [OutlinedButton], [TextButton]
  ///     - FAB: [FloatingActionButton], [FloatingActionButton.extended]
  ///     - Icon buttons: [IconButton]
  ///     - Segmented buttons: [SegmentedButton]
  ///   * Cards: [Card]
  ///   * Checkbox: [Checkbox]
  ///   * Chips:
  ///     - [ActionChip] (used for Assist and Suggestion chips),
  ///     - [FilterChip], [ChoiceChip] (used for single select filter chips),
  ///     - [InputChip]
  ///   * Dialogs: [Dialog], [AlertDialog]
  ///   * Divider: [Divider]
  ///   * Lists: [ListTile]
  ///   * Menus: [MenuBar], [DropdownMenu]
  ///   * Navigation bar: [NavigationBar] (replacing [BottomNavigationBar])
  ///   * Navigation drawer: [NavigationDrawer]
  ///   * Navigation rail: [NavigationRail]
  ///   * Progress indicators: [CircularProgressIndicator],
  ///     [LinearProgressIndicator]
  ///   * Radio button: [Radio]
  ///   * Snack bar: [SnackBar]
  ///   * Slider: [Slider]
  ///   * Switch: [Switch]
  ///   * Tabs: [TabBar]
  ///   * TextFields: [TextField] together with its [InputDecoration]
  ///   * Top app bar: [AppBar]
  ///
  /// In addition, this flag enables features introduced in Android 12.
  ///   * Stretch overscroll: [MaterialScrollBehavior]
  ///   * Ripple: `splashFactory` (see table above)
  ///
  /// See also:
  ///
  ///   * [Material 3 specification](https://m3.material.io/)
  final bool useMaterial3 = false,

  /// Set to true to automatically swap secondary and tertiary colors, on
  /// built-in color schemes when [useMaterial3] is true, that benefit
  /// from it to better match the Material 3 color system design intent.
  ///
  /// Starting with FlexColorScheme version 6.1.0, built-in color schemes,
  /// defined via [FlexSchemeColor], have a flag [swapOnMaterial3]. When
  /// defined to be true, the scheme will benefit if the [secondary] and
  /// [tertiary] colors, including their containers, are swapped when using
  /// Material 3. Most FlexColorScheme color schemes were designed with
  /// M2 usage in mind, before M3 existed. They may often have their
  /// [swapOnMaterial3] set to true. If this flag is false, it may mean
  /// that its `FlexSchemeColor` was designed for M3 or that it won't
  /// benefit from swapping its secondary and tertiary colors. In the
  /// [Scheme Reference](https://docs.flexcolorscheme.com/scheme_reference),
  /// you can see which schemes have the flag defined to true.
  ///
  /// Using a seed-generated color scheme based on built-in FlexSchemeColor
  /// colors is another way to make them suitable for the M3 Color system.
  /// However, in some cases, the secondary color in their design may not
  /// be in-line with the M3 color system design intent, especially if you
  /// use the config that also uses the hue from the secondary color to
  /// make tonal palettes for it. In some legacy FlexSchemeColor color
  /// designs this can be fixed if we swap the secondary and tertiary colors.
  ///
  /// To make FlexSchemeColor designs color designs that benefit from it
  /// automatically swap secondary and tertiary colors when [useMaterial3]
  /// is set to true, set `swapLegacyOnMaterial3` to true. It defaults to
  /// false, for backward compatibility, but it is recommended to turn
  /// it on when using Material 3 and its color system. If you use
  /// seeded color schemes with Material 2, [useMaterial3] flag is false,
  /// then it may be preferable to keep [swapOnMaterial3] false for more
  /// prominent colors on secondaries.
  ///
  /// This color swap has higher priority than [swapColor], using it will
  /// always happen on the effective result of [swapLegacyOnMaterial3] and
  /// [useMaterial3], and value of [swapOnMaterial3] in currently used
  /// built-in scheme [FlexSchemeColor].
  ///
  /// If a custom [colorScheme] is passed in, or any of the direct color
  /// properties [secondary], [secondaryContainer], [tertiary] or
  /// [tertiaryContainer], then it is assumed a custom scheme or overrides,
  /// are being used and the [swapLegacyOnMaterial3] setting does nothing.
  ///
  /// The Themes Playground app defaults to setting [swapLegacyOnMaterial3]
  /// to ON (true), but allows you to turn it OFF.
  ///
  /// Defaults to false, for backwards compatibility, but prefer setting it
  /// to true if you also set [useMaterial3] to true.
  final bool swapLegacyOnMaterial3 = false,

  /// Arbitrary additions to this theme.
  ///
  /// This is the same property as [extensions] in ThemeData, it is provided
  /// as a convenience pass-through to ThemeData.
  ///
  /// To define extensions, pass an [Iterable] containing one or more
  /// [ThemeExtension] subclasses to [ThemeData.new] or [copyWith].
  ///
  /// To obtain an extension, use ThemeData.of(context).extension.
  final Iterable<ThemeExtension<dynamic>>? extensions,
}) {
  // LIGHT: Check valid inputs
  assert(usedColors >= 1 && usedColors <= 7, 'usedColors must be 1 to 7');
  assert(appBarOpacity == null || appBarOpacity >= 0 && appBarOpacity <= 1,
      'appBarOpacity must be 0 to 1, or null');
  assert(
    blendLevel >= 0 && blendLevel <= 40,
    'Only blend levels from 0 to 40 are allowed. Very high alpha values may '
    'not produce results that are visually very appealing or useful.',
  );
  assert(appBarElevation == null || appBarElevation >= 0.0,
      'AppBar elevation must be >= 0 or null.');
  assert(bottomAppBarElevation == null || bottomAppBarElevation >= 0.0,
      'Bottom AppBar elevation must be null or must be >= 0.');
  // Use color seeding based on passed in keyColors or make one where
  // it is not used, if one was not defined, since we want that as default
  // behavior to match past default behavior.
  final FlexKeyColors seed =
      keyColors ?? const FlexKeyColors(useKeyColors: false);
  // Fallback value for scheme is default material scheme.
  final FlexScheme flexScheme = scheme ?? FlexScheme.material;
  // If colors was null, we used the scheme based value.
  final FlexSchemeColor flexColors =
      colors ?? FlexColor.schemesWithCustom[flexScheme]!.light;

  // If the passed in property values are not null, or there was a colorScheme
  // provided, we will override the colors properties with them. Doing it here
  // gets also correct effective and swap behavior on directly passed in
  // property values or colorScheme based colors too.
  final FlexSchemeColor withPassedColors = flexColors.copyWith(
    primary: primary ?? colorScheme?.primary,
    primaryContainer: primaryContainer ?? colorScheme?.primaryContainer,
    secondary: secondary ?? colorScheme?.secondary,
    secondaryContainer: secondaryContainer ?? colorScheme?.secondaryContainer,
    tertiary: tertiary ?? colorScheme?.tertiary,
    tertiaryContainer: tertiaryContainer ?? colorScheme?.tertiaryContainer,
    error: error ?? colorScheme?.error,
    errorContainer: colorScheme?.errorContainer,
  );
  // Swap legacy secondary and tertiary color if we use Material 3 and
  // we have swapping of legacy colors on and if the colors in used built-in
  // scheme has flag [swapOnMaterial3] set that tells it benefits from doing
  // this. Additionally we should only do this if we have not passed a custom
  // ColorScheme, nor secondary or tertiary colors directly.
  final bool swapLegacy = useMaterial3 &&
      swapLegacyOnMaterial3 &&
      flexColors.swapOnMaterial3 &&
      secondary == null &&
      secondaryContainer == null &&
      tertiary == null &&
      tertiaryContainer == null &&
      colorScheme == null;
  // First cut of effective FlexSchemeColor depends on colors, usedColors
  // and swapLegacy and swap. When we use Brightness.light, we also guarantee
  // that we have colors on effectiveColors.error and errorContainer, they
  // are guaranteed to no longer be null after this call.
  FlexSchemeColor effectiveColors = FlexSchemeColor.effective(
    withPassedColors,
    usedColors,
    swapLegacy: swapLegacy,
    swapColors: swapColors,
    brightness: Brightness.light,
  );
  // ColorScheme to hold our seeded scheme colors, it will be kept as null
  // if we do not use M3 key based seeded tonal palette ColorScheme.
  ColorScheme? seedScheme;
  // If keyColor seeds is active, apply seeded colors to effective colors.
  if (seed.useKeyColors) {
    // Create a complete ColorScheme from active and effective seed colors.
    seedScheme = SeedColorScheme.fromSeeds(
      brightness: Brightness.light,
      primaryKey: effectiveColors.primary,
      // If use secondary seed, use it with fromSeeds, otherwise undefined.
      secondaryKey: seed.useSecondary ? effectiveColors.secondary : null,
      // If use tertiary seed, use it with fromSeeds, otherwise undefined.
      tertiaryKey: seed.useTertiary ? effectiveColors.tertiary : null,
      // If a custom surface tint is used, use it also as key for neutral and
      // neutral variant tonal palette generation.
      neutralKey: surfaceTint,
      neutralVariantKey: surfaceTint,
      // Use provided tones configuration or default one.
      tones: tones,
      surfaceTint: surfaceTint,
    );
    // Update effective main colors to seed colors, keeping configured
    // effective main color values when so defined.
    effectiveColors = FlexSchemeColor(
      primary:
          seed.keepPrimary ? effectiveColors.primary : seedScheme.primary,
      primaryContainer: seed.keepPrimaryContainer
          ? effectiveColors.primaryContainer
          : seedScheme.primaryContainer,
      secondary: seed.keepSecondary
          ? effectiveColors.secondary
          : seedScheme.secondary,
      secondaryContainer: seed.keepSecondaryContainer
          ? effectiveColors.secondaryContainer
          : seedScheme.secondaryContainer,
      tertiary:
          seed.keepTertiary ? effectiveColors.tertiary : seedScheme.tertiary,
      tertiaryContainer: seed.keepTertiaryContainer
          ? effectiveColors.tertiaryContainer
          : seedScheme.tertiaryContainer,
      appBarColor: effectiveColors.appBarColor,
      error: seedScheme.error,
      errorContainer: seedScheme.errorContainer,
    );
  }
  // Get effective surfaceTint color, also used as blend color for surfaces.
  final Color blendColor =
      surfaceTint ?? colorScheme?.surfaceTint ?? effectiveColors.primary;
  // Compute surface blends, they are also be added to seeded surfaces.
  final FlexSchemeSurfaceColors surfaceSchemeColors =
      FlexSchemeSurfaceColors.blend(
    brightness: Brightness.light,
    surfaceMode: surfaceMode ?? FlexSurfaceMode.highScaffoldLowSurfaces,
    blendLevel: blendLevel,
    surfaceVariantBlendDivide: seed.useKeyColors ? 2 : 1,
    schemeColors: effectiveColors,
    blendColors: FlexSchemeSurfaceColors(
      surface: blendColor,
      surfaceVariant: blendColor,
      inverseSurface: blendColor,
      dialogBackground: blendColor,
      background: blendColor,
      scaffoldBackground: blendColor,
    ),
    surfaceColors: seed.useKeyColors
        // Using seed colors, starting surfaces are given by generated scheme.
        ? FlexSchemeSurfaceColors(
            surface: seedScheme!.surface,
            surfaceVariant: seedScheme.surfaceVariant,
            inverseSurface: seedScheme.inverseSurface,
            dialogBackground: seedScheme.surface,
            background: seedScheme.background,
            scaffoldBackground: seedScheme.background,
          )
        // Colorscheme surfaces are used as starting point for blended ones.
        : colorScheme != null
            ? FlexSchemeSurfaceColors(
                surface: colorScheme.surface,
                surfaceVariant: colorScheme.surfaceVariant,
                inverseSurface: colorScheme.inverseSurface,
                dialogBackground: colorScheme.surface,
                background: colorScheme.background,
                scaffoldBackground: colorScheme.background,
              )
            : null,
  );
  // Use sub-themes if a none null FlexSubThemesData was provided.
  final bool useSubThemes = subThemesData != null;
  // Use passed in sub-theme config data, or a default one, if none given.
  final FlexSubThemesData subTheme =
      subThemesData ?? const FlexSubThemesData();
  // Effective blend level for the onColors.
  int onBlendLevel = useSubThemes ? (subTheme.blendOnLevel ?? 0) : 0;
  assert(
      onBlendLevel >= 0 && onBlendLevel <= 40,
      'Only onBlendLevel:s from 0 to 40 '
      'are allowed. Very high alpha blend levels may not produce results '
      'that are visually very appealing or useful.');
  // If above happens in none debug mode, use 0, no blends.
  if (onBlendLevel < 0 || onBlendLevel > 40) onBlendLevel = 0;

  // Get alpha blend values for used mode, on blend level and brightness,
  // used for onContainers and onSurface and onBackground.
  final FlexAlphaValues alphaOnValue = useSubThemes
      ? FlexAlphaValues.getAlphas(
          surfaceMode ?? FlexSurfaceMode.highScaffoldLowSurfaces,
          onBlendLevel)
      : const FlexAlphaValues();
  // Get alpha blend values for used mode, on blend level and brightness,
  // used for onPrimary, onSecondary, onTertiary and onError.
  final FlexAlphaValues alphaOnMain = useSubThemes && subTheme.blendOnColors
      ? FlexAlphaValues.getAlphas(
          surfaceMode ?? FlexSurfaceMode.highScaffoldLowSurfaces,
          onBlendLevel)
      : const FlexAlphaValues();
  // Determine the input surface, surfaceVariant and background colors,
  // inputSurfaceVariant cannot be overridden via FlexColorScheme prop yet.
  // This is a preparation for adding it.
  // TODO(rydmike): Maybe add prop inputSurfaceVariant and inverseSurface.
  final Color inputSurface = surface ?? surfaceSchemeColors.surface;
  final Color inputSurfaceVariant = surfaceSchemeColors.surfaceVariant;
  final Color inputBackground = background ?? surfaceSchemeColors.background;

  final FlexSchemeOnColors onColors = FlexSchemeOnColors.from(
    primary: effectiveColors.primary,
    primaryContainer: effectiveColors.primaryContainer,
    secondary: effectiveColors.secondary,
    secondaryContainer: effectiveColors.secondaryContainer,
    tertiary: effectiveColors.tertiary,
    tertiaryContainer: effectiveColors.tertiaryContainer,
    surface: inputSurface,
    surfaceVariant: inputSurfaceVariant,
    inverseSurface: surfaceSchemeColors.inverseSurface,
    background: inputBackground,
    error: effectiveColors.error!,
    errorContainer: effectiveColors.errorContainer,
    onPrimary: onPrimary ??
        (seed.useKeyColors && seed.keepPrimary
            ? null
            : seedScheme?.onPrimary) ??
        colorScheme?.onPrimary,
    onPrimaryContainer: onPrimaryContainer ??
        (seed.useKeyColors && seed.keepPrimaryContainer
            ? null
            : seedScheme?.onPrimaryContainer) ??
        colorScheme?.onPrimaryContainer,
    onSecondary: onSecondary ??
        (seed.useKeyColors && seed.keepSecondary
            ? null
            : seedScheme?.onSecondary) ??
        colorScheme?.onSecondary,
    onSecondaryContainer: onSecondaryContainer ??
        (seed.useKeyColors && seed.keepSecondaryContainer
            ? null
            : seedScheme?.onSecondaryContainer) ??
        colorScheme?.onSecondaryContainer,
    onTertiary: onTertiary ??
        (seed.useKeyColors && seed.keepTertiary
            ? null
            : seedScheme?.onTertiary) ??
        colorScheme?.onTertiary,
    onTertiaryContainer: onTertiaryContainer ??
        (seed.useKeyColors && seed.keepTertiaryContainer
            ? null
            : seedScheme?.onTertiaryContainer) ??
        colorScheme?.onTertiaryContainer,
    onSurface: onSurface ?? seedScheme?.onSurface ?? colorScheme?.onSurface,
    onSurfaceVariant:
        seedScheme?.onSurfaceVariant ?? colorScheme?.onSurfaceVariant,
    onInverseSurface:
        seedScheme?.onInverseSurface ?? colorScheme?.onInverseSurface,
    onBackground:
        onBackground ?? seedScheme?.onBackground ?? colorScheme?.onBackground,
    onError: onError ?? seedScheme?.onError ?? colorScheme?.onError,
    onErrorContainer: seedScheme?.onError ?? colorScheme?.onErrorContainer,
    primaryAlpha: alphaOnMain.primaryAlpha,
    primaryContainerAlpha: alphaOnValue.primaryContainerAlpha,
    secondaryAlpha: alphaOnMain.secondaryAlpha,
    secondaryContainerAlpha: alphaOnValue.secondaryContainerAlpha,
    tertiaryAlpha: alphaOnMain.tertiaryAlpha,
    tertiaryContainerAlpha: alphaOnValue.tertiaryContainerAlpha,
    surfaceAlpha: alphaOnValue.surfaceAlpha,
    surfaceVariantAlpha: alphaOnValue.surfaceVariantAlpha,
    inverseSurfaceAlpha: alphaOnValue.inverseSurfaceAlpha,
    backgroundAlpha: alphaOnValue.backgroundAlpha,
    errorAlpha: alphaOnMain.errorAlpha,
    errorContainerAlpha: alphaOnValue.errorContainerAlpha,
  );
  // Determine effective surface color.
  // Surface is used e.g. by Card and bottom appbar.
  // If light is white, we make a lighter than normal surface. If not
  // light is white, we use provided surface color, or computed one.
  final Color effectiveSurfaceColor =
      lightIsWhite ? inputSurface.lighten(5) : inputSurface;
  final Color effectiveSurfaceVariantColor =
      lightIsWhite ? inputSurfaceVariant.lighten(5) : inputSurfaceVariant;
  final Color effectiveInverseSurfaceColor = lightIsWhite
      ? surfaceSchemeColors.inverseSurface.darken(5)
      : surfaceSchemeColors.inverseSurface;
  // Determine effective background color.
  // Used e.g. by drawer, nav rail, side menu and bottom bar.
  // If light is white, we make a lighter than normal background. If not
  // light is white, we use provided background color, or computed one.
  final Color effectiveBackgroundColor =
      lightIsWhite ? inputBackground.lighten(5) : inputBackground;

  // Determine the effective scaffold background color.
  final Color effectiveScaffoldColor = scaffoldBackground ??
      (lightIsWhite ? Colors.white : surfaceSchemeColors.scaffoldBackground);

  // Determine effective dialog background color.
  // If light is white, we use lighter than normal. If not,
  // we use dialog provided background color, or computed one.
  // The provided dialog background color overrides factory surface behavior,
  // but is impacted by plain white for a lighter effect.
  final Color effectiveDialogBackground = lightIsWhite
      ? dialogBackground?.lighten(5) ??
          surfaceSchemeColors.dialogBackground.lighten(5)
      : dialogBackground ?? surfaceSchemeColors.dialogBackground;

  // Compute the effective ColorScheme based on all selection options.
  final ColorScheme effectiveColorScheme = seedScheme?.copyWith(
        // We made a seeded color scheme, we use it as given but set
        // override values for props we have not handled via FCS direct
        // props further below. We don't adjust onColors for
        // surfaceVariant and inverseSurface on purpose.
        surfaceVariant: effectiveSurfaceVariantColor,
        inverseSurface: effectiveInverseSurfaceColor,
        surfaceTint: surfaceTint,
      ) ??
      // We had a colorScheme passed in, we use as passed in, but set
      // override values for props we do not handle via FCS direct
      // props further below.
      colorScheme?.copyWith(
        surfaceVariant: effectiveSurfaceVariantColor,
        onSurfaceVariant: onColors.onSurfaceVariant,
        inverseSurface: effectiveInverseSurfaceColor,
        onInverseSurface: onColors.onInverseSurface,
        surfaceTint: surfaceTint,
      ) ??
      // In order to avoid using a ColorScheme.light that sets
      // some opinionated defaults on deprecated members that we do not
      // want, we make a full one matching the target. Values that
      // exist as direct properties in FlexColorScheme, will actually
      // be used via them further below, but we need this ColorScheme
      // to provide the properties we are not handling via FCS
      // constructor. An alternative would be to add missing ColorScheme
      // properties to FlexColorScheme as direct override properties.
      // Might do so later.
      ColorScheme(
        brightness: Brightness.light,
        primary: effectiveColors.primary,
        onPrimary: onColors.onPrimary,
        primaryContainer: effectiveColors.primaryContainer,
        onPrimaryContainer: onColors.onPrimaryContainer,
        secondary: effectiveColors.secondary,
        onSecondary: onColors.onSecondary,
        secondaryContainer: effectiveColors.secondaryContainer,
        onSecondaryContainer: onColors.onSecondaryContainer,
        tertiary: effectiveColors.tertiary,
        onTertiary: onColors.onTertiary,
        tertiaryContainer: effectiveColors.tertiaryContainer,
        onTertiaryContainer: onColors.onTertiaryContainer,
        error: useMaterial3ErrorColors && !seed.useKeyColors
            ? FlexColor.material3LightError
            : effectiveColors.error!,
        onError: useMaterial3ErrorColors && !seed.useKeyColors
            ? FlexColor.material3LightOnError
            : onColors.onError,
        errorContainer: useMaterial3ErrorColors && !seed.useKeyColors
            ? FlexColor.material3LightErrorContainer
            : effectiveColors.errorContainer!,
        onErrorContainer: useMaterial3ErrorColors && !seed.useKeyColors
            ? FlexColor.material3LightOnErrorContainer
            : onColors.onErrorContainer,
        background: effectiveBackgroundColor,
        onBackground: onColors.onBackground,
        surface: effectiveSurfaceColor,
        onSurface: onColors.onSurface,
        surfaceVariant: effectiveSurfaceVariantColor,
        onSurfaceVariant: onColors.onSurfaceVariant,
        outline: _outlineColor(Brightness.light, onColors.onBackground, 45),
        outlineVariant:
            _outlineColor(Brightness.light, onColors.onBackground, 75),
        shadow: Colors.black,
        scrim: Colors.black,
        inverseSurface: effectiveInverseSurfaceColor,
        onInverseSurface: onColors.onInverseSurface,
        inversePrimary: _inversePrimary(
            Brightness.light, effectiveColors.primary, effectiveSurfaceColor),
        surfaceTint: surfaceTint ?? effectiveColors.primary,
      );

  // Determine the effective AppBar color:
  // - First priority, passed in color value.
  Color? effectiveAppBarColor = appBarBackground;
  // - Second priority, sub-theme based scheme color.
  effectiveAppBarColor ??=
      useSubThemes && subTheme.appBarBackgroundSchemeColor != null
          ? FlexSubThemes.schemeColor(
              subTheme.appBarBackgroundSchemeColor!, effectiveColorScheme)
          : null;
  // Third priority [appBarStyle] based.
  if (effectiveAppBarColor == null) {
    switch (appBarStyle) {
      case FlexAppBarStyle.primary:
        effectiveAppBarColor =
            effectiveColors.primary.withOpacity(appBarOpacity ?? 1.0);
      case FlexAppBarStyle.material:
        effectiveAppBarColor =
            FlexColor.materialLightSurface.withOpacity(appBarOpacity ?? 1.0);
      case FlexAppBarStyle.surface:
        effectiveAppBarColor =
            effectiveSurfaceColor.withOpacity(appBarOpacity ?? 1.0);
      case FlexAppBarStyle.background:
        effectiveAppBarColor =
            effectiveBackgroundColor.withOpacity(appBarOpacity ?? 1.0);
      case FlexAppBarStyle.scaffoldBackground:
        effectiveAppBarColor =
            effectiveScaffoldColor.withOpacity(appBarOpacity ?? 1.0);
      case FlexAppBarStyle.custom:
        effectiveAppBarColor =
            effectiveColors.appBarColor?.withOpacity(appBarOpacity ?? 1.0) ??
                effectiveColors.primary.withOpacity(appBarOpacity ?? 1.0);
      case null:
        // Style was null, if Opacity used, apply to use M2/M3 mode default.
        if (appBarOpacity != null && appBarOpacity != 1.0) {
          effectiveAppBarColor = useMaterial3
              ? effectiveSurfaceColor.withOpacity(appBarOpacity)
              : effectiveColors.primary.withOpacity(appBarOpacity);
        }
    }
  }
  // The resulting effectiveAppBarColor may remain null if default values
  // are used, this used to avoid creating any AppBar theme in M3 mode if
  // using no sub-theme and only default FCS.light direct AppBar properties.

  return FlexColorScheme(
    colorScheme: effectiveColorScheme,
    // This is the light theme factory so we always set brightness to light.
    brightness: Brightness.light,
    // Primary colors for the application
    primary: effectiveColors.primary,
    primaryContainer: effectiveColors.primaryContainer,
    // The secondary colors for the application.
    secondary: effectiveColors.secondary,
    secondaryContainer: effectiveColors.secondaryContainer,
    // The tertiary colors for the application.
    tertiary: effectiveColors.tertiary,
    tertiaryContainer: effectiveColors.tertiaryContainer,
    // Surface is used e.g. by Card and bottom appbar.
    surface: effectiveSurfaceColor,
    // Background is used e.g. by drawer and bottom nav bar.
    background: effectiveBackgroundColor,
    // Color of the scaffold background.
    scaffoldBackground: effectiveScaffoldColor,
    // Color of dialog background elements, a passed in dialogBackground
    // color will override the factory style, if provided.
    dialogBackground: effectiveDialogBackground,
    // Set app bar background to effective background color.
    appBarBackground: effectiveAppBarColor,
    // Effective error color and null fallback.
    error: useMaterial3ErrorColors && !seed.useKeyColors
        ? FlexColor.material3LightError
        : effectiveColors.error ?? FlexColor.materialLightError,
    onPrimary: onColors.onPrimary,
    onPrimaryContainer: onColors.onPrimaryContainer,
    onSecondary: onColors.onSecondary,
    onSecondaryContainer: onColors.onSecondaryContainer,
    onTertiary: onColors.onTertiary,
    onTertiaryContainer: onColors.onTertiaryContainer,
    onSurface: onColors.onSurface,
    onBackground: onColors.onBackground,
    onError: useMaterial3ErrorColors && !seed.useKeyColors
        ? FlexColor.material3LightOnError
        : onColors.onError,
    surfaceTint: surfaceTint,
    tabBarStyle: tabBarStyle,
    appBarElevation: appBarElevation,
    bottomAppBarElevation: bottomAppBarElevation,
    tooltipsMatchBackground: tooltipsMatchBackground,
    transparentStatusBar: transparentStatusBar,
    visualDensity: visualDensity,
    textTheme: textTheme,
    primaryTextTheme: primaryTextTheme,
    fontFamily: fontFamily,
    fontFamilyFallback: fontFamilyFallback,
    package: package,
    materialTapTargetSize: materialTapTargetSize,
    pageTransitionsTheme: pageTransitionsTheme,
    splashFactory: splashFactory,
    platform: platform,
    typography: typography,
    applyElevationOverlayColor: applyElevationOverlayColor,
    subThemesData: subThemesData,
    useMaterial3: useMaterial3,
    extensions: extensions,
  );
}